Discussion :

[Linquisiteur]

Bonjour, j'essaie de comprendre le mouvement des adresses des pointeurs.
J'ai testé avec ce code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#include <stdio.h>
#include <stdlib.h>
 
 
int main(int argc, char *argv[])
{
 
char *x = malloc(1);
char *y = malloc(1);
*x = 20;
*y = 3;
printf("x: %p %p %d\n",&x,x,*x );
printf("y: %p %p %d\n",&y,y,*y );
// Première partie de l’output
char*temp=x;x =y;y = temp;
printf("x: %p %p %d\n",&x,x,*x );
printf("y: %p %p %d\n",&y,y,*y );
free(x);
free(y);
 
 return 0;
}

output

Code :

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

1
2
3
4
5
6
7
8
9
 
 
x : ffbffaa4 20a58 2
y : ffbffaa0 20a68 3
 
(devient)
 
x : ffbffaa4 20a68 3
y : ffbffaa0 20a58 2

d'après moi:


un pointeur pointe sur une adresse mémoire donc
*x pointe sur &x qui, elle, contient 2.

Ce qui se passe lors de ce morceau de code :

char* temp = x ;
x = y ;
y = temp ;


Un pointeur sur une case char est créé, sur lequel on va assigner la valeur de x donc 2. On va écraser x par la valeur de y ( 3 ) et écraser ensuite y en le remplaçant par temp (donc l'ancienne valeur de x : 2 )

Ce qui se passe dans la mémoire est que l'on a 2 pointeurs. Le premier pointe vers une case qui a une valeur 2 et le second vers une case qui a une valeur de 3.

Ensuite, on place la valeur x dans temp et le pointeur va pointer sur cette nouvelle case. Idem lorsque l'on écrasera x par 3, le pointeur *y va pointer sur x
et puis enfin le pointeur de x pointera sur la variable y

Ce qui explique que seule l'adresse des cases des 2 variables n'ait pas bougé.

Mais je voudrais vérifier si j'ai juste ou tort.

Merci

[deletme]

Salut,

*x pointe sur &x qui, elle, contient 2.

Attention à la syntaxe :
x pointe sur l'adresse &x qui contient la valeur *x (soit 20 au début)

[Linquisiteur]

ah oui merci

[Obsidian]

Bonjour,

d'après moi:

un pointeur pointe sur une adresse mémoire donc
*x pointe sur &x qui, elle, contient 2.

Non.

Ce qui se passe lors de ce morceau de code :

char* temp = x ;
x = y ;
y = temp ;


Un pointeur sur une case char est créé, sur lequel on va assigner la valeur de x donc 2. On va écraser x par la valeur de y ( 3 ) et écraser ensuite y en le remplaçant par temp (donc l'ancienne valeur de x : 2 )

Non, pas tout-à-fait.

x pointe sur l'adresse &x qui contient la valeur *x (soit 20 au début)

Non plus.

Il faut bien comprendre que les pointeurs, quand tu les instancies, sont des variables comme les autres. Elles peuvent recevoir n'importe quelle valeur, même si elle est invalide. Il se trouve que cette valeur est réputée être l'adresse en mémoire de quelque chose, mais il n'y a pas de liaison directe entre cette chose et son pointeur.

Donc, en l'occurrence :

• x = ffbffaa4, soit 4.290.771.620 en décimal ;
• y = ffbffaa0, soit 4.290.771.616 en décimal.

Et c'est tout. Lorsque tu inverses leur contenu avec temp, tu permutes ces valeurs comme tu le ferais avec des entiers ordinaires, par exemple.

Maintenant, sur le plan syntaxique :

• x est le nom de ta variable (en l'occurrence un pointeur) ;
• &x est l'adresse en mémoire de ta variable. Donc ici, de ton pointeur, mais ça pourrait également être l'adresse de n'importe quoi d'autre, comme un entier, encore une fois ;
• *x se réfère à ce qui est pointé par ton pointeur (donc, contrairement à « & », « * » ne s'applique qu'aux pointeurs). Il se trouve que ce quelque chose est en fait la mémoire que tu as réservé avec malloc et dans laquelle tu as déposé une valeur à l'aide de ce même opérateur.

Donc, « *x » ne pointe pas sur « &x », parce que ça voudrait dire que le pointeur se pointe lui-même. Et ça ne contient pas « 2 » car, dans ce cas, « 2 » serait l'adresse en mémoire de ton pointeur, ce qui n'a pas de sens sur le système d'exploitation concerné.

[deletme]

hummm...

Code :

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

1
2
3
4
void *ptr;
int a = 12;
ptr = &a
printf("valeur pointée par ptr = %d",*ptr);

sortie

Code :

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

valeur pointée par ptr = 12

ptr pointe sur l'adresse &ptr (=&a) qui contient la valeur *ptr = 12 non ?

[CGi]

ptr pointe sur l'adresse &ptr (=&a) qui contient la valeur *ptr = 12 non ?

ptr pointe sur a, c'est a dire qu'il contient l'adresse de a.
Mais il ne pointe pas sur lui même ! il à sa propre adresse qui est différente de celle de a qui a aussi sa propre adresse.

Ton code est juste, c'est ton explication qui va pas !