反汇编看c++引用

继续反汇编系列，本次使用vc2008在x86体系下分析c++中的引用。

定义一个引用类型和将一个变量转换成引用类型一样吗？

引用比指针安全，真的是这样吗，对引用不理解的话比指针还危险。

为什么要用常量引用传参，只是为了只读？

先来说明一下下面使用到的词汇：

对象：不是OO里的对象，而是泛指在c++语言中某种类型（内嵌，结构体，类）的实例，与变量相同的意思。

存储体： “the standard (draft 3225, section [basic.life]) which clearly states that a reference binds to storage and can outlive the object which existed when the reference was created:”，对象（或变量）的存储内容的空间，一般是内存。

下面用到的变量名命名规则：

引用: 以r开头，紧跟接类型缩写，如 float& rf。

指针: 以p开头，紧跟接类型缩写，如 float* pf, const float* pcf, float* const pfc。

c++代码编译成汇编代码后，引用和指针同样是一个指向内存地址的存储体（一般是内存单元，或优化后使用寄存器，存放指向的内存地址）。

    uintptr_t uintptr = ;
0041C7F6  mov         dword ptr [uintptr],
    float flt = .f;
0041C7FD  fldz
0041C7FF  fstp        dword ptr [flt]
    float flt2 = .f;
0041C802  fld         dword ptr ds:[426C64h]
0041C808  fstp        dword ptr [flt2]
    float& rf = (float&)uintptr;
0041C80B  lea         eax,[uintptr]
0041C80E  mov         dword ptr [rf],eax
    float* const pfc = &(float&)uintptr;
0041C81F  lea         edx,[uintptr]
0041C822  mov         dword ptr [pfc],edx

不同的是它们的访问方式，最根本的区别就是，引用的访问直接访问被引用目标（直接反引用），而指针的访问是访问存放着目标内存地址的存储体，对目标的访问必须显式反引用。

也就是说你不能访问到引用存放目标内存地址的存储体（，除非你强行crack）。当你使用赋值符号（=）对引用进行赋值时，编译器首先将引用反引用为目标，你只能对引用的目标进行赋值操作。指针在没有使用反引用（*）时，访问的是存放着目标内存地址的存储体，也就是你可以对指针单元赋值改变指向，而无法对引用单元赋值改变指向。

    rf = .;
0041C837  mov         eax,dword ptr [rf]
0041C83A  fld1
0041C83C  fstp        dword ptr [eax]  

同样当你希望通过&符号访问引用单元的地址时，你也是不可能做到的，因为引用先于地址访问符号，反引用到被引用的目标身上，也就是说&访问到的是被引用的目标的地址。以上面的反汇编来说，当你使用&rf访问地址时，rf比&先反引用成引用的目标，&就只能访问到rf引用的目标"dword ptr [rf]"。除非你用汇编代码强行"lea ?, [rf]"，你才能取得引用的用于存放引用目标的地址的地址。

    float* pf = &rf;
0041C82B  mov         ecx,dword ptr [rf]
0041C82E  mov         dword ptr [pf],ecx
    void* pv = (void*)&pfc;
0041C831  lea         edx,[pfc]
0041C834  mov         dword ptr [pv],edx
    void* pv2;
    __asm {
        lea eax, [rf];
0041C837  lea         eax,[rf]
        mov dword ptr[pv2], eax;
0041C83A  mov         dword ptr [pv2],eax
    }

如果说引用是被引用目标的别名，那么将一个变量转换成引用类型，是否使用这个变量成为了其它目标的别名？

答案显然不是。那会是什么呢？先来看反汇编代码：

    rf = .;
0041C837  mov         eax,dword ptr [rf]
0041C83A  fld1
0041C83C  fstp        dword ptr [eax]
    (float&)rf = .;
0041C83E  mov         ecx,dword ptr [rf]
0041C841  fld         dword ptr ds:[426C64h]
0041C847  fstp        dword ptr [ecx]
    (float&)uintptr = .;
0041C849  fld         dword ptr ds:[426BC4h]
    (float&)uintptr = .;
