枚举类可以嵌套吗?

时间:2013-02-24 21:59:33

标签: c++ c++11 enum-class

可以这样做吗?

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

};

希望使用强类型功能。

4 个答案:

答案 0 :(得分:9)

,它们无法以这种方式嵌套。实际上,任何编译器都会拒绝它。

  

如果没有替代解决方案?

这主要取决于你想要达到的目标(解决什么问题?)。如果您的目标是能够编写类似A::B::SOMETHING1的内容,那么您可以在命名空间中定义它们,这样:

namespace A
{
    enum B
    {
        SOMETHING1,
        SOMETHING2
    };

    enum C
    {
        SOMETHING3,
        SOMETHING4
    };     
}

答案 1 :(得分:3)

看到在这种特殊情况下,枚举不太可能经常改变,你可以选择:

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

        // ...
    }
}

然而,我确实想知道为什么你想为不同类型的粒子使用不同的enum类型。您是否有接受Mesons类型但不属于Leptons类型的参数的函数?如果没有,并且您的所有函数都接受任何粒子,那么请使用单个enum - 最好将长前缀放到MATTER_MESONS_MATTER_BARYONS_等值的名称中。

答案 2 :(得分:0)

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

你介意一点C ++ 11模板魔术吗?

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目前无法在两个层次结构之外工作,但如果您愿意,可以添加此项

答案 3 :(得分:-2)

不,如果没有在一个枚举中的长列表中定义所有内容,就无法做到这一点。

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

如果这对你没有意义,那么你肯定是一名物理学家。

我接受这个作为停止来自stackoverflow的进一步通知的答案,要求我接受答案。