C++入门编程四(指针、结构体、const修饰指针(深度理解))

基于b站黑马c++视频做的笔记，仅供参考和复习！！！

指针的基本概念

指针的作用： 可以通过指针间接访问内存
指针中存放的数据是地址，通过地址即门牌号取址来找到对应的存储数据。

• 内存编号是从0开始记录的，一般用十六进制数字表示。
• 可以利用指针变量保存地址。

指针的进阶可以看看我的另一篇博文

	// 1 定义指针
	int a = 10;
	//指针定义的语法： 数据类型 * 指针变量名；
	
	int* p;		//变量名叫p，类型为int *，即整数类型的指针
	//char *q  代表字符类型的指针
	//让指针记录变量a的地址
	p = &a;
	cout << "a的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;

	//2 使用指针
	//可以通过解引用的方式来找到指针指向的内存
	// 指针前加 * 代表解引用，找打指针指向的内存中的数据
	*p = 100;
	cout << "a = " << a << endl;
	cout << "*p = " << *p << endl;

针所占内存空间

	//指针所占内存空间
	int a = 10;
	int* p = &a;
	cout << "sizeof (int *) = " << sizeof(p) << endl;
	cout << "sizeof (int *) = " << sizeof(int *) << endl;
	cout << "sizeof (float *) = " << sizeof(float *) << endl;
	cout << "sizeof (double *) = " << sizeof(double *) << endl;
	cout << "sizeof (char *) = " << sizeof(char *) << endl;

所有指针类型在32位操作系统下是4个字节，64位则是8个字节。

空指针和野指针

空指针：指针变量指向内存中编号为0的空间。用途：初始化指针变量。注意：空指针指向的内存是不可以访问的。
野指针：因为指针未被初始化，所以指针所指向的也是随机的，他是个野指针。

	//空指针
	//1 空指针用于给指针变量进行初始化
	//int* p = NULL;

	//2 空指针是不可以进行访问
	//0~255之间的内存编号是系统占用的，因此不可访问
	// *p = 100 是不可取的

	//野指针
	//在程序中，尽量避免出现野指针
	int* p = (int*)0x1100; //避免直接指向非法的内存空间

	cout << *p << endl;
	// 空指针和野指针都不是我们申请的空间，因此不要进行访问。

const修饰指针

很多人难以理解const修饰指针的情况，下面我用图解的方式来帮助大家理解，这样很容易会记住

int a = 10;
int *p = &a;

首先定义一个指针，指针指向的int类型的变量a，如下图所示。指针p的指向是可以改变的，即此时指针可以通过赋值操作指向其他地方。

1、const int * p = &a，如图，const修饰的是int类型，即表明int a这个变量是不可以改变的，那么指针的指向不受影响，可以改变。
2、int* const p =&a，如图，const修饰的是指针，即表明指针指向的那个箭头是不可以改变的，对于int类型的变量a里的值就可以改变。

	int a = 10;
	int b = 20;
	//常量指针
	const int * p1 = &a;
	//*p1 = 20; 错误
	p1 = &b; //指针的指向可以修改

	//指针常量
	//特点： 指针的指向不可以修改，指针指向的值指可以改
	int* const p2 = &b;
	*p2 = 30; //指针指向的值可以改

	//const即修饰指针和常量
	//特点： 指针的指向和指针指向的值都不可以改
	const int* const p3 = &a;

指针和数组

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	cout << "第一个元素为：" << arr[0] << endl;

	int* p = arr; 			//arr就是数组地址
	cout << "指针访问第一个元素为：" << *p << endl;
	p++; 					//让指针向后偏移4个字节 p里面的地址++
	cout << "指针访问第二个元素为：" << *p << endl;

	cout << "利用指针遍历数组" << endl;
	int* p1 = arr;
	for (int i = 0; i < 10; i++){
		cout << *p1 << endl;
		p1++;				//实质是 p1+1*sizeof（int）
	}

指针和函数