0041C84F  fstp        dword ptr [uintptr]
    (int&)rf = ;
0041C852  mov         edx,dword ptr [rf]
0041C855  mov         dword ptr [edx],
    (int&)uintptr = ;
0041C85B  mov         dword ptr [uintptr],  

注：fld是从内存单元加载浮点数到浮点寄存器，fstp是将浮点寄存器0的浮点数存储进内存单元。

将变量转换成引用类型，不是把变量转换成引用，而是转换成批向变量的引用，按引用的类型来访问。

uintptr是一个非引用类型，（float&)uintptr转换成引用类型，但uintptr不引用其它目标，而是作为一个没有别名的引用目标使用，或者说对uintptr内存单元改变了对它访问的类型（，与*(float*)&uintptr访问的效果一样）。而（float）uintptr则是按uintptr声明的类型读出它的内存单元的数据，然后将数据转换类型。

至于"（float&）rf = 2.;"，rf这个引用首先反引用（在rf我们不可能通过c++语言访问到的指针单元，放着uintptr变量单元的地址，反引用成uintptr），实质就是对引用目标改变了对它访问的类型，又如"（int&）rf = 2;"，并非改变对引用"rf"的访问类型，而是改变对其引用的目标"uintptr"的访问类型。

说到这里，引用的引用是禁止的，这就不难理解了。当你有一个名为"rf"的引用，你对这个"rf"的访问（不论读写）都会转化成对引用目标的访问（限定在高级语言层）。即使你想定义一个引用去引用这个引用也是无功的。"float& rfx = rf;"这句，rfx并不是在引用rf，而是rf直接反引用成了uintptr，实质就是"float& rfx = uintptr;"。如果你要引用到名为rf的引用，你必须先要能够通过在c++语言层取得名为rf的引用，它存放指针的内存单元地址，而这样是不可能的，所以引用的引用是禁止的。

不知从何起方间流传引用比指针安全。理由大至如下：

1. 引用定义之时必须初始化。

2. 引用不会指向NULL。

3. 引用的指向不可以被修改，只有定义引用的同时才能定义它的指向。

1. 的问题归根到底是程序员不对变量（类构造）进行初始化，这样的程序员不少你还改变不了他们。使用引用，编译器强行要求他们进行初始化。因为由于没有写初始化造成的问题不只专属于指针。往往有程序员认为花时间写初始化是在浪费时间，这么多变量我还要一个一个初始化，每个类这么多成员变量我还要一个一个初始化，这么多类我还要一个一个为它们写几种构造函数？！！我的工作是按需求写逻辑不是写初始化和构造析构函数。

2. 的问题有点无稽，引用为什么就理所当然不会指向NULL。

看一下下面的反汇编代码：

    uintptr_t ptr = ;
0041C8A6  mov         dword ptr [ptr],
    float flt = .;
0041C8AD  fldz
0041C8AF  fstp        dword ptr [flt]
    float flt2 = .;
0041C8B2  fld         dword ptr ds:[426C64h]
    float flt2 = .;
0041C8B8  fstp        dword ptr [flt2]
    float& rf0 = *(float*);
0041C8BB  mov         dword ptr [rf0],  　　　　　　　　　　; 反引用到空地址上，
    float& rf = *new float(flt);
0041C8C2  push
0041C8C4  call        operator new (040112Eh)
0041C8C9  add         esp,
0041C8CC  mov         dword ptr [ebp-40h],eax
0041C8CF  cmp         dword ptr [ebp-40h],
0041C8D3  je          block1+45h (041C8E5h)  　　　　　　　　; new是否分配到空间
0041C8D5  mov         eax,dword ptr [ebp-40h]
0041C8D8  fld         dword ptr [flt]
0041C8DB  fstp        dword ptr [eax]
0041C8DD  mov         ecx,dword ptr [ebp-40h]
0041C8E0  mov         dword ptr [ebp-48h],ecx
0041C8E3  jmp         block1+4Ch (041C8ECh)
0041C8E5  mov         dword ptr [ebp-48h],  　　　　　　　　; new失败了，名为rf的引用指向NULL
0041C8EC  mov         edx,dword ptr [ebp-48h]
0041C8EF  mov         dword ptr [rf],edx  

