C++: inicializador de constructores para matrices

Solo para actualizar esta pregunta para C++11, esto ahora es posible de hacer y muy natural:

struct Foo { Foo(int x) { /* ... */  } };

struct Baz { 
     Foo foo[3];

     Baz() : foo{{4}, {5}, {6}} { }
};

Esos frenos también pueden ser elided para un aún más conciso:

struct Baz { 
     Foo foo[3];

     Baz() : foo{4, 5, 6} { }
};

Que también se puede extender fácilmente a matrices multidimensionales:

struct Baz {
    Foo foo[3][2];

    Baz() : foo{1, 2, 3, 4, 5, 6} { }
};

En este momento, no puede usar la lista inicializador para los miembros de la matriz. Estás atascado haciéndolo de la manera difícil.

class Baz {
    Foo foo[3];

    Baz() {
        foo[0] = Foo(4);
        foo[1] = Foo(5);
        foo[2] = Foo(6);
    }
};

En C++0x puedes escribir:

class Baz {
    Foo foo[3];

    Baz() : foo({4, 5, 6}) {}
};

Desafortunadamente no hay manera de inicializar los miembros del array hasta C++0x.

Podría usar un std::vector y push_back las instancias Foo en el cuerpo del constructor.

Podrías darle a Foo un constructor por defecto (podría ser privado y hacer de Baz un amigo).

Puede usar un objeto array que es copiable (boost o std:: tr1) e inicializar desde un array estático:

#include <boost/array.hpp>

struct Baz {

    boost::array<Foo, 3> foo;
    static boost::array<Foo, 3> initFoo;
    Baz() : foo(initFoo)
    {

    }
};

boost::array<Foo, 3> Baz::initFoo = { 4, 5, 6 };

Puede usar C++0x auto palabra clave junto con plantilla especialización en por ejemplo una función llamada boost::make_array() (similar a make_pair()). Para el caso de donde N es 1 o 2 argumentos podemos entonces escribir variante A como

namespace boost
{
/*! Construct Array from @p a. */
template <typename T>
boost::array<T,1> make_array(const T & a)
{
    return boost::array<T,2> ({{ a }});
}
/*! Construct Array from @p a, @p b. */
template <typename T>
boost::array<T,2> make_array(const T & a, const T & b)
{
    return boost::array<T,2> ({{ a, b }});
}
}

And variant B as

namespace boost {
/*! Construct Array from @p a. */
template <typename T>
boost::array<T,1> make_array(const T & a)
{
    boost::array<T,1> x;
    x[0] = a;
    return x;
}
/*! Construct Array from @p a, @p b. */
template <typename T>
boost::array<T,2> make_array(const T & a, const T & b)
{
    boost::array<T,2> x;
    x[0] = a;
    x[1] = b;
    return x;
}
}

GCC-4.6 con -std=gnu++0x y -O3 genera el exactamente el mismo código binario para

auto x = boost::make_array(1,2);

Usando A y B como lo hace para

boost::array<int, 2> x = {{1,2}};

Para tipos definidos por el usuario (UDT), sin embargo, la variante B resulta en un constructor de copia adicional, que generalmente ralentiza las cosas, y por lo tanto debe evitarse.

Tenga en cuenta que boost::make_array errores al llamarlo con literales de matriz de caracteres explícitos como en el siguiente caso

auto x = boost::make_array("a","b");

Creo que esto es algo bueno ya que const char*los literales pueden ser engañosos en su uso.

Plantillas variádicas, disponible en CCG desde el punto 4.5, se puede seguir utilizando reducir todo el código de placa de caldera de especialización de plantilla para cada N en una definición de plantilla única de boost::make_array() definida como

/*! Construct Array from @p a, @p b. */
template <typename T, typename ... R>
boost::array<T,1+sizeof...(R)> make_array(T a, const R & ... b)
{
    return boost::array<T,1+sizeof...(R)>({{ a, b... }});
}

Esto funciona más o menos como esperamos. El primer argumento determina boost::array argumento de plantilla T y todos los demás argumentos se convierten en T. Para algunos casos esto puede ser indeseable, pero no estoy seguro de cómo si esto es posible especificar el uso de plantillas variádicas.

Tal vez boost::make_array() debería entrar en el ¿Aumentar Bibliotecas?

Esto parece funcionar, pero no estoy convencido de que sea correcto:

#include <iostream>

struct Foo { int x; Foo(int x): x(x) { } };

struct Baz { 
     Foo foo[3];

    static int bar[3];
     // Hmm...
     Baz() : foo(bar) {}
};

int Baz::bar[3] = {4, 5, 6};

