十一、指针和引用（一）

十一、指针和引用（一）

1、指针

1）思考

​ 在计算机程序中，有一条铁律那就是万物皆内粗，而我们知道，内存就是一个个小格，存放着高电平或者低电平，也就是0或者1，我们要表达的一切都是通过这种二进制的方式放到内存中，当我们读取、写入，其实局势在对应的内存空间执行读或者写操作

​ 我们今天就研究研究，当我们读取和写入的时候，背后的故事，首先我们需要知道我们读取和写入的内存地址，因为内存里有很多个小格，就好比一栋楼有很多住户，你要找好朋友张三，你就要知道他家的地址，你不能挨个去敲门，因为这样会被打死...,其次来说，效率也很低。

​ 再者来讲，你还要知道你到底要读取多少格的内容，或者写入多少格的内容，因为不同的数据类型，占用的内存空间也是不同的

​ 总结：操作内存，即读取和写入操作时，需要知道内存地址和内存的大小

2）内存空间模拟图

​ 在计算机中，内存的最小单位为字节，每8个bit算一个内存地址，要操作内存，需要知道内存的地址和内存的大小

3）指针语法

​ C/C++提供了让我们直接操作内存的机会，这种机会就是利用指针，利用指针操作内存需要知道两个要素：即要操作的内存地址和要操作的内存大小。

​ 指针的本质就是一种特殊的变量类型，指针本身就是一种变量。

​ 利用int类型的指针，可以操作int类型的数据，int类型占4个字节，所以int类型的指针操作的也是4个字节的内存。

//指针语法
数据类型* 变量名称;           //数据类型解决指针内存大小的问题

//示例
int* pStudentId;

#include <iostream>

int main()
{
    int* a{ };   //声明一个int类型的指针,指针指向的是内存地址
    std::cout << a;
}

4）指针的其他声明方法

//指针声明
数据类型 *变量名称;

//示例
int *pStudentId;          //*号靠近变量名

int* a{},b;        //a是int类型的指针，b是int类型的变量
int *a{},*b;       //a和b都是int类型的指针

//指针声明建议方式：多个指针分开写
int* a;
int* b;

5）取址运算符（读取内存地址）

​ 既然指针是用来操作内存的，那么如何获得一个变量的内存地址呢？可以通过取值运算符&获取变量的地址。取值运算符&是一个一元运算符，用于获取变量的地址，也可称为引用运算符。

#include <iostream>

int main()
{
    int a = 500;
    int* pa{ &a };   //声明一个int类型的指针pa，将a的地址赋值给指针pa
    std::cout << pa;  //输出a内存地址00F9FA98
}
//注：局部变量，每一次运行程序，内存地址是会发生变化的

6）间接运算符（操作内存地址）

​ 通过取值运算符&可以获取到变量的内存地址，通过间接运算符*可以操作内存地址。

通过地址来操作内存空间，虽然效果一样，但是原理不一样

//间接运算符*
#include <iostream>

int main()
{
    int a = 500;
    int* pa{ &a };   //声明一个int类型的指针pa，将a的地址赋值给指针pa
    //pa=0x5000      //表示修改a的内存地址

    std::cout << "a的内存地址为：" << pa << std::endl;

    *pa = 1000;      //在变量a的内存空间中写入1000（修改a的内存空间），即修改变量a的值

    std::cout << "a的值为：" << a << std::endl;  //输出a的值为1000
}  
    
    
// *pa可以当作来用，*pa是直接操作变量的内存空间；直接修改a的值，是通过操作系统来修改a的值，本质不同。
   

7）指针声明、取值及操作示例

//指针声明、取值及操作示例
#include <iostream>

int main()
{
    int a{ 5000 };         //声明一个int类型的指针,并初始化为空指针
    int* pa{ &a };         //pa等于a的内存地址      
    std::cout << "a的内存地址:" << pa << std::endl << "a的初始值：" << *pa << std::endl;

    *pa = 1000;         //通过内存修改值
    std::cout << "修改后a的值：" << *pa << std::endl;;
    std::cout << "++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
    char c = 65;
    char* pc = &c;
    std::cout << *pc << std::endl;
    (*pc)++;     //要对指针进行++,需要使用括号
    std::cout << *pc << std::endl;
}

2、指针数组

