255

我正在寻找涉及将 C++ 模板函数作为参数传递的规则。

C++ 支持这一点，如下面的示例所示：

#include <iostream>

void add1(int &v)
{
  v+=1;
}

void add2(int &v)
{
  v+=2;
}

template <void (*T)(int &)>
void doOperation()
{
  int temp=0;
  T(temp);
  std::cout << "Result is " << temp << std::endl;
}

int main()
{
  doOperation<add1>();
  doOperation<add2>();
}

然而，学习这种技术是困难的。谷歌搜索“作为模板参数的函数”并没有带来太多结果。并且经典的C++ 模板完整指南令人惊讶地也没有讨论它（至少不是来自我的搜索）。

我的问题是这是否是有效的 C++（或者只是一些广泛支持的扩展）。

另外，有没有办法在这种模板调用期间允许具有相同签名的函子与显式函数互换使用？

以下在上述程序中不起作用，至少在Visual C++中，因为语法显然是错误的。能够为仿函数切换函数会很好，反之亦然，类似于如果您想定义自定义比较操作，您可以将函数指针或仿函数传递给 std::sort 算法。

   struct add3 {
      void operator() (int &v) {v+=3;}
   };
...

    doOperation<add3>();

指向一个或两个 Web 链接或 C++ 模板书中的页面的指针将不胜感激！

4

7 回答 7

147

是的，它是有效的。

至于让它与仿函数一起使用，通常的解决方案是这样的：

template <typename F>
void doOperation(F f)
{
  int temp=0;
  f(temp);
  std::cout << "Result is " << temp << std::endl;
}

现在可以称为：

doOperation(add2);
doOperation(add3());

现场观看

这样做的问题是，如果编译器难以内联对 的调用add2，因为编译器所知道的只是函数指针类型void (*)(int &)正在传递给doOperation。（但是add3，作为仿函数，可以很容易地内联。在这里，编译器知道一个类型的对象add3被传递给函数，这意味着要调用的函数是add3::operator()，而不仅仅是一些未知的函数指针。）

于 2009-07-23T20:12:14.077 回答
80

模板参数可以按类型（typename T）或按值（int X）参数化。

模板化一段代码的“传统”C++ 方法是使用函子——也就是说，代码在一个对象中，因此该对象为代码提供了唯一的类型。

在使用传统函数时，这种技术不能很好地工作，因为类型的变化并不表示特定的函数——而是它只指定了许多可能函数的签名。所以：

template<typename OP>
int do_op(int a, int b, OP op)
{
  return op(a,b);
}
int add(int a, int b) { return a + b; }
...

int c = do_op(4,5,add);

不等同于仿函数的情况。在此示例中，为所有签名为 int X (int, int) 的函数指针实例化 do_op。编译器必须非常积极才能完全内联这种情况。（不过我不排除它，因为编译器优化已经非常先进了。）

判断这段代码并没有完全符合我们要求的一种方法是：

int (* func_ptr)(int, int) = add;
int c = do_op(4,5,func_ptr);

仍然是合法的，显然这并没有被内联。为了获得完整的内联，我们需要按值模板，因此该函数在模板中是完全可用的。

typedef int(*binary_int_op)(int, int); // signature for all valid template params
template<binary_int_op op>
int do_op(int a, int b)
{
 return op(a,b);
}
int add(int a, int b) { return a + b; }
...
int c = do_op<add>(4,5);

在这种情况下，do_op 的每个实例化版本都使用已经可用的特定函数进行实例化。因此，我们希望 do_op 的代码看起来很像“return a + b”。（Lisp 程序员，别再傻笑了！）

我们还可以确认这更接近我们想要的，因为：

int (* func_ptr)(int,int) = add;
int c = do_op<func_ptr>(4,5);

将无法编译。GCC 说：“错误：'func_ptr' 不能出现在常量表达式中。换句话说，我无法完全扩展 do_op，因为您在编译器时没有给我足够的信息来知道我们的操作是什么。

所以如果第二个例子真的完全内联了我们的操作，而第一个不是，那么模板有什么用呢？它在做什么？答案是：类型强制。第一个例子的这个即兴演奏将起作用：

template<typename OP>
int do_op(int a, int b, OP op) { return op(a,b); }
float fadd(float a, float b) { return a+b; }
...
int c = do_op(4,5,fadd);

该示例将起作用！（我并不是说它是好的 C++，但是......）发生的事情是 do_op 已经围绕各种函数的签名进行了模板化，并且每个单独的实例化都会编写不同类型的强制代码。所以带有 fadd 的 do_op 的实例化代码如下所示：

convert a and b from int to float.
call the function ptr op with float a and float b.
convert the result back to int and return it.

相比之下，我们的按值案例要求函数参数完全匹配。

于 2010-01-28T18:28:54.760 回答
23

函数指针可以作为模板参数传递，这是标准 C++ 的一部分 。但是在模板中，它们被声明并用作函数而不是指向函数的指针。在模板实例化时，传递函数的地址而不仅仅是名称。

