[Перевод] Эволюция enum19.12.2023 17:15

Константы — это здорово. Типы — это замечательно. Константы определенного типа — еще лучше. А enum классы — это просто фантастика.

В прошлом году мы говорили о том, почему следует избегать использования булевых параметров функций. Одно из предложенных решений — использование сильных типов, в частности, использование перечислений вместо голых булевых значений. В этот раз давайте посмотрим, как развивались перечисления и связанная с ними поддержка на протяжении всего жизненного пути нашего любимого языка.

Unscoped перечисления

Перечисления являются частью оригинального языка C++, фактически, они были заимствованы из C. Перечисления — это отдельные типы с ограниченным диапазоном значений. Диапазон значений ограничивается некоторыми явно прописанными константами. Ниже приведен пример классического перечисления:

enum Color { red, green, blue };

Посмотрев на этот небольшой пример, можно обратить внимание на две вещи:

• Само перечисление (enum) — это существительное в единственном числе, даже несмотря на то, что обычно оно перечисляет несколько значений. Мы используем такое соглашение, потому что понимаем, что оно всегда будет использоваться с одним значением. Если вы берете параметр функции Color, то будет взят один цвет. Когда вы сравниваете со значением, вы будете сравнивать с одним значением. Например, логичнее сравнивать с Color::red, чем с Colors::red.

• Значения перечислителей прописываются в нижнем регистре, а не капсом (ALL_CAPS)! Хотя есть большая вероятность, что вы привыкли писать их именно капсом. Я тоже так делал. Почему же я в итоге изменил своей традиции? Потому что для написания этой статьи я проверил core guidelines, и в Enum.5 четко сказано, что мы не должны использовать капс, чтобы избежать конфликтов с макросами. Кстати, в Enum.1 также сказано, что мы должны использовать перечисления, а не макросы.

Начиная с C++11, количество возможностей для объявления enum увеличилось. В C++11 появилась возможность указывать базовый тип (underlying type) перечисления. Если он не определен, то базовый тип определяется реализацией, но в любом случае это будет целочисленный тип.

Как его определить? С точки зрения синтаксиса это будет выглядеть немного похожим на наследование! Хотя здесь не нужно определять уровни доступа:

enum Color : int { red, green, blue };

Благодаря этому вы можете быть уверены в том, какой тип будет базовым. Тем не менее, это должен быть целочисленный тип! Например, это не может быть строка. Если вы попробуете указать ее в качестве базового типа, то получите явное сообщение об ошибке:

main.cpp:4:19: error: underlying type 'std::string' {aka 'std::__cxx11::basic_string'} of 'Color' must be an integral type
    4 | enum Color : std::string { red, green, blue };
      |                   ^~~~~~

Обратите внимание, что core guidelines не рекомендуют использовать эту практику! Указывать базовый тип следует только в том случае, если это необходимо.

Когда это может быть необходимо? Можно выделить две распространенные ситуации:

• Если вы знаете, что количество вариантов будет очень ограничено, и хотите сэкономить немного памяти:

enum Direction : char { north, south, east, west,
   northeast, northwest, southeast, southwest }; 

• Или, если вы делаете предварительное объявление (forward declare) enum, вы также должны объявить и тип:

enum Direction : char;
void navigate(Direction d);

enum Direction : char { north, south, east, west,
     northeast, northwest, southeast, southwest };

Вы также можете указать точное значение одного или всех перечисляемых значений, если они являются constexpr.

enum Color : int { red = 0, green = 1, blue = 2 };

И снова core guidelines рекомендует не делать этого, если на это нет особой необходимости! Как только вы начнете это делать, можно легко ошибиться и все испортить. В любом случае, мы можем рассчитывать на то, что компилятор присвоит последующие значения последующим значениям перечислителя.

• Хорошим юзкейсом для указания значения перечислителя является определение только начального значения. Например, если вы определяете месяцы и не хотите начинать с нуля.

enum Month { jan = 1, feb, mar, apr, may, jun,
                 jul, august, sep, oct, nov, dec };

• Другая причина может заключаться в том, что вы хотите определить значения в виде некоторого значимого символа

enum altitude: char {
  high = 'h',
  low = 'l'
}; 

• Еще одной причиной может быть эмуляция некоторых битовых полей. То есть вам не нужны последующие значения, вместо этого вы всегда хотите получать следующую степень двойки

enum access_type { read = 1, write = 2, exec = 4 };

Scoped перечисления

В предыдущем разделе мы видели объявления типа enum EnumName{};. В C++11 появился новый тип перечислений, называемый scoped (с ограничением на область видимости) enum. Они объявляются либо с помощью ключевых слов class, либо struct (между ними нет никакой разницы).

Их синтаксис следующий:

enum class Color { red, green, blue };

