Enum valor de colisión con el nombre de enumeración

Question

Tomemos una construcción de código que he encontrado recientemente en alguna parte en el proyecto:

namespace Test 
{ 
    enum EName 
    { 
     CoolEnum, 
     NiceEnum 
    }; 

    enum CoolEnum 
    { 
     CoolVal1, 
     CoolVal2 
    }; 

    enum NiceEnum 
    { 
     NiceVal1, 
     NiceVal2 
    }; 
} 

Mi pregunta es por qué el compilador permite que algo como esto. Tomemos un ejemplo de código aquí:

Test::CoolEnum cEnum = Test::NiceVal1; // INVALID, as compiler refers to Test::CoolEnum value of Test::Ename enum 

¿Por qué se permite tal confusión? Entiendo por qué tengo que anteponer la palabra clave enum, por lo que el compilador sabe claramente que estoy declarando una variable de enumeración dada, sin usar el valor de otra enumeración en el mismo espacio de nombres. Simplemente no entiendo por qué, en primer lugar, incluso es posible hacer tal construcción.

Answer 1

C++ de 11 clases de enumeración son la solución para esto:

namespace Test 
{ 
    enum class EName 
    { 
     CoolEnum, 
     NiceEnum 
    }; 

    enum class CoolEnum 
    { 
     NiceVal1, 
     NiceVal2 
    }; 

    enum class NiceEnum 
    { 
     NiceVal1, 
     NiceVal2 
    }; 
} 

continuación, puede utilizar el apropiado NiceVal1:

Test::CoolEnum cEnum = Test::CoolEnum::NiceVal1; 

enumeraciones Plain fueron heredadas de C, donde no existe la noción de lo que es un espacio de nombres Si las enumeraciones simples introducen algún tipo de espacio de nombres, el código C que utiliza enumeraciones no se compilará en absoluto. Es por eso que se introdujeron las clases enum, para no romper la compatibilidad con versiones anteriores.

Answer 2

La respuesta es porque el estándar dicta este comportamiento. Ver 3.3.7/2:

un nombre de clase (9.1) o el nombre de la enumeración (7.2) se pueden ocultar por el nombre de un objeto, función o empadronador declarado en el mismo ámbito. Si una clase o nombre de enumeración y un objeto, función o enumerador son declarados en el mismo ámbito (en cualquier orden) con el mismo nombre, la clase nombre o enumeración está oculta donde sea que el objeto, función nombre del enumerador es visible.

Se supone que esto es para facilitar la compatibilidad con el mecanismo de C (donde un enumerador no abre un nuevo ámbito) que se ha establecido durante mucho tiempo.

En su caso, al menos con g ++ puede usar typename para indicar que desea utilizar el tipo en lugar del enumerador (typename Test::CoolEnum cEnum = Test::NiceVal1;).

En general, sin embargo, me gusta abarcar todas las enumeraciones en un espacio de nombres o clase para evitar estas colisiones por completo.