void swap01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
}
void swap02(int *p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main()
{
	//指针和函数
    //1 值传递
	int a = 10;
	int b = 20;
	swap01(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	//2 地址传递
	int c = 10;
	int d = 20;
	swap02(&c, &d);//如果是地址传递，可以修改实参
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;

	system("pause");
	return 0;
}

其中，地址传递时，首先系统分别位c，d开辟内存。而传入参数时，系统为p1和p2指针变量开辟空间，里面存放的时c和d的地址值。

指针、数组、函数结合案例

封装一个函数，利用冒泡排序，实现对整型数组的升序排序。例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 }。

//冒泡排序函数 参数1 数字的首地址 参数2 数组长度
void bubbleSort(int *arr, int len)
{
	for (int i = 0; i < len - 1; i++){
		for (int j = 0; j < len - i - 1; j++){
			if (arr[j] > arr[j+1]){
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组
void printArray(int* arr, int len)
{
	cout << "排序后---------------" << endl;
	for (int i = 0; i < len; i++){
		cout << arr[i] << " ";
	}
}

int main()
{
	int arr[10] = { 2,4,6,5,10,7,1,3,8,9 };
	int* p = arr;

	cout << "排序前---------------" << endl;
	for(int i = 0; i< 10; i++){
		cout << arr[i] << " ";
	}
	cout << endl;
	//数组长度
	int len = sizeof(arr) / sizeof(arr[0]);
	bubbleSort(arr, len);
	printArray(arr, len);
	
	cout << endl;
	return 0;
}

结构体的定义和使用

语法 struct 类型名称 {成员列表}；

//1 创建学生数据类型 结构体定义
//自定义数据类型，一些类型数据集合组成的一个类型
//语法 struct 类型名称 {成员列表}
struct Student
{
	string name; //姓名
	int age;		//年龄
	int score;  //分数

}s3; //顺便创建结构体变量名

//2 通过学生类型创建具体学生  三种赋值方式

	//2.1 struct Student s1
	//结构体变量创建时struct关键字可以省略
	Student s1;//结构体变量命名为s1
	//成员赋值
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;
	
	cout << "姓名：" << s1.name << " 年龄：" << s1.age << " 分数：" << s1.score << endl;

	//2.2 struct Student s2 = {...}
	struct Student s2 = { "李四", 20, 80 }; 		//struct可省略
	cout << "姓名：" << s2.name << " 年龄：" << s2.age << " 分数：" << s2.score << endl;

	//2.3 在定义结构体时顺便创建结构体变量
	s3.name = "王五";
	s3.age = 22;
	s3.score = 70;
	cout << "姓名：" << s3.name << " 年龄：" << s3.age << " 分数：" << s3.score << endl;

结构体数组

struct Student
{
	string name; //姓名
	int age;		//年龄
	int score;  //分数

};

	//创建结构体数组
	struct Student stuArray[3] =
	{
		{"张三", 18, 100}, //初始化赋值
		{"李四", 20, 90},
		{"王五", 22,80},  
	};

	//给结构体数组中的元素赋值
	stuArray[2].name = "赵六";
	stuArray[2].age = 80;

	//遍历结构体数组
	for (int i = 0; i < 3; i++){
		cout << "姓名：" << stuArray[i].name << " 年龄：" << stuArray[i].age << " 分数：" << stuArray[i].score << endl;
	}

结构体指针

作用：通过指针访问结构体中的成员。利用操作符 -> 可以通过结构体指针访问结构体属性。
struct student * p = &s 定义结构体类型的指针 类比于int* p = &a。

//定义学生结构体
struct student
{
	string name; //姓名
	int age; //年龄
	int score; //分数
};

	//1 创建学生结构体变量
	struct student s = { "张三", 18, 100 };

	//2 通过指针指向结构体变量
	struct student * p = &s;

	//3 通过指针访问结构体变量中的数据
	//通过结构体指针 访问结构体中的属性， 需要利用‘->’
	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;

结构体嵌套结构体

//定义学生结构体
struct student
{
	string name; //姓名
	int age; //年龄
	int score; //分数
};

//定义老师结构体
struct teacher
{
	int id;	//教师编号
	string name; //教师姓名
	int age; //年龄
	struct student stu; //辅导学生
};

int main()
{
	//结构体嵌套结构体
	//创建老师
	teacher t;
	t.id = 10086;
	t.name = "老王";
	t.age = 60;
	t.stu.name = "小王";

	cout << "老师姓名：" << t.name << endl << "老师辅导的学生姓名：" << t.stu.name << endl;
	
	system("pause");
	return 0;
}

结构体做函数参数

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

//定义学生结构体
struct student
{
	string name; //姓名
	int age; //年龄
	int score; //分数
};

//打印学生信息
//1 值传递
void printStudent1(struct student s1)
{
	cout << "子函数中打印 姓名：" << s1.name << " 年龄 " << s1.age << " 分数 " << s1.score << endl;
}

//2 地址传递
void printStudent2(struct student *p)
{
	p->name = "李四";
	cout << "子函数中打印 姓名：" << p->name << " 年龄 " << p->age << " 分数 " << p->score << endl;
}

	student s;//结构体变量命名
	s.name = "张三";
	s.age = 18;
	s.score = 85;

	printStudent1(s);
	printStudent2(&s);
	//cout << "main函数中打印 姓名：" << s.name << " 年龄 " << s.age << " 分数 " << s.score << endl;

结构体中 const使用场景

//定义学生结构体
struct student
{
	string name; //姓名
	int age; //年龄
	int score; //分数
};

//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent(const student *p)
{
	//p->age = 100; //加入const之后，一旦修改就会报错，防止误操作
	cout << "姓名：" << p->name << " 年龄 " << p->age << " 分数 " << p->score << endl;
}

int main()
{
	struct student s = { "李四", 20, 80 };
	printStudent(&s);

	system("pause");
	return 0;
}

结构体案例

案例1

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下：
设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员。学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值。最终打印出老师数据以及老师所带的学生数据。

案例2

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。
案例汇总地址可查看相应代码