How to statically assert if enumeration constant is defined?

Question

I've this C++14 code:

#include <type_traits>

struct f1 {
    enum struct e { a };
};

struct f2 {
    enum struct e {};
};

template <typename T>
struct my_struct {
    using e = typename T::e;
    my_struct()
    : _e{e::a} {} // e::a used here
    e _e;
};

int main() {
    my_struct<f1> a;
    my_struct<f2> b; // compilation fails
}

Obviously the compilation fails with something like 'a' is not a member of 'my_struct<f2>::e'. I really would like to add some static assertions to my_struct, to add a custom error message. First of all, I can check if e is actually an enumeration:

static_assert(std::is_enum<e>::value, "my message");

Then, what should I add to statically assert that e::a is defined?

score 3 · Accepted Answer · answered Jun 15 '20 at 11:36

3

The same way as you would detect any nested declaration:

template <typename T, typename = void>
struct enum_defines_a : std::false_type {};

template <typename T>
struct enum_defines_a<T, decltype(void(T::a))> : std::is_enum<T> {};

static_assert(enum_defines_a<e>::value, "Enum doesn't define 'a'");

answered Jun 15 '20 at 11:36

Piotr Skotnicki

46,953
7
118
160

Why is `void(...)` needed? – Giovanni Cerretani Jun 16 '20 at 11:55
@GiovanniCerretani For convenience, so you can avoid specifying the second template argument of `enum_defines_a`. Then, the compiler inserts the default `void`, and searches for a partial specialization. It finds one, because a valid `T::a` is cast to `void`. – Piotr Skotnicki Jun 16 '20 at 11:59
@GiovanniCerretani [How does `void_t` work](https://stackoverflow.com/q/27687389/3953764) – Piotr Skotnicki Jun 16 '20 at 12:05

score 0 · Answer 2 · answered Jun 15 '20 at 11:52

You could use SFINAE to solve this problem. Consider the following code:

template <class T>
class has_a
{
    template <class C>
    static std::true_type test(C, C = C::a);

    template <class C>
    static std::false_type test(...);

public:
    using type = T;
    static bool constexpr value = decltype(test<T>(T{}))::value;
};

Then, you can just:

static_assert(has_a<e>::value, "Given type is incorrect.");

How to statically assert if enumeration constant is defined?

2 Answers2