【C++】引用_c++引用-CSDN博客

本文链接：https://blog.csdn.net/No_char/article/details/140893253

引用

1.1 引用的概念和定义

引用不是新定义⼀个变量，而是给已存在变量取了一个别名，编译器不会为引⽤变量开辟内存空间，它和它引用的变量共用同⼀块内存空间。
比如：
水壶传中李逵，宋江叫他"铁牛"，江湖上人称"黑旋风"；
林冲，外号豹子头；
类型& 引用别名 = 引用对象;

#include<iostream>
using namespace std;

int main()
{
	int a = 0;
	// 引⽤：b和c是a的别名
	int& b = a;
	int& c = a;
	// 也可以给别名b取别名，d相当于还是a的别名
	int& d = b;
	// 这⾥取地址我们看到是⼀样的
	cout << &a << endl;  // 0x61fe04
	cout << &b << endl;  // 0x61fe04
	cout << &c << endl;  // 0x61fe04
	cout << &d << endl;  // 0x61fe04
	
	return 0;
}

在这里插入图片描述

1.2 引用的特性

引用在定义时必须初始化。
一个变量可以有多个引用。
一个引用只能有一个实体。

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	// 编译报错：“ra”: 必须初始化引⽤
	//int& ra;
	int& b = a;
	int c = 20;
	// 这⾥并⾮让b引⽤c，因为C++引⽤不能改变指向，
	// 这⾥是⼀个赋值
	b = c;
	cout << &a <<" "<< a << endl;  // 0x61fe14 20
	cout << &b <<" "<< b << endl;  // 0x61fe14 20
	cout << &c <<" "<< c << endl;  // 0x61fe10 20

	return 0;
}

1.3 引用的使用

引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。
引用传参跟指针传参功能是类似的，引用传参相对更方便⼀些。
引用返回值的场景相对比较复杂，我们在这里简单讲了⼀下场景，还有⼀些内容后续类和对象章节中会继续深⼊讲解。
引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的点是，C++引用定义后不能改变指向，Java的引用可以改变指向。
使用C++引用替代指针传参，目的是简化程序，避开复杂的指针。

#include<iostream>
using namespace std;

void Swap(int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
} 

int main()
{
	int x = 0, y = 1;
	cout << x <<" " << y << endl;
	Swap(x, y);
	cout << x << " " << y << endl;
	return 0;
}

#include<iostream>
#include<assert.h>
using namespace std;

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void STInit(ST& rs, int n = 4)
{
	rs.a = (STDataType*)malloc(n * sizeof(STDataType));
	rs.top = 0;
	rs.capacity = n;
}

// 栈顶
void STPush(ST& rs, STDataType x)
{
	assert(rs);
	// 满了， 扩容
	if (rs.top == rs.capacity)
	{
		printf("扩容\n");
		int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
		STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			} 
		rs.a = tmp;
		rs.capacity = newcapacity;
	} 
	rs.a[rs.top] = x;
	rs.top++;
} 

// int STTop(ST& rs)  //传值传参会生成一个拷贝（临时对象tmp)
int& STTop(ST& rs)  // 传引用返回，无需拷贝(无中间商了）
{
	assert(rs.top > 0);
	return rs.a[rs.top - 1];
}

int main()
{
	// 调⽤全局的
	ST st1;
	STInit(st1);
	STPush(st1, 1);
	STPush(st1, 2);
	cout << STTop(st1) << endl;
	// 修改栈顶的数据呢
	STTop(st1) += 1;
	cout << STTop(st1) << endl;
	return 0;
}

在这里插入图片描述

1.4 const引用

可以引⽤⼀个const对象，但是必须⽤const引⽤。const引⽤也可以引⽤普通对象，因为对象的访问权限在引⽤过程中可以缩⼩，但是不能放⼤。
需要注意的是类似int& rb = a*3; double d = 12.34; int& rd = d;这样⼀些场景下a*3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产⽣临时对象存储中间值，也就是，rb和rd引⽤的都是临时对象，⽽C++规定临时对象具有常性，所以这⾥就触发了权限放⼤，必须要⽤常引⽤才可以。
所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象，C++中把这个未命名对象叫做临时对象。

int main()
{
	const int a = 10;
	// 编译报错：error C2440: “初始化”: 
	// ⽆法从“const int”转换为“int &”
	// 这⾥的引⽤是对a访问权限的放⼤
	//int& ra = a;
	// 这样才可以
	const int& ra = a;
	// 编译报错：error C3892: “ra”: 不能给常量赋值
	//ra++;
	// 这⾥的引⽤是对b访问权限的缩⼩
	int b = 20;
	const int& rb = b;
	// 编译报错：error C3892: “rb”: 不能给常量赋值
	//rb++;
	return 0;
}

int main()
{
	int a = 10;
	const int& ra = 30;
	// 编译报错: “初始化”: ⽆法从“int”转换为“int &”
	// int& rb = a * 3;
	const int& rb = a*3;
	double d = 12.34;
	// 编译报错：“初始化”: ⽆法从“double”转换为“int &”
	// int& rd = d;
	const int& rd = d;
	return 0;
}