Discussion :

[GhostNemo]

Bonjour,
J'ai fait un prgramme test et j'obtiens un résultat bizzare . Je pensais avoir tout bien compris sur les pointeurs ... mais je crois que j'ai encore des ombres xD

Code :

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

1
2
3
4
5
 
int main(){
	char c1[4]="abc";
	printf("l'adresse &c1 = %p soit %u et c1 = %p soit %u et *c1 = %p soit %u soit %c\n",&c1,&c1,c1,c1,*c1,*c1,*c1);
}

et j'obtiens le résultat suivant

l'adresse &c1 =0xbfe3fc54 soit 3219389524 et c1 = 0xbfe3fc54 soit 3219389524 et *c1 = 0x61 soit 97 soit a

Je ne comprend vraiment pas pourquoi j'ai &c1=c1 ... je pensais qu'en délarant c1[4]="abc" je créais un pointeur sur character c1 dans la pile et qu'il lui était attribué l'adresse d'un espace de 4 caractères dans le tas. Donc pour moi je devrais avoir &c1 different de c1.

J'y comprend plus rien xD
j'en perd mon latin ... euh bon ok je parle pas latin xD

[Gruik]

Salux

Je ne comprend vraiment pas pourquoi j'ai &c1=c1 ... je pensais qu'en délarant c1[4]="abc" je créais un pointeur sur character c1 dans la pile et qu'il lui était attribué l'adresse d'un espace de 4 caractères dans le tas. Donc pour moi je devrais avoir &c1 different de c1.

Non non, tout est dans la pile dans ce cas ci.
Un tableau n'est pas un pointeur, c'est juste que quand on le considere comme un pointeur (cast explicite ou implicite), on obtient le pointeur sur le 1er element.

[GhostNemo]

Merci Gruik pour ta réponse.
Mais cependant est-il normal que j'ai &c1=c1?

[GhostNemo]

euh en fait ma question est débile xD évidemment que c'est normal puisque c'est ce que j'obtiens. xD en fait je devrait plutôt dire : ok tout est dans la pile mais je comprends toujours pas pourquoi j'ai &c1=c1

[Emmanuel Delahaye]

Bonjour,
J'ai fait un prgramme test et j'obtiens un résultat bizzare . Je pensais avoir tout bien compris sur les pointeurs ... mais je crois que j'ai encore des ombres

C'est pourtant simple.

Code :

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

	char c1[4] = "abc";

créée un tableau de char initialisé comme suit :

Code :

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

        char c1[] = {'a', 'b', 'c', 0};

dont le nom est c1. La valeur de c1 est l'adresse du premier élément du tableau. Son type est 'tableau de 4 char'. Cette valeur n'est pas modifiable :

Code :

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

   c1 = "xyz"; /* ne compile pas */

Par contre, les éléments de c1 sont des char que l'on peut modifier :

Code :

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

1
2
3
 
   c1[2] = 'y';
   strcpy(c1, "xy");

L'adresse du premier élément de c1, c'est à dire &c1[0] a la même valeur que c1, ce qui est logique, car on peut l'écrire (c1+0), c'est à dire c1.

Par contre, le type de l'adresse du premier élément est char *, puisque l'élément est de type char.

L'adresse du tableau (&c1) a donc la même valeur que l'adresse du premier élément du tableau (donc c1). Par contre, son type est "adresse d'un tableau de 4 char", soit 'char (*)[4]', ce qui entraine une arithmétique de pointeurs très différente..

Code :

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

1
2
3
 
char *pa = c1;
char (*pb)[4] = &c1;

Maintenant, regarde combien valent pa + 1 et pb + 1.

Au fait, pour voir les pointeurs, c'est "%p" avec (void*).

Code :

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

1
2
3
4
5
6
 
   printf ("pa + 0 = %p\n", (void *) (pa + 0));
   printf ("pa + 1 = %p\n", (void *) (pa + 1));
 
   printf ("pb + 0 = %p\n", (void *) (pb + 0));
   printf ("pb + 1 = %p\n", (void *) (pb + 1));

