结构体

  • 结构体类型的声明
  • 结构体初始化
  • 结构体成员访问
  • 结构体传参

现实生活中的对象大多是复杂对象，我们用简单的int,float,double是没办法描述的

结构体的声明

结构的基础支持

结构式一些值的集合，这些值称为成员变量，结构的每个成员可以是不同类型的变量

结构的声明
语法

  1. struct/*关键字*/ tag/*结构体标签,自定义*/{
  2.     member-list/*被称为成员变量(成员列表)*/;
  3. }variable-list/*变量列表*/;
  1. struct tag{
  2.     member-list;
  3. }variable-list;

例如描述一个学生

  1. typedef struct Stu{
  2.     char name[20];//名字
  3.     int age;//年龄
  4.     char sex[5];//性别
  5.     char id[20];//学号
  6. }Stu;

结构体创建

  1. /*StuOne.c -- 以学生为例的结构体*/
  2. #include "stdio.h"
  4. //描述一个学生
  5. /**
  6.  * 名字
  7.  * 年龄
  8.  * 电话
  9.  * 性别
  10.  */
  11. /**
  12.  * struct: 结构体关键字
  13.  * Stu: 结构体标签
  14.  * struct Stu: 结构体类型
  15.  */
  16. struct Stu{
  17.     //成员变量
  18.     char name[60];
  19.     short age;
  20.     char tele[12];
  21.     char sex[5];
  22. };
  24. int main(){
  25.     return 0;
  26. }

结构体变量创建

  1. int main(){
  2.     struct Stu s; //局部的结构体变量
  3.     return 0;
  4. }

类型->图纸

  1. struct Stu{
  2.     //成员变量
  3.     char name[60];
  4.     short age;
  5.     char tele[12];
  6.     char sex[5];
  7. }s1,s2,s3;//s1,s2,s3是三个全局结构体的变量(不建议,原因: 尽量少用使用全局变量)

typedef

  1. typedef struct Stu{
  2.     //成员变量
  3.     char name[60];
  4.     short age;
  5.     char tele[12];
  6.     char sex[5];
  7. }Stu;
  • typedef: 把struct结构体类型重新起名字(这里是重起了Stu)
  1. int main(){
  2.     //struct Stu s; //局部的结构体变量
  3.     Stu s1; //使用了typedef可以这样写
  4.     return 0;
  5. }

结构体的类型

结构的成员可以是标量(普通变量)、数组、指针，甚至可以是其他结构体。

数组里面放数据用大括号，结构体里面发数据也是用大括号

  1. typedef struct Stu{
  2.     //成员变量
  3.     char name[60];
  4.     short age;
  5.     char tele[12];
  6.     char sex[5];
  7. }Stu;
  9. int main(){
  10.     Stu s1 = {"张三",20,"15637","男"};//局部变量
  11.     struct s2 = {"李四",20,"135728","保密"};
  12. }
  1. /*StuTwo.c -- 结构体成员类型*/
  2. #include "stdio.h"
  4. struct S{
  5.     int a;
  6.     char c;
  7.     char arr[20];
  8.     double d;
  9. };
  11. struct T{
  12.     char ch[10];
  13.     struct S s;
  14.     char* pc;
  16. };
  19. int main(){
  20.     char arr[] = "hello bit";
  21.     struct T t = {"hehe",{100,'w',"hello world",3.14},arr};//初始化赋值
  22.     printf("%s\n",t.ch); //打印结构体中的数据
  23.     printf("%s\n",t.s.arr); //打印结构体中的结构体中的数据
  24.     printf("%lf\n",t.s.d);
  25.     printf("%s\n",t.pc);
  27.     return 0;
  28. }

注: 俩个arr互不影响,不同范围的变量互不干扰互不影响

  1. /*StuThree.c -- 常规写法*/
  2. #include "stdio.h"
  4. typedef struct Stu{
  5.     //成员变量
  6.     char name[20];
  7.     short age;
  8.     char tele[12];
  9.     char sex[5];
  10. }Stu;
  12. void Print1(Stu tmp){
  13.     printf("name:%s\n",tmp.name);
  14.     printf("age:%d\n",tmp.age);
  15.     printf("tele:%s\n",tmp.tele);
  16.     printf("sex:%s\n",tmp.sex);
  17. }
  19. int main(){
  20.     Stu s = {"李四",25,"15161314","男"};
  21.     Print1(s);
  22.     return 0;
  23. }
  1. /*StuThree.c -- 箭头*/
  2. #include "stdio.h"
  4. typedef struct Stu{
  5.     //成员变量
  6.     char name[20];
  7.     short age;
  8.     char tele[12];
  9.     char sex[5];
  10. }Stu;
  12. void Print2(Stu* ps){
  13.     printf("name: %s\n",ps->name);
  14.     printf("age: %d\n",ps->age);
  15.     printf("tele: %s\n",ps->tele);
  16.     printf("sex: %s\n",ps->sex);
  17. }
  19. int main(){
  20.     Stu s = {"李四",25,"15161314","男"};
  21.     //Print1(s); //常规写法
  22.     Print2(&s); //传入的参数是指针
  23.     return 0;
  24. }
  • 方法1(Print1(Stu tmp)): 传入实参，形参会开辟一个与实参大小相同的内存空间，浪费了资源
  • 方法2(Print2(Stu* ps)): 传入的实参的内存，地址，形参只需要开辟指针变量的内存地址，指向实参的内存地址，尽而节约空间

数据结构

线性数据结构
  • 顺序表
    • 1,2,3,4,5,6(数组)按顺序存储
  • 链表
    • 1->2->3->4->5->6(1能找到2，2能找到3，…) 这就是链表
  • 栈
    • 放入元素叫压栈
    • 取出元素叫出栈(弹栈)
    • 先进后出,后进先出原则
  • 队列
    +

树形数据数据结构
  • 二叉树
  • 图

Debug和Release的介绍

  • Debug通常称为调试版本，它包含调试信息，并不做任何优化。便于程序员调试程序。
  • Release称为发布版本,它王五进行了各种优化，使得程序在代码大小和运行速度上都是最优的，以便用户很好的使用。