[C++]指针与结构体

标题

一.指针
- 1.指针的定义和使用
- 2.指针所占的内存空间
- 3.空指针与野指针
- 4.const修饰指针
- 5.指针和数组
- 6.指针和函数
二.结构体
- 1.结构体的定义与使用
- 2.结构体数组
- 3.结构体指针
- 4.结构体的嵌套使用
- 5.结构体做函数参数
- 6.结构体中const使用场景
- 7.案例练习

一.指针

作用: 可以通过指针间接的访问一段内存
内存编号是从0开始记录的,一般用16进制的数字表示
可以利用指针变量保存地址

1.指针的定义和使用

定义
指针类型指针名;(指针类型指int *,float *等等)
使用:可以通过解引用的方法*来操作指针所指向的内存

#include <iostream>
using namespace std;int main() {int a = 12;// 定义指针： 数据类型 * 指针名；int * p;p = &a;  // &为取地址符号,可以取到a的地址cout << "&a = " << &a << endl;cout << " p = " << p << endl;  // 二者打印的内容相同,均为变量a的地址// 使用指针*p = 12345; // *代表解引用,可以通过它找到指针指向的内存中的数据cout << "*p = " << *p << endl;cout << " a = " << a << endl;  // 修改*p的值也间接的修改了变量a的值system("pause");return 0;
}

2.指针所占的内存空间

32位系统:不管什么类型的指针都占用4个字节空间
64位:8字节

可以在这里调整编译器编译时的32或64位选项

	int a = 99;int* p = &a;// 具体输出和操作系统有关cout << "sizeof(int *) = " << sizeof(p) << endl;cout << "sizeof(bool *) = " << sizeof(bool *) << endl;cout << "sizeof(char *) = " << sizeof(char *) << endl;cout << "sizeof(double *) = " << sizeof(double *) << endl;cout << "sizeof(long long *) = " << sizeof(long long *) << endl;

3.空指针与野指针

空指针:指向的内存编号为0的指针
用途:不知道指针的具体赋值时,进行指针的初始化
注意:空指针指向的内存是不可以被访问的!!!(0~255之间的内存编号是系统占用的,不能被访问)

这段代码在编写的时候没有问题,但是在编译运行的时候会报异常

#include <iostream>
using namespace std;int main() {int* p = NULL;int a = *p;system("pause");return 0;
}

野指针:指针变量指向了非法的内存空间

int * p = (int *)0x1100;
// 这里会报访问权限异常,因为这个地址就不是由你本人申请的!
int c = *p;

空指针与野指针,都不是我们申请的空间,请不要随意的访问它!!!!

4.const修饰指针

const修饰指针有三种情况:
1.const修饰指针—常量指针
2.const修饰常量—指针常量
3.const即修饰指针也修饰常量

5.指针和数组

可以利用指针访问数组内的元素

	int arr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };int* p = arr;  // 将这个指针指向数组的首地址cout << "指针访问第一个元素：" << *p << endl;  // 输出0/*// 如果需要用指针来访问第二个元素，需要让指针指向后移4个字节p++; // 自增已经可以让指针向后移动4字节cout << "第二个元素: " << *p << endl; // 输出1*/// 利用指针遍历数组元素for (int i = 0; i < size(arr); i++) {cout << "arr[" << i << "] = " << *p << endl;cout << "p = " << p << endl;cout << "&arr[" << i << "] = " << &arr[i] << endl;p++;}

6.指针和函数

利用指针作为函数的参数, 通过解引用可以修改实参的值!

#include <iostream>
using namespace std;void swap01(int* a, int* b);// 值传递,并不会改变传入的形参的值
void swap02(int a, int b) {int temp = a;a = b;b = temp;
}int main() {int a = 33;int b = 99;cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "值传递" << endl;swap02(a, b);// 不会改变传入的实参的值cout << "a = " << a << endl;  // 33cout << "b = " << b << endl;  // 99cout << "地址传递" << endl;swap01(&a, &b);// 可以看到这里的值已经被改变了cout << "a = " << a << endl; // 99cout << "b = " << b << endl; // 33system("pause");return 0;
}// 交换两个数的函数, 通过解引用的方式交换两个数
void swap01(int* a, int* b) {  // 把房间号传递过来了,可以借助房间号,改变房间里放的东西int temp = *a;*a = *b;*b = temp;
}

案例描述:实现一个函数,利用冒泡排序对整数数组进行降序排序

