C++初阶——入门(2)引用

最新推荐文章于 2024-09-16 17:46:36 发布

IfYouHave

最新推荐文章于 2024-09-16 17:46:36 发布

阅读量311

点赞数 1

分类专栏： C++ 文章标签： c++ jvm java

本文链接：https://blog.csdn.net/IfYouHave/article/details/129668988

版权

C++ 专栏收录该内容

32 篇文章 1 订阅

订阅专栏

文章详细介绍了C++中的引用概念，包括它是已有变量的别名，不占用额外内存。引用必须在定义时初始化且一旦绑定不能改变。文中探讨了引用和指针的区别，以及引用在作为参数和返回值时的效率优势，特别是在处理大对象和避免拷贝时。此外，还讨论了常引用和权限问题。文章最后提到了引用在数据结构如链表初始化中的限制。

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

6.5.2 值和引用的作为返回值类型的性能比较

6.6 引用和指针的区别

6. 引用

6.1 引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。

类型& 引用变量名(对象名) = 引用实体；
#include<iostream>
using namespace std;

int main()
{
	int a = 0;
	int& b = a;//定义引用类型

	cout << &a << endl;//取地址
	cout << &b << endl;//取地址
	//地址相同

	a++;
	cout << a << endl;//1
	cout << b << endl;//1
	b++;
	cout << a << endl;//2
	cout << b << endl;//2
	return 0;
}
注意：引用类型必须和引用实体是同种类型的

6.2 引用特性

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

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int& b = a;
	int& c = a;
	int& d = c;

	int& ra = a;
	int& rra = a;
	cout << &a << ' ' << &ra << ' ' << &rra << endl;
	//地址相同
	//引用一旦引用了一个实体，在不能引用其他实体
	int x = 50;
	b = x;
	//此时b 不是x的别名，而是赋值给b
	cout << b << endl;
	return 0;
}

6.3 常引用

//常引用
#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int& b = a;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;


	const int c = 20;
	//c的权限被修改，权限放大
	//int& d = c; //err

	const int& d = c;
	int const&  e = c;

	//权限缩小，e以只读的方式取别名f，f只能读，不能改
	int f = 30;
	const int& g = f;

	int ii = 1;
	double dd = ii;
	//double& rdd = (double)ii;//err
	const double& rdd = ii;//如上图分析

	const int& x = 10;
	//引用一个常量，对常量起别名
	return 0;
	
	//由上可知，权限不能放大，但是可以缩小
}

所有类型的提升、转换或强转，并不会改变原变量的类型，而是中间产生一个临时变量

void func1(int n)
{}
//如果使用引用传参，函数内如果不改变n，那么建议尽量用const引用传参
//void func2(int& n)
void func2(const int& n)
{}

void func3(int* n)
{}
int main()
{
	//使用引用可以传多种类型的变量
	int a = 10;
	const int b = 20;
	func1(a);
	func1(b);
	func1(30);

	func2(a);//sucess
	func2(b);//err,涉及权限放大,const引用传参正确
	func2(30);//err,涉及权限放大，const引用传参正确

	int* c = &a;
	func3(&a);
	func3(c);
	//func3(&b);//err,传递的是const int* ，而函数是 int*

	//只有引用才涉及权限放大问题，同样指针也涉及权限放大问题
	//而 func1 函数穿的只是一份临时拷贝，并不会影响原数据
	return 0;
}

6.4 使用场景

引用的使用场景：

1.做参数—— a. 输出型参数 b. 大对象传参，提高效率

2. 做返回值—— a. 输出型返回对象，调用者可以修改返回对象 b. 减少拷贝，提高效率

1. 做参数——输出型参数

#include<iostream>
using namespace std;
//1.做参数————输出型参数
void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

typedef struct SeqList
{
	//...
}SL;
void SLPushBack(SL& s, int x)
{

}

//原 1
//typedef struct SListNode
//{
//	//..
//}SLTNode;
//
//void SListPushBack(SLTNode** pphead, int x)
//{
//
//}

优化 1
//typedef struct SListNode
//{
//	//..
//}SLTNode;
//
//void SListPushBack(SLTNode*& pphead, int x)
//{
//
//}

//优化 2
typedef struct SListNode
{
	//..
}SLTNode,*PSLTNode;

void SListPushBack(PSLTNode& pphead, int x)
{

}


int main()
{
	int a = 1, b = 2;
	Swap(a, b);
	cout << "a = " << a << endl << "b = " << b << endl;

	SL sl;
	SLPushBack(sl, 1);
	SLPushBack(sl, 1);
	SLPushBack(sl, 1);
	SLPushBack(sl, 1);

	//SLTNode* list = NULL;
	//SListPushBack(&list, 1);
	//SListPushBack(&list, 2);
	//SListPushBack(&list, 3);

	//SLTNode* list = NULL;
	//SListPushBack(list, 1);
	//SListPushBack(list, 2);
	//SListPushBack(list, 3);

	PSLTNode list = NULL;
	SListPushBack(list, 1);
	SListPushBack(list, 2);
	SListPushBack(list, 3);

	return 0;
}

2. 做返回值——传引用返回的具体使用

