使用可变参数函数作为模板参数

Question

我想让以下代码在不更改 Child1 和 Child2 类的情况下运行：

#include <iostream>

int triple(int a) {
    return a * 3;
}

int add(int a, int b) {
    return a + b;
}

template<int (*F)(int)>
class Parent {
    public:
        Parent(int a) {
            std::cout << "constructed: " << F(a) << std::endl;
        }
};

class Child1 : Parent<triple> {
    public:
        Child1(int a) : Parent(a) {}
};

/*class Child2 : Parent<add> {
    public:
        Child2(int a, int b) : Parent(a, b) {}
};*/

int main() {
    Child1 child(4);
    //Child2 child(5, 6);
    return 0;
}

例如，您可以看到，Child1 继承自 Parent，该 Parent 已使用 triple 函数实例化。因此，当Child1 被实例化为 4 时，它会输出“constructed: 12”。

相比之下，Child2 被注释掉了，因为它显然还不能工作。在主函数中，我试图将两个参数传递给Child2 构造函数，就像底层add() 函数所期望的那样。然而，Parent 的构造函数只接受一个参数，并且可能需要在它前面加上template<typename Args...> 才能解决问题。此外，Parent 类将需要一个模板参数，如int (*F)(Args...)。最终，像 main 函数一样构造一个Child2 实例应该输出“constructed: 11”。

我怎样才能做到这一点，即创建一个模板参数，它是一个可以有任意数量参数的函数？同样，请注意 Parent 类的代码是唯一可以更改的内容。

Answer 1

使用 C++17，您可以使用推导的非类型模板参数并使构造函数成为可变参数模板：

template<auto x_pointer_to_function>
class Parent
{
    public:
    template<typename... x_Args>
    Parent(x_Args &&... args)
    {
        std::cout << "constructed: " << ((*x_pointer_to_function)(::std::forward<x_Args>(args)...)) << std::endl;
    }
};

online compiler

Answer 2

来不及玩了？

我提出了基于 C++17 VTT 的 auto 的变体，它使用类专业化来提取 Args... 输入类型（以及 Ret 类型，如果有用的话）。

我是说

template <auto>
class Parent;

template <typename Ret, typename ... Args, Ret(*F)(Args...)>
class Parent<F>
 {
   public:
      Parent (Args const & ... as)
       { std::cout << "constructed: " << F(as...) << std::endl; }
 };

以下是完整的编译示例

#include <iostream>

int triple (int a)
 { return a * 3; }

long add (int a, int b)
 { return a + b; }

template <auto>
class Parent;

template <typename Ret, typename ... Args, Ret(*F)(Args...)>
class Parent<F>
 {
   public:
      Parent (Args const & ... as)
       { std::cout << "constructed: " << F(as...) << std::endl; }
 };

class Child1 : public Parent<triple>
 {
    public:
        Child1 (int a) : Parent{a}
         { }
 };

class Child2 : public Parent<add>
 {
    public:
        Child2 (int a, int b) : Parent{a, b}
         { }
 };

int main()
 {
   Child1 c1{4};
   Child2 c2{5, 6};
 }

松散的完美转发，但可以控制参数的数量（和类型）。