带有可变模板的静态继承

Question

我正在尝试使用std::conditional来实现静态继承。我的child类有两个可能的父类：parent_one (它应该根据传递的类型保存多个变量)和parent_two (它需要两种类型)。我使用标记分派来区别我想要继承的类。

现在是问题所在。当我调用child并用两种类型标记它从parent_one继承时，它按预期工作。但是，如果我试图将任意数量的类型传递到child中，以便从parent_one继承，则会得到错误：

static_polymorphism.cpp: In instantiation of ‘class child<foo_type, int, int, double, float>’:
static_polymorphism.cpp:110:41:   required from here
static_polymorphism.cpp:99:7: error: wrong number of template arguments (4, should be 2)
   99 | class child : public std::conditional_t<
      |       ^~~~~
static_polymorphism.cpp:90:7: note: provided for ‘template<class T, class F> class parent_two’
   90 | class parent_two {
      |       ^~~~~~~~~~
static_polymorphism.cpp: In function ‘int main(int, char**)’:
static_polymorphism.cpp:111:9: error: ‘class child<foo_type, int, int, double, float>’ has no member named ‘log’
  111 |   first.log();

如果我理解正确的话，编译器应该根据我的标记分派来生成代码。这意味着它应该从parent_one创建重载类-N(基于传递的类型)，从parent_two创建M(基于传递的类型)。但是，由于某些原因，我不知道它是否接受类型的变量计数。能告诉我我做错了什么吗？

实现就在这里。

using one_t = struct foo_type{};
using two_t = struct bar_type{};

template <typename ... TYPES>
class parent_one {
public:
  parent_one() = default;
  void log() {
    std::cout << "parent_one" << std::endl;
  }
};

template <typename T, typename F>
class parent_two {
public:
  parent_two() = default;
  void log() {
    std::cout << "parent_two" << std::endl;
  }
};

template <typename T, typename ... ARGS>
class child : public std::conditional_t<
    std::is_same_v<T, one_t>,
    parent_one<ARGS...>,
    parent_two<ARGS...>
  >
{
public:
  child() = default;
};

int main(int argc, char *argv[]) {
  child<one_t, int, int, double, float> first;
  first.log();

  child<two_t, int, int> second;
  second.log();
  return 0;
}

Answer 1

std::conditional_t<
    std::is_same_v<T, one_t>,
    parent_one<ARGS...>,
    parent_two<ARGS...>
>

这里，在检查条件之前，将对这两个选项进行验证。std::conditional_t并不神奇，它只是一个普通的模板，它需要所有的模板参数都是有效的，然后才能做任何事情。

您需要延迟将模板参数替换为父模板，直到选择了其中一个替代方案。这里有一个可能的解决方案：

template <template <typename...> typename T>
struct delay
{
    template <typename ...P>
    using type = T<P...>;
};
// ...
class child :
    public std::conditional_t<
        std::is_same_v<T, one_t>,
        delay<parent_one>,
        delay<parent_two>
    >::template type<ARGS...> 
{
    // ...
};

Answer 2

你可能是经典的：

template<class T, class... Args> struct child: parent_one<Args...> {};

template<class T, class A, class B> struct child<T, A, B>: parent_two<A, B> {};

template<class A, class B> struct child<one_t, A, B>: parent_one<A, B> {};

(这两个专门化可以结合为一个与requires (!std::is_same_v<T, one_t>))。