Número de elementos en una enumeración

Question

En C, ¿hay una buena manera de rastrear la cantidad de elementos en una enumeración? He visto

enum blah { 
    FIRST, 
    SECOND, 
    THIRD, 
    LAST 
}; 

Pero esto solo funciona si los elementos son secuenciales y comienzan en cero.

Answer 1

No creo que exista. Pero, ¿qué harías con tal número si no son secuenciales, y aún no tienes una lista de ellos en algún lugar? Y si ellos son secuenciales, pero comienzan a partir de un número diferente, siempre se puede hacer:

enum blah { 
    FIRST = 128, 
    SECOND, 
    THIRD, 
    END 
}; 
const int blah_count = END - FIRST; 

Answer 2

Lamentablemente, no. No hay.

Answer 3

Bueno, ya que las enumeraciones no pueden cambiar en tiempo de ejecución, lo mejor que puede hacer es:

enum blah { 
    FIRST = 7, 
    SECOND = 15, 
    THIRD = 9, 
    LAST = 12 
}; 
#define blahcount 4 /* counted manually, keep these in sync */ 

Pero me resulta difícil imaginar una situación en la que esa información sería útil. ¿Qué estás tratando de hacer exactamente?

Answer 4

int enaumVals[] = 
{ 
FIRST, 
SECOND, 
THIRD, 
LAST 
}; 

#define NUM_ENUMS sizeof(enaumVals)/sizeof (int); 

Answer 5

Si no asigna sus enumeraciones que se pueden hacer algunas cosas como esta:

enum MyType { 
    Type1, 
    Type2, 
    Type3, 
    NumberOfTypes 
} 

NumberOfTypes evaluarán a 3, que es el número de tipos reales.

Answer 6

Vieja pregunta, lo sé. Esto es para los googlers con la misma pregunta.

Usted podría utilizar X-Macros

Ejemplo:

//The values are defined via a map which calls a given macro which is defined later 
#define ENUM_MAP(X) \ 
     X(VALA, 0) \ 
     X(VALB, 10) \ 
     X(VALC, 20) 

//Using the map for the enum decl 
#define X(n, v) [n] = v, 
typedef enum val_list { 
    ENUM_MAP(X) //results in [VALA] = 0, etc... 
} val_list; 
#undef X 

//For the count of values 
#define X(n, v) + 1 
int val_list_count = 0 + ENUM_MAP(X); //evaluates to 0 + 1 + 1 + 1 
#undef X 

Esto también es transparente para un IDE, por lo que se completa automáticamente funciona bien (como todo se hace en el pre-procesador).

Answer 7

Sé que esta es una pregunta muy antigua, pero como la respuesta aceptada es incorrecta, me siento obligado a publicar la mía. Reutilizaré el ejemplo de la respuesta aceptada, ligeramente modificado. (Haciendo la suposición de que las enumeraciones son secuenciales.)

// Incorrect code, do not use! 
enum blah { 
    FIRST = 0, 
    SECOND, // 1 
    THIRD, // 2 
    END  // 3 
}; 
const int blah_count = END - FIRST; 
// And this above would be 3 - 0 = 3, although there actually are 4 items. 

Cualquier desarrollador sabe la razón: count = last - first + 1. Y esto funciona con cualquier combinación de signos (ambos extremos negativos, ambos positivos, o solo el primer extremo negativo). Puedes probar.

// Now, the correct version. 
enum blah { 
    FIRST = 0, 
    SECOND, // 1 
    THIRD, // 2 
    END  // 3 
}; 
const int blah_count = END - FIRST + 1; // 4 

Editar: volviendo a leer el texto, tengo una duda. ¿Eso significa que END no forma parte de los artículos ofrecidos? Esto se ve muy raro para mí, pero bueno, supongo que podría tener sentido ...

Answer 8

Prueba esto:

Es fea y podría haber algunos compiladores que no le gusta, pero usualmente funciona y es útil. Puedes usarlo para cada tipo de enumeración.

Answer 9

#include <stdio.h> 

// M_CONC and M_CONC_ come from https://stackoverflow.com/a/14804003/7067195 
#define M_CONC(A, B) M_CONC_(A, B) 
#define M_CONC_(A, B) A##B 

#define enum_count_suffix _count 
#define count(tag) M_CONC(tag, enum_count_suffix) 
#define countable_enum(tag, ...) \ 
    enum tag {__VA_ARGS__}; \ 
    const size_t count(tag) = sizeof((int []) {__VA_ARGS__})/sizeof(int) 

// The following declares an enum with tag `color` and 3 constants: `red`, 
// `green`, and `blue`. 
countable_enum(color, red, green, blue); 

int main(int argc, char **argv) { 
    // The following prints 3, as expected. 
    printf("number of elements in enum: %d\n", count(color)); 
}