c++ - 嵌套概念多态模板

Question

假设我有编译时多态继承结构:

enum class Enum1 {
    Undefined = 0;
    /* ... */
};
enum class Enum2 {
    Undefined = 0;
    /* ... */
};

template<Enum1 A, Enum2 B>
struct Base {
    int state;
};

struct Derived : public Base <Enum1::Undefined, Enum2::Undefined>> {
    int statederived;
};

有没有办法做这样的事情:

template<Base<Enum1, Enum2> DerivedTemplate>
using Function = std::function<void (DerivedTemplate&)>;

去完成:

Function<Derived> & function;

或者使用元编程基于这些派生类型创建一个类？
我可以为这些派生类型中的每一个创建一个类，但我想避免这种情况，因为我有大约 50 个。
本质上，我想避免具有相同模板参数的不同派生类型的冲突，同时仍然强制执行概念约束。

Answer 1

struct Derived : public Base <Enum1::Undefined, Enum2::Undefined>> {
  int statederived;
};

这将创建一个来自 Derived 的映射至 Base<Enum1::Undefined, Enum2::Undefined> ，但不会以相反的方式创建映射。
现在你可以这样做

template<Enum e1, Enum e2, class D>
struct DerivedExtra:Base<e1, e2> {
  // can static cast to D to get Derived stuff
};

template<Enum1 e1, Enum2 e2>
struct Derived:
  DerivedExtra<e1, e2, Derived<e1, e2>>
{
  constexpr auto E1 = e1;
  constexpr auto E2 = e2;

  // common codes goes here
};

通过专业编写任何自定义派生状态 DerivedExtra :

template<class D>
struct DerivedExtra<
  Derived<Enum1::Undefined, Enum2::Undefined>,
  D 
>:
  Base<Enum1::Undefined, Enum2::Undefined>
{
  int statederived;
};

现在我们可以获取 Enum1 的列表和 Enum2状态并制作笛卡尔积。

template<auto x>
using constant_t = std::integral_constant<std::decay_t<decltype(x)>, x>;
template<auto x>
constexpr constant_t<x> constant = {};

constexpr auto enum1s = std::make_tuple(
  constant<Enum1::Undefined>,
  constant<Enum1::Defined>
);
constexpr auto enum2s = std::make_tuple(
  constant<Enum2::Undefined>,
  constant<Enum2::Defined>
);

constexpr auto e1xe2 = std::apply( [](auto...e1s) {
  return std::tuple_cat(
    std::apply([e1=e1s](auto...e2s) {
      return std::make_tuple(
        std::make_tuple(
          e1,
          e2s
        )...
      );
    }, enum2s )...
  );
}, enum1s );

Live example .
使用 e1xe2s你可以做一个 std::tuple<std::function<void(Derived<a, b>)...>例如，或相同的变体。