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

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>);

为了能够传递sum而不写int，你有编写一个函子 - 具有将调用模板函数的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

我为此使用 lambda。

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

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 6

我认为您正在寻找策略模式。

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：

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