• 十、结构体联合枚举


    1.结构体 关键字 struct定义一个结构体类型 .点运算符 ->箭头运算符

    数组 存放一组相同类型的数据

    存放一组不同类型的数据 结构体类型
    存放一个学生的信息 学号 姓名

     1 struct student  //结构体类型  存放什么类型的数据
     2 {
     3     char name[15];//存放名字   成员变量  这个结构体包含这些数据
     4     int ID;
     5     float height;
     6     //.....
     7 };
     8 
     9 void myfun(struct student stu1)
    10 {
    11     //不能修改实参的值    这里形参会定义一个新的结构体 (有内存)
    12 
    13 }
    14 void myfun2(struct student *p)
    15 {
    16     (*p).name;
    17     p->name;        //结构体->成员
    18 
    19 
    20     ST ouguang;//定义变量 
    21     PST ou;//指针
    22     ou = (PST)malloc(sizeof(ST));
    23 }
    24 void test()//结构体
    25 {
    26     struct  student  guang;//定义结构体变量
    27 
    28     guang.height = 1.77;
    29     guang.ID = 65;
    30     //guang.name[0] = 'g';   //strcpy   用于给字符数组赋值
    31     strcpy(guang.name, "广广");
    32 
    33     struct student beiwang = { "北望", 123, 1.75 };    
    34 
    35     printf("ID是%d
    ", beiwang.ID);//结构体成员使用方式  结构体变量.成员
    36     printf("名字是%s
    ", beiwang.name);
    37 
    38     struct student arr[10];
    39     for (int i = 0; i < 10; ++i)
    40     {
    41         &arr[i].name;
    42         //(arr + i)->name;
    43     }
    44     struct student *p;
    45     p = (struct student *)malloc(sizeof(struct student) * 10);
    46 
    47     p[0].name;
    48 
    49     free(p);
    50 }
    51 void test2()
    52 {
    53     myINT x = 3;
    54     TE m;//结构体变量
    55     PTE n;//结构体指针变量
    56 }


    取别名 给结构体类型取一个更短的名字 方便使用
    typedef 类型 别名
    typedef int myINT ;使用别名和使用类型是一致的

     1 typedef struct student ST; //ST作为结构体类型的别名
     2 typedef struct student* PST;//PST 结构体指针类型的别名
     3 
     4 typedef struct teacher
     5 {
     6     int age;
     7     int ID;
     8 }TE, *PTE; //定义类型的时候取别名
     9 //TE 相当于结构体类型
    10 //PTE 结构体指针类型的别名
    11 
    12 
    13 typedef int myINT;


    作用 类型名字太长 取一个短的名字方便
    取一些别名有助于提高代码的可读性
    结构体大小 结构体对齐
    结构体大小 >= 结构体所有成员大小之和

    这个str的结构体所占用的空间为32


    存在对齐操作的目的 取成员的时候 提高效率 通过浪费空间来提高运行效率
    比较小的成员放到前面 减少内存对齐浪费的空间

    2.联合 union
    共用体
    共同使用一个空间 存放一般同时只能存放一个数据

    1 union testNum    //联合类型定义方式
    2 {
    3     int  x;
    4     float y;
    5     //char name[10];
    6 };

    联合大小 >= 联合最大成员大小之和

    1 printf("联合大小 %d
    ", sizeof(union testNum));    
    2 union testNum num;
    3 num.y = 3.14f;
    4 printf("%x", num.x);

    3.枚举

    switch 分支
    case

    把类型的值 全部列举出来 方向 上下左右四个方向
    enum 枚举的关键字

     1 enum dir
     2 {
     3     UP=72,DOWN=80,LEFT=75,RIGHT=77        //列举这个类型可能出现的所有的值
     4 }; 
     5 enum week
     6 {
     7     Monday,Tuesday,Wednesday=3,Thursday
     8 };
     9 
    10 void test4()
    11 {
    12     //推箱子  贪吃蛇
    13     enum dir way = UP;//给枚举变量赋值
    14 
    15     switch (way)
    16     {
    17     case UP:
    18         break;
    19     case DOWN:
    20         break;
    21     case LEFT:
    22         break;
    23     case RIGHT:
    24         break;
    25     default:
    26         break;
    27     }
    28 }


    列举这个类型所有可能的值 
    这些常量可以手动设置他们的值
    常量有名字 提高代码的可读性
    在定义的时候 没有给他设置初值 那么默认从0开始 后一个是前一个加1

      1 #include<stdio.h>
      2 #include<stdlib.h>
      3 #include<string.h>
      4 
      5 struct student  //结构体类型  存放什么类型的数据
      6 {
      7     char name[15];//存放名字   成员变量  这个结构体包含这些数据
      8     int ID;
      9     float height;
     10     //.....
     11 };
     12 
     13 typedef struct student ST; //ST作为结构体类型的别名
     14 typedef struct student* PST;//PST 结构体指针类型的别名
     15 
     16 //---> student  完整的类型  strcut  student
     17 
     18 void myfun(struct student stu1)
     19 {
     20     //不能修改实参的值    这里形参会定义一个新的结构体 (有内存)
     21 
     22 }
     23 void myfun2(struct student *p)
     24 {
     25     (*p).name;
     26     p->name;        //结构体->成员
     27 
     28 
     29     ST ouguang;//定义变量 
     30     PST ou;//指针
     31     ou = (PST)malloc(sizeof(ST));
     32 }
     33 void test()//结构体
     34 {
     35     struct  student  guang;//定义结构体变量
     36 
     37     guang.height = 1.77;
     38     guang.ID = 65;
     39     //guang.name[0] = 'g';   //strcpy   用于给字符数组赋值
     40     strcpy(guang.name, "广广");
     41 
     42     struct student beiwang = { "北望", 123, 1.75 };    
     43 
     44     printf("ID是%d
    ", beiwang.ID);//结构体成员使用方式  结构体变量.成员
     45     printf("名字是%s
    ", beiwang.name);
     46 
     47     struct student arr[10];
     48     for (int i = 0; i < 10; ++i)
     49     {
     50         &arr[i].name;
     51         //(arr + i)->name;
     52     }
     53     struct student *p;
     54     p = (struct student *)malloc(sizeof(struct student) * 10);
     55 
     56     p[0].name;
     57 
     58     free(p);
     59 }
     60 
     61 typedef struct teacher
     62 {
     63     int age;
     64     int ID;
     65 }TE, *PTE; //定义类型的时候取别名
     66 //TE 相当于结构体类型
     67 //PTE 结构体指针类型的别名
     68 
     69 
     70 typedef int myINT;
     71 
     72 void test2()
     73 {
     74     myINT x = 3;
     75     TE m;//结构体变量
     76     PTE n;//结构体指针变量
     77 }
     78 
     79 struct str
     80 {
     81     char name[10];
     82     int ID;
     83     float height;
     84     double score;
     85 };
     86 
     87 union testNum    //联合类型定义方式
     88 {
     89     int  x;
     90     float y;
     91     //char name[10];
     92 };
     93 
     94 void fun(int dA[][20])   // int (*dA)[20]  
     95 {
     96     for (int i = 0; i < 10; ++i)
     97     {
     98         for (int j = 0; j < 20; ++j)
     99         {
    100             dA[i][j];//
    101         }
    102     }
    103 }
    104 
    105 
    106 
    107 //枚举
    108 enum dir
    109 {
    110     UP=72,DOWN=80,LEFT=75,RIGHT=77        //列举这个类型可能出现的所有的值
    111 };  //有名字的常量 可以放到switch的case后面
    112 // 这些常量可以手动设置值
    113 // 常量有名字  提高代码的可读性
    114 //在定义的时候 没有给他设置初值  那么默认从0开始赋值 后一个是前一个加1
    115 
    116 enum week
    117 {
    118     Monday,Tuesday,Wednesday=3,Thursday
    119 };
    120 
    121 void test4()
    122 {
    123     //推箱子  贪吃蛇
    124     enum dir way = UP;//给枚举变量赋值
    125 
    126     switch (way)
    127     {
    128     case UP:
    129         break;
    130     case DOWN:
    131         break;
    132     case LEFT:
    133         break;
    134     case RIGHT:
    135         break;
    136     default:
    137         break;
    138     }
    139 }
    140 
    141 
    142 
    143 int main()
    144 {
    145     printf("结构体大小 %d
    ", sizeof(struct str));
    146     printf("联合大小 %d
    ", sizeof(union testNum));
    147     printf("%d
    ", sizeof(enum dir));
    148     //test();
    149 
    150     union testNum num;
    151     num.y = 3.14f;
    152     printf("%x", num.x);
    153 
    154     /*int map[10][20];
    155     fun(map);*/
    156 
    157     //int *p; //指针必须赋值(赋值变量地址)才能使用 使用指针指向的变量
    158     //*p = 3;
    159 
    160     getchar();
    161     return 0;
    162 }
    整体代码
  • 相关阅读:
    【JAVA】java 堆溢出分析
    【数据结构】链表的基本学习 实现
    【其他】博客园自定义样式指南
    【JAVA】一些好用的开源java类库
    【Shell】Shell 常用命令
    【Spring】Spring Boot 要点整理
    【数据库】Mysql 连接相关
    【Linux】Shell 参数解析
    Erlang 中类型转换
    erlang 中 maps 练习
  • 原文地址:https://www.cnblogs.com/liugangjiayou/p/11773344.html
Copyright © 2020-2023  润新知