什么是C ++函子及其用途？

我不断听到很多有关C ++中的函子的信息。有人可以概述一下它们是什么，在什么情况下会有用吗？

函子几乎只是一个定义operator（）的类。这样就可以创建“看起来像”函数的对象：

// 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。这使得它们很好地可定制。

如最后几行所示，您通常将函子作为参数传递给其他函数，例如std :: transform或其他标准库算法。您可以对常规函数指针执行相同的操作，除了如上所述，函子可以“自定义”，因为函子包含状态，从而使它们更加灵活（如果我想使用函子指针，则必须编写函子，它的参数正好加1。函子是通用的，并且添加了您对其进行初始化的所有内容），它们的效率也可能更高。在上面的示例中，编译器确切知道std::transform应调用哪个函数。它应该调用add_x::operator()。这意味着它可以内联该函数调用。就像我手动在向量的每个值上调用该函数一样，它的效率也很高。

如果我改用了函数指针，则编译器将无法立即看到其指向的函数，因此除非它执行了一些相当复杂的全局优化，否则它必须在运行时取消引用该指针，然后进行调用。

一点点补充。您可以使用boost::function，从函数和方法创建函子，如下所示：

class Foo
{
public:
    void operator () (int i) { printf("Foo %d", i); }
};
void Bar(int i) { printf("Bar %d", i); }
Foo foo;
boost::function<void (int)> f(foo);//wrap functor
f(1);//prints "Foo 1"
boost::function<void (int)> b(&Bar);//wrap normal function
b(1);//prints "Bar 1"

您可以使用boost :: bind向此仿函数添加状态

boost::function<void ()> f1 = boost::bind(foo, 2);
f1();//no more argument, function argument stored in f1
//and this print "Foo 2" (:
//and normal function
boost::function<void ()> b1 = boost::bind(&Bar, 2);
b1();// print "Bar 2"

最有用的是，使用boost :: bind和boost :: function可以从类方法创建函子，实际上这是一个委托：

class SomeClass
{
    std::string state_;
public:
    SomeClass(const char* s) : state_(s) {}

    void method( std::string param )
    {
        std::cout << state_ << param << std::endl;
    }
};
SomeClass *inst = new SomeClass("Hi, i am ");
boost::function< void (std::string) > callback;
callback = boost::bind(&SomeClass::method, inst, _1);//create delegate
//_1 is a placeholder it holds plase for parameter
callback("useless");//prints "Hi, i am useless"

您可以创建函子的列表或向量

std::list< boost::function<void (EventArg e)> > events;
//add some events
....
//call them
std::for_each(
        events.begin(), events.end(), 
        boost::bind( boost::apply<void>(), _1, e));

所有这些东西都有一个问题，编译器错误消息是不可读的:)

函子是充当函数的对象。基本上，是一个定义的类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)
{ ....}

在C ++出现之前很久，名称“ functor”就一直在类别理论中使用。这与functor的C ++概念无关。最好使用名称函数对象而不是我们在C ++中称为“函数器”的函数。这就是其他编程语言如何调用类似的构造。

用于代替普通功能：

特征：

• 功能对象可能具有状态
• 函数对象适合OOP（它的行为与其他所有对象一样）。

缺点：

• 给程序带来更多的复杂性。

用于代替函数指针：

特征：

• 函数对象通常可以内联

缺点：

• 在运行时不能将函数对象与其他函数对象类型交换（至少除非它扩展了一些基类，否则会产生一些开销）

用于代替虚函数：

特征：

• 函数对象（非虚拟）不需要vtable和运行时调度，因此在大多数情况下它更高效

缺点：

• 在运行时不能将函数对象与其他函数对象类型交换（至少除非它扩展了一些基类，否则会产生一些开销）

就像其他人提到的一样，函子是一个像函数一样起作用的对象，即，它使函数调用运算符重载。

函子通常用于STL算法中。它们非常有用，因为它们可以在函数调用之前和之间保持状态，例如函数语言中的闭包。例如，您可以定义一个MultiplyBy函子，将其参数乘以指定的数量：

class MultiplyBy {
private:
    int factor;

public:
    MultiplyBy(int x) : factor(x) {
    }

    int operator () (int other) const {
        return factor * other;
    }
};

然后，您可以将MultiplyBy对象传递给类似std :: transform的算法：

int array[5] = {1, 2, 3, 4, 5};
std::transform(array, array + 5, array, MultiplyBy(3));
// Now, array is {3, 6, 9, 12, 15}

相对于指向函数的指针，函子的另一个优点是，在更多情况下可以内联调用。如果您向传递了一个函数指针transform，除非该调用被内联并且编译器知道您始终将相同的函数传递给它，否则它将无法通过该指针内联该调用。

