Discussion :

[Melem]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int main(void)
{
    return 0;
}

Qui est strictement équivalent (en C90) à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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).

[ram-0000]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[DaZumba]

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.

[Thierry Chappuis]

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

[DaZumba]

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 !

[Emmanuel Delahaye]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Médinoc]

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

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

Notez que la version 2005 ne dit rien de tel.

[nicolas.sitbon]

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 —>"

[dapounet]

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

[Melem]

Même pas dans les annexes :

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.

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.

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.

[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

[maxim_um]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

int main (void)

contrairement à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int main ()

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

[Thierry Chappuis]

Par ailleurs, la forme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int main (void)

contrairement à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[nicolas.sitbon]

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!!!

[Thierry Chappuis]

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.

[DaZumba]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int main(void)
{
    return 0;
}

Qui est strictement équivalent (en C90) à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[nicolas.sitbon]

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).

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).

[Thierry Chappuis]

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

[DaZumba]

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?

[Thierry Chappuis]

Ce ne serait pas un ajout C99 par hasard?

Le draft de C89 disponible ici dit:

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