​ 要深刻理解，指针的本质起始就是一种特殊的变量类型，因此指针也可以通过数组的方式声明。对变量可以操作什么，那么对指针就能够操作什么

1）指针数组的声明

//指针数组的声明语法
int* ptrArray[10];       //即什么10个int类型的指针

2）指针数组的使用

#include <iostream>

int main()
{
	int studentId[5]{ 1001,1002,1003,1004,1005 };
	//取数数组中每个元素的内存地址，查看是否连续
	int* ptrStudentId[5]{};
	for (int i = 0; i < 5; i++)
	{
		ptrStudentId[i] = &studentId[i];   //指针数组的小标即对应数组的小标
		std::cout << "第" << i << "个元素的内存地址为" << ptrStudentId[i] <<"，值为" <<studentId[i]<< std::endl;
	}

}

2）指针二维数组

#include <iostream>

int main()
{	
	int studentId[2][2]
	{
		{1001,1002},
		{2001,2002}
	};
	int* ptrStudent[2][2];          //声明一个二维数组指针
	for (int x = 0; x < 2; x++)
	{
		for (int y = 0; y < 2; y++)
		{
			ptrStudent[x][y] = &studentId[x][y];      #使指针获取到二维数组的地址
			std::cout << "内存地址：" << ptrStudent[x][y] << "  值：" << *ptrStudent[x][y] << std::endl;
		}
	}
}

3、指针补充

1）指针的大小

​ 指针也是一种特别的数据类型，也是一个变量，因此也需要内存空间来存放指针。

​ 指针的本质是一个内存地址，而内存地址的本质是一个整数。为了能够完美表达内存地址，不管是什么类型的指针，在32位操作系统下指针的大小都为4个字节，64位操作系统下为8字节，即需要4个字节来存放指针

//可以通过sizeof()计算指针的大小
#include <iostream>

int main()
{
	int a{ 100 };
	int* ptr{ &a };
	char ch{ 65 };
	char* ctr{ &ch };
	std::cout << sizeof(ptr) << "\n";   //输出4
	std::cout << sizeof(ctr) << "\n";	//输出4
}

//在x86和x64操作系统下，指针的大小不同

2）指针的类型转化

​ 不能将一个类型的地址赋值给另外一个类型的指针。只要是指针，就说明是一个内存地址，就可以进行类型转化


类型的意义在于告诉编译器，同样的一个地址，显示的结果不同，在于变量的类型，如果是int类型的指针，显示内容时，按照int的规则进行处理

#include <iostream>

int main()
{
	 int      a{ 9999 };
	 unsigned b{ 9999 };

	int* ptra{ &a };

	//ptra = &b;     //&b是一个地址，说明就是一个整数，整数就可进行数据类型转化
	ptra =(int*)&b; //对&b进行地址转化，转化为int类型的指针

	std::cout <<"b的初始值为：" << b << std::endl;

	*ptra = 5200;
	std::cout << "通过间接运算符修改后，b的值为：" << b << std::endl;
	std::cout << "通过间接运算符修改后，b的值为：" << *ptra << std::endl;
	std::cout << std::endl;
	*ptra = -1;
	std::cout << "通过间接运算符修改后，b的值为：" << b << std::endl;  //b的类型为unsigned，所以输出的为正数
	std::cout << "通过间接运算符修改后，b的值为：" << *ptra << std::endl; //*ptra的类型的int型指针，所以输入为-1
	//同一个内存地址，但是因为数据类型的不同，输出的值也不同

	char* ctr{};
	ctr = (char*)ptra;

	//A的16进制为41，而char类型，只能够修改指针中的一个字节，其他字节的值无法修改，即0xFFFFFF41，转化为10进制为4294967105
	*ctr = 'A';
	std::cout << "转化为char类型指针后b的值为：" << b << std::endl;  

}

4、指针的计算

//指针的计算
int a[]{1001,1002,1003,1004,1005};
int* ptr{&a[0]};
计算(*ptr)++和*ptr++的结果?    //*ptr++相当于*(ptr++)  
(*ptr)++ 相当于a[0]++,即1001+1==1002

#include <iostream>