对于我们中间的像我这样的新手：经过一番研究，我弄清楚了jalf发布的代码是做什么的。

函子是可以像函数一样被“调用”的类或结构对象。通过使过载可以实现这一点() operator。的() operator（不知道其所谓的）可以采取任何数量的参数。其他运算符仅取两个，即+ operator只能取两个值（运算符的每一侧一个），并返回您为其重载的任何值。您可以在内容纳任意数量的参数，() operator这使它具有更大的灵活性。

首先要创建函子，请先创建类。然后，使用您选择的类型和名称的参数为类创建一个构造函数。在同一条语句中紧随其后的是一个初始化器列表（该列表使用单个冒号运算符，这对我来说还很陌生），该列表使用构造函数的先前声明的参数构造类成员对象。然后() operator会超载。最后，您声明已创建的类或结构的私有对象。

我的代码（我发现jalf的变量名令人困惑）

class myFunctor
{ 
    public:
        /* myFunctor is the constructor. parameterVar is the parameter passed to
           the constructor. : is the initializer list operator. myObject is the
           private member object of the myFunctor class. parameterVar is passed
           to the () operator which takes it and adds it to myObject in the
           overloaded () operator function. */
        myFunctor (int parameterVar) : myObject( parameterVar ) {}

        /* the "operator" word is a keyword which indicates this function is an 
           overloaded operator function. The () following this just tells the
           compiler that () is the operator being overloaded. Following that is
           the parameter for the overloaded operator. This parameter is actually
           the argument "parameterVar" passed by the constructor we just wrote.
           The last part of this statement is the overloaded operators body
           which adds the parameter passed to the member object. */
        int operator() (int myArgument) { return myObject + myArgument; }

    private: 
        int myObject; //Our private member object.
}; 

如果其中任何一个不准确或仅是错误，请随时纠正我！

函子是将函数应用于参数化（即模板化）类型的高阶函数。它是地图高阶函数的一般化。例如，我们可以这样定义一个函子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;
}

当给定一个接受a 并返回a 的函数时，此函数接受a std::vector<T>并返回。函子不必在容器类型上进行定义，也可以为任何模板化类型进行定义，包括：std::vector<U>FTUstd::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个位置调用它。（因此，该代码只需要出现一次，而不是二十次。）

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

另一个解决方案是拥有一个基类，其中特定的功能是派生类中的重写方法。但是我真的要构建所有这种继承吗，以便可以传递函数指针？？？？

解决方案：所以我所做的就是，创建了一个包装器类（“ Functor”），该类可以调用我需要调用的任何函数。我预先设置了它（带有其参数等），然后将其而不是函数指针传递给了它。现在，被调用的代码可以触发仿函数，而无需知道内部发生了什么。它甚至可以多次调用（我需要调用3次。）

就是这样-一个实际的例子，其中一个Functor变成了显而易见且简单的解决方案，使我能够将代码重复从20个函数减少到1。

除了用于回调外，C ++函子还可以帮助提供对矩阵 类的Matlab喜欢的访问样式。有个例子。

就像已经重复的一样，函子是可以视为函数的类（重载运算符（））。

在需要将某些数据与对函数的重复或延迟调用相关联的情况下，它们最有用。

例如，函子的链表可用于实现基本的低开销同步协程系统，任务分派器或可中断的文件解析。例子：

/* prints "this is a very simple and poorly used task queue" */
class Functor
{
public:
    std::string output;
    Functor(const std::string& out): output(out){}
    operator()() const
    {
        std::cout << output << " ";
    }
};

int main(int argc, char **argv)
{
    std::list<Functor> taskQueue;
    taskQueue.push_back(Functor("this"));
    taskQueue.push_back(Functor("is a"));
    taskQueue.push_back(Functor("very simple"));
    taskQueue.push_back(Functor("and poorly used"));
    taskQueue.push_back(Functor("task queue"));
    for(std::list<Functor>::iterator it = taskQueue.begin();
        it != taskQueue.end(); ++it)
    {
        *it();
    }
    return 0;
}

/* prints the value stored in "i", then asks you if you want to increment it */
int i;
bool should_increment;
int doSomeWork()
{
    std::cout << "i = " << i << std::endl;
    std::cout << "increment? (enter the number 1 to increment, 0 otherwise" << std::endl;
    std::cin >> should_increment;
    return 2;
}
void doSensitiveWork()
{
     ++i;
     should_increment = false;
}
class BaseCoroutine
{
public:
    BaseCoroutine(int stat): status(stat), waiting(false){}
    void operator()(){ status = perform(); }
    int getStatus() const { return status; }
protected:
    int status;
    bool waiting;
    virtual int perform() = 0;
    bool await_status(BaseCoroutine& other, int stat, int change)
    {
        if(!waiting)
        {
            waiting = true;
        }
        if(other.getStatus() == stat)
        {
            status = change;
            waiting = false;
        }
        return !waiting;
    }
}

