How am I incorrectly using the round() function in C?

Question

I\'m getting unexpected results from the round() and roundf() functions in the math.h library. Here is the sample code:

#         


        

Answer 1

This obviously doesn't help but the code looks and runs as expected for me. Everything seems fine.

Answer 2

litb was on the right track. -std=c99 didn't work but adding #define _ISOC99_SOURCE worked. So the code looks like:

#define _ISOC99_SOURCE
#include <stdio.h>
#include <math.h>

int main(void)
{
...

Answer 3

One more "works on my machine" on Ubuntu with gcc version 4.3.2.

$ ./a.out
1.000000
1.000000

I do get a couple of warnings when I compile, though.

$ gcc -lm round.c
round.c: In function ‘main’:
round.c:11: warning: incompatible implicit declaration of built-in function ‘roundf’
round.c:12: warning: incompatible implicit declaration of built-in function ‘round’

Answer 4

When I compile and run this exact code (under gcc on cygwin) I get:

$ ./a.exe
1.000000
1.000000

How new is your compiler? A compiler bug is all I can think of, as gcc -Wall gives no warnings either.

To add some further information this forum thread seems to show changing compiler to a newer version fixes it. If this doesn't work for you you'll need to give more details of compiler and OS, but given this seems to work for other people on three different platforms looks like your compiler is at fault.

Answer 5

You can fail if you compile the code without telling gcc to compile with C99 mode (-std=c99) and tell it not to know about "special builtin" functions (using -fno-builtin). Then it assumes that your round/roundf function is defined as

int round();
int roundf();

Because in pre-C99 times there were no such functions yet, so it does not have a declaration and implicitly declares them then. And this will obviously fail, because the call-side treats the return value as an int, while the callee side (in the definition of those functions in the linked library) returns a float. I get these results for example:

[js@HOST2 cpp]$ ./a.out
1065353216.000000
-1048576.000000
[js@HOST2 cpp]$

Not that you think now that you could cast the return value to a float and be OK. Well, it's worse. The return value is not even guaranteed to have anything to do with the float returned. The call-side reads from a place that it knows where integers are returned. But your compiler may return floats in another place (say, in a floating pointer register) from the callee side. The above could actually have done anything, including aborting the program because it behaves in an undefined manner.

So, what can you do to make it work? Pass the compiler the std=c99 flag or use other ways to round (floor is one of them) which do not require those functions

gcc -std=c99 test.c -lm

See the manpage of man 3 round. However, if you have a very old GCC - i'm not sure whether it supports enough of C99 to have that switch. Look into the feature test macros described in the manpage of round then.

Answer 6

To add to the chorus of approvals, this works fine for me (OS X Leopard using gcc).

Out of curiosity, do you need to use the -lm flag? I didn't the first time, and I did the second time, and there was no difference, but that's because libm.dylib and libc.dylib are symbolic links to the same library on OS X. Perhaps your libm is broken or something? Do you need to link to libm or not? I would think that the math.h functions would be part of libc...?

EDIT:

Before you do any of that, try using this instead:

float f = 0;
double d = 0;

I don't think that should change anything, but if it does, I win.