将指向模板函数的指针作为函数参数传递？

Question

假设我想要一个 C++ 函数对两个输入执行算术运算，并将它们视为给定类型：

伪：

function(var X,var Y,function OP)
{
 if(something)
  return OP<int>(X,Y);
 else if(something else)
  return OP<double>(X,Y);
 else
  return OP<string>(X,Y);
}

适合 OP 的函数可能是这样的：

template <class T> add(var X,var Y)
{
 return (T)X + (T)Y; //X, Y are of a type with overloaded operators
}

那么，问题是函数的签名是什么样的？如果运算符函数是非模板化的，我可以这样做，但我对这种额外的复杂性感到困惑。

Answer 1

模板函数不能作为模板参数传递。在将它传递给另一个模板函数之前，您必须手动推断此函数的模板参数。比如你有函数

T sum(T a, T b)
{
    return a + b;
}

你想把它传递给 callFunc:

template<typename F, typename T>
T callFunc(T a, T b, F f)
{
    return f(a, b);
}

你不能简单地写

int a = callFunc(1, 2, sum);

你必须写

int a = callFunc(1, 2, sum<int>);

为了能够在不编写 int 的情况下传递 sum，您必须编写一个函子 - 带有 operator() 的结构或类来调用您的模板函数。然后您可以将此函子作为模板参数传递。这是一个例子。

template<class T>
T sum(T a, T b)
{
    return a + b;
}
template<class T>
struct Summator
{
    T operator()(T a, T b)
    {
        return sum<T>(a, b);
    }
};
template<template<typename> class TFunctor, class T>
T doSomething(T a, T b)
{
    return TFunctor<T>()(a, b);
    //Equivalent to this:
    //TFunctor<T> functor;
    //return functor(a, b);
}


int main()
{
    int n1 = 1;
    int n2 = 2;
    int n3 = doSomething<Summator>(n1, n2); //n3 == 3
    return 0;
}

Answer 2

你在找这个吗？

template<class T> T add(T X, T Y)
{
    return X + Y;
}

或者您正在寻找类似 add 的东西？

template<class T, class F>
T Apply(T x, T y, F f)
{
    return f( x, y );
}

调用方式：

int x = Apply( 2, 4, add<int> );

Answer 3

我有点困惑……为什么你的伪代码中有类型区分？

C++ 模板允许对模板进行完整的类型推导：

template <typename T, typename F>
T function(T x, T y, F op) {
    return op(x, y);
}

在这里，F 适合任何可以使用 () 函数调用语法调用的任何东西（尤其是函数），并且只接受两个 T 类型的参数（或隐式转换为它）。

Answer 4

我为此使用 lambdas。

auto add = [](const auto& lhs, const auto& rhs) {
    static_assert(std::is_arithmetic<typename std::decay<decltype(lhs)>::type>::value,
            "Needs to be arithmetic.");
    static_assert(std::is_arithmetic<typename std::decay<decltype(rhs)>::type>::value,
            "Needs to be arithmetic.");
    return lhs + rhs;
};

template<typename LHS, typename RHS, typename FUNC
    , typename OUT = typename std::result_of<FUNC(LHS, RHS)>::type>
constexpr OUT do_arithmetic(LHS lhs, RHS rhs, FUNC func) {
    return func(lhs, rhs);
}

constexpr auto t = do_arithmetic(40, 2, add);
static_assert(t == 42, "Wrong answer!");
static_assert(std::is_same<std::decay<decltype(t)>::type, int>::value,
        "Should be int.");

Answer 5

我认为您正在寻找Strategy Pattern。

Answer 6

template <class OP> void function(OP op)
{
  // call with int
  op(1, 2);
  // or with double
  op(1.2, 2.3);
  // call with explicit template argument
  op.template operator()<int>(1, 2);
  op.template operator()<string>("one", "two");
}

struct Add
{
  template <class T> T operator ()(T a, T b)
  {
    return a + b;
  }
};

function(Add());
// or call with C++14 lambda
function([](auto a, auto b) { return a + b; });

Answer 7

我不确定您问题中的 var 是什么意思。它肯定不是一个有效的 C++ 关键字，所以我认为它是类似于boost:any 的类型。此外，该函数缺少结果类型。我添加了另一个var，不管它是什么。您的解决方案可能如下所示：

template< template<typename> class Func >
var function(var X, var Y, Func OP)
{
 if(something)
  return OP<int>(X,Y);
 else if(something else)
  return OP<double>(X,Y);
 else
  return OP<string>(X,Y);
}

有趣的模板参数是一个模板本身，因此它的名字是“模板模板参数”。您传入模板的名称，而不是实例。也就是说，你通过std::plus，而不是std::plus<int>：

return function( a, b, std::plus );