¿Por qué no puedo asignar el valor correcto a la variable de tipo C ++ Enum?

Question

No puedo entender lo que va allí. Usando Visual Studio 2008, he definido un enum como este:

enum MyType{
    A,
    B,
    C
};

Luego lo uso para inicializar una variable de miembro:

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    
};

Instancia myClass = new MyClass ();

Estoy usando la configuración de depuración, por lo que ninguna optimización puede engañarme al leer una variable. En un punto de interrupción justo después de la asignación, el depurador muestra el valor de member_ como member_ = C.

Podría ser un problema del depurador de actualización, pero, dentro de un método, evalúa verdadero al verificar:

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

Y también, asignar a los otros valores da números extraños, por ejemplo, hacer member_ = B da member_ = 258 al ferch lo ferch. ¿Puedes decirme qué pasa? Gracias por adelantado.

Editar #1

He notado un efecto divertido que explica por qué después de asignar member_ = A la expresion member_ == C evaluar true para el enum con los valores predeterminados:

Para el enum

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

yo obtengo

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)

Pero si hago

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

yo obtengo

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)

Entonces, al asignar ese #?^% Enum, la regla parece ser, cambiar 8 bits y agregar 2. Suena como problemas de compilador.

Por cierto, haciendo el tipo de member_ ser - estar int en cambio MyType No cambia nada.

Editar #2Se agregó dos miembros más a la clase, que son la verdadera causa del problema. Publicaré la respuesta tan pronto como la restricción de tiempo desaparezca (8 h de la publicación de la pregunta).

Answer 1

Gracias a todos. Alguien en el trabajo me señaló el origen del problema.

Es una cuestión de configuración defectuosa del proyecto, que ofrece problemas de alineación de datos.

Después de compilar, con la configuración actual del proyecto, los dos primeros miembros de la clase son 3 bytes de tamaño.

Debe ser 4 bytes, de ahí la desalineación de 1 byte. El adicional 2 agregado es basura en el byte desalineado, por lo que todo el efecto es cambiar un byte y agregar 2.

Este efecto se cancela agrega un miembro adicional, aunque no es una solución elegante (la solución es configurar el proyecto de manera corectamente).

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

Las entradas de Enum no tienen que tener valores únicos. Es posible que tenga un enumno con A, B, C donde tanto A como C son iguales a '42'. En tal caso, cuando el VAR tiene un valor de 42, el IDE te mostrará solo uno de las entradas coincidentes, A o C, no ambas.

Puede crear fácilmente una enumación con entradas 'duplicadas', como esta:

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

Pero lo más probable es que no lo hiciste así. Sin embargo, al usar autonumbering, también puede crear duplicados accidentalmente (o intencionalmente):

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

Asegúrese de verificar dos veces su definición de Enum.

Ver es decir http://www.learncpp.com/cpp-tutorial/45-enumerated-types/