Для scoped перечислений базовый тип по умолчанию определен в стандарте, и это int. Это также означает, что если вы хотите предварительно объявить перечисление, вам не нужно указывать базовый тип. Если он должен быть int, то этого будет достаточно:

enum class Color;

Но какие еще существуют различия, помимо синтаксических различий между способами их объявления?

Unscoped перечисления могут быть неявно преобразованы к своему базовому типу. Неявные преобразования — это часто не то, что вам нужно, и у scoped перечислений нет такой «особенности». Именно из-за нежелательности неявных преобразований core guidelines настоятельно рекомендует использовать scoped, а не unscoped перечисления.

void Print_color(int color);

enum Web_color { red = 0xFF0000, green = 0x00FF00, blue = 0x0000FF };
enum Product_info { red = 0, purple = 1, blue = 2 };

Web_color webby = Web_color::blue;

// Clearly at least one of these calls is buggy.
Print_color(webby);
Print_color(Product_info::blue);

Unscoped перечисления экспортируют свои перечислители в объемлющую область видимости, что может привести к конфликту имен. С другой стороны, при использовании scoped перечислений вы всегда должны указывать имя перечисления вместе с перечислителями.

enum UnscopedColor { red, green, blue };
enum class ScopedColor { red, green, blue };

int main() {
    [[maybe_unused]] UnscopedColor uc = red;
    // [[maybe_unused]] ScopedColor sc = red; // Doesn't compile
    [[maybe_unused]] ScopedColor sc = ScopedColor::red;
}

Что еще?

Теперь, когда мы разобрались, как работают scoped/unscoped перечисления и чем они отличаются друг от друга, давайте посмотрим, какие еще функции, связанные с перечислениями, предлагает язык или стандартная библиотека.

std: is_enum

В C++11 появился заголовок . Он включает утилиты для проверки свойств типов. Неудивительно, что is_enum проверяет, является ли тип перечислением или нет. Он возвращает true как для scoped, так и для unscoped версий.

Начиная с C++17, также доступен более удобный is_enum_v.

#include 
#include 

enum UnscopedColor { red, green, blue };
enum class ScopedColor { red, green, blue };
struct S{};

int main() {
    std::cout << std::boolalpha
              << std::is_enum::value << '\n'
              << std::is_enum::value << '\n'
              << std::is_enum_v << '\n';
}

#include 
#include 

enum UnscopedColor { red, green, blue };
enum class ScopedColor { red, green, blue };
enum class CharBasedColor : char { red = 'r', green = 'g', blue = 'b' };

int main() {
 
  constexpr bool isUnscopedColorInt = std::is_same_v< std::underlying_type::type, int >;
  constexpr bool isScopedColorInt = std::is_same_v< std::underlying_type_t, int >;
  constexpr bool isCharBasedColorInt = std::is_same_v< std::underlying_type_t, int >;
  constexpr bool isCharBasedColorChar = std::is_same_v< std::underlying_type_t, char >;

  std::cout
    << "underlying type for 'UnscopedColor' is " << (isUnscopedColorInt ? "int" : "non-int") << '\n'
    << "underlying type for 'ScopedColor' is " << (isScopedColorInt ? "int" : "non-int") << '\n'
    << "underlying type for 'CharBasedColor' is " << (isCharBasedColorInt ? "int" : "non-int") << '\n'
    << "underlying type for 'CharBasedColor' is " << (isCharBasedColorChar ? "char" : "non-char") << '\n'
    ;
}

#include 

enum class ScopedColor { red, green, blue };
enum class CharBasedColor : char { red = 'r', green = 'g', blue = 'b' };

int main() {
  using enum ScopedColor; // OK!
  using enum CharBasedColor; // error: 'CharBasedColor CharBasedColor::red' conflicts with a previous declaration
}

#include 

enum UnscopedColor { red, green, blue };
enum class ScopedColor { red, green, blue };

int main() {
  using enum ScopedColor;
}

#include 
#include 
 
enum UnscopedColor { red, green, blue };
enum class ScopedColor { red, green, blue };
struct S{};

int main() 
{
    std::cout << std::boolalpha;
    std::cout << std::is_scoped_enum::value << '\n';
    std::cout << std::is_scoped_enum_v << '\n';
    std::cout << std::is_scoped_enum_v << '\n';
    std::cout << std::is_scoped_enum_v << '\n';
}
/*
false
true
false
false
*/

#include 
#include 
#include 
 
enum class ScopedColor { red, green, blue };

int main() 
{
    ScopedColor sc = ScopedColor::red;
    [[maybe_unused]] int underlying = std::to_underlying(sc);
    [[maybe_unused]] int underlyingEmulated = static_cast>(sc);
    [[maybe_unused]] std::underlying_type_t underlyingDeduced = std::to_underlying(sc);
}