结构体
1.1 结构体基本概念
结构体属于用户 自定义的数据类型， 允许用户存储不同的数据类型
1.2 结构体定义和使用(cpp23.cpp)
语法：struct 结构体名{结构体成员列表};
通过结构体创建变量的方式有三种：
- struct 结构体名 变量名
- struct 结构体名 变量名 = {成员1值，成员2值，...}
- 定义结构体时顺便创建变量
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
using namespace std;
//定义结构体，定义结构体时 struct 关键字 不能省略
struct Student
{ //以下是 结构体属性 //姓名 string name;
//年龄 int age;
//性别 string gender;
//分数 double score;
}s3;
int main()
{
//1、struct 结构体名 变量名
//使用结构体时，struct 关键字 可以省略
struct Student s1;
s1.name = "张三";
s1.age = 18;
s1.gender = "男";
s1.score = 100;
cout << "姓名：" << s1.name << "性别：" << s1.gender << "年龄：" << s1.age << "分数：" << s1.score << endl;
//2、struct 结构体名 变量名 = { 成员1值，成员2值，... } //使用结构体时，struct 关键字 可以省略
struct Student s2 = { "李四",20,"男",100 };
cout << "姓名：" << s2.name << "性别：" << s2.gender << "年龄：" << s2.age << "分数：" << s2.score << endl;
//3、定义结构体时顺便创建变量
s3.name = "王五";
s3.gender = "女";
s3.age = 19;
s3.score = 100;
cout << "姓名：" << s3.name << "性别：" << s3.gender << "年龄：" << s3.age << "分数：" << s3.score << endl;
return 0;
}
1.3 结构体数组
作用：将自定义的结构体放入到数组中方便维护
语法：struct 结构体名 数组名[元素个数] = {结构体1,结构体2,...};
使用 结构体数组 时，struct 关键字可以省略
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
using namespace std;
struct Student
{
string name;
string gender;
int age;
int score;
};
int main()
{
Student s1 = { "张三","男",10,30 };
Student s2 = { "孙琪","男",10,30 };
Student s3 = { "赵六","男",10,30 };
Student s4 = { "王五","男",10,30 };
Student s5 = { "李四","男",10,30 };
//使用 结构体数组 时 struct 关键字 可以省略
struct Student students[] = { s1,s2,s3,s4,s5 };
int length = sizeof(students) / sizeof(students[0]);
for (int i = 0; i < length; i )
{
cout << "姓名：" << students[i].name << "性别：" << students[i].gender << "年龄：" << students[i].age << "分数：" << students[i].score << endl;
}
return 0;
}
1.4 结构体指针（cpp24.cpp）
|当同一个结构体 的 两个变量的属性值 全部一样时，这两个变量 指向 同一个 内存地址
|一个结构体的 变量 的 各个属性 存放于 不同的内存地址
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
using namespace std;
struct Student
{ string name;
string gender;
int age;
int score;
};
int main()
{
Student s1 = { "张三","男",10,30 };
Student s2 = { "孙琪","男",10,30 };
Student s3 = { "赵六","男",10,30 };
Student s4 = { "王五","男",10,30 };
Student s5 = { "李四","男",10,30 };
//使用 结构体数组 时 struct 关键字 可以省略
struct Student students[] = { s1,s2,s3,s4,s5 };
int length = sizeof(students) / sizeof(students[0]);
//struct 关键字 可以省略 //常量指针，指针指向的值不能修改，但是指针的指向可以修改
const struct Student* p = students;
for (int i = 0; i < length; i )
{
//打印这个对象的 各个属性的 内存地址
cout << "地址值：" << "姓名：" << &p->name << "性别：" << &p->gender << "年龄：" << &p->age << "分数：" << &p->score << endl;
//打印这个对象的 各个属性的 值
cout << "姓名：" << p->name << "性别：" << p->gender << "年龄：" << p->age << "分数：" << p->score << endl;
p = &students[i];
}
//我们定义的s1 和 s2 的属性完全相同，通过如下 输出结果 我们可以看到 s1 和 s2 指向 同一个 内存地址;同时我们可以看到，结构体中的各个属性 都存放于 不同的内存地址中
/* 地址值：姓名：00000088A01CF390 性别：00000088A01CF3B8 年龄：00000088A01CF3E0 分数：00000088A01CF3E4 姓名：张三性别：男年龄：10分数：30 地址值：姓名：00000088A01CF390 性别：00000088A01CF3B8 年龄：00000088A01CF3E0 分数：00000088A01CF3E4 姓名：张三性别：男年龄：10分数：30 地址值：姓名：00000088A01CF3E8 性别：00000088A01CF410 年龄：00000088A01CF438 分数：00000088A01CF43C 姓名：孙琪性别：男年龄：10分数：30 地址值：姓名：00000088A01CF440 性别：00000088A01CF468 年龄：00000088A01CF490 分数：00000088A01CF494 姓名：赵六性别：男年龄：10分数：30 地址值：姓名：00000088A01CF498 性别：00000088A01CF4C0 年龄：00000088A01CF4E8 分数：00000088A01CF4EC 姓名：王五性别：男年龄：10分数：30 */
return 0;
}
1.5 结构体嵌套结构体（cpp25.cpp）
作用：结构体中的成员可以是另一个结构体
例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体；
1.6 结构体做函数参数（cpp33.cpp）
作用：将结构体作为参数向函数中传递
函数中使用指针作为形参的好处：1、可以减少内存空间；2、不会复制新的副本出来
传递的方式由两种：
值传递 值传递不会影响实参
地址传递 地址传递可以影响实参
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
struct Student
{
string name;
string gender;
int age;
int score;
};
//值传递 void printStudent(struct Student s)
{
cout << "学生姓名：" << s.name << " 学生性别： " << s.gender << " 学生年龄：" << s.age << " 学生成绩：" << s.score << endl;
s.name = "王五";
s.gender = "nan";
cout << "地址传递修改后:" << endl;
}
//地址传递
void printStudentAddress(Student* p)
{
cout << "学生姓名：" << p->name << " 学生性别： " << p->gender << " 学生年龄：" << p->age << " 学生成绩：" << p->score << endl;
p->name = "李四";
p->age = 100;
p->gender = "nv"; p->score = 300;
cout << "地址传递修改后:" << endl;
}
int main()
{
//结构体作函数参数
//将学生传入到一个参数中，打印学生身上的所有信息
//创建一个结构体变量
struct Student s;
s.name = "张三";
s.gender = "男";
s.age = 20;
s.score = 100;
printStudent(s);
//值传递不会影响实参
//printStudentAddress(&s);
//地址传递会影响实参
cout << "学生姓名：" << s.name << " 学生性别： " << s.gender << " 学生年龄：" << s.age << " 学生成绩：" << s.score << endl;
return 0;
}
1.7 结构体中const使用场景（cpp34.cpp）
作用：用const来防止误操作
//将参数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
//使用const作用是，当我们只想读而不想修改时，可以防止误操作
void printStudentAddress(const Student* s)
{
p->name = "张三";
// 这里对指针形参进行const修饰后，就可以防止对 原学生 实参误操作，这里编译直接不能通过
}
int main()
{
//创建结构体变量
struct Student s = { "张三","男",10,10 };
Student* p = &s;
printStudentAddress(p);
//值传递不会影响实参
return 0;
}
1.8 结构体案例
1.8.1 案例1（cpp35.cpp）
案例描述：
学校正在做毕设项目，每名老师带领5个学生，总共3名老师，需求如下
设计学生和老师的结构体，其中在老师的结构体中，由老师姓名和一个存放5名学生的数组作为成员，学生的成员由姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值，最终打印出老师数据以及老师所带的学生数据。
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string> using namespace std;
struct Student
{
string name;
int score;
};
struct Teacher
{
string name;
Student stus[5];
};
void func(Teacher(*t)[3], int len)
{
for (int i = 0; i < len; i )
{
string t_name = "teacher_";
t_name = to_string(i);
(*t i)->name = t_name;
for (int j = 0; j < 5; j )
{
string s_name = "studetn_";
s_name = to_string(j);
(*t i)->stus[j].name = s_name;
//int rad = rand() % 61;
// 0 ~ 60
int rad = rand() % 61 40;
// 40 ~ 100
(*(*t i)).stus[j].score = rad;
}
}
}
void print(Teacher (* t)[3], int len)
{
for (int i = 0; i < len; i )
{
cout << "第" << i << "名老师的姓名:" << (*t i)->name;
for (int j = 0; j < 5; j )
{
cout << "学生姓名：" << (*t i)->stus[j].name << " 分数：" << (*t i)->stus[j].score << endl;
}
}
}
int main()
{
//创建3名老师的数组
Teacher t[3];
//通过函数给3名老师的属性赋值，并给3名老师所带的学生赋值
int length = sizeof(t) / sizeof(t[0]);
func(&t, length);
//打印出老师和他所带的学生的信息
print(&t, length);
return 0;
}
1.8.2 案例2（cpp40.cpp）
案例描述：
设计一个英雄的结构体，包括成员姓名，年龄，性别；创建结构体数组，数组中存放5名英雄。
通过冒泡排序的算法，将数组钟的英雄按照年龄进行升序排序，最终打印出排序后的结果。
struct hero
{
string name;
int age;
string gender;
};
void sort(hero * heros, int len)
{
for (int i = 0; i < len; i )
{
for (int j = i 1; j < len; j )
{
if (heros[i].age > heros[j].age)
{
hero temp = heros[i];
heros[i] = heros[j];
heros[j] = temp;
}
}
}
}
void print(hero heros[], int len)
{
for (int i = 0; i < len; i )
{
cout << "英雄姓名：" << heros[i].name << "英雄年龄：" << heros[i].age << "英雄性别：" << heros[i].gender << endl;
}
}
int main()
{
struct hero heros[5] = {
{"刘备",23,"男"},
{"关于",20,"男"},
{"张飞",15,"男"},
{"赵云",22,"男"},
{"貂蝉",23,"女"}
};
sort(heros, 5);
print(heros, 5);
return 0; }
融合 指针常量 和 常量指针，深入理解 指针常量 和 常量指针 在数组中的用法：
struct hero
{
string name;
int age;
string gender;
};
void sort(hero * heros, int len)
{
for (int i = 0; i < len; i )
{
for (int j = i 1; j < len; j )
{
if (heros[i].age > heros[j].age)
{
hero* const temp = &heros[j];
hero* const temp1 = &heros[i];
hero temp2 = *temp;
*temp = *temp1;
*temp1 = temp2;
//可以用指针常量，因为指针常量是在原指针位置不变的情况下，修改了值
/*const hero* temp = &heros[j];
//常量指针则是将指针对调了位置，但是对于数组而言，每个元素的值还是没有变化
const hero* temp1 = &heros[i];
hero temp2 = *temp;
temp = temp1;
temp1 = &temp2;*/
}
}
}
}
void print(hero heros[], int len)
{
for (int i = 0; i < len; i )
{
cout << "英雄姓名：" << heros[i].name << "英雄年龄：" << heros[i].age << "英雄性别：" << heros[i].gender << endl;
}
}
int main()
{
struct hero heros[5] = {
{"刘备",23,"男"},
{"关于",20,"男"},
{"张飞",15,"男"},
{"赵云",22,"男"},
{"貂蝉",23,"女"}
};
sort(heros, 5);
print(heros, 5);
return 0;
}
