引用与指针那些事

1.引用与指针

总论：

引用指针
必须初始化可以不初始化
不能为空可以为空
不能更换目标可以更换目标

引用必须初始化，而指针可以不初始化。

我们在定义一个引用的时候必须为其指定一个初始值，但是指针却不需要。

  1. int &r;    //不合法，没有初始化引用
  2. int *p;    //合法，但p为野指针，使用需要小心

引用不能为空，而指针可以为空。

由于引用不能为空，所以我们在使用引用的时候不需要测试其合法性，而在使用指针的时候需要首先判断指针是否为空指针，否则可能会引起程序崩溃。

  1. void test_p(int* p)
  2. {
  3.     if(p != null_ptr)    //对p所指对象赋值时需先判断p是否为空指针
  4.         *p = 3;
  5.     return;
  6. }
  7. void test_r(int& r)
  8. {
  9.     r = 3;    //由于引用不能为空，所以此处无需判断r的有效性就可以对r直接赋值
  10.     return;
  11. }

引用不能更换目标

指针可以随时改变指向，但是引用只能指向初始化时指向的对象，无法改变。

  1. int a = 1;
  2. int b = 2;
  4. int &r = a;    //初始化引用r指向变量a
  5. int *p = &a;   //初始化指针p指向变量a
  7. p = &b;        //指针p指向了变量b
  8. r = b;         //引用r依然指向a，但a的值变成了b

2.引用

左值引用

常规引用，一般表示对象的身份。

右值引用

右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。

右值引用可实现转移语义（Move Sementics）和精确传递（Perfect Forwarding），它的主要目的有两个方面：

  • 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。
  • 能够更简洁明确地定义泛型函数。

引用折叠

  • X& &、X& &&、X&& & 可折叠成 X&
  • X&& && 可折叠成 X&&

C++的引用在减少了程序员自由度的同时提升了内存操作的安全性和语义的优美性。比如引用强制要求必须初始化，可以让我们在使用引用的时候不用再去判断引用是否为空，让代码更加简洁优美，避免了指针满天飞的情形。除了这种场景之外引用还用于如下两个场景：

引用型参数

一般我们使用const reference参数作为只读形参，这种情况下既可以避免参数拷贝还可以获得与传值参数一样的调用方式。

  1. void test(const vector<int> &data)
  2. {
  3.     //...
  4. }
  5. int main()
  6. {
  7.     vector<int> data{1,2,3,4,5,6,7,8};
  8.     test(data);
  9. }

引用型返回值

C++提供了重载运算符的功能，我们在重载某些操作符的时候，使用引用型返回值可以获得跟该操作符原来语法相同的调用方式，保持了操作符语义的一致性。一个例子就是operator []操作符，这个操作符一般需要返回一个引用对象，才能正确的被修改。

  1. vector<int> v(10);
  2. v[5] = 10;    //[]操作符返回引用，然后vector对应元素才能被修改
  3.               //如果[]操作符不返回引用而是指针的话，赋值语句则需要这样写
  4. *v[5] = 10;   //这种书写方式，完全不符合我们对[]调用的认知，容易产生误解

3.指针与引用的性能差距

指针与引用之间有没有性能差距呢？这种问题就需要进入汇编层面去看一下。我们先写一个test1函数，参数传递使用指针：

  1. void test1(int* p)
  2. {
  3.     *p = 3;    //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。
  4.     return;
  5. }

该代码段对应的汇编代码如下：

  1. (gdb) disassemble 
  2. Dump of assembler code for function test1(int*):
  3.    0x0000000000400886 <+0>:  push   %rbp
  4.    0x0000000000400887 <+1>:  mov    %rsp,%rbp
  5.    0x000000000040088a <+4>:  mov    %rdi,-0x8(%rbp)
  6. => 0x000000000040088e <+8>:  mov    -0x8(%rbp),%rax
  7.    0x0000000000400892 <+12>: movl   $0x3,(%rax)
  8.    0x0000000000400898 <+18>: nop
  9.    0x0000000000400899 <+19>: pop    %rbp
  10.    0x000000000040089a <+20>: retq   
  11. End of assembler dump.

上述代码1、2行是参数调用保存现场操作；第3行是参数传递，函数调用第一个参数一般放在rdi寄存器，此行代码把rdi寄存器值（指针p的值）写入栈中；第4行是把栈中p的值写入rax寄存器；第5行是把立即数3写入到rax寄存器值所指向的内存中，此处要注意(%rax)两边的括号，这个括号并并不是可有可无的，(%rax)和%rax完全是两种意义，(%rax)代表rax寄存器中值所代表地址部分的内存，即相当于C++代码中的*p，而%rax代表rax寄存器，相当于C++代码中的p值，所以汇编这里使用了(%rax)而不是%rax。

我们再写出参数传递使用引用的C++代码段test2：

  1. void test2(int& r)
  2. {
  3.     r = 3;    //赋值前无需判断reference是否为空
  4.     return;
  5. }

这段代码对应的汇编代码如下：

  1. (gdb) disassemble 
  2. Dump of assembler code for function test2(int&):
  3.    0x000000000040089b <+0>:  push   %rbp
  4.    0x000000000040089c <+1>:  mov    %rsp,%rbp
  5.    0x000000000040089f <+4>:  mov    %rdi,-0x8(%rbp)
  6. => 0x00000000004008a3 <+8>:  mov    -0x8(%rbp),%rax
  7.    0x00000000004008a7 <+12>: movl   $0x3,(%rax)
  8.    0x00000000004008ad <+18>: nop
  9.    0x00000000004008ae <+19>: pop    %rbp
  10.    0x00000000004008af <+20>: retq   
  11. End of assembler dump.

我们发现test2对应的汇编代码和test1对应的汇编代码完全相同，这说明C++编译器在编译程序的时候将指针和引用编译成了完全一样的机器码。所以C++中的引用只是C++对指针操作的一个“语法糖”，在底层实现时C++编译器实现这两种操作的方法完全相同。

3.总结

C++中引入了引用操作，在对引用的使用加了更多限制条件的情况下，保证了引用使用的安全性和便捷性，还可以保持代码的优雅性。在适合的情况使用适合的操作，引用的使用可以一定程度避免“指针满天飞”的情况，对于提升程序鲁棒性也有一定的积极意义。最后，指针与引用底层实现都是一样的，不用担心两者的性能差距。

上述部分参考自：http://irootlee.com/juicer_pointer_reference/#