int main()
{
	int a[]{ 1001,1002,1003,1004,1005 };
	int* ptr{ &a[0] };

	std::cout << ptr << std::endl;
	std::cout << *ptr << std::endl;
	(*ptr)++;                       //*ptr即a的值，即将a的值+1，即1002
	std::cout << ptr << std::endl;
	std::cout << *ptr << std::endl;
	*ptr++;          //++的优先级高，即先ptr++，即地址进行++，地址++,一次增加数据类型的长度
	std::cout << ptr << std::endl;
	std::cout << &a[1] << std::endl;     //ptr+1指向了数组的下一个元素的起始地址
	std::cout << *ptr << std::endl;
	//指针+1的时候，数值的变化是+1*指针类型的大小
}

5、指针的指针

//指针的指针
int a[]{1001,1002,1003,1004,1005};
int* ptr{&a[0]};
如何表示ptr指针的内存？

注：ptr是一个int类型的指针，因此ptr是一个变量，在32位操作系统下占用4个字节内存，因此ptr也有地址

//指针的指针示例
#include <iostream>

int main()
{
	int a[]{ 1001,1002,1003,1004,1005 };
	int* ptr{ &a[0] };
	int** pptr{ &ptr };   //指针的指针，取指针ptr的地址

	std::cout <<"a的地址:" << ptr << std::endl;
	std::cout  <<"通过地址取a的值：" << *ptr << std::endl;
	std::cout <<"取a的指针的地址:" << pptr << std::endl;
	std::cout <<"取a的指针的值:" << *pptr << std::endl;   //是一个地址
	std::cout <<"取a指针的值（地址）的值:" << **pptr << std::endl;

	std::cout << "++++++++++++++++++++++++++++++++\n";
	*pptr = &a[1];
	std::cout << *ptr << std::endl;

}

