Conditional compilation (constexpr if) and "ISO C++ forbids zero-size array"

Question

With the following code:

#include <algorithm>

constexpr int DATA_SIZE = 5;

constexpr int A_ARRAY_ALLOWED_SIZE = 5;
constexpr int A_ARRAY_SIZE = std::min(A_ARRAY_ALLOWED_SIZE, DATA_SIZE);
constexpr int B_ARRAY_SIZE = DATA_SIZE - A_ARRAY_ALLOWED_SIZE;

class A {
    int a[A_ARRAY_SIZE];
};

class B {
    int b[B_ARRAY_SIZE];
};

int main()
{
    A a;
    
    if constexpr (B_ARRAY_SIZE)
    {
        B b;
    }

    return 0;
}

I'm getting compiler error (with -pedantic flag) which complains that zero-size array is not allowed. In my example the object with the zero size array is never created but looks like it is still an issue.

I was trying to workaround it with usage of std::conditional but even then I ended up with an additional function like:

constexpr int Get_B_ARRAY_SIZE()
{
    if (B_ARRAY_SIZE)
        return B_ARRAY_SIZE;
    return 1; // workaround for zero-size array
}

What is a proper way of handling such an issue?

EDIT: I'm aware that all of if branches should contain valid code. I'm also aware that zero-size arrays are not allowed. My question is how to refactor this code to get similar behawior like when compiling without -pedantic flag. I suspect that I can use template meta programming to achieve this purpose but I'm not sure how to do it.

`if constexpr` only has its magic power in templates, when the condition depends on a template parameter. Your actual code is templated, isn't it? — HolyBlackCat, Feb 01 '23 at 18:07
Possibly a dupe of [this question](https://stackoverflow.com/questions/63469333/why-does-the-false-branch-of-if-constexpr-get-compiled) — Nathan Pierson, Feb 01 '23 at 18:07
@HolyBlackCat No, it is not templated. I suspect that I can use template meta programming to fix it. But I'm not sure how. — Adam, Feb 01 '23 at 18:12
You get this error whether or not `B` is actually instantiated anywhere in the code (so constexpr around instantiations won't help). You could probably get away with `int b[std::max(B_ARRAY_SIZE, 1)]` and then `if constexpr` to only instantiate the class when the size is not zero. — Dean Johnson, Feb 01 '23 at 18:13
The code says that the class `B` has a member named `b` that's an array of size 0. That's not allowed. Doesn't matter whether `B` is used or not. — Pete Becker, Feb 01 '23 at 18:20
@PeteBecker I'm aware of this. My question is how to refactor this code to have possibility to create B class when `B_ARRAY_SIZE > 0` and be able to compile whole program even if `B_ARRAY_SIZE == 0`. — Adam, Feb 01 '23 at 18:27
Are you looking for macros? Use them for the constants, then you can hide unwanted code parts behind `#if`. And perhaps override the values from the command line. — HolyBlackCat, Feb 01 '23 at 18:32
@HolyBlackCat I was hoping to avoid usage of `#if`. The use case... the code base is pretty big and there is a lot of dependencies. It is hard to describe all of dependencies here. — Adam, Feb 01 '23 at 18:58
Use macros. It's weird to have to change code to alter configuration variables. Those changes should be done with compiler flags (by defining macros from there). — HolyBlackCat, Feb 01 '23 at 19:14

sklott · Answer 1 · 2023-02-01T19:39:28.477

If you need equivalent of std::conditional, but for values, rather than types, you can do it like this:

#include <iostream>
#include <type_traits>

template<size_t N>
struct safe_array_size : std::integral_constant<size_t, N> {};

template<>
struct safe_array_size<0> : std::integral_constant<size_t, 1> {};

int main()
{
    char a[safe_array_size<0>::value];
    char b[safe_array_size<1>::value];
    std::cout << sizeof(a) << std::endl;
    std::cout << sizeof(b) << std::endl;
}

Or using std::conditional:

#include <iostream>
#include <type_traits>

template<size_t N>
constexpr size_t safe_array_size = std::conditional_t<N==0, std::integral_constant<size_t, 1>, std::integral_constant<size_t, N>>::value;

int main()
{
    char a[safe_array_size<0>];
    char b[safe_array_size<1>];
    std::cout << sizeof(a) << std::endl;
    std::cout << sizeof(b) << std::endl;
}

Dean Johnson · Answer 2 · 2023-02-01T22:45:28.473

if constexpr (at least, how you are using it) cannot directly work around this error because it is the class definition that is ill-formed. Whether or not you instantiate the class is irrelevant. You can fix this by ensuring that the array size is never zero with std::max:

#include <algorithm>

constexpr int DATA_SIZE = 5;

constexpr int A_ARRAY_ALLOWED_SIZE = 5;
constexpr int A_ARRAY_SIZE = std::min(A_ARRAY_ALLOWED_SIZE, DATA_SIZE);
constexpr int B_ARRAY_SIZE = DATA_SIZE - A_ARRAY_ALLOWED_SIZE;

class A {
    int a[A_ARRAY_SIZE];
};

class B {
    int b[std::max(B_ARRAY_SIZE, 1)];
};

int main()
{
    A a;
    
    if constexpr (B_ARRAY_SIZE)
    {
        B b;
    }

    return 0;
}

Note that std::max is constexpr as of C++14. You could implement your own max function if you are on C++11.

If you need to ensure that the class is never actually instantiated unless the array size is non-zero, the if constexpr check in the above code will handle that.

Conditional compilation (constexpr if) and "ISO C++ forbids zero-size array"

2 Answers2