9

I have a struct that holds an array, and I'd like to pass an initializer list to the struct's constructor to be forwarded on to the array. To illustrate, I tried:

#include <initializer_list>

struct Vector
{
    float v[3];

    Vector(std::initializer_list<float> values) : v{values} {}
};

int main()
{
    Vector v = {1, 2, 3};
}

Which resulted in the error:

error: cannot convert ‘std::initializer_list<float>’ to ‘float’ in initialization

I tried using parentheses instead of braces for v but that gave the error:

error: incompatible types in assignment of ‘std::initializer_list<float>’ to ‘float [3]’

My main motivation for trying to do this is to avoid the following warning that clang generates:

template <int N>
struct Vector
{
    float v[N];
};

template <>
struct Vector<2>
{
    float x, y;
};

int main()
{
    Vector<2> v2 = {1.0f, 2.0f};         // Yay, works
    Vector<3> v3 = {1.0f, 2.0f, 3.0f};   // Results in warning in clang++
    Vector<3> u3 = {{1.0f, 2.0f, 3.0f}}; // Must use two braces to avoid warning
    // If I could make Vector<N> take an initializer list in its constructor, I
    // could forward that on to the member array and avoid using the double braces
}

warning: suggest braces around initialization of subobject

So my question is: How can I initialize a member array with an initializer list? (i.e. How can I make the first code work? Or is it not possible?

Cornstalks
  • 37,137
  • 18
  • 79
  • 144
  • For an aggregate, you wouldn't even need a ctor. Note the size of an `initializer_list` is variable. There's also a difference between initializing with an `initializer-list` and _list-initialization_ (which is a language construct and may lead to calling a ctor using an initializer-list). – dyp May 02 '13 at 14:54
  • You can't really do it, but could you use an `std::array` instead? – juanchopanza May 02 '13 at 14:54
  • He could use std::array, but I read this as a question about the language, not the standard library. And, with due respect to whomever, telling someone to go read the standard library is like telling a toddler to learn English by reading Shakespeare. So std::array isn't a very good answer. – Samuel Danielson Mar 02 '16 at 00:32

4 Answers4

12

Plain C style arrays are not assignable. If you switch over to using std::array instead, the initialization becomes trivial.

#include <array>

struct Vector
{
    std::array<float, 3> v;

    Vector(std::array<float, 3> const& values) 
    : v(values)
    {}
};

int main()
{
    Vector v{{1, 2, 3}};
}
Praetorian
  • 106,671
  • 19
  • 240
  • 328
9

If your class is an aggregate, you can use your syntax

template < std::size_t len >
struct Vector
{
    float elems[len];
};

Vector<3> v = {1.0f, 2.0f, 3.0f};

Note: this is possible due to brace-elision. No need for v = {{1,2,3}}; though this is also possible. Clang issues this warning because the clearer and less error-prone syntax is with the double braces (one for initializing v and one for initializing the sub-aggregate elems).

If your class is not an aggregate, you can use variadic templates:

#include <array>
#include <cstddef>

template < std::size_t len >
struct Vector
{
    std::array < float, len > m;  // also works with raw array `float m[len];`

    template < typename... TT >
    Vector(TT... pp) : m{{pp...}}
    {}

    // better, using perfect forwarding:
    // template < typename... TT >
    // Vector(TT&&... pp) : m{{std::forward<TT>(pp)...}}
    // {}
};

Vector<3> a = {1.0f, 2.0f, 3.0f};
dyp
  • 38,334
  • 13
  • 112
  • 177
2

Try to use std::copy. 

Vector(std::initializer_list<float> values) 
{
    std::copy(values.begin(), values.end(), v);
}
Evgeny Eltishev
  • 593
  • 3
  • 18
0

To initialize an array non-static member, use the aggregate syntax. That is, directly fill the braced-list with N elements, where N is the number of elements in the array. You can use fewer than N if the element type is Default-Constructible; the missing elements will be value-initialized.

There is no conversion from a std::initializer_list to an array. Even if you were using a source type that could convert to an array reference (never a value), you couldn't exploit the conversion in a member initializer since arrays are not Assignable. In these cases, you have to use something like std::copy within the constructor's body.

Note for multidimensional arrays, since arrays aren't Assignable, you only use braced-lists to represent the sub-arrays. There is also the option of brace elision; using a flat list of std::remove_all_extents<TheArrayType>::type items and the compiler will make-do. (When the inner non-array type is a built-in character type, you can sometimes use a quoted string as the next-to-innermost initializer for a multidimensional array.)

CTMacUser
  • 1,996
  • 1
  • 16
  • 27