Où sont stockés les pointeurs en C ++, sur la pile ou dans le tas?

Je suis en train d'essayer de comprendre la différence entre le pile et tas de la mémoire, et cette question sur de SORTE que comme cette explication fait un assez bon travail en expliquant les principes de base.

Dans la deuxième explication cependant, je suis tombé sur un exemple pour lequel j'ai une question spécifique, l'exemple est: est-ce

Il est expliqué que l'objet m est alloué sur la tasje me demandais simplement si c'est de l'histoire. Selon ma compréhension, l'objet lui-même, en effet, est allouée sur le tas comme le new mot-clé a été utilisé pour son instanciation.

Cependant, n'est-ce pas que le pointeur vers l'objet m est sur le même temps alloué sur la pile? Sinon, comment serait l'objet lui-même, qui, bien sûr, est assis dans la tas être consulté. Je me sens comme dans un souci d'exhaustivité, il aurait été mentionné dans ce tutoriel, laissant provoque un peu de confusion pour moi, donc j'espère que quelqu'un peut éclaircir ce point et de me dire que je suis avec ma compréhension que cet exemple devrait en deux états qui aurait à dire:

1. un pointeur vers l'objet m a été alloué sur la pile

2. l'objet m lui-même (de sorte que les données qu'il contient, ainsi que l'accès à ses méthodes) a été alloué sur le tas

source d'informationauteur nburk

c++memory-management pointers

12

Votre compréhension peut être correcte, mais les déclarations sont fausses:

Un pointeur vers l'objet m a été alloué sur la pile.

m est le pointeur. Il est sur la pile. Peut-être que vous avez voulu dire pointeur vers un Member objet.

L'objet m lui-même (les données qu'il contient, ainsi que l'accès à ses méthodes) a été alloué sur le tas.

Correcte serait de dire l'objet pointé par m est créé sur le tas

En général, aucune fonction/méthode de l'objet local et les paramètres de la fonction sont créés sur la pile. Depuis m est un fonction locale objet, il est sur la pile, mais l'objet pointé par m est sur le tas.
13

"pile" et "tas" sont le jargon de la programmation en général. En particulier , aucun stockage est nécessaire pour être géré à l'interne par l'intermédiaire d'une pile ou un tas de structure de données.

C++ a la suite de classes de stockage
- statique
- automatique
- dynamique
- fil
Environ, dynamique correspond à un "tas", et automatique correspond à la "pile".

De passer à votre question: un pointeur peut être créé dans n'importe quel de ces quatre classes de stockage; et d'objets pointus à peut aussi être dans une de ces classes de stockage. Quelques exemples:
```
void func()
{
    int *p = new int;            //automatic pointer to dynamic object
    int q;                       //automatic object
    int *r = &q;                 //automatic pointer to automatic object
    static int *s = p;           //static pointer to dynamic object
    static int *s = r;           //static pointer to automatic object (bad idea)
    thread_local int **t = &s;   //thread pointer to static object 
}
```
Nommé les variables déclarées avec aucun fournisseur sont automatique si à l'intérieur d'une fonction, ou statique autrement.
5

Lorsque vous déclarez une variable dans une fonction, il va toujours sur la pile. Si votre variable Member* m est créé sur la pile. Notez que par lui-même, m est un pointeur, il n'a pas à quoi que ce soit. Vous pouvez l'utiliser pour pointer vers un objet sur la pile ou le tas, ou à rien du tout.

La déclaration d'une variable dans une classe ou structure est différente, ceux où aller, où jamais la classe ou structure est instancié.

De créer quelque chose sur le tas, vous utilisez new ou std::malloc (ou leurs variantes). Dans votre exemple, vous créez un objet sur le tas à l'aide de new et d'attribuer son adresse à m. Objets sur le tas doivent être libérés pour éviter les fuites de mémoire. Si alloués à l'aide de newvous devez utiliser delete; si alloués à l'aide de std::mallocvous devez utiliser std::free. La meilleure approche est généralement d'utiliser un pointeur "intelligent", qui est un objet qui contient un pointeur et a un destructeur qui le libère.
2

Oui, le pointeur est alloué sur la pile, mais l'objet que d'un pointeur sur est alloué sur le tas. Vous êtes correct.

Cependant, n'est-ce pas que le pointeur vers l'objet m est sur le même temps
alloués sur la pile?

Je suppose que vous parliez de l' Member objet. Le pointeur est alloué sur la pile et dernière place pour toute la durée de la fonction (ou de sa portée). Après cela, le code peut toujours fonctionner:
```
#include <iostream>
using namespace std;

struct Object {
    int somedata;
};

Object** globalPtrToPtr; //This is into another area called 
                         //"data segment", could be heap or stack

void function() {
    Object* pointerOnTheStack = new Object;
    globalPtrToPtr = &pointerOnTheStack;
    cout << "*globalPtrToPtr = " << *globalPtrToPtr << endl;
} //pointerOnTheStack is NO LONGER valid after the function exits

int main() {
     //This can give an access violation,
     //a different value after the pointer destruction
     //or even the same value as before, randomly - Undefined Behavior
    cout << "*globalPtrToPtr = " << *globalPtrToPtr << endl;
    return 0;
}
```
http://ideone.com/BwUVgm

Le code ci-dessus stocke l'adresse d'un pointeur résidant sur la pile (et les fuites de mémoire aussi parce qu'il n'est pas libre Object's de la mémoire allouée avec delete).

Depuis après la sortie de la fonction le pointeur est "détruit" (c'est à dire sa mémoire peut être utilisé pour tout ce qui plaît au programme), vous ne pouvez plus accéder en toute sécurité il.

Le programme ci-dessus peut soit: exécuter correctement, crash ou de vous donner un résultat différent. L'accès libéré ou désallocation de la mémoire est appelé comportement indéfini.

Vous devez vous connecter pour publier un commentaire.