Creazione di array di oggetti sullo stack e heap

Question

Si consideri il seguente codice:

class myarray 
{ 
    int i; 

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

} 

Come si può creare un array di oggetti di myarray sullo stack e come è possibile creare un array di oggetti sul mucchio?

Answer 1

È possibile creare un array di oggetti sullo stack ^† via:

myarray stackArray[100]; // 100 objects 

E sul mucchio ^† (o "Freestore"):

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

Ma è meglio non gestire la memoria da soli. Invece, utilizzare un std::vector:

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

Un vettore è un array dinamico, che (per default) alloca elementi dal cumulo. ^††

---

Perché la classe non ha un costruttore di default, per creare in pila è necessario lasciare che il compilatore sa cosa passare al costruttore:

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

O con un vettore :

// 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)); 

Naturalmente, si può sempre fare un costruttore di default:

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

---

† Per i pedanti: C++ non ha veramente un "stack" o "heap"/"Freestore". Quello che abbiamo è la durata di "archiviazione automatica" e "archiviazione dinamica". In pratica, questo si allinea con l'allocazione dello stack e l'allocazione dell'heap.

†† Se si desidera allocare "dinamico" dallo stack, è necessario definire una dimensione massima (lo storage di stack è noto in anticipo), quindi assegnare un nuovo allocatore al vettore in modo che utilizzi lo stack.

Answer 2

Se si crea una matrice di oggetti di classe myarray (su stack o su heap), è necessario definire un costruttore predefinito.

Non è possibile passare argomenti al costruttore durante la creazione di una matrice di oggetti.

Answer 3

so come creare oggetto con fuori il costruttore di default, ma solo sulla pila:

Si supponga di voler creare 10 oggetti per la classe MyArray con a = 1..10:

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

Non c'è bisogno di chiamare il distruttore, perché sono creati nello stack.

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

Poiché C++ 11 std::array<T,size> è disponibile per array allocati sullo stack.Include T[size] fornendo l'interfaccia di std::vector, ma la maggior parte dei metodi è constexpr. Il rovescio della medaglia qui è che non si sa mai quando si trabocca lo stack.

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

Per gli array allocati con memoria heap utilizzare std::vector<T>. A meno che non si specifichi un allocatore personalizzato, l'implementazione standard utilizzerà la memoria heap per allocare i membri dell'array.

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

Nota che in entrambi i casi un costruttore di default è necessario per inizializzare l'array, quindi è necessario definire

myarray::myarray() { ... } 

Ci

sono anche opzioni per l'utilizzo VLAs C o C++ s 'new, ma si dovrebbe astenersi dall'utilizzarli il più possibile, perché il loro uso rende il codice soggetto a errori di segmentazione e perdite di memoria.