int main() {
    Baz z;
    std::cout << z.foo[1].x << "\n";
}

Salida:

$ make arrayinit -B CXXFLAGS=-pedantic && ./arrayinit
g++ -pedantic    arrayinit.cpp   -o arrayinit
5

Caveat emptor.

Editar: no, Comeau lo rechaza.

Otra edición: Esto es una especie de trampa, simplemente empuja la inicialización de la matriz miembro por miembro a un lugar diferente. Por lo tanto, todavía requiere que Foo tenga un constructor predeterminado, pero si no tiene std::vector, entonces puede implementar por sí mismo el mínimo absoluto que necesita:

#include <iostream>

struct Foo { 
    int x; 
    Foo(int x): x(x) { }; 
    Foo(){}
};

// very stripped-down replacement for vector
struct Three { 
    Foo data[3]; 
    Three(int d0, int d1, int d2) {
        data[0] = d0;
        data[1] = d1;
        data[2] = d2;
    }
    Foo &operator[](int idx) { return data[idx]; }
    const Foo &operator[](int idx) const { return data[idx]; }
};

struct Baz { 
    Three foo;

    static Three bar;
    // construct foo using the copy ctor of Three with bar as parameter.
    Baz() : foo(bar) {}
    // or get rid of "bar" entirely and do this
    Baz(bool) : foo(4,5,6) {}
};

Three Baz::bar(4,5,6);

int main() {
    Baz z;
    std::cout << z.foo[1].x << "\n";
}

z.foo en realidad no es una matriz, pero se parece tanto a uno como a un vector. Agregar begin() y end() funciones a Tres es trivial.

Solo se puede llamar al constructor predeterminado cuando se crean objetos en una matriz.

En el caso específico cuando el array es un miembro de datos de la clase, no puede inicializarlo en la versión actual del lenguaje. No hay sintaxis para eso. Proporcione un constructor predeterminado para los elementos de matriz o use std::vector.

Una matriz independiente se puede inicializar con aggregate initializer

Foo foo[3] = { 4, 5, 6 };

Pero desafortunadamente no hay una sintaxis correspondiente para la lista inicializador del constructor.

No existe una sintaxis de construcción de matrices que pueda usarse en este contexto, al menos no directamente. Usted puede lograr lo que está tratando de lograr por algo a lo largo de las líneas de:

Bar::Bar()
{
    static const int inits [] = {4,5,6};
    static const size_t numInits = sizeof(inits)/sizeof(inits[0]);
    std::copy(&inits[0],&inits[numInits],foo);  // be careful that there are enough slots in foo
}

...pero tendrás que darle a Foo un constructor predeterminado.

Ideas de una mente retorcida:

class mytwistedclass{
static std::vector<int> initVector;
mytwistedclass()
{
    //initialise with initVector[0] and then delete it :-)
}

};

Ahora establece esto initVector a algo que u quiere antes de que u instancie un objeto. A continuación, los objetos se inicializan con sus parámetros.

Puedes hacerlo, pero no es bonito:

#include <iostream>

class A {
    int mvalue;
public:
    A(int value) : mvalue(value) {}
    int value() { return mvalue; }
};

class B {
    // TODO: hack that respects alignment of A.. maybe C++14's alignof?
    char _hack[sizeof(A[3])];
    A* marr;
public:
    B() : marr(reinterpret_cast<A*>(_hack)) {
        new (&marr[0]) A(5);
        new (&marr[1]) A(6);
        new (&marr[2]) A(7);
    }

    A* arr() { return marr; }
};

int main(int argc, char** argv) {
    B b;
    A* arr = b.arr();
    std::cout << arr[0].value() << " " << arr[1].value() << " " << arr[2].value() << "\n";
    return 0;
}

Si pones esto en tu código, espero que tengas una muy buena razón.

Esta es mi solución para su referencia:

struct Foo
{
    Foo(){}//used to make compiler happy!
    Foo(int x){/*...*/}
};

struct Bar
{
    Foo foo[3];

    Bar()
    {
        //initialize foo array here:
        for(int i=0;i<3;++i)
        {
            foo[i]=Foo(4+i);
        }
    }
};

En visual studio 2012 o superior, puedes hacer así

struct Foo { Foo(int x) { /* ... */  } };

struct Baz { 
     Foo foo[3];

     Baz() : foo() { }
};

class C
{
   static const int myARRAY[10];  // only declaration !!!

   public:
   C(){}
   }

const int C::myARRAY[10]={0,1,2,3,4,5,6,7,8,9};  // here is definition

int main(void)
{
   C myObj;
   }