Initialize array in constructor without using default constructor or assignment

Question

Consider:

struct A {

 A (int);

 A (const A &);
};

struct B {

 A foo [2];

 B (const A & x, const A & y)
 : foo {x, y} /* HERE IS THE PROBLEM          


        

Answer 1

You can use boost::array. It has a plain native array inside, so it still has the same memory layout like in your example.

struct B {
 boost::array<A, 2> foo;

 B (const A & x, const A & y)
 : foo(createFoo(x, y))
 {}

private:
 static boost::array<A, 2> createFoo(const A & x, const A & y) {
   boost::array<A, 2> a = {{ x, y }};
   return a;
 }
};

If you don't have boost you can create your own array class or use std::tr1 if your compiler has it

template<typename T, std::size_t N>
struct array {
  T data[N];
};

That's all you need, but you can add the usual begin, end, size functions and so on to make it more comfortable to use.

Answer 2

It should work in C++0x, but g++ 4.5.0 complains with "bad array initializer". If you replace A foo[2] with std::vector<A> foo, it compiles.

Answer 3

Unfortunately, there really is no proper, clean way to do this. Consider it something of a language limitation that results from an awkward mixing of C++ constructors and C style arrays. The C++11 standard addresses this issue, but until then you'll have to settle for a workaround.

Since A has no default constructor, one possible work-around is to have an array of A* pointers, and then loop over the array and initialize each one with new. (Obviously, don't forget to delete each item in the array in B's destructor, or just use smart pointers.)

Answer 4

Your question is similar to this previous question: C++: constructor initializer for arrays

Your main suggestion (make two members foo_a and foo_b) is probably the best way of doing things, provided that you'll need only two elements. There's no way of initializing array elements with anything but the type's default constructor in an initializer list, as you're trying to do in your example. Edit: Sorry, I didn't see that you were using C++0x. In C++0x you should be able to initialize as you wanted to do, provided that A is copyable or movable. I don't know about GCC 4.3's support for this, though.

Be careful using char arrays and placement new - char arrays aren't necessarily aligned properly to construct an A, and doing this can result in undefined behavior.

Some other suggestions:

• Store an array of pointers to A, or better, an array of smart pointers like auto_ptr or boost::scoped_ptr, and create the A objects on the heap using new A(args...).
• Store an array of another type, like boost::optional<A>, which handles the default construction and the alignment problem for you, but still essentially stores the A objects inside the B object proper.