Tas vs allocation de Pile

Je suis un peu confus sur le sujet de l'allocation des objets sur le tas vs l'allocation sur la pile, et quand et comment les supprimer() doit être appelée.

Par exemple, j'ai de la classe Vector. Je voudrais faire un tableau de ces.

Je pouvais soit faire

Vector** v = new Vector*[100]; //create an array of 100 pointers to 100 Vector objects

Ce que je comprends serait d'allouer tout (enfin sauf pointeur d'adresses) sur un tas de?
Donc, pour libérer de la mémoire j'aurais besoin de:

for (int i = 0; i < 100; ++i)
{
   delete(v[i]);
}
delete(v);

OU tout simplement

delete(v);

est-elle suffisante?

Maintenant un autre exemple:

Vector* v = Vector[100];

Ce qui se passe dans ce cas? D'où vient l'allocation de se produire? Tas ou de la pile?
Dois-je toujours besoin d'appeler

delete(v);

Mais ce n'est pas une question, désolé pour le long post..

exemple:

class Vector
{
  int x, y, z;
}

Vector* v = new Vector();

wheres x, y, z alloué? Tas ou pile?

ou comment à ce sujet:

class Vector2
{
   int items[10];
}

Vector2* v2 = new Vector2();

où sont les articles[10] alloué?
Comment puis-je supprimer la v2? Ai-je besoin personnalisé destructeur?

Aussi le dernier mais non le moins, comment à ce sujet:

class Vector3
{
   int* items;
}

Vector3 v3 = Vector3();

Où les éléments pointeur stocké? tas ou de la pile? Comment puis-je supprimer?

Merci et désolé pour la longue question. J'ai de la difficulté avec ce genre de choses depuis longtemps et ne pourrais pas vraiment trouver aucune explication complète sur la ligne.

Oublier de new/delete vous n'avez pas besoin d'eux. Il suffit d'utiliser un std::vector
désolé mec, c'était juste un exemple de classe que j'ai donné à comprendre l'allocation de la mémoire. Cela n'a rien à voir avec une réelle application. Je pourrais ainsi appelé MyClass. + même si c'était std::Vector, c'est autre chose, ne pas confondre les noms!
Il n'a rien à voir avec le nom de. Il est plus à voir avec l'utilisation de new X[]. Dans la plupart des situations que vous faites cela, vous devriez être en utilisant std::vector<X>

OriginalL'auteur Mikhail Naumov | 2011-07-15

c++

13

Je vais commencer par le début...
```
Vector** v = new Vector*[100];
```
Alloue un tableau de 100 pointeurs vers des objets de type Vecteur sur le tas
Elle renvoie un pointeur - v - le que vous pouvez utiliser pour garder une trace de ce tableau de pointeurs.

Supprimer ce tableau de 100 points avec:
```
delete[] v;
```
(Utiliser le delete opérateur- delete pour un seul objet alloué, delete[] pour un tableau)

Cas suivant (je suppose que tu veux dire new Vector[100]:
```
Vector* v = new Vector[100];
```
Vous avez alloué un tableau de 100 Vecteurs sur le tas et a obtenu un pointeur vers son emplacement de départ - v.
Supprimer ce tableau avec:
```
delete[] v;
```
Prochaine...
```
class Vector
{
  int x, y, z;
}

Vector* v = new Vector();
```
Il alloue un objet de la classe Vecteur sur le tas et vous donne un pointeur d'en garder la trace. Parce que vous avez alloué à l'ensemble de l'objet sur le tas, x, y, et z sont allouées sur le tas.

Supprimer avec:
```
delete v;


class Vector2
{
   int items[10];
}

Vector2* v2 = new Vector2();
```
Celui-ci est un peu plus compliqué, mais je vais à la raison...

Classes sont des modèles. Vous n'avez pas alloué de la mémoire à tous jusqu'à ce que vous instancier la classe en quelque sorte, dans ce cas, sur le tas. Parce que la classe est un modèle, items n'aurait pas été alloué jusqu'à ce que vous avez créé un objet de la classe Vector2 sur le tas. Je pense qu'on peut raisonnablement en déduire que items est donc alloué sur le tas.

Supprimer v2 avec:
```
delete v2;
```
Et enfin:
```
class Vector3
{
   int* items;
}

Vector3 v3 = Vector3();
```
Vous affecté l'ensemble de la classe Vector3 sur la pile, le pointeur à l'intérieur de items est également attribuée ainsi. Rien n'est allé sur le tas, afin de ne pas le supprimer.

Je pense qu'un simple delete[] v; pourrait causer des fuites de mémoire (si l'alloués pointeurs utilisés).
Oubliez les modèles. Votre compréhension de la dynamique de la mémoire a besoin d'être travaillé correctement avant même de commencer à réfléchir à des modèles. Un modèle est un ensemble de sous la langue (vous avez besoin de comprendre la langue principale de la première).
Je ne voulais pas donner l'impression de modèles dans le réel C++ sens d'un modèle (vector<maclasse>, etc.). J'ai essayé de transmettre l'idée que, lorsque une déclaration de classe est faite, il sert de modèle pour les futures attributions de cette classe. Aussi, je pense que Naumov est à l'aide de Vecteur dans le sens X, Y, Z de la valeur (en ligne avec la pensée de coordonnées 3D de l'avion) plutôt que dans le sens de la STL modèle. Ils sont deux choses différentes.
Il n'a alloué un tableau de 100 pointeurs avec son premier appel. Il n'y aurait qu'une fuite de mémoire si, effectivement, il a continué à faire quelque chose avec ces pointeurs, par exemple allouer 100 objets Vectoriels avec eux. Il n'a pas alors un simple delete[] suffit.
La surcharge du terme avec quand on parle de C++ est une mauvaise idée. Changer votre phrase de trop: Classes are a blueprints.

