8.1结构体基本概念

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

8.2结构体定义和使用

定义语法：struct 结构体名 {结构体成员列表}；

通过结构体创建变量的方式有3种：

  • struct 结构体名 变量名
  • struct 结构体名 变量名 = { 成员1值 ，成员2值…}
  • 定义结构体时顺便创建变量

EXAMPLE：

  1. //1.创建学生数据类型 ： 学生包括（姓名，年龄，分数）
  2. //自定义数据类型，一些类型集合组成的一个类型
  3. //语法 struct 类型名称 { 成员列表 }
  4. struct student
  5. {
  6.     //成员列表
  8.     //姓名
  9.     string name;
  10.     //年龄
  11.     int age;
  12.     //分数
  13.     int score;
  15. }
  17. #include<string> 
  19. //2.通过学生类型创建具体学生
  20. int main()
  21. {
  23. //2.1 struct student s1
  24.     struct student s1;//struct关键字可以不写
  25.     //给s1属性赋值，通过，访问结构体变量中的属性
  26.     s1.name = "张三";
  27.     s1.age = 18;
  28.     s1.score =100;
  30.     cout<<"姓名： "<<s1.name
  31.         <<"年龄： "<<s1.age
  32.         <<"分数："<<s1.score<<endl;
  33.     //s1.name是string类型，输出string类型需要多一个头文件#include<string> 
  35. //2.2 struct student s2 = {...}
  36.     struct student s2 = {"李四" , 19 , 80};
  37.     cout<<"姓名： "<<s2.name
  38.         <<"年龄： "<<s2.age
  39.         <<"分数："<<s2.score<<endl;
  41. //2.3在定义结构体时顺便创建结构体变量（一般不建议使用）
  42.     //在定义结构体的时候，在括号}外边创建变量，比如：s3
  43.     //然后再给s3赋值
  44.     s3.name = "王五";
  45.     s3.age = 20;
  46.     s3.score =70;
  47.      cout<<"姓名： "<<s3.name
  48.          <<"年龄： "<<s3.age
  49.          <<"分数："<<s3.score<<endl;
  50. }

注意：结构体变量创建的时候struct可以省略
结构体定义的时候struct不可以省略
结构体变量利用操作符” . “访问成员

8.3结构体数组

作用：将自定义的结构体放入数组中方便维护
语法：struct 结构体名 数组名{元素个数} ={ { } ， { } ，…{ } }

EXAMPLE

  1. //定义结构体
  2. struct student
  3. {
  4.     //成员列表
  5.     string name; //姓名
  6.     int age;     //年龄
  7.     int score;   //分数
  8. }
  10. #include<string> 
  12. int main()
  13. {
  14.     //创建结构体数组
  15.     struct student arr[3] =
  16.     {
  17.         {"张三",18,90},
  18.         {"李四",19,78},
  19.         {"王五",23,90}
  20.     };
  22.     //给结构体数组中的元素赋值
  23.     arr[2].name="赵六";
  25.     //遍历结构体数组
  26.     for (int i = 0; i<3 ; i++)
  27.     {
  28.          cout<<"姓名： "<<arr[i].name
  29.              <<"年龄： "<<arr[i].age
  30.              <<"分数："<<arr[i].score<<endl;
  31.     }

结构体数组：

  1. 定义结构体
  2. 创建结构体数组
  3. 给结构体数组中的元素赋值
  4. 遍历结构体数组

8.4结构体指针

作用：通过指针访问结构体中的成员

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

EXAMPLE

  1. //定义结构体
  2. struct student
  3. {
  4.     //成员列表
  5.     string name; //姓名
  6.     int age;     //年龄
  7.     int score;   //分数
  8. }
  10. #include<string> 
  12. int main()
  13. {
  14.     //创建学生结构体变量
  15.     student stu = {"张三",18,90};
  16.     //通过指针指向结构体变量
  17.     student  * p = &stu;
  19.     //通过指针访问结构体变量中的数据
  20.      cout<<"姓名： "<<p->name
  21.          <<"年龄： "<<p->age
  22.          <<"分数："<<p->score<<endl;

8.5结构体嵌套结构体

作用：结构体的成员可以是另一个结构体
例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

EXAMPLE

  1. //定义学生结构体
  2. struct student
  3. {
  4.     //成员列表
  5.     string name; //姓名
  6.     int age;     //年龄
  7.     int score;   //分数
  8. }
  10. //定义教师结构体
  11. struct teacher
  12. {
  13.     //成员列表
  14.     int id;//职工编号
  15.     string name;//老师姓名
  16.     int age;//老师姓名
  17.     struct student stu;//辅导的学生
  18. }
  20. int main()
  21. {
  22.     //结构体嵌套结构体
  23.     //创建老师
  24.     teacher t;
  25.     t.id = 10000;
  26.     t.name = "老王"；
  27.     t.age = 50;
  28.     t.stu.name = "小王"；
  29.     t.stu.age = 20；
  30.     t.stu.score = 60；
  32.     cout<<"老师姓名： "<<t.name
  33.         <<"老师编号： "<<t.id
  34.         <<"老师年龄： "<<t.age
  35.         <<"老师辅导的学生姓名： "<<t.stu.name
  36.         <<"学生年龄： "<<t.stu.age
  37.         <<"学生考试分数： "<<t.stu.score <<endl;
  39. }

8.6结构体做函数参数

  • 值传递（形参不会改变实参）
  • 地址传递 （形参可以改变实参） ```cpp //定义学生结构体 struct student { //成员列表 string name; //姓名 int age; //年龄 int score; //分数 }

//打印学生信息的函数 //值传递 void print01(struct student s) { cout<<”姓名： “<<s.name <<”年龄： “<<s.age <<”分数：”<<s.score<<endl; }

//地址传递 //形参用指针，可以减少内存空间，不会复制新的副本出来 void print02(struct student * p) { cout<<”姓名： “<name <<”年龄： “<age <<”分数：”<score<<endl; } int main() { //将学生传入到一个参数中，打印学生身上的信息

  1. //创建结构体变量
  2. struct student s;
  3. s.name="张三";
  4. s.age=19
  5. s.score=85;
  7. print01(s)；
  8. print02(&s)；

}

  2. <a name="minU0"></a>
  3. # 8.7结构体中const使用场景
  4. 作用：用const来防止误操作<br />EXAMPLE:
  5. ```cpp
  6. #include <string>
  7. //定义学生结构体
  8. struct student
  9. {
  10.     //成员列表
  11.     string name; //姓名
  12.     int age;     //年龄
  13.     int score;   //分数
  14. }
  16. //有了const之后，一旦有修改的操作，就会报错，可以防止误操作
  17. void print(const student *s)
  18. {
  19.     cout<<"姓名： "<<s->name
  20.         <<"年龄： "<<s->age
  21.         <<"分数："<<s->score<<endl;
  22. }
  24. //const的使用场景
  25. int main()
  26. {
  27.     //创建结构体变量
  28.     struct student s ={"张三",15 ,78};
  30.     //通过函数打印结构体变量信息
  31.     print(&s);
  32. }

案例1

image.png