Pourquoi les gens utilisent-ils les enums en C++ comme constantes alors qu'ils peuvent utiliser const?

Question

Pourquoi les gens utilisent-ils les enums en C++ comme constantes lorsqu'ils peuvent utiliser const?

Answer 1

Une énumération implique un ensemble de constantes associées, de sorte que les informations supplémentaires sur la relation doivent être utiles dans leur modèle du problème en question.

Answer 2

Une raison est que const nécessite plus taper:

enum { Val1, Val2, Val3 }; 

... contre ...

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

Answer 3

énumérations sont des types distincts, de sorte que vous pouvez faire des choses type orienté comme la surcharge avec les:

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

Il y a une raison historique aussi lorsqu'il s'agit de modèle rencontré aprogramming. Certains compilateurs peuvent utiliser des valeurs d'une énumération, mais pas un const int statique pour instancier une classe.

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

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

Maintenant, vous pouvez le faire de la façon plus sensible:

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

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

Une autre raison possible est qu'un int const statique peut avoir la mémoire qui lui est réservé lors de l'exécution, alors qu'une ENUM ne va jamais avoir un emplacement mémoire réel qui lui est réservé, et sera traité au moment de la compilation. Voir this related question.

Answer 5

Les énumérations sont plus descriptives lorsqu'elles sont utilisées. Considérez:

int f(int fg, int bg) 

contre

int f(COLOR fg, COLOR bg) 

En outre, les énumérations donnent un peu plus-sécurité de type, parce que

• entiers ne sont pas convertibles en ENUM implicitement les types
• ENUM d'un le type n'est pas implicitement convertible en enum d'un autre type

Answer 6

Enums peut également être utilisé comme nom de type. Vous pouvez donc définir une fonction qui prend enum en paramètre, ce qui rend plus clair quels types de valeurs devraient être donnés comme arguments à la fonction, comparé à avoir les valeurs définies comme variables const et la fonction n'acceptant que "int" comme argument.

Tenir compte:

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 
{ 
    ... 
} 

contre:

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

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

Answer 7

L'utilisation d'un ENUM documente les choix valides d'une manière laconique et permet au compilateur de les appliquer.

Si elles utilisent des constantes globales enum store, comme Pi, par exemple, je ne sais pas quel est leur but.

Answer 8

J'aime le comportement automatique qui peut être utilisé avec les énumérations, par exemple:

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

Ensuite, il est facile à boucle jusqu'à LAST, et quand un nouvel état (ou tout ce qui est représenté) est ajouté, la la logique s'adapte.

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

Ajouter quelque chose ...

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

La boucle s'adapte ...

Answer 9

Avant les fournisseurs de compilateur mis en œuvre la norme ISO/CEI 14882: 1998 C++ standard, ce code pour définir une constante une étendue de classe a abouti à une erreur de compilation:

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

Si la constante est un type entier, un travail de contour est nécessaire. éfinir dans un ENUM intérieur de la classe:

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

Answer 10

Bruce Eckel donne une raison en 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; 
} 

[Modifier]

Je pense qu'il serait plus juste de relier le site de Bruce Eckel : .

Answer 11

Certains débogueurs afficheront le nom de l'énumération au lieu de sa valeur lors du débogage. Cela peut être très utile. Je sais que je préfère voir day_of_week = MONDAY que day_of_week = 1.

Answer 12

Il est en partie parce que les compilateurs anciens ne prennent pas en charge la déclaration d'une véritable constante de classe

class C 
{ 
    const int ARealConstant = 10; 
}; 

Nous avons donc dû faire

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

Pour cette raison, de nombreuses bibliothèques portables continuer à utiliser ce formulaire .

L'autre raison est que les énumérations peuvent être utilisés comme un dispositif syntaxique pratique pour organiser des constantes de classe dans ceux qui sont liés, et ceux qui ne sont pas

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

vs

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