目录

引入

一.引用的基本使用

(1)引用的概念：

(2)引用的表示方法

(3)引用注意事项

(4)引用权限

二.引用的本质

三.引用与函数

 (1)引用做函数参数

 (2)引用做函数返回值

四.常量引用

五.引用与指针

引入

 一.引用的基本使用

(1)引用的概念：

(2)引用的表示方法

小白： &不是按位与吗？

小明： 这是其实是运算符重载。通过重载，同一个运算符将会有不同的含义。编译器会通过上下文来确定运算符的含义。

小白： 啊，原来如此，我说&怎么还是取地址符呢，懂了。

代码实例

#include <iostream>
using namespace std;
int main() {int money = 99999;int& money_1 = money;cout << "money=" << money<<endl;cout << "money_1=" << money_1<<endl;return 0;
}

小白： 果然他们的值是相等的，那怎么确定他们共用一块内存空间呢？

小明： 我们一起来调试看一下。

 小明： 看，引用和它引用的对象是同一块地址。

小白：  学会了，小明厉害啊。

(3)引用注意事项

1.引用在定义的时候必须初始化

由于引用是对已经存在的变量进行取别名，因此使用引用时必须指定变量(初始化)。

int& a;//错误，未初始化

 2.一个变量可以有多个引用，但一个引用只能引用一个变量

在C++语法中，一个变量有多个引用，就类似于一个人可以有多个外号。但是一个引用变量只能指向一个引用对象。

代码实例：

#include <iostream>
using namespace std;
int main() {int x = 100;int& y = x;int& z = x; return 0;
}

3. 引用一旦初始化，就不可更改。 

引用一旦指向引用对象后，不可以更改引用对象。

小白： 啊啊啊，好多内容，脑袋记不住啊！

小明： 不急慢慢来，你哪里不明白？

小白： 为什么一个引用只能引用一个对象？

小明： 你想，如果一个引用类型同时是两个对象的别名，那计算机编译时怎么知道应该用哪一个呢？

小白：也就是说，同时指向多个对象时，具有二义性？

小明：对的。

小白：那为什么初始化后，不能更改引用对象啊？

小明：这个涉及引用的本质，文章后面会讲到的。

小白 ：好的，我会继续努力的。

(4)引用权限

 代码实例：

#include <iostream>
using namespace std;
int main() {int x = 100;int& y = x;//权限不变可行const int& z = x; //权利缩小可行return 0;
}

权限没有扩大可行

代码实例：

#include <iostream>
using namespace std;
int main() {const int x = 100;int& y = x;//权限扩大可行const int& z = x; //权利不变可行return 0;
}

存在权限扩大不可行。

小白：这个我知道，就像班长指挥军长干活，军长上去就是一脚。

小明：哈哈哈哈，对，权限不能扩大，只能缩小

二.引用的本质

代码实例： 

#include <iostream>
using namespace std;
int main() {int a = 10;int& b = a;//本质：int* const b=&ab = 100;//本质：*b=100;return 0;
}

小白：原来如此，这就解释了为什么初始化后，不能更改引用对象了。

小明：对的，因为const修饰b，b中存储的值不能改变，因此b指向的内存地址不能改变，所以引用初始化后不能更改引用对象。

小白：这个引用本质，还是有点糊涂......

小明：你可以这样理解，当代码编译到int& b=a时，编译器其实执行int* const b=&a,当执行b=100时，编辑器实际执行*b=100。

小白：我可以理解为这两种写法是一样的，只是引用简化了吗？

小明：可以的。

三.引用与函数

(1)引用做函数参数

一般认为函数传参有两种形式，值传递和地址传递。值传递的形参是对实参的一份临时拷贝。地址传递是传递指针，通过指针访问实参所在的内存区间。所以地址传递不用开辟新空间，因此速度更快，还能减少内存。

值传递代码实例：

#include <iostream>
using namespace std;
void swap(int x, int y) {int temp = x;x = y;y = temp;cout << "形参：" << "x=" << x << ' ' << "y=" << y << endl;
}
int main() {int x = 10, y = 20;swap(x,y);cout << "实参：" << "x=" << x <<' ' << "y=" << y << endl;return 0;
}

 地址传递代码实例：

#include <iostream>
using namespace std;
void swap(int* x, int* y) {int temp = *x;*x = *y;*y = temp;cout << "形参：" << "x=" << x << ' ' << "y=" << y << endl;
}int main() {int x = 10, y = 20;swap(&x,&y);cout << "实参：" << "x=" << x <<' ' << "y=" << y << endl;return 0;
}

 小白：理解地差不多了，不过值传递的形参是对实参的一份临时拷贝是什么意思？

小明：我画个图你就知道了

 小白：明白了，值传递就是从新开辟空间，只是内容一样而已

小明：对的。

小白：那地址传递呢？

小明：地址传递就是利用指针，形参是存储实参的指针，解引用就找到实参了。

小白：明白了，那引用做形参又是怎么回事？

小明：你忘了刚学的引用本质了？

