enum 클래스를 중첩 할 수 있습니까?

Question

이 작업을 수행 할 수 있습니까?

enum A 
{ 
    enum B 
    { 
     SOMETHING1, 
     SOMETHING2 
    }; 

    enum C 
    { 
     SOMETHING3, 
     SOMETHING4 
    }; 
}; 

대체 솔루션이 없다면?

이 질문의 목적은 : 원함 /은 같은 것을 할 수 있어야합니다 :

enum class ElementaryParticleTypes 
{ 

    enum class MATTER 
    { 
     enum class MESONS 
     { 
      PI 
     }; 

     enum class BARYONS 
     { 
      PROTON, 
      NEUTRON 
     }; 

     enum class LEPTONS 
     { 
      ELECTRON 
     }; 
    }; 

    enum class ANTI_MATTER 
    { 
     enum class ANTI_MESONS 
     { 
      ANTI_PI 
     }; 

     enum class ANTI_BARYONS 
     { 
      ANTI_PROTON 
      ANTI_NEUTRON 
     }; 

     enum class ANTI_LEPTONS 
     { 
      POSITRON 
     }; 
    }; 

}; 

위시는 강력한 형식의 기능을 사용 할 수 있습니다.

Answer 1

아니요과 같이 중첩 될 수 없습니다. 사실, 모든 컴파일러는이를 거부합니다.

If not is there an alternative solution?

대부분 해결하려고하는 대상에 따라 다릅니다 (문제의 해결책은 무엇입니까?). 당신의 목표는 A::B::SOMETHING1 같은 것을 쓸 수 있어야하는 경우, 당신은 단지 네임 스페이스 내에서 그것들을 정의 할 수 있습니다,이 방법 :

namespace A 
{ 
    enum B 
    { 
     SOMETHING1, 
     SOMETHING2 
    }; 

    enum C 
    { 
     SOMETHING3, 
     SOMETHING4 
    };  
} 

Answer 2

아니, 하나를 내부에 긴 목록에서 모든 것을 정의하지 않고이 일을 방법이 없습니다 enum.

enum class A{ 
    PARTICLE_MATTER_BARYON_PROTON, 
    PARTICLE_MATTER_BARYON_NEUTRON, 
    PARTICLE_ANTIMATTER_BARYON_PROTON // etc 
}; 

이것은 사용자에게 이해가되지 않는 경우라면 분명 물리학 자입니다.

나는이 대답을 받아들이고 대답을 받아들이라는 stackoverflow에서 더 이상의 알림을 중지합니다.

Answer 3

MESONS pi = PI(); 
MATTER mat = pi; 
assert (pi == mat); 

약간의 C++ 11 템플릿 마법에 신경 써야합니까? 이 특별한 경우에 그것을보고

Answer 4

에서, 열거하면, 자주 변경 가능성이 없습니다

template <typename T, typename... L> 
struct is_defined_in : std::false_type {}; 

template <typename T, typename U, typename... L> 
struct is_defined_in<T, U, L...> : is_defined_in<T, L...> {}; 

template <typename T, typename... L> 
struct is_defined_in<T, T, L...> : std::true_type {}; 

template <int ID> struct helper { 
    friend bool operator==(helper a, helper b) 
    { return a.id == b.id; } 
    friend bool operator!=(helper a, helper b) 
    { return a.id != b.id; } 

    int id=ID; 
}; 
template <typename... B> struct category { 
    int id; 

    template <typename T, 
      typename = typename std::enable_if<is_defined_in<T, B...>::value>::type> 
    category(T t) : id(t.id) {} 

    friend bool operator==(category a, category b) 
    { return a.id == b.id; } 
    friend bool operator!=(category a, category b) 
    { return a.id != b.id; } 
}; 

enum class ElementaryParticleTypesID 
{ PI, PROTON, NEUTRON, ELECTRON }; 

struct PI  : helper<(int)ElementaryParticleTypesID::PI> {}; 
struct PROTON : helper<(int)ElementaryParticleTypesID::PROTON> {}; 
struct NEUTRON : helper<(int)ElementaryParticleTypesID::NEUTRON> {}; 
struct ELECTRON : helper<(int)ElementaryParticleTypesID::ELECTRON> {}; 

using MESONS = category<PI>; 
using BARYONS = category<PROTON, NEUTRON>; 
using LEPTONS = category<ELECTRON>; 

using MATTER = category<MESONS, BARYONS, LEPTONS>; 

(당신이 원하는 경우 현재 the static_assert 두 계층 이상 작동하지 않습니다,하지만이 추가 될 수 있습니다) 당신이 입자의 다른 유형에 대해 다른 enum 유형을 원하는 이유는, 그러나 놀라움을

namespace ParticleTypes { 
    namespace Matter { 
     enum Mesons { 
      Pi 
     }; 

     enum Baryons { 
      Proton = Pi + 1, 
      Neutron 
     }; 

     enum Leptons { 
      Electron = Neutron + 1 
     }; 
    } 

    namespace AntiMatter { 
     enum AntiMesons { 
      AntiPi = Matter::Electron + 1 
     }; 

     // ... 
    } 
} 

: 갈 수 있습니다. 유형 Mesons의 인수를 허용하지만 형식이 Leptons이 아닌 함수가 있습니까? 그렇지 않은 경우 모든 함수에서 입자를 허용하면 enum 단일 문자를 사용하고 MATTER_MESONS_, MATTER_BARYONS_ 등의 이름에 긴 접두어를 사용하지 않는 것이 좋습니다.