Почему класс перечисления предпочтительнее простого перечисления?

Из часто задаваемых вопросов по C ++ 11 Бьярна Страуструпа:

enum classes («новые перечисления», «строгие перечисления») решают три проблемы с традиционными перечислениями C ++:

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

Новые перечисления являются «классом перечисления», потому что они сочетают в себе аспекты традиционных перечислений (имена значений) с аспектами классов (элементы с заданной областью действия и отсутствие преобразований).

Итак, как отмечали другие пользователи, «сильные перечисления» сделают код более безопасным.

Базовый тип «классического» enum должен быть целочисленным типом, достаточно большим, чтобы соответствовать всем значениям enum; обычно это int. Также каждый перечислимый тип должен быть совместим с char или целочисленным типом со знаком / без знака.

Это подробное описание того, каким должен быть enum базовый тип, поэтому каждый компилятор будет принимать решения о базовом типе классического enum самостоятельно, и иногда результат может быть удивительным.

Например, я встречал такой код несколько раз:

enum E_MY_FAVOURITE_FRUITS
{
    E_APPLE      = 0x01,
    E_WATERMELON = 0x02,
    E_COCONUT    = 0x04,
    E_STRAWBERRY = 0x08,
    E_CHERRY     = 0x10,
    E_PINEAPPLE  = 0x20,
    E_BANANA     = 0x40,
    E_MANGO      = 0x80,
    E_MY_FAVOURITE_FRUITS_FORCE8 = 0xFF // 'Force' 8bits, how can you tell?
};

В приведенном выше коде какой-то наивный программист думает, что компилятор сохранит значения E_MY_FAVOURITE_FRUITS в беззнаковый 8-битный тип ... но на это нет никаких гарантий: компилятор может выбрать unsigned char, int или short, любой из этих типов достаточно велик чтобы соответствовать всем значениям, указанным в enum. Добавление поля E_MY_FAVOURITE_FRUITS_FORCE8 является обузой и не заставляет компилятор делать какой-либо выбор в отношении базового типа enum.

Если есть какой-то фрагмент кода, который полагается на размер типа и / или предполагает, что E_MY_FAVOURITE_FRUITS будет иметь некоторую ширину (например, процедуры сериализации), этот код может вести себя странным образом в зависимости от мыслей компилятора.

И что еще хуже, если какой-то напарник по неосторожности добавит новое значение к нашему enum:

    E_DEVIL_FRUIT  = 0x100, // New fruit, with value greater than 8bits

Компилятор на это не жалуется! Он просто изменяет размер типа, чтобы он соответствовал всем значениям enum (при условии, что компилятор использовал наименьший возможный тип, что является предположением, которое мы не можем сделать). Это простое и неосторожное дополнение к enum могло незаметно нарушить связанный код.

Поскольку в C ++ 11 можно указать базовый тип для enum и enum class (спасибо, rdb), поэтому эта проблема аккуратно решена :

enum class E_MY_FAVOURITE_FRUITS : unsigned char
{
    E_APPLE        = 0x01,
    E_WATERMELON   = 0x02,
    E_COCONUT      = 0x04,
    E_STRAWBERRY   = 0x08,
    E_CHERRY       = 0x10,
    E_PINEAPPLE    = 0x20,
    E_BANANA       = 0x40,
    E_MANGO        = 0x80,
    E_DEVIL_FRUIT  = 0x100, // Warning!: constant value truncated
};

Указание базового типа, если поле имеет выражение вне диапазона этого типа, компилятор будет жаловаться вместо изменения базового типа.

Я считаю, что это хорошее улучшение безопасности.

Итак, Почему класс перечисления предпочтительнее простого перечисления?, если мы можем выбрать базовый тип для перечислений с ограниченным (enum class) и без области действия (enum), что еще делает enum class лучшим выбором ?:

• Они не конвертируются в int неявно.
• Они не загрязняют окружающее пространство имен.
• Они могут быть заявлены заранее.

Основное преимущество использования класса enum по сравнению с обычными перечислениями заключается в том, что у вас могут быть одинаковые переменные перечисления для двух разных перечислений, и вы все равно можете их разрешать (что было упомянуто OP как типобезопасное)

Например:

enum class Color1 { red, green, blue };    //this will compile
enum class Color2 { red, green, blue };

enum Color1 { red, green, blue };    //this will not compile 
enum Color2 { red, green, blue };

