type enum vérifier en C/gcc

Cette déclaration:

enum fruit {
    apple,
    orange
};

déclare trois choses: un type appelé enum fruit, et deux agents recenseurs ont appelé apple et orange.

enum fruit est en fait un type distinct. Il est compatible avec certains de la mise en œuvre définies de type entier; par exemple, enum fruit peut être compatible avec int, avec char, ou même avec unsigned long long si la mise en œuvre choisit de le faire, aussi longtemps que le type choisi peut représenter toutes les valeurs.

Les agents recenseurs, d'autre part, sont des constantes de type int. En fait, il y a un truc commun de l'aide d'un nu enum déclaration de déclarer int constantes sans l'aide du préprocesseur:

enum { MAX = 1000 };

Oui, cela signifie que la constante de apple, même si elle a été déclarée comme faisant partie de la définition de enum fruit, n'est-ce pas en fait de type enum fruit. Les raisons en sont historiques. Et oui, il aurait probablement fait plus de sens pour les agents recenseurs pour être des constantes du type.

Dans la pratique, cette incohérence rarement des questions beaucoup. Dans la plupart des contextes, discret types (c'est a dire entier et l'énumération des types) sont largement interchangeables, et les conversions implicites généralement de faire la bonne chose.

enum fruit { apple, orange };
enum fruit obj;      /* obj is of type enum fruit */
obj = orange;        /* orange is of type int; it's
                        implicitly converted to enum fruit */
if (obj == orange) { /* operands are converted to a common type */
    /* ... */
}

Mais le résultat est que, comme vous l'avez vu, le compilateur n'est pas susceptible de vous avertir si vous utilisez une constante associée à un type énuméré quand tu veux en utiliser un autre.

Une manière type de vérification est d'envelopper vos données dans une structure (struct):

enum fruit { /* ... */ };
enum color { /* ... */ };
struct fruit { enum fruit f; };
struct color { enum color c; };

struct fruit et struct color sont distinctes et les types incompatibles avec aucune implicite (ou explicite) de conversion d'entre eux. L'inconvénient est que vous devez vous référer à la .f ou .c membre explicitement. (La plupart des programmeurs C de ne compter que sur leur capacité à faire les choses, en premier lieu, -- avec des résultats mitigés.)

(typedef ne vous donne pas la vérification de type fort; malgré le nom, il crée un alias pour un type existant, pas d'un nouveau type.)

(Les règles en C++ sont un peu différentes.)

gcc décidé de ne pas les prévenir (comme le fait clang) mais icc (Intel compilateur) garde dans cette situation. Si vous voulez quelques autres type de vérification pour enum types, vous pouvez passer votre code à code statique checker comme Lint qui est en mesure d'avertir dans de tels cas.

gcc a décidé qu'il n'était pas utile d'avertir pour les conversions implicites entre enum types, mais note également que le C ne nécessite pas la mise en œuvre d'émettre un diagnostic en cas de cession entre deux enum types. C'est le même que pour l'affectation entre l'arithmétique type: diagnostic n'est pas nécessaire de C. Par exemple, gcc aussi de ne pas avertir si vous affectez un long long à un char ou un short à un long.

Un enum en C est essentiellement traité comme un entier. C'est juste une plus belle façon d'utiliser les constantes.

  //this would work as well
  ftype = 1;

Vous pouvez également spécifier les valeurs:

  enum color {
     RED=0,GREEN,BLUE
  } mycolor;

  mycolor = 1; //GREEN