{{uploading-image-986560.png(uploading...)}

多级指针

代码	值	内存地址
int a{500};	500	0x50000
int* ptr{&a};	0x50000	0x50100
int** pptr(&ptr)	0x50100	0x50200
int*** ppptr	0x50200	0x50300

6、常量指针、指针常量、指向常量对象的常量指针

1）常量指针

​ 所谓的常量指针，即这个指针指向一个常量的内存地址，常量指针中，不能对其指向的内存地址进行改变，但是指针指向的地址可以改变

//常量指针语法
const 变量类型* 变量名{&常量名}

//示例
int const a{1000};
int const b{1500};
const int*  ptrA{&a};

ptrA = &b;          //正确，可以修改常量指针的指向
*ptrA = 500;        //错误，不可以修改常量指针内存中的地址

//常量指针示例
#include <iostream>

int main()
{
	const int a{ 1000 };
	const int b{ 2000 };
	const int* ptr{ &a };   //常量指针 
	std::cout << ptr << std::endl;;
	//*ptr = 9000;   //错误，当指针指向常量时，不可以修改内存地址里的值
	ptr = &b;      //但是可以修改常量指针的指向 
	std::cout << ptr << std::endl;
}
//注：常量指针可以修改指向，但是不可以修改内存里的值

2）指针常量

​ 所谓的指针常量，即这个指针变量是一个常量，一旦初始化就不可以再指向其它内存地址，但是内存地址里的数据可以读写。(即指针是一个常量)

//指针常量语法
变量类型* const

//示例
int const a{1000};
int const b{1500};
int* const ptrA{&a};

ptrA = &b;          //错误，不可以修改常量指针的指向
*ptrA = 500;        //正确，可以修改常量指针内存中的值

//指针常量示例
#include <iostream>

int main()
{
	int a{ 1000 };
	int b{ 2000 };
	int* const ptr{ &a };   //指针常量，const修饰的是ptr
	std::cout << *ptr << std::endl;;
	//ptr = &b;   //错误，指针指向的内存空间不可以修改
	*ptr = 9000;  //正确，可以修改内存空间的值
	std::cout << a << std::endl;  
}

3）指向常量的常量指针

​ 指向常量的常量指针，即这个指针变量是一个常量，一旦初始化就不可以再指向其他内存地址，因为其本事就是一个指向常量的指针，所以其执行的内存区域也不可以修改。

//指向常量的常量指针语法
const 变量类型* const

//示例
int const a{1000};
int const b{1500};
const int*  ptrA{&a};

ptrA = &b;          //错误，不可以修改常量指针的指向
*ptrA = 500;        //错误，不可以修改常量指针内存中的值

//指向常量的常量指针示例
#include <iostream>

int main()
{
	const int a{ 1000 };
	const int b{ 2000 };
	const int* const ptr{ &a };

	//ptr = &b;           //错误，不允许修改内存地址的指向
	//*ptr = 9999;        //错误，不允许修改内存地址的值

	std::cout << *ptr << std::endl;
}

7、项目：通过指针实现游戏技能

需求：设计麟江湖的技能释放模型，要求用户按下相应技能快捷键后开始释放技能，技能数据如下，假设角色的当前等级下最高内力为1000，最高生命为3000，基础攻击力为50

快捷键	技能名称	技能效果
1	治愈	消耗100内力，生命值恢复最大生命值的10%
2	金刚掌	消耗50内力，对远程目标造成基础攻击+50点伤害
3	麻痹数	消耗50内力，禁止目标攻击三个回合
4	鹰抓功	10个回合内，对目标造成伤害将恢复伤害量20%的内力伤害量60%的生命
5	绝处逢生	消耗100内力，对目标造成基础攻击+已损失血量的伤害
6	易筋经	消耗300内力，将内力和生命值进行互换，攻击力提高1000%

#include <iostream>
#include <conio.h>

struct Role
{
	int Hp;
	int maxHp;
	int Mp;
	int maxMp;
	int act; //攻击力
	int cantact; //禁止攻击
	int bufcount; //回合
	bool cant;
};
int main()
{
	int inkey, damage;  //damage表示角色造成的伤害
	Role user{ 3000,3000,1000,1000,50,0,false };
	Role boss{ 30000,30000,1000,1000,190,0,false };

	//结构体中的变量，也可以通过指针表示
	int* pUserHp = &user.Hp;
	int* pBossHp = &boss.Hp;
lfight:
	system("cls");
	printf("玩家生命[%d  /  %d]  BOSS生命[%d  /  %d]\n", user.Hp, user.maxHp, *pBossHp, boss.maxHp);
	printf("玩家内力[%d  /  %d]  攻击力[%d]\n", user.Mp, user.maxMp, user.act);
	printf("请输入你的技能:");

	inkey = _getch();
	damage = 0;
	switch (inkey)
	{
	case 49:
		if (user.Mp > 99)
		{
			user.Mp -= 100;
			user.Hp += 300;
			user.Hp = user.Hp > user.maxHp ? user.maxHp : user.Hp;  //如果用户生命值大于最大生命值，则显示最大生命值
		}
		break;
	case 50:
		if (user.Mp >= 50)
		{
			user.Mp -= 50;
			*pBossHp -= 50 + user.act;
		}
		break;
	case 51:
		if (user.Mp >= 50)
		{
			user.Mp -= 50;
			boss.cantact = 3;  //禁止攻击三次
		}
		break;
	case 52:
		user.bufcount = 10;
		break;
	case 53:
		if (user.Mp >= 100)
		{
			user.Mp -= 100;
			damage = user.maxHp - user.Hp + user.act;
		}
		break;
	case 54:
		if ((user.Mp >= 300) && (!user.cant))
		{
			int ls = user.maxHp;
			user.maxHp = user.maxMp;
			user.maxMp = ls;
			ls = user.Hp;
			user.Hp = user.Mp;
			user.Mp = ls;
			user.act *= 10;
			user.cant = true;        //此技能使用过一次后，不允许再使用
		}
		break;
	}

	if (boss.cantact > 0)
	{
		boss.cantact--;
	}
	else user.Hp -= boss.act;
	*pBossHp -= damage;
	if (user.bufcount > 0)
	{
		user.bufcount--;   //在4技能后，bufcount设置为了10，在10以内重新计算角色伤害
		user.Hp += (int)(damage * 0.6);
		user.Mp += int(damage * 0.2);
		user.Hp = user.Hp > user.maxHp ? user.maxHp : user.Hp;
		user.Mp = user.Mp > user.maxMp ? user.maxMp : user.Mp;
	}
	if (user.Hp < 1)
	{
		system("cls");
		printf("你死了，游戏结束！！");
	}
	else if (*pBossHp < 1)
	{
		system("cls");
		printf("击败BOSS，游戏结束！！");
	}
	else goto lfight;
}