Doit déclarer le prototype de fonction en C? [dupliquer]

Il n'est jamais nécessaire de déclarer un prototype pour une fonction en C, ni dans l'ancien C (y compris C89/90) ni dans le nouveau C (C99). Cependant, il existe une différence significative entre C89 / 90 et C99 en ce qui concerne les déclarations de fonction.

Dans C89 / 90, il n'était pas nécessaire de déclarer une fonction du tout. Si la fonction n'est pas déclarée au point de l'appel, le compilateur "devine" (déduit) la déclaration implicitement à partir des types d'arguments passés dans l'appel et suppose que le type de retour est int.

Par exemple

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

En C99 chaque fonction que vous appelez doit être déclaré avant le point de l'appel. Cependant, il n'est pas encore nécessaire de le déclarer avec un prototype spécifiquement. Une déclaration non-prototype fonctionnera également. Cela signifie qu'en C99, la règle" implicit int " ne fonctionne plus (pour les types de retour de fonction inférés, dans ce cas), mais les types de paramètres peuvent toujours être devinés à partir des types d'arguments si la fonction est déclaré sans prototype.

L'exemple précédent ne sera pas compiler en C99, depuis foo n'est pas déclaré au moment de l'appel. Pourtant, vous pouvez ajouter une déclaration non-prototype

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

Et se retrouver avec un code C99 valide.

Néanmoins, c'est toujours une bonne pratique de déclarer un prototype pour la fonction avant de l'appeler.

Une note supplémentaire: j'ai dit plus haut qu'il n'est jamais nécessaire de déclarer un prototype de fonction. En fait, pour certaines fonctions, il est exigence. Afin de bien appeler un variadic fonction en C (printf par exemple), la fonction doit être déclarée , avec un prototype avant le point de l'appel. Sinon, le comportement est indéfini. Ceci s'applique à la fois à C89 / 90 et C99.

Ce n'est pas un must, si la fonction est définie avant son utilisation.

Ce n'est pas nécessaire, mais c'est une mauvaise pratique de ne pas utiliser de prototypes.

Avec les prototypes, le compilateur peut vérifier que vous appelez la fonction correctement (en utilisant le bon nombre et le bon type de paramètres).

Sans prototypes, il est possible d'avoir ceci:

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

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

Et ceci:

// 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);
}

En C, si nous ne déclarons pas un prototype de fonction et utilisons la définition de la fonction, il n'y a pas de problème et le programme compile et génère la sortie si le type de retour de la fonction est "entier". Dans toutes les autres conditions, l'erreur du compilateur apparaît. La raison en est que si nous appelons une fonction et ne déclarons pas de prototype de fonction, le compilateur génère un prototype qui renvoie un entier et recherche la définition de fonction similaire. si le prototype de fonction correspond alors il compile correctement. Si le type de retour n'est pas entier, les prototypes de fonctions ne correspondent pas et génèrent une erreur. Il est donc préférable de déclarer le prototype de fonction dans les fichiers d'en-tête.

C permet d'appeler des fonctions même si elles n'ont pas déjà été déclarées, mais je vous recommande fortement de déclarer un prototype pour toutes les fonctions avant de les utiliser afin que le compilateur puisse vous sauver si vous utilisez les mauvais arguments.

Vous devez placer les déclarations de fonction dans le fichier d'en-tête (X. h) et la définition dans le fichier source (X. c). Puis d'autres fichiers peuvent #include "X.h" et appeler la fonction.

Le prototype de fonction

N'est pas obligatoire selon la norme C99.

Il n'est pas absolument nécessaire de déclarer une fonction pour que le code appelant soit compilé. Il y a des mises en garde cependant. La fonction non déclarée est supposée renvoyer int et le compilateur émettra d'abord des avertissements sur la fonction non déclarée, puis sur les discordances dans les types de type de retour et de paramètre.

Cela dit, il est évident que déclarer correctement les fonctions avec des prototypes est une bien meilleure pratique.

Sélectionnez le menu 'Options', puis sélectionnez ' Compiler / c++ Option’. Dans la boîte de dialogue qui apparaît, sélectionnez "RPC toujours" dans les options’ Utiliser le compilateur C++'. Sélectionnez à nouveau le menu ‘Options’, puis sélectionnez ‘Environnement | Éditeur’. Assurez - vous que l'extension par défaut est ‘C’ plutôt que ‘RPC’.