std::function从实践到原理

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

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

#include 
#include 

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继承了两个类,如下所示:
std::function从实践到原理_第1张图片

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

⚠️WARNING⚠️
注意:不同的平台,实现不一样。本文所用平台是CentOS7.

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

让我们先在GDB中按s进入f1()的细节
std::function从实践到原理_第2张图片
原来对std::function的调用转给了_M_invoker, 参数除了你传给f1()的参数,还多了一个_M_functor, 还记得它吗?最开始的UML图里有它,它是std::function基类std::_Function_base的一个数据成员, 类型为std::_Any_data, 在上面的图中我已经打印了它的值,0x603010反复出现,很好奇吧,查查看它指向的内存的内容:
std::function从实践到原理_第3张图片
明显它指向了int 5和6,value1和value2恰巧分别是5和6,但又不是value1和value2,因为地址对不上。
我们的程序用的是lambda表达式, 如果你知道lambda会被编译器编成一个类,你可能想到0x603010可能指向的正是那个类的一个对象。如果不知道lambda的原理,请看下图:
std::function从实践到原理_第4张图片
我们再回到_M_invoke
std::function从实践到原理_第5张图片
_M_get_pointer看字面意思是要获得一个指针,从__functor中,也就是从_M_invoker(_Any_data类型)中,是不是0x603010(lambda对象的地址)哪?让我们继续调试以验证:
std::function从实践到原理_第6张图片
果然没错,正是0x603010,也就是lambda匿名类对象的地址,f1()最终调用到了lambda匿名类对象的operator()函数。

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

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

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

这一行按s进入.
std::function从实践到原理_第7张图片
这是std::function的其中一个构造函数,形参_Functor __f是模板参数,在我们的例子中对应的__lambda0类型(编译器把我们的lambda表达式转成的)。显然我们的__f非空,来到了

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

看名字大概可以感觉到它的目的是:用__lambda0类型的__f初始化std::_Any_data类型的_M_functor(std::function的成员)。
std::function从实践到原理_第8张图片
可以看到这里new了一个新_lambda0对象,把旧的Move到了新的里面。新_lambda0对象保存到了__functor(即std::function对象的_M_functor)的_M_pod_data数组中,细节请参考下面_Any_data的具体实现(其size为16,最大的成员是_M_member_pointer, 类函数指针,大小为16):
std::function从实践到原理_第9张图片

看一下_Any_data类型的_M_functor赋值前后的对比:
std::function从实践到原理_第10张图片
VS
std::function从实践到原理_第11张图片
最后给_M_invoker、_M_manager赋值,std::function构造完成。

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

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

#include 
#include 

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

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

   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);
}

还是来到了和上面一样的构造函数
std::function从实践到原理_第12张图片
不同的是__f不再是__lambda0, 而是函数指针类型。不再赘述。看一下此std::function对象的面貌:
std::function从实践到原理_第13张图片

5. 其它问题

不知读者注意到没?
std::function从实践到原理_第14张图片
这里一个placement new,一个堆上new,解释请移步链接。
函数赋值是用placement new,而lambda表达式赋值用的堆上new。

你可能感兴趣的:(modern,C++,linux,modern,c++,function,function原理)