• C语言笔记22 •结构体•

    C语言结构体

    1.结构体类型的声明

    struct Stu
    {
      char name[ 20 ]; // 名字
      int age; // 年龄
       char sex[ 5 ]; // 性别
       char id[ 20 ]; // 学号
    };

    2.结构体变量的创建和初始化

    1. #include 
    2.  
    3. // 定义一个结构体类型 Point
    4. struct Point {
    5.     int x;
    6.     int y;
    7. };
    8.  
    9. int main() {
    10.     // 创建并初始化结构体变量的几种方式
    11.     
    12.     // 1. 分别初始化每个成员
    13.     struct Point p1;
    14.     p1.x = 10;
    15.     p1.y = 20;
    16.  
    17.     // 2. 声明的同时初始化
    18.     struct Point p2 = {30, 40};
    19.  
    20.     // 3. 使用C99提供的指定成员初始化
    21.     struct Point p3 = {.y = 50, .x = 60};
    22.  
    23.     // 打印结构体变量的值
    24.     printf("Point p1: x = %d, y = %d\n", p1.x, p1.y);
    25.     printf("Point p2: x = %d, y = %d\n", p2.x, p2.y);
    26.     printf("Point p3: x = %d, y = %d\n", p3.x, p3.y);
    27.  
    28.     return 0;
    29. }
    1. #include 
    2.  
    3. struct Stu {
    4.     char name[20];  // 名字
    5.     int age;        // 年龄
    6.     char sex[5];    // 性别
    7.     char id[20];    // 学号
    8. };
    9.  
    10. int main() {
    11.     // 按照结构体成员的顺序初始化
    12.     struct Stu s = { "张三", 20, "男", "20230818001" };
    13.  
    14.     // 打印结构体s的成员
    15.     printf("name: %s\n", s.name);
    16.     printf("age : %d\n", s.age);
    17.     printf("sex : %s\n", s.sex);
    18.     printf("id : %s\n", s.id);
    19.  
    20.     // 按照指定的成员初始化
    21.     struct Stu s2 = { 
    22.         .age = 18, 
    23.         .name = "lisi", 
    24.         .id = "20230818002", 
    25.         .sex = "女" 
    26.     };
    27.  
    28.     // 打印结构体s2的成员
    29.     printf("name: %s\n", s2.name);
    30.     printf("age : %d\n", s2.age);
    31.     printf("sex : %s\n", s2.sex);
    32.     printf("id : %s\n", s2.id);
    33.  
    34.     return 0;
    35. }
    //匿名结构体
    struct
    {
      char name[ 20 ]; // 名字
      int age; // 年龄
       char sex[ 5 ]; // 性别
       char id[ 20 ]; // 学号
    }p;
    //像这样的匿名结构体是不能多次使用，只能使用一次
    struct
    {
      char name[ 20 ]; // 名字
      int age; // 年龄
       char sex[ 5 ]; // 性别
       char id[ 20 ]; // 学号
    }*pa;  pa是匿名结构体指针变量
    pa=&p；   
    //这样是不合法 因为一个是结构体变量 p，另一个是结构体指针变量 pa。匿名结构体的这两个定义是独立的, 编译器会把上⾯的两个声明当成完全不同的两个类型，所以是⾮法的。

    3.结构体的⾃引⽤

    struct Node
    {
        int data;
        struct Node * next ;
    };
    如下图

    4.结构体内存对齐

    学习结构体的内存对齐，其实也是计算结构体的⼤⼩

    结构体的对齐规则：

    1. 结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处
    2. 其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。
        对⻬数 = 编译器默认的⼀个对⻬数 与 该成员变量⼤⼩的较⼩值。
        - VS 中默认的值为 8
        - Linux中 gcc 没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩
    3. 结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤      的）的整数倍。
    4. 如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。
    举例：
    //假设对齐数 默认的值为 8
    // #pragma 这个预处理指令，可以改变编译器的默认对⻬数。
    // # pragma pack(1) // 设置默认对⻬数为 1
    //# pragma pack() // 取消设置的对⻬数，还原为默认
    struct data
    {
      int a;
      char b;
      short c;
      short d;
    }AA_t;
    解释：
    （1）a是整形占4个字节：4   8  按照对齐规则2,对齐数4和8的最小值就是 4，又因为a是第一个成员变量，就从偏移量为0开始。
    （2）b是字符占1个字节：1   8   对齐数就是 1，此时b要从偏移量为多少处开始呢，就是找1的整数倍数，从a往下数就是4，4是1的整数倍数，因为b是字符占1个字节，只占一个就行。
    （3）c是短整形short占2个字节：2   8   对齐数就是 2，此时c要从偏移量为多少处开始呢，就是找2的整数倍数，从b往下数就是5，5不是2的整数倍数，接着往下数也就是6了，因为c是短整形占2个字节，占两个就行。
    （3）d是短整形short占2个字节：2   8   对齐数就是 2，此时d要从偏移量为多少处开始呢，就是找2的整数倍数，从c往下数就是8，8是2的整数倍数，因为d是短整形占2个字节，占两个就行。
    此时此刻a、b、c、d已经占了 10个字节了，按照 对齐规则3， 结构体总⼤⼩为最⼤对⻬数的整数倍。a、b、c、d中最大对齐数是4，那么 结构体总⼤⼩为4的整数倍。显然10不是4的整数倍，就往下找到偏移量为11处 占了12个字节，也正好为4的整数倍。 所以结构体总⼤⼩为：12
    struct data1
    {
      int a;
      char b;
      short c;
      short d;
      struct data e；
    }AA;

    结构体 struct data1在struct data的基础之上把struct data嵌套在 struct data1里，所以按照对齐规则4，就是嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，struct data的最大对齐数是4，那偏移量就从12处开始，struct data大小为12个字节就到偏移量23处，此时此刻a、b、c、d、e所占字节为24，struct data1结构体大小为所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍，struct data1结构体的最⼤对⻬数为4，24是4的倍数，所以struct data1结构体大小为24

    5.为什么结构体存在内存对⻬

    （1）平台原因 (移植原因)：
    不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定 类型的数据，否则抛出硬件异常。
    （2）性能原因：
    数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要 作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以 ⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两个8字节内存块中。
    总体来说：结构体的内存对⻬是拿空间来换取时间的做法，就如上面的例子，对齐需要1次访问就可以访问b，节约时间成本，但是浪费了3个字节空间。
    所以在设计结构体的时候，既要满⾜对⻬，⼜要节省空间，解决方法就是：
    让占⽤空间⼩的成员尽量集中在⼀起
    //举例：
      struct S1
    {
        char c1;
        int i;
        char c2;
    };
    struct S2
      {
          char c1;
          char c2;
          int i;
    };
    //   S2 比   S1 结构体 所占空间就要小。
  • 相关阅读:
    风车IM即时通讯系统APP源码DJ2403版完整苹果安卓教程
    四目大视场四目夜视镜 --TFN TD401 大视场头盔四目夜视仪 夜视镜 无需转头微光夜视系统 四目四管
    数据分析技能点-数据挖掘及入门
    【React源码】(十七)React 算法之深度优先遍历
    GraphBase基础原理
    离散数学考前小记
    推荐一个好用的电商开源项目yudao源码
    LabVIEW将视觉生成器AI用作OPC服务器
    文件编码、转换、乱码问题
    IDEA中安装Docker插件实现远程访问Docker
  • 原文地址：https://blog.csdn.net/qq_64446190/article/details/139193994