C++对C语言的扩展_引用

最新推荐文章于 2024-09-13 20:03:48 发布

原创最新推荐文章于 2024-09-13 20:03:48 发布 · 8k 阅读

0 ·

CC 4.0 BY-SA版权

C++ 专栏收录该内容

5 篇文章

订阅专栏

本文深入探讨C++中的引用概念，包括其基本语法、作用、与指针的区别，以及如何在函数参数和返回值中使用引用。文章还详细解释了引用作为常量的特殊用途，以及在内存管理中的角色。

在上一篇文章中,我们讲述了c++对c语言的加强,在这篇文章中,我们开始学习c++对c语言的扩展_引用

引用

变量名

变量名实质上是一段连续存储空间的别名,是一个标号(门牌号).
通过变量来申请并命名内存空间
通过变量的名字可以使用存储空间.

问题：对一段连续的内存空间只能取一个别名吗？

引用的概念

变量名,本身是一段内存的引用,即别名(alias).引用可以看作一个已定
义变量的别名.
引用的语法：Type& name = var;
基本用法

#include<iostream>
using namespace	std;	
int	main(void)	
{	
	int	a=10;//c编译器分配4个字节内存,a内存空间的别名
	int	&b=a;//b就是a的别名
	a=11;//直接赋值
	{	
	int	*p=&a;	
	*p=12;	
	cout<<a<<endl;	
	}	
	b=14;
	cout<<"a = "<<a	<<", b = "<<b<<endl;	
	return 0;
}

规则

引用没有定义,是一种关系型声明。声明它和原有某一变量(实体)的关系.故而类型与原类型保持一致,且不分配内存.与被引用的变量有相同的地址.
声明的时候必须初始化,一经声明,不可变更.
可对引用,再次引用.多次引用的结果,是某一变量具有多个别名.
&符号前有数据类型时,是引用.其它皆为取地址.

int	main(void)	
{	
	int	a,b;	
	int	&r=a;	
	int	&r=b;//错误,不可更改原有的引⽤关系
	float &rr=b;//错误,引⽤类型不匹配	cout<<&a<<&r<<endl;	//变量与引⽤	具有相同的地址。
	int	&ra	=	r;	//可对引⽤更次引⽤,表⽰a变量有两个别名,分别是	r和	ra
	return 0;
}

引用作为函数的参数

普通引用在声明时必须用其它的变量进行初始化,引用作为函数参数声明时不进行初始化,

#include<iostream>
using namespace	std;	
struct Teacher	
{
	char name[64];
	int age;
};
void printfT(Teacher *pT)
{
	cout<<pT->age<<endl;
}
//pT是t1的别名,相当于修改了t1
void printfT2(Teacher &pT)
{
	pT.age=33;
	cout<<pT.age<<endl;	
}	
//pT和t1的是两个不同的变量
void printfT3(Teacher pT)	
{
	cout<<pT.age<<endl;	
	pT.age=45;//只会修改pT变量,不会修改t1变量
}	
int	main(void)	
{
	Teacher	t1;	
	t1.age	=	35;	
	printfT(&t1);	
	printfT2(t1);	//pT是t1的别名
	printf("t1.age:%d \n",	t1.age);	//33
	printfT3(t1)	;//	pT是形参	,t1	copy⼀份数据 给pT
	printf("t1.age:%d \n",	t1.age);	//33
	return 0;	
}

引用的意义

引用作为其它变量的别名而存在，因此在一些场合可以代替指针
引用相对于指针来说具有更好的可读性和实用性

在c语言中.
void swap(int a, int b); //⽆法实现两数据的交换
void swap(int *p, int *q); //开辟了两个指针空间实现交换

void swap(int &a,int &b)
{
	int tmp;
	tmp=a;
	a=b;
	b=tmp;
}
int main()
{
	int	a=3,b=5;	
	cout<<"a = "<<a<<"b = "<<b<<endl;	
	swap(a,b);	
	cout<<"a = "<<a<<"b	= "<<b<<endl;	
	return 0;		
}

