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

Citation:

---

Envoyé par Melem

Même pas dans les annexes :

---

:question:

http://pix.nofrag.com/d/c/f/f931d331...eb67fff134.png

Dans la norme C89, on trouve aussi :

Citation:

---

A.6.5 Common extensions

The following extensions are widely used in many systems, but are not portable to all implementations. The inclusion of any extension that may cause a strictly conforming program to become invalid renders an implementation nonconforming. Examples of such extensions are new keywords, or library functions declared in standard headers or predefined macros with names that do not begin with an underscore.
A.6.5.1 Environment arguments

In a hosted environment, the main function receives a third argument, char *envp[] , that points to a null-terminated array of pointers to char , each of which points to a string that provides information about the environment for this execution of the process (2.1.2.2).

---

Citation:

---

Envoyé par nicolas.sitbon

Dans la norme C89, on trouve aussi :

---

dans une section 'non normative' ...

Citation:

---

Envoyé par Emmanuel Delahaye

dans une section 'non normative' ...

---

Je n'ai pas dit le contraire mais ais simplement cité ma référence.

Citation:

---

Envoyé par nicolas.sitbon

Je n'ai pas dit le contraire mais ais simplement cité ma référence.

---

péché par omission.

1 - tu cites la norme
2 - tu oublies de dire que ce que tu cites n'est pas la norme.

Confusion du lecteur non averti assurée.

Et pour ces définitions-là

Code:

---

1 2 3 4

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

---

Vous savez à quel endroit la norme en parle ? Ou bien ce n'est plus supporté du tout depuis la normalisation du C ?

Le implicit int était autorisé en C90. Il n'est plus autorisé en C99.

Merci, j'ai trouvé la référence dans le draft de C89 en cherchant avec "implicit int" :

Citation:

---

If the expression that precedes the parenthesized argument list in a function call consists solely of an identifier, and if no declaration is visible for this identifier, the identifier is implicitly declared exactly as if, in the innermost block containing the function call, the declaration

Code:

---

extern int identifier();

---

appeared.

---

http://megaton.obfuscated.net/~orang...t.html#3.3.2.2

Et une qui dit également que lorsqu'on définit une fonction sans préciser le type de retour, comme dans ton exemple avec main, alors son type de retour est int (et non void).

Citation:

---

Envoyé par wiztricks

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

---

Je partage aussi cet avis. Le langage C semble plus permissif que C++, et le fait d'adopter une attitude rigoureuse est la meilleure solution, ne serait-ce que pour des raisons de rétro compatibilité.

Par ailleurs, la forme

Code:

---

int main (void)

---

contrairement à

Code:

---

int main ()

---

ne vas à l'encontre d'aucune des normes du C, alors autant ne pas s'en priver.

Citation:

---

Envoyé par maxim_um

Par ailleurs, la forme

Code:

---

int main (void)

---

contrairement à

Code:

---

int main ()

---

ne vas à l'encontre d'aucune des normes du C, alors autant ne pas s'en priver.

---

La deuxième forme est valide également. Voir posts plus haut.

Thierry

Citation:

---

Envoyé par Thierry Chappuis

La deuxième forme est valide également. Voir posts plus haut.

Thierry

---

Valide mais peut potentiellement entraîner un comportement indéterminé comme je l'ai expliqué plus haut donc si on parle de bonne pratique de programmation, elle est à éviter!!!

Citation:

---

Envoyé par nicolas.sitbon

Valide mais peut potentiellement entraîner un comportement indéterminé comme je l'ai expliqué plus haut donc si on parle de bonne pratique de programmation, elle est à éviter!!!

---

Je n'ai pas dit qu'elle était conseillée, j'ai dit qu'elle était valide.

Valide peut-être pas, ou plus pour longtemps en tout cas.

voilà ce que dit C99: (je suis sûr qu'il y en a qui pensent à DBZ)

Citation:

---

6.11.4 Function declarators

#1

The use of function declarators with empty parentheses (not prototype-format parameter type declarators) is an obsolescent feature.

---

En d'autres termes si tu spécifies à ton compilateur que tu programmes selon les normes les plus récentes, tu auras certainement droit à quelques «warnings».

Personne n'a dit que c'était conseillé en C99, mais ça reste valide, c'est bien ce qu'on a dit depuis le début. La quasi totalité des exemples (si ce n'est pas : tous les exemples) du document duquel tu as tiré ce 6.11.4 Function declarators ne mettent rien entre les parenthèses dans la définition de main.