La question est simple:
#include <iostream>
enum SomeEnum {
EValue1 = 1,
EValue2 = 4
};
int main() {
SomeEnum enummy;
std::cout << (int)enummy;
}
Quelle sera la sortie?
Remarque: Ceci est pas une interview, c'est du code hérité par moi des développeurs précédents. L'opérateur de streaming ici est juste par exemple, le code hérité réel ne l'a pas.
Le programme a Comportement indéfini . La valeur de énumération est indéterminée. Sur le plan conceptuel, il n'y a aucune différence entre votre code et le code suivant:
int main() {
int i; //indeterminate value
std::cout << i; //undefined behavior
};
Si vous aviez défini votre variable à la portée de l'espace de noms, sa valeur serait initialisée à 0.
enum SomeEnum {
EValue1 = 1,
EValue2 = 4,
};
SomeEnum e; // e is 0
int i; // i is 0
int main()
{
cout << e << " " << i; //prints 0 0
}
Ne soyez pas surpris que e
puisse avoir des valeurs différentes de toutes les valeurs d'énumérateur de SomeEnum
. Chaque type d'énumération a un type intégral sous-jacent (tel que int
, short
ou long
) et l'ensemble des valeurs possibles d'un objet de ce type d'énumération est l'ensemble de valeurs du type intégral sous-jacent. L'énumération est juste un moyen de nommer facilement certaines des valeurs et de créer un nouveau type, mais vous ne limitez pas les valeurs de votre énumération par l'ensemble des valeurs des énumérateurs.
Mise à jour: Quelques citations me soutenant:
Initialiser à zéro un objet de type T signifie:
- si T est un type scalaire (3.9), l'objet est mis à la valeur de 0 (zéro) convertie en T;
Notez que les énumérations sont des types scalaires.
Pour initialiser en valeur un objet de type T, cela signifie:
- si T est un type de classe bla bla
- si T est une classe non syndiquée bla bla
- si T est un type de tableau, alors bla bla - sinon, l'objet est initialisé à zéro
Donc, nous entrons dans une autre partie. Et les objets de portée d'espace de noms sont initialisés en valeur
La sortie sera indéterminée. les variables membres enummy ne peuvent être que 1 ou 4.