为什么使用函子而不是函数？

Question

比较

double average = CalculateAverage(values.begin(), values.end());

使用函子相

double average = std::for_each(values.begin(), values.end(), CalculateAverage());

对于函数有什么好处？第一个不是更容易阅读吗（甚至在添加实现之前）？

假设函子定义如下：

class CalculateAverage
{
private:
   std::size_t num;
   double sum;
public:

   CalculateAverage() : num (0) , sum (0)
   {
   }

   void operator () (double elem) 
   {
      num++; 
      sum += elem;
   }

   operator double() const
   {
       return sum / num;
   }
};

Answer 1

至少有四个充分的理由：

关注点分离

在您的特定示例中，基于函子的方法具有将迭代逻辑与平均计算逻辑分离的优点。因此，您可以在其他情况下使用您的函子（想想 STL 中的所有其他算法），并且您可以将其他函子与 for_each 一起使用。

参数化

您可以更轻松地参数化函子。例如，您可以有一个 CalculateAverageOfPowers 函子，它取数据的平方或立方等的平均值，可以这样写：

class CalculateAverageOfPowers
{
public:
    CalculateAverageOfPowers(float p) : acc(0), n(0), p(p) {}
    void operator() (float x) { acc += pow(x, p); n++; }
    float getAverage() const { return acc / n; }
private:
    float acc;
    int   n;
    float p;
};

您当然可以用传统函数，但随后很难与函数指针一起使用，因为它与 CalculateAverage 具有不同的原型。

有状态

由于函子可以是有状态的，因此您可以执行以下操作：

CalculateAverage avg;
avg = std::for_each(dataA.begin(), dataA.end(), avg);
avg = std::for_each(dataB.begin(), dataB.end(), avg);
avg = std::for_each(dataC.begin(), dataC.end(), avg);

对多个不同的数据集进行平均。

请注意，几乎所有接受函子的 STL 算法/容器都要求它们是“纯”谓词，即随着时间的推移，状态没有可观察到的变化。 for_each 是这方面的一个特例（参见例如有效的标准 C++ 库 - for_each 与 Transform）。

性能

函子通常可以由编译器内联（毕竟，STL 是一堆模板）。虽然理论上函数也是如此，但编译器通常不会通过函数指针进行内联。典型的例子是比较 std::sort 和 qsort；假设比较谓词本身很简单，STL 版本通常快 5-10 倍。

总结

当然，可以使用传统函数和指针来模拟前三个，但使用函子会变得更加简单。

Answer 2

Functor 的优点：

• 与 Function 不同，Functor 可以有状态。
• 与函数相比，函子更适合 OOP 范式。
• 与函数指针不同，Functor 通常可以内联，
• Functor 不需要 vtable 和运行时调度，因此在大多数情况下更高效。

Answer 3

std::for_each 无疑是标准算法中最反复无常且最无用的。它只是一个很好的循环包装。然而，即使它也有优点。

考虑您的 CalculateAverage 的第一个版本必须是什么样子。它将在迭代器上进行循环，然后对每个元素进行处理。如果你错误地编写了该循环会发生什么？哎呀；存在编译器或运行时错误。第二个版本绝对不会有这样的错误。是的，代码并不多，但是为什么我们必须如此频繁地编写循环呢？为什么不只一次呢？

现在，考虑真实算法；那些真正起作用的。你想写std::sort吗？或者std::find？或者std::nth_element？您是否知道如何以最有效的方式实施它？您想要实现这些复杂算法多少次？

至于阅读的难易程度，那就是仁者见仁智者见智了。正如我所说，std::for_each 几乎不是算法的首选（尤其是使用 C++0x 基于范围的 for 语法）。但如果你谈论的是真正的算法，它们就非常具有可读性； std::sort 对列表进行排序。一些比较晦涩的内容（例如 std::nth_element）不会那么熟悉，但您始终可以在方便的 C++ 参考中查找它。

一旦您在 C++0x 中使用 Lambda，甚至 std::for_each 也是完全可读的。

Answer 4

•与函数不同，Functor 可以有状态。

这非常有趣，因为 std::binary_function、std::less 和 std::equal_to 有一个 const 的operator() 模板。但是，如果您想打印一条包含该对象当前调用计数的调试消息，您会怎么做呢？

这是 std::equal_to 的模板：

struct equal_to : public binary_function<_Tp, _Tp, bool>
{
  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x == __y; }
};

我可以想到 3 种方法来允许 operator() 为 const，但仍更改成员变量。但最好的方法是什么？举个例子：

#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <cassert>  // assert() MACRO

// functor for comparing two integer's, the quotient when integer division by 10.
// So 50..59 are same, and 60..69 are same.
// Used by std::sort()

