static_assert on array values

Question

Is it possible to have a compile-time check on array values?

example:

typedef enum
{
    dummy0 = 0,
    dummy1,
    dummy2
} eDummyEnum;

typedef struct
{
    eDummyEnum name;
    int value;
} sDummyStruct;

const sDummyStruct array[]=
{
    {dummy0, 3},
    {dummy1, 5},
    {dummy2, 6}
}

Is there any possibility to check if array[dummy1].name == dummy1 at compilation time?

Answer 1

Something along these lines, perhaps:

constexpr sDummyStruct array[]=
{
    {dummy0, 3},
    {dummy1, 5},
    {dummy2, 6}
};

constexpr bool checkArray(int index) {
    return (index >= sizeof(array)/sizeof(array[0])) ||
           (array[index].name == index && checkArray(index + 1));          
}

static_assert(checkArray(0), "bad array");

Live demo

Answer 2

I guess, this could be made a bit more efficient but I think the following code does work correctly:

template <typename T, int N>
constexpr int size(T(&)[N]) {
    return N;
}

template <int I, int J>
struct check_name {
    static constexpr bool check() {
        return array[I].name != array[J].name
            && check_name<I + 1, J>::check()
            && check_name<I, J - 1>::check();
    }
};

template <int I>
struct check_name<I, I> {
    static constexpr bool check() { return true; }
};
constexpr bool check_names() {
    return check_name<0, size(array) - 1>::check();
}

static_assert(check_names(), "duplicate names");