c++ - 枚举类可以嵌套吗？

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

不，它们不能那样嵌套。事实上，任何编译器都会拒绝它。

如果没有，是否有替代解决方案？

这主要取决于您要实现的目标（解决什么问题？）。如果您的目标是能够编写类似的东西A::B::SOMETHING1，您可以在命名空间中定义它们，这样：

namespace A
{
    enum B
    {
        SOMETHING1,
        SOMETHING2
    };

    enum C
    {
        SOMETHING3,
        SOMETHING4
    };     
}

Answer 2

看到在这种特殊情况下，枚举不太可能经常更改，您可以选择：

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_。

Answer 3

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目前不能在两个层次结构之外工作，但如果您愿意，可以添加）

Answer 4

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

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

如果这对您没有意义，那么您肯定是物理学家。

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