Si j'ai bonne memoire, c'est d'ailleurs un petit point de difference
entre C et C++. Il me semble que la norme C++ donne un statut tres
particulier a main(), qui n'est vraiment pas une fonction comme les
autres, et qu'en particulier tu ne peux pas la rappeler de l'interieur de
ton programme...
Si j'ai bonne memoire, c'est d'ailleurs un petit point de difference
entre C et C++. Il me semble que la norme C++ donne un statut tres
particulier a main(), qui n'est vraiment pas une fonction comme les
autres, et qu'en particulier tu ne peux pas la rappeler de l'interieur de
ton programme...
Si j'ai bonne memoire, c'est d'ailleurs un petit point de difference
entre C et C++. Il me semble que la norme C++ donne un statut tres
particulier a main(), qui n'est vraiment pas une fonction comme les
autres, et qu'en particulier tu ne peux pas la rappeler de l'interieur de
ton programme...
J'ai pas vu un message précédent où tu fais un raisonnement relatif à
"la ligne de commande" (si tu pouvais citer le lien http de
groups.google plutôt que le liens <new&###!15744154584uiydgbciu...>
auquel je comprends rien ;) )
J'ai pas vu un message précédent où tu fais un raisonnement relatif à
"la ligne de commande" (si tu pouvais citer le lien http de
groups.google plutôt que le liens <new&###!15744154584uiydgbciu...>
auquel je comprends rien ;) )
J'ai pas vu un message précédent où tu fais un raisonnement relatif à
"la ligne de commande" (si tu pouvais citer le lien http de
groups.google plutôt que le liens <new&###!15744154584uiydgbciu...>
auquel je comprends rien ;) )
Cela tient à mon avis au statut particulier de ces objets : ils
ne sont pas alloués par le programme mais par l'environnement.
En fait il y a 4 objets :
-- argc (fourni par l'environnement)
-- la copie de argc passé en argument à main() (les arguments sont
passés par valeur),
-- argv
-- les chaînes pointées dans le "tableau" argv .
J'aurais tendance à dire que argc et argv sont de classe automatique et
seules les chaînes pointées sont de classe statique.
Mais la Norme ne dit rien.
Pourtant, dans un autre cas similaire où le programme alloue
un objet sans le déclarer, celui des chaînes littérales, la Norme prend
bien soin de préciser que les chaînes sont de classe statique.
Par ailleurs, il y a une autre difficulté : la Norme ne donne pas
précisément la définition de la "classe" static, ni d'"automatic" ni
même d'"allocated" (rien de formel en tous cas). Elle dit d'abord qu'il
existe trois types de durée de mémorisation.
Mais à la limite, je ne vois pas où la Norme m'empêcherait de
considérer que les arguments du programme (les chaînes) sont de
classe automatique !!
Cela tient à mon avis au statut particulier de ces objets : ils
ne sont pas alloués par le programme mais par l'environnement.
En fait il y a 4 objets :
-- argc (fourni par l'environnement)
-- la copie de argc passé en argument à main() (les arguments sont
passés par valeur),
-- argv
-- les chaînes pointées dans le "tableau" argv .
J'aurais tendance à dire que argc et argv sont de classe automatique et
seules les chaînes pointées sont de classe statique.
Mais la Norme ne dit rien.
Pourtant, dans un autre cas similaire où le programme alloue
un objet sans le déclarer, celui des chaînes littérales, la Norme prend
bien soin de préciser que les chaînes sont de classe statique.
Par ailleurs, il y a une autre difficulté : la Norme ne donne pas
précisément la définition de la "classe" static, ni d'"automatic" ni
même d'"allocated" (rien de formel en tous cas). Elle dit d'abord qu'il
existe trois types de durée de mémorisation.
Mais à la limite, je ne vois pas où la Norme m'empêcherait de
considérer que les arguments du programme (les chaînes) sont de
classe automatique !!
Cela tient à mon avis au statut particulier de ces objets : ils
ne sont pas alloués par le programme mais par l'environnement.
En fait il y a 4 objets :
-- argc (fourni par l'environnement)
-- la copie de argc passé en argument à main() (les arguments sont
passés par valeur),
-- argv
-- les chaînes pointées dans le "tableau" argv .
J'aurais tendance à dire que argc et argv sont de classe automatique et
seules les chaînes pointées sont de classe statique.
Mais la Norme ne dit rien.
Pourtant, dans un autre cas similaire où le programme alloue
un objet sans le déclarer, celui des chaînes littérales, la Norme prend
bien soin de préciser que les chaînes sont de classe statique.
Par ailleurs, il y a une autre difficulté : la Norme ne donne pas
précisément la définition de la "classe" static, ni d'"automatic" ni
même d'"allocated" (rien de formel en tous cas). Elle dit d'abord qu'il
existe trois types de durée de mémorisation.
Mais à la limite, je ne vois pas où la Norme m'empêcherait de
considérer que les arguments du programme (les chaînes) sont de
classe automatique !!
candide écrivit :Cela tient à mon avis au statut particulier de ces objets : ils
ne sont pas alloués par le programme mais par l'environnement.
Attention : ils ne sont pas alloués au sens de la norme.
Sinon, ce n'est pas vraiment l'environnement (qui n'est pas spécifié),
En fait il y a 4 objets :
-- argc (fourni par l'environnement)
-- la copie de argc passé en argument à main() (les arguments sont
passés par valeur),
-- argv
-- les chaînes pointées dans le "tableau" argv .
Si on accepte que le « argv » dans ton énumération ci-dessus désigne le
paramètre (un pointeur vers tableau de chaînes) passé en argument à
main(), par le même mécanisme que pour « la copie de argc », il te
manque le "tableau" lui-même (construit à partir de l'environnement).
J'aurais tendance à dire que argc et argv sont de classe automatique et
Voui. Mais je ne veux pas parler de ceux-là (d'où mon appréciation
qu'Emmanuel a utilisé une mauvaise formulation au départ).seules les chaînes pointées sont de classe statique.
C'est là où je ne suis pas d'accord. Pour moi le premier terme ci-dessus
ainsi que le tableau (le 5e article) sont aussi de classe statique.
Je lis 5.1.2.2.1§2 dernier alinéa commeMais la Norme ne dit rien.
??? Au seul endroit où elle mentionne les chaînes, elle mentionne les
deux autres objets...
Bzzz. « prend bien soin » est une lecture erronée de la norme.
Mais à la limite, je ne vois pas où la Norme m'empêcherait de
considérer que les arguments du programme (les chaînes) sont de
classe automatique !!
Bien justement, parce que le fameux dernier alinéa de 5.1.2.2.1
explicite que les chaînes doivent être encore valides dans la "program
termination"
candide écrivit :
Cela tient à mon avis au statut particulier de ces objets : ils
ne sont pas alloués par le programme mais par l'environnement.
Attention : ils ne sont pas alloués au sens de la norme.
Sinon, ce n'est pas vraiment l'environnement (qui n'est pas spécifié),
En fait il y a 4 objets :
-- argc (fourni par l'environnement)
-- la copie de argc passé en argument à main() (les arguments sont
passés par valeur),
-- argv
-- les chaînes pointées dans le "tableau" argv .
Si on accepte que le « argv » dans ton énumération ci-dessus désigne le
paramètre (un pointeur vers tableau de chaînes) passé en argument à
main(), par le même mécanisme que pour « la copie de argc », il te
manque le "tableau" lui-même (construit à partir de l'environnement).
J'aurais tendance à dire que argc et argv sont de classe automatique et
Voui. Mais je ne veux pas parler de ceux-là (d'où mon appréciation
qu'Emmanuel a utilisé une mauvaise formulation au départ).
seules les chaînes pointées sont de classe statique.
C'est là où je ne suis pas d'accord. Pour moi le premier terme ci-dessus
ainsi que le tableau (le 5e article) sont aussi de classe statique.
Je lis 5.1.2.2.1§2 dernier alinéa comme
Mais la Norme ne dit rien.
??? Au seul endroit où elle mentionne les chaînes, elle mentionne les
deux autres objets...
Bzzz. « prend bien soin » est une lecture erronée de la norme.
Mais à la limite, je ne vois pas où la Norme m'empêcherait de
considérer que les arguments du programme (les chaînes) sont de
classe automatique !!
Bien justement, parce que le fameux dernier alinéa de 5.1.2.2.1
explicite que les chaînes doivent être encore valides dans la "program
termination"
candide écrivit :Cela tient à mon avis au statut particulier de ces objets : ils
ne sont pas alloués par le programme mais par l'environnement.
Attention : ils ne sont pas alloués au sens de la norme.
Sinon, ce n'est pas vraiment l'environnement (qui n'est pas spécifié),
En fait il y a 4 objets :
-- argc (fourni par l'environnement)
-- la copie de argc passé en argument à main() (les arguments sont
passés par valeur),
-- argv
-- les chaînes pointées dans le "tableau" argv .
Si on accepte que le « argv » dans ton énumération ci-dessus désigne le
paramètre (un pointeur vers tableau de chaînes) passé en argument à
main(), par le même mécanisme que pour « la copie de argc », il te
manque le "tableau" lui-même (construit à partir de l'environnement).
J'aurais tendance à dire que argc et argv sont de classe automatique et
Voui. Mais je ne veux pas parler de ceux-là (d'où mon appréciation
qu'Emmanuel a utilisé une mauvaise formulation au départ).seules les chaînes pointées sont de classe statique.
C'est là où je ne suis pas d'accord. Pour moi le premier terme ci-dessus
ainsi que le tableau (le 5e article) sont aussi de classe statique.
Je lis 5.1.2.2.1§2 dernier alinéa commeMais la Norme ne dit rien.
??? Au seul endroit où elle mentionne les chaînes, elle mentionne les
deux autres objets...
Bzzz. « prend bien soin » est une lecture erronée de la norme.
Mais à la limite, je ne vois pas où la Norme m'empêcherait de
considérer que les arguments du programme (les chaînes) sont de
classe automatique !!
Bien justement, parce que le fameux dernier alinéa de 5.1.2.2.1
explicite que les chaînes doivent être encore valides dans la "program
termination"
Antoine Leca a écrit :candide écrivit :Mais à la limite, je ne vois pas où la Norme m'empêcherait de
considérer que les arguments du programme (les chaînes) sont de
classe automatique !!
Bien justement, parce que le fameux dernier alinéa de 5.1.2.2.1
explicite que les chaînes doivent être encore valides dans la "program
termination"
Je sais bien que ce que je vais dire peut paraître absurde mais si je me
fie juste au texte de la Norme qu'est-ce que ça contredit le fait de
supposer que les chaînes soient de classe automatique puisque lorsque
lorsque le bloc qui définit main(), mon programme se termine et donc mes
chaînes s'évanouissent ?
Antoine Leca a écrit :
candide écrivit :
Mais à la limite, je ne vois pas où la Norme m'empêcherait de
considérer que les arguments du programme (les chaînes) sont de
classe automatique !!
Bien justement, parce que le fameux dernier alinéa de 5.1.2.2.1
explicite que les chaînes doivent être encore valides dans la "program
termination"
Je sais bien que ce que je vais dire peut paraître absurde mais si je me
fie juste au texte de la Norme qu'est-ce que ça contredit le fait de
supposer que les chaînes soient de classe automatique puisque lorsque
lorsque le bloc qui définit main(), mon programme se termine et donc mes
chaînes s'évanouissent ?
Antoine Leca a écrit :candide écrivit :Mais à la limite, je ne vois pas où la Norme m'empêcherait de
considérer que les arguments du programme (les chaînes) sont de
classe automatique !!
Bien justement, parce que le fameux dernier alinéa de 5.1.2.2.1
explicite que les chaînes doivent être encore valides dans la "program
termination"
Je sais bien que ce que je vais dire peut paraître absurde mais si je me
fie juste au texte de la Norme qu'est-ce que ça contredit le fait de
supposer que les chaînes soient de classe automatique puisque lorsque
lorsque le bloc qui définit main(), mon programme se termine et donc mes
chaînes s'évanouissent ?
mais je ne vois qu'un truc du genre
exit(main(...)) (je schématise hein)
mais je ne vois qu'un truc du genre
exit(main(...)) (je schématise hein)
mais je ne vois qu'un truc du genre
exit(main(...)) (je schématise hein)
Antoine Leca a écrit :candide écrivit :Cela tient à mon avis au statut particulier de ces objets : ils
ne sont pas alloués par le programme mais par l'environnement.
Attention : ils ne sont pas alloués au sens de la norme.
J'ai employé ce terme en me croyant autorisé à le faire
Mais la Norme ne dit rien.
??? Au seul endroit où elle mentionne les chaînes, elle mentionne les
deux autres objets...
Oui. Mais je ne vois pas ce que ça prouve. La Norme dit que
"Each parameter has automatic storage duration. "
Au passage je lis un peu plus loin :
"The layout of the storage for parameters is unspecified."
C'est pas contradictoire avec ce qui précède ?
Antoine Leca a écrit :
candide écrivit :
Cela tient à mon avis au statut particulier de ces objets : ils
ne sont pas alloués par le programme mais par l'environnement.
Attention : ils ne sont pas alloués au sens de la norme.
J'ai employé ce terme en me croyant autorisé à le faire
Mais la Norme ne dit rien.
??? Au seul endroit où elle mentionne les chaînes, elle mentionne les
deux autres objets...
Oui. Mais je ne vois pas ce que ça prouve. La Norme dit que
"Each parameter has automatic storage duration. "
Au passage je lis un peu plus loin :
"The layout of the storage for parameters is unspecified."
C'est pas contradictoire avec ce qui précède ?
Antoine Leca a écrit :candide écrivit :Cela tient à mon avis au statut particulier de ces objets : ils
ne sont pas alloués par le programme mais par l'environnement.
Attention : ils ne sont pas alloués au sens de la norme.
J'ai employé ce terme en me croyant autorisé à le faire
Mais la Norme ne dit rien.
??? Au seul endroit où elle mentionne les chaînes, elle mentionne les
deux autres objets...
Oui. Mais je ne vois pas ce que ça prouve. La Norme dit que
"Each parameter has automatic storage duration. "
Au passage je lis un peu plus loin :
"The layout of the storage for parameters is unspecified."
C'est pas contradictoire avec ce qui précède ?
candide écrivit :Antoine Leca a écrit :candide écrivit :
Oui. Mais je ne vois pas ce que ça prouve. La Norme dit que
"Each parameter has automatic storage duration. "
Au passage je lis un peu plus loin :
"The layout of the storage for parameters is unspecified."
C'est pas contradictoire avec ce qui précède ?
Non, à partir du moment où on comprend que argc et argv sont les
_paramètres_ (des objets automatiques) qui sont différents des
_arguments_ (qui n'ont pas de noms définis par la norme).
Si tu relis le paragraphe sur les appels de fonction, tu verras que
l'association entre argument et paramètre (une assignation) se fait au
moment de l'appel, et par la suite chacun vit sa vie.
candide écrivit :
Antoine Leca a écrit :
candide écrivit :
Oui. Mais je ne vois pas ce que ça prouve. La Norme dit que
"Each parameter has automatic storage duration. "
Au passage je lis un peu plus loin :
"The layout of the storage for parameters is unspecified."
C'est pas contradictoire avec ce qui précède ?
Non, à partir du moment où on comprend que argc et argv sont les
_paramètres_ (des objets automatiques) qui sont différents des
_arguments_ (qui n'ont pas de noms définis par la norme).
Si tu relis le paragraphe sur les appels de fonction, tu verras que
l'association entre argument et paramètre (une assignation) se fait au
moment de l'appel, et par la suite chacun vit sa vie.
candide écrivit :Antoine Leca a écrit :candide écrivit :
Oui. Mais je ne vois pas ce que ça prouve. La Norme dit que
"Each parameter has automatic storage duration. "
Au passage je lis un peu plus loin :
"The layout of the storage for parameters is unspecified."
C'est pas contradictoire avec ce qui précède ?
Non, à partir du moment où on comprend que argc et argv sont les
_paramètres_ (des objets automatiques) qui sont différents des
_arguments_ (qui n'ont pas de noms définis par la norme).
Si tu relis le paragraphe sur les appels de fonction, tu verras que
l'association entre argument et paramètre (une assignation) se fait au
moment de l'appel, et par la suite chacun vit sa vie.
Le problème est que dans le cas de la fonction main(), sauf appel
récursif direct ou indirect, il n'y a pas d'appel du genre
Pendant qu'on y est, puisqu'on a évoqué la question, comment
comprends-tu la phrase :
"The layout of the storage for parameters is unspecified."
"unspecified" c'est je suppose au sens de l'annexe J1.
Mais qu'est-il entendu par "layout".
Le problème est que dans le cas de la fonction main(), sauf appel
récursif direct ou indirect, il n'y a pas d'appel du genre
Pendant qu'on y est, puisqu'on a évoqué la question, comment
comprends-tu la phrase :
"The layout of the storage for parameters is unspecified."
"unspecified" c'est je suppose au sens de l'annexe J1.
Mais qu'est-il entendu par "layout".
Le problème est que dans le cas de la fonction main(), sauf appel
récursif direct ou indirect, il n'y a pas d'appel du genre
Pendant qu'on y est, puisqu'on a évoqué la question, comment
comprends-tu la phrase :
"The layout of the storage for parameters is unspecified."
"unspecified" c'est je suppose au sens de l'annexe J1.
Mais qu'est-il entendu par "layout".
candide a écrit :Le problème est que dans le cas de la fonction main(), sauf appel
récursif direct ou indirect, il n'y a pas d'appel du genre
Ma lecture des trois premiers mots du paragraphe 5.1.2.2.1 m'incite à
penser le contraire. Mais je n'arriverais pas à te convaincre, donc je
ne vais même pas essayer.
Mais qu'est-il entendu par "layout".
« Disposition » ?
Cela devient peut-être plus clair si tu lis les propos du /Rationale/
(p. 96) à ce sujet : il y est expliqué en particulier que pour les
fonctions variadyques comme printf, la méthode utilisée par <varargs.h>
n'était pas suffisamment portable et devait être évitée dans des
programmes portables.
candide a écrit :
Le problème est que dans le cas de la fonction main(), sauf appel
récursif direct ou indirect, il n'y a pas d'appel du genre
Ma lecture des trois premiers mots du paragraphe 5.1.2.2.1 m'incite à
penser le contraire. Mais je n'arriverais pas à te convaincre, donc je
ne vais même pas essayer.
Mais qu'est-il entendu par "layout".
« Disposition » ?
Cela devient peut-être plus clair si tu lis les propos du /Rationale/
(p. 96) à ce sujet : il y est expliqué en particulier que pour les
fonctions variadyques comme printf, la méthode utilisée par <varargs.h>
n'était pas suffisamment portable et devait être évitée dans des
programmes portables.
candide a écrit :Le problème est que dans le cas de la fonction main(), sauf appel
récursif direct ou indirect, il n'y a pas d'appel du genre
Ma lecture des trois premiers mots du paragraphe 5.1.2.2.1 m'incite à
penser le contraire. Mais je n'arriverais pas à te convaincre, donc je
ne vais même pas essayer.
Mais qu'est-il entendu par "layout".
« Disposition » ?
Cela devient peut-être plus clair si tu lis les propos du /Rationale/
(p. 96) à ce sujet : il y est expliqué en particulier que pour les
fonctions variadyques comme printf, la méthode utilisée par <varargs.h>
n'était pas suffisamment portable et devait être évitée dans des
programmes portables.