//传值返回——--都会生成一个临时拷贝对象，返回该值

// 由函数栈帧可知，当函数执行完，就会销毁，而返回值有以下两种情况
// 当返回值不大的时候，会用寄存器保存返回值
// 当返回值过大的时候，会提前在main函数开辟好存储返回值的空间进行返回
//int Count1()
//{
//	int n = 0;
//	n++;
//	//...
//	return n;
//}

//这里的返回值由于是放在静态区的静态变量，因此当函数栈帧结束
//返回值n不后销毁，但是编译器仍像上述生成一临时拷贝区
int Count1()
{
	static int n = 0;
	n++;
	//...
	return n;
}

//2.传引用返回————就是返回其返回值的别名
#include<iostream>
using namespace std;
int& Count()
{
	int n = 0;
	n++;
	//...
	return n;
}

int main()
{
	int ret = Count();
	//此时函数调用完，反会值销毁，为什么还会返回 1 ？
	//可知，销毁后，虽然越界了，但是进行访问是可以的
	//这里的ret 为 1 是侥幸
	cout << ret << endl;//1
	//引用返回的语法含义是返回返回对象的别名
	//ret 的结果是未定义的
	//如果栈帧结束时，系统会清理栈帧置成随机值，那么这里的ret的结果就是随机值
	
	//上面程序使用引用返回本质是不对的，结果是不会有保证的
	return 0;
}

总结：如果出了函数的作用域，返回对象就销毁了，那么一定不能用引用返回，一定要用传值返回。

//2.传引用返回————就是返回其返回值的别名
//此场景才会使用传引用返回
#include<iostream>
using namespace std;
int& Count()
{
	static int n = 0;
	n++;
	//...
	return n;
}

int main()
{
	int ret = Count();
	int& tmp = Count();
	cout << ret << endl;//1
	//static修饰的变量存在静态区，因此n这块空间不会销毁
	cout << tmp << endl;//2
	return 0;
}

传引用返回的具体使用——修改：

SeqList.h

#pragma once
#include<iostream>
#include<assert.h>

namespace SeqList
{
	typedef int SLDataType;
	typedef struct SeqList
	{
		SLDataType* _a;
		int _size;
		int _capacity;
	}SL;

	void SLInit(SL& s, int capacity = 4);

	void SLPushBack(SL& s, SLDataType x);

	//修改数据的函数
	//void SLModify(SL& s,int pos,SLDataType x);
	SLDataType& SLAt(SL& s, int pos);
}

SeqList.cpp

#include"SeqList.h"

void SeqList::SLInit(SL& s, int capacity)
{
	s._a = (SLDataType*)malloc(sizeof(SLDataType*) * capacity);
	assert(s._a);
	s._size = 0;
	s._capacity = capacity;
}

void SeqList::SLPushBack(SL& s, SLDataType x)
{
	// ...
	s._a[s._size] = x;
	s._size++;
}

int& SeqList::SLAt(SL& s, int pos)
{
	assert(pos >= 0 && pos <= s._size);
	return s._a[pos];
}

SeqListTest.cpp

#include"SeqList.h"
using namespace std;
using namespace SeqList;

int main()
{
	SL sl;
	SLInit(sl);
	SLPushBack(sl, 1);
	SLPushBack(sl, 2);
	SLPushBack(sl, 3);
	SLPushBack(sl, 4);

	SLAt(sl, 0)++;
	for (int i = 0; i < sl._size; i++)
	{
		cout << sl._a[i] << " ";
	}
	cout << endl;
	SLAt(sl, 0) = 10;
	for (int i = 0; i < sl._size; i++)
	{
		cout << sl._a[i] << " ";
	}
	cout << endl;
	return 0;
}

6.5 传值、传引用

6.5.1 传值和传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

//大对象传参，提高效率
#include<iostream>
using namespace std;

#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();

	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();

	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;//12ms
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;//0ms
}

int main()
{
	TestRefAndValue();
	return 0;
}

6.5.2 值和引用的作为返回值类型的性能比较

#include<iostream>
using namespace std;
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }

void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();

	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;//194ms
	cout << "TestFunc2 time:" << end2 - begin2 << endl;//3ms
}

int main()
{
	TestReturnByRefOrValue();
	return 0;
}

通过上述代码的比较，发现传值和传引用在作为传参以及返回值类型上效率相差很大。

6.6 引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
int main()
{
	int a = 10;
	int& ra = a;

	cout << "&a = " << &a << endl;
	cout << "&ra = " << &ra << endl;
	return 0;
}
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
int main()
{
	int a = 10;

	int& ra = a;
	ra = 20;

	int* pa = &a;
	*pa = 20;

	return 0;
}
我们来看下引用和指针的汇编代码对比：

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 指针更强大，更危险，更复杂，而引用相对局限一些，比指针使用起来相对更安全，更简单

10.从语法的角度，引用没有开辟空间，指针开了4/8字节空间，而从上图反汇编，从底层实现角度分析，引用底层使用指针实现的。可以理解为引用是指针的封装。

数据结构，链表初始化，不能够使用引用，1.因为引用定义时必须初始化，2.因为引用不能改变指向，参考上面第三条，而指针可以改变指向