Création d'un réseau d'objets sur la pile et tas

Question

Consultez le code suivant:

class myarray 
{ 
    int i; 

    public: 
      myarray(int a) : i(a){ } 

} 

Comment pouvez-vous créer un tableau d'objets de myarray sur la pile et comment pouvez-vous créer un tableau d'objets sur le tas?

Answer 1

Vous pouvez créer un tableau d'objets sur la pile ^† via:

myarray stackArray[100]; // 100 objects 

Et sur le tas ^† (ou "Freestore"):

myarray* heapArray = new myarray[100]; 
delete [] heapArray; // when you're done 

Mais il est préférable pas gérer la mémoire vous-même. Au lieu de cela, utiliser un std::vector:

#include <vector> 
std::vector<myarray> bestArray(100); 

Un vecteur est un tableau dynamique, qui (par défaut) alloue des éléments de la pile. ^††

---

Parce que votre classe n'a pas de constructeur par défaut, pour créer sur la pile, vous devez laisser le compilateur savoir quoi passer dans le constructeur:

myarray stackArray[3] = { 1, 2, 3 }; 

Ou avec un vecteur :

// C++11: 
std::vector<myarray> bestArray{ 1, 2, 3 }; 

// C++03: 
std::vector<myarray> bestArray; 
bestArray.push_back(myarray(1)); 
bestArray.push_back(myarray(2)); 
bestArray.push_back(myarray(3)); 

Bien sûr, vous pouvez toujours donner un constructeur par défaut:

class myarray 
{ 
    int i;  
public: 
    myarray(int a = 0) : 
    i(a) 
    {} 
}; 

---

† Pour les pédants: C++ n'a pas vraiment une "pile" ou "tas"/"Freestore". Ce que nous avons, c'est la "conservation automatique" et la "durée de stockage dynamique". En pratique, cela s'aligne sur l'allocation de pile et l'allocation de tas. Si vous voulez une allocation "dynamique" à partir de la pile, vous devez définir une taille maximale (le stockage de la pile est connu à l'avance), puis attribuer au vecteur un nouvel allocateur afin qu'il utilise la pile à la place.

Answer 2

Si vous créez un tableau d'objets de classe myarray (sur pile ou sur tas), vous devez définir un constructeur par défaut.

Il n'existe aucun moyen de transmettre des arguments au constructeur lors de la création d'un tableau d'objets.

Answer 3

Je sais comment créer objet avec hors du constructeur par défaut, mais seulement sur la pile:

Supposons que vous voulez créer 10 objets pour la classe MonTableau avec a = 1..10:

MyArray objArray[] = { MyArray[1], MyArray[2]......MyArray[10]} 

Pas besoin d'appeler le destructeur, car ils sont créés dans la pile.

Answer 4

#include <stdio.h> 
class A 
{ 
public: 
    A(int a){ 
     printf("\nConstructor Called : %d\n",a); 
     aM = a; 
     } 
    ~A(){ 
    printf("\ndestructor Called : %d\n",aM); 
} 
private: 
    int aM; 
}; 

int main() 
{                         
    A **a = new A*[10]; 
    for (int i = 0;i<10;i++) 
    a[i] = new A(i+1); 
    for (int i = 0;i<10;i++) 
     delete a[i];// = new A(i+1);                      

    delete []a; 
} 

Answer 5

Depuis C++ 11 std::array<T,size> est disponible pour les tableaux alloués sur la pile.Il enveloppe T[size] fournissant l'interface de std::vector, mais la plupart des méthodes sont constexpr. L'inconvénient ici est que vous ne savez jamais quand vous débordez la pile.

std::array<myarray, 3> stack_array; // Size must be declared explicitly.VLAs 

Pour les tableaux attribués à l'utilisation de la mémoire de tas std::vector<T>. Sauf si vous spécifiez un allocateur personnalisé, l'implémentation standard utilisera la mémoire heap pour allouer les membres du groupe.

std::vector<myarray> heap_array (3); // Size is optional. 

Remarque que dans les deux cas, un constructeur par défaut est nécessaire pour initialiser le tableau, vous devez donc définir

myarray::myarray() { ... } 

Il y a aussi des options à utiliser l 'new C de VLAs ou C++, mais vous devriez évitez de les utiliser autant que possible, car leur utilisation rend le code sujet aux failles de segmentation et aux fuites de mémoire.