class MyCoroutine1: public BaseCoroutine
{
public:
    MyCoroutine1(BaseCoroutine& other): BaseCoroutine(1), partner(other){}
protected:
    BaseCoroutine& partner;
    virtual int perform()
    {
        if(getStatus() == 1)
            return doSomeWork();
        if(getStatus() == 2)
        {
            if(await_status(partner, 1))
                return 1;
            else if(i == 100)
                return 0;
            else
                return 2;
        }
    }
};

class MyCoroutine2: public BaseCoroutine
{
public:
    MyCoroutine2(bool& work_signal): BaseCoroutine(1), ready(work_signal) {}
protected:
    bool& work_signal;
    virtual int perform()
    {
        if(i == 100)
            return 0;
        if(work_signal)
        {
            doSensitiveWork();
            return 2;
        }
        return 1;
    }
};

int main()
{
     std::list<BaseCoroutine* > coroutineList;
     MyCoroutine2 *incrementer = new MyCoroutine2(should_increment);
     MyCoroutine1 *printer = new MyCoroutine1(incrementer);

     while(coroutineList.size())
     {
         for(std::list<BaseCoroutine *>::iterator it = coroutineList.begin();
             it != coroutineList.end(); ++it)
         {
             *it();
             if(*it.getStatus() == 0)
             {
                 coroutineList.erase(it);
             }
         }
     }
     delete printer;
     delete incrementer;
     return 0;
}

当然，这些例子本身并不是那么有用。它们仅显示函子是如何有用的，函子本身是非常基本且不灵活的，这使它们不如Boost提供的有用。

gtkmm中使用函子将一些GUI按钮连接到实际的C ++函数或方法。

如果使用pthread库使应用程序成为多线程，Functors可以为您提供帮助。
要启动线程，的参数之一pthread_create(..)是要在自己的线程上执行的函数指针。
但是有一个不便之处。该指针不能是方法的指针，除非它是静态方法，或者除非您指定它的类（如）class::method。另外，方法的接口只能是：

void* method(void* something)

因此，您不能在线程中运行（以一种简单的明显方式）类中的方法，而无需执行其他操作。

在C ++中处理线程的一个很好的方法是创建自己的Thread类。如果您想从MyClass类中运行方法，我要做的就是将这些方法转换为Functor派生类。

另外，Thread该类具有此方法：static void* startThread(void* arg)
指向该方法 的指针将用作call的参数pthread_create(..)。什么startThread(..)应该接受arg是void*铸造参考实例中的任何堆Functor派生类，将被转换回Functor*时执行，然后把它称为的run()方法。

作为补充，我使用了函数对象使现有的旧方法适合命令模式；（只有我感觉到的OO范式真正的OCP之美的地方）；还在此处添加相关的功能适配器模式。

假设您的方法具有签名：

int CTask::ThreeParameterTask(int par1, int par2, int par3)

我们将看到如何使它适合Command模式-为此，首先，您必须编写成员函数适配器，以便可以将其称为函数对象。

注意-这很丑陋，可能是您可以使用Boost绑定助手等，但是，如果您不愿意或不愿意，这是一种方法。

// a template class for converting a member function of the type int        function(int,int,int)
//to be called as a function object
template<typename _Ret,typename _Class,typename _arg1,typename _arg2,typename _arg3>
class mem_fun3_t
{
  public:
explicit mem_fun3_t(_Ret (_Class::*_Pm)(_arg1,_arg2,_arg3))
    :m_Ptr(_Pm) //okay here we store the member function pointer for later use
    {}

//this operator call comes from the bind method
_Ret operator()(_Class *_P, _arg1 arg1, _arg2 arg2, _arg3 arg3) const
{
    return ((_P->*m_Ptr)(arg1,arg2,arg3));
}
private:
_Ret (_Class::*m_Ptr)(_arg1,_arg2,_arg3);// method pointer signature
};

另外，我们需要上述类的辅助方法mem_fun3来帮助调用。

template<typename _Ret,typename _Class,typename _arg1,typename _arg2,typename _arg3>
mem_fun3_t<_Ret,_Class,_arg1,_arg2,_arg3> mem_fun3 ( _Ret (_Class::*_Pm)          (_arg1,_arg2,_arg3) )
{
  return (mem_fun3_t<_Ret,_Class,_arg1,_arg2,_arg3>(_Pm));

}

