Implementacja wartości wyliczenia kołowego

Question

Jaki byłby najlepszy sposób implementacji wyliczenia za pomocą wartości cyklicznych i odpowiednich funkcji do przejścia z wartości do drugiej?

Na przykład:

enum class Direction { 
    NORTH, EAST, SOUTH, WEST 
}; 

constexpr Direction left(Direction d) { 
    return (Direction)((std::underlying_type<Directions>::type(d) - 1) % 4); 
} 

Jednak czuję, że jest podatny na błędy i ogólnie nieczytelne. Czy istnieje lepszy sposób radzenia sobie z tego typu wyliczeniami?

Answer 1

Zawsze możesz zrobić:

enum class Direction { 
    NORTH, EAST, SOUTH, WEST, NUMBER_OF_DIRECTIONS 
}; 

constexpr Direction left(Direction d) { 
    using ut = std::underlying_type<Direction>::type; 
    return (Direction)((ut(d) + ut(Direction::NUMBER_OF_DIRECTIONS)-1) 
         % ut(Direction::NUMBER_OF_DIRECTIONS)); 
} 

Wykorzystanie example/mały test:

#include <iostream> 

std::ostream& operator<<(std::ostream& os, Direction d) 
{ 
    switch(d) 
    { 
     case Direction::NORTH: return os << "NORTH"; 
     case Direction::EAST : return os << "EAST"; 
     case Direction::SOUTH: return os << "SOUTH"; 
     case Direction::WEST : return os << "WEST"; 
     default    : return os << "invalid"; 
    } 
} 

int main() 
{ 
    Direction d = Direction::NORTH; 
    for(int i = 0; i < 2*(int)Direction::NUMBER_OF_DIRECTIONS; ++i) 
    { 
     std::cout << d << "\n"; 
     d = left(d); 
    } 
} 

wyjściowa:

 
NORTH 
WEST 
SOUTH 
EAST 
NORTH 
WEST 
SOUTH 
EAST 

Live example