Quand on d=E9clare une fonction main comme ceci:
int main (int argc, char *argv[])
*argv[], repr=E9sente un tableau dont chaque =E9l=E9ment est un pointeur
vers une chaine de caract=E8re.
Je ne comprends pas pourquoi alors on acc=E8de =E0 la valeur de chaque
=E9l=E9ment de ce tableau par argv[i] car si chaque =E9l=E9ment est un
pointeur, il faut utiliser une * pour avoir la vlaeur de ce pointeur
non?
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère.
Oui.
Je ne comprends pas pourquoi alors on accède à la valeur de chaque élément de ce tableau par argv[i] car si chaque élément est un pointeur, il faut utiliser une * pour avoir la vlaeur de ce pointeur non?
On peut mais c'est compliqué.
*(arg + i)
Le C offre l'alternative 'index' (/subscript/ ou []) qui simplifie énormément l'écriture.
argv[i]
Quand on déclare une fonction main comme ceci:
définit...
http://mapage.noos.fr/emdel/notes.htm#definitions
int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur
vers une chaine de caractère.
Oui.
Je ne comprends pas pourquoi alors on accède à la valeur de chaque
élément de ce tableau par argv[i] car si chaque élément est un
pointeur, il faut utiliser une * pour avoir la vlaeur de ce pointeur
non?
On peut mais c'est compliqué.
*(arg + i)
Le C offre l'alternative 'index' (/subscript/ ou []) qui simplifie
énormément l'écriture.
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère.
Oui.
Je ne comprends pas pourquoi alors on accède à la valeur de chaque élément de ce tableau par argv[i] car si chaque élément est un pointeur, il faut utiliser une * pour avoir la vlaeur de ce pointeur non?
On peut mais c'est compliqué.
*(arg + i)
Le C offre l'alternative 'index' (/subscript/ ou []) qui simplifie énormément l'écriture.
Quand on déclare une fonction main comme ceci: int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère. *argv[] ne représente mon avis rien de précis, disons une erreur de
syntaxe. Les *argv[n] pour n compris entre 0 et argc - 1 sont de type char et représentent le premier caractère (' ' compris) d'une chaîne. argv[argc] est le pointeur nul, *argv[argc] un crash. Bref, c'est un peu confus.
Dans le cas général: Type Ident[]; déclare que Ident est un tableau de "Type". Vous avez le choix de la position de l'étoile quand Type est un pointeur (choix de style). Ici, et AMHA le plus souvent, l'écriture suivante est plus claire: char* argv[]; argv est un tableau de char*, que vous pouvez prononcer "argvé est un tableau de charétoiles". *Dans le contexte*, vous pouvez faire l'assimilation char* <=> chaîne. Donc argv[n] est la ennième chaîne argument.
Je ne comprends pas pourquoi alors on accède à la valeur de chaque élément de ce tableau par argv[i] car si chaque élément est un pointeur, il faut utiliser une * pour avoir la vlaeur de ce pointeur non? Non. argv[i] *est* la valeur du pointeur, c'est à dire ce qu'il faut
fournir à une fonction qui attend une chaîne: printf("%sn", argv[0]); Mais aussi: printf("La chaine: %sn", argv[0]); printf("Adresse de la chaine: %pn", argv[0]); printf("Premier caractère de la chaine: %cn", *argv[0]);
-- Pierre Maurette
Bonjour,
Quand on déclare une fonction main comme ceci:
int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur
vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de
syntaxe.
Les *argv[n] pour n compris entre 0 et argc - 1 sont de type char et
représentent le premier caractère (' ' compris) d'une chaîne.
argv[argc] est le pointeur nul, *argv[argc] un crash. Bref, c'est un
peu confus.
Dans le cas général:
Type Ident[];
déclare que Ident est un tableau de "Type".
Vous avez le choix de la position de l'étoile quand Type est un
pointeur (choix de style). Ici, et AMHA le plus souvent, l'écriture
suivante est plus claire:
char* argv[];
argv est un tableau de char*, que vous pouvez prononcer "argvé est un
tableau de charétoiles".
*Dans le contexte*, vous pouvez faire l'assimilation char* <=> chaîne.
Donc argv[n] est la ennième chaîne argument.
Je ne comprends pas pourquoi alors on accède à la valeur de chaque
élément de ce tableau par argv[i] car si chaque élément est un
pointeur, il faut utiliser une * pour avoir la vlaeur de ce pointeur
non?
Non. argv[i] *est* la valeur du pointeur, c'est à dire ce qu'il faut
fournir à une fonction qui attend une chaîne:
printf("%sn", argv[0]);
Mais aussi:
printf("La chaine: %sn", argv[0]);
printf("Adresse de la chaine: %pn", argv[0]);
printf("Premier caractère de la chaine: %cn", *argv[0]);
Quand on déclare une fonction main comme ceci: int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère. *argv[] ne représente mon avis rien de précis, disons une erreur de
syntaxe. Les *argv[n] pour n compris entre 0 et argc - 1 sont de type char et représentent le premier caractère (' ' compris) d'une chaîne. argv[argc] est le pointeur nul, *argv[argc] un crash. Bref, c'est un peu confus.
Dans le cas général: Type Ident[]; déclare que Ident est un tableau de "Type". Vous avez le choix de la position de l'étoile quand Type est un pointeur (choix de style). Ici, et AMHA le plus souvent, l'écriture suivante est plus claire: char* argv[]; argv est un tableau de char*, que vous pouvez prononcer "argvé est un tableau de charétoiles". *Dans le contexte*, vous pouvez faire l'assimilation char* <=> chaîne. Donc argv[n] est la ennième chaîne argument.
Je ne comprends pas pourquoi alors on accède à la valeur de chaque élément de ce tableau par argv[i] car si chaque élément est un pointeur, il faut utiliser une * pour avoir la vlaeur de ce pointeur non? Non. argv[i] *est* la valeur du pointeur, c'est à dire ce qu'il faut
fournir à une fonction qui attend une chaîne: printf("%sn", argv[0]); Mais aussi: printf("La chaine: %sn", argv[0]); printf("Adresse de la chaine: %pn", argv[0]); printf("Premier caractère de la chaine: %cn", *argv[0]);
-- Pierre Maurette
Emmanuel Delahaye
Quand on déclare une fonction main comme ceci: int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de syntaxe.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
Quand on déclare une fonction main comme ceci:
int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur
vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de
syntaxe.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à
fait valable. char *argv[] est équivallent (à un poil de grenouille
près) à char **argv
Quand on déclare une fonction main comme ceci: int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de syntaxe.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
Pierre Maurette
Quand on déclare une fonction main comme ceci: int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de syntaxe.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. C'est évident, puisque c'est de ça dont on parle. Mais sans le 'char',
*argv[] n'a aucun sens. *argv[n] en a un (voir ma réponse). *argv également, c'est argv[0], un char*.
char *argv[] est équivallent (à un poil de grenouille près) à char **argv Oui. Là, le tableau est parfait.
-- Pierre Maurette
Quand on déclare une fonction main comme ceci:
int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur
vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de
syntaxe.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait
valable.
C'est évident, puisque c'est de ça dont on parle. Mais sans le 'char',
*argv[] n'a aucun sens. *argv[n] en a un (voir ma réponse). *argv
également, c'est argv[0], un char*.
char *argv[] est équivallent (à un poil de grenouille près) à char
**argv
Oui. Là, le tableau est parfait.
Quand on déclare une fonction main comme ceci: int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de syntaxe.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. C'est évident, puisque c'est de ça dont on parle. Mais sans le 'char',
*argv[] n'a aucun sens. *argv[n] en a un (voir ma réponse). *argv également, c'est argv[0], un char*.
char *argv[] est équivallent (à un poil de grenouille près) à char **argv Oui. Là, le tableau est parfait.
-- Pierre Maurette
Harpo
Emmanuel Delahaye wrote:
Quand on déclare une fonction main comme ceci: int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de syntaxe.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
D'abord, on dit "KesKiditçuilàlotencore".
Amha, '*argv[]" est, bien qee syntactiqument irréprochable, peu apte à montrer ce qu'est un pointeur, un pointeur sur un pointeur etc. C'est une facilité qyi n'en est pas une, car il n'y a d'équibalence que dans un argument formel d'une fonction. Pour autant que je sache ; void blah( char * blurb[] ) et void blah( char **blurb ) sont équivalentes. Je pense que la première notation entraîne une difficulté parce qu'elle n'est oas traité de la même manière lorsqu'elle est utilisée dans un paramètre formel d'une fonction et dans une définition de variable. Je me rappelle avoir eu beaucoup de mal à comprendre ces notations en apprennant le C, mon esprit était très perturbé, ça a duré au moins 3 jours, je n'y comprennais rien à rien, je pensais que ce langage dépassait mes limites et cherchais même un sabre pas cher our me faire hara-kiri, Je me posais des questions folles ; "est-ce que ce tableau est empilé sur le stack ?" et ce genre de question uui donnent des cauchemars la nuit. Un matin en me rveillant en sueur, j'ai compris que ce n'était qu'une adresse qui était passée.
Je pense que la notation [] hors de la définition de variables est de nature à entraîner des incompréhensions voire même à disturber des débutants.
Emmanuel Delahaye wrote:
Quand on déclare une fonction main comme ceci:
int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur
vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de
syntaxe.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à
fait valable. char *argv[] est équivallent (à un poil de grenouille
près) à char **argv
D'abord, on dit "KesKiditçuilàlotencore".
Amha, '*argv[]" est, bien qee syntactiqument irréprochable, peu apte à
montrer ce qu'est un pointeur, un pointeur sur un pointeur etc.
C'est une facilité qyi n'en est pas une, car il n'y a d'équibalence que
dans un argument formel d'une fonction.
Pour autant que je sache ;
void blah( char * blurb[] )
et
void blah( char **blurb )
sont équivalentes.
Je pense que la première notation entraîne une difficulté parce qu'elle
n'est oas traité de la même manière lorsqu'elle est utilisée dans un
paramètre formel d'une fonction et dans une définition de variable.
Je me rappelle avoir eu beaucoup de mal à comprendre ces notations en
apprennant le C, mon esprit était très perturbé, ça a duré au moins 3
jours, je n'y comprennais rien à rien, je pensais que ce langage
dépassait mes limites et cherchais même un sabre pas cher our me faire
hara-kiri,
Je me posais des questions folles ; "est-ce que ce tableau est empilé
sur le stack ?" et ce genre de question uui donnent des cauchemars la
nuit.
Un matin en me rveillant en sueur, j'ai compris que ce n'était qu'une
adresse qui était passée.
Je pense que la notation [] hors de la définition de variables est de
nature à entraîner des incompréhensions voire même à disturber des
débutants.
Quand on déclare une fonction main comme ceci: int main (int argc, char *argv[])
*argv[], représente un tableau dont chaque élément est un pointeur vers une chaine de caractère.
*argv[] ne représente mon avis rien de précis, disons une erreur de syntaxe.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
D'abord, on dit "KesKiditçuilàlotencore".
Amha, '*argv[]" est, bien qee syntactiqument irréprochable, peu apte à montrer ce qu'est un pointeur, un pointeur sur un pointeur etc. C'est une facilité qyi n'en est pas une, car il n'y a d'équibalence que dans un argument formel d'une fonction. Pour autant que je sache ; void blah( char * blurb[] ) et void blah( char **blurb ) sont équivalentes. Je pense que la première notation entraîne une difficulté parce qu'elle n'est oas traité de la même manière lorsqu'elle est utilisée dans un paramètre formel d'une fonction et dans une définition de variable. Je me rappelle avoir eu beaucoup de mal à comprendre ces notations en apprennant le C, mon esprit était très perturbé, ça a duré au moins 3 jours, je n'y comprennais rien à rien, je pensais que ce langage dépassait mes limites et cherchais même un sabre pas cher our me faire hara-kiri, Je me posais des questions folles ; "est-ce que ce tableau est empilé sur le stack ?" et ce genre de question uui donnent des cauchemars la nuit. Un matin en me rveillant en sueur, j'ai compris que ce n'était qu'une adresse qui était passée.
Je pense que la notation [] hors de la définition de variables est de nature à entraîner des incompréhensions voire même à disturber des débutants.
Emmanuel Delahaye
char *argv[] est équivallent (à un poil de grenouille près) à char **argv
Oui. Là, le tableau est parfait.
Gné ? Quel tableau ?
-- C is a sharp tool
char *argv[] est équivallent (à un poil de grenouille près) à char **argv
char *argv[] est équivallent (à un poil de grenouille près) à char **argv
Oui. Là, le tableau est parfait.
Gné ? Quel tableau ?
-- C is a sharp tool
Djoume SALVETTI
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
C'est quoi ce poil de grenouille, je pensais que c'était strictement équivalent.
-- Djoume SALVETTI
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à
fait valable. char *argv[] est équivallent (à un poil de grenouille
près) à char **argv
C'est quoi ce poil de grenouille, je pensais que c'était strictement
équivalent.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
C'est quoi ce poil de grenouille, je pensais que c'était strictement équivalent.
-- Djoume SALVETTI
Emmanuel Delahaye
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
C'est quoi ce poil de grenouille, je pensais que c'était strictement équivalent.
T'as dejà vu une grenouille avec des poils ?
-- C is a sharp tool
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à
fait valable. char *argv[] est équivallent (à un poil de grenouille
près) à char **argv
C'est quoi ce poil de grenouille, je pensais que c'était strictement
équivalent.
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
C'est quoi ce poil de grenouille, je pensais que c'était strictement équivalent.
T'as dejà vu une grenouille avec des poils ?
-- C is a sharp tool
Emmanuel Delahaye
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
C'est quoi ce poil de grenouille, je pensais que c'était strictement équivalent.
T'as dejà vu une grenouille avec des poils ?
En fait, oui !
avec char **p, on peut ecrire char ** const p ce qui interdit p++;, par exemple, alors qu'avec char *p[], on ne peut pas. Inutile de dire que la première forme a ma préférence pour cette raison...
-- C is a sharp tool
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à
fait valable. char *argv[] est équivallent (à un poil de grenouille
près) à char **argv
C'est quoi ce poil de grenouille, je pensais que c'était strictement
équivalent.
T'as dejà vu une grenouille avec des poils ?
En fait, oui !
avec char **p, on peut ecrire char ** const p ce qui interdit p++;, par
exemple, alors qu'avec char *p[], on ne peut pas. Inutile de dire que la
première forme a ma préférence pour cette raison...
Keskidi ? Dans le contexte d'un parametre, cette notation est tout à fait valable. char *argv[] est équivallent (à un poil de grenouille près) à char **argv
C'est quoi ce poil de grenouille, je pensais que c'était strictement équivalent.
T'as dejà vu une grenouille avec des poils ?
En fait, oui !
avec char **p, on peut ecrire char ** const p ce qui interdit p++;, par exemple, alors qu'avec char *p[], on ne peut pas. Inutile de dire que la première forme a ma préférence pour cette raison...
