C++学习笔记（二）-----引用语法介绍-优快云博客

本文链接：https://blog.youkuaiyun.com/double__main__/article/details/142413490

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。

预处理：头文件展开/宏替换/去掉注释/条件编译
编译：检查语法，生成汇编代码（指令级代码）
汇编：将汇编代码生成二进制机器码
链接：合并链接，生成可执行程序

C++新语法------引用（差点把指针干掉了）

1. 引用概念

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

比如：孙悟空、齐天大圣、弼马温、美猴王、石猴。

int main()
{
	int a = 0;
	int& b = a;   // 这里的&不是取地址是引用，给a取了一个别名叫b
	
	// 打印a和b的地址看看，结果相同（X86的环境）
	cout << &a << endl;  // 00CFFBC4
	cout << &b << endl;  // 00CFFBC4

	a++;
	b++;
	// 对a操作，b会变；对b操作，a也会变。a和b本质是同一个玩意
	return 0;
}

1.1 引用的场景

1.1.1 引用做参数

// 以前写Swap函数，必须传址传惨（传值传参不行，因为形参的改变不会影响实参）
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

int main()
{
	int x = 0, y = 1;
	Swap(&x, &y);
	cout << x <<" " << y << endl;
	return 0;
}

这样写很麻烦，传值传参，传址传参容易出错

下面是C++引用的玩法。

void Swap(int& x1, int& y1)
{
	int tmp = x1;
	x1 = y1;
	y1 = tmp;
}

int main()
{
	int x = 0, y = 1;
	Swap(x, y);
	cout << x <<" "<< y << endl;
	return 0;
}

1.1.2 引用做返回值

以前C语言用传值返回时

int Count()
{
	int n = 0;
	n++;
	return n;
}
// 因为n是临时变量，出了作用域就销毁了
// 所以这里的返回值，不是直接把n返回，返回的是n的一份临时拷贝
int main()
{
	int ret = Count();
	return 0;
}

C++里面使用传引用返回

注意：如果函数返回时，出了函数作用域，返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

int& Count()
{
	int n = 0;
	n++;
	return n;
}
//这里返回的是n的别名
int main()
{
	int ret = Count();
	return 0;
}

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

int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1,2) is :" << ret << endl;
	// 输出结果是：Add(1,2) is :7

	return 0;
}

上面两段代码都是大坑，是错误使用引用返回的例子（它们的返回值出了作用域都被销毁了），极易出错

返回值不销毁时，才传引用返回（例如：malloc开辟出来的空间、全局变量、生命周期不受函数限制、链表等）

// CPP接口设计（顺序表）
struct SeqList
{
	int a[10];
	int size;
};

// 读 or 修改第i个位置的值
int& SLAT(struct SeqList& ps, int i)
{
	assert(i < ps.size);
	// ...
	return ps.a[i];
}

int main()
{
	struct SeqList s;
	s.size = 3;
	// ...
	SLAT(s, 0) = 10;
	SLAT(s, 1) = 20;
	SLAT(s, 2) = 30;

	cout << SLAT(s, 0) << endl;
	cout << SLAT(s, 1) << endl;
	cout << SLAT(s, 2) << endl;

	return 0;
}

1.2 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

传引用传参（任何适合都可以用）
1. 提高效率
2. 输出型参数（形参的修改，影响实参）

传引用返回（出了函数作用域对象还在）
1. 提高效率
2. 修改返回对象

1.3 引用特性

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体

int main()
{
	// int& b;  // 不行，引用在定义时必须初始化

	int a = 1;
	int& b = a;
	int& c = a;
	int& d = b;   // 一个变量可以有多个引用
	
	int x = 0;
	int& a = x;  // 报错:重定义，引用一旦引用一个实体，再不能引用其他实体
	return 0;
}

1.4 常引用

在引用的过程中

权限可以平移
权限可以缩小
权限不能放大

int main()
{
	const int a = 0;

	// 权限的放大
	int& b = a;  // 报错
	int d = a;   // 这个是赋值拷贝，d的修改不影响a

	// 权限的平移
	const int& c = a;

	//权限的缩小
	int x = 0;
	const int& y = x;

	return 0;
}

int func()
{
	int a = 0;

	return a;
}
// 这里返回的不是a，a出了作用域就销毁了
// 返回的是：a的一个临时拷贝（相当于有个中间值）

int main()
{
	int ret1 = func();  // 这个是把a的临时拷贝赋值给ret1，ret1的改变不影响中间的临时变量
	int& ret2 = func();  // 报错
	// 因为a出了函数作用域就销毁了，所以函数不是直接将a返回
	// 返回的是a的一份临时拷贝，临时变量具有常性（相当于前面加了const）
	// 权限放大了，所以报错
	const int& ret3 = func();  // 这个正确，权限的平移
	// 被const修饰后，ret3的生命周期延长了，中间的临时变量生命周期也变长了

	int a = 0;
	double b = a;  // 可以

	double& c = a;  // 报错
	// 报错的原因：a先赋值给一个临时变量，临时变量的类型是double
	// 而临时变量具有常性，临时变量在引用时，权限的放大，所以报错

	const double& d = a;  // 这个可以

	return 0;
}

1.5 引用和指针的区别

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

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

引用和指针的不同点:

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

2 C语言里面的结构体升级成了类

// 写死一个静态列表
# define N 10
struct SeqList
{
	// 成员函数
	int& at(int i)  // 引用返回
	{
		assert(i < N);
		return a[i];
	}

	// 成员变量
	int a[N];
};

int main()
{
	//struct SeqList s1;   // 兼容C的语法

	SeqList s2;  // C++可以用类创建对象，省略前面的struct

	for (size_t i = 0; i < N; i++)
	{
		s2.at(i) = i;
	}

	for (size_t i = 0; i < N; i++)
	{
		cout << s2.at(i) << " ";
	}

	cout << endl;

	return 0;
}