C++：引用的使用细则

---

引用概念

引用不是新定义一个变量，而 是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量 共用同一块内存空间。

类型& 引用变量名(对象名) = 引用实体；

void TestRef()
{
	int a = 10;
	int& ra = a;//<====定义引用类型
	printf("%p\n", &a);	//a与ra地址相同
	printf("%p\n", &ra);
}

int main() {
	TestRef();
	return 0;
}

注意: 引用类型必须和引用实体是同种类型的

引用特性

1. 引用在 定义时必须初始化
2. 一个变量可以有多个引用
3. 一个引用一旦引用了一个变量，就不能再引用其他变量了。

#include <iostream>
void TestRef()
{
     int a = 10;
     // int& ra;
     int& ra = a;
     int& rra = a;
     printf("%p  %p  %p\n", &a, &ra, &rra);//地址都相同
}
int main(){
     TestRef();
     return 0;
}

做参数

void Swap(int& left, int& right)
{
	int temp = left;
    left = right;
    right = temp;
}

做返回值

int& TestRefReturn(int& a)
{
	a += 10;
	return a; 
}

例题：

int& Add(int a, int b)
{
	int c = a + b;
	return c; 
}

int main() {
    int& ret = Add(1, 2);
    Add(3, 4);
    cout << ret << endl;    // 7 (警告:返回与局部变量“c”关联的堆栈内存引用)
    return 0;
}

注意:

• 如果函数返回时，离开函数作用域后，其栈上空间已经还给系统，因此不能用栈上的空间作为引用类型返回。 如果以引用类型返回，返回值的生命周期必须不受函数的限制(即比函数生命周期长)。

2. 引用变量与它的实体，哪个生命周期长，为什么？

一般情况下是一样的，但是特殊情况下 实体生命周期长 ：比如说，在你小的时候有个外号，但是长大了没有人叫了。

int main(){
    int a = 10;

    if(true){
        int& ra = a;
        ra = 20;
    }
    //ra = 30;    // 使用未声明的标识符
    a = 30;

    return 0;
}

3. 传值、传引用效率比较：

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝。（不能通过形参改变外部实参）

• 因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
• 与在栈上构造出一个临时拷贝比起来，传递他的指针/引用是更高效的

引用和const引用

const引用可以用不同类型的对象初始化(只要能从一种类型转换到另一种类型即可)，也可以是不可寻址的值，如文字常量。

测试如下：

void TestConstRef()
{
	const int a = 10;
	//int& ra = a; // 该语句编译时会出错，a为常量 
	const int& ra = a;
	//int& b = 10; // 该语句编译时会出错，10为常量 
	const int& b = 10;

	double d = 12.34;
	//int& rd = d; // 该语句编译时会出错，类型不同 
	const int& rd = d; //引用后的rd具有常属性，不能通过修改rd来改变d中存储的值。  12
	const double &dr = d + 1.0;	// 13.34

	const int ival = 1024;
	int *&pi_ref = &ival;    //错误，非const引用是非法的
	const int *&pi_ref = &ival;   //错误，需要临时变量，且引用的是指针，而pi_ref是一个非常量指针
	const int * const &pi_ref = &ival;  //正确
	//补充
	const int *p = &ival;
	const int *&pi_ref = p;  //正确 
}

编译器产生临时变量的时候引用必须为const

引用在内部存放的是一个对象的地址，它是该对象的别名。对于不可寻址的值，如文字常量，以及不同类型的对象，编译器为了实现引用，必须生成一个临时对象，引用时间上指向该对象，但用户不能访问它。

举例如下：

double dval = 23;
const int &ri = dval;

编译器将其转换为:

int tmp = dval; // double -> int
const int &ri = tmp;

引用和指针的区别

在 语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main() {
	int a = 10;
	int& ra = a;
	cout<<"&a = "<<&a<<endl;
	cout<<"&ra = "<<&ra<<endl;
	return 0; 
}

在 底层实现 上实际是有空间的，因为引用是按照指针方式来实现的。（两者从底层实现(汇编)上来看是完全相同的）

• T& ------> T* const
• const T& -------> const T* const

引用和指针的不同点:

1. 引用在定义时 必须初始化，指针没有要求
2. 引用在初始化时引用一个实体后，就 不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
3. 没有NULL引用，但有NULL指针
4. 在 sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6. 有多级指针，但是没有多级引用
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
8. 引用比指针使用起来相对更安全（指针所保存的地址必须为有效地址，在使用前需要判空【nullptr】）

总结：

1. 引用是给一个变量起别名，两个名字都是一个变量，所以操作谁从结果上看都一样。
2. 引用是代替指针完成跨栈操作的，所以它具备指针跨栈的一切特点。
3. 引用的底层实现实际是指针。

---

如有不同见解，欢迎留言讨论！！！