Comment vérifier si une variable enum est valide?

J'ai un enum:

enum myenum{
  typeA,
  typeB,
  typeC
} myenum_t;

Ensuite, une des fonctions est d'être appelée avec un enum paramètre:

int myfunction(myenum_t param1)
{
  switch(param1)
  {
    case typeA:
    case typeB:
    case typeC:
      //do the work
      break;

    default:
      printf("Invalid parameter");
  }
  return 0;
}

Mais, comme myenum_t grandit avec de plus en plus de valeurs, myfunction n'a pas l'air si élégant.

Est-il une meilleure façon de vérifier si un enum est valide ou pas?

source d'informationauteur mustafa

  1. 18

    D'une convention commune pour ce qui est de faire quelque chose comme ceci:

    typedef enum {
  typeA,
  typeB,
  typeC,
  num_types
} myenum_t;

    Ensuite, vous pouvez vérifier pour (t < num_types).

    Si vous ajoutez ultérieurement plus d'énumérations, par exemple

    typedef enum {
  typeA,
  typeB,
  typeC,
  typeD,
  typeE,
  num_types
} myenum_t;

    puis num_types est automatiquement mis à jour et que votre erreur de code de vérification n'a pas besoin de changer.

  2. 5

    Vous pouvez utiliser un bit à bit enum:

    enum myEnum {
    typeA = 1 << 0;
    typeB = 1 << 1;
    typeC = 1 << 2;
}

int myFunction(myEnum arg1)
{
    int checkVal = typeA | typeB | typeC;

    if (checkVal & arg1)
    {
        //do work here;
    }
    else
    {
        printf("invalid argument!");
    }

    return 0;
}

    Excuse moi, il me semble que j'ai lu la question mal.

    Il semble que ce que vous voulez faire est de déterminer si vous avez une bonne valeur passée dans, pas un hasard option non valide. Dans ce cas, le plus logique option est ceci:

    if (arg1 < typeA || arg1 > typeC)
    printf("invalid argument");

    C'est, bien sûr, en supposant que vous ne définissez pas de manuel des valeurs de l'enum, ce qui est assez rare, sauf si l'aide au niveau du bit enums.

  3. 3

    Oui.

    Laisser le compilateur faire son travail, ne jette pas int à un enum type et vous devriez être bon.

  4. 1

    Un truc que j'ai utilisé dans le passé:

    enum foo {FIRST_FOO, BAR, BLETCH, BLURGA, BLAH, LAST_FOO};

    et de vérifier ensuite si votre valeur est > FIRST_FOO && < LAST_FOO1.

    Bien sûr, cela suppose qu'il n'y a pas des écarts entre vos valeurs d'énumération.

    Sinon, non, il n'y a pas de bonne méthode pour faire ce que vous demandez (au moins en C).

    1 à Partir de la dernière ligne Norme Du Langage C:

    6.7.2.2 Énumération des prescripteurs

    ...

    3 Les identificateurs dans un énumérateur de la liste sont déclarés en tant que constantes qui ont type int et
    peut apparaître partout où cela est autorisé.109) Un agent recenseur avec = définit son
    l'énumération constante la valeur de la constante d'expression. Si le premier agent recenseur a
    pas de =, la valeur de sa constante d'énumération est 0. Par la suite, chaque agent recenseur sans =
    définit son énumération constante la valeur de la constante de l'expression obtenue par
    l'ajout de 1 à la valeur de la précédente énumération constante. (L'utilisation d'agents recenseurs avec
    = peut produire des constantes de l'énumération avec des valeurs qui font double emploi avec d'autres valeurs dans le même
    l'énumération.) Les agents recenseurs d'une énumération sont également connus comme ses membres.

  5. 0

    Ne pouvez pas vous aussi faire quelque chose comme

    enum myEnum {typeA,typeB, typeC};

int myFunction (myEnum arg1) {
    if (arg1 >= typeA && arg1 <= typeC) {
        //do work here
    } else {
        printf("invalid argument!");
    }
    return 0;
}
  6. 0

    Malheureusement, il n'y a pas un moyen simple de le faire de langue de niveau (au moins avec C), vous avez juste à vous assurer que vous utilisez uniquement des variables définies par enum.

    Mais vous pouvez activer l'une des opérations suivantes avertissements du compilateur avec -Werror:

    • -Wswitch
    • -Wswitch-default
    • -Wswitch-enum

    Cela fait construire échouer si l'une des énumérations est oubliée à l'intérieur de l'interrupteur.

  7. 0

    Énumérations en C++ ont déjà plus forte que dans C.

    Prendre la suite de programme simple:

    #include <iostream>

enum E
{
    A,
    B 
};

void f(E e)
{
}

int main()
{
    f(1);
}

    Utilisant le compilateur GCC je vais obtenir cette erreur:

    enum.cpp: In function ‘int main()’: 
enum.rpc:15: erreur: invalid conversion from ‘int’ à ‘E’ 
enum.rpc:15: erreur: l'initialisation de l'argument 1 de ‘void f(E)"

    De sorte que vous pouvez voir les membres de l'énumération sont déjà cochée.

    Si vous voulez encore plus forte de la vérification de type, et ont un C++11 est capable de compilateur, vous pouvez utiliser encore plus forte de la vérification de type pour les énumérations, voir http://en.wikipedia.org/wiki/C%2B%2B11#Strongly_typed_enumerations.