函数对象点滴

Revision: 1.11 Date: 2006/01/11

---

是什么，为什么要用它？

函数对象是就是一个类对象，由于重载了调用运算符（）而具有了类似函数的调用形式。通常使用函数对象来实现某种形式的回调，和传统的用函数指针实现的回调相比，函数对象有以下优点：

• 能在多次调用之间保存数据。由于函数对象可以有成员变量，很容易在多次调用之间保存数据。而常规函数则必须借助于静态局部变量或全局变量，显得很不自然。
• 运行效率更高。对使用函数指针进行的调用，编译器由于不能确定实际调用的函数的名称，生成的机器指令只是一种间接调用；而对使用函数对象进行的调用，编译器知道函数的名称（即重载调用运算符的那个函数），因此可以生成直接调用的机器指令，而且可以把调用运算符内联化来获得进一步效率提升，而把一个通过指针传递的函数内联化是非常困难的。
• 更灵活。可以在函数对象里提供一些操作，完成初始化和对有关数据的提取工作等。

最好设计为按值传递

理由是STL中可以使用函数对象的算法都被设计为值传递。当然你可以使用显式模板实参来传引用，但是那样可能会带来问题（比如对象切割问题）；精心设计的类或函数模板或许可以去掉这些问题，但是你能保证在这些模板里不使用STL吗？ 如果按值传递，那么函数对象就不能是多态的，并且应该很小。而在现实中函数对象又往往不是这样，这时候我们就需要使用C++ 的惯用法Pimpl：把大和/或多态的函数对象的数据和/或多态移到另一个类（实现类）中，然后给你的函数对象一个指向这个新类的指针, 这样就需要多个函数对象实例共享一个实现类实例，boost的shared_ptr是当然之选：

template<typename T>
    class BPFCImpl : public unary_function<T, void> {
        private:
        Widget w;
        int x;
        ...
        virtual ~BPFCImpl();
        virtual void operator()(const T& val) const;
        friend class BPFC<T>;
            };
            
template<typename T>
    class BPFC : public unary_function<T, void> {
        private:
        shared_ptr<BPFCImpl<T> > pImpl;
        
        public:
        void operator()(const T& val) const
        {
        pImpl->operator() (val);
        }
        ...
    };
     

boost.function

有时候我们需要实现一个一般化的回调，可以回调普通函数或函数对象，只要它们满足规定的型别（返回值类型，参数个数和类型），这当然可以用模板参数来实现该回调，就像find_if作的那样；但如果想在一个类中保存这么一个回调函数，通常需要把该类变成类模板，而类模板必须显式实例化，这样客户端的代码就显得不够简洁， boost.function 通过一个巧妙的包装，统一了型别一致的普通函数和函数对象，同时又不失去类型安全性，具有较强的使用价值。boost.thread就使用了boost.function：

    class thread {
    public:
        explicit thread(const boost::function0<void>&);
    };
     

这里thread的构造函数声明它接受一个参数个数为0，返回值类型为void的函数型别，不管它是普通函数还是函数对象。不过boost.function提供的便利性也是有代价的,除占用空间上有增加外,执行效率也有降低,那些性能狂人可要注意了。

boost.bind

有时候我们想要回调的函数或函数对象不满足该回调所期望的型别，仅仅是因为多了几个事先可以确定的参数，这时用boost.bind就很方便，它是std::bind1st和std::bind2nd的一般化，它能绑定任意参数到一个特定的值，或者把输入参数传递到任意位置。绑定方式也很灵活，而且支持函数对象和成员函数的绑定。比如想使用 boost::thread 创建一个线程来执行函数：void f(int i)，如果写成boost::thread thrd(f)是不对的，因为thread构造函数声明接受的是一个没有参数且返回类型为void的型别，而且不提供参数i的值的f也不可能运行。这时就可以写：

boost::thread thrd(bind(f, 1))//假设以1为实参运行f                
                

再如：想对vector<int> v 中的每个元素做个处理，而负责处理的函数是类 A 成员函数 void A::f(int i) ，这时就可写：

A a;
for_each(v.begin(), v.end(), bind(&A::f, &a, _1));
     

写法看起来有点奇怪，但是只要我们清楚：bind生成的是一个函数对象，其写法一定表达的是该函数对象的逻辑，该逻辑对bind来讲，就是写出调用被绑定函数的表达式，该表达式通常是要用该函数对象的参数的，于是用 _1 来代表第一个形参， _2 来代表第二个形参，。。。，对于成员函数，可以认为它的第一个参数是个 this 指针。 再举几个例子，假设有函数void f(int i, int j, int m)

         bind(f, _1, _1);//生成带一个参数的函数对象，以这个参数作为f的第一和第二个实参来调用f
         bind(f, _1, _1+1, _2);//生成带两个参数的函数对象，以第一个参数作为f的第一个实参，第一个参数加1作为f的第二个实参，第二个参数作为f的第三个实参来调用f 
                

boost.mem_fn

有一个Shape对象的容器v，想要对其容纳的每个对象调用draw方法，写成

for_each(v.begin(),v.end(),&Shape::draw)

                                        

是不对的，因为你不能在成员函数和成员函数指针上进行调用，必须通过一个对象或对象指针来调用成员函数。通过 boost.mem_fn生成的函数对象以指向成员函数所在类的指针或引用或智能指针为第一个参数，它可以支持多个参数，因此是stl中 mem_fun等的一般化.

boost.lambda

有一个对象指针的容器，当要销毁其引用的那些对象时，你会怎么做？手写循环？稍显麻烦；用for_each似乎省去了写循环的烦恼，可是又不得不在另外的地方写一个函数对象,好像更麻烦，似乎把一个本该局部解决的问题扩散到了外部，而且会降低代码的可读性。这时候 boost.lambda也许可以帮上忙：

for_each(v.begin(), v.end(), bind(delete_ptr(), _1))    

这里的bind(delete_ptr(), _1)是一个lambda表达式，编译器会为这种表达式生成一个无名函数对象类（有点像java中的匿名类），从而有效地避免手写简单函数对象的烦恼。对一般的可以重载的运算符，用法和在C++中一样， 如<<,=等；对特殊的可以重载的运算符如new,delete等，有其对应的表达方式(如例中的delete_ptr())；对函数调用使用lambda提供的bind；甚至连控制结构都支持。