¿Cómo declaro una matriz de objetos cuya clase no tiene un constructor predeterminado?

Question

Si una clase tiene solo un constructor con un parámetro, ¿cómo declarar una matriz? Sé que el vector se recomienda en este caso. Por ejemplo, si tengo una clase

class Foo{ 

public: 
Foo(int i) {} 

} 

Cómo declarar una matriz o un vector que contiene 10000 objetos Foo?

Answer 1

Para una matriz, debe proporcionar un inicializador para cada elemento de la matriz en el punto donde defina la matriz.

Para un vector puede proporcionar una instancia para copiar para cada miembro del vector.

p. Ej.

std::vector<Foo> thousand_foos(1000, Foo(42)); 

Answer 2

Tendría que hacer una serie de indicaciones a Foo.

Foo* myArray[10000]; 
for (int i = 0; i < 10000; ++i) 
    myArray[i] = new Foo(i); 

Answer 3

En realidad, puede hacerlo, siempre se utiliza una lista de inicialización, como

Foo foos[4] = { Foo(0),Foo(1),Foo(2),Foo(3) }; 

sin embargo, con 10000 objetos esto es absolutamente impracticable. Ni siquiera estoy seguro de si estabas lo suficientemente loco como para intentar si el compilador aceptaría una lista de inicialización tan grande.

Answer 4

Cuando declara un objeto que no tiene un constructor predeterminado, debe inicializarlo en la declaración.

Foo a; // not allowed 
Foo b(0); // OK 

Lo mismo ocurre con las matrices de tales tipos:

Foo c[2]; // not allowed 
Foo d[2] = { 0, 1 }; // OK 
Foo e[] = { Foo(0), Foo(1), Foo(2) }; // also OK 

En su caso, es probable que encuentre que no sea práctico para inicializar todos los 10.000 elementos por el estilo, por lo que es posible que desee volver a pensar si el clase realmente no debería tener un constructor predeterminado.

Answer 5

usted tiene que utilizar el inicializador agregado, con 10.000 de inicializadores inidividual entre el {}

Foo array[10000] = { 1, 2, 3, ..., 10000 }; 

Por supuesto, especificando 10000 inicializadores es algo del reino de lo imposible, pero se preguntó por él mismo. Querías declarar una matriz de 10000 objetos sin un constructor predeterminado.

Answer 6

La única manera de definir una matriz de una clase sin constructor por defecto sería para inicializar inmediato - no es realmente una opción con 10000 objetos.

Puede, sin embargo, asignar suficiente memoria sin procesar de la manera que desee y usar la ubicación new para crear los objetos en esa memoria.Pero si usted quiere hacer esto, es mejor utilizar std::vector que hace exactamente eso:

#include <iostream> 
#include <vector> 

struct foo { 
    foo(int) {} 
}; 

int main() 
{ 
    std::vector<foo> v; 
    v.resize(10000,foo(42)); 
    std::cout << v.size() '\n'; 
    return 0; 
} 

Answer 7

Otra opción podría ser usar una gran variedad de boost::optional<Foo>:

boost::optional<Foo> foos[10]; // No construction takes place 
           // (similar to vector::reserve) 

foos[i] = Foo(3); // Actual construction 

Una advertencia es que se le tener que acceder a los elementos con la sintaxis de puntero:

bar(*foos[2]); // "bar" is a function taking a "Foo" 

std::cout << foos[3]->baz(); // "baz" is a member of "Foo" 

también debe tener cuidado de no acceder a un elemento no inicializado.

Otra advertencia es que este no es un verdadero reemplazo para una matriz de Foo, ya que no podrá pasarlo a una función que espera lo último.

Answer 8

En línea recta C, usando int foo[10000] = {1}; se inicializará el primer elemento de matriz a 1 y el resto de la matriz a cero. ¿C++ no autoinicializa miembros de matriz no especificados, o esto requiere un constructor predeterminado?

Answer 9

sbi tenía la mejor respuesta para arreglos simples, pero no daba un ejemplo. Así que ...

Debe utilizar la colocación de nuevo:

char *place = new char [sizeof(Foo) * 10000]; 
Foo *fooArray = reinterpret_cast<Foo *>(place); 
for (unsigned int i = 0; i < 10000; ++i) { 
    new (fooArray + i) Foo(i); // Call non-default constructor 
} 

Tenga en cuenta que cuando se utiliza la colocación nueva, que es responsable de llamar destructores de los objetos - el compilador no hacerlo para ti:

// In some cleanup code somewhere ... 
for (unsigned int i = 0; i < 10000; ++i) { 
    fooArray[i].~Foo(); 
} 

// Don't forget to delete the "place" 
delete [] reinterpret_cast<char *>(fooArray); 

Esta es la única vez que ves una llamada explícita legítima a un destructor.

NOTA: La primera versión de esto tenía un error sutil al eliminar el "lugar". Es importante volver a colocar el "lugar" en el mismo tipo que se renovó. En otras palabras, fooArray debe volver a fundirse al char * al eliminarlo. Vea los comentarios a continuación para una explicación.

Answer 10

Si tiene sentido para su clase, se podría proporcionar un valor predeterminado para el parámetro constructor:

class Foo 
{ 
public: 
    explicit Foo(int i = 0); 
} 

Ahora usted tienen un constructor predeterminado. (Un "constructor predeterminado" es un constructor al que se puede llamar sin argumentos: FAQ)

También recomendaría hacer explícito su constructor, como hice anteriormente. Le impedirá obtener Foo s de int s cuando no desee solicitarlos.

Answer 11

class single 
{ 
    int data; 
public: 
    single() 
    { 
     data = 0; 
    } 
    single(int i) 
    { 
     data = i; 
    } 
}; 

// in main() 
single* obj[10000]; 
for (unsigned int z = 0; z < 10000; z++) 
{ 
    obj[z] = new single(10); 
} 

Answer 12

Pruebe esto.

Foo **ppInstances=0; 
    size_t total_instances = 10000; 

    for(int parent=0;parent < total_instances;parent++){ 
     ppInstances[parent]=new Foo(parent); 
     ppInstances++; 
    } 
    for(int parent=0;parent < total_instances;parent++){ 
     delete *ppInstances; 
     ppInstances--; 
    }