Código de guardia después de encender la enumeración nunca se alcanza

Question

Acabo de encontrar un problema confuso al intentar compilar algún código con g ++ 4.4.3.

El siguiente código compila bien, pero en lugar de golpear la aserción de esperar cuando pase un valor de enumeración 'no válido', la función simplemente devuelve 1. Lo que me parece aún más extraño es que cuando elimine el comentario de las líneas pertenecientes a la enumeración E3 valor, las cosas comienzan a funcionar como se esperaba.

El hecho de que no haya una entrada predeterminada en el bloque de interruptor es por diseño. Compilamos con la opción -Wall para obtener advertencias de valores enum no controlados.

enum MyEnum 
{ 
    E1, 
    E2, 
    //E3 
}; 

int doSomethingWithEnum(MyEnum myEnum) 
{ 
    switch (myEnum) 
    { 
     case E1: return 1; 
     case E2: return 2; 
     //case E3: return 3; 
    } 

    assert(!"Should never get here"); 
    return -1; 
} 

int main(int argc, char **argv) 
{ 
    // Should trigger assert, but actually returns 1 
    int retVal = doSomethingWithEnum(static_cast<MyEnum>(4)); 
    std::cout << "RetVal=" << retVal << std::endl; 

    return 0; 
} 

Answer 1

Su sentencia switch se compila en este (g ++ 4.4.5):

cmpl $1, %eax 
    je  .L3 
    movl $1, %eax 
    jmp  .L4 
.L3: 
    movl $2, %eax 
.L4: 
    leave 
    ret 

Como puede verse, la aserción se optimiza por completo, y el compilador elige el que comparar E2 y volver en 1 todos los demás casos. Con tres valores enum, no puede hacer eso.

Sección 5.2.9 de la C++ 98 estándar (por vaciado estático) da la razón para permitir esto:

Valor de tipo integral o de enumeración se puede convertir explícitamente a un tipo de enumeración. El valor no se modifica si el valor original está dentro del rango de los valores de enumeración (7.2). De lo contrario, el valor de enumeración resultante es sin especificar.

En otras palabras, el compilador es libre de usar cualquier valor enum que desee, (en este caso E1) si intenta usar un valor ilegal. Esto incluye hacer lo intuitivo y usar el valor ilegal proporcionado o usar diferentes valores según las circunstancias, por lo que el comportamiento cambia según el número de valores enum.

Answer 2

No parece un error del compilador. Es más como un comportamiento indefinido. La regla dice que puede atribuir un valor indefinido a un Enum SI este valor está en el rango de la enumeración. En su caso, el compilador solo necesita un bit para representar la enumeración, por lo que probablemente esté haciendo algún tipo de optimización.

Answer 3

Esto es perfectamente normal, su código se basa en un comportamiento no especificado.

En C++, se supone que una enumeración debe contener valores entre sus valores inferior y superior. Cualquier otra cosa puede ser transformada o ignorada por el compilador.

Por ejemplo, si tengo enum Foo { min = 10, max = 11 };, entonces el compilador puede representarlo con un solo bit significativo y agregar 10 cuando solicite imprimirlo o convertirlo en un entero.

En general, sin embargo, los compiladores no aprovechan esta "compactación" debido al costo de rendimiento, simplemente seleccionan un tipo subyacente que puede acomodar todos los valores y 0. La mayoría de las veces es int, a menos que int sea demasiado pequeño.

Sin embargo, no impide que asuman que los valores que este int contienen están restringidos al rango que usted definió. En su caso: [0, 2).

Como tal, la declaración switch simplemente se puede optimizar en una comparación con 0, ya que ha especificado que su enumeración sólo podía ser 0 o 1.

En la misma línea, if (foo == 3) podría considerarse una comparación tautológica (siempre falso) y optimizados de distancia.

De hecho, tal como se describe en el gcc "error" señalado por Hans Passat, esta optimización se produce normalmente en poder de 2s límites para gcc. Por ejemplo, si tenía enum { zero, one, two, three }; y le asignó 4 o superior, se produciría el mismo comportamiento.

Tenga en cuenta que el valor almacenado en realidad no se ve afectada! Esta es la razón por la cual la declaración impresa funciona como esperaba, y es una fuente de confusión.

No sé si hay una advertencia para indicar que el almacenamiento de 4 en esta enumeración dará lugar a un comportamiento no especificado. En cualquier caso, sólo funcionaría para los valores de tiempo de compilación ...

---

Hans Passat siempre que el gcc "bug" que está abierto a realizar un seguimiento de este "problema".

y Emil Styrke proporcionan la justificación (en este caso es la cotización actualizada para las enumeraciones de ámbito):

5.2.9/10

Un valor de tipo integral o de enumeración se puede convertir explícitamente a un tipo de enumeración. El valor no cambia si el valor original está dentro del rango de los valores de enumeración (7.2). De lo contrario, el valor resultante no está especificado (y podría no estar en ese rango). Un valor de tipo punto flotante también se puede convertir a un tipo de enumeración. El valor resultante es lo mismo que convertir el valor original en el tipo subyacente de la enumeración (4.9) y, posteriormente, en el tipo de enumeración.