Is there a way to access all enumerations in a enum class with a using directive or similar? [duplicate]

Question

I have a enum class which is used to clearly store the kinds of tokens which are passed into a parser for a calculator. The enum class looks like this:

enum class TokenKind
{
    Number,
    WhiteSpace, 
    Parenthesis,
    Multiplication,
    Divition,
    Plus,
    Minus,
    Name
};

Using the scope specifier :: to access the enum types of TokenKind works great for the most part. But I have a single syntax checking method which gets very unreadable having to use the scope specifier every time.

For only this method it would be more readable to use something like:

bool Parser::validSyntax(const std::vector<Token> tokens)
{
    using namespace TokenKind;
    
    {
        const TokenKind firstKind = tokens.begin()->getKind();
        const TokenKind lastKind = (tokens.end() - 1)->getKind();
        switch(firstKind)
        {
            case Plus: case Divition: 
            case Multplication:
                return false;
        }

        switch(lastKind)
        {
            case Plus: case Minus:
            case Divition: case Multiplication:
                return false;
        }
    }

    for (auto it = tokens.begin(); it < tokens.end() - 1; ++it)
    {
        const TokenKind kind = it->getKind();
        const TokenKind nextKind = std::next(it)->getKind();

        switch(kind)
        {
            case Plus: case Minus:
            case Divition: case Multiplication:
                if (nextKind != Number && nextKind != Name && nextKind != Minus) return false;
            
            case Number: case Name:
                if (nextKind != Plus && nextKind != Minus &&
                nextKind != Divition && nextKind != Multiplication) return false;
        }
    }
    return true;
}

But using namespace ClassName; is not valid syntax. Is there another way to achieve the behavior I am looking for? I am still quite new to C++ and have not nearly discovered all its functionalities.

Is it a requirements to have a scoped enumeration? Why not plain enum TokenKind { ... };? — Some programmer dude
– Some programmer dude, Commented May 12, 2024 at 12:56
@Someprogrammerdude The main reason I used enum class was such that it would be safer in other parts of my program in case I added more enums. But since I currently only have a single enum the plain one works fine in this use case I guess. — a_floating_point
– a_floating_point, Commented May 12, 2024 at 13:00
Well you could put it in a namespace or a class, limiting scoping of the names. But if it's possible to use C++20 features there seems to be better solutions (as shown in the answer or the voted duplicate). — Some programmer dude
– Some programmer dude, Commented May 12, 2024 at 13:02

NathanOliver · Accepted Answer · 2024-05-12 12:58:00Z

6

C++20 introduced the using enum directive that allows you to import the names of the specified enumeration into the scope.

In your case you would change

using namespace TokenKind;

to

using enum TokenKind;

answered May 12, 2024 at 12:58

NathanOliver

183k29 gold badges323 silver badges439 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

Is there a way to access all enumerations in a enum class with a using directive or similar? [duplicate]

1 Answer 1

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Linked

Related