tiene - Número de elementos en una enumeración

puntuación en listas rae

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

Bueno, dado que las enumeraciones no pueden cambiar en el 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 2

Lamentablemente no. No hay.

Answer 3

Prueba esto:

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

Answer 4

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. (Hacer 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 conoce el motivo: 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: leyendo el texto nuevamente, tengo una duda. ¿ END significa no ser parte de los artículos ofrecidos? Eso me parece extraño, pero bueno, creo que podría tener sentido ...

Answer 5

Si no asigna sus enumeraciones, puede hacer algo así:

enum MyType {
  Type1,
  Type2,
  Type3,
  NumberOfTypes
}

NumberOfTypes evaluará a 3, que es la cantidad de tipos reales.

Answer 6

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

Podría usar 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 y funcionará bien (ya que todo se hace en el preprocesador).

Answer 7

Yo 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 son secuenciales pero comienzan en un número diferente, siempre puedes hacer:

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

Answer 8

#include <stdio.h>

// M_CONC and M_CONC_ come from https://.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));
}

Answer 9

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

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