Quand dois-je affecter sur le tas? (C++)

Question

Je ne comprends pas vraiment quand je devrais allouer de la mémoire sur le tas et quand je devrais l'allouer sur la pile. Tout ce que je sais, c'est que l'allocation sur la pile est plus rapide, mais comme la pile est plus petite, je ne devrais pas l'utiliser pour allouer de grandes structures de données; Quelles autres choses devrais-je prendre en compte pour décider où allouer la mémoire? Edit: où devrais-je allouer des variables d'instance? Allouer sur la pile pour la plupart des objets.

Answer 1

1. Durée de vie == portée.
2. Si vous avez besoin de contrôler manuellement la durée de vie de l'objet, l'affecter sur le tas.
3. Si l'objet est grand et la pile n'est pas assez grand pour elle, allouer sur le tas.
4. Utilisez le (mal noms) idiome RAII dans les cas 2 et 3, il vous permet d'utiliser l'objet sur la pile qui manipulent des ressources qui pourraient être vos objets sur le tas - un bon exemple sont les pointeurs intelligents comme std :: shared_ptr/boost :: shared_ptr.

Answer 2

Utilisez le segment de mémoire lorsque la mémoire doit persister au-delà de la portée de la fonction en cours.

Answer 3

Vous ne pouvez utiliser la pile comme espace de stockage que lorsque vous savez au moment de la compilation quelle est la taille du stockage dont vous avez besoin. Il en résulte que vous pouvez utiliser la pile pour

• objets simples (comme vous déclarer un int ou double ou variable MyClass temp1;
• locales tableaux statiquement taille (comme vous le faites lorsque vous déclarez char local_buf[100]; ou MyDecimal numbers[10];

vous devez utiliser le tas (« magasin gratuit ») lorsque vous ne savez combien d'espace dont vous avez besoin à l'exécution et vous devez utiliser probablement le tas pour grands tampons statiquement connus (comme ne font char large_buf[32*1024*1024];)

Normalement cependant vous très rarement devrait toucher le tas directement, mais normalement utiliser des objets qui gèrent une mémoire de tas pour vous (et l'objet vit peut-être sur la pile ou en tant que membre d'un autre objet - où vous alors ne vous inquiétez pas celui de l'autre objet)

pour donner quelques exemples de code:

{ 
char locBuf[100]; // 100 character buffer on the stack 
std::string s; // the object s will live on the stack 
myReadLine(locBuf, 100); // copies 100 input bytes to the buffer on the stack 
s = myReadLine2(); 
    // at this point, s, the object, is living on the stack - however 
    // inside s there is a pointer to some heap allocated storage where it 
    // saved the return data from myReadLine2(). 
} 
// <- here locBuf and s go out-of-scope, which automatically "frees" all 
// memory they used. In the case of locBuf it is a noop and in the case of 
// s the dtor of s will be called which in turn will release (via delete) 
// the internal buffer s used. 

donc, pour donner une réponse courte à votre question quand: Ne rien allouent sur le tas (via new) à moins que cela se fait au moyen d'un objet emballage approprié. (Std :: string, std :: vecteur, etc.)

Answer 4

Dans mon expérience allocation de tas est plus utile lorsque vous voulez déclarer la taille d'un tableau d'objets lors de l'exécution.

int numberOfInts; 
cout << "How many integers would you like to store?: "; 
cin >> numberOfInts; 
int *heapArray = new int[numberOfInts]; 

Ce code vous donnera un tableau pointé de ints de taille numberOfInts. Il est également possible de le faire dans la pile, mais cela est considéré comme dangereux, et vous risquez d'obtenir l'erreur dont ce site porte le nom.