Pile vs Tas de C++

De la pile de la mémoire est ce que vous avez dit, mais pour être plus précis, c'est la mémoire locale du champ d'application actuel. Notez qu'en fonction de ce champ dont vous parlez, cette mémoire peut être global ou peut-être locale à une fonction ou d'une classe. Ce sont nettoyés une fois ils sont allés hors de portée.

De segment de mémoire allouée par le new de l'opérateur.
Ces persistera en mémoire, même après tous les pointeurs pointant vers la mémoire sont allés hors de portée. Vous devez libérer explicitement cette mémoire vous-même en C++ via delete. Ne pas le faire va entraîner une fuite de mémoire, à moins que des pointeurs intelligents sont utilisés.

Une autre chose à noter, prendre l'exemple de code suivant:

void foo()
{
   int *bar = new int; //creates a pointer to an int on the stack, but initializes an int on the heap
   *bar = 3; //sets the int being pointed to to 3
   delete bar; //deletes the int
   bar = 0; //removes the now invalid reference
}

le pointeur lui-même, d'un bar, est créé sur la pile. Toutefois, les données pointées par la barre. *bar -- oui, l'astérisque ne faire une différence ici. Il vous obtient les données pointé par le pointeur-est sur le tas. Lorsque toto revient, la barre passe hors de portée. N'avais-je pas appelé supprimer, j'aurais perdu l'accès à l' *bar et aurait obtenu une fuite de mémoire.

Pour la deuxième question, le rôle de la dtor est de nettoyer l'objet que vous avez construit. L'un est fourni par défaut pour vous, mais il ya des moments où vous devez écrire votre propre. Par exemple, si votre classe a cru pointeurs, vous devez explicitement mise en liberté supprimer dans la dtor. Elle est appelée lorsque l'objet est hors de portée pour la pile de la mémoire et lors de la suppression est appelé à la mémoire du tas.

• La pile est une zone qui est utilisée dans la fonction et les appels de méthode. Il est essentiellement utilisé pour stocker les paramètres et la fonction des données locales (entre autres impliqué dans le processus de l'appel d'une fonction). La pile est une LIFO type de structure de données, ce qui signifie que la dernière chose que vous mettez en est la première fois que vous obtenez à partir d'elle.

• Le tas, en revanche, est un magasin libre, j'entends par là que vous pouvez obtenir toutes les valeurs dans le tas peu importe l'ordre qu'il a mis là - cette distinction est importante.

• En C++ , chaque fois que vous appelez new l'objet est créé sur le Tas et un pointeur vers cet objet est retourné à vous, vous pouvez utiliser le pointeur pour accéder à votre objet. Qui s'applique à la fois des objets complexes comme des objets de classes que vous ou quelqu'un d'autre a créé et construit dans les types, tels que int, char, double, etc... Il n'y a rien de magique avec l'aide de nouveau, il est à la base il appelle simplement malloc, ou certains saveur de celle-ci en fonction de la plate-forme, puis appelle le constructeur de l'objet. Vous devez penser à appeler delete (ou delete []p_array_of_object_pointers) pour chaque objet créé avec new.

• Le destructeur n'est rien de plus qu'une fonction de la langue des appels sur l'objet lorsque vous faites un delete my_object_pointer dans votre code. Le destructeur vous donne une chance de faire un peu de ménage dans votre code. Dans des langages tels que C++, où vous devez gérer vos propres ressources, vous devez généralement utiliser pour appeler des delete ou free sur d'autres objets que vous avez alloué sur le tas, ou de la fermeture des descripteurs de fichiers que vous avez créés avec fopen ou tel...

• Les deux mots-clés à travailler à l'intérieur ou à l'extérieur de fonctions et de méthodes, il n'importe pas où vous les appelez, ils seront toujours travailler avec le tas. Tout ce que vous créez sans l'utilisation de new le mettre dans un autre lieu, soit la zone statique de l'exécutable ou de la pile, en fonction de comment et où il est en cours de création.

• Chaque fois que vous créez un objet à l'intérieur d'une méthode ou d'une fonction avec la syntaxe suivante MyClassType myObject(contructor, arguments); et sans l'utilisation de new, de sa création sur la pile (à moins que vous déclarez comme statique, ce qui est quand il se termine dans la zone statique je l'ai mentionné ci-dessus).

Espère que cette aide.

Allouer de la mémoire dans la pile dans votre exemple. C'est variable automatique et il serait supprimé, puis le retour s'est passé.
Si vous utilisez new mot-clé, vous devez fournir le bon de libération de la mémoire

MyObject* newObject = new MyObject(a);

Utilisation allouée dynamiquement des instances d'objets lors de l':

1) Le type réel de l'objet n'est pas connu au moment de la compilation
2) Lorsque le nombre d'objets que vous souhaitez créer, n'est pas connu au moment de la compilation
3) Lorsque le (généré par le compilateur) gestion de durée de vie de vos objets ne répondent pas à vos besoins.

Chaque objet créé avec l'opérateur new, doit être libérée avec opérateur d'effacement à un certain moment. Si vous ne le faites pas, vous aurez des fuites de mémoire, et si vous comptez sur les effets secondaires des objets destructeur, vous n'obtiendrez pas ces effets secondaires et votre programme ne peut pas faire ce qu'il veut faire.

Lorsqu'un objet est créé comme une pile variable, le compilateur va ajouter du code pour appeler les objets destructeur lorsque l'objet est hors de portée. Comment le compilateur de savoir ce destructeur de l'appeler? Le type de l'objet est connu au moment de la compilation, il y a seulement une possibilité, qu'un seul destructeur d'appel.

Si vous utilisez la "supprimer" pour détruire un objet, le compilateur ne peut pas être en mesure de dire qui de destructeur à utiliser. L'objet peut être de type "basique", puis le destructeur de base::~base () sera appelée.

    class basic;
    class derived : public basic
    {
           ....
           ~derived();
    }

    basic *l = new derived();
    ...
    delete l;

Le compilateur ne sait pas le type réel de l'objet n'est pas 'de base', mais 'dérivé'. Si, toutefois, vous devez déclarer le destructeur de "base" pour être virtuel, le compilateur va insérer le code consulte les objets de la table de méthode virtuelle, et l'appel est redirigé vers la droite destructeur (dans ce cas, le destructeur qui détruit sur l'objet de type 'dérivé').

Si vous êtes inquiet à propos de ce problème, et si vous le pouvez, prenez le destructeur "virtuel".