Muss Funktionsprototyp in C deklariert werden? [duplicate]

Ich bin ziemlich neu in C (ich habe bereits Erfahrung mit Java, C# und etwas C++). Muss in C ein Funktionsprototyp deklariert werden oder kann der Code ohne ihn kompiliert werden? Ist es gute Programmierpraxis, dies zu tun? Oder liegt es einfach am Compiler? (Ich verwende Ubuntu 9.10 und verwende den GNU C Compiler oder gcc unter der Code::Blocks IDE)

Es ist nie erforderlich, a zu deklarieren Prototyp für eine Funktion in C, weder in “altem” C (einschließlich C89/90) noch in neuem C (C99). Es gibt jedoch einen signifikanten Unterschied zwischen C89/90 und C99 in Bezug auf Funktionsdeklarationen.

In C89/90 war es überhaupt nicht notwendig, eine Funktion zu deklarieren. Wenn die Funktion zum Zeitpunkt des Aufrufs nicht deklariert ist, “schätzt” (leitet) der Compiler die Deklaration implizit aus den Typen der beim Aufruf übergebenen Argumente und nimmt an, dass der Rückgabetyp ist int.

Zum Beispiel

int main() {
  int i = foo(5); 
  /* No declaration for `foo`, no prototype for `foo`.
     Will work in C89/90. Assumes `int foo(int)` */

  return 0;
}

int foo(int i) {
  return i;
}

In C99 muss jede Funktion, die Sie aufrufen, sein erklärt vor dem Anrufpunkt. Es ist jedoch immer noch nicht erforderlich, es mit a zu deklarieren Prototyp speziell. Eine Nicht-Prototyp-Deklaration funktioniert ebenfalls. Das bedeutet, dass in C99 die “implizit int” Die Regel funktioniert nicht mehr (in diesem Fall für abgeleitete Funktionsrückgabetypen), aber Parametertypen können immer noch aus den Argumenttypen erraten werden, wenn die Funktion ohne Prototyp deklariert wird.

Das vorherige Beispiel wird nicht in C99 kompiliert, da foo wird zum Zeitpunkt des Aufrufs nicht deklariert. Sie können jedoch eine Nicht-Prototyp-Deklaration hinzufügen

int foo(); /* Declares `foo`, but still no prototype */

int main() {
  int i = foo(5); 
  /* No prototype for `foo`, although return type is known. 
     Will work in C99. Assumes `int foo(int)` */

  return 0;
}
...

und am Ende mit gültigem C99-Code.

Trotzdem empfiehlt es sich immer, einen Prototyp für die Funktion zu deklarieren, bevor Sie sie aufrufen.

Ein zusätzlicher Hinweis: Ich habe oben gesagt, dass es nie erforderlich ist, einen Funktionsprototypen zu deklarieren. Für einige Funktionen ist es sogar eine Voraussetzung. Um a variadisch Funktion in C (printf zum Beispiel) muss die Funktion deklariert werden mit einem Prototyp vor dem Anrufpunkt. Andernfalls ist das Verhalten undefiniert. Dies gilt sowohl für C89/90 als auch für C99.

In ANSI C (d. h. C89 oder C90) müssen Sie keinen Funktionsprototypen deklarieren; Es ist jedoch eine bewährte Methode, sie zu verwenden. Der einzige Grund, warum der Standard Ihnen erlaubt, sie nicht zu verwenden, ist die Abwärtskompatibilität mit sehr altem Code.

Wenn Sie keinen Prototyp haben und eine Funktion aufrufen, leitet der Compiler einen Prototyp aus den Parametern ab, die Sie an die Funktion übergeben. Wenn Sie die Funktion später in derselben Kompilierungseinheit deklarieren, erhalten Sie einen Kompilierungsfehler, wenn sich die Signatur der Funktion von der unterscheidet, die der Compiler erraten hat.

Schlimmer noch, wenn sich die Funktion in einer anderen Kompilierungseinheit befindet, gibt es keine Möglichkeit, einen Kompilierungsfehler zu erhalten, da es ohne einen Prototyp keine Möglichkeit gibt, dies zu überprüfen. Wenn der Compiler in diesem Fall einen Fehler macht, könnten Sie ein undefiniertes Verhalten erhalten, wenn der Funktionsaufruf andere Typen auf den Stapel drückt, als die Funktion erwartet.

Die Konvention besteht darin, einen Prototyp immer in einer Header-Datei zu deklarieren, die den gleichen Namen hat wie die Quelldatei, die die Funktion enthält.

In C99 oder C11 erfordert Standard-C eine Funktionsdeklaration im Gültigkeitsbereich, bevor Sie eine Funktion aufrufen. Viele Compiler erzwingen diese Einschränkung in der Praxis nicht, es sei denn, Sie zwingen sie dazu.

es ist kein Muss, wenn die Funktion vor ihrer Verwendung definiert wird.

Es ist nicht erforderlich, aber es ist schlechte Praxis, keine Prototypen zu verwenden.

Mit Prototypen kann der Compiler überprüfen, ob Sie die Funktion korrekt aufrufen (mit der richtigen Anzahl und Art von Parametern).

Ohne Prototypen ist Folgendes möglich:

// file1.c
void doit(double d)
{
    ....
}

int sum(int a, int b, int c)
{
    return a + b + c;
}

und das:

// file2.c

// In C, this is just a declaration and not a prototype
void doit();
int sum();

int main(int argc, char *argv[])
{
    char idea[] = "use prototypes!";

    // without the prototype, the compiler will pass a char *
    // to a function that expects a double
    doit(idea);

    // and here without a prototype the compiler allows you to
    // call a function that is expecting three argument with just
    // one argument (in the calling function, args b and c will be
    // random junk)
    return sum(argc);
}

Wenn wir in C keinen Funktionsprototyp deklarieren und die Funktionsdefinition verwenden, gibt es kein Problem, und das Programm kompiliert und generiert die Ausgabe, wenn der Rückgabetyp der Funktion “Integer” ist. Unter allen anderen Bedingungen erscheint der Compiler-Fehler. Der Grund dafür ist, wenn wir eine Funktion aufrufen und keinen Funktionsprototyp deklarieren, generiert der Compiler einen Prototyp, der eine ganze Zahl zurückgibt, und sucht nach einer ähnlichen Funktionsdefinition. Wenn der Funktionsprototyp übereinstimmt, wird er erfolgreich kompiliert. Wenn der Rückgabetyp keine Ganzzahl ist, stimmen die Funktionsprototypen nicht überein und es wird ein Fehler generiert. Daher ist es besser, Funktionsprototypen in den Header-Dateien zu deklarieren.

C erlaubt den Aufruf von Funktionen, auch wenn sie vorher nicht deklariert wurden, aber ich empfehle Ihnen dringend, für alle Funktionen einen Prototyp zu deklarieren, bevor Sie sie verwenden, damit der Compiler Sie retten kann, wenn Sie die falschen Argumente verwenden.

Sie sollten Funktionsdeklarationen in der Header-Datei (Xh) und die Definition in der Quelldatei (Xc) ablegen. Dann können andere Dateien #include "X.h" und rufe die Funktion auf.