【C++】5.引用的本质分析_综合

引用的意义

引用作为变量的别名而存在，因此在一些场合中可以代替指针
引用相对于指针来说更具有更好的可读性和实用性

swap 函数的对比

// 指针版本
void swap(int *a, int *b)
{int t = *a;*a = *b;*b = t
}// 引用版本(注意：函数中的引用行参不需要进行初始化！！！)
void swap(int& a, int& b)
{int t = a;a = b;b = c;
}

函数对比分析：

引用如果作为函数的形参时，不需要进行初始初始化发生在调用的时候。
指针版本要交换a和b的值，传进去的是a和b的地址，想想其实是很奇怪的，引用给人感觉很舒服多了

特殊的引用：const 引用

在C ++ 中可以声明 const 引用

const Type& name = var

const 引用让变量拥有只读属性

int a = 4;
const int& b = a;
int *p = (int*)&b;b = 5; // error  b是只读变量
*p = 5; // ok 还是可以修改 a 的值的
// 只读变量直接赋值是错误的， 但还是可以通过指针改变里面的值

当使用常量对 const 引用进行初始化时，C++ 编译器会为常量分配空间，并将引用名作为这段空间的的别名

const int& b = 1;
int *p = (int*)&b;
b = 5; // error 只读变量
*p = 5 // ok

使用常量对 const 引用初始化后将生成一个只读变量

#include <stdio.h>void Example()
{printf("Example:\n");int a = 4;const int& b = a;int* p = (int*)&b;//b = 5;*p = 5;printf("a = %d\n", a);printf("b = %d\n", b);
}void Demo()
{printf("Demo:\n");const int& c = 1;int* p = (int*)&c;//c = 5;*p = 5;printf("c = %d\n", c);
}int main(int argc, char *argv[])
{Example();printf("\n");Demo();return 0;
}

思考：

引用有自己的存储空间吗？

struct Tref
{char& c;
};cout << sizeof(Tref) << endl;

#include <stdio.h>struct Tref
{char& c;
};int main(int argc, char *argv[])
{char c = 'C';char& rc = c;Tref ref = {c};printf("sizeof(char&) = %d\n", sizeof(char&));  // 1printf("sizeof(rc) = %d\n", sizeof(rc));        // 1printf("sizeof(Tref) = %d\n", sizeof(Tref));    // ?printf("sizeof(ref.c) = %d\n", sizeof(ref.c));  // 1}

输出

sizeof(char&) = 1
sizeof(rc) = 1
sizeof(Tref) = 8    // 让人联想是否为指针
sizeof(ref.c) = 1

引用的本质

引用很多行为类似与指针因为本质如下：

引用在C++ 中的内部实现时一个指针常量

Type& name
等效
Type* const name

void func(int& a)
{a = 5;
}void func(int* const a)
{*a = 5;
}

注意：

C++ 编译器在编译过程中用指针常量作为引用的内部实现，因此引用所占用的空间大小与指针相同
从使用角度，引用只是一个别名， C++ 为了实用性而隐藏了引用的存储空间这一细节

#include <stdio.h>struct TRef
{char* before;char& ref;char* after;
};int main(int argc, char* argv[])
{char a = 'a';char& b = a;char c = 'c';TRef r = {&a, b, &c};printf("sizeof(r) = %d\n", sizeof(r));printf("sizeof(r.before) = %d\n", sizeof(r.before));printf("sizeof(r.after) = %d\n", sizeof(r.after));printf("&r.before = %p\n", &r.before);printf("&r.after = %p\n", &r.after);return 0;
}

在 Linuc 64位机器下编译结果

sizeof(r) = 24
sizeof(r.before) = 8
sizeof(r.after) = 8
&r.before = 0x7ffc17a6c4c0
&r.after = 0x7ffc17a6c4d0

汇编代码分析（VS2013，32位编译器）

char a = 'a';
008E3B38  mov         byte ptr [a],61h

16进制数 61h 送到 a 这个标识符的内存空间，大小是一个 Byte

char& b = a;
008E3B3C  lea         eax,[a]  // 
008E3B3F  mov         dword ptr [b],eax

a 的地址取出来，放到 eax 这个寄存器中去

将 eax 里面的内容，送到一片内存空间里去，这片内存空间就是 b 标识符对应的内存空间，大小为 dword ，即4个字节

C++ 中引用旨在大多数的情况下代替指针

功能性：可以满足多数需要使用指针的场合
安全性：可以避开由于指针操作不当而带来的内存错误
操作性：简单易用，又不失功能强大

生成了只读变量，直接对只读变量修改是不行的

要使已经存在的变量（变成只读属性），只要定义一个它的const的引用

函数返回引用分析

#include <stdio.h>int& demo()
{int d = 0;printf("demo: d = %d\n", d);return d;   // return &d; // 返回局部变量的引用
}int& func()  // int* const
{static int s = 0;printf("func: s = %d\n", s);return s;   // return &s;
}int main(int argc, char* argv[])
{int& rd = demo();int& rs = func();printf("\n");printf("main: rd = %d\n", rd);printf("main: rs = %d\n", rs);printf("\n");rd = 10;rs = 11;demo();func();printf("\n");printf("main: rd = %d\n", rd);printf("main: rs = %d\n", rs);printf("\n");return 0;
}

demo: d = 0
func: s = 0Segmentation fault (core dumped)

不要返回局部变量的引用（这个本质在C看来就是不能返回局部变量的指针）。

如果这个局部变量被static修饰就是可以返回（因为此时的变量存储在全局数据区）。

返回的是局部变量的地址（local variable），main 中rd已经是野指针了，已经没有意义了

小结

引用作为变量别名而存在旨在代替指针
const 引用可以使得变量具有只读属性
引用在编译器内部使用指针常量实现
引用的最终本质为指针
引用可以尽可能的避开内存错误