可以看出引用在初始化之时，同样会有些情况，使它们指向空地址。你并不能阻止别人使用指针反引用来对引用进行初始化。的确在使用指针的时候，我们无时无刻都要为安全考虑多写些指针判断，但是使用了引用，我们就可以堂而皇之认为安全了。

此外使用引用，还必须要注意它和目标之间的生命周期关系。因为一旦使用了引用，就让“安全”遮眼，不去理会引用目标的生命周期了。因为《effective c++》提到的不要企图返回函数的局部变量的引用或函数new出来的对象的引用，这两处实质都是引用和引用目标之间的生命周期关系之间的问题。你引用了一个目标，而这个目标在你使用引用的范围之内就已经被多销毁。你引用了一个目标，而这个目标的生命周期大于你使用引用的范围，你应不应该去管理这个目标的生命周期。《effective c++》提到如果你返回了函数new出来的对象的引用，你不得不自己去亲手delete引用的目标，这样使用起来就很奇怪。从使用引用的角度来看，是不想也不要去理会目标的生命周期的，但是它的本质还是一个指针，指针有的问题它身上也一样会发生。

比如你写了一个模块，模块内的类之间存在引用关系，这些引用在你模块内的生命周期关系中一切如好。但某天有人或你要重用其中的某些类，这些类聚合的引用由模块外的类实现代替了，又或者某些类被cache起来，生命周期变大了，引用之间的生命周期关系发生了变化，引用就如指针一样，同样可以指向一处无效的地方。因为你使用的是引用而不是指针，你就可能认为引用不会出现问题，因为引用是安全的。

3. 至于引用不能在定义之外通过语言规则改变它的指向。当引用同样有可能被定义指向NULL的时候，它与指针常量就差异不大了。一直以来都认为指针常量不可能像引用那样定义的时候，保证指向非NULL的对象，但是引用会指向NULL只是个慌言。那么指针常量有的问题，引用当然也都有。只是引用的使用过程中，你的赋值访问都转化为对目标反引用的赋值操作，而对指针常量进行赋值时，编译器会报错指出。但是这样都无法避免有人不正确去访问你的对象，例如引用是结构体或类的成员变量。只要某处不正确访问了结构体对象或类对象，同样不论是以指针常量还是引用定义的成员变量，一样会被更改。

引用比指针安全，这只是一个希望，希望通过引用隐藏指针的使用，看起来更加安全。但无论如何引用在汇编层的实现就是指针，让引用代替指针使编程更加安全，只能够是一个慌言。当人人都认为这个慌言是真理的时候就是比使用指针更加坏的事情，相信引用比指针更加安全，麻痹对待同一样的事物了。

C++书籍在讲引用相关的话题，更多的是它作为函数的传递参数，与对象传参作比较。你只需要将对象形参改变成引用形参，你就能访问对象的方式访问对象，还可以避免传参过程临时对象的构造，带来诸多好处。或者在重载类的操作符返回自身的引用，使得类的设计在使用上可以连续书写。

说到传参就不得不说一下常量引用，就是引用一个常量了。

首先你不可以用一个非常量的引用，定义它指向一个常量，你必须用一个常量类型的引用，定义它指向一个常量。那么指向常量会发生什么事呢，请看反汇编代码：

    const float& rcf = .f;
  fld1
  fstp        dword ptr [ebp-]
  lea         eax,[ebp-]
  mov         dword ptr [rcf],eax
    const float& rcf2 = .f;
0040118C  fld1
0040118E  fstp        dword ptr [ebp-2Ch]
  lea         ecx,[ebp-2Ch]
  mov         dword ptr [rcf2],ecx  

可以看到编译器悄悄为常量分配了局部空间，形式就像

const float implict = .f;　　　　// dword ptr [ebp-8]
const float& rcf = implict;
const flost implict2 = .f;　　　　// dword ptr [ebp-2Ch]
const float& rcf2 = implict2;

为什么对不打算修改其内容的引用形参，使用常量引用呢？让其只读是其一，其二是你不能将一个常量去定义一个引用形参。

