- 在C++中新增加了引用的概念
- 引用可以看做是一个已定义变量的别名
- 引用的语法： Type& name = var;
int a = 4;
int& b = a; //b为a的别名
b = 5; //操作b就是操作a
tip:普通引用在定义时必须用同类型的变量进行初始化。
引用的意义
- 引用作为变量别名而存在，因为在一些场合可以代替指针
- 引用相对于指针来说具有更好的可读性和实用性
举个栗子：
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 = t;
}
特殊的引用
- const引用
- 在c++中可以声明const引用
- const Type& name = var;
- const 引用让变量拥有只读属性
int a = 4;
const int& b = a;
int* p = (int*) &b;
b = 5; //error, 只读变量
*p = 5; // OK,修改变量a的值
- 当时会用常量对const引用进行初始化时，c++编译器会为常量值分配空间，并将引用名作为这段空间的别名
const int& b = 1; //ok
int* p = (int*) &b;
b = 5; // error， 只读变量
*p = 5; // ok, 修改变量a 的值
使用常量对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;
}
上述代码运行效果如下：
Example:
a = 5
b = 5
Demo:
c = 5
在Example函数中， b=5 是运行不通过的，因为它使用const修饰了 引用 b，拥有只读属性后不能更改。但是使用指针指向的时候，可以直接在运行期把它的值替换掉。
在Demo函数中，同样 c=5 是运行不通过的，因为它使用常量赋值，所以变成一个只读变量，不能直接修改，只能通过指针指向的时候在运行期修改。
引用的本质
首先上一段代码：
#include <stdio.h>
struct TRef
{
char& r;
};
int main(int argc, char *argv[])
{
char c = 'c';
char& rc = c;
TRef ref = { c };
printf("sizeof(char&) = %d\n", sizeof(char&));
printf("sizeof(rc) = %d\n", sizeof(rc));
printf("sizeof(TRef) = %d\n", sizeof(TRef));
printf("sizeof(ref.r) = %d\n", sizeof(ref.r));
return 0;
}
上述代码运行输出为：
sizeof(char&) = 1
sizeof(rc) = 1
sizeof(TRef) = 8
sizeof(ref.r) = 1
首先看第一个 sizeof(char&) ，因为char & 是一个char类型的变量，所以内存大小为1； sizeof(rc) 同理，也是1； sizeof(ref.r) 中ref.r和刚才的两个同理，所以也是1；最后就说到 sizeof(TRef) 因为TRef里就包含了一个引用，所以输出8（32位系统下输出4），那就说明引用占8字节。
开始正题！
- 引用在c++中的内部实现是一个指针常量
- Type& name; <==> Type* const name;
- c++编译器在编译过程中用指针常量作为引用的内部实现，因此引用所占用的空间大小与指针相同
- 从使用的角度，引用只是一个别名， c++为了实用性而隐藏了引用的储存空间这一细节。
这里注意下：
int * const a 因为const 修饰的是a，a是一个指针，所以修饰后a为指针常量；
const int * a 因为const 修饰的是一个int类型的变量，所以修饰后a为常量指针
再举个栗子：
#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;
}
运行结果为：
sizeof(r) = 24
sizeof(r.before) = 8
sizeof(r.after) = 8
&r.before = 0x7fff57b75b00
&r.after = 0x7fff57b75b10
从结果就可以看出 char & 和指针一样，占用8个字节（32位系统下占4个字节）。
引用的意义
- c++中的引用旨在大多数的情况下代替指针
- 功能性： 可以满足多数需要使用指针的场合
- 安全性：可以避开由于指针操作不当而带来的内存错误
- 操作性：简单易用，又不失功能强大
依然举栗子：
#include <stdio.h>
int& demo()
{
int d = 0;
printf("demo: d = %d\n", d);
return d;
}
int& func()
{
static int s = 0;
printf("func: s = %d\n", 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;
}
编译时报了一个警告：
warning: reference to stack memory associated with local variable
'd' returned [-Wreturn-stack-address]
return d;
^
1 warning generated.
意思是说不能返回一个局部变量的引用。
输出结果为：
demo: d = 0
func: s = 0
main: rd = 0
main: rs = 0
demo: d = 0
func: s = 11
main: rd = 0
main: rs = 11
因为demo函数返回了一个局部变量的引用，相当于是一个野指针，所以直接输出0.之后对它的所有操作都无效，都为0； func函数中使用static修饰后，变为全局变量，所以可以返回它的引用，在main函数中对引用的所有操作就都有效。
小结
- 引用作为变量别名而存在旨在代替指针
- const引用可以使得变量具有只读属性
- 引用在编译器内部使用指针常量实现
- 引用的最终本质为指针
- 引用可以尽可能的避开内存错误
