C++模板化函子

Question

我想知道是否有人可以帮助我处理函子。我真的不明白函子是什么以及它们是如何工作的我尝试过谷歌搜索但我仍然不明白。函子如何工作以及它们如何与模板一起工作

Answer 1

函子基本上是一个“函数对象”。它是一个封装在类或结构中的单个函数，您可以将其传递给其他函数。

它们通过创建您自己的类或结构来工作，该类或结构会重载函数调用运算符（称为 operator() ）。通常，您只需将其构造为带有函子的函数的参数即可创建它的实例。

假设您有以下情况：

std::vector<int> counts;

现在，您想要增加该向量中包含的所有计数。您可以手动循环它们以增加它们，或者您可以使用函子。在这种情况下，合适的函子如下所示：

struct IncrementFunctor
{
    int operator() (int i)
    {
        return i + 1;
    }
}

IncrementFunctor 现在是一个函子，它接受任何整数并递增它。要将其应用于计数，您可以使用 std::transform 函数，该函数将函子作为参数。

std::transform(
    counts.begin(),       // the start of the input range
    counts.end(),         // the end of the input range
    counts.begin(),       // the place where transform should place new values. 
                          // in this case, we put it right back into the original list.
    IncrementFunctor());  // an instance of your functor

语法 IncrementFunctor() 创建该函子的一个实例，然后将其直接传递给 std::transform。当然，您可以创建一个实例作为局部变量并将其传递，但​​这要方便得多。

现在，进入模板。 std::transform 中函子的类型是模板参数。这是因为 std::transform 不知道（或关心！）你的函子是什么类型。它所关心的是它定义了一个合适的operator()，为此它可以做类似的事情

newValue = functor(oldValue);

编译器对模板非常聪明，并且通常可以自己找出模板参数是什么。在这种情况下，编译器会自动意识到您正在传递 IncrementFunctor 类型的参数，该参数在 std::transform 中定义为模板类型。它也对列表执行相同的操作，因此编译器会自动识别实际的调用如下所示：

std::transform<std::vector<int>::iterator, // type of the input iterator
               std::vector<int>::iterator, // type of the output iterator
               IncrementFunctor>(          // type of your functor
    counts.begin(),       // the start of the input range
    counts.end(),         // the end of the input range
    counts.begin(),       // the place where transform should place new values. 
                          // in this case, we put it right back into the original list.
    IncrementFunctor());  // an instance of your functor

它可以节省您相当多的打字时间。 ;)

Answer 2

函子是可以使用函数调用运算符调用的东西，在语法上通过附加()，并且可以选择在括号内添加参数列表。

这就是模板所需要的全部内容。就模板而言，调用此函数的对象是任何允许此语法的对象，或者换句话说，可以是自由函数，也可以是重写operator()()<的类的实例/代码>。 （“自由”函数只是一个不是成员的函数，也就是说，它是全局范围内的函数或先前包含的命名空间范围内的函数。）

在模板元编程之外，我们通常不会这样说自由函数是一个函子，并为重写operator()()的类实例保留该名称：

struct Foo {
 public:
   void operator()( int i ) { // do something }
   void operator()( int i, char x ) { // do something else }
}

在C++中，模板是编译的，因此只要语法有意义 /em>，编译器会很乐意使用函数或函子：

template<typename T> class Bar {
  private int j ;
  public:
    Bar( int i ) : j(i) {}
    void doIt(T t) {
     t( j ) ;
  }
}

Foo f;
extern void resize( int i ) ; // in some header

Bar<Foo> bf( 5 ) ;
// a Bar that is templated on Foo
Bar< void (&)(int)   > br( 5 ) ; 
// a Bar that is templated on a function taking int and returning void

br.doit( &resize ) ; // call resize with br.j
bf.doit( f ) ; // call Foo::operator()(int) on Foo f with bf.j