void foo(float&);
void foo2(const float&);

main()
{
     foo (.f); // error
     foo2(.f);  // ok
}

那么这个foo2函数是如何接受一个常量，去定义一个常量引用形参呢。请看反汇编代码：

    foo2(.f);
004011A3  fld1
004011A5  fstp        dword ptr [ebp-5Ch]
004011A8  lea         ecx,[ebp-5Ch]
004011AB  push        ecx
004011AC  call        foo2 (0401005h)
004011B1  add         esp,  

同样，编译器偷偷为这个常量开辟了一个临时变量空间，将其赋值为1.f常量，并定义foo2的形参指向这个没有名字的临时变量。

另外对于临时类对象，赋值给其它变量，则会拷贝这个临时类对象，并随后析构这个临时类对象。但是如果将一个临时类对象去定义一个引用呢？

    B();
  lea         ecx,[ebp-59h]
  call        B::B (0401019h)
0040116B  lea         ecx,[ebp-59h]
0040116E  call        B::~B (0401028h)
    A& ra = A();
  lea         ecx,[ebp-21h]
  call        A::A (040101Eh)
0040117B  lea         edx,[ebp-21h]
0040117E  mov         dword ptr [ra],edx
    C* const pcc = &C();
  lea         ecx,[ebp-5Ah]
  call        C::C (0401037h)
  mov         dword ptr [pcc],eax
0040118C  lea         ecx,[ebp-5Ah]
0040118F  call        C::~C (040103Ch)
    ...
    return ;
004011C7  mov         dword ptr [ebp-64h],
004011CE  lea         ecx,[ebp-21h]
004011D1  call        A::~A (0401023h)
004011D6  mov         eax,dword ptr [ebp-64h]
}
004011D9  mov         esp,ebp
004011DB  pop         ebp
004011DC  ret  

这个局部的临时对象"A()"生命周期延长到了局部范围的结束，因为编译器要保证这个引用不会产生一个迷途引用。而使用指针常量则没有办法延长一个临时对象的生命周期，"C()"这个临时对象在定义了指针常量pcc的指向后，就马上析构了，留下了一个迷途指针。

相同的讨论可以参看stackoverflow

《Why is a c++ reference considered safer than a pointer?》

结合上面的内容，你能说出下面的指向和发生了什么操作吗？

uintptr_t uintptr = ;
float flt = .f;
float flt2 = .f;
float& rf = (float&)uintptr;
float& rf2 = (float&)uintptr = flt;
float& rf3 = (float&)rf2 = flt2;
float*& rpf2 = (float*&)uintptr = &flt;

你说对了吗，请参看反汇编代码：

    float& rf2 = (float&)uintptr = flt;
  fld         dword ptr [flt]
0040113B  fstp        dword ptr [uintptr]
0040113E  lea         eax,[uintptr]
  mov         dword ptr [rf2],eax
    float& rf3 = (float&)rf2 = flt2;
  mov         ecx,dword ptr [rf2]
  fld         dword ptr [flt2]
0040114A  fstp        dword ptr [ecx]
0040114C  mov         edx,dword ptr [rf2]
0040114F  mov         dword ptr [rf3],edx
    float*& rpf2 = (float*&)uintptr = &flt;
  lea         eax,[flt]
  mov         dword ptr [uintptr],eax
  lea         ecx,[uintptr]
0040115B  mov         dword ptr [rpf2],ecx 

之前的反汇编分析系列有

《objc反汇编分析__strong和__weak》

《objc里的伪指针TaggedPointer》

《反汇编分析NSString，你印象中的NSString是这样吗》

《反汇编分析objc函数枢纽objc_msgSend》

《objc反汇编分析，block函数块为何物？》

《反汇编objc分析__block（类型）》

《自制反汇编逆向分析工具 与hopper逆向输出对比》

《自制反汇编逆向分析工具 迭代第六版本 （一）》

《成员函数指针，动态绑定(vc平台）》

《函数指针和成员函数指针有什么不同，反汇编带看清成员函数指针的本尊（gcc@x64平台）》