Code :

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

1
2
3
4
5
6
7
 
pa + 0 = 0022FF70
pa + 1 = 0022FF71
pb + 0 = 0022FF70
pb + 1 = 0022FF74
 
Press ENTER to continue.

Tout ceci ne doit pas être confondu avec

Code :

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

   char const *c2 = "abc";

qui est totalement autre chose...

[GhostNemo]

Bonsoir,
Je souhaiterais dire un grand merci à Emmanuel pour sa superbe explication. J'ai compris plein de trucs. Merci notamment le coup du char (*pb)[4] = &c1; qui fait que si j'incrémente de 1 et bien je déplace le pointeur de 4 octets :-)

Mais je ne suis pas bien sûr d'avoir compris cette étape:

L'adresse du premier élément de c1, c'est à dire &c1[0] a la même valeur que c1, ce qui est logique, car on peut l'écrire (c1+0), c'est à dire c1.

Par contre, le type de l'adresse du premier élément est char *, puisque l'élément est de type char.

L'adresse du tableau (&c1) a donc la même valeur que l'adresse du premier élément du tableau (donc c1)

Je ne vois pas bien en quoi le fait que

&c1[0]=c1

et le fait que

le type de l'adresse du premier élément est char *

implique

(&c1) = c1

Je vais tenter d'expliquer ce que j'ai compris et vous me corrigez si c'est faux? ^^

Tout d'abord partons du schéma

Code :

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

1
2
char x='m';
char c1[4]="abc";

&x me donnera 0012BB02. Jusque là rien de nouveau.
et si j'ai bien compris c1 n'est pas un pointeur sur caractère mais un objet de type "tableau de 4 caractères" au même titre que x est un caractère.
Donc quand j'affiche &c1 j'ai 02FF01 (même comportement que pour &x).
(c'est bien cela ? ou j'ai déja faux ? ).

Par contre si je veux afficher "c1" le compilateur fait une conversion automatique du type de c1 (qui est un type talbeau de 4 caractères à l'origine) en un type pointeur sur caractère et lui attribut l'adresse du 1er élément du tableau. Donc 0022FF01 dans le cas de l'exemple.
Et de même avec *c1.

En gros y'a que dans le cas "&c1" où c1 n'est pas converti.

Emmanuel s'il te plaît dis moi si j'ai juste ^^

[Emmanuel Delahaye]

Je ne vois pas bien en quoi le fait que
&c1[0]=c1
et le fait que
le type de l'adresse du premier élément est char *
implique
(&c1) = c1

J'ai peut être oublié de rappeler un élément basique du langage C qui veut le premier élément d'un objet composé (tableau, structure) se trouve à la même adresse que l'objet lui même...

Code :

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

char c1[4]="abc";

et si j'ai bien compris c1 n'est pas un pointeur sur caractère mais un objet de type "tableau de 4 caractères".
Donc quand j'affiche &c1 j'ai 02FF01.

OK

Par contre si je veux afficher "c1" le compilateur fait une conversion automatique du type de c1 (qui est un type talbeau de 4 caractères à l'origine) en un type pointeur sur caractère et lui attribut l'adresse du 1er élément du tableau. Donc 0022FF01 dans le cas de l'exemple.

Oui. c1 est converti en un char * valant l'adresse de c1[0].

Et de même avec *c1.

*c1 est *(c1 + 0) soit c1[0].

En gros y'a que dans le cas "&c1" où c1 n'est pas converti.

On peut dire ça, oui. Il y a aussi le cas de sizeof...

Tant que Jean Marc ne fais pas les gros yeux, tu peux considérer que ma réponse (et la tienne) sont correctes.

[GhostNemo]

Merci infiniment Emmanuel !!! Merci pour toutes tes explications.
A présent tout est clair ^^