一、引用
作用：给变量起别名。
语法：数据类型 &别名=原名
cpp
#include <iostream>
using namespace std;
int main() {
//引用基本语法
//数据类型 &别名=原名
int a=10;
//创建引用
int &b=a;
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
}通过别名b，把b的值进行修改。
cpp
#include <iostream>
using namespace std;
int main() {
//引用基本语法
//数据类型 &别名=原名
int a=10;
//创建引用
int &b=a;
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
b=100;
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
}二、引用注意事项
引用必须初始化
引用在初始化后，不可改变。(如果b一开始是a的原名，后面b就不能再变成c的别名。）
cpp
#include <iostream>
using namespace std;
int main() {
//引用基本语法
//数据类型 &别名=原名
int a=10;
//创建引用
int &b=a;
// cout<<"a="<<a<<endl;
// cout<<"b="<<b<<endl;
//2.引用在初始化后 ，不可以改变
int c=20;
b=c;//赋值操作，而不是更改引用
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
cout<<"c="<<c<<endl;
}
cpp
//输出
a=20
b=20
c=20三、引用做函数参数
作用：函数传参，可以利用引用的技术让形参修饰实参。
优点：可以简化指针修改实参。
（1）值传递
cpp
#include <iostream>
using namespace std;
//1.值传递
void test01(int a,int b) {
int tmp=a;
a=b;
b=tmp;
cout<<"swap01 a="<<a<<endl;
cout<<"swap01 b="<<b<<endl;
}
//2.地址传递
void test02(int *a,int * b) {
int tmp=*a;
*a=*b;
*b=tmp;
}
//3. 引用传递
int main() {
int a=10;
int b=20;
test01(a,b);
cout<<"Main a="<<a<<endl;
cout<<"Main b="<<b<<endl;
}
cpp
//输出
swap01 a=20
swap01 b=10
Main a=10
Main b=20（2）地址传递
cpp
#include <iostream>
using namespace std;
//1.值传递
void test01(int a,int b) {
int tmp=a;
a=b;
b=tmp;
cout<<"swap01 a="<<a<<endl;
cout<<"swap01 b="<<b<<endl;
}
//2.地址传递
void test02(int *a,int * b) {
int tmp=*a;
*a=*b;
*b=tmp;
cout<<"swap02 a="<<*a<<endl;
cout<<"swap02 b="<<*b<<endl;
}
//3. 引用传递
int main() {
int a=10;
int b=20;
// test01(a,b);//值传递，形参不会修饰实参
// cout<<"Main a="<<a<<endl;
// cout<<"Main b="<<b<<endl;
test02(&a,&b);//地址传递，形参会修饰实参
cout<<"Main a="<<a<<endl;
cout<<"Main b="<<b<<endl;
}
cpp
//输出
swap02 a=20
swap02 b=10
Main a=20
Main b=10（3）引用传递
cpp
#include <iostream>
using namespace std;
//1.值传递
void test01(int a,int b) {
int tmp=a;
a=b;
b=tmp;
cout<<"swap01 a="<<a<<endl;
cout<<"swap01 b="<<b<<endl;
}
//2.地址传递
void test02(int *a,int * b) {
int tmp=*a;
*a=*b;
*b=tmp;
cout<<"swap02 a="<<*a<<endl;
cout<<"swap02 b="<<*b<<endl;
}
//3. 引用传递
void test03(int &a,int &b) {
int tmp=a;
a=b;
b=tmp;
// cout<<"swap03 a="<<*a<<endl;
// cout<<"swap03 b="<<*b<<endl;
}
int main() {
int a=10;
int b=20;
// test01(a,b);//值传递，形参不会修饰实参
// cout<<"Main a="<<a<<endl;
// cout<<"Main b="<<b<<endl;
// test02(&a,&b);//地址传递，形参会修饰实参
test03(a,b);//引用传递，形参会修饰实参
cout<<"Main a="<<a<<endl;
cout<<"Main b="<<b<<endl;
}
cpp
//输出
Main a=20
Main b=10四、引用做函数返回值
作用：引用可以作为函数的返回值存在的。
注意：不要返回局部变量引用。
用法：函数调用作为左值。
cpp
#include <iostream>
using namespace std;
//1.不要返回局部变量的引用
int & test01() {
int a=10;//局部变量存放在四区中的栈区
return a;
}
//2.函数的调用可以作为左值
int & test02() {
}
//2.函数的调用可以作为左值
int main() {
//引用做函数的返回值
//1.不要返回局部变量的引用
//2.函数的调用可以作为左值
int &ref=test01();
cout<<"ref="<<ref<<endl;//第一次结果正确，因为编译器做了保留。
cout<<"ref="<<ref<<endl;//第二次结果错误，因为a的内存已经释放。
}
cpp
//输出
ref=
进程已结束，退出代码为 -1073741819 (0xC0000005)函数的调用作为左值
cpp
#include <iostream>
using namespace std;
//1.不要返回局部变量的引用
int & test01() {
int a=10;//局部变量存放在四区中的栈区
return a;
}
//2.函数的调用可以作为左值
//返回静态变量的引用
int & test02() {
static int a=20;
return a;
}
//2.函数的调用可以作为左值
int main() {
//引用做函数的返回值
//1.不要返回局部变量的引用
//2.函数的调用可以作为左值
// int &ref=test01();
// cout<<"ref="<<ref<<endl;//第一次结果正确，因为编译器做了保留。
// cout<<"ref="<<ref<<endl;//第二次结果错误，因为a的内存已经释放。
//如果函数做左值,那么必须返回引用
int &ref2=test02();
cout<<"ref2="<<ref2<<endl;
cout<<"ref2="<<ref2<<endl;
test02()=1000;
cout<<"ref2="<<ref2<<endl;
cout<<"ref2="<<ref2<<endl;
}
cpp
ref2=20
ref2=20
ref2=1000
ref2=1000五、引用的本质
本质：引用的本质在C++内部实现是一个指针常量。
cpp
#include <iostream>
using namespace std;
//发现是引用,转换为int * const ref=&a
void func(int &ref) {
ref=1000;//ref是引用,转换为*ref=100
}
int main() {
int a=10;
//自动转换为 int * const ref=&; 指针常量是指针指向不可改，也说明了为什么引用不可更改。
int &ref=a;
ref=20;//内部发现ref是引用，自动帮我们转换为：*ref=20；
cout<<"a:"<<a<<endl;
cout<<"ref:"<<ref<<endl;
func(a);
return 0;
}
cpp
a:20
ref:20六、常量引用
作用：常量引用主要用来修饰形参，防止误操作。
在函数列表中，可以加const修饰形参，防止形参改变实参。
cpp
#include <iostream>
using namespace std;
//打印数据函数
void showValue(int &val) {
val=1000;
cout<<"val="<<val<<endl;
}
int main() {
//常量引用
//使用场景：用来修饰形参，防止误操作
// int a=10;
// int &ref=a;
//加上const之后，编译器将代码修改 int tmp=10; const int & ref=temp;
// const int &ref=10;//引用必须引一块合法的内存空间
//
// ref=20;//加入const之后变为只读，不可以修改。
int a=100;
showValue(a);
cout<<"main a="<<a<<endl;
}
cpp
//输出
val=1000
main a=1000引用引用是别名，如果修改了引用的值，原名的值也随之修改。所以为了避免误操作，我们把形式参数设成const，也就是只读模式。
cpp
#include <iostream>
using namespace std;
//打印数据函数
void showValue(const int &val) {
// val=1000;
cout<<"val="<<val<<endl;
}
int main() {
//常量引用
//使用场景：用来修饰形参，防止误操作
// int a=10;
// int &ref=a;
//加上const之后，编译器将代码修改 int tmp=10; const int & ref=temp;
// const int &ref=10;//引用必须引一块合法的内存空间
//
// ref=20;//加入const之后变为只读，不可以修改。
int a=100;
showValue(a);
cout<<"main a="<<a<<endl;
}
cpp
val=100
main a=100