OriginalL'auteur Prime
9

Permet de star hors que vous n'avez probablement pas besoin d'allouer dynamiquement de quoi que ce soit.

Soit un tableau statique ou vecteur fonctionnera beaucoup mieux.

Mais permet en supposant que vous faites cela comme un exercice d'apprentissage.

1 de l'Allocation d'un tableau de pointeurs
```
Vector** v = new Vector*[100]; //create an array of 100 pointers to 100 Vector objects
                               //
                               //The above comment is misleading.
                               //The 100 pointers have not been initialized.
```
Ce alloué une zone de la mémoire de l'espace pour 100 pointeurs (de Vecteur (Notez qu'ils ne sont pas initialisées dire que chaque pointeur au hasard)). Pour supprimer ce que vous devez faire:
```
delete [] v;
```
2 Allouer les membres de la matrice

Si vous allouer à chacun des membres (que vous devriez faire si vous voulez les utiliser:
```
for (int i = 0; i < 100; ++i)
{
   v[i] = new Vector;
}

//Code

for (int i = 0; i < 100; ++i)
{
   delete v[i];
}
```
Donc noter que pour chaque appel à de nouvelles il devrait y avoir un appel correspondant à supprimer.

3 Une ERREUR
```
Vector* v = Vector[100];
```
C'est tout simplement faux. Si ne compilera pas.

4 Où les membres

À moins que le membre est un pointeur, il est à l'intérieur de l'objet.

Si le membre est un pointeur, il doit être allouée séparément.
```
class Vector
{
  int x, y, z;
}

Vector* v1 = new Vector();
Vector  v2 = Vector();      //Yes the = Vector() is required
```
Ici v1 points à un objet alloué dynamiquement qui contient x/y/z

Ici v2 est un objet qui contient x/y/z

Je sais que les gens vont dire les = Vector(); est pas nécessaire ou une copie de la construction. À la fois peu vrai, mais les deux à côté de l'essentiel. 1) Sa une copie de la construction, mais le compilateur est toujours assez intelligents pour le retirer. 2) Il est nécessaire pour la rendre équivalente à la ligne du dessus. La différence est sans il est default-initialized (c'est à dire pas initialisé) les membres sont zero-initialized (parce que Vecteur() n'a qu'un compilateur a généré constructeur).

Ainsi que sur les membres du groupe.

Ils ne sont pas différents des autres membres. Les membres sont TOUJOURS allouée à l'intérieur de l'objet. Si le membre est un pointeur, alors il est à l'intérieur de l'objet, mais ce qu'il désigne à doit être définie de façon explicite.
```
class Bob
{
    int   dataArray[10];
    int*   dataPtr;
};
Bob  b1 = Bob();
Bob* b2 = new Bob();

b1.dataArray[0] = 1;            //dataArray is inside the object.
                                //b1 is allocated locally

b1.dataPtr      = new int [10]; //dataPtr is inside the object.
                                //But what it points at must be seprotally defined.
                                //Note you must call delete [] for each new []
b1.dataPtr[5] = 2;

b2->dataArray[0] = 1;           //dataArray is inside the object.
                                //b2 is allocated dynamically

b2->dataPtr      = new int [10];//dataPtr is inside the object.
                                //But what it points at must be aseptically defined.
                                //Note you must call delete [] for each new []
b2->dataPtr[5] = 2;
```
C'est la réponse complète.

OriginalL'auteur Martin York
2

Règle générale:
- lorsque vous utilisez new ou new [], vous allouer sur le tas, dans d'autres cas, vous allouer sur la pile.
- chaque fois que vous utilisez new vous devez utiliser delete (explicitement ou non)
- chaque fois que vous utilisez new[] vous devez utiliser delete[] (explicitement ou non)
Le code suivant est UB puisque vous utilisez un [nouveau] et 101 supprimer. Utiliser un delete[].
```
Vector** v = new Vector*[100];
for (int i = 0; i < 100; ++i)
{
   delete(v[i]);
}
delete(v);
```
Je suis désolé whats UB veux dire?
Un comportement indéterminé, situation qui n'était pas entièrement spécifié par la norme du langage, de sorte que chaque langage de mise en œuvre peuvent agir comme il veut. Il peut tomber en panne, ou d'endommager vos données ou de lancement de la Navette Spatiale.

OriginalL'auteur Yuras
1
1. delete [] v; - c'est un tableau de notation de l'opérateur d'effacement. Vous devez utiliser lors de la suppression des tableaux, au lieu de supprimer chaque élément de manière séquentielle.
2. Vector* v = Vector[100]; juste ne compile pas. Écrire Vector v[100]; et il va allouer de la matrice de vecteurs sur la pile. Vous ne pouvez pas le supprimer manuellement.
3. x, y, z sont sur le tas comme l'ensemble de l'objet est sur le tas
4. items[10] est également alloué sur le tas comme le fait une partie de l'objet. Pour le supprimer il suffit d'appeler delete v2;. Vous n'avez pas besoin d'un destructeur, à moins que vous allouer quelque chose dans le constructeur.
5. int* items; est stocké sur la pile en tant que partie de l'objet alloué sur la pile. Vous n'avez pas à le supprimer, il sera supprimé automatiquement lorsque vient hors de portée.
OriginalL'auteur RocketR

Vous devez vous connecter pour publier un commentaire.

1 de l'Allocation d'un tableau de pointeurs

2 Allouer les membres de la matrice

3 Une ERREUR

4 Où les membres