What does error conflicting types for '' mean?

Question

i got an error that said \"error: conflicting types for \'____\'. What does that mean?

Answer 1

Quickfix:

Make sure that your functions are declared once and only once before they are called. For example, change:

main(){ myfun(3.4); }
double myfun(double x){ return x; }

To:

double myfun(double x){ return x; }
main(){ myfun(3.4); }

Or add a separate function declaration:

double myfun(double x);
main(){ myfun(3.4); }
double myfun(double x){ return x; }

Possible causes for the error

1. Function was called before being declared
2. Function defined overrides a function declared in an included header.
3. Function was defined twice in the same file
4. Declaration and definition don't match
5. Declaration conflict in the included headers

What's really going on

error: conflicting types for ‘foo’ means that a function was defined more than once with different type signatures.

A file that includes two functions with the same name but different return types would throw this error, for example:

int foo(){return 1;}
double foo(){return 1.0;}

Indeed, when compiled with GCC we get the following errors:

foo.c:5:8: error: conflicting types for ‘foo’
 double foo(){return 1.0;}
        ^
foo.c:4:5: note: previous definition of ‘foo’ was here
 int foo(){return 1;}
     ^

Now, if instead we had a file with two function definitions with the same name

double foo(){return 1;}
double foo(){return 1.0;}

We would get a 'redefinition' error instead:

foo.c:5:8: error: redefinition of ‘foo’
 double foo(){return 1.0;}
        ^
foo.c:4:8: note: previous definition of ‘foo’ was here
 double foo(){return 1;}
        ^

Implicit function declaration

So why does the following code throw error: conflicting types for ‘foo’?

 main(){ foo(); }
 double foo(){ return 1.0; }

The reason is implicit function declaration.

When the compiler first encounters foo() in the main function, it will assume a type signature for the function foo of int foo(). By default, implicit functions are assumed to return integers, and the input argument types are derived from what you're passing into the function (in this case, nothing).

Obviously, the compiler is wrong to make this assumption, but the specs for the C (and thus Objective-C) language are old, cranky, and not very clever. Maybe implicitly declaring functions saved some development time by reducing compiler complexity back in the day, but now we're stuck with a terrible feature that should have never made it into the language. In fact, implicit declarations were made illegal in C99.

That said, once you know what's going on, it should be easy to dig out the root cause of your problem.