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的进一步通知的答案，要求我接受答案。

枚举类可以嵌套吗？

4 个答案: