❥关于C++之引用

Posted 2022-03-04 itzyjr

引用的本质是指针

int rats = 101;
int& alias = rats;
int* prats = &rats;
——————————————————————————
alias <=> *prats <=> rats
&alias <=> prats <=> &rats

alias和*prats都可以同rats互换，&alias和prats都可以同&rats互换。从这一点来说，引用看上去很像伪装表示的指针。
也就是说：

int & alias = rats;
实际上是下述代码的伪装表示：
int * const pr = &rats;// 【指针常量】

由于pr是指针常量(指向不能变，所指值能变)，所以pr所指地址不变，即一直跟踪rats，能通过pr改变rats的值，直接改变rats的值也同步到(*pr)，所以和引用的本质是一样的。
引用也可以再赋值，引用效忠的对象也可再赋值，但总之引用是作为别名一直效忠于rats变量，不易主！
引用是引用的对象的别名！

---

int rats;
int& rodents = rats; // 使rodents成为rats的别名

引用更接近指针常量，必须在创建时进行初始化，一旦与某个变量关联起来，就将一直效忠于它(不易主)。——地址与地址上存的值总相同。

假设程序员试图这样做：

int rats = 101;
int* pt = &rats;
int& rodents = *pt; // 一直效忠rats
int bunnies = 50;
pt = &bunnies;

将rodents初始化为*pt使得rodents指向rats。接下来将pt改为指向bunnies，并不能改变这样的事实，即rodents引用的是rats。

下图直观演示了按值传递与按引用传递的区别：

示例：用三种方式，交互两个int值

#include <iostream>
void swapr(int& a, int& b);   // a, b are aliases for ints
void swapp(int* p, int* q);   // p, q are addresses of ints
void swapv(int a, int b);     // a, b are new variables
int main() 
	using namespace std;
	int wallet1 = 300;
	int wallet2 = 350;
	cout << "wallet1 = $" << wallet1;
	cout << " wallet2 = $" << wallet2 << endl;
 
	cout << "Using references to swap contents:\\n";
	swapr(wallet1, wallet2);   // pass variables
	cout << "wallet1 = $" << wallet1;
	cout << " wallet2 = $" << wallet2 << endl;
 
	cout << "Using pointers to swap contents again:\\n";
	swapp(&wallet1, &wallet2); // pass addresses of variables
	cout << "wallet1 = $" << wallet1;
	cout << " wallet2 = $" << wallet2 << endl;
 
	cout << "Trying to use passing by value:\\n";
	swapv(wallet1, wallet2);   // pass values of variables
	cout << "wallet1 = $" << wallet1;
	cout << " wallet2 = $" << wallet2 << endl;
	return 0;

void swapr(int& a, int& b) 
	int temp;
	temp = a;
	a = b;
	b = temp;

void swapp(int* p, int* q) 
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;

void swapv(int a, int b) 
	int temp;
	temp = a;
	a = b;
	b = temp;

wallet1 = $300 wallet2 = $350            <<原始数据
Using references to swap contents:       
wallet1 = $350 wallet2 = $300            <<值被交换了
Using pointers to swap contents again:
wallet1 = $300 wallet2 = $350            <<值又被交换了
Trying to use passing by value:
wallet1 = $300 wallet2 = $350            <<交换失败

int main() 
	double x = 3.0;
	cout << cube(x);
	cout << " = cube of " << x << endl;
	cout << refcube(x);
	cout << " = cube of " << x;
	return 0;

double cube(double a) 
	a *= a * a;
	return a;

double refcube(double& ra) 
	ra *= ra * ra;
	return ra;

27 = cube of 3
27 = cube of 27

为何要返回引用：
计算关键字return后面的表达式，并将结果返回给调用函数。从概念上说，这个值被复制到一个临时位置，而调用程序将使用这个值。

double m = sqrt(16.0);
cout << sqrt(25.0);

在第一条语句中，值4.0被复制到一个临时位置，然后被复制给m。在第二条语句中，值5.0被复制到一个临时位置，然后被传递给cout。

dup = accumalate(team, five);

如果accumulate()返回一个结构，而不是指向结构的引用，将把整个结构复制到一个临时位置，再将这个拷贝复制给dup。但在返回值为引用时，将直接把team复制到dup，其效率更高。

返回引用时最重要的一点是，应避免返回函数终止时不再存在的内存单元引用。应避免编写下面的代码：

const free_throws & clone2(free_throwns & ft) 
    free_throwns newguy; // first step to big error
    newguy = ft; // copy info
    return newguy; // return reference to copy

该函数返回一个指向临时变量（newguy）的引用，函数运行完毕后它将不再存在。同样，也应避免返回指向临时变量的指针。
为避免这种问题，最简单的方法是，返回一个作为参数传递给函数的引用。作为参数的引用将指向调用函数使用的数据，因此返回的引用也将指向这些数据。如下代码就是这样做的：

free_throws& accumulate(free_throws& target, const free_throws& source) 
	target.attempts += source.attempts;
	target.made += source.made;
	return target;

示例：不注意上面要避免的后果：

int& test(int&);
int main() 
	int x = 6;
	int& y = test(test(x));// test()函数运行完后返回的临时引用消失！因为临时引用无变量承载！
	cout << y;
	return 0;

int& test(int& i) 
	int tmp = 2 * i;// 局部临时变量
	return tmp;// 块结束后，tmp变量被系统回收消失

有些系统或IDE输出：
-1717986920
有些报错：
Segmentation fault
另一些报错：
warning: reference to local variable 'tmp' returned [-Wreturn-local-addr]

当返回值是引用类型时，会返回该变量的地址。当返回值不是引用型时，编译器会专门给返回值分配出一块临时内存。
总之，绝不能将一个指向局部变量的引用类型值作为函数的返回值！
同样，将一个指向局部变量的指针作为函数的返回值是也有问题的！
程序试图引用已经释放的内存，就是大问题。

将const用于引用返回类型及参数：
避免在设计中添加模糊的特性，因为模糊特性增加了犯错的机会。

accumlate(dup, five) = four;// 直接将函数返回的引用赋值！

假设您要使用引用返回值，但又不允许执行像给accumulate()赋值这样的操作，只需将返回类型声明为const引用：

const free_throwns & accumlate(free_throwns & target, const free_throwns & source);

参数source类型也声明为const，让它成为“只读”。

当然，有时省略const确实有道理，在讨论的重载运算符<<就是一个这样的例子。