Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14 - [32]

:

enum class Status; // Базовый тип — int

Если вас не устраивает значение по умолчанию, вы можете его перекрыть:

enum class Status: std::uint32_t; // Базовый тип для Status -
                                  // std::uint32_t (из )

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

Чтобы указать базовый тип для перечисления без области видимости, вы делаете то же, что и для перечисления с областью видимости, и полученный результат может быть предварительно объявлен:

enum Color: std::uint8_t; // Предварительное объявление
                          // перечисления без области видимости;
                          // базовый тип - std::uint8_t

Спецификация базового типа может быть указана и в определении enum:

enum class Status: std::uint32_t { good = 0,
                                   failed = 1,
                                   incomplete = 100,
                                   corrupt = 200,
                                   audited = 500,
                                   indeterminate = 0xFFFFFFFF
};

С учетом того факта, что enum с областью видимости устраняет загрязнение пространства имен и невосприимчиво к бессмысленным преобразованиям типов, вас может удивить тот факт, что имеется как минимум одна ситуация, в которой могут быть полезны перечисления без области видимости, а именно — при обращении к полям в кортежах C++11 std::tuple. Предположим, например, что у нас есть кортеж, содержащий имя, адрес электронной почты и значение репутации пользователя на сайте социальной сети:

using UserInfo =          // Псевдоним типа; см. раздел 3.3
std::tuple
           std::string,   // Адрес
           std::size_t> ; // Репутация
Хотя комментарии указывают, что представляет собой каждое поле кортежа, это, вероятно, не слишком полезно, когда вы сталкиваетесь с кодом наподобие следующего в отдельном исходном файле:
UserInfo uInfo;                // Объект с типом кортежа
…
auto val = std::get<1>(uInfo); // Получение значения поля 1
Как программисту вам приходится отслеживать множество вещей. Вы действительно должны помнить, что поле 1 соответствует адресу электронной почты пользователя? Я думаю, нет. Использование enum без области видимости для сопоставления имен полей с их номерами позволяет избежать необходимости перегружать память:
enum UserInfoFields { uiName, uiEmail, uiReputation };

UserInfo uInfo;                      // Как и ранее
…
auto val = std::get<uiEmail>(uInfo); // Значение адреса

Все было бы гораздо сложнее без неявного преобразования значений из UserInfoFields в тип std::size_t, который является типом, требующимся для std::get.

Соответствующий код с применением перечисления с областью видимости существенно многословнее:

enum class UserInfoFields { uiName, uiEmail, uiReputation };

UserInfo uInfo; // Как и ранее
…
auto val =
 std::get<static_cast(UserInfoFields::uiMail)>
  (uInfo);

Эта многословность может быть сокращена с помощью функции, которая принимает перечислитель и возвращает соответствующее значение типа std::size_t, но это немного сложнее. std::get является шаблоном, так что предоставляемое значение является аргументом шаблона (обратите внимание на применение не круглых, а угловых скобок), так что функция, преобразующая перечислитель в значение std::size_t, должна давать результат во время компиляции. Как поясняется в разделе 3.9, это означает, что нам нужна функция, являющаяся constexpr.

Фактически это должен быть constexpr-шаблон функции, поскольку он должен работать с любыми перечислениями. И если мы собираемся делать такое обобщение, то должны обобщить также и возвращаемый тип. Вместо того чтобы возвращать std::size_t, мы должны возвращать базовый тип перечисления. Он доступен с помощью свойства типа std::underlying_type (о свойствах типов рассказывается в разделе 3.3). Наконец мы объявим его как noexcept (см. раздел 3.8), поскольку мы знаем, что он никогда не генерирует исключений. В результате мы получим шаблон функции toUType, который получает произвольный перечислитель и может возвращать значение как константу времени компиляции:

template
constexpr typename std::underlying_type::type
toUType(E enumerator) noexcept
{
 return
  static_cast
   std::underlying_type::type>(enumerator);
}
В С++14 toUType можно упростить заменой typename std::underlying_type::type  более изящным std::underlying_type_t (см. раздел 3.3):
template // С++14
constexpr std::underlying_type_t
toUType(E enumerator) noexcept {
 return static_cast_t>(enumerator);
}
Еще более изящный возвращаемый тип auto (см. раздел 1.3) также корректен в С++14:
template // С++14
constexpr auto
toUType(E enumerator) noexcept {
 return static_cast>(enumerator);
}
Независимо от того, как он написан, шаблон toUType позволяет нам обратиться к полю кортежа следующим образом:
auto val = std::get<toUType(UserInfoFields::uiEmail)>(uInfo);
Это все же больше, чем достаточно написать при использовании перечисления без области видимости, но зато позволяет избежать загрязнения пространства имен и непреднамеренных преобразований перечислителей. Во многих случаях вы можете решить, что набор нескольких дополнительных символов является разумной ценой за возможность избежать ловушек перечислений, появление которых восходит ко времени, когда вершиной достижений в цифровых телекоммуникациях был модем со скоростью 2400 бод.