2021c++核心编程之引用(二)

最新推荐文章于 2024-09-11 15:28:58 发布

置顶 QZP51ZX

最新推荐文章于 2024-09-11 15:28:58 发布

阅读量160

点赞数

分类专栏： c/c++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/QZP51ZX/article/details/121071459

版权

c/c++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本文详细介绍了C++中的引用，包括其基本使用、注意事项、作为函数参数和返回值的作用，以及引用的本质。引用作为变量的别名，不占用额外内存，且在函数调用中能避免值传递的拷贝，提高效率。同时，文章强调了常量引用在保护实参不变中的应用，以及引用在内部实际上是指针常量的实现。

摘要由CSDN通过智能技术生成

2.1 引用的基本使用

作用: 给目标变量起别名

语法规则：

数据类型 &引用名 = 目标变量名;

特别注意: &不是求地址运算符，而是起标志作用

示例：

#include<iostream>
using namespace std;
int main() {
	//1.定义一个局部变量
	int a = 100;
	//2.给目标变量a取一个别名
	int& b = a;
	//3.输出查看是否引用结果
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	system("pause");
	return 0;
}

2.2 引用注意事项

引用的类型必须和其所绑定的变量的类型相同

#include<iostream>
using namespace std;
int main(){
    double a=10.3;
    int& b=a; //错误，引用的类型必须和其所绑定的变量的类型相同
    cout<<b<<endl;
}

声明引用的同时必须对其初始化，否则系统会报错

#include<iostream>
using namespace std;
int main(){
    int& a; //错误！声明引用的同时必须对其初始化(指向目标变量合法的内存空间)
    return 0;
}

引用初始化之后，相当于变量或对象的别名，因此不能再将已有的引用名作为其他数据类型变量或对象的名字或别名

#include<iostream>
using namespace std;
int main() {
	int a = 100;
	int& b = a;
	double b = 999;// 编译时，直接报错，不能再将已有的引用名作为其他数据类型变量或对象的名字或别名
	system("pause");
	return 0;
}

引用不是定义一个新的变量或对象，因此内存不会为引用开辟新的空间存储这个引用

#include<iostream>
using namespace std;
int main() {
	//1.定义一个局部变量
	int a = 100;
	//2.给目标变量a取一个别名
	int& b = a;
	//3.查看变量a和引用b地址
	cout << "变量a在内存中的地址为:" << &a << endl;
	cout << "引用b在内存中的地址为:" << &b << endl;
	system("pause");
	return 0;
}

输出结果:

在这里插入图片描述

对数组的引用

语法格式:

数据类型 (&引用名)[数组中元素数量]=数组名;

示例如下:

#include<iostream>
using namespace std;
#define max_arrys 3
int main() {
    //1.创建一个数组并赋值
    int a[3] = { 1,2,3 };
    //2.对数组的引用
    int(&b)[3] = a;
    //对数组进行输出
	cout << "数组a:[";
	for (int i = 0; i < max_arrys; i++)
	{
		if (max_arrys - 1 > i) {
			cout << b[i] << ", ";
		}
		else
		{
			cout << b[i] << "]" << endl;
		}
	}
	system("pause");
    return 0;
}

对指针的引用

语法格式:

数据类型 *&引用名=指针名;
//可以理解为：（数据类型*） &引用名=指针名，即将指针的类型当成数据类型*

示例如下:

#include<iostream>
using namespace std;
int main() {
	//定义一个局部变量a
	int a = 10;
	//定义一个指针p并指向变量a
	int* p = &a;
	//给指针取一个别名b
	int*& b = p;
	cout << "变量a的地址为:" << &a << " 指针p地址为:" << p << " 引用名b的地址为:" << b << endl;

	system("pause");
	return 0;
}

输出结果:

在这里插入图片描述

2.3 引用做函数参数

作用: 函数传参时，可以利用引用的技术让形参修饰实参

优点: 可以简化指针修改实参

示例：

#include<iostream>
using namespace std;

//1. 值传递
void mySwap01(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}

//2. 地址传递
void mySwap02(int* a, int* b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}

