How can I do the type deduction on parameterized template function

#include <iostream>

template <typename... Ts> void Print(Ts... args) { 
  (std::cout << ... << args) << std::endl;
}

template <typename T> void Add(T a, T b) { Print(a + b); } 

template <typename T> void Sub(T a, T b) { Print(a - b); } 

template <typename T> void Mul(T a, T b) { Print(a * b); } 

template <typename F, typename... Fns> void CallFuncs(F a, F b, Fns... fns) { 
  (fns(a, b), ...);
};

void FunctionInvokeTest() { CallFuncs(1, 2, Add<int>, Mul<int>); }

int main() { 
  FunctionInvokeTest();
  return 0;
}

I want to pass the template function as parameter shown as above. The code works. However I must put <int> after the function such as Add<int>.

If this is non-deductible context, then is there another way to allow me write like this, where the Add and Mul are still template functions?

CallFuncs(1,2, Add, Mul);

You can't do it directly, but you can turn functions into function objects:

struct Add {
    template<typename T>
    void operator()(T a, T b) {
        Print(a + b); } 
};

struct Mul {
    template<typename T>
    void operator()(T a, T b) {
        Print(a * b); } 
};

template<typename F, typename... Fns>
void CallFuncs(F a, F b, Fns... fns) {
    (fns(a, b), ...);
};

void FunctionInvokeTest() { 
    CallFuncs(1, 2, Add{}, Mul{});
}

T will be deduced from the type of a and b. In this example it will be int. To get double, you need double parameters:

CallFuncs(1., 2., Add{}, Mul{});

or explicit type specification:

CallFuncs<double>(1, 2, Add{}, Mul{});

This is very similar to "diamond" functors in the standard library (since C++14). For example, the std::plus declaration is

template<class T = void>
struct plus;

If T is void (e.g., in std::plus<>{}), plus::operator() deduces argument and return types. Typical implementation looks like this (with some minor simplifications):

template<> struct plus<void> {
    template<typename Tp, typename Up>
    constexpr auto operator()(Tp&& t, Up&& u) const {
        return std::forward<Tp>(t) + std::forward<Up>(u);
    }
};

</details>



# 答案2
**得分**: 2

如果您可以将模板函数转换为函数对象类，您可以这样做：

```cpp
struct Add {
    template <typename T>
    void operator ()(T a, T b) const { Print(a + b); } 
};

struct Sub {
    template <typename T> void operator() (T a, T b) const  { Print(a - b); } 
};

struct Mul {
    template <typename T> void operator() (T a, T b) const { Print(a * b); } 
};

然后您可以这样使用：

void FunctionInvokeTest() { CallFuncs(1, 2, Add{}, Mul{}); }

或者要使用更类似的语法：

constexpr Add add{};
constexpr Mul mul{};

void FunctionInvokeTest() { CallFuncs(1, 2, add, mul); }

如果无法更改您的函数，将它们包装在lambda函数中可能会有所帮助：

void FunctionInvokeTest() { CallFuncs(1, 2,
                                      [](auto lhs, auto rhs) { Add(lhs, rhs); },
                                      [](auto lhs, auto rhs) { Mul(lhs, rhs); }); }

struct Add {
    template <typename T>
    void operator ()(T a, T b) const { Print(a + b); } 
};

struct Sub
{
    template <typename T> void operator() (T a, T b) const  { Print(a - b); } 
};

struct Mul
{
    template <typename T> void operator() (T a, T b) const { Print(a * b); } 
};

void FunctionInvokeTest() { CallFuncs(1, 2, Add{}, Mul{}); }

constexpr Add add{};
constexpr Mul mul{};

void FunctionInvokeTest() { CallFuncs(1, 2, add, mul); }

void FunctionInvokeTest() { CallFuncs(1, 2,
                                      [](auto lhs, auto rhs) { Add(lhs, rhs); },
                                      [](auto lhs, auto rhs) { Mul(lhs, rhs); }); }

答案3

得分: 2

将函数参数移入模板的解决方法

template <typename F>
using BinaryOp = void(F, F); // 函数类型

// fns 现在是函数对象的包，而不是类型
template <typename F, BinaryOp<F>... fns>
void CallFuncs(F a, F b) { 
  (fns(a, b), ...);
};

void FunctionInvokeTest() {
    // 现在将函数作为模板参数传递，与所需的数字类型一起
    CallFuncs<float, Add, Mul>(1, 2); 
}

链接: https://godbolt.org/z/DutpHk

template <typename F>
using BinaryOp = void(F, F); // function type

// fns is now a pack of function objects instead of types
template <typename F, BinaryOp<F>... fns>
void CallFuncs(F a, F b) { 
  (fns(a, b), ...);
};

void FunctionInvokeTest() {
    // the functions are now passed as template arguments alongside the desired numeric type
    CallFuncs<float, Add, Mul>(1, 2); 
}