Creación de matriz de objetos en la pila y montón

Question

Considere el siguiente código:

class myarray 
{ 
    int i; 

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

} 

Cómo se puede crear una matriz de objetos de myarray en la pila y cómo se puede crear una matriz de objetos en el montón?

Answer 1

Puede crear una matriz de objetos en la pila ^† a través de:

myarray stackArray[100]; // 100 objects 

Y en el montón ^† (o "almacén libre"):

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

Pero es mejor no gestionas la memoria tú mismo En su lugar, utilizar un std::vector:

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

Un vector es una matriz dinámica, que (por defecto) asigna los elementos de la pila. ^††

---

Debido a que su clase no tiene constructor por defecto, para crear en la pila es necesario dejar que el compilador sabe qué pasa en el constructor:

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

O con un vector :

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

Por supuesto, siempre se puede dar un constructor por defecto: 012

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

---

† Para los pedantes: C++ no tiene realmente una "pila" o "montón"/"almacén libre". Lo que tenemos es duración de "almacenamiento automático" y "almacenamiento dinámico". En la práctica, esto se alinea con la asignación de pila y la asignación de pila.

†† Si desea asignar "dinámicamente" de la pila, necesitará definir un tamaño máximo (se conoce el almacenamiento de la pila antes de tiempo), y luego darle al vector un nuevo asignador para que use la pila en su lugar.

Answer 2

Si crea una matriz de objetos de clase myarray (ya sea en la pila o en el montón) tendría que definir un constructor predeterminado.

No hay forma de pasar argumentos al constructor al crear una matriz de objetos.

Answer 3

sé cómo crear objetos con fuera del constructor por defecto, pero sólo en la pila:

Supongamos que desea crear 10 objetos de la clase MiMatriz con a = 1..10:

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

No hay necesidad de llamar el destructor, porque se crean en la pila.

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

Dado que C++ 11 std::array<T,size> está disponible para las matrices asignadas en la pila.Envuelve T[size] proporcionando la interfaz de std::vector, pero la mayoría de los métodos son constexpr. La desventaja aquí es que nunca se sabe cuando se desborda la pila.

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

Para las matrices asignados con el uso de memoria montón std::vector<T>. A menos que especifique un asignador personalizado, la implementación estándar utilizará la memoria de pila para asignar los miembros de la matriz.

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

Nota que en ambos casos se requiere un constructor por defecto para inicializar la matriz, por lo que debe definir

myarray::myarray() { ... } 

También hay opciones para utilizar de VLAs C o C++ 's new, pero debe abstenerse de usarlos tanto como sea posible, ya que su uso hace que el código sea propenso a errores de segmentación y pérdidas de memoria.