Error conflicting types for си

A C Function-Declaration Backgrounder

In C, function declarations don’t work like they do in other languages: The C compiler itself doesn’t search backward and forward in the file to find the function’s declaration from the place you call it, and it doesn’t scan the file multiple times to figure out the relationships either: The compiler only scans forward in the file exactly once, from top to bottom. Connecting function calls to function declarations is part of the linker’s job, and is only done after the file is compiled down to raw assembly instructions.

This means that as the compiler scans forward through the file, the very first time the compiler encounters the name of a function, one of two things have to be the case: It either is seeing the function declaration itself, in which case the compiler knows exactly what the function is and what types it takes as arguments and what types it returns — or it’s a call to the function, and the compiler has to guess how the function will eventually be declared.

(There’s a third option, where the name is used in a function prototype, but we’ll ignore that for now, since if you’re seeing this problem in the first place, you’re probably not using prototypes.)

History Lesson

In the earliest days of C, the fact that the compiler had to guess types wasn’t really an issue: All of the types were more-or-less the same — pretty much everything was either an int or a pointer, and they were the same size. (In fact, in B, the language that preceded C, there were no types at all; everything was just an int or pointer and its type was determined solely by how you used it!) So the compiler could safely guess the behavior of any function just based on the number of parameters that were passed: If you passed two parameters, the compiler would push two things onto the call stack, and presumably the callee would have two arguments declared, and that would all line up. If you passed only one parameter but the function expected two, it would still sort-of work, and the second argument would just be ignored/garbage. If you passed three parameters and the function expected two, it would also still sort-of work, and the third parameter would be ignored and stomped on by the function’s local variables. (Some old C code still expects these mismatched-argument rules will work, too.)

But having the compiler let you pass anything to anything isn’t really a good way to design a programming language. It worked well in the early days because the early C programmers were mostly wizards, and they knew not to pass the wrong type to functions, and even if they did get the types wrong, there were always tools like lint that could do deeper double-checking of your C code and warn you about such things.

Fast-forward to today, and we’re not quite in the same boat. C has grown up, and a lot of people are programming in it who aren’t wizards, and to accommodate them (and to accommodate everyone else who regularly used lint anyway), the compilers have taken on many of the abilities that were previously part of lint — especially the part where they check your code to ensure it’s type-safe. Early C compilers would let you write int foo = "hello"; and it would just blithely assign the pointer to the integer, and it was up to you to make sure you weren’t doing anything stupid. Modern C compilers complain loudly when you get your types wrong, and that’s a good thing.

Type Conflicts

So what’s all this got to do with the mysterious conflicting-type error on the line of the function declaration? As I said above, C compilers still have to either know or guess what a name means the first time they see that name as they scan forward through the file: They can know what it means it if it’s an actual function declaration itself (or a function «prototype,» more on that shortly), but if it’s just a call to the function, they have to guess. And, sadly, the guess is often wrong.

When the compiler saw your call to do_something(), it looked at how it was invoked, and it concluded that do_something() would eventually be declared like this:

int do_something(char arg1[], char arg2[])
{
    ...
}

Why did it conclude that? Because that’s how you called it! (Some C compilers may conclude that it was int do_something(int arg1, int arg2), or simply int do_something(...), both of which are even farther from what you want, but the important point is that regardless of how the compiler guesses the types, it guesses them differently from what your actual function uses.)

Later on, as the compiler scans forward in the file, it sees your actual declaration of char *do_something(char *, char *). That function declaration isn’t even close to the declaration that the compiler guessed, which means that the line where the compiler compiled the call was compiled wrong, and the program is just not going to work. So it rightly prints an error telling you that your code isn’t going to work as written.

You might be wondering, «Why does it assume I’m returning an int?» Well, it assumes that type because there’s no information to the contrary: printf() can take in any type in its variable arguments, so without a better answer, int is as good a guess as any. (Many early C compilers always assumed int for every unspecified type, and assumed you meant ... for the arguments for every function declared f() — not void — which is why many modern code standards recommend always putting void in for the arguments if there really aren’t supposed to be any.)

The Fix

There are two common fixes for the function-declaration error.

The first solution, which is recommended by many other answers here, is to put a prototype in the source code above the place where the function is first called. A prototype looks just like the function’s declaration, but it has a semicolon where the body should be:

char *do_something(char *dest, const char *src);

By putting the prototype first, the compiler then knows what the function will eventually look like, so it doesn’t have to guess. By convention, programmers often put prototypes at the top of the file, just under the #include statements, to ensure that they’ll always be defined before any potential usages of them.

The other solution, which also shows up in some real-world code, is to simply reorder your functions so that the function declarations are always before anything that calls them! You could move the entire char *do_something(char *dest, const char *src) { ... } function above the first call to it, and the compiler then would know exactly what the function looks like and wouldn’t have to guess.

In practice, most people use function prototypes, because you can also take function prototypes and move them into header (.h) files so that code in other .c files can call those functions. But either solution works, and many codebases use both.

C99 and C11

It is useful to note that the rules are slightly different in the newer versions of the C standard. In the earlier versions (C89 and K&R), the compiler really would guess the types at function-call time (and K&R-era compilers often wouldn’t even warn you if they were wrong). C99 and C11 both require that the function declaration/prototype must precede the first call, and it’s an error if it doesn’t. But many modern C compilers — mainly for backward compatibility with earlier code — will only warn about a missing prototype and not consider it an error.

