Pourquoi je ne peux pas attribuer la valeur correcte à la variable de type énumération C ++?

Question

Je ne peux pas comprendre ce qui se passe là-bas. En utilisant Visual Studio 2008, j'ai défini une enum comme ceci:

enum MyType{
    A,
    B,
    C
};

Ensuite, je l'utilise pour initialiser une variable de membre:

class MyClass
{
    private:
        bool   bit_;
        uint16 num_;
        MyType member_;
    public:
        MyClass(MyType value){
            member_ = value; // This the assignment which fails
        } // Here, there's a breakpoint to query member_ value    
};

Instance myClass = new myClass ();

J'utilise la configuration de débogage, donc aucune optimisation ne peut me tromper lors de la lecture d'une variable. À un point d'arrêt juste après la mission, le débuger montre la valeur du membre_ comme member_ = C.

Il pourrait s'agir d'un problème de rafraîchissement du débogueur mais, à l'intérieur d'une méthode, il évalue vrai lors de la vérification:

if(member_ == C){
    // ??
}

Et aussi, attribuer aux autres valeurs donne des nombres étranges, par exemple member_ = B donner member_ = 258 Lors de la ferche. Pouvez-vous me dire ce qui ne va pas? Merci d'avance.

EDIT # 1

J'ai noté un effet drôle qui explique pourquoi après avoir attribué member_ = A l'expression member_ == C évalue à true Pour l'énumération avec les valeurs par défaut:

Pour l'énumération

enum MyType{ A, B, C}; // equivalent to enum MyType{ A = 0, B = 1, C = 2};

Je reçois

MyType  a = A; // but when fetching a the value is   2  (0x0002)  thats the map for C!
MyType  b = B; // but when fetching a the value is 258  (0x0102)
MyType  c = C; // but when fetching a the value is 514  (0x0202)

Mais si je fais

enum MyType{ A = 5, B = 6, C = 7};

Je reçois

MyType  a = A; // but when fetching a the value is 1282  (0x0502)
MyType  b = B; // but when fetching a the value is 1538  (0x0602)
MyType  c = C; // but when fetching a the value is 1794  (0x0702)

Donc, lorsque vous attribuez ce #?! ^% Enum, la règle semble être, changer 8 bits et ajouter 2. Cela ressemble à des problèmes de compilateur.

Btw, faisant le type de member_ être int Au lieu MyType ne change rien.

EDIT # 2Ajout de deux autres membres à la classe, qui sont la vraie cause du problème. Je publierai la réponse dès que la restriction du temps disparaît (8h de la publication de la question).

Answer 1

Merci tout le monde. Quelqu'un au travail m'a indiqué l'origine du problème.

Il s'agit d'une configuration défectueuse du projet, qui donne des problèmes d'alignement des données.

Après avoir compilé, avec les paramètres du projet actuels, les deux premiers membres de la classe sont de 3 octets de taille.

Il devrait être de 4 octets, d'où le désalignement de 1 octet. Le 2 supplémentaire ajouté est les ordures à l'octet mal aligné, donc, l'effet entier est de déplacer un octet et d'ajouter 2.

Cet effet est annulé en ajoutant un membre supplémentaire, bien qu'il ne s'agisse pas d'une solution élégante (la solution consiste à configurer le projet de manière corect).

class MyClass
{
    private:
        bool   bit_;  // 1 byte
        uint16 num_;  // 2 byte

        bool dummy;   // extra byte to help the alignment

        MyType member_;
    public:
        MyClass(MyType value){
            member_ = value; // Now it works as expected.
        }
};

Answer 2

ENUM ENTRIES n'a pas besoin d'avoir des valeurs uniques. Vous pourriez avoir une énumération avec A, B, C où A et C sont égaux à «42». Dans un tel cas, lorsque le VAR a une valeur de 42, l'IDE ne vous montrera qu'un seul des entrées correspondantes, A ou C, pas les deux.

Vous pouvez facilement créer une énumération avec des entrées «en double», comme ceci:

enum { A=1, B=1, C=1 }

Mais très probablement, vous ne l'avez pas fait comme ça. Cependant, lors de l'utilisation automatique, vous pouvez également créer accidentellement (ou intentionnellement) des doublons:

enum { A, B, C }       // 0,1,2
enum { A, B, C=0 }     // 0,1,0
enum { A=2, B=1, C }   // 2,1,2
enum { A=-1, B, C=0 }  // -1,0,0

Assurez-vous de revérifier la définition de votre énumération.

voir ie http://www.learncpp.com/cpp-tutorial/45-enumerated-types/