Почему люди используют перечисления в C++ как константы, в то время как они могут использовать const?

Question

Почему люди используют перечисления в C++ в качестве констант, когда они могут использовать const?

Answer 1

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

Answer 2

Одной из причин является то, что const требует большего набора:

enum { Val1, Val2, Val3 }; 

... против ...

const int Val1=0, Val2=1, Val3=2; 

Answer 3

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

enum Color { Red,Green,Blue }; 
enum Size { Big,Little }; 

void f(Color c) { 
} 

void f(Size s) { 
} 

int main() { 
    f(Red); 
    f(Big); 
} 

Answer 4

Существует историческая причина также при рассмотрении шаблона aprogramming. Некоторые компиляторы могут использовать значения из перечисления, но не статические константы int для создания экземпляра класса.

template <int N> 
struct foo 
{ 
    enum { Value = foo<N-1>::Value + N }; 
}; 

template <> 
struct foo<0> 
{ 
    enum { Value = 0; } 
}; 

Теперь вы можете сделать это более разумный способ:

template <int N> 
struct foo 
{ 
    static const int Value = foo<N-1>::Value + N; 
}; 

template <> 
struct foo<0> 
{ 
    static const int Value = 0; 
}; 

Другой возможной причиной является то, что статический константный INT может иметь память, зарезервированный для него во время выполнения, в то время как перечисление никогда не будет имеют фактическое место памяти, зарезервированное для него, и будут обрабатываться во время компиляции. См. this related question.

Answer 5

Указанные значения являются более наглядными. Рассмотрим:

int f(int fg, int bg) 

против

int f(COLOR fg, COLOR bg) 

Кроме того, перечислений дать немного больше безопасности типа, потому что

• целые числа не неявно конвертируются в ENUM типы
• перечисление из одного тип неявно конвертируется в перечисление другого типа

Answer 6

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

Рассмотрим:

enum my_new_fangled_type { 
    baz = 0, 
    meh = 1 
}; 

void foo (my_new_fangled_type bar) // bar can be a value listed in the enum 
{ 
    ... 
} 

против:

int const baz = 0; 
int const meh = 1; 

void foo (int bar) // what are valid values for bar? 
{ 
    ... 
} 

Answer 7

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

Если они используют глобальные константы enum, например Pi, то я не знаю, какова их цель.

Answer 8

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

enum {NONE, START, HEY, HO, LAST}; 

Тогда легко в цикле до последнего, а когда новое состояние (или любой другой представлен) добавлен, логика адаптируется.

for (int i = NONE; i < LAST; i++) 
{ 
    // Do stuff... 
} 

Добавить что-то ...

enum {NONE, START, HEY, WEE, HO, LAST}; 

Петля приспосабливается ...

Answer 9

Перед вендоры компилятор реализован ISO/IEC 14882: 1998 стандарт C++, этот код, чтобы определить константу в класс scope привел к ошибке компиляции:

class Foo { 
    static const int MAX_LEN = 80; 
    ... 
}; 

Если константа является целым типом, то kludgy работает вокруг d efine его в перечислении внутри класса:

class Foo { 
    enum { 
     MAX_LEN = 80 
    }; 
    ... 
}; 

Answer 10

Брюс Eckel дает основание в Thinking in C++:

In older versions of C++, static const was not supported inside classes. This meant that const was useless for constant expressions inside classes. However, people still wanted to do this so a typical solution (usually referred to as the “enum hack”) was to use an untagged enum with no instances. An enumeration must have all its values established at compile time, it’s local to the class, and its values are available for constant expressions. Thus, you will commonly see:

#include <iostream> 
using namespace std; 

class Bunch { 
    enum { size = 1000 }; 
    int i[size]; 
}; 

int main() { 
    cout << "sizeof(Bunch) = " << sizeof(Bunch) 
     << ", sizeof(i[1000]) = " 
     << sizeof(int[1000]) << endl; 
} 

[Редактировать]

Я думаю, что было бы более справедливым, чтобы связать сайт Брюса Eckel в : http://www.mindview.net/Books/TICPP/ThinkingInCPP2e.html.

Answer 11

Некоторые отладчики будут отображать имя перечисления вместо его значения при отладке. Это может быть очень полезно. Я знаю, что лучше бы посмотрел day_of_week = MONDAY, чем day_of_week = 1.

Answer 12

Это отчасти потому, что старые компиляторы не поддерживают декларацию истинного класса постоянной

class C 
{ 
    const int ARealConstant = 10; 
}; 

так должен был сделать это

class C 
{ 
    enum { ARealConstant = 10 }; 
}; 

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

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

class DirectorySearcher 
{ 
    enum options 
    { 
    showFiles = 0x01, 
    showDirectories = 0x02, 
    showLinks = 0x04, 
    }; 
}; 

против

class Integer 
{ 
    enum { treatAsNumeric = true }; 
    enum { treatAsIntegral = true }; 
    enum { treatAsString = false }; 
};