现在，为了绑定参数，我们必须编写一个绑定函数。因此，它去了：

template<typename _Func,typename _Ptr,typename _arg1,typename _arg2,typename _arg3>
class binder3
{
public:
//This is the constructor that does the binding part
binder3(_Func fn,_Ptr ptr,_arg1 i,_arg2 j,_arg3 k)
    :m_ptr(ptr),m_fn(fn),m1(i),m2(j),m3(k){}

 //and this is the function object 
 void operator()() const
 {
        m_fn(m_ptr,m1,m2,m3);//that calls the operator
    }
private:
    _Ptr m_ptr;
    _Func m_fn;
    _arg1 m1; _arg2 m2; _arg3 m3;
};

并且，一个辅助函数可以使用活页夹3类-bind3：

//a helper function to call binder3
template <typename _Func, typename _P1,typename _arg1,typename _arg2,typename _arg3>
binder3<_Func, _P1, _arg1, _arg2, _arg3> bind3(_Func func, _P1 p1,_arg1 i,_arg2 j,_arg3 k)
{
    return binder3<_Func, _P1, _arg1, _arg2, _arg3> (func, p1,i,j,k);
}

现在，我们必须在Command类中使用它。使用以下typedef：

typedef binder3<mem_fun3_t<int,T,int,int,int> ,T* ,int,int,int> F3;
//and change the signature of the ctor
//just to illustrate the usage with a method signature taking more than one parameter
explicit Command(T* pObj,F3* p_method,long timeout,const char* key,
long priority = PRIO_NORMAL ):
m_objptr(pObj),m_timeout(timeout),m_key(key),m_value(priority),method1(0),method0(0),
method(0)
{
    method3 = p_method;
}

这是你的称呼：

F3 f3 = PluginThreadPool::bind3( PluginThreadPool::mem_fun3( 
      &CTask::ThreeParameterTask), task1,2122,23 );

注意：f3（）; 将调用方法task1-> ThreeParameterTask（21,22,23）;。

以下链接中此模式的完整上下文

将函数实现为函子的一大优势在于，它们可以维护和重用调用之间的状态。例如，许多动态编程算法（例如用于计算字符串之间的Levenshtein距离的Wagner-Fischer算法）通过填写大型结果表来工作。每次调用该函数时分配该表的效率都很低，因此将函数实现为函子并使表成为成员变量可以大大提高性能。

下面是将Wagner-Fischer算法实现为函子的示例。请注意，表是如何在构造函数中分配的，然后在中进行重用operator()，并根据需要调整大小。

#include <string>
#include <vector>
#include <algorithm>

template <typename T>
T min3(const T& a, const T& b, const T& c)
{
   return std::min(std::min(a, b), c);
}

class levenshtein_distance 
{
    mutable std::vector<std::vector<unsigned int> > matrix_;

public:
    explicit levenshtein_distance(size_t initial_size = 8)
        : matrix_(initial_size, std::vector<unsigned int>(initial_size))
    {
    }

    unsigned int operator()(const std::string& s, const std::string& t) const
    {
        const size_t m = s.size();
        const size_t n = t.size();
        // The distance between a string and the empty string is the string's length
        if (m == 0) {
            return n;
        }
        if (n == 0) {
            return m;
        }
        // Size the matrix as necessary
        if (matrix_.size() < m + 1) {
            matrix_.resize(m + 1, matrix_[0]);
        }
        if (matrix_[0].size() < n + 1) {
            for (auto& mat : matrix_) {
                mat.resize(n + 1);
            }
        }
        // The top row and left column are prefixes that can be reached by
        // insertions and deletions alone
        unsigned int i, j;
        for (i = 1;  i <= m; ++i) {
            matrix_[i][0] = i;
        }
        for (j = 1; j <= n; ++j) {
            matrix_[0][j] = j;
        }
        // Fill in the rest of the matrix
        for (j = 1; j <= n; ++j) {
            for (i = 1; i <= m; ++i) {
                unsigned int substitution_cost = s[i - 1] == t[j - 1] ? 0 : 1;
                matrix_[i][j] =
                    min3(matrix_[i - 1][j] + 1,                 // Deletion
                    matrix_[i][j - 1] + 1,                      // Insertion
                    matrix_[i - 1][j - 1] + substitution_cost); // Substitution
            }
        }
        return matrix_[m][n];
    }
};

Functor也可以用于模拟在函数内定义局部函数。请参阅 问题和另一个。

但是本地函子无法访问外部自动变量。lambda（C ++ 11）函数是一个更好的解决方案。

我已经“发现”了一个非常有趣的函子用法：当我对一个方法没有很好的名字时，我就使用它们，因为函子是没有名称的方法;-)