Bonjour =E0 toutes et =E0 tous,
quel livre me conseilleriez vous sur le langage C, plutot orient=E9 microco=
ntroleurs...
Je pr=E9cise que je suis technicien en =E9lectronique, et que j'ai quand me=
me des notions de programmations...
J'ai vu rapidement le langage en BTS, mais il m'a toujours rebut=E9, m=EAme=
si je reste persuad=E9 qu'il est puissant, versatile, portable, enfin bref=
bourr=E9 de qualit=E9s connues et reconnues...=20
Sinon, =E0 part =E7a, vous allez vous moquer de moi, mais j'ai commenc=E9 =
=E0 "bidouiller" en BASIC =E0 la fin des ann=E9es 80 sur le Commodore C64 d=
e mon fr=E8re... En plus le "Basic V2" du C64 n'=E9tait deja pas une r=E9f=
=E9rence !
Un peu plus tard, j'ai bidouill=E9 en Visual Basic 1.0, puis en Quick Basic=
4.5, ...
En BTS je me suis =E9clat=E9 en assembleur 68705 et 68HC11... Et pour la su=
ite, plus grand chose, =E0 mon grand regret !
J'ai d=E9ja post=E9 un message =E0 ce sujet sur fr.sci.electronique, beauco=
up m'ont conseill=E9 le K&R, ou le ANSI C.
Merci par avance de votre aide !
Pour moi, le premier définit main comme une fonction retournant un int et sans paramètre et la déclare de la même manière, la seconde définit main comme une fonction retournant un int et sans paramètre mais la déclare comme une fonction retournant un int avec des paramètres non spécifié. Ça ne fait une différence que dans le cadre de l'IOCCC quand on appelle main de manière récursive, si on appelle main avec des paramètres, ça ne doit pas compiler dans le premier cas, ça doit dans le second, mais l'exécution est un comportement indéfini.
Résumons, le premier est correct, le deuxième est une forme batarde entre la verion d'avant la normalisation et celle d'après
En passant, je vous rappelle que même dans la seconde édition de K&R, c'est simplement
main() { }
avec des fonctions qui sont parfois déclarées à l'intérieur des fonctions qui les appellent.
Tu as certainement une version préhistorique du K&R, qui parle de la version pré-normalisation.
-- Le travail n'est pas une bonne chose. Si ça l'était, les riches l'auraient accaparé
Jean-Marc Bourguet <jm@bourguet.org> écrivait :
Pour moi, le premier définit main comme une fonction retournant un int et
sans paramètre et la déclare de la même manière, la seconde définit main
comme une fonction retournant un int et sans paramètre mais la déclare
comme une fonction retournant un int avec des paramètres non spécifié. Ça
ne fait une différence que dans le cadre de l'IOCCC quand on appelle main
de manière récursive, si on appelle main avec des paramètres, ça ne doit
pas compiler dans le premier cas, ça doit dans le second, mais l'exécution
est un comportement indéfini.
Résumons, le premier est correct, le deuxième est une forme batarde
entre la verion d'avant la normalisation et celle d'après
En passant, je vous rappelle que même dans la seconde édition de K&R, c'est
simplement
main()
{
}
avec des fonctions qui sont parfois déclarées à l'intérieur des fonctions
qui les appellent.
Tu as certainement une version préhistorique du K&R, qui parle de la
version pré-normalisation.
--
Le travail n'est pas une bonne chose. Si ça l'était,
les riches l'auraient accaparé
Pour moi, le premier définit main comme une fonction retournant un int et sans paramètre et la déclare de la même manière, la seconde définit main comme une fonction retournant un int et sans paramètre mais la déclare comme une fonction retournant un int avec des paramètres non spécifié. Ça ne fait une différence que dans le cadre de l'IOCCC quand on appelle main de manière récursive, si on appelle main avec des paramètres, ça ne doit pas compiler dans le premier cas, ça doit dans le second, mais l'exécution est un comportement indéfini.
Résumons, le premier est correct, le deuxième est une forme batarde entre la verion d'avant la normalisation et celle d'après
En passant, je vous rappelle que même dans la seconde édition de K&R, c'est simplement
main() { }
avec des fonctions qui sont parfois déclarées à l'intérieur des fonctions qui les appellent.
Tu as certainement une version préhistorique du K&R, qui parle de la version pré-normalisation.
-- Le travail n'est pas une bonne chose. Si ça l'était, les riches l'auraient accaparé
espie
In article , Jean-Marc Bourguet wrote:
Erwan David writes:
Stephane Legras-Decussy écrivait :
Le 24/08/2012 22:19, Tonton Th a écrit :
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...] 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 [...]): int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant de l'implementation...
beaucoup de compilo reconnaissent les vieilles declarations "K&R" (chez qui main() est licite). Mais c'est au mieux obsolescent...
In article <87wr0mopll.fsf@news.bourguet.org>,
Jean-Marc Bourguet <jm@bourguet.org> wrote:
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par
int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...]
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 [...]):
int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant
de l'implementation...
beaucoup de compilo reconnaissent les vieilles declarations "K&R" (chez
qui main() est licite). Mais c'est au mieux obsolescent...
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...] 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 [...]): int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant de l'implementation...
beaucoup de compilo reconnaissent les vieilles declarations "K&R" (chez qui main() est licite). Mais c'est au mieux obsolescent...
Jean-Marc Bourguet
Erwan David writes:
Résumons, le premier est correct, le deuxième est une forme batarde entre la verion d'avant la normalisation et celle d'après
Ce qui ne la rend pas fausse.
Tu as certainement une version préhistorique du K&R, qui parle de la version pré-normalisation.
J'ai la 41ième impression datée de décembre 2006 de la deuxième édition, celle qui a un tampon rouge "ANSI C" dessus. J'avais une impression antérieure que je ne retrouve plus, mais je suis certain n'avoir jamais possédé de première édition, j'ai commencé le C suffisemment tôt pour m'être frotté à du code K&R mais trop tard pour acheter autre chose que la deuxième édition.
Je ne dis pas que main n'est pas parfois défini autrement que
main() { ... }
mais je viens de regarder, je n'ai pas vu de cas (ce qui est pire que dans mon souvenir, je croyais qu'ils avaient modifiés au moins les premières occurences). J'ai par contre compté 17 occurences de main défini comme ci-dessus.
Les fonctions sont généralement déclarées en dehors des fonctions où elles sont utilisées. Mais au moins p 163 et p 187, ce n'est pas le cas. (C'est légèrement mieux que dans mon souvenir, je n'ai pas trouvé de cas avec des fonctions de la lib standard et je pensais qu'il y en avait; mais je n'ai pas tout regardé non plus).
A+
-- Jean-Marc FAQ de fclc: http://www.levenez.com/lang/c/faq Site de usenet-fr: http://www.usenet-fr.news.eu.org
Erwan David <erwan@rail.eu.org> writes:
Résumons, le premier est correct, le deuxième est une forme batarde
entre la verion d'avant la normalisation et celle d'après
Ce qui ne la rend pas fausse.
Tu as certainement une version préhistorique du K&R, qui parle de la
version pré-normalisation.
J'ai la 41ième impression datée de décembre 2006 de la deuxième édition,
celle qui a un tampon rouge "ANSI C" dessus. J'avais une impression
antérieure que je ne retrouve plus, mais je suis certain n'avoir jamais
possédé de première édition, j'ai commencé le C suffisemment tôt pour
m'être frotté à du code K&R mais trop tard pour acheter autre chose que la
deuxième édition.
Je ne dis pas que main n'est pas parfois défini autrement que
main() { ... }
mais je viens de regarder, je n'ai pas vu de cas (ce qui est pire que dans
mon souvenir, je croyais qu'ils avaient modifiés au moins les premières
occurences). J'ai par contre compté 17 occurences de main défini comme
ci-dessus.
Les fonctions sont généralement déclarées en dehors des fonctions où elles
sont utilisées. Mais au moins p 163 et p 187, ce n'est pas le cas. (C'est
légèrement mieux que dans mon souvenir, je n'ai pas trouvé de cas avec des
fonctions de la lib standard et je pensais qu'il y en avait; mais je n'ai
pas tout regardé non plus).
A+
--
Jean-Marc
FAQ de fclc: http://www.levenez.com/lang/c/faq
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Résumons, le premier est correct, le deuxième est une forme batarde entre la verion d'avant la normalisation et celle d'après
Ce qui ne la rend pas fausse.
Tu as certainement une version préhistorique du K&R, qui parle de la version pré-normalisation.
J'ai la 41ième impression datée de décembre 2006 de la deuxième édition, celle qui a un tampon rouge "ANSI C" dessus. J'avais une impression antérieure que je ne retrouve plus, mais je suis certain n'avoir jamais possédé de première édition, j'ai commencé le C suffisemment tôt pour m'être frotté à du code K&R mais trop tard pour acheter autre chose que la deuxième édition.
Je ne dis pas que main n'est pas parfois défini autrement que
main() { ... }
mais je viens de regarder, je n'ai pas vu de cas (ce qui est pire que dans mon souvenir, je croyais qu'ils avaient modifiés au moins les premières occurences). J'ai par contre compté 17 occurences de main défini comme ci-dessus.
Les fonctions sont généralement déclarées en dehors des fonctions où elles sont utilisées. Mais au moins p 163 et p 187, ce n'est pas le cas. (C'est légèrement mieux que dans mon souvenir, je n'ai pas trouvé de cas avec des fonctions de la lib standard et je pensais qu'il y en avait; mais je n'ai pas tout regardé non plus).
A+
-- Jean-Marc FAQ de fclc: http://www.levenez.com/lang/c/faq Site de usenet-fr: http://www.usenet-fr.news.eu.org
Jean-Marc Bourguet
(Marc Espie) writes:
In article , Jean-Marc Bourguet wrote:
Erwan David writes:
Stephane Legras-Decussy écrivait :
Le 24/08/2012 22:19, Tonton Th a écrit :
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...] 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 [...]): int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
^^^^^^^^^^^^^
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant de l'implementation...
int main() est équivalent à int main(void) pour ce qui concerne la définition. (C'est l'aspect déclaration qui est différent). Si tu penses que le *or equivalent* ne concerne que la deuxième forme, il me faut savoir quel est ton raisonnement et pourquoi main serait un cas particulier sur ce point.
A+
-- Jean-Marc FAQ de fclc: http://www.levenez.com/lang/c/faq Site de usenet-fr: http://www.usenet-fr.news.eu.org
espie@lain.home (Marc Espie) writes:
In article <87wr0mopll.fsf@news.bourguet.org>,
Jean-Marc Bourguet <jm@bourguet.org> wrote:
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par
int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...]
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 [...]):
int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
^^^^^^^^^^^^^
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant
de l'implementation...
int main() est équivalent à int main(void) pour ce qui concerne la
définition. (C'est l'aspect déclaration qui est différent). Si tu penses
que le *or equivalent* ne concerne que la deuxième forme, il me faut savoir
quel est ton raisonnement et pourquoi main serait un cas particulier sur ce
point.
A+
--
Jean-Marc
FAQ de fclc: http://www.levenez.com/lang/c/faq
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...] 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 [...]): int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
^^^^^^^^^^^^^
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant de l'implementation...
int main() est équivalent à int main(void) pour ce qui concerne la définition. (C'est l'aspect déclaration qui est différent). Si tu penses que le *or equivalent* ne concerne que la deuxième forme, il me faut savoir quel est ton raisonnement et pourquoi main serait un cas particulier sur ce point.
A+
-- Jean-Marc FAQ de fclc: http://www.levenez.com/lang/c/faq Site de usenet-fr: http://www.usenet-fr.news.eu.org
espie
In article , Jean-Marc Bourguet wrote:
(Marc Espie) writes:
In article , Jean-Marc Bourguet wrote:
Erwan David writes:
Stephane Legras-Decussy écrivait :
Le 24/08/2012 22:19, Tonton Th a écrit :
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...] 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 [...]): int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
^^^^^^^^^^^^^
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant de l'implementation...
int main() est équivalent à int main(void) pour ce qui concerne la définition. (C'est l'aspect déclaration qui est différent). Si tu penses que le *or equivalent* ne concerne que la deuxième forme, il me faut savoir quel est ton raisonnement et pourquoi main serait un cas particulier sur ce point.
Le "or equivalent" est explicite par une note de bas de page, qui indique que c'est l'utilisation d'un type equivalent a int, ou d'une declaration equivalente de char *argv[] qui peut etre presente...
In article <87ipc6omq9.fsf@news.bourguet.org>,
Jean-Marc Bourguet <jm@bourguet.org> wrote:
espie@lain.home (Marc Espie) writes:
In article <87wr0mopll.fsf@news.bourguet.org>,
Jean-Marc Bourguet <jm@bourguet.org> wrote:
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par
int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...]
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 [...]):
int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
^^^^^^^^^^^^^
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant
de l'implementation...
int main() est équivalent à int main(void) pour ce qui concerne la
définition. (C'est l'aspect déclaration qui est différent). Si tu penses
que le *or equivalent* ne concerne que la deuxième forme, il me faut savoir
quel est ton raisonnement et pourquoi main serait un cas particulier sur ce
point.
Le "or equivalent" est explicite par une note de bas de page, qui indique
que c'est l'utilisation d'un type equivalent a int, ou d'une declaration
equivalente de char *argv[] qui peut etre presente...
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...] 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 [...]): int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
^^^^^^^^^^^^^
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant de l'implementation...
int main() est équivalent à int main(void) pour ce qui concerne la définition. (C'est l'aspect déclaration qui est différent). Si tu penses que le *or equivalent* ne concerne que la deuxième forme, il me faut savoir quel est ton raisonnement et pourquoi main serait un cas particulier sur ce point.
Le "or equivalent" est explicite par une note de bas de page, qui indique que c'est l'utilisation d'un type equivalent a int, ou d'une declaration equivalente de char *argv[] qui peut etre presente...
Jean-Marc Bourguet
(Marc Espie) writes:
In article , Jean-Marc Bourguet wrote:
(Marc Espie) writes:
In article , Jean-Marc Bourguet wrote:
Erwan David writes:
Stephane Legras-Decussy écrivait :
Le 24/08/2012 22:19, Tonton Th a écrit :
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...] 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 [...]): int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
^^^^^^^^^^^^^
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant de l'implementation...
int main() est équivalent à int main(void) pour ce qui concerne la définition. (C'est l'aspect déclaration qui est différent). Si tu penses que le *or equivalent* ne concerne que la deuxième forme, il me faut savoir quel est ton raisonnement et pourquoi main serait un cas particulier sur ce point.
Le "or equivalent" est explicite par une note de bas de page, qui indique que c'est l'utilisation d'un type equivalent a int, ou d'une declaration equivalente de char *argv[] qui peut etre presente...
Qu'est-ce qui te fait penser que le "and so on" de la note exclus `int main() {}` comme définition équivalente à `int main(void) {}` alors que c'est le cas pour toutes les autre fonctions?
A+
-- Jean-Marc FAQ de fclc: http://www.levenez.com/lang/c/faq Site de usenet-fr: http://www.usenet-fr.news.eu.org
espie@lain.home (Marc Espie) writes:
In article <87ipc6omq9.fsf@news.bourguet.org>,
Jean-Marc Bourguet <jm@bourguet.org> wrote:
espie@lain.home (Marc Espie) writes:
In article <87wr0mopll.fsf@news.bourguet.org>,
Jean-Marc Bourguet <jm@bourguet.org> wrote:
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par
int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...]
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 [...]):
int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
^^^^^^^^^^^^^
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant
de l'implementation...
int main() est équivalent à int main(void) pour ce qui concerne la
définition. (C'est l'aspect déclaration qui est différent). Si tu penses
que le *or equivalent* ne concerne que la deuxième forme, il me faut savoir
quel est ton raisonnement et pourquoi main serait un cas particulier sur ce
point.
Le "or equivalent" est explicite par une note de bas de page, qui indique
que c'est l'utilisation d'un type equivalent a int, ou d'une declaration
equivalente de char *argv[] qui peut etre presente...
Qu'est-ce qui te fait penser que le "and so on" de la note exclus `int
main() {}` comme définition équivalente à `int main(void) {}` alors que
c'est le cas pour toutes les autre fonctions?
A+
--
Jean-Marc
FAQ de fclc: http://www.levenez.com/lang/c/faq
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Qui contient un certain nombre d'approximations assez douteuses...
c'est mieux que d'être dégouté et d'abandonner.
EN quoi est-il plus simple de faire commencer le hello world par int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
Référence, SVP.
ISO/IEC 9899:1999
5.1.2.2.1 Program startup
The function called at program startup is name main [...] 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 [...]): int main(int argc, char *argv[]) { /* ... */ }
or equivalent, or in SOME OTHER IMPLEMENTATION-DEFINED MANNER.
^^^^^^^^^^^^^
(emphase mienne).
tu as donc deux facons de declarer main() conformes. Le reste est dependant de l'implementation...
int main() est équivalent à int main(void) pour ce qui concerne la définition. (C'est l'aspect déclaration qui est différent). Si tu penses que le *or equivalent* ne concerne que la deuxième forme, il me faut savoir quel est ton raisonnement et pourquoi main serait un cas particulier sur ce point.
Le "or equivalent" est explicite par une note de bas de page, qui indique que c'est l'utilisation d'un type equivalent a int, ou d'une declaration equivalente de char *argv[] qui peut etre presente...
Qu'est-ce qui te fait penser que le "and so on" de la note exclus `int main() {}` comme définition équivalente à `int main(void) {}` alors que c'est le cas pour toutes les autre fonctions?
A+
-- Jean-Marc FAQ de fclc: http://www.levenez.com/lang/c/faq Site de usenet-fr: http://www.usenet-fr.news.eu.org
Tonton Th
On 08/25/2012 01:24 PM, Stephane Legras-Decussy wrote:
EN quoi est-il plus simple de faire commencer le hello world par int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
parce qu'il faudrait expliquer "void" qui est très compliqué quand on est seulement à ce niveau du cours.
Peut-être est-ce toi qui n'arrive pas à comprendre...
en pratique, cette absence de void, ça va provoquer quoi ?
Une insulte du compilateur ?
--
Nous vivons dans un monde étrange/ http://foo.bar.quux.over-blog.com/
On 08/25/2012 01:24 PM, Stephane Legras-Decussy wrote:
EN quoi est-il plus simple de faire commencer le hello world par
int main(void) plutôt que int main() ?
Le premier est correct, le second utilisé sur le site est faux.
parce qu'il faudrait expliquer "void" qui est très compliqué quand on
est seulement à ce niveau du cours.
Peut-être est-ce toi qui n'arrive pas à comprendre...
en pratique, cette absence de void, ça va provoquer quoi ?
Une insulte du compilateur ?
--
Nous vivons dans un monde étrange/
http://foo.bar.quux.over-blog.com/
Peut-être est-ce toi qui n'arrive pas à comprendre...
simplement je me souviens parfaitement de ma 1ère minute confronté au C, j'avais 15 ans en 87 ... void ça faisait pas envie esthétiquement ...
en pratique, cette absence de void, ça va provoquer quoi ?
Une insulte du compilateur ?
excellent, très formateur les warning, ce sera son 1er et pas son dernier ...
Stephane Legras-Decussy
Le 25/08/2012 13:56, Marc Espie a écrit :
Autant ne pas rentrer trop dans les details, je comprend, autant remplacer du code correct et pas plus complique par du code qui ne marche que sur certaines machines, c'est un peu cretin...
je serais curieux d'un exemple réel de machine où int main() ne marche pas ...
le site du zéro n'est pas parfait mais c'est ce que se fait de mieux dans le genre sympathique.
mon 1er cours d'info en fac, polycopié de 200 pages hyper dense police courrier sur le Scheme. Probablement hyper exact et rigoureux.
45 étudiants le 1er cours, 5 étudiants au 2ème.
on dira ce qu'on voudra sur ce document, c'est un echec.
Le 25/08/2012 13:56, Marc Espie a écrit :
Autant ne pas rentrer trop dans les details, je comprend, autant remplacer
du code correct et pas plus complique par du code qui ne marche que sur
certaines machines, c'est un peu cretin...
je serais curieux d'un exemple réel de machine où int main() ne
marche pas ...
le site du zéro n'est pas parfait mais c'est ce que se fait
de mieux dans le genre sympathique.
mon 1er cours d'info en fac, polycopié de 200 pages hyper dense
police courrier sur le Scheme. Probablement hyper exact et rigoureux.
45 étudiants le 1er cours, 5 étudiants au 2ème.
on dira ce qu'on voudra sur ce document, c'est un echec.
Autant ne pas rentrer trop dans les details, je comprend, autant remplacer du code correct et pas plus complique par du code qui ne marche que sur certaines machines, c'est un peu cretin...
je serais curieux d'un exemple réel de machine où int main() ne marche pas ...
le site du zéro n'est pas parfait mais c'est ce que se fait de mieux dans le genre sympathique.
mon 1er cours d'info en fac, polycopié de 200 pages hyper dense police courrier sur le Scheme. Probablement hyper exact et rigoureux.
45 étudiants le 1er cours, 5 étudiants au 2ème.
on dira ce qu'on voudra sur ce document, c'est un echec.
Jean-Marc Bourguet
Tonton Th writes:
en pratique, cette absence de void, ça va provoquer quoi ?
Une insulte du compilateur ?
Sur quelle base? La seule que je vois ce sont des warnings demandant spécifiquement à vérifier des choix stylistiques (genre Wstrict-prototypes, -Wold-style-definition avec gcc). C'est pas que je ne les recommanderais pas aux débutants (bien au contraire, si je donnais un cours ils auraient à trafiquer pour ne pas les utiliser), c'est que c'est stylistique et sans effet sur main.
A+
-- Jean-Marc FAQ de fclc: http://www.levenez.com/lang/c/faq Site de usenet-fr: http://www.usenet-fr.news.eu.org
Tonton Th <tth@la.bas.invalid> writes:
en pratique, cette absence de void, ça va provoquer quoi ?
Une insulte du compilateur ?
Sur quelle base? La seule que je vois ce sont des warnings demandant
spécifiquement à vérifier des choix stylistiques (genre Wstrict-prototypes,
-Wold-style-definition avec gcc). C'est pas que je ne les recommanderais
pas aux débutants (bien au contraire, si je donnais un cours ils auraient à
trafiquer pour ne pas les utiliser), c'est que c'est stylistique et sans
effet sur main.
A+
--
Jean-Marc
FAQ de fclc: http://www.levenez.com/lang/c/faq
Site de usenet-fr: http://www.usenet-fr.news.eu.org
en pratique, cette absence de void, ça va provoquer quoi ?
Une insulte du compilateur ?
Sur quelle base? La seule que je vois ce sont des warnings demandant spécifiquement à vérifier des choix stylistiques (genre Wstrict-prototypes, -Wold-style-definition avec gcc). C'est pas que je ne les recommanderais pas aux débutants (bien au contraire, si je donnais un cours ils auraient à trafiquer pour ne pas les utiliser), c'est que c'est stylistique et sans effet sur main.
A+
-- Jean-Marc FAQ de fclc: http://www.levenez.com/lang/c/faq Site de usenet-fr: http://www.usenet-fr.news.eu.org