例如：

int i;


void add1(int& i) { i += 1; }

template<void op(int&)>
void do_op_fn_ptr_tpl(int& i) { op(i); }

i = 0;
do_op_fn_ptr_tpl<&add1>(i);

如果您想将仿函数类型作为模板参数传递：

struct add2_t {
  void operator()(int& i) { i += 2; }
};

template<typename op>
void do_op_fntr_tpl(int& i) {
  op o;
  o(i);
}

i = 0;
do_op_fntr_tpl<add2_t>(i);

几个答案将仿函数实例作为参数传递：

template<typename op>
void do_op_fntr_arg(int& i, op o) { o(i); }

i = 0;
add2_t add2;

// This has the advantage of looking identical whether 
// you pass a functor or a free function:
do_op_fntr_arg(i, add1);
do_op_fntr_arg(i, add2);

使用模板参数最接近这种统一外观的方法是定义do_op两次——一次使用非类型参数，一次使用类型参数。

// non-type (function pointer) template parameter
template<void op(int&)>
void do_op(int& i) { op(i); }

// type (functor class) template parameter
template<typename op>
void do_op(int& i) {
  op o; 
  o(i); 
}

i = 0;
do_op<&add1>(i); // still need address-of operator in the function pointer case.
do_op<add2_t>(i);

老实说，我真的希望这不会编译，但它适用于 gcc-4.8 和 Visual Studio 2013。

于 2014-03-01T08:17:15.617 回答
11

在您的模板中

template <void (*T)(int &)>
void doOperation()

该参数T是非类型模板参数。这意味着模板函数的行为随着参数的值而变化（必须在编译时固定，函数指针常量是什么）。

如果你想要一个同时适用于函数对象和函数参数的东西，你需要一个类型化的模板。但是，当您这样做时，您还需要在运行时向函数提供对象实例（函数对象实例或函数指针）。

template <class T>
void doOperation(T t)
{
  int temp=0;
  t(temp);
  std::cout << "Result is " << temp << std::endl;
}

有一些次要的性能考虑。这个新版本对于函数指针参数的效率可能较低，因为特定函数指针仅在运行时被取消引用和调用，而您的函数指针模板可以根据使用的特定函数指针进行优化（可能是函数调用内联）。函数对象通常可以使用类型化模板非常有效地扩展，尽管具体operator()情况完全由函数对象的类型决定。

于 2009-07-23T20:18:34.593 回答
2

您的仿函数示例不起作用的原因是您需要一个实例来调用operator().

于 2009-07-23T20:12:35.247 回答
1

带着额外的要求来到这里，参数/返回类型也应该有所不同。在 Ben Supnik 之后，这将适用于某些类型 T

typedef T(*binary_T_op)(T, T);

代替

typedef int(*binary_int_op)(int, int);

这里的解决方案是将函数类型定义和函数模板放入一个环绕的struct模板中。

template <typename T> struct BinOp
{
    typedef T(*binary_T_op )(T, T); // signature for all valid template params
    template<binary_T_op op>
    T do_op(T a, T b)
    {
       return op(a,b);
    }
};


double mulDouble(double a, double b)
{
    return a * b;
}


BinOp<double> doubleBinOp;

double res = doubleBinOp.do_op<&mulDouble>(4, 5);

或者 BinOp 可以是具有静态方法模板 do_op(...) 的类，然后称为

double res = BinOp<double>::do_op<&mulDouble>(4, 5);

编辑

受来自 0x2207 的评论的启发，这里是一个仿函数，它采用具有两个参数和可转换值的任何函数。

struct BinOp
{
    template <typename R, typename S, typename T, typename U, typename V> R operator()(R (*binaryOp )(S, T), U u, V v)
    {
        return binaryOp(u,v);
    }

};

double subD(double a, int b)
{
    return a-b;
}

int subI(double a, int b)
{
    return (int)(a-b);
}


int main()
{
    double resD = BinOp()(&subD, 4.03, 3);
    int resI = BinOp()(&subI, 4.03, 3);

    std::cout << resD << std::endl;
    std::cout << resI << std::endl;
    return 0;
}

正确计算为双1.03 和int 1

于 2020-08-18T12:58:09.560 回答
0

编辑：将运算符作为参考传递是行不通的。为简单起见，将其理解为函数指针。您只需发送指针，而不是参考。我想你正在尝试写这样的东西。

struct Square
{
    double operator()(double number) { return number * number; }
};

template <class Function>
double integrate(Function f, double a, double b, unsigned int intervals)
{
    double delta = (b - a) / intervals, sum = 0.0;

    while(a < b)
    {
        sum += f(a) * delta;
        a += delta;
    }

    return sum;
}

. .

std::cout << "interval : " << i << tab << tab << "intgeration = "
 << integrate(Square(), 0.0, 1.0, 10) << std::endl;
于 2009-07-23T20:19:16.183 回答