un tableau, est un pointeur sur son 1er élément, car sa valeur est l'adresse
de ce 1er élément...
donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
que contient &tableau ? je dirais comme ça... bah l'adresse de tableau, qui
est différente de la valeur de tableau (qui est l'adresse du 1er élément )
donc pour simplifier, je me rammène au cas d'un pointeur sur int...
int a;
int *ptr;
ptr=&a;
là, ptr contient &a, et l'adresse de ptr est &ptr. cette adresse &ptr est
différente de &a.
alors comment explique - t-on le code suivant ???
#include <stdio.h>
int main(void)
{
int tableau[10];
printf("%p == %p ?\n", &tableau, &tableau[0]);
int a;
int *ptr;
ptr=&a;
printf("%p == %p ?\n",&a , &ptr);
getchar();
return 0;
}
ce code me montre que j'ai raison pour le pointeur sur a, mais tord pour le
tableau, ça m'affiche la même adresse, qui m'explique, parce que là je
trouve ça vraiment louche !!!
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Jean-Marc Bourguet
"Nicolas aunai" @free.fr> writes:
un tableau, est un pointeur sur son 1er élément, car sa valeur est l'adresse de ce 1er élément...
Depuis quand? Il est des contextes ou un tableau a une conversion implicite en un pointeur vers le premier element, mais confondre les deux est sources de problemes. Par exemple, que vaut sizeof(tableau)?
donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
Non, tableau designe tout le tableau. Il est des contextes ou il se transforme en un pointeur vers le premier element.
que contient &tableau ?
Un pointeur vers le tableau, qui commence par le premier element, donc l'adresse est la meme (mais pas le type).
je dirais comme ça... bah l'adresse de tableau, qui est différente de la valeur de tableau (qui est l'adresse du 1er élément )
L'adresse du premier element est l'adresse du tableau.
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
un tableau, est un pointeur sur son 1er élément, car sa valeur est
l'adresse de ce 1er élément...
Depuis quand? Il est des contextes ou un tableau a une conversion
implicite en un pointeur vers le premier element, mais confondre les
deux est sources de problemes. Par exemple, que vaut sizeof(tableau)?
donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
Non, tableau designe tout le tableau. Il est des contextes ou il se
transforme en un pointeur vers le premier element.
que contient &tableau ?
Un pointeur vers le tableau, qui commence par le premier element, donc
l'adresse est la meme (mais pas le type).
je dirais comme ça... bah l'adresse de tableau, qui est différente
de la valeur de tableau (qui est l'adresse du 1er élément )
L'adresse du premier element est l'adresse du tableau.
--
Jean-Marc
FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc
Site de usenet-fr: http://www.usenet-fr.news.eu.org
un tableau, est un pointeur sur son 1er élément, car sa valeur est l'adresse de ce 1er élément...
Depuis quand? Il est des contextes ou un tableau a une conversion implicite en un pointeur vers le premier element, mais confondre les deux est sources de problemes. Par exemple, que vaut sizeof(tableau)?
donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
Non, tableau designe tout le tableau. Il est des contextes ou il se transforme en un pointeur vers le premier element.
que contient &tableau ?
Un pointeur vers le tableau, qui commence par le premier element, donc l'adresse est la meme (mais pas le type).
je dirais comme ça... bah l'adresse de tableau, qui est différente de la valeur de tableau (qui est l'adresse du 1er élément )
L'adresse du premier element est l'adresse du tableau.
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
Bruno Desthuilliers
Nicolas aunai wrote:
bon
un tableau, est un pointeur
constant !
sur son 1er élément, car sa valeur est l'adresse de ce 1er élément...
admettons...
donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
que contient &tableau ?
&tableau == &tableau[0]
L'adresse de tableau est l'adresse du premier élément de tableau. Les adresses des éléments suivants s'obtiennent facilement à partir de l'adresse du premier élément et de la taille du type de variable.
je dirais comme ça... bah l'adresse de tableau, qui est différente de la valeur de tableau (qui est l'adresse du 1er élément )
Pourquoi l'adresse de tableau serait-elle différente de celle du premier élément. Relis ce que tu dis toi-même plus haut...
donc pour simplifier, je me rammène au cas d'un pointeur sur int...
int a; int *ptr;
ptr=&a;
là, ptr contient &a, et l'adresse de ptr est &ptr. cette adresse &ptr est différente de &a.
alors comment explique - t-on le code suivant ???
#include <stdio.h>
int main(void) { int tableau[10];
printf("%p == %p ?n", &tableau, &tableau[0]); int a; int *ptr; ptr=&a;
printf("%p == %p ?n",&a , &ptr);
getchar(); return 0; }
ce code me montre que j'ai raison pour le pointeur sur a, mais tord pour le tableau, ça m'affiche la même adresse, qui m'explique, parce que là je trouve ça vraiment louche !!!
Tu t'es emmelé les pinceaux dans ta réflexion, en supposant a priori et par principe que l'adresse du tableau devait être différente de celle du premier élément du tableau. Ton code te démontre le contraire.
Bruno
Nicolas aunai wrote:
bon
un tableau, est un pointeur
constant !
sur son 1er élément, car sa valeur est l'adresse
de ce 1er élément...
admettons...
donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
que contient &tableau ?
&tableau == &tableau[0]
L'adresse de tableau est l'adresse du premier élément de tableau. Les
adresses des éléments suivants s'obtiennent facilement à partir de
l'adresse du premier élément et de la taille du type de variable.
je dirais comme ça... bah l'adresse de tableau, qui
est différente de la valeur de tableau (qui est l'adresse du 1er élément )
Pourquoi l'adresse de tableau serait-elle différente de celle du premier
élément. Relis ce que tu dis toi-même plus haut...
donc pour simplifier, je me rammène au cas d'un pointeur sur int...
int a;
int *ptr;
ptr=&a;
là, ptr contient &a, et l'adresse de ptr est &ptr. cette adresse &ptr est
différente de &a.
alors comment explique - t-on le code suivant ???
#include <stdio.h>
int main(void)
{
int tableau[10];
printf("%p == %p ?n", &tableau, &tableau[0]);
int a;
int *ptr;
ptr=&a;
printf("%p == %p ?n",&a , &ptr);
getchar();
return 0;
}
ce code me montre que j'ai raison pour le pointeur sur a, mais tord pour le
tableau, ça m'affiche la même adresse, qui m'explique, parce que là je
trouve ça vraiment louche !!!
Tu t'es emmelé les pinceaux dans ta réflexion, en supposant a priori et
par principe que l'adresse du tableau devait être différente de celle du
premier élément du tableau. Ton code te démontre le contraire.
sur son 1er élément, car sa valeur est l'adresse de ce 1er élément...
admettons...
donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
que contient &tableau ?
&tableau == &tableau[0]
L'adresse de tableau est l'adresse du premier élément de tableau. Les adresses des éléments suivants s'obtiennent facilement à partir de l'adresse du premier élément et de la taille du type de variable.
je dirais comme ça... bah l'adresse de tableau, qui est différente de la valeur de tableau (qui est l'adresse du 1er élément )
Pourquoi l'adresse de tableau serait-elle différente de celle du premier élément. Relis ce que tu dis toi-même plus haut...
donc pour simplifier, je me rammène au cas d'un pointeur sur int...
int a; int *ptr;
ptr=&a;
là, ptr contient &a, et l'adresse de ptr est &ptr. cette adresse &ptr est différente de &a.
alors comment explique - t-on le code suivant ???
#include <stdio.h>
int main(void) { int tableau[10];
printf("%p == %p ?n", &tableau, &tableau[0]); int a; int *ptr; ptr=&a;
printf("%p == %p ?n",&a , &ptr);
getchar(); return 0; }
ce code me montre que j'ai raison pour le pointeur sur a, mais tord pour le tableau, ça m'affiche la même adresse, qui m'explique, parce que là je trouve ça vraiment louche !!!
Tu t'es emmelé les pinceaux dans ta réflexion, en supposant a priori et par principe que l'adresse du tableau devait être différente de celle du premier élément du tableau. Ton code te démontre le contraire.
Bruno
Emmanuel Delahaye
In 'fr.comp.lang.c', "Nicolas aunai" @free.fr> wrote:
un tableau, est un pointeur sur son 1er élément, car sa valeur est
Non. Un tableau n'est pas un pointeur, un pointeur n'est pas un tableau.
Tout ce qu'on peut dire, c'est que l'adresse d'un tableau est la même que l'adresse de son premier élément.
char s[] ="Hello"; char *p = s;
s peut s'écrire s + 0.
l'élément en s + 0 est *(s + 0), ce qui s'écrit aussi s[0].
Donc, ici, p contient s + 0, soit s.
Pour accéder à un element avec p, on peut faire
*(p + 2), ce qui s'écrit aussi p[2].
Le nom d'un tableau est une adresse constante (on dit aussi un pointeur constant). On ne peut pas faire s++, ou s = "hello"; (hors initialisation).
Un pointeur comme p est une variable que l'on peut modifier comme n'importe quelle variable :
p = "hello";
p++;
etc.
l'adresse de ce 1er élément... donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
'tableau' est une constante. Une constante a une valeur mais ne contient rien. Une variable peut contenir quelquechose, pas une constante. Une constante n'a pas d'adresse.
que contient &tableau ? je dirais comme ça... bah l'adresse de tableau, qui est différente de la valeur de tableau (qui est l'adresse du 1er élément )
Comme &fonction. C'est un & superflu, car l'objet nommé est déjà un pointeur constant.
On peut néanmoins s'en servir pour initialiser un pointeur de type tableau :
int (*pa)[10] = tableau. /* erreur de type */ int (*pb)[10] = &tableau. /* correct */
main.c: In function `main': main.c:9: warning: initialization from incompatible pointer type main.c:9: warning: unused variable `pa' main.c:10: warning: unused variable `pb'
donc pour simplifier, je me rammène au cas d'un pointeur sur int...
int a; int *ptr;
ptr=&a;
Ok.
là, ptr contient &a, et l'adresse de ptr est &ptr. cette adresse &ptr est différente de &a.
ce code me montre que j'ai raison pour le pointeur sur a, mais tord pour le tableau, ça m'affiche la même adresse, qui m'explique, parce que là je trouve ça vraiment louche !!!
Parce qu'on se tue à te répeter qu'un pointeur et un tableau ne sont pas la même chose.
Par exemple, le sizeof d'un tableau ne donne pas la même chose que le sizeof d'un pointeur sur le même objet.
Un tableau est une construction agrégée aux propriétés bien particulières. Un pointeur est une simple variable.
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', "Nicolas aunai" <nicolas.aunai@nospam@free.fr> wrote:
un tableau, est un pointeur sur son 1er élément, car sa valeur est
Non. Un tableau n'est pas un pointeur, un pointeur n'est pas un tableau.
Tout ce qu'on peut dire, c'est que l'adresse d'un tableau est la même que
l'adresse de son premier élément.
char s[] ="Hello";
char *p = s;
s peut s'écrire s + 0.
l'élément en s + 0 est *(s + 0), ce qui s'écrit aussi s[0].
Donc, ici, p contient s + 0, soit s.
Pour accéder à un element avec p, on peut faire
*(p + 2), ce qui s'écrit aussi p[2].
Le nom d'un tableau est une adresse constante (on dit aussi un pointeur
constant). On ne peut pas faire s++, ou s = "hello"; (hors initialisation).
Un pointeur comme p est une variable que l'on peut modifier comme n'importe
quelle variable :
p = "hello";
p++;
etc.
l'adresse de ce 1er élément...
donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
'tableau' est une constante. Une constante a une valeur mais ne contient
rien. Une variable peut contenir quelquechose, pas une constante. Une
constante n'a pas d'adresse.
que contient &tableau ? je dirais comme ça... bah l'adresse de tableau,
qui est différente de la valeur de tableau (qui est l'adresse du 1er
élément )
Comme &fonction. C'est un & superflu, car l'objet nommé est déjà un pointeur
constant.
On peut néanmoins s'en servir pour initialiser un pointeur de type tableau :
int (*pa)[10] = tableau. /* erreur de type */
int (*pb)[10] = &tableau. /* correct */
main.c: In function `main':
main.c:9: warning: initialization from incompatible pointer type
main.c:9: warning: unused variable `pa'
main.c:10: warning: unused variable `pb'
donc pour simplifier, je me rammène au cas d'un pointeur sur int...
int a;
int *ptr;
ptr=&a;
Ok.
là, ptr contient &a, et l'adresse de ptr est &ptr. cette adresse &ptr
est différente de &a.
ce code me montre que j'ai raison pour le pointeur sur a, mais tord pour
le tableau, ça m'affiche la même adresse, qui m'explique, parce que là
je trouve ça vraiment louche !!!
Parce qu'on se tue à te répeter qu'un pointeur et un tableau ne sont pas la
même chose.
Par exemple, le sizeof d'un tableau ne donne pas la même chose que le sizeof
d'un pointeur sur le même objet.
Un tableau est une construction agrégée aux propriétés bien particulières. Un
pointeur est une simple variable.
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', "Nicolas aunai" @free.fr> wrote:
un tableau, est un pointeur sur son 1er élément, car sa valeur est
Non. Un tableau n'est pas un pointeur, un pointeur n'est pas un tableau.
Tout ce qu'on peut dire, c'est que l'adresse d'un tableau est la même que l'adresse de son premier élément.
char s[] ="Hello"; char *p = s;
s peut s'écrire s + 0.
l'élément en s + 0 est *(s + 0), ce qui s'écrit aussi s[0].
Donc, ici, p contient s + 0, soit s.
Pour accéder à un element avec p, on peut faire
*(p + 2), ce qui s'écrit aussi p[2].
Le nom d'un tableau est une adresse constante (on dit aussi un pointeur constant). On ne peut pas faire s++, ou s = "hello"; (hors initialisation).
Un pointeur comme p est une variable que l'on peut modifier comme n'importe quelle variable :
p = "hello";
p++;
etc.
l'adresse de ce 1er élément... donc
int tableau[10];
tableau contient &tableau[0]; jusqu'à là c sans mystère.
'tableau' est une constante. Une constante a une valeur mais ne contient rien. Une variable peut contenir quelquechose, pas une constante. Une constante n'a pas d'adresse.
que contient &tableau ? je dirais comme ça... bah l'adresse de tableau, qui est différente de la valeur de tableau (qui est l'adresse du 1er élément )
Comme &fonction. C'est un & superflu, car l'objet nommé est déjà un pointeur constant.
On peut néanmoins s'en servir pour initialiser un pointeur de type tableau :
int (*pa)[10] = tableau. /* erreur de type */ int (*pb)[10] = &tableau. /* correct */
main.c: In function `main': main.c:9: warning: initialization from incompatible pointer type main.c:9: warning: unused variable `pa' main.c:10: warning: unused variable `pb'
donc pour simplifier, je me rammène au cas d'un pointeur sur int...
int a; int *ptr;
ptr=&a;
Ok.
là, ptr contient &a, et l'adresse de ptr est &ptr. cette adresse &ptr est différente de &a.
ce code me montre que j'ai raison pour le pointeur sur a, mais tord pour le tableau, ça m'affiche la même adresse, qui m'explique, parce que là je trouve ça vraiment louche !!!
Parce qu'on se tue à te répeter qu'un pointeur et un tableau ne sont pas la même chose.
Par exemple, le sizeof d'un tableau ne donne pas la même chose que le sizeof d'un pointeur sur le même objet.
Un tableau est une construction agrégée aux propriétés bien particulières. Un pointeur est une simple variable.
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
un tableau, est un pointeur sur son 1er élément, car sa valeur est l'adresse de ce 1er élément...
C'est faux - et c'est la source de beaucoup de mésentendus.
Un tableau n'*est* pas un pointeur sur son premier élément. Il se *comporte* (sauf dans les expressions &tab et sizeof tab) comme un pointeur vers le premier élément du tableau. Ce sont justement les exceptions mentionnées qui rendent le nom d'un tableau différent d'une variable du type pointeur qui pointe vers le premier élément du tableau.
Après
int tab[10]; int * p = tab;
on peut remplacer 'tab' par 'p' et 'p' par 'tab' - sauf dans sizeof ... ou &...
un tableau, est un pointeur sur son 1er élément, car sa valeur est l'adresse
de ce 1er élément...
C'est faux - et c'est la source de beaucoup de mésentendus.
Un tableau n'*est* pas un pointeur sur son premier élément. Il se
*comporte* (sauf dans les expressions &tab et sizeof tab) comme un
pointeur vers le premier élément du tableau. Ce sont justement les
exceptions mentionnées qui rendent le nom d'un tableau différent d'une
variable du type pointeur qui pointe vers le premier élément du
tableau.
Après
int tab[10];
int * p = tab;
on peut remplacer 'tab' par 'p' et 'p' par 'tab' - sauf dans sizeof
... ou &...
un tableau, est un pointeur sur son 1er élément, car sa valeur est l'adresse de ce 1er élément...
C'est faux - et c'est la source de beaucoup de mésentendus.
Un tableau n'*est* pas un pointeur sur son premier élément. Il se *comporte* (sauf dans les expressions &tab et sizeof tab) comme un pointeur vers le premier élément du tableau. Ce sont justement les exceptions mentionnées qui rendent le nom d'un tableau différent d'une variable du type pointeur qui pointe vers le premier élément du tableau.
Après
int tab[10]; int * p = tab;
on peut remplacer 'tab' par 'p' et 'p' par 'tab' - sauf dans sizeof ... ou &...
