Déclarer une fonction vide en C?

J’apprends le C et j’étudie les fonctions. Donc, j’ai lu que lorsque j’implémente ma propre fonction, je dois la déclarer avant le main () Si je manque la déclaration, le compilateur recevra un message d’erreur.
Pendant que j’étudiais cet exemple (trouve si le nombre est un nombre premier)

#include  void prime(); //function prototype(declaration) int main() { int num,i,flag; num = input(); // No argument is passed to input() for(i=2,flag=i; i<=num/2; ++i,flag=i) { flag = i; if(num%i==0) { printf("%d is not prime\n",num); ++flag; break; } } if(flag==i) printf("%d is prime\n",num); return 0; } int input() /* Integer value is returned from input() to calling function */ { int n; printf("\nEnter positive enter to check: "); scanf("%d",&n); return n; } 

J’ai remarqué qu’une fonction prime () est déclarée, mais dans l’ensemble une fonction input () est appelée et la fonction input () est également implémentée en bas. Ok, je pensais que c’était une erreur et je change le nom de prime à input.
Cependant, si je supprime la déclaration et que je n’en mets pas, le programme est compilé sans erreurs et il fonctionne correctement. (Je comstack et l’exécute sous Ubuntu)

Ma question est donc la suivante: est-il nécessaire de déclarer une fonction vide sans arguments?

Si vous n’avez pas de déclaration forward de votre fonction avant le lieu d’utilisation, le compilateur créera pour vous une déclaration implicite – avec la signature int input() – il prendra le nom de la fonction que vous avez appelée, il supposera que la fonction est de retour int et il peut accepter n’importe quel argument (comme Bartek l’a noté dans le commentaire).

Pour cette fonction, la déclaration implicite correspond à la déclaration réelle, de sorte que vous n’avez pas de problèmes. Cependant, vous devez toujours être prudent à ce sujet et préférer toujours les déclarations en aval aux déclarations implicites (qu’elles soient identiques ou non). Ainsi, au lieu de simplement avoir une déclaration en aval de la fonction void prime() (en supposant que vous l’utiliserez quelque part), vous devriez également avoir une déclaration en int input() de int input() .

Pour voir comment vous pouvez passer n’importe quel nombre d’arguments, considérons ceci:

 #include  // takes any number of the arguments int foo(); // takes no arguments int bar(void) { printf("Hello from bar()!\n"); return 0; } int main() { // both works // However, this will print junk as you're not pushing // any arguments on the stack - but the comstackr will assume you are foo(); // this will print 1, 2, 3 foo(1, 2, 3); // works bar(); // doesn't work // bar(1, 2, 3); return 0; } // definition int foo(int i, int j, int k) { printf("%d %d %d\n", i, j, k); return 0; } 

Donc, dans la définition de la fonction, vous décrivez les arguments de la fonction. Cependant, la déclaration de la fonction indique au compilateur de ne pas vérifier les parameters.

Ne pas déclarer un prototype et s’appuyer sur une promotion par type d’argument / retour par défaut est dangereux et faisait partie de l’ancien C. À partir de C99, il est illégal d’appeler une fonction sans fournir au préalable une déclaration ou une définition de celle-ci .

Ma question est la suivante: est-il nécessaire de déclarer une fonction vide sans arguments?

Oui. Pour cela, vous devez mettre void dans la fonction parenthèse.

 void foo(void); 

Déclarer une fonction comme

 void foo(); 

signifie qu’il peut prendre n’importe quel nombre d’arguments.

Si prime n’est pas utilisé, omettez la déclaration.

Le code ne sera pas compilé en tant que C ++ car le compilateur se plaindrait que l’ input fonction est utilisée mais non déclarée. Le compilateur AC peut émettre un avertissement, mais C est plus souple et fait une déclaration implicite d’entrée en tant que int input() ce qui signifie que vous pouvez passer n’importe quelle valeur à l’entrée et que l’entrée renvoie un int.

C’est un bon style de toujours fournir une déclaration de fonction avant d’utiliser la fonction. Ce n’est que si vous faites cela que le compilateur peut voir si vous passez à peu d’arguments, à plusieurs arguments mal typés et comment gérer correctement la valeur de retour (qui peut être short ou char au lieu d’int).