错误：与gcc的“六个”类型冲突

Question

Receiving error: conflicting types for 'six' when attempting to compile.

void main(){
    const int k = 4;
    six(&k);
}

float * six(const int *x)
{
    float *p =  malloc(sizeof(float));
    *p = (float)*x;
    return p;
}

Answer 1

Here is what is going on.

When the compiler does not encounter a prototype for a function before a call to it, it deduces the prototype from the call itself, and assumes the return type to be int. This is what it does in your example.

Later it finds the definition of the function, and it finds that the return type is actually float, which does not match with the prototype it has deduced earlier. Hence the error of conflicting types (instead of, say, missing prototype).

The solution is to, of course, provide a prototype for the function before a call to it is made.

Answer 2

You didn't declare six to the compiler before you called it, so the compiler was forced to guess what the signature of six is (typically, this is something like int func() ). When it saw the actual declaration, it threw an error because the actual function declaration didn't match its implicit declaration.

You need to declare functions before they are used; place a declaration like

float *six(const int *x);

before main .

Answer 3

Solution to your problem

Just add the following declaration before main() :

float *six(const int *x);

Or put your float *six(const int *x) definition before the main() function.

Why the compiler complain conflicting types

Since there is no declaration of your six() function before the compiler compile the main function, it will deduce the prototype from the function callsite, and will assume the return type to be int . And when it compiles your six() function, the compiler will find two function with the same name but different return type, so it complain the conflicting types error.

Thanks to Ziffusion's comment.

why to adjust your code in the above way

You should declare/define each of your element before use in C.

For your currently code, you need to declare your function type before the main function, so that the compiler knows what six() is when compile the main function.

Why there should be a declaration before use in C

For variables and other data types, since C is strong typed. When the variable is used, it need to be declared first, so that the compiler knows what type the variable is, and could do data type check.

For functions, since the C compiler compiles the code function by function, and will generate a function call statement in the assembly, so the compiler need to know the function parameter and return value data type, so that it could generated correct instructions to do parameter passing, and return value restoring. Normally, the compiler will compile the function in a source code file one by one from the start of the file to the end of the file, so you need to declare the function type before use it.