时间戳

首页 > 解决方案 > 嵌套的概念多态模板

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

问题描述

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

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

本质上，我想避免不同派生类型与相同模板参数的冲突，同时仍然强制执行概念约束。

标签： c++templatesnestedmetaprogrammingc++20

解决方案

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

这会创建从Derivedto的映射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 );

活生生的例子。

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

推荐阅读