struct lessThanByTen: public std::less<int>
{
private:
    // data members
    int count;  // nr of times operator() was called

public:
    // default CTOR sets count to 0
    lessThanByTen() :
        count(0)
    {
    }


    // @override the bool operator() in std::less<int> which simply compares two integers
    bool operator() ( const int& arg1, const int& arg2) const
    {
        // this won't compile, because a const method cannot change a member variable (count)
//      ++count;


        // Solution 1. this trick allows the const method to change a member variable
        ++(*(int*)&count);

        // Solution 2. this trick also fools the compilers, but is a lot uglier to decipher
        ++(*(const_cast<int*>(&count)));

        // Solution 3. a third way to do same thing:
        {
        // first, stack copy gets bumped count member variable
        int incCount = count+1;

        const int *iptr = &count;

        // this is now the same as ++count
        *(const_cast<int*>(iptr)) = incCount;
        }

        std::cout << "DEBUG: operator() called " << count << " times.\n";

        return (arg1/10) < (arg2/10);
    }
};

void test1();
void printArray( const std::string msg, const int nums[], const size_t ASIZE);

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

void test1()
{
    // unsorted numbers
    int inums[] = {33, 20, 10, 21, 30, 31, 32, 22, };

    printArray( "BEFORE SORT", inums, 8 );

    // sort by quotient of integer division by 10
    std::sort( inums, inums+8, lessThanByTen() );

    printArray( "AFTER  SORT", inums, 8 );

}

//! @param msg can be "this is a const string" or a std::string because of implicit string(const char *) conversion.
//! print "msg: 1,2,3,...N", where 1..8 are numbers in nums[] array

void printArray( const std::string msg, const int nums[], const size_t ASIZE)
{
    std::cout << msg << ": ";
    for (size_t inx = 0; inx < ASIZE; ++inx)
    {
        if (inx > 0)
            std::cout << ",";
        std::cout << nums[inx];
    }
    std::cout << "\n";
}

因为所有 3 个解决方案都被编译进来，所以计数增加了 3。输出如下：

gcc -g -c Main9.cpp
gcc -g Main9.o -o Main9 -lstdc++
./Main9
BEFORE SORT: 33,20,10,21,30,31,32,22
DEBUG: operator() called 3 times.
DEBUG: operator() called 6 times.
DEBUG: operator() called 9 times.
DEBUG: operator() called 12 times.
DEBUG: operator() called 15 times.
DEBUG: operator() called 12 times.
DEBUG: operator() called 15 times.
DEBUG: operator() called 15 times.
DEBUG: operator() called 18 times.
DEBUG: operator() called 18 times.
DEBUG: operator() called 21 times.
DEBUG: operator() called 21 times.
DEBUG: operator() called 24 times.
DEBUG: operator() called 27 times.
DEBUG: operator() called 30 times.
DEBUG: operator() called 33 times.
DEBUG: operator() called 36 times.
AFTER  SORT: 10,20,21,22,33,30,31,32

Answer 5

在第一种方法中，必须在所有想要对集合执行某些操作的函数中复制迭代代码。第二种方法隐藏了迭代的细节。

Answer 6

OOP 是这里的关键字。

http://www.newty.de/fpt/functor.html：

4.1 什么是函子？

函子是具有状态的函数。在 C++ 中，您可以将它们实现为一个类，该类具有一个或多个私有成员来存储状态，并具有一个重载运算符 () 来执行函数。函子可以使用模板和多态性概念来封装 C 和 C++ 函数指针。您可以构建指向任意类的成员函数的指针列表，并通过同一接口调用它们，而不必担心它们的类或需要指向实例的指针。所有函数必须具有相同的返回类型和调用参数。有时函子也称为闭包。您还可以使用函子来实现回调。

Answer 7

您正在比较不同抽象级别的函数。

您可以将 CalculateAverage(begin, end) 实现为：

template<typename Iter>
double CalculateAverage(Iter begin, Iter end)
{
    return std::accumulate(begin, end, 0.0, std::plus<double>) / std::distance(begin, end)
}

或者您可以使用 for 循环来实现

template<typename Iter>
double CalculateAverage(Iter begin, Iter end)
{
    double sum = 0;
    int count = 0;
    for(; begin != end; ++begin) {
        sum += *begin;
        ++count;
    }
    return sum / count;
}

前者需要您了解更多的事情，但是一旦您了解了它们，就更简单并且留下的可能性更少错误。

它还只使用两个通用组件（std::accumulate 和 std::plus），在更复杂的情况下也经常出现这种情况。您通常可以拥有一个简单的通用仿函数（或函数；普通的旧函数可以充当仿函数），然后将其与您需要的任何算法简单地组合起来。