C++ : initialisateur de constructeur pour les tableaux

Question

J'ai une crampe au cerveau... comment initialiser correctement un tableau d'objets en C++ ?

exemple de non-réseau :

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

struct Bar { 
     Foo foo;

     Bar() : foo(4) {}
};

l'exemple du réseau :

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

struct Baz { 
     Foo foo[3];

     // ??? I know the following syntax is wrong, but what's correct?
     Baz() : foo[0](4), foo[1](5), foo[2](6) {}
};

editar: Les idées de contournement sauvages et folles sont appréciées, mais elles ne m'aideront pas dans mon cas. Je travaille sur un processeur embarqué où std::vector et d'autres constructions STL ne sont pas disponibles, et la solution de contournement évidente est de créer un constructeur par défaut et d'avoir une fonction explicite init() qui peut être appelée après la construction, de sorte que je n'ai pas à utiliser d'initialisateurs du tout. (C'est l'un de ces cas où j'ai été gâté par la méthode Java final mot-clé + flexibilité avec les constructeurs).

Answer 1

Il n'y a pas moyen. Vous avez besoin d'un constructeur par défaut pour les membres du tableau et il sera appelé, ensuite, vous pouvez faire toute initialisation que vous voulez dans le constructeur.

Answer 2

Actuellement, vous ne pouvez pas utiliser la liste d'initialisation pour les membres d'un tableau. Vous êtes obligé de le faire à la manière forte.

class Baz {
    Foo foo[3];

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

En C++0x, vous pouvez écrire :

class Baz {
    Foo foo[3];

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

Answer 3

Malheureusement, il n'y a aucun moyen d'initialiser les membres d'un tableau jusqu'à C++0x.

Vous pourriez utiliser un std::vector et repousser les instances de Foo dans le corps du constructeur.

Vous pourriez donner à Foo un constructeur par défaut (qui pourrait être privé et faire de Baz un ami).

Vous pourriez utiliser un objet de type tableau qui es copiable (boost ou std::tr1) et initialiser à partir d'un tableau statique :

#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 };

Answer 4

Vous pouvez utiliser C++0x auto ainsi que le mot-clé spécialisation des modèles sur par exemple une fonction nommée boost::make_array() (similaire à make_pair() ). Pour le cas où N est soit 1 soit 2 arguments, nous pouvons alors écrire variante A comme

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

et variante B comme

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 avec -std=gnu++0x y -O3 génère le exactement le même code binaire pour

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

en utilisant à la fois A y B comme il le fait pour

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

Pour types définis par l'utilisateur (UDT), cependant, la variante B donne lieu à un constructeur de copie supplémentaire qui ralentissent généralement les choses et sont donc à éviter.

Notez que boost::make_array des erreurs lorsqu'il est appelé avec des littéraux de tableaux de caractères explicites, comme dans le cas suivant

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

Je pense que c'est une bonne chose car const char* les littéraux peuvent être trompeuse dans leur utilisation.

Modèles variadiques disponible dans GCC depuis la version 4.5, peut être utilisé pour réduire le code passe-partout de la spécialisation des modèles pour chaque élément du modèle. N en un définition du modèle unique de boost::make_array() défini comme suit

/*! 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... }});
}

Cela fonctionne à peu près comme prévu. Le premier argument détermine boost::array argument de modèle T et tous les autres arguments sont convertis en T . Dans certains cas, cela peut être indésirable, mais je ne suis pas sûr de la manière dont il est possible de le spécifier en utilisant des modèles variadiques.

Peut-être boost::make_array() devrait aller dans les bibliothèques de Boost ?

Answer 5

Seul le constructeur par défaut peut être appelé lors de la création d'objets dans un tableau.