A way to use all the unqualified names in a C++0x enum class?

Question

The new C++ (C++0x or C++11) has an new kind of enum, an "enum class" where the names are scoped to the enum (among other things).

enum class E {
    VAL1, VAL2
};

void fun() {
    E e = E::VAL1;  // Qualified name
}

I'm wondering, however, if I can selectively use the unqualified name in a certain scope. Something like:

void fun() {
    using E::*;
    E e = VAL1;
    switch (e) {
        case VAL2: ...

I see I can write using E::VAL1 and get one value. But I don't want to do that for every value of a larger enum.

If I may ask, what compiler are you using? A bug report for being able to 'using E::Val1;' is in order. — emsr, Sep 18 '11 at 16:36
I missed this comment years ago. It was, and still is, clang. Now version 4.0. — Rob N, Mar 06 '13 at 13:39
Is clang4 still not getting this? Surprising. I was/am working gcc - now 4.8. This works there. — emsr, Mar 06 '13 at 16:43

score 7 · Accepted Answer · answered Sep 17 '11 at 19:11

There is no way to do this in C++11. Just in case you are not aware of it - you get the E::Val1 notation even for an unscoped enumeration. For such an enumeration, you have Val1 accessible with and without the use of E::.

But you cannot take a scoped enumeration and selectively make all its enumerators visible in a given scope. It should also be noted that you can not write using E::Val1. The spec explicitly forbids this, your compiler just doesn't reject it yet.

For the curious, §7.3.3/7 reads "A using-declaration shall not name a scoped enumerator." — Potatoswatter, Sep 17 '11 at 21:15

Potatoswatter · Answer 2 · 2011-09-19T03:35:36.810

This is also something I happen to want, but haven't gotten around to trying to solve. Here's an ~~untested~~ solution. EDIT: I tried it out and it works great! This is my very first C++11 utility macro. Also I added a one-past-the-end enumerator to help extend it to "derived" enumerations.

#define IMPORTABLE_ENUM( TYPENAME, ... ) \
\
struct import_ ## TYPENAME { \
    enum TYPENAME { \
        __VA_ARGS__ \
    }; \
}; \
\
typedef import_ ## TYPENAME :: TYPENAME TYPENAME;

This cannot be imported into a block scope, but defines a base class import_duck to bring the enumerators into a class. Usage:

IMPORTABLE_ENUM ( duck, huey, dewey, louie )

duck d = duck::dewey; // can't use unscoped enumerators here

struct duck_madness : private import_duck { // but inside a derived class
    duck who_did_it() { return huey; } // qualification is unnecessary
}

And since there is only one enum type even among derived classes, no static_cast is ever required.

A way to use all the unqualified names in a C++0x enum class?

2 Answers2

Linked