//3. 引用传递
void mySwap03(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}
int main() {
	//定义两个局部变量a1,b1
	int a1 = 10;
	int b1 = 20;
	cout << "值传递情况:" << endl;
	cout << "调用mySwap01函数进行值传递前:" << " a1=" << a1 << " b1=" << b1 << endl;
	//调用mySwap01函数，进行值传递
	mySwap01(a1, b1);
	cout << "调用mySwap01函数进行值传递后:" << " a1=" << a1 << " b1=" << b1 << endl;

	//定义两个局部变量a2,b2
	int a2 = 10;
	int b2 = 20;
	cout << "地址传递情况:" << endl;
	cout << "调用mySwap02函数进行值传递前:" << " a2=" << a2 << " b2=" << b2 << endl;
	//调用mySwap02函数，进行地址传递
	mySwap02(&a2, &b2);
	cout << "调用mySwap02函数进行值传递后:" << " a2=" << a2 << " b2=" << b2 << endl;


	//定义两个局部变量a1,b1
	int a3 = 10;
	int b3 = 20;
	cout << "引用传递情况:" << endl;
	cout << "调用mySwap03函数进行值传递前:" << " a3=" << a3 << " b3=" << b3 << endl;
	//调用mySwap03函数，进行引用传递
	mySwap03(a3, b3);
	cout << "调用mySwap03函数进行值传递后:" << " a3=" << a3 << " b3=" << b3 << endl;

	system("pause");
	return 0;
}

效果如图:

在这里插入图片描述

总结：通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单

2.4 引用做函数返回值

作用：引用是可以作为函数的返回值存在的

注意：不要返回局部变量引用,原因是因为局部变量值都是在栈区，栈区存储数据空间由编译器管理开辟和自动释放

用法：函数调用作为左值

示例：

#include<iostream>
using namespace std;
//1.定义一个函数test01，返回局部变量的引用
//注意:千万不要返回局部变量引用,局部变量的值都在栈区，栈区存储数据空间由编译器管理开辟和自动释放
int& test01() {
	int a = 10;
	int& b = a;
	return b;
}
//2.定义一个函数test03，返回非局部变量的引用
int& test02() {
	//static修饰的变量称为静态变量，变量中的值存在堆区，当函数完被调用之后，栈区存储数据空间由编译器管理开辟和自动释放，但不影响堆区堆区的值
	static int c = 20;
	return c;
}

int main() {
	//调用函数test01，并接收返回的局部变量的引用
	//注意:函数test01中定义的局部变量a的值在函数调用完之后就自动释放了，导致返回局部变量a的引用指向的值为未知，但是编译器会做一次值保留，当再次进行输出时，值不在保留
	int& b1 = test01();
	cout << "引用b1的地址为:" << &b1 << " 引用b1的值为:" << b1 << endl;
	cout << "引用b1的地址为:" << &b1 << " 引用b1的值为:" << b1 << endl;
	//调用函数test02，并接收返回的静态变量的引用
	int& b2 = test02();
	cout << "引用b2的地址为:" << &b2 << " 引用b2的值为:" << b2 << endl;
	cout << "引用b2的地址为:" << &b2 << " 引用b2的值为:" << b2 << endl;
	//当函数返回值是引用类型，这个函数调用可以作为左值
	//注意:如果函数做左值，那么必须返回引用
	test02() = 1000;
	cout << "引用b2的地址为:" << &b2 << " 引用b2的值为:" << b2 << endl;
	cout << "引用b2的地址为:" << &b2 << " 引用b2的值为:" << b2 << endl;
	system("pause");
	return 0;
}

效果如图:

在这里插入图片描述

2.5 引用的本质

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

讲解示例：

#include<iostream>
using namespace std;
int main() {
	//1.定义一个局部变量a
	int a = 100;
	//2.给目标变量a取一个别名
	//编译器会自动进行转换成:int* const ref = &a;就是我们之前学习的指针常量，指针指向不可以改，但指针的值可以改，同理，引用也不可以更改，值可以改
	int& ref = a;
	cout << "a的地址为:" << &a << "a的值为:" << a << endl;
	cout << "ref的地址为:" << &ref << "ref的值为:" << ref << endl;
	//3,当通过引用的方式改变值
	//编译器会自动转换成:*ref = 1
	ref = 1;
	cout << "a的地址为:" << &a << "a的值为:" << a << endl;
	cout << "ref的地址为:" << &ref << "ref的值为:" << ref << endl;
	system("pause");
	return 0;
}

结论：C++推荐用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们转换

2.6 常量引用

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

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

示例：

#include<iostream>
using namespace std;
//定义showValue函数，利用常量引用防止误操作修改实参
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; //编译器报错
	int a = 10;
	showValue(a);
	system("pause");
	return 0;
}

读万卷书，行万里路，博主会持续更新学习笔记，如有问题，可以留言和私信，我们一起进步！！！