Quelle est la taille d'une énumération en C?

Je crée un ensemble de valeurs d'énumération, mais j'ai besoin que chaque valeur d'énumération ait une largeur de 64 bits. Si je me souviens bien, un enum a généralement la même taille qu'un int; mais je pensais avoir lu quelque part que (au moins dans GCC) le compilateur peut faire l'énumération de toute largeur nécessaire pour contenir leurs valeurs. Alors, est-il possible d'avoir une énumération de 64 bits de large?

Il enumest garanti que An est suffisamment grand pour contenir des intvaleurs. Le compilateur est libre de choisir le type réel utilisé en fonction des constantes d'énumération définies afin de pouvoir choisir un type plus petit s'il peut représenter les valeurs que vous définissez. Si vous avez besoin de constantes d'énumération qui ne rentrent pas dans un, intvous devrez utiliser des extensions spécifiques au compilateur pour ce faire.

Tiré de la norme C actuelle (C99): http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf

6.7.2.2 Spécificateurs d'énumération
[...]
Contraintes
L'expression qui définit la valeur d'une constante d'énumération doit être une expression de constante entière qui a une valeur représentable comme un int.
[...]
Chaque type énuméré doit être compatible avec char, un type entier signé ou un type entier non signé. Le choix du type est défini par l'implémentation, mais doit être capable de représenter les valeurs de tous les membres de l'énumération.

Non pas que les compilateurs soient bons pour suivre la norme, mais essentiellement: Si votre enum contient autre chose qu'un int, vous êtes dans un "comportement non pris en charge profond qui peut revenir vous mordre dans un an ou deux" territoire.

Bien que les réponses précédentes soient correctes, certains compilateurs ont des options pour briser la norme et utiliser le plus petit type qui contiendra toutes les valeurs.

Exemple avec GCC (documentation dans le manuel GCC ):

enum ord {
    FIRST = 1,
    SECOND,
    THIRD
} __attribute__ ((__packed__));
STATIC_ASSERT( sizeof(enum ord) == 1 )

Définissez simplement la dernière valeur de l'énumération sur une valeur suffisamment grande pour lui donner la taille que vous souhaitez que l'énumération soit, elle devrait alors être de cette taille:

enum value{a=0,b,c,d,e,f,g,h,i,j,l,m,n,last=0xFFFFFFFFFFFFFFFF};

Nous n'avons aucun contrôle sur la taille d'une enumvariable. Cela dépend totalement de l'implémentation, et le compilateur donne la possibilité de stocker un nom pour un entier en utilisant enum, donc enumsuit la taille d'un entier.

En langage C, an enumest garanti d'avoir la taille d'un int. Il existe une option de compilation ( -fshort-enums) pour le rendre aussi court (ceci est principalement utile dans le cas où les valeurs ne dépassent pas 64 Ko). Il n'y a pas d'option de compilation pour augmenter sa taille à 64 bits.

Considérez ce code:

enum value{a,b,c,d,e,f,g,h,i,j,l,m,n};
value s;
cout << sizeof(s) << endl;

Il donnera 4 en sortie. Ainsi, quel que soit le nombre d'éléments qu'un enumcontient, sa taille est toujours fixe.