Initializing constant array of fixed size inside c

Question

Consider the following class:

class A {
    const int arr[2];
public:
      A() { }
};

Is it possible to initialize arr from the constructor initializer list or in any other way than on the line where it is declared (i.e. const int arr[2] = {1,2};)?

Note that I'm interested in methods that work with C++98!

Answer 1

Initializing array elements to non-zero values requires C++11 support.

In C++03, it's only possible to value-initialize your array, resulting in each element's value being 0:

class A {
    const int arr[2];
public:
    A() : arr() { }
};

For the relevant C++03 standardese, see this question and answer:
How can i use member initialization list to initialize it?

^{(I'm going to assume that by C++98 you mean not C++11, i.e. that C++03 is acceptable. If this assumption is wrong, please say so.)}

Answer 2

By wrapping them in a struct, e.g.:

class A
{
    struct Data
    {
        int arr[2];
    };

    Data const arr;
public:
    A() : arr( someOtherStruct ) {}
};

This does mean that to access the data, you'd have to write arr.arr. It's possible to avoid that by inheriting from the struct:

struct PrivateDataForA
{
    int arr[2];
};

class A : private PrivateDataForA
{
public:
    A() : PrivateDataForA( someOtherStruct ) {}
};

This does make the name of the struct visible outside of the class (which might be an advantage—client code could pass you one as an argument).

If you don't have an instance of the struct handy, say because you want to fill it with values calculated from arguments to the constructor, you can use a static member function:

class A : private PrivateDataForA
{
    static PrivateDataForA createInitializer( int a, int b );
public:
    A( int a, int b ) : PrivateDataForA( createInitializer( a, b ) )
    {
    }
};

---

For the OP’s concrete example:

#include <iostream>
#include <stddef.h>

typedef ptrdiff_t   Size;
typedef Size        Index;

template< class Element, Size n >
struct Array{ Element elem[n]; };

class A {
    Array<int, 2> const arr_;       // const int arr[2];

    A& operator=( A const& );       // No such.

    static Array<int, 2> const& oneAndTwo()
    {
        static Array<int, 2> const a = {1, 2};
        return a;
    }

public:
    A(): arr_( oneAndTwo() ) {}
    int at( Index i ) const { return arr_.elem[i]; }
};


int main()
{
    using namespace std;

    A o;
    for( int i = 0;  i < 2;  ++i )
    {
        cout << o.at( i ) << endl;
    }
}

Answer 3

No. It's not.