07-25-2011

#1

Быстрая починка:

Убедитесь, что ваши функции объявлены один раз и только один раз перед их вызовом. Например, изменить:

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

В:

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

Или добавьте отдельное объявление функции:

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

Возможные причины ошибки

1. Функция была вызвана до объявления
2. Определенная функция переопределяет функцию, объявленную во включенном заголовке.
3. Функция была определена дважды в одном и том же файле
4. Декларация и определение не совпадают
5. Конфликт объявлений во включенных заголовках

Что на самом деле происходит

error: conflicting types for ‘foo’ означает, что функция была определена более одного раза с разными сигнатурами типов.

Файл, содержащий две функции с одинаковыми именами, но разными типами возвращаемых данных, вызовет эту ошибку, например:

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

Действительно, при компиляции с помощью GCC мы получаем следующие ошибки:

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;}
     ^

Теперь, если бы вместо этого у нас был файл с двумя определениями функций с одинаковым именем

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

Вместо этого мы получили бы ошибку «переопределения»:

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;}
        ^

Неявное объявление функции

Итак, почему следующий код выдает error: conflicting types for ‘foo’?

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

Причина в неявное объявление функции.

Когда компилятор впервые встречает foo() в main функция, она примет сигнатуру типа для функции foo of int foo(). По умолчанию предполагается, что неявные функции возвращают целые числа, а типы входных аргументов являются производными от того, что вы передаете в функцию (в данном случае ничего).

Очевидно, что компилятор ошибается, делая такое предположение, но спецификации для языка C (и, следовательно, Objective-C) старые, капризные и не очень умные. Возможно, когда-то неявное объявление функций сэкономило время разработки, уменьшив сложность компилятора, но теперь мы застряли с ужасной функцией, которая никогда не должна была быть реализована в языке. Фактически неявные объявления были объявлены незаконными в C99.

Тем не менее, как только вы узнаете, что происходит, вам будет легко найти основную причину вашей проблемы.

#include <stdbool.h>
#include <stdio.h>
#include "bst.h"
 
void PKL(BstNode **node, const int level);

int main(void)
{
    int i, maxBFS;
    char cmd[255], arg;
    BstNode *root = NULL;
 
    do
    {
        printf("Введите команду (h - справка):n");
        scanf("%s", cmd);
 
        if (cmd[0] == '+')
        {
            scanf(" %c", &arg);
 
            if (arg >= 'A' && arg <= 'Z')
            {
                bstInsert(&root, arg);
 
                printf("Узел %c вставленn", arg);
            }
            else
                printf("Ошибка. Введена недопустимая букваn");
        }
        else if (cmd[0] == '-')
        {
            scanf(" %c", &arg);
 
            if (arg >= 'A' && arg <= 'Z')
            {
                if (bstRemove(&root, arg))
                    printf("Узел %c удаленn", arg);
                else
                    printf("Узел %c не найденn", arg);
            }
            else
                printf("Ошибка. Введена недопустимая букваn");
        }
        else if (cmd[0] == 'p')
        {
            PKL(&root, 0);
        }
        
        else if (cmd[0] == 't')
        {
         if (is_symmetric(&root))
         {
            printf("YES");
         }
            else
            {
            printf("NO");   
            }   
            }   
        else if (cmd[0] == 'h')
        {
            printf("================================n");
            printf("Список команд:n");
            printf("+ CHAR - вставить узел CHAR (A, B, ..., Z) в двоичное деревоn");
            printf("- CHAR - удалить узел CHAR из двоичного дереваn");
            printf("p - распечатать двоичное деревоn");
            printf("t - выполнить задание над двоичным деревомn");
            printf("q - завершить программуn");
            printf("================================n");
        }
        else if (cmd[0] != 'q')
        {
            printf("Неизвестная командаn");
        }
    }
    while (cmd[0] != 'q');
 
    bstDestroy(&root);
 
    return 0;
}
void PKL(BstNode **node, const int level)
{
    if (*node == NULL)
    {
        printf("Дерево пустоn");
 
        return;
    }
 
    if ((*node)->_right != NULL)
        PKL(&(*node)->_right, level + 1);
 
    printf("%*s%cn", level * 2, "", (*node)->_key);
 
    if ((*node)->_left != NULL)
        PKL(&(*node)->_left, level + 1);
}

_Bool mirror_equals(BstNode *_left, BstNode *_right)
{
    if( _left == NULL || _right == NULL )
        {return _left == NULL && _right == NULL;
    return (_left->_key == _right->_key &&
        mirror_equals(_left->_left, _right->_right) &&
        mirror_equals(_left->_right, _right->_left) );}
}
_Bool is_symmetric(BstNode *node)
{
    if( node == NULL|| mirror_equals(node->_left, node->_right))
        {return true;}
    else {return false;}
}

3.c:111:7: error: conflicting types for ‘is_symmetric’
 _Bool is_symmetric(BstNode *node)
       ^
3.c:53:8: note: previous implicit declaration of ‘is_symmetric’ was here
    if (is_symmetric(&root))
        ^