You don't have a prototype for int round_near(float b), so you're relying on implicit declarations.

Try adding this to your code.

int round_near (float b); // Prototype

int main(void) // Nitpick: main returns an int!

Using implicit declarations for round_near(b), b is being promoted to a double. But the definition assumes it's a float, which has a different binary layout, so you get crazy random results.

You should make sure your code compiles without any warnings to avoid this sort of stuff. The only reason implicit declaration is in the language is for backwards compatibility, but every compiler for the last decade or two warns you that it's bad on compile.

When I tried to compile this under gcc I got the following error:

/tmp/x1.c:23: error: conflicting types for ‘round_near’
/tmp/x1.c:23: note: an argument type that has a default promotion can’t match an empty parameter name list declaration
/tmp/x1.c:16: error: previous implicit declaration of ‘round_near’ was here

The funny results you're getting is because your compiler didn't know the definition of round_near at the time it was first encountered and assumed it was int round_near(). So this resulted in undefined behavior.

If you either move round_near above main or put in a declaration above main you should get the expected results.

@QuestionC well answered OP's immediate problem: implied function signature of int round_near(...) is incompatible with int round_near(float b) and call of round_near(b) which passes b as a double.

Simple solution: prototype the function.

Some issues about the round_near()

1. Casting to int severely narrows the legitimate range. Better to use long long.

2. General incorrect functionality with negative numbers. @Eugene Sh. Code should test for sign.

Below is a solution that takes advantage of the range of long long as it is usually greater than the continuous range of integers a float can represent exactly. Alternatively OP can replace my_roundf() with round_near() and use this code for testing. round_near() fails about 40% of the time.

#include <limits.h>
#include <stdio.h>

float my_roundf(float x) {
  // Large `float`s typically have no fractional portion to round
  if (x > LLONG_MAX / 2) return x;
  if (x < LLONG_MIN / 2) return x;
  return x > 0 ? (long long) (x + 0.5f) : (long long) (x - 0.5f);
}

float rand_float(void) {
  union {
    unsigned char uc[sizeof(float)];
    float f;
  } u;
  do {
    unsigned i;
    for (i = 0; i < sizeof(float); i++) {
      u.uc[i] = rand();
    }
  } while (u.f != u.f);  // re-do if NaN encountered
  return u.f;
}

void my_roundf_test(void) {
  unsigned n = 100000;
  while (n-- > 0) {
    float x = rand_float();
    float ymath = roundf(x);
    // float ymy = round_near(x);
    float ymy = my_roundf(x);
    // Exact half-way cases may fail
    if (ymath != ymy) {
      printf("x:% .9e math:% .9e my:% .9e\n", x, ymath, ymy);
    }
  }
}

Note: There are exact half-way cases per various floating point rounding modes, negative zero, etc. to consider for a complete answer. But leave that for another day.