Jak zainicjować tablicę członkowską za pomocą Initializer_list?

Zamiast konstruktora listy inicjującej można użyć konstruktora szablonów wariadycznych:

struct foo { 
    int x[2]; 
    template <typename... T> 
    foo(T... ts) : x{ts...} { // note the use of brace-init-list
    } 
};

int main() {
    foo f1(1,2);   // OK
    foo f2{1,2};   // Also OK
    foo f3(42);    // OK; x[1] zero-initialized
    foo f4(1,2,3); // Error: too many initializers
    foo f5(3.14);  // Error: narrowing conversion not allowed
    foo f6("foo"); // Error: no conversion from const char* to int
}

EDYCJA:Jeśli możesz żyć bez wytrwałości, innym sposobem byłoby pominięcie inicjalizacji i wypełnienie tablicy w treści funkcji:

struct foo {
    int x[2]; // or std::array<int, 2> x;
    foo(std::initializer_list<int> il) {
       std::copy(il.begin(), il.end(), x);
       // or std::copy(il.begin(), il.end(), x.begin());
       // or x.fill(il.begin());
    }
}

W ten sposób jednak tracisz ograniczenia czasu kompilacji, które zapewnia poprzednie rozwiązanie.

O ile mogę powiedzieć, użycie listy inicjalizacji argumentu funkcji konstruktora (8.5.4/1) powinno być legalne i rozwiązuje wiele z powyższych problemów. Jednak GCC 4.5.1 na ideone.com nie pasuje do konstruktora i odrzuca go.

#include <array>

struct Foo
  {
    std::array< int, 2 > const data;

    Foo(std::array<int, 2> const& ini) // parameter type specifies size = 2
    : data( ini )
    {}
  };

Foo f( {1,3} ); // list-initialize function argument per 8.5.4/1

Jeśli naprawdę nalegasz na initializer_list , możesz użyć reinterpret_cast aby zmienić podstawową tablicę initializer_list do tablicy w stylu C.

Foo(std::initializer_list<int> ini) // pass without reference- or cv-qualification
: data( reinterpret_cast< std::array< int, 2 > const & >( * ini.begin() )

Zgodnie z dyskusją tutaj:

prawidłowa składnia drugiego rozwiązania Potatoswatter to:

Foo f( {{1,3}} ); //two braces

trochę brzydki, niezgodny z powszechnym zastosowaniem