嵌套概念多态模板

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;

和/或基于这些派生类型和元编程创建class？

我可以为每个派生类型创建一个 class，但我想避免这种情况，因为我有大约 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>)...> 或其变体。

Answer 2

如果你想在Function上加一个约束让DerivedTemplate从Base<someEnum1, someEnum2>派生出来，你可以检查DeriveTemplate&&是否可以转换为Base<someEnum1, someEnum2>&& 与模板参数 someEnum1 和 someEnum2:

template<Enum1 e1, Enum2 e2>
std::int32_t test(Base<e1, e2>&);
template<Enum1 e1, Enum2 e2>
std::int32_t test(Base<e1, e2> const&);
template<Enum1 e1, Enum2 e2>
std::int32_t test(Base<e1, e2>&&);
template<Enum1 e1, Enum2 e2>
std::int32_t test(Base<e1, e2> const&&);

template<typename T>
std::int8_t helper(...);
template<typename T>
std::int32_t helper(decltype(test(std::declval<T&&>()))*);

template<typename D>
inline constexpr bool is_base_of_Base_with_some_Enum = sizeof(helper<D>(nullptr)) == sizeof(std::int32_t);

然后您可以将类型别名 Function 更改为：

template<typename D>
struct FunctionImpl : std::enable_if<is_base_of_Base_with_some_Enum<D>, std::function<void(D&)>>{};

template<typename Derive>
using Function = typename FunctionImpl<Derive>::type;

Example.

嵌套概念多态模板

Nested Conceptual Polymorphic Templates

c++

templates

nested

metaprogramming

c++20