How to protect an array definition againt incomplete initialization with non-zero values?

Question

I have a global array, which is indexed by the values of an enum, which has an element representing number of values. The array must be initialized by a special value, which unfortunately is not a 0.

enum {
  A, B, C, COUNT
};

extern const int arr[COUNT];

In a .cpp file:

const int arr[COUNT] = { -1, -1, -1 };

The enum is occasionally changed: new values added, some get removed. The error in my code, which I just fixed was an insufficient number of initialization values, which caused the rest of the array to be initialized with zeroes. I would like to put a safeguard against this kind of error.

The problem is to either guarantee that the arr is always completely initialized with the special value (the -1 in the example) or to break compilation to get the developers attention, so the array can be updated manually.

The recent C++ standards are not available (old ms compilers and some proprietary junk). Templates can be used, to an extent. STL and Boost are strongly prohibited (don't ask), but I wont mind to copy or to reimplement the needed parts.

If it turns out to be impossible, I will have to consider changing the special value to be 0, but I would like to avoid that: the special value (the -1) might be a bit too special and encoded implicitly in the rest of the code.

I would like to avoid DSL and code generation: the primary build system is jam on ms windows and it is major PITA to get anything generated there.

Answer 1

The best solution I can come up with is to replace arr[COUNT] with arr[], and then write a template to assert that sizeof(arr) / sizeof(int) == COUNT. This won't ensure that it's initalized to -1, but it will ensure that you've explicitly initialized the array with the correct number of elements.

C++11's static_assert would be even better, or Boost's macro version, but if you don't have either available, you'll have to come up with something on your own.

Answer 2

This is easy.

enum {
  A, B, C, COUNT
};
extern const int (&arr)[COUNT];

const int (&arr)[COUNT] = (int[]){ -1, -1, -1};

int main() {
   arr[C];
}

At first glance this appears to produce overhead, but when you examine it closely, it simply produces two names for the same variable as far as the compiler cares. So no overhead.

Here it is working: http://ideone.com/Zg32zH, and here's what happens in the error case: http://ideone.com/yq5zt3

prog.cpp:6:27: error: invalid initialization of reference of type ‘const int (&)[3]’ from expression of type ‘const int [2]’

For some compilers you may need to name the temporary

const int arr_init[] = { -1, -1, -1};
const int (&arr)[COUNT] = arr_init;

update

I've been informed the first =(int[]){-1,-1,-1} version is a compiler extension, and so the second =arr_init; version is to be preferred.

Answer 3

Answering my own question: while it seems to be impossible to provide the array with the right amount of initializers directly, it is really easy to just test the list of initializers for the right amount:

#define INITIALIZERS -1, -1, -1,
struct check {
  check() {
    const char arr[] = {INITIALIZERS};
    typedef char t[sizeof(arr) == COUNT ? 1: -1];
  }
};

const int arr[COUNT] = { INITIALIZERS };

Thanks @dauphic for the idea to use a variable array to count the values.

Answer 4

The Boost.Preprocessor library might provide something useful, but I doubt whether you will be allowed to use it and it might turn out to be unwieldy to extract from the Boost sources.

This similar question has an answer that looks helpful: Trick : filling array values using macros (code generation)

Answer 5

The closest I could get to an initialization rather than a check is to use a const reference to an array, then initialize that array within a global object. It's still runtime initialization, but idk how you're using it so this may be good enough.

#include <cstring>

enum {A, B, C, COUNT};

namespace {
    class ArrayHolder {
        public:
            int array[COUNT];  // internal array
            ArrayHolder () {
                // initialize to all -1s
                memset(this->array, -1, sizeof(this->array));
            }
    };

    const ArrayHolder array_holder; // static global container for the array
}


const int (&arr)[COUNT] = array_holder.array;  // reference to array initailized
                                               // by ArrayHolder constructor

You can still use the sizeof on it as you would before:

for (size_t i=0; i < sizeof(arr)/sizeof(arr[0]); ++i) {
        // do something with arr[i]
}

---

Edit If the runtime initialization can never be relied on you should check your implementation details in the asm because the values of arr even when declared with an initializer may still not be known at until runtime initialization

const int arr[1] = {5};

int main() {
    int local_array[arr[0]]; // use arr value as length
    return 0;
}

compiling with g++ -pedantic gives the warning:

 warning: ISO C++ forbids variable length array ‘local_array’ [-Wvla]

another example where compilation actually fails:

const int arr1[1] = {5};
int arr2[arr1[0]];

error: array bound is not an integer constant before ']' token

As for using an array value as a an argument to a global constructor, both constructor calls here are fine:

// [...ArrayHolder definition here...]
class IntegerWrapper{
    public:
        int value;
        IntegerWrapper(int i) : value(i) {}
};


const int (&arr)[COUNT] = array_holder.array;

const int arr1[1] = {5};

IntegerWrapper iw1(arr1[0]); //using = {5}
IntegerWrapper iw2(arr[0]);  //using const reference

Additionally the order of initalization of global variables across different source files is not defined, you can't guarantee the arr = {-1, -1, -1}; won't happen until run time. If the compiler is optimizing out the initialization, then you're relying on implementation, not the standard.

The point I really wanna stress here is: int arr[COUNT] = {-1, -1, -1}; is still runtime initialization unless it can get optimized out. The only way you could rely on it being constant would be to use C++11's constexpr but you don't have that available.