Variable créée sur le tas, 2 pointeurs pointant vers la même variable ont des adresses différentes?

Question

Je viens d'apprendre la différence entre la pile et le tas. Après avoir créé une fonction qui allouera dynamiquement de la mémoire sur le tas pour moi, je retourne le pointeur et affiche (dans et hors de la fonction) l'adresse et la valeur de chaque pointeur.

Les valeurs sont les mêmes, ce que j'attendais, mais les adresses pour le même morceau de mémoire sur le tas sont différentes, ce que je ne m'attendais pas.

Pourquoi? Should pHeap2 et pTemp ne devraient pas pointer vers la même adresse?

#include <iostream> 
using namespace std; 

int* intOnHeap(); // returns an int on the heap 
int main() 
{ 
int* pHeap = new int; // new operator allocates memory on the heap and returns its address 
     // 'new int' allocates enough memory on heap for one int and returns the address on the heap for that chunk of memory 
     // 'int* pHeap' is a local pointer which points to the newly allocated chunk of memory 
*pHeap = 10; 
cout << "*pHeap: " << *pHeap << "\n\n"; 

int* pHeap2 = intOnHeap(); 
cout << "pHeap2:\n-----------" << endl; 
cout << "Address:\t" << &pHeap2 << "\n"; 
cout << "Value:\t\t" << *pHeap2 << "\n\n"; 

cout << "Freeing memory pointed to by pHeap.\n\n"; 
delete pHeap; 

cout << "Freeing memory pointed to by pHeap2.\n\n"; 
delete pHeap2; 

// get rid of dangling pointers 
    pHeap = 0; 
    pHeap2 = 0; 

system("pause"); 
return 0; 
} 

int* intOnHeap() 
{ 
int* pTemp = new int(20); 
cout << "pTemp:\n-----------" << endl; 
cout << "Address:\t" << &pTemp << "\n"; 
cout << "Value:\t\t" << *pTemp << "\n\n"; 
return pTemp; 
} 

Sortie:

*pHeap: 10 

pTemp: 
----------- 
Address:  0042FBB0 
Value:   20 

pHeap2: 
----------- 
Address:  0042FCB4 
Value:   20 

Freeing memory pointed to by pHeap. 

Freeing memory pointed to by pHeap2. 

Press any key to continue . . . 

Answer 1

Vous SIGNALENT l'adresse des pointeurs, pas l'adresse que le pointeur pointe. Bien sûr, l'adresse du pointeur sera différente pour pTemp et pHeap2; ce sont des pointeurs différents qui pointent vers la même adresse en mémoire. Supprimez le & préfixant pTemp et pHeap2 pour voir les résultats que vous attendez.

L'image est quelque chose comme ceci:

0042FBB0   0042FBC0  0042FCB4 
------------  ------  ------------ 
| 0042FBC0 |------>| 20 |<------| 0042FBC0 | 
------------  ------  ------------ 
pTemp       pHeap2 

Ici vous avez cette &pTemp est 0042FBB0 et &pHeap2 est 0042FCB4. J'ai inventé une adresse pour l'adresse que et pHeap2 pointent vers (bien sûr, les résultats pourraient varier d'un bout à l'autre) et si vous supprimez le & préfixe pTemp et pHeap2 alors vous verriez 0042FBC0 imprimé à la place dans chaque cas.

Answer 2

&pHeap2 ne renvoie pas la valeur du pointeur, il renvoie l'adresse du pointeur. C'est à cause du &, qui dans ce contexte signifie "l'adresse de".

, c'est-à-dire à 0042FCB4 en mémoire, il y a un pointeur pointant sur 0042FBB0 (c'est-à-dire dans un environnement big-endian, vous verriez 00 42 FB B0 à 0042FCB4).

Answer 3

Oui, pTemp et pHeap2 doivent être identiques. Mais &pTemp et &pHeap2 sont différents. En effet, l'opérateur & renvoie un pointeur sur son opérande. Donc pTemp est un pointeur vers un int, alors que &pTemp est un pointeur vers un pointeur vers un int.