C++, matriz de objetos sin <vector>

Question

Quiero crear en C++ una matriz de Objetos sin usar STL.

¿Cómo puedo hacer esto?

¿Cómo podría crear una matriz de Object2, que no tiene un constructor sin argumento (constructor predeterminado)?

Answer 1

Si el tipo en cuestión tiene un constructor sin argumentos, utilice new[]:

Object2* newArray = new Object2[numberOfObjects]; 

no se olvide de llamar delete[] cuando ya no se necesita la matriz:

delete[] newArray; 

Si no es así No tiene tal constructor use operator new para asignar memoria, luego invoca constructores:

//do for each object 
::new(addressOfObject) Object2(parameters); 

De nuevo, no olvide desasignar la matriz cuando ya no la necesite.

Answer 2

Si no hay un constructor predeterminado disponible, necesitará una matriz de punteros y luego recorra esa matriz para inicializar cada uno de los punteros.

Answer 3

Object2 *myArray[42]; 
for (int i = 0; i < 42; i++) 
{ 
    myArray[i] = new Object2(param1, param2, ...); 
} 

Más adelante se tendrá que caminar a través de la matriz y desasignar cada miembro individual:

for (int j = 0; j < 42; j++) 
{ 
    delete myArray[j]; 
} 

Answer 4

La pregunta obvia es por qué usted no desea utilizar la STL.

Suponiendo que tenga un motivo, crearía una matriz de objetos con algo como Obj * op = new Obj[4];. Solo recuerde deshacerse de él con delete [] op;.

No puede hacer eso con un objeto sin un constructor que no tome argumentos. En ese caso, creo que lo mejor que puedes hacer es asignar algo de memoria y usar la ubicación nueva. No es tan sencillo como los otros métodos.

Answer 5

utilizar una matriz de punteros a Object2:

std::tr1::shared_ptr<Object2>* newArray = new shared_ptr<Object2>[numberOfObjects]; 
for(int i = 0; i < numberOfObjects; i++) 
{ 
    newArray[i] = shared_ptr<Object2>(new Object2(params)); 
} 

O, alternativamente, sin el uso de shared_ptr:

Object2** newArray = new Object2*[numberOfObjects]; 
for(int i = 0; i < numberOfObjects; i++) 
{ 
    newArray[i] = new Object2(params); 
} 

Answer 6

Usted puede hacer lo std::vector hace y crear un bloque de memoria en bruto. A continuación, construye los objetos que no tienen un constructor predeterminado en esa memoria utilizando la colocación nueva, según se requiera. Pero, por supuesto, si haces eso también podrías haber usado std::vector en primer lugar.

Answer 7

Suponiendo que su clase es la base y que tiene un constructor un argumento

Base arr[3] = {Base(0), Base(1), Base(2)} ; 

Answer 8

// allocate memory 
Object2* objArray = static_cast<Object2*>(::operator new (sizeof Object2 * NUM_OF_OBJS)); 
// invoke constuctors 
for (size_t i = 0; i < NUM_OF_OBJS; i++) 
    new (&objArray[i]) Object2(/* initializers */); 

// ... do some work 

// invoke destructors 
for (size_t i = 0; i < NUM_OF_OBJS; i++) 
    objArray[i].~Object2(); 

// deallocate memory 
::operator delete (objArray); 

Answer 9

Si realmente necesita un array (secuencia contigua de objetos) de un tipo construible no predeterminada y por alguna razón puede molestar al usuario std::vector (!?) luego debe usar una función de asignación sin procesar y la ubicación nueva.

Esto es muy difícil de hacer de manera confiable; esto debería ayudar a mostrar por qué. Este fragmento incluye alguna defensa contra excepciones, pero es más que probable que no sea robusto contra todas las fallas.

const size_t required_count = 100; //e.g. 

// cast to pointer of required type needed for pointer arithmetic 
Object2* objarray = static_cast<Object2*>(operator new(required_count * sizeof(Object2))); 

size_t construction_count = 0; 

try 
{ 
    while (construction_count < required_count) 
    { 
     // params could change with index. 
     new (static_cast<void*>(objarray + construction_count)) Object2(param1, param2); 
     ++construction_count; 
    } 
} 
catch (...) 
{ 
    while (construction_count-- != 0) 
    { 
     try 
     { 
      (&objarray[construction_count])->~Object2(); 
     } 
     catch (...) 
     { 
      // not a lot we can do here, log but don't re-throw. 
     } 
    } 

    operator delete(objarray); 
    throw; 
} 

// Now objarray has been allocated and pointer to an array of required_count Object2 
// It cannot be de-allocated via delete[] or delete; you must loop through 
// calling destructors and then call operator delete on the buffer.