creando una matriz de punteros a objetos C++

Question

Quiero crear una matriz que contenga punteros a muchos objetos, pero no sé de antemano la cantidad de objetos que mantendré, lo que significa que necesito asignar dinámicamente memoria para la matriz He pensado en el siguiente código:

ants = new *Ant[num_ants]; 
for (i=1;i<num_ants+1;i++) 
{ 
    ants[i-1] = new Ant(); 
} 

donde ants se define como Ant **ants; y Ant es una clase.

¿Funcionará?

Answer 1

Will it work?

Sí.

Sin embargo, si es posible, se debe utilizar un vector:

#include <vector> 

std::vector<Ant*> ants; 
for (int i = 0; i < num_ants; ++i) { 
    ants.push_back(new Ant()); 
} 

Si tiene que utilizar una matriz asignada dinámicamente entonces yo preferiría esta sintaxis:

typedef Ant* AntPtr; 
AntPtr * ants = new AntPtr[num_ants]; 
for (int i = 0; i < num_ants; ++i) { 
    ants[i] = new Ant(); 
} 

Pero se olvidan de todo eso. El código aún no es bueno ya que requiere una gestión manual de la memoria. Para solucionar esto se podía cambiar su código para:

std::vector<std::unique_ptr<Ant>> ants; 
for (auto i = 0; i != num_ants; ++i) { 
    ants.push_back(std::make_unique<Ant>()); 
} 

Y lo mejor de todo sería simplemente esto:

std::vector<Ant> ants(num_ants); 

Answer 2

std::vector<Ant> ants(num_ants); 
ants.resize(new_num_ants); 

Answer 3

std::vector<Ant*> ants(num_ants); 
for (int i = 0; i != num_ants; ++ i) { 
    ants[i] = new Ant; 
} 

O si usted no sabe cuántos de antemano:

std::vector<Ant*> ants; 
while (moreAntsNeeded()) { 
    ants.push_back(new Ant); 
} 

Por otro lado, creo que hay que preguntarse si Ant es un tipo de entidad o un valor . Si se trata de un valor, probablemente quiera omitir los punteros y la asignación dinámica; si se trata de un tipo de entidad, deberá tener en cuenta la duración del objeto y cuándo y dónde se eliminará.

Answer 4

Sí, esa es la idea general. Sin embargo, hay alternativas. ¿Estás seguro de que necesitas una serie de indicadores? Una matriz de objetos de la clase Ant puede ser suficiente. El que sólo tiene que asignar la matriz:

Ant *ants = new Ant[num_ants]; 

En general, se debe preferir el uso std::vector a la utilización de una matriz. Un vector puede crecer según sea necesario y gestionará la gestión de memoria por usted.

En el código que has publicado, se tendría que eliminar cada elemento de ants en un bucle, y luego eliminar la matriz en sí, delete [] ant. Tenga en cuenta la diferencia entre delete y delete [].

Un punto más, ya que los índices de matriz en C++ son 0-base, la siguiente convención se usa para iterar sobre los elementos:

for (i=0; i<num_ants; i++) 
{ 
    ants[i] = new Ant(); 
} 

Esto hace que el código mucho más legible.

Answer 5

¿De verdad necesita mantener punteros en los artículos? Si puede usar objetos por valor, un enfoque mucho más simple es usar un vector: std::vector<Ant> ants(num_ants);. Entonces no solo no tiene que escribir bucles, sino que no tiene que preocuparse por las pérdidas de memoria de los punteros sin procesar y otros elementos de administración de objetos.

Si necesita que los punteros de los objetos digan satisfacer una API, puede usar vector para el contenedor externo y asignar los objetos manualmente.

struct CreateAnt 
{ 
    Ant* operator()() const { return new Ant; } 
}; 

std::vector<Ant*> ants(num_ants); // Create vector with null pointers. 
std::generate(ants.begin(), ants.end(), CreateAnt());