std::function从实践到原理

1. 测试程序&俯瞰function对象

先来一个简单的测试程序：

#include <functional>
#include <iostream>

int gAdd(int i1, int i2){
        return i1+i2;
}

int main() {
   int value1 = 5;
   int value2 = 6;
   typedef std::function<void()> Fun1;
   Fun1 f1 = [value1, value2]() { std::cout << value1<< value2 << std::endl;};
   f1();
}

编译：

 g++ function.cpp -std=c++11 -g

断点打到调用f1()行，并print f1

(gdb) set print pretty on
(gdb) p f1
$1 = {
  <std::_Maybe_unary_or_binary_function<void>> = {<No data fields>},
  <std::_Function_base> = {
    static _M_max_size = 16,
    static _M_max_align = 8,
    _M_functor = {
      _M_unused = {
        _M_object = 0x603010,
        _M_const_object = 0x603010,
        _M_function_pointer = 0x603010,
        _M_member_pointer = (void (std::_Undefined_class::*)(std::_Undefined_class * const)) 0x603010, this adjustment 4295032831
      },
      _M_pod_data = "\020\060`\000\000\000\000\000\377\377\000\000\001\000\000"
    },
    _M_manager = 0x400cea <std::_Function_base::_Base_manager<main()::__lambda0>::_M_manager(std::_Any_data &, const std::_Any_data &, std::_Manager_operation)>
  },
  members of std::function<void()>:
  _M_invoker = 0x400cc8 <std::_Function_handler<void(), main()::__lambda0>::_M_invoke(const std::_Any_data &)>
}
(gdb) ptype f1._M_functor
type = union std::_Any_data {
    std::_Nocopy_types _M_unused;
    char _M_pod_data[16];
  public:
    void * _M_access(void);
    const void * _M_access(void) const;
    const std::type_info *& _M_access<std::type_info const*>(void);
    __lambda0 *& _M_access<main()::__lambda0*>(void);
    __lambda0 * const& _M_access<main()::__lambda0*>(void) const;
    int (**&)(int, int) _M_access<int (**)(int, int)>(void);
    int (* const&)(int, int) _M_access<int (*)(int, int)>(void) const;
    int (*&)(int, int) _M_access<int (*)(int, int)>(void);
}
(gdb) ptype f1._M_manager
type = bool (*)(std::_Any_data &, const std::_Any_data &, std::_Manager_operation)
(gdb) ptype f1._M_invoker
type = void (*)(const std::_Any_data &)
(gdb) ptype f1
type = class std::function<void()> [with _Signature = void (void)] : public std::_Maybe_unary_or_binary_function<void>, private std::_Function_base {
  private:
    _Invoker_type _M_invoker;

  public:
    function(void);
    function(std::nullptr_t);
    function(const std::function<void()> &);
    function(<unknown type in /home/mzhai/a.out, CU 0x0, DIE 0x1249>);
    std::function<void()> & operator=(const std::function<void()> &);
    std::function<void()> & operator=(<unknown type in /home/mzhai/a.out, CU 0x0, DIE 0x1291>);
    std::function<void()> & operator=(std::nullptr_t);
    void swap(std::function<void()> &);
    operator bool(void) const;
    void operator()(void) const;
    const std::type_info & target_type(void) const;
    void function<main()::__lambda0, void>(__lambda0);

    typedef void (*_Invoker_type)(const std::_Any_data &);
}

可见function继承了两个类，如下所示：

我们曾经在《知其所以然，C++系列3 - C++11中主要类的大小》中度量过std::function的大小为32，与这里对上了：_Any_data大小为16（下面会解释），外加2个函数指针。

??WARNING??
注意：不同的平台，实现不一样。本文所用平台是CentOS7.

2. 先看看std::function调用的实现

让我们先在GDB中按s进入f1()的细节

原来对std::function的调用转给了_M_invoker, 参数除了你传给f1()的参数，还多了一个_M_functor, 还记得它吗？最开始的UML图里有它，它是std::function基类std::_Function_base的一个数据成员, 类型为std::_Any_data, 在上面的图中我已经打印了它的值，0x603010反复出现，很好奇吧，查查看它指向的内存的内容：

明显它指向了int 5和6，value1和value2恰巧分别是5和6，但又不是value1和value2，因为地址对不上。
我们的程序用的是lambda表达式, 如果你知道lambda会被编译器编成一个类，你可能想到0x603010可能指向的正是那个类的一个对象。如果不知道lambda的原理，请看下图：

我们再回到_M_invoke

_M_get_pointer看字面意思是要获得一个指针，从__functor中，也就是从_M_invoker（_Any_data类型）中，是不是0x603010(lambda对象的地址）哪？让我们继续调试以验证：

果然没错，正是0x603010，也就是lambda匿名类对象的地址，f1()最终调用到了lambda匿名类对象的operator()函数。

3. std::function对象的初始化

看过std::function对象的调用后，我们再回过头来看看它是怎么初始化的。
重新调试，到

Fun1 f1 = [value1, value2]() { std::cout << value1<< value2 << std::endl;}; 

这一行按s进入.

这是std::function的其中一个构造函数，形参_Functor __f是模板参数，在我们的例子中对应的__lambda0类型（编译器把我们的lambda表达式转成的）。显然我们的__f非空，来到了

_M_init_functor(_M_functor, std::move(__f))

看名字大概可以感觉到它的目的是：用__lambda0类型的__f初始化std::_Any_data类型的_M_functor（std::function的成员）。

可以看到这里new了一个新_lambda0对象，把旧的Move到了新的里面。新_lambda0对象保存到了__functor（即std::function对象的_M_functor）的_M_pod_data数组中，细节请参考下面_Any_data的具体实现（其size为16，最大的成员是_M_member_pointer, 类函数指针，大小为16）：

看一下_Any_data类型的_M_functor赋值前后的对比：

VS

最后给_M_invoker、_M_manager赋值，std::function构造完成。

4. 函数指针赋值给std::function

除了lambda表达式可以赋给std::function，纯函数指针也可以。我们把代码简单改改，试验一下。

#include <functional>
#include <iostream>

int gAdd(int i1, int i2){
        return i1+i2;
}

int main() {
        /*class _Undefined_class_mzhai;
        void (_Undefined_class_mzhai::*_M_member_pointer)();
        std::cout<<sizeof(_M_member_pointer)<<std::endl; //16*/

   int value1 = 5;
   int value2 = 6;
   typedef std::function<void()> Fun1;
   Fun1 f1 = [value1, value2]() { std::cout << value1<< value2 << std::endl;};
   f1();

   typedef std::function<int(int,int)> Fun2;
   Fun2 f2 = gAdd;
   f2(11,12);
}

还是来到了和上面一样的构造函数

不同的是__f不再是__lambda0, 而是函数指针类型。不再赘述。看一下此std::function对象的面貌：

5. 其它问题

不知读者注意到没？

这里一个placement new，一个堆上new，解释请移步链接。
函数赋值是用placement new，而lambda表达式赋值用的堆上new。