5

With the following code:

int main(){ printf("%f\n",multiply(2)); return 0; } float multiply(float n){ return n * 2; }

When I try to compile, I get one warning: "'%f' expects 'double', but the argument has type 'int'" and two errors: "conflicting types for 'multiply'", "previous implicit declaration of 'multiply' was here."

Question 1: I am guessing that it's because, given the compiler has no knowledge of function 'multiply' when he comes across it the first time, he will invent a prototype, and invented prototypes always assume 'int' is both returned and taken as parameter. So the invented prototype would be "int multiply(int)", and hence the errors. Is this correct?

Now, the previous code won't even compile. However, if I break the code into two files like this:

#file1.c int main(){ printf("%f\n",multiply(2)); return 0; } #file2.c float multiply(float n){ return n * 2; }

and execute "gcc file1.c file2.c -o file" it will still give one warning (that printf is expecting double but is getting int), but the errors won't show up anymore and it will compile.

Question 2: How come when I break the code into 2 files, it compiles?

Question 3: Once I run the program above (the version split into 2 files), the result is that 0.0000 is printed on the screen. How come? I am guessing the compiler again invented a prototype that doesn't match the function, but why is 0 printed? And if I change the printf("%f") to printf("%d"), it prints a 1. Again, any explanation of what's going on behind the scenes?

Improve this question
1
  • Compile C code with GCC using the options -Wall -Wextra -Werror -std=c18 (you can use other versions of the standard if need be, but not -ansi or -std=c90), This will avoid a lot of problems. If you have two source files and one contains a function that the other calls, you need a header file that both source files include which contains a declaration for the function(s) that both use. Commented Jun 5, 2024 at 13:59

4 Answers 4

Reset to default
5

So the invented prototype would be "int multiply(int)", and hence the errors. Is this correct?

Absolutely. This is done for backward compatibility with pre-ANSI C that lacked function prototypes, and everything declared without a type was implicitly int. The compiler compiles your main, creates an implicit definition of int multiply(int), but when it finds the real definition, it discovers the lie, and tells you about it.

How come when I break the code into 2 files it compiles?

The compiler never discovers the lie about the prototype, because it compiles one file at a time: it assumes that multiply takes an int, and returns an int in your main, and does not find any contradictions in multiply.c. Running this program produces undefined behavior, though.

Once I run the program above (the version split into 2 files) the result is that 0.0000 is printed on the screen.

That's the result of undefined behavior described above. The program will compile and link, but because the compiler thinks that multiply takes an int, it would never convert 2 to 2.0F, and multiply will never find out. Similarly, the incorrect value computed by doubling an int reinterpreted as a float inside your multiply function will be treated as an int again.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

Makes sense. The only point still not clear is why the compiler won't find the lie/contradiction with 2 files. After all it will still create the "int multiply(int)" prototype while running through main.c, and once it gets to the second file it will come across the "float multiply(float)" function declaration, which clearly contradicts the previous prototype.
@DanielS Good point! I edited the answer to mention why: essentially, the compiler compiles each file in isolation, one source at a time. This is different from, say, Java, which considers all files at once. With C and C++, each translation unit (that's a fancy name for a .c file) is compiled separately, and then the linker assembles the results together. By the time the linker gets into the game, however, all type information is gone: linkers work on much lower level of bytes, offsets, and addresses, so they cannot detect a discrepancy either.
@DanielS: The compiler works with one file at a time; while working on file1.c, it knows nothing about the contents of file2.c and vice-versa. When building file1.c, it only knows that multiply has not been declared before use. When building file2.c, it doesn't know that multiply is being used in another translation unit without a proper declaration in scope.
dasblinkenlight and John Bode, that explains it. Thanks a lot for the help.
Strictly, the "invented prototype" would not be a prototype but a simple declaration extern int multiply() — a function that returns an int but with an unspecified argument list (except it is not a variadic function — the prototype would not end , ...) — all variadic functions must always be declared before use). That means you could call multiply(3.4) and multiply(1), and multiply() and the compiler is not obliged to complain; all those calls are compatible with the declaration. C23 tightens the rules — a declaration int multiply() now means the same as int multiply(void).
|
1

An unspecified function has a return type of int (that's why you get the warning, the compiler thinks it returns an integer) and an unknown number of unspecified arguments.

If you break up your project in multiple files, just declare a function prototype before you call the functions from the other files, and all will work fine.

Improve this answer

Comments

1

Question1:

So the invented prototype would be "int multiply(int)", and hence the errors. Is this correct?

Not exactelly yes because it it depends of your Cx (C89, C90, C99,...)

for function return values, prior to C99 it was explicitly specified that if no function declaration was visible the translator provided one. These implicit declarations defaulted to a return type of int

Justification from C Standard (6.2.5 page 506)

Prior to C90 there were no function prototypes. Developers expected to be able to interchange argu-ments that had signed and unsigned versions of the same integer type. Having to cast an argument, if the parameter type in the function definition had a different signedness, was seen as counter to C’s easy-going type-checking system and a little intrusive. The introduction of prototypes did not completely do away with the issue of interchangeability of arguments. The ellipsis notation specifies that nothing is known about the 1590 ellipsis supplies no information expected type of arguments. Similarly, for function return values, prior to C99 it was explicitly specified that if no function declaration was visible the translator provided one. These implicit declarations defaulted to a return type of int . If the actual function happened to return the type unsigned int , such a default declaration might have returned an unexpected result. A lot of developers had a casual attitude toward function declarations. The rest of us have to live with the consequences of the Committee not wanting to break all the source code they wrote. The interchangeability of function return values is now a moot point, because C99 requires that a function declaration be visible at the point of call (a default declaration is no longer provided)

Question 2:

How come when I break the code into 2 files it compiles?

it will compile and it will be treated like indicated in the first question exactelly the same

Improve this answer

Comments

1

Question 1: Yes you are correct. If there is no function prototype, the default type is int

Question 2: When you are compiling this code as one file, the compiler see that there is already function named multiply and it has a different type than supposed (double instead of int). Thus compilation doesn't work.

When you separate this in two files, the compiler makes two .o files. In the first one it suppose that the multiply() function will be in other file. Then linker links both files into a binary and according to the name multiply inserts call of float multiply() on the place of int multiply() supposed by the compiler in the first .o file.

Question 3: If you read int 2 as a float, you will get a very small number (~1/2^25), so after that you multiply it by 2 and it still remains too small for format %f. That's why you see 0.00000.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.