c++中引入引用后,可以用引用解决的问题,避免用指针来解决,

引用的本质

单独定义的引用,必须初始化,说明很像一个变量.
引用在c++中内部实现是一个常指针.Type& name;<–>Type* const name;
c++编译器在编译过程中使用常指针作为引用的内部实现,因此引用所占的空间大小与指针相同
从使用的角度,引用会让人误会其只是一个别名,没有自己的存储空间.这是C++为了实用性而做出的细节隐藏.

//程序的输入方式
void func(int &a)
{
	a=5;
}
c++内部的实现
void func(int* const a)
{
	*a=5;
}

间接赋值的3各必要条件:

定义两个变量（一个实参一个形参）
建立关联实参取地址传给形参
*p形参去间接的修改实参的值
引用在实现上，只不过是把：间接赋值成立的三个条件的后两步和二为一.

引用作为函数的返回值（引用当左值）

当函数返回值为引用时:若返回栈变量,不能成为其它引用的初始值(不能作为左值使用).

#include<iostream>
int getA1()
{
	int a=10;
	return a;
}
int& getA2()
{
	int a=10;
	return a;
}
int main()
{
	int a1=0;
	int a2=0;
	a1=getA1();//值拷贝

	//将⼀个引⽤赋给⼀个变量，会有拷⻉动作
	//理解： 编译器类似做了如下隐藏操作， a2=*(getA2())
	a2=getA2();
	//将⼀个引⽤赋给另⼀个引⽤作为初始值， 由于是栈的引⽤，内存⾮法
	int &a3=getA2();
	cout<<"a1="<<a1<<endl;
	cout<<"a2="<<a2<<endl;
	cout<<"a3="<<a3<<endl;
	return 0;
}

. 当函数返回值为引用时:若返回静态变量或全局变量,可以成为其他引用的初始值(可作为右值使用，也可作为左值使用)

#include<iostream>
using namespace	std;	
int	getA1()
{
static int a;
				a=10;
return a;
}
int& getA2()	
{	
	static int a;
	a=10;
	return a;	
}	
int	main(void)	
{
	int	a1 = 0;	
	int	a2 = 0;	
	//值拷⻉
	a1=getA1();
	//将⼀个引⽤赋给⼀个变量，会有拷⻉动作
	//理解： 编译器类似做了如下隐藏操作， a2	=	*(getA2())
	a2=getA2();
	//将⼀个引⽤赋给另⼀个引⽤作为初始值， 由于是静态区域，内存合法
	int	&a3=getA2();
	cout<<"a1="<<a1<<endl;
	cout<<"a2="<<a2<<endl;
	cout<<"a3="<<a3<<endl;
	return 0;
}

引用作为函数返回值,如果返回值为引用可以当左值.如果返回值为普通变量不可以当左值.

#include<iostream>
using namespace	std;
//函数当左值
//返回变量的值
int	func1()	
{
	static int a1=10;
	return a1;
}	
//返回变量本⾝	
int& func2()
{
	static int a2 = 10;
	return a2;
}	
int	main(void)	
{	
	//函数当右值
	int	c1 = func1();
	cout<<"c1="<<c1	<<endl;
	int	c2=func2();//函数返回值是⼀个引⽤,并且当右值
	cout<<"c2="<<c2<<endl;
	//函数当左值
	//func1()=100;//error
	func2()=100;//函数返回值是⼀个引⽤,并且当左值
	c2=func2();
	cout<<"c2="<<c2<<endl;	
	return 0;
}

指针引用

#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;
/*
	指针的引用
*/
struct Teacher {
	char name[64];
	int age;
};

//在被调用函数中,获取资源
int getTeacher01(Teacher **p)
{	
	Teacher *tmp = NULL;
	if (p == NULL)
	{
		return -1;
	}
	tmp = (Teacher *)malloc(sizeof(Teacher));
	if (tmp == NULL)
	{
		return -2;
	}
	tmp->age = 33;
	//p是实参的地址,*实参的地址,去间接的修改是实参的值
	*p = tmp;
}

