C++-Record10—指针的引用及常量引用

指针的引用

常量引用

使用变量初始化const引用

指针的引用

关于指针的引用，类似于C语言中的二级指针的使用，但是，引用帮程序员把取地址的过程给自动完成的，所以，实现同样的功能，一个是用二级指针，一个是用指针的引用，后者更简便，也更高效。

先设置一个结构体：

//
struct Teacher
{
	char name[64];
	int age ;
};

再设置两个函数，一个是使用的二级指针，一个是使用的指针的引用：

//在被调用函数 获取资源 
int getTeacher(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; 
}

指针的引用：

//指针的引用 做函数参数
int getTeacher2(Teacher* &myp)
{
	//给myp赋值 相当于给main函数中的pT1赋值
	myp = (Teacher *)malloc(sizeof(Teacher));
	if (myp == NULL)
	{
		return -1;
	}
	myp->age = 36;
}

经过对比，可以发现，通过二级指针的方式来控制内存时，过程繁琐，需要创建辅助指针进行实现，而设置指针的引用，直接就可以完成想要实现的功能。

常量引用

引用分为普通引用和常量引用，之前的都是普通引用，接下来介绍一下常量引用。比如，这就算是普通引用：

	int  a = 10;
	int &b = a;

接下来看常引用：

	//常引用
	int  x = 20;
	const int &y = x;  //常引用 是 让变量 引用只读属性 不能通过y去修改x了
	//y = 21;

常引用的作用是：让变量拥有只读属性，（在指针作函数参数的时候这个属性作用比较大，即不能通过y去修改x了）。

使用变量初始化const引用

常量引用的初始化，分为两种情况，第一种，是用变量初始化来进行常量引用，会单独分配内存空间（即上面举得那个例子就是）：

		int x1 = 30;
		const int &y1 = x1; //用x1变量去初始化 常引用

使用字面量常量初始化const引用

第二种，用常量（即字面量）去初始化：

		const int a = 40;  //c++编译器把a放在符号表中
		int &m = 41; //普通引用 引用一个字面量 请问字面量有没有内存地址
		//引用 就是给内存取多个门牌号 (多个别名)
		//printf("&40:%d \n", &40);

普通引用，引用一个字面量是没有内存地址的，即“41”没有内存地址(是直接放在符号表中的),而引用就是给内存取别名，那“41”没有内存，引用还去啥别名呢？啥也取不了。所以，以上是编译不通过的，要改进的方式，只有：

		const int a = 40;  //c++编译器把a放在符号表中
		const int &m = 43;  //c++编译器 会 分配内存空间

在其前加个"const"就可以了，（这也是const和引用在一起的一个特殊点！）一用const，编译器会给m分配一个内存空间，并将这个m指向"43",但"43"依旧没内存空间。

字面量没有内存空间，故没有存放的内存地址，即使存在，也是代码区中。这是在C++中一个和C不一样的地方。

综合案例

//
struct Teacher
{
	char name[64];
	int age ;
};

常量引用作函数参数：

//void printTeacher(const Teacher  * const myt)
void printTeacher(const Teacher &myt)
{
	//常引用 让 实参变量 拥有只读属性 
	//myt.age = 33; 这样写就会报错
	printf("myt.age:%d \n", myt.age);
	
}

常量引用让变量拥有只读属性，即写了就不能让轻易的改。

void main()
{
	Teacher  t1;
	t1.age = 36;

	printTeacher(t1);

	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

常量引用总结

1）Const & int e 相当于 const int * const e ，指针变量和指针所指向的内存空间都不能被修改。

2）普通引用相当于 int *const e1。

3）当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名。

4）使用字面量对const引用初始化后，将生成一个只读变量。

总体代码

dm12_指针的引用.cpp

#include "iostream"
using namespace std;

//
struct Teacher
{
	char name[64];
	int age ;
};

//在被调用函数 获取资源 
int getTeacher(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; 
}


//指针的引用 做函数参数
int getTeacher2(Teacher* &myp)
{
	//给myp赋值 相当于给main函数中的pT1赋值
	myp = (Teacher *)malloc(sizeof(Teacher));
	if (myp == NULL)
	{
		return -1;
	}
	myp->age = 36;
}

void FreeTeacher(Teacher *pT1)
{
	if (pT1 == NULL)
	{
		return ;
	}
	free(pT1);
}

void main1201()
{
	Teacher *pT1 = NULL;

	//1 c语言中的二级指针
	getTeacher(&pT1);
	cout<<"age:"<<pT1->age<<endl;
	FreeTeacher(pT1);


	//2 c++中的引用 （指针的引用）
	//引用的本质 间接赋值后2个条件 让c++编译器帮我们程序员做了。
	getTeacher2(pT1);

	cout<<"age:"<<pT1->age<<endl;
	FreeTeacher(pT1);

	cout << "hello..." << endl;
	system("pause");
}

dm13_常量引用.cpp


#include <iostream>
using namespace std;

//常引用的知识架构
void main1301()
{
	//普通引用

	int  a = 10;
	int &b = a;
	printf("b:%d \n", b);

	//常引用
	int  x = 20;
	const int &y = x;  //常引用 是 让变量 引用只读属性 不能通过y去修改x了
	//y = 21;

	//常引用 初始化 分为2种情况
	//1> 用变量 初始化 常引用
	{
		int x1 = 30;
		const int &y1 = x1; //用x1变量去初始化 常引用
	}
	//2> 用字面量 初始化 常量引用
	{
		const int a = 40;  //c++编译器把a放在符号表中
		int &m = 41; //普通引用 引用一个字面量 请问字面量有没有内存地址
		//引用 就是给内存取多个门牌号 (多个别名)
		//printf("&40:%d \n", &40);
		const int &m = 43;  //c++编译器 会 分配内存空间 
	}
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}


//
struct Teacher
{
	char name[64];
	int age ;
};


//void printTeacher(const Teacher  * const myt)
void printTeacher(const Teacher &myt)
{
	//常引用 让 实参变量 拥有只读属性 
	//myt.age = 33;
	printf("myt.age:%d \n", myt.age);
	
}

void main()
{
	Teacher  t1;
	t1.age = 36;

	printTeacher(t1);

	
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

恋蛩音

发布了140 篇原创文章 · 获赞 6 · 访问量 4849

私信关注