Что касается основных перечислений, компилятор не сможет различить, ссылается ли red на тип Color1 или Color2, как в инструкции ниже.

enum Color1 { red, green, blue };   
enum Color2 { red, green, blue };
int x = red;    //Compile time error(which red are you refering to??)

Перечисления используются для представления набора целочисленных значений.

Ключевое слово class после enum указывает, что перечисление строго типизировано и его перечислители имеют ограниченную область видимости. Таким образом enum классы предотвращают случайное неправильное использование констант.

Например:

enum class Animal{Dog, Cat, Tiger};
enum class Pets{Dog, Parrot};

Здесь нельзя смешивать значения Animal и Pets.

Animal a = Dog;       // Error: which DOG?    
Animal a = Pets::Dog  // Pets::Dog is not an Animal

1. не неявно преобразовывать в int
2. можете выбрать, какой тип лежит в основе
3. ENUM, чтобы избежать загрязнения
4. По сравнению с обычным классом, может быть объявлен вперед, но не имеет методов

Помимо этих других ответов, стоит отметить, что C ++ 20 решает одну из проблем enum class: многословие. Представляя гипотетический enum class, Color.

void foo(Color c)
  switch (c) {
    case Color::Red: ...;
    case Color::Green: ...;
    case Color::Blue: ...;
    // etc
  }
}

Это многословно по сравнению с простым вариантом enum, где имена находятся в глобальной области и, следовательно, не нуждаются в префиксе Color::.

Однако в C ++ 20 мы можем использовать using enum для введения всех имен в перечислении в текущую область видимости, решая проблему.

void foo(Color c)
  using enum Color;
  switch (c) {
    case Red: ...;
    case Green: ...;
    case Blue: ...;
    // etc
  }
}

Итак, теперь нет причин не использовать enum class.

C ++ 11 FAQ упоминает следующие моменты:

обычные перечисления неявно преобразуются в int, вызывая ошибки, когда кто-то не хочет, чтобы перечисление действовало как целое число.

enum color
{
    Red,
    Green,
    Yellow
};

enum class NewColor
{
    Red_1,
    Green_1,
    Yellow_1
};

int main()
{
    //! Implicit conversion is possible
    int i = Red;

    //! Need enum class name followed by access specifier. Ex: NewColor::Red_1
    int j = Red_1; // error C2065: 'Red_1': undeclared identifier

    //! Implicit converison is not possible. Solution Ex: int k = (int)NewColor::Red_1;
    int k = NewColor::Red_1; // error C2440: 'initializing': cannot convert from 'NewColor' to 'int'

    return 0;
}

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

// Header.h

enum vehicle
{
    Car,
    Bus,
    Bike,
    Autorickshow
};

enum FourWheeler
{
    Car,        // error C2365: 'Car': redefinition; previous definition was 'enumerator'
    SmallBus
};

enum class Editor
{
    vim,
    eclipes,
    VisualStudio
};

enum class CppEditor
{
    eclipes,       // No error of redefinitions
    VisualStudio,  // No error of redefinitions
    QtCreator
};

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

// Header1.h
#include <iostream>

using namespace std;

enum class Port : unsigned char; // Forward declare

class MyClass
{
public:
    void PrintPort(enum class Port p);
};

void MyClass::PrintPort(enum class Port p)
{
    cout << (int)p << endl;
}

.

// Header.h
enum class Port : unsigned char // Declare enum type explicitly
{
    PORT_1 = 0x01,
    PORT_2 = 0x02,
    PORT_3 = 0x04
};

.

// Source.cpp
#include "Header1.h"
#include "Header.h"

using namespace std;
int main()
{
    MyClass m;
    m.PrintPort(Port::PORT_1);

    return 0;
}

Поскольку, как сказано в других ответах, перечисление классов не может быть неявно преобразовано в int / bool, это также помогает избежать ошибочного кода, например:

enum MyEnum {
  Value1,
  Value2,
};
...
if (var == Value1 || Value2) // Should be "var == Value2" no error/warning

Одна вещь, о которой явно не упоминалось, - функция области дает вам возможность иметь одно и то же имя для метода перечисления и класса. Например:

class Test
{
public:
   // these call ProcessCommand() internally
   void TakeSnapshot();
   void RestoreSnapshot();
private:
   enum class Command // wouldn't be possible without 'class'
   {
        TakeSnapshot,
        RestoreSnapshot
   };
   void ProcessCommand(Command cmd); // signal the other thread or whatever
};