пространства имен для типов перечислений - лучшие практики

Часто требуется несколько перечислимых типов вместе. Иногда возникает конфликт имен. На ум приходят два решения: использовать пространство имен или использовать «более крупные» имена элементов перечисления. Тем не менее, решение с пространством имен имеет две возможные реализации: фиктивный класс с вложенным перечислением или полноценное пространство имен.

Я ищу плюсы и минусы всех трех подходов.

Пример:

// oft seen hand-crafted name clash solution
enum eColors { cRed, cColorBlue, cGreen, cYellow, cColorsEnd };
enum eFeelings { cAngry, cFeelingBlue, cHappy, cFeelingsEnd };
void setPenColor( const eColors c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cColorBlue: //...
        //...
    }
 }


// (ab)using a class as a namespace
class Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
class Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
 }


 // a real namespace?
 namespace Colors { enum e { cRed, cBlue, cGreen, cYellow, cEnd }; };
 namespace Feelings { enum e { cAngry, cBlue, cHappy, cEnd }; };
 void setPenColor( const Colors::e c ) {
    switch (c) {
        default: assert(false);
        break; case Colors::cRed: //...
        break; case Colors::cBlue: //...
        //...
    }
  }

Исходный ответ C ++ 03:

Выгода от А namespace(больше class), что вы можете использовать usingобъявление , когда вы хотите.

Проблема с использованием в namespaceтом , что пространство имен может быть расширен в других местах в коде. В большом проекте вам не будет гарантировано, что два разных перечисления не оба думают, что они вызываютсяeFeelings

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

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

Новее, совет C ++ 11:

Если вы используете C ++ 11 или новее, enum classбудет неявно ограничивать значения перечисления в пределах имени перечисления.

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

FYI В C ++ 0x есть новый синтаксис для случаев, подобных тому, что вы упомянули (см. Страницу вики C ++ 0x )

enum class eColors { ... };
enum class eFeelings { ... };

Я гибридизировал предыдущие ответы на что-то вроде этого: (EDIT: это полезно только для pre-C ++ 11. Если вы используете C ++ 11, используйте enum class)

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

Он structизбегает общедоступного синтаксического сахара и typedefпозволяет вам фактически объявлять переменные этих перечислений в других рабочих классах.

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

    struct KeySource {
        typedef enum { 
            None, 
            Efuse, 
            Bbram
        } Type;
    };

    struct Checksum {
        typedef enum {
            None =0,
            MD5 = 1,
            SHA1 = 2,
            SHA2 = 3
        } Type;
    };

    struct Encryption {
        typedef enum {
            Undetermined,
            None,
            AES
        } Type;
    };

    struct File {
        typedef enum {
            Unknown = 0,
            MCS,
            MEM,
            BIN,
            HEX
        } Type;
    };

...

class Worker {
    File::Type fileType;
    void DoIt() {
       switch(fileType) {
       case File::MCS: ... ;
       case File::MEM: ... ;
       case File::HEX: ... ;
    }
}

Я бы определенно избегал использовать для этого класс; вместо этого используйте пространство имен. Вопрос сводится к тому, использовать ли пространство имен или использовать уникальные идентификаторы для значений перечисления. Лично я бы использовал пространство имен, чтобы мои идентификаторы были короче и, надеюсь, более понятными. Тогда код приложения может использовать директиву using namespace и сделать все более читабельным.

Из вашего примера выше:

using namespace Colors;

void setPenColor( const e c ) {
    switch (c) {
        default: assert(false);
        break; case cRed: //...
        break; case cBlue: //...
        //...
    }
}

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

Возможное преимущество использования класса заключается в том, что они могут использоваться в качестве аргументов типа шаблона, что не относится к пространствам имен:

class Colors {
public:
  enum TYPE {
    Red,
    Green,
    Blue
  };
};

template <typename T> void foo (T t) {
  typedef typename T::TYPE EnumType;
  // ...
}

Лично я не являюсь поклонником использования и предпочитаю полностью определенные имена, поэтому я не считаю это плюсом для пространств имен. Однако, вероятно, это не самое важное решение, которое вы примете в своем проекте!

Преимущество использования класса в том, что на его основе можно построить полноценный класс.

#include <cassert>

class Color
{
public:
    typedef enum
    {
        Red,
        Blue,
        Green,
        Yellow
    } enum_type;

private:
    enum_type _val;

public:
    Color(enum_type val = Blue)
        : _val(val)
    {
        assert(val <= Yellow);
    }

    operator enum_type() const
    {
        return _val;
    }
};

void SetPenColor(const Color c)
{
    switch (c)
    {
        case Color::Red:
            // ...
            break;
    }
}

Как показано в приведенном выше примере, с помощью класса вы можете:

1. запретить (к сожалению, не во время компиляции) C ++ разрешать приведение из недопустимого значения,
2. установить (ненулевое) значение по умолчанию для вновь созданных перечислений,
3. добавить дополнительные методы, например, для возврата строкового представления выбора.

Просто обратите внимание, что вам нужно объявить, operator enum_type()чтобы C ++ знал, как преобразовать ваш класс в базовое перечисление. В противном случае вы не сможете передать тип switchвыражению.

Поскольку перечисления ограничены их охватывающей областью видимости, вероятно, лучше всего обернуть их чем-то, чтобы избежать загрязнения глобального пространства имен и избежать конфликтов имен. Я предпочитаю пространство имен классу просто потому, namespaceчто оно похоже на сумку для хранения, тогда как classощущается как надежный объект (см. Обсуждение structvs. class). Возможное преимущество пространства имен состоит в том, что его можно расширить позже - это полезно, если вы имеете дело со сторонним кодом, который вы не можете изменить.

Это все спорно, конечно, когда мы получаем классы перечислений с C ++ 0x.

Я также стараюсь объединять свои перечисления в классы.

Как сообщил Ричард Корден, преимущество класса состоит в том, что это тип в смысле C ++, и поэтому вы можете использовать его с шаблонами.

У меня есть специальный класс toolbox :: Enum для моих нужд, который я специализирую для каждого шаблона, который предоставляет базовые функции (в основном: отображение значения enum в std :: string, чтобы ввод-вывод было легче читать).

Мой маленький шаблон также имеет дополнительное преимущество - действительно проверять допустимые значения. Компилятор не очень хорошо проверяет, действительно ли значение находится в перечислении:

typedef enum { False: 0, True: 2 } boolean;
   // The classic enum you don't want to see around your code ;)

int main(int argc, char* argv[])
{
  boolean x = static_cast<boolean>(1);
  return (x == False || x == True) ? 0 : 1;
} // main

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

Так же:

typedef enum { Zero: 0, One: 1, Two: 2 } example;

int main(int argc, char* argv[])
{
  example y = static_cast<example>(3);
  return (y == Zero || y == One || y == Two) ? 0 : 1;
} // main

И снова main вернет ошибку.

Проблема в том, что компилятор поместит перечисление в наименьшее доступное представление (здесь нам нужно 2 бита) и что все, что соответствует этому представлению, считается допустимым значением.

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

В общем, мой маленький помощник действительно упрощает работу с перечислениями (конечно, он добавляет некоторые накладные расходы), и это возможно только потому, что я вкладываю каждое перечисление в отдельную структуру :)