引用的基础用法

1、引用的基本使用

        作用是给变量起一个别名

        语法：数据类型 &别名 = 需要指代的变量名

#include <iostream>
using namespace std;

int main(void)
{
    //定义一个变量
    int a = 10;
    
    //用引用来指代这个变量
    int &b = a;

    //输出这两个变量的值
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    return 0;
}

输出：a = 10    b = 10

       

注意事项：

        引用定义后必须初始化！

        引用初始化后不可以改变！

        引用的数据类型必须和要指代数据的数据类型一样

2、引用做函数参数

#include <iostream>
using namespace std;

//值传递交换两个数据
void swp01(int a,int b)
{
    int temp = a;
    a = b;
    b = temp;

    cout << "swp01中a = " << a << endl;
    cout << "swp01中b = " << b << endl;
}

//地址传递交换两个数据
void swp02(int *a,int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;

    cout << "swp02中a = " << *a << endl;
    cout << "swp02中b = " << *b << endl;
}

//引用交换两个数据
void swp03(int &a,int &b)
{
    int temp = a;
    a = b;
    b = temp;

    cout << "swp03中a = " << a << endl;
    cout << "swp03中b = " << b << endl;
}

int main(void)
{
    int a = 10;
    int b = 20;
    //swp01(a,b);

    //swp02(&a,&b);
    
    swp03(a,b);
    cout << "主函数中a = " << a << endl;
    cout << "主函数中b = " << b << endl;

    return 0;
}

3、引用做函数返回值

语法： 数据类型 &函数名(形参列表)

注意事项：

        函数中的局部变量不要返回，会报错！

#include <iostream>
using namespace std;

int &test01()
{
    int a = 10;    //不要返回局部变量的引用
    return a;
}

int main(void)
{
    int &ret = test01();
    return 0;
}

如果我们想要在主函数中获取它的返回值就必须定义一个int &类型的引用来接收它

在函数运行时定义了一个局部变量，当函数运行完成后，函数返回了这个局部变量

这是会出现一个问题，在函数运行时编译器会在栈上创建一个内存空间来存放这个函数，当函数运行完成后，编译器会将创建的内存空间销毁，所以函数中的局部变量也销毁了，如果返回局部变量到主函数中，那么主函数中的引用所引用到的内存空间是一个未知的。所以会出错！

如果我们想要获取函数中变量的值时，可以在数据类型前面加上一个static，让这个变量在全局区中这样可以增加它的生命周期。

#include <iostream>
using namespace std;

int &test02()
{
    static int a = 100;
    return a;            //返回了a的引用，也就是返回了a自己本身
}

int main(void)
{
    int &ret2 = test02();    //此时ret2就是a的一个别名，因为a是一个静态变量不会被销毁

    test02() = 1000;        //因为函数本身就是返回a的本身，所以这时就是a = 1000

    cout << "ret2 = " << ret2 << endl;
    
    return 0;
}

输出：1000

4、引用的本质

本质：引用的本质在c++内部实现是一个指针常量.

#include <iostream>
using namespace std;

//发现是引用，转换为 int* const ref = &a;
void func(int& ref){
	ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
	int a = 10;
    
    //自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
	int& ref = a; 
	ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
    
	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;
    
	func(a);
	return 0;
}

5、常量引用

作用：常量引用主要用来修饰形参，防止误操作

在函数形参列表中，可以加const修饰形参，防止形参改变实参

#include <iostream>
using namespace std;

//引用使用的场景，通常用来修饰形参
void showValue(const int& v) {
	//v += 10;
	cout << v << endl;
}

int main() {

	//int& ref = 10;  引用本身需要一个合法的内存空间，因此这行错误
	//加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;
	const int& ref = 10;

	//ref = 100;  //加入const后不可以修改变量
	cout << ref << endl;

	//函数中利用常量引用防止误操作修改实参
	int a = 10;
	showValue(a);

	system("pause");

	return 0;
}

有写的不对的地方，评论区指正！