#include <iostream>
using namespace std;// 输出数组内容
void printArray(int* arr, int size) {for (int i = 0; i < size; i++) {cout << arr[i] << "\t";}cout << endl;
}// 冒泡排序
void bubbleSort(int* arr, int size) {for (int i = 0; i < size - 1; i++) {for (int j = 0; j < size - 1 - i; j++) {if (arr[j] < arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}int main() {int arr[] = { 9, 34, 56, 7, 123, 45, 67, 98, 33, 12, 55, 987, 11, -2 };int* arrP = arr; // arr就是数组的首地址bubbleSort(arr, size(arr));printArray(arr, size(arr));system("pause");return 0;
}

二.结构体

结构体属于用户自定义的数据类型, 允许用户存储不同的数据类型

1.结构体的定义与使用

语法struct 结构体名 { 结构体成员列表 };
通过结构体创建变量(使用结构体)的方式有三种:
1.struct 结构体名变量名;
2.struct 结构体名变量名 = { 成员值1, 成员值2... };
3.定义结构体是顺便创建变量

#include <iostream>
using namespace std;// 定义结构体
struct Student {string name;int age;double score;
} s0; // 创建结构体的时候顺便创建结构变量(不推荐)void printStudent(Student stu) {cout << "name: " << stu.name << " age: " << stu.age << " score: " << stu.score << endl;
}int main() {// 这种方式struct关键字能省略不写struct Student s1;s1.name = "叶子";s1.age = 18;s1.score = 100;printStudent(s1);// 按顺序填入结构体数据Student s2 = { "老黄", 25, 60 };printStudent(s2);// 创建的时候顺便创建的量s0.name = "YeZi";s0.age = 25;s0.score = 100;printStudent(s0);system("pause");return 0;
}

2.结构体数组

将自定义的结构体放入数组中方便维护
语法
struct 结构体名数组名[元素个数] = { {} , {}, ... {} }

#include <iostream>
using namespace std;struct Student {// 成员列表string name; // 姓名int age; // 年龄int score; // 分数
};int main() {// 结构体数组Student stus[3] = {{"叶子", 18, 100},{"老黄", 20, 99},{"罗磊", 21, 100}};// 遍历结构体数组for (int i = 0; i < size(stus); i++) {cout << "姓名:" << stus[i].name<< " 年龄:" << stus[i].age<< " 分数:" << stus[i].score << endl;}system("pause");return 0;
}

3.结构体指针

通过指针来访问结构体的元素
利用操作符->可以通过结构体指针访问结构体的属性

#include <iostream>
using namespace std;struct Student {// 成员列表string name; // 姓名int age; // 年龄int score; // 分数
};int main() {Student stu0 = { "老黄", 20, 99 };// 指针指向结构体变量Student* p = &stu0;// 通过指针访问结构体变量中的数据cout << "姓名: " << p->name << " 年龄: " << p->age << " 分数: " << p->score << endl;system("pause");return 0;
}

4.结构体的嵌套使用

结构体也可以结合实际情况嵌套使用

#include <iostream>
using namespace std;struct Student {// 成员列表string name; // 姓名int age; // 年龄int score; // 分数
};struct Teacher {string name;int age;Student stu;
};int main() {Teacher teacher = {"娟", 18, {"叶子", 18, 100}};cout << "老师姓名: " << teacher.name << " 老师年龄: " << teacher.age<< " 学生姓名: " << teacher.stu.name << " 学生年龄: " << teacher.stu.age << " 学生分数: " << teacher.stu.score << endl;system("pause");return 0;
}

5.结构体做函数参数

将结构体作为参数向函数中传递
方式有两种：
值传递
地址传递（形参修改影响实参的值）

#include <iostream>
using namespace std;struct Student {string name;int age;double score;
};// 输出函数，值传递不影响实参变量
void printStudent(Student stu, string tag) {cout <<"tag: " << tag << " name: " << stu.name << " age : " << stu.age << " score : " << stu.score << endl;
}// 值传递，在函数中修改结构体不会影响具体值
void printStudent1(Student stu) {stu.name = "luilui";stu.age = 20;stu.score = 99;printStudent(stu, "printStudent1");
}// 引用传递，函数中修改结构体会影响实参的值
void printStudent2(Student* ps) {ps -> name = "老黄";ps -> age = 20;ps -> score = 99;printStudent(*ps, "printStudent2");
}int main() {Student stu;stu.name = "叶子";stu.age = 18;stu.score = 100;cout << "值传递: " << endl;printStudent(stu, "main");printStudent1(stu);printStudent(stu, "main");  // 函数里修改了具体的值，但是值传递不影响实参结构体cout << "\n\n引用传递: " << endl;printStudent(stu, "main");printStudent2(&stu); // 取地址符，传入的是对应结构体的指针printStudent(stu, "main");  // 引用传递，函数里边的修改影响实参结构体system("pause");return 0;
}

6.结构体中const使用场景

作用：用const来防止误操作(可以结合前文中的常量指针进行理解)

示例：

#include <iostream>
using namespace std;struct Student {string name;int age;double score;
};// 3值传递时,会将实参复制给形参,数据量越大,占用的内存越多
void printStruct(Student stu) {cout << "name: " << stu.name << " age: " << stu.age << " score: " << stu.score << endl;
}// 4将函数中的形参改为指针,不会复制,所以会介绍内存空间的占用
void printStruct(const Student *stu) {  // 6加入const(常量指针)可以防止在形参修改,影响到实参的值// 5这样会留下一个隐患,地址传递时对形参指针的修改会影响到实参的值// stu->name = "老黄";  7加入const之后会报错,防止误操作cout << "name: " << stu->name << " age: " << stu->age << " score: " << stu->score << endl;
}int main() {//1创建结构体变量Student s = { "叶子", 18, 100.00 };//2通过函数打印结构体的信息printStruct(s);printStruct(&s);system("pause");return 0;
}

7.案例练习

案例1:

#include <iostream>
using namespace std;struct Student {string name;int score;
};struct Teacher {string name;Student stus[5];
};void input(Teacher* tchs, int sizeT) {for (int i = 0; i < sizeT; i++) {string name = "";cout << "请输入第" << i << "位老师的姓名:";cin >> name;tchs[i].name = name;cout << "开始录入 " << name << " 老师的学生们!" << endl;for (int j = 0; j < size(tchs[i].stus); j++) {string name = "";cout << "输入学生" << j << "的姓名:";cin >> name;tchs[i].stus[j].name = name;cout << "输入 " << name << " 的成绩:" << endl;int score = 0;cin >> score;tchs[i].stus[j].score = score;}}
}void input1(Teacher tchs[], int sizeT) {for (int i = 0; i < sizeT; i++) {string name = "";cout << "请输入第" << i << "位老师的姓名:";cin >> name;tchs[i].name = name;cout << "开始录入 " << name << " 老师的学生们!" << endl;for (int j = 0; j < size(tchs[i].stus); j++) {string name = "";cout << "输入学生" << j << "的姓名:";cin >> name;tchs[i].stus[j].name = name;cout << "输入 " << name << " 的成绩:" << endl;int score = 0;cin >> score;tchs[i].stus[j].score = score;}}
}void print(Teacher* tchs, int sizeT) {for (int i = 0; i < sizeT; i++) {cout << tchs[i].name << " 老师的学生信息:" << endl;for (int j = 0; j < size(tchs[i].stus); j++) {string name = "";cout << tchs[i].stus[j].name << " 的成绩是: " << tchs[i].stus[j].score << endl;}}}int main() {Teacher teachers[3];input(teachers, size(teachers));print(teachers, size(teachers));system("pause");return 0;
}

案例2

#include<iostream>
#include<ctime>
using namespace std;/*设计一个英雄的结构体，包括成员 姓名，年龄，性别创建结构体数组，数组中存放5名英雄。通过冒泡排序法将数组中的英雄按照年龄进行升序排序，打印最终结果。*/// 英雄结构体
struct Hero {string name;int age;string sex;
};// 随机获取英雄的年龄
int getRandAge() {int age = rand() % 51;if (age <= 21) { // 小于201岁重新获取return getRandAge();}return age;
}// 初始化英雄数据
void initHeroInfo(Hero heros[], int len) {srand((unsigned int)time(NULL));heros[0] = { "刘备", getRandAge(), "男"};heros[1] = { "关羽", getRandAge(), "男" };heros[2] = { "张飞", getRandAge(), "男" };heros[3] = { "赵云", getRandAge(), "男" };heros[4] = { "貂蝉", getRandAge(), "女" };heros[5] = { "西施", getRandAge(), "女" };}// 冒泡排序
void sortHeros(Hero *heros, int len) {for (int i = 0; i < len - 1; i++) {for (int j = 0; j < len - i - 1; j++) {if (heros[j].age > heros[j + 1].age) {Hero temp = heros[j];heros[j] = heros[j + 1];heros[j + 1] = temp;}}}
}// 打印英雄信息
void printHeros(const Hero *heros, int len) {for (int i = 0; i < len; i++) {cout << "姓名: " << heros[i].name << " 年龄: " << heros[i].age << " 性别: " << heros[i].sex << endl;}cout << endl;
}int main() {Hero heros[6];initHeroInfo(heros, size(heros));printHeros(heros, size(heros));sortHeros(heros, size(heros));printHeros(heros, size(heros));system("pause");return 0;
}