How can i use member initialization list to initialize an array?

Question

class A {
public:
   A();

private:
   char a[5];
   int* ptr;
};

A::A() : a(0), ptr(0) { }

Is this right?

Answer 1

The only sensible thing you can do with a C-array in C++03 is value-initialize it (in C++11 and beyond it can be list-initialized).

From the C++03 standard, §8.5/7:

An object whose initializer is an empty set of parentheses, i.e., (), shall be value-initialized.

And from §8.5/5:

To value-initialize an object of type T means:

• if T is a class type with a user-declared constructor, then the default constructor for T is called (and the initialization is ill-formed if T has no accessible default constructor);
• if T is a non-union class type without a user-declared constructor, then every non-static data member and base-class component of T is value-initialized;
• if T is an array type, then each element is value-initialized;
• otherwise, the object is zero-initialized

To zero-initialize an object of type T means:

• if T is a scalar type, the object is set to the value of 0 (zero) converted to T;
• if T is a non-union class type, each nonstatic data member and each base-class subobject is zero-initialized;
• if T is a union type, the object’s first named data member) is zero-initialized;
• if T is an array type, each element is zero-initialized;
• if T is a reference type, no initialization is performed.

So, if your constructor definition is changed to

A::A() : a(), ptr() { }

then you are guaranteed that post-construction, all 5 elements of A::a will have the value '\0' and A::ptr will be null.

Answer 2

Afraid not; C++ doesn't support initialising arrays like this.

You'll just have to assign to its members in A's constructor body, or you can use value-initialisation if you don't really care what the values are:

struct A {
   int x[5];
   A() : x();
};

C++0x does let you give all the values, though:

struct A {
   int x[5];
   A() : x{1,2,3,4,5} {}
};

Note, though, that because arrays are not class-objects, you won't be able to do this:

struct A {
   int x[5];
   A(std::initializer_list<int[5]>& i) // or whatever the T should be
      : x{i} // or x(i)
        {}
}
A a({1,2,3,4,5)};