函子基本上就是一个定义操作符()的类。这让你可以创建“看起来像”函数的对象:

// this is a functor
struct add_x {
  add_x(int val) : x(val) {}  // Constructor
  int operator()(int y) const { return x + y; }

private:
  int x;
};

// Now you can use it like this:
add_x add42(42); // create an instance of the functor class
int i = add42(8); // and "call" it
assert(i == 50); // and it added 42 to its argument

std::vector<int> in; // assume this contains a bunch of values)
std::vector<int> out(in.size());
// Pass a functor to std::transform, which calls the functor on every element 
// in the input sequence, and stores the result to the output sequence
std::transform(in.begin(), in.end(), out.begin(), add_x(1)); 
assert(out[i] == in[i] + 1); // for all i

函子有几个优点。其一，与常规函数不同，它们可以包含状态。上面的例子创建了一个函数，无论你给它什么，它都会加上42。但是值42并不是硬编码的，它是在创建函数实例时作为构造函数参数指定的。我可以创建另一个加法器，只需要用不同的值调用构造函数，就可以加27。这使得它们可以很好地定制。

As the last lines show, you often pass functors as arguments to other functions such as std::transform or the other standard library algorithms. You could do the same with a regular function pointer except, as I said above, functors can be "customized" because they contain state, making them more flexible (If I wanted to use a function pointer, I'd have to write a function which added exactly 1 to its argument. The functor is general, and adds whatever you initialized it with), and they are also potentially more efficient. In the above example, the compiler knows exactly which function std::transform should call. It should call add_x::operator(). That means it can inline that function call. And that makes it just as efficient as if I had manually called the function on each value of the vector.

如果我传递的是一个函数指针，编译器不能立即看到它指向哪个函数，所以除非它执行一些相当复杂的全局优化，否则它必须在运行时解除对指针的引用，然后进行调用。

函子是一个类似于函数的对象。 基本上，一个定义operator()的类。

class MyFunctor
{
   public:
     int operator()(int x) { return x * 2;}
}

MyFunctor doubler;
int x = doubler(5);

真正的优点是函子可以保存状态。

class Matcher
{
   int target;
   public:
     Matcher(int m) : target(m) {}
     bool operator()(int x) { return x == target;}
}

Matcher Is5(5);

if (Is5(n))    // same as if (n == 5)
{ ....}

函子基本上就是一个定义操作符()的类。这让你可以创建“看起来像”函数的对象:

// this is a functor
struct add_x {
  add_x(int val) : x(val) {}  // Constructor
  int operator()(int y) const { return x + y; }

private:
  int x;
};

// Now you can use it like this:
add_x add42(42); // create an instance of the functor class
int i = add42(8); // and "call" it
assert(i == 50); // and it added 42 to its argument

std::vector<int> in; // assume this contains a bunch of values)
std::vector<int> out(in.size());
// Pass a functor to std::transform, which calls the functor on every element 
// in the input sequence, and stores the result to the output sequence
std::transform(in.begin(), in.end(), out.begin(), add_x(1)); 
assert(out[i] == in[i] + 1); // for all i

函子有几个优点。其一，与常规函数不同，它们可以包含状态。上面的例子创建了一个函数，无论你给它什么，它都会加上42。但是值42并不是硬编码的，它是在创建函数实例时作为构造函数参数指定的。我可以创建另一个加法器，只需要用不同的值调用构造函数，就可以加27。这使得它们可以很好地定制。

As the last lines show, you often pass functors as arguments to other functions such as std::transform or the other standard library algorithms. You could do the same with a regular function pointer except, as I said above, functors can be "customized" because they contain state, making them more flexible (If I wanted to use a function pointer, I'd have to write a function which added exactly 1 to its argument. The functor is general, and adds whatever you initialized it with), and they are also potentially more efficient. In the above example, the compiler knows exactly which function std::transform should call. It should call add_x::operator(). That means it can inline that function call. And that makes it just as efficient as if I had manually called the function on each value of the vector.

如果我传递的是一个函数指针，编译器不能立即看到它指向哪个函数，所以除非它执行一些相当复杂的全局优化，否则它必须在运行时解除对指针的引用，然后进行调用。

除了在回调中使用，c++函子还可以帮助为矩阵类提供Matlab喜欢的访问样式。这里有一个例子。

函子是一种高阶函数，它将函数应用于参数化(即模板化)类型。它是映射高阶函数的推广。例如，我们可以像这样为std::vector定义一个函子:

template<class F, class T, class U=decltype(std::declval<F>()(std::declval<T>()))>
std::vector<U> fmap(F f, const std::vector<T>& vec)
{
    std::vector<U> result;
    std::transform(vec.begin(), vec.end(), std::back_inserter(result), f);
    return result;
}

这个函数接受一个std::vector<T>，并在给定一个接受T并返回U的函数F时返回std::vector<U>。一个函子不一定要在容器类型上定义，它也可以为任何模板类型定义，包括std::shared_ptr:

template<class F, class T, class U=decltype(std::declval<F>()(std::declval<T>()))>
std::shared_ptr<U> fmap(F f, const std::shared_ptr<T>& p)
{
    if (p == nullptr) return nullptr;
    else return std::shared_ptr<U>(new U(f(*p)));
}

下面是一个将类型转换为double类型的简单示例:

double to_double(int x)
{
    return x;
}

std::shared_ptr<int> i(new int(3));
std::shared_ptr<double> d = fmap(to_double, i);

std::vector<int> is = { 1, 2, 3 };
std::vector<double> ds = fmap(to_double, is);

函子应该遵循两条定律。第一个是恒等定律，它指出，如果函子给定了恒等函数，它应该与将恒等函数应用于类型相同，即fmap(identity, x)应该与identity(x)相同:

struct identity_f
{
    template<class T>
    T operator()(T x) const
    {
        return x;
    }
};
identity_f identity = {};

std::vector<int> is = { 1, 2, 3 };
// These two statements should be equivalent.
// is1 should equal is2
std::vector<int> is1 = fmap(identity, is);
std::vector<int> is2 = identity(is);

下一个定律是组合定律，它指出，如果函子被赋予两个函数的组合，它应该与将函子应用于第一个函数，然后再应用于第二个函数相同。因此，fmap(std::bind(f, std::bind(g， _1))， x)应该与fmap(f, fmap(g, x))相同:

double to_double(int x)
{
    return x;
}

struct foo
{
    double x;
};

foo to_foo(double x)
{
    foo r;
    r.x = x;
    return r;
}

std::vector<int> is = { 1, 2, 3 };
// These two statements should be equivalent.
// is1 should equal is2
std::vector<foo> is1 = fmap(std::bind(to_foo, std::bind(to_double, _1)), is);
std::vector<foo> is2 = fmap(to_foo, fmap(to_double, is));

这是一个我被迫使用Functor来解决我的问题的实际情况:

我有一组函数(比如20个)，它们都是相同的，除了每个函数在3个特定位置调用不同的特定函数。

这是难以置信的浪费和代码复制。通常我会传入一个函数指针，然后在3个位置调用它。(所以代码只需要出现一次，而不是20次。)

但后来我意识到，在每种情况下，特定的功能需要完全不同的参数配置文件!有时2个参数，有时5个参数，等等。

另一种解决方案是有一个基类，其中特定的函数是派生类中的重写方法。但是我真的想要构建所有这些INHERITANCE，只是为了传递一个函数指针????

解决方案:所以我所做的是，我做了一个包装类(一个“Functor”)，它能够调用任何我需要调用的函数。我提前设置了它(用它的参数等)，然后我传递它而不是函数指针。现在调用的代码可以触发Functor，而不知道内部发生了什么。它甚至可以多次调用它(我需要它调用3次)。

这就是一个实际的例子，在这个例子中，Functor被证明是一个明显而简单的解决方案，它允许我将代码重复从20个函数减少到1个。