La fonction main()

Bon suite à quelques remarques sur mes tutoriels, j'ai décidé d'ouvrir ce thread afin qu'on puisse discuter un peu de la fonction main et du coup des fonctions en C en général.

On est bien d'accord que le prototype de main() est :

Code:

---

1 2 3

> int main(void) > ou : > int main(int argc, char * argv[])

---

Mais comme dans un programme on a rarement besoin d'appeler cette fonction nous-mêmes, il n'est pas nécessaire de la déclarer. Si on devait la déclarer, on écrirait ceci :

Code:

---

1 2 3

> int main(void); > ou : > int main(int argc, char * argv[]);

---

Selon la forme utilisée.

Si main() n'est pas appelée dans le programme, on peut se contenter de la définir tout simplement. En particulier, pour la première forme, on peut donc écrire ceci :

Code:

---

1 2 3 4

int main(void) { return 0; }

---

Qui est strictement équivalent (en C90) à :

Code:

---

1 2 3 4

int main() { return 0; }

---

Cette forme est toujours acceptée en C99, et même les exemples de n1256 utilisent cette forme.

Corrigez moi si j'ai tort (point de vue norme uniquement, pas de "je préfère ceci" s'il vous plaît. Moi je préfère l'autre ! Merci).

J'avais utilisé dans le temps une autre définition de main qui était

Code:

---

1 2	int main(int argc, char * argv[], char *envp[])

---

dans lequel envp[] pointait sur les variables d'environnement.

Cette forme de déclaration est complètement obsolète ou bien elle peut encore être utilisée ?

Si nous faisons abstraction du cas de main, pour une fonction, les déclarations

int foo(void) { ...; }
int foo() { ...; }

ne sont pas strictement équivalentes.

Dans le premier cas, nous disons que la fonction foo n'a pas d'argument et le compilo va raler lorsqu'il rencontrera foo(1).
Dans le second, pour des raisons de compatibilités, il va accepter une liste quelconque de paramètres.

Dans le cas de main, cela ne va pas changer grand chose puisque "son prototype" ne sera jamais utilisé. Les implications sont a rechercher dans le "non-fonctionnel" (maintenabilité, lisibilité,...).

En gros, c'est une question de "style". Elle tourne autour de l'intérêt à être "plus précis" et s'imposer une discipline dans la cohérence de son écriture allant (souvent) au delà du nécessaire (côté fonctionnel).

Sans vouloir entrer dans ce débat, je pense que si on fait un tuto, il sera préférable d'utiliser int main(void)...
Si on fait un exemple vite fait pour illustrer ses propos dans une réponse du forum, on pourra être plus laxiste.

- W

Citation:

---

Envoyé par Melem

Code:

---

1 2 3 4

int main(void) { return 0; }

---

Qui est strictement équivalent (en C90) à :

Code:

---

1 2 3 4

int main() { return 0; }

---

---

Je ne suis pas convaincu que ce soit deux ecritures equivalentes. La premiere (int main(void)) est un prototype, alors que la seconde ne donne que le type de retour.

Citation:

---

Envoyé par ram_0000

Cette forme de déclaration est complètement obsolète ou bien elle peut encore être utilisée ?

---

C'est une extension au standard, disponible sur les plateformes Unixoides. Non portable, evidemment.

Les deux formes sont équivalentes, mais pas strictement. Dans les deux cas, on définit une fonction main() renvoyant un int et ne prenant aucun paramètre. Par ailleurs, la première forme déclare main sous forme de prototype, ce qui n'est pas le cas de la deuxième. Pour main(), comme tu l'as fait remarquer, ce n'est pas important car elle n'est jamais appelée explicitement dans le programme. En revanche, pour les autres fonctions, il est fortement recommandé de les déclarer sous forme de prototype. Or, pour s'en assurer, gcc offre l'option de compilation -Wstrict-prototypes qui active un avertissement lorsqu'une fonction non déclarée sous forme de prototype est rencontrée. Or, du point de vue de gcc, main() est une fonction comme les autres. Je préfère donc spécifier explicitement que main() ne prend aucun argument. Ceci m'évite d'avoir à trainer un avertissement, même si le code est parfaitement valide sans cela.

C++ a résolu le problème à la base en rendant ces deux formes de définition de main() strictement équivalentes. Pour ce qui est du C, il y a une asymétrie embêtante entre déclaration faisant partie d'une définition (selon les termes utilisés par la norme) et déclaration ne faisant pas partie d'une définition.

Thierry

Citation:

---

Envoyé par DaZumba

Je ne suis pas convaincu que ce soit deux ecritures equivalentes. La premiere (int main(void)) est un prototype, alors que la seconde ne donne que le type de retour.

---

Du point de vue de l'appelé (en l'occurrence main ici), elles sont identiques.
En revanche du point de vue de l'appelant, il y a une différence qui selon moi justifie de ne jamais utiliser la seconde : si on met explicitement void, comme dit plus, il n'est pas possible d'appeler main ainsi : main(1) car on viole une contrainte. Si au contraire, on laisse les parenthèses vides (), le fait d'appeler main ainsi main(1) ne viole aucune contrainte mais induit un comportement indéterminé.
En conclusion, afin d'éviter tout comportement indéterminé, la forme main() ne doit pas être utiliser (que ce soit pour main ou tout autre fonction ne recevant pas d'argument).

Citation:

---

J.2 Undefined behavior
1 The behavior is undefined in the following circumstances:
...
— For a call to a function without a function prototype in scope, the number of
arguments does not equal the number of parameters (6.5.2.2).