小白：哦我明白了，这个代码让我来，嘿嘿。

#include <iostream>
using namespace std;
void swap(int& x, int& y) {int temp = x;x = y;y = temp;cout << "形参：" << "x=" << x << ' ' << "y=" << y << endl;
}int main() {int x = 10, y = 20;swap(x,y);cout << "实参：" << "x=" << x <<' ' << "y=" << y << endl;return 0;
}

小明：没错，引用当形参就是这样写的。

小明：你能根据引用本质写出指针版本吗？

小白：小问题啦，看我大展身手。

 小白：怎么样，我写的对吗？

小明：对的，其实引用也是地址传递，只是因为const的缘故，不能改变指向的对象而已。

小白：我明白了。

小明：相比指针，引用更加简便，而且因为const，比指针更加安全。

(2)引用做函数返回值

 小白：为什么引用不能返回局部变量的引用啊？

小明：引用本质是指针，是指针常量。因为指针不能返回局部变量的地址。

小白：指针不能返回局部变量的指针吗？

小明：是的，因为局部变量会在函数执行完之后销毁，该变量的内存会返回给系统，此时函数返回该变量地址，并且调用的话，属于非法访问，是失效指针。

小白：哦哦，明白了，也就是函数执行完之后，该地址不属于该程序了，再次访问是非法的。

小明：对的。

代码实例：

#include <iostream>
using namespace std;
int& test() {int n = 0;n = 100;return n;
}
int main() {int& res = test();cout << res << endl;cout << "系统清除" << endl;;cout << res<<endl;return 0;
}

小白：那只能创建全局变量，返回全局变量了吗？

小明：其实可是使用static关键字，static关键字创建在全局区(静态区)，生命周期是整个程序。

小白：static创建的变量，程序不停止，变量不销毁对吗？

小明：对的。

小白：还是有些懵。

小明：不急，我们来看一下代码就懂了。

代码实例：

#include <iostream>
using namespace std;
int& test() {static int n = 0;n = 100;return n;
}
int main() {int& res = test();cout << res << endl;cout << "系统清除" << endl;cout << res<<endl;return 0;
}

小白：懂了，只要返回值在函数调用不销毁就可以是吗？

小明：对的。

小白：那函数的调用可以作为左值，又是什么意思？

小明：就是说函数可以放到等号左边，给函数赋值。

小白：给函数赋值，不可能吧？

小明：实际上，函数返回值是引用时，会产生一个引用变量，只是没有名字，给函数赋值，实际就是给该引用赋值。

小白：还是不明白。

小明：我们来看代码。

代码实例：

#include <iostream>
using namespace std;
int& test() {static int n = 0;n = 100;return n;
}
int main() {int& res = test();test() = 99;cout << res<<endl;return 0;
}

小白：哦哦，也就是说此时函数相当于一个匿名的引用，函数当左值相当于通过匿名引用修改n的值。

小明：对的，那你看看下面代码什么意思。

代码实例：

#include <iostream>
using namespace std;
int& test() {static int n = 0;n = 100;return n;
}
int main() {int res = test();test() = 99;cout << res<<endl;return 0;
}

 小白：int类型能接收int&类型的值吗？

小明：可以的，其实相当于吧匿名引用解引用后，把值传给res。

小白：还是不明白。

小明：我们接着看代码。

代码实例：

#include <iostream>
using namespace std;
int& test() {static int n = 0;n = 100;return n;
}
int main() {/*int res = test();*/int& m = test();int res = m;test() = 99;cout << res<<endl;return 0;
}

 小明：这个明白吧。

小白：这个明白。

小明：那么换成匿名引用不懂了？

小白：懂了，也就是直接通过，匿名引用传值给变量。

小明：对的。

四.常量引用

小白：这个我懂相当于指向常量的指针常量。

小明：没错，例如const int* const p；p的值不能改变，*p的值也不能改变。

小白：可以直接指向一块常量，是什么意思？

小明：其实常量保存在常量区，声明周期和程序共存亡，并且常量区只有只读权限，没有写权限。如果用普通的引用，由于引用可以更给指向内存的值，属于权限扩大，会报错，使用常量引用则引用也只有读权限，则可以指向常量区。

小白：有些糊涂。

小明：没事，我们来看看代码。

代码实例：

#include <iostream>
using namespace std;
int main() {/*int& res = 10;*/const int& res = 10;cout << 10;return 0;
}

 小白：明白了，防止实参改变，从而改变实参，是为了防止手误没小心改变形参吧。

小明：厉害，直到抢答了，某些场景我们只需要值，但不许要改变引用的值，可以使用常量引用，防止粗心改变形参的值。

代码实例：

#include <iostream>
using namespace std;
void text(const int& x) {//x = 100;cout << x;
}
int main() {/*int& res = 10;*/text(9);return 0;
}

 五.引用与指针

(其余浅谈C++系列持续更新中，请三连关注，本篇完)

本文链接：https://my.lmcjl.com/post/4073.html