C ++從屬常量

Question

我有一組固定的領域特定類別。 每個類別都由可枚舉類型的相關常量值（本身有用）標識。 此外，每個類別都有一組固定的子類別。 每個子類別都將由一個相關的常數值（也有用）來標識，該常數在該類別中是唯一的，但在各個類別中不是唯一的。

我試圖找到一種方法來聲明我的子類別的標識符，“從屬於”類別的標識符，即使得子類別標識符可以通過相關的類別標識符以編譯時解析的方式進行訪問。

在C ++ 14中執行此操作的適當方法是什么？

標識符只是可枚舉類型的常量值（讓它基於int）。

這是我嘗試過的：

enum Category
{
  One = 1,
  Two = 2,
  Three = 3
};

template<Category categoryName> struct Subcategory;

template<> struct Subcategory<Category::One>
{
  enum
  {
    A = 0,
    B = 1
  };
};

我們可以通過Subcategory<Category::One>::A訪問子類別標識符（不是很刺激...）

該表達式看起來太長，我正在嘗試找到一種解決方案，該方案可以使訪問A的表達式更簡潔。沿着這條路徑的最后一招就是使第一個枚舉不具名。

實際上，正如pepper_chico所指出的，表達式被簡化為Subcategory<One>::A 是否有一種解決方案（可能不是基於模板的）可以擺脫標識符Subcategory ，而只留下One和A ？

Answer 1

這有點奇怪，但是通過定義與類別相對應的對象，您可以為子類別名稱啟用語法One.A （ Live at Coliru ）：

#include <iostream>
#include <type_traits>

enum class Category
{
  One = 1,
  Two = 2,
  Three = 3
};

template <Category> struct CategoryDescriptor;

#define DECLARE(name,...) \
template <> \
struct CategoryDescriptor<Category::name> { \
  enum sub_type { __VA_ARGS__ }; \
  constexpr operator Category() const { return Category::name; } \
}; \
constexpr CategoryDescriptor<Category::name> name{}

DECLARE(One, A, B);
DECLARE(Two, C, D);
DECLARE(Three, A, C, E);

#undef DECLARE

std::ostream& operator << (std::ostream& os, Category c) {
    return os << static_cast<std::underlying_type<Category>::type>(c);
}

template <Category C>
using SubCategoryOf = typename CategoryDescriptor<C>::sub_type;

int main() {
    std::cout << "One = " << One << "\n"
                 "One.A = " << One.A << "\n"
                 "Two = " << Two << "\n"
                 "Two.D = " << Two.D << "\n"
                 "Three = " << Three << "\n"
                 "Three.A = " << Three.A << '\n';

    // Category names convert to Category
    auto foo = [](Category){};
    foo(Three);

    // Subcategory names convert to SubCategoryOf<Category>
    auto bar = [](SubCategoryOf<Two>){};
    bar(Two.C);
}