//c++中的指针引用
int getTeacher02(Teacher* &tmp)
{
	//给tmp赋值,相当于给main函数的pT1赋值
	tmp = (Teacher *)malloc(sizeof(Teacher));
	if (tmp == NULL)
	{
		return -1;
	}

	tmp->age = 20;
}

int main(void)
{
	/*
	c语言二级指针的使用
		Teacher *pT1 = NULL;
		getTeacher01(&pT1);
		cout << "age : " << pT1->age << endl;
	*/

	//c++的引用(指针的引用)
	//引用的本质:间接赋值后两个要求,让c++帮我们做了
	Teacher *pT1 = NULL;
	getTeacher02(pT1);
	cout << "age : " << pT1->age << endl;

	cout << endl;
	system("pause");
	return 0;
}

常量引用

const 引用有较多使用.它可以防止对象的值被随意修改.因而具有一些特性.
1.const 对象的引用必须是const 的,将普通引用绑定到const 对象是不合法的. 这个原因比较简单.既然对象是const的,表示不能被修改,引用当然也不能修改,必须用 const 引用。实际上,const int a=1;int &b=a;这种写法是不合法的
2. const 引用可使用相关类型的对象(常量,非同类型的变量或表达式)初始化.这个是const引用与普通引用最大的区别.这个是 const 引用与普通引用最大的区别.

#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;

void method01()
{
	//普通引用
	int a = 10;
	int &b = a;
	printf("%d\n", b);
	//常引用
	int x = 20;
	const int &y = x;//常引用:让变量引用拥有只读属性,不能通过y修改x
	//y = 21;  错误写法

	/*
		常引用初始化,分为两种情况:
			1>.用变量初始化常量引用
				int x1=30;
				const int &y1=x1;
			2>.用常量(字面量)初始化常量引用
				const int a=10; -->c++编译器把a放到符号表中
				int &m=41; -->普通引用引用一个字面量,没有内存地址
				(引用就是给内存取多个门牌号)(多个别名)
				const int &m=43;-->常引用存在一个内存地址,会分配内存空间
			3>.
				常引用相当于:const int* const e;
				普通引用相当于;int* const e1;
			

	*/	
}

struct Teacher {
	char name[64];
	int age; 
};
int printTeacher(const Teacher &p)
{
	//p.age = 10; 错误的,只有只读功能
	//常引用让实参拥有只读属性
	printf("t1 : %d\n", p.age);
	return 0;
}

int main(void)
{
	Teacher t1;
	t1.age = 36;
	printTeacher(t1);
	cout << endl;
	system("pause");
	return 0;
}

const引用的原理

const 引用的目的是,禁止通过修改引用值来改变被引用的对象.const引用的初化特性较为微妙,可通过如下代码说明:

double val = 3.14;
const int &ref = val;
double &ref2 = val;
cout<<ref<<" "<<ref2<<endl;	
val=4.14;
cout<<ref<<" "<<ref2<<endl;

上述输出结果为 3 3.14 和 3 4.14.因为 ref 是 const 的,在初始化的过程中已经给定值,不允许修改.而被引用的对象是val,是非const的,所以 val的修改并未影响ref 的值,而 ref2 的值发生了相应的改变

那么,为什么非 const 的引用不能使用相关类型初始化呢?实际上,const引用使用相关类型对象初始化时发生了如下过程:

int	temp=val;
const int &ref = temp;

如果 ref 不是 const 的,那么改变 ref 值,修改的是 temp,而不是 val.期望对 ref 的赋值会修改 val 的程序员会发现 val 实际并未修改.

结论

const int & e 相当于 const int * const e
普通引用相当于 int *const e
当使用常量（字面量）对const引用进行初始化时,C++编译器会为常量值分配空间,并将引用名作为这段空间的别名
使用字面量对const引用初始化后,将生成一个只读变量