---

Citation:

---

Envoyé par DaZumba

Je ne suis pas convaincu que ce soit deux ecritures equivalentes. La premiere (int main(void)) est un prototype, alors que la seconde ne donne que le type de retour.

---

La seconde ne donne pas seulement le type de retour. Selon la norme, elle spécifie bel et bien que la fonction ne prend aucun argument. Cette forme n'est toutefois pas considérée comme prototype.

Thierry

Citation:

---

Envoyé par Thierry Chappuis

Pour main(), comme tu l'as fait remarquer, ce n'est pas important car elle n'est jamais appelée explicitement dans le programme.

---

Il ne faut jamais dire jamais !

Citation:

---

Envoyé par Thierry Chappuis

Selon la norme, elle spécifie bel et bien que la fonction ne prend aucun argument.

---

Ce ne serait pas un ajout C99 par hasard?

Citation:

---

Envoyé par DaZumba

Ce ne serait pas un ajout C99 par hasard?

---

Le draft de C89 disponible ici dit:

Citation:

---

Envoyé par C89

An empty list in a function declarator that is part of a function definition specifies that the function has no parameters. The empty list in a function declarator that is not part of a function definition specifies that no information about the number or types of the parameters is supplied.

---

Idem en C99.

Thierry

Citation:

---

Envoyé par Thierry Chappuis

Le draft de C89 disponible ici dit:

---

Ok, la subtilite est dans le comportement different entre definition et non-definition de fonction. Merci.

juste en passant,

ce bout de code

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include<stdio.h> #include<string.h> #include <stdlib.h>   int main( int argc, char** argv, char** envp ) { char** cpy = envp;   while( *cpy != NULL ) { fprintf( stderr, "%s\n", *cpy ); cpy += 1; }   return EXIT_SUCCESS; }

---

fonctionne sous c::b + gcc 3.4 et sous visual 2005 (ou 2008 je sais plus) te donne bien le resultat escompté (le tout sous Windows bien sur) .

Citation:

---

Envoyé par ram_0000

Code:

---

int main(int argc, char * argv[], char *envp[])

---

Cette forme de déclaration est complètement obsolète ou bien elle peut encore être utilisée ?

---

Elle n'a jamais fait partie de la définition du C (K&R ou ANSI). C'est une extension supportée par certains compilateurs sous certains sytèmes...

Il y a un truc bizarre dans l'évangile selon Visual 6 :

Citation:

---

This argument is ANSI compatible in C, but not in C++

---

Notez que la version 2005 ne dit rien de tel.

Citation:

---

Envoyé par Médinoc

Il y a un truc bizarre dans l'évangile selon Visual 6 :

Notez que la version 2005 ne dit rien de tel.

---

c'est louche d'autant que cette section est clairement encadrée par "Microsoft Specific —>"

La norme en parle dans les extensions de l'annexe J.5, faut peut-être pas chercher plus loin.

Même pas dans les annexes :

Citation:

---

Envoyé par n1256

5.1.2.2.1 Program startup

1 The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters :

int main(void) { /* ... */ }

or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared) :

int main(int argc, char *argv[]) { /* ... */ }

or equivalent; 9) or in some other implementation-defined manner.

---

D'autres proptotypes de main autres que int main(void) et int main(int argc, char * argv[]) sont donc également autorisés mais ils ne sont bien évidemment pas standards.

Citation:

---

Envoyé par Thierry Chappuis

Citation:

---

Envoyé par C89

An empty list in a function declarator that is part of a function definition specifies that the function has no parameters. The empty list in a function declarator that is not part of a function definition specifies that no information about the number or types of the parameters is supplied.

---

Idem en C99.

---

:king: 10 / 10.

Donc : Dans la définition d'une fonction qui ne prend aucun argument, void placé entre les parenthèses est complètement facultatif. Dans sa déclaration, qui est une chose à part (définition et déclaration n'apparaissent pas forcément dans le même fichier source ...), il est cependant obligatoire (si on veut indiquer au compilateur que la fonction ne prend aucun argument).

Merci à tous.

Citation:

---

Envoyé par Melem

Donc : Dans la définition d'une fonction qui ne prend aucun argument, void placé entre les parenthèses est complètement facultatif. Dans sa déclaration, qui est une chose à part (définition et déclaration n'apparaissent pas forcément dans le même fichier source ...), il est cependant obligatoire (si on veut indiquer au compilateur que la fonction ne prend aucun argument).

Merci à tous.

---

Je dois parler dans le vent...

Citation:

---

Envoyé par nicolas.sitbon

Du point de vue de l'appelé (en l'occurrence main ici), elles sont identiques.
En revanche du point de vue de l'appelant, il y a une différence qui selon moi justifie de ne jamais utiliser la seconde : si on met explicitement void, comme dit plus, il n'est pas possible d'appeler main ainsi : main(1) car on viole une contrainte. Si au contraire, on laisse les parenthèses vides (), le fait d'appeler main ainsi main(1) ne viole aucune contrainte mais induit un comportement indéterminé.
En conclusion, afin d'éviter tout comportement indéterminé, la forme main() ne doit pas être utiliser (que ce soit pour main ou tout autre fonction ne recevant pas d'argument).

---

Citation:

---

Envoyé par nicolas.sitbon

Je dois parler dans le vent...

---

Non, tu ne parles pas dans le vent et merci pour la précision sur le comportement indéterminé.

Thierry