C语言13--结构体

标签：13 字节 -- 偏移量 C语言 char int 对齐 struct

结构体基本概念

        C语言提供了众多的基本类型，但现实生活中的对象一般都不是单纯的整型、浮点型或字符串，而是这些基本类型的综合体。比如一个学生，典型地应该拥有学号（整型）、姓名（字符串）、分数（浮点型）、性别（枚举）等不同侧面的属性，这些所有的属性都不应该被拆分开来，而是应该组成一个整体，代表一个完整的学生。

在C语言中，可以使用结构体来将多种不同的数据类型组装起来，形成某种现实意义的自定义的变量类型。结构体本质上是一种自定义类型。

结构体的定义：

struct 结构体标签    //结构体标签不可省略，只有在结构体内的嵌套结构体可省略标签
{
    成员1;    //成员都要加上;最后一个成员加不加都可以
    成员2;
    ...
};    //结构体大括号后也要加上;

• 语法：
  • 结构体标签，用来区分各个不同的结构体。
  • 成员，是包含在结构体内部的数据，可以是任意的数据类型(只要不是函数就行）。

结构体的基础操作：

• • 声明结构体类型
  • 定义结构体变量、指针 + 初始化
  • 赋值、访问、 如何取地址、如何访问地址...

结构体初始化

        结构体跟普通变量一样，涉及定义、初始化、赋值、取址、传值等等操作，这些操作绝大部分都跟普通变量别无二致，只有少数操作有些特殊性。这其实也是结构体这种组合类型的设计初衷，就是让开发者用起来比较顺手，不跟普通变量产生太多差异。

• 结构体的定义和初始化。
  • 由于结构体内部拥有多个不同类型的成员，因此初始化采用与数组类似的列表方式。
  • 结构体的初始化有两种方式：①普通初始化；②指定成员初始化。
  • 为了能适应结构体类型的升级迭代，一般建议采用指定成员初始化。
• 示例：

// 1，普通初始化
struct node n = {100, 'x', 3.14};

// 2，指定成员初始化
struct node n = {
     .a = 100,  // 此处，小圆点.被称为成员引用符
     .b = 'x',
     .c = 3.14
}

• 指定成员初始化的好处：
  • 成员初始化的次序可以改变（不需要与声明保持一致）。
  • 可以任意初始化一部分成员。
  • 结构体新增了成员之后初始化语句仍然可用。

结构体成员引用

结构体相当于一个集合，内部包含了众多成员，每个成员实际上都是独立的变量，都可以被独立地引用。引用结构体成员非常简单，只需要使用一个成员引用符即可：

结构体.成员

示例：

n.a = 200;
n.b = 'y';
n.c = 2.22;
printf("%d, %c, %lf\n", n.a, n.b, b.c);

结构体指针与数组

跟普通变量别无二致，可以定义指向结构体的指针，也可以定义结构体数组。

• 结构体指针：

struct node  n = {100, 'x', 3.14};
struct node *p = &n;

// 以下语句都是等价的
printf("%d\n",   n.a);
printf("%d\n", (*p).a);
printf("%d\n",  p->a);  // 箭头 -> 是结构体指针的成员引用符

• 结构体数组：

struct node s[5];
s[0].a = 300;
s[0].b = 'z';
s[0].c = 3.45;

结构体声明语句的变形：

初始版本：

struct DataType
{
    int Num ;
    char Name [32];   
};

变形1：

在声明语句中直接定义结构体变量或指针。

// 声明语句中直接定义
struct DataType
{
    int Num ;
    char Name[32];    
} Even , *ptr ;
// Even 为一个全局的结构体类型【变量】
// ptr 为一个全局的结构体类型【指针】

变形2：

在声明语句中把标签省略，这种写法比较少出现，该写法会导致无法单独定义该类型的结构体，因为该类型的标签缺失了无法分别是哪一个结构体类型。一般会用于结构体中进行嵌套使用，也就是在大结构体中作为一个成员出现。

// 声明语句中直接定义
struct DataType
{
    int Num ;
    char Name[32];    
} Even , *ptr ;
// Even 为一个全局的结构体类型【变量】
// ptr 为一个全局的结构体类型【指针】

注意： 由于这种情况下的结构体无法单独定义变量，因此必须在声明语句的后面立刻定义所需的所有变量。

示例例子：

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

// 声明语句中直接定义
struct Stud
{
    int Num ;
    char Name[32];   

    struct 
    {
        /* 学科成绩 */
        float Mathematics;
        float CLanguage;
    } Achievement ;

    struct 
    {
        /* 生活状态 */
        int Girlfriend;
        char Hobby[32];
    } Life ;

} Even , *ptr ;


int main(int argc, char const *argv[])
{
    Even.Num = 34 ;
    // Even.Name = "Even" ;
    strcpy(Even.Name , "Even");

    Even.Achievement.Mathematics = 13.5 ;
    Even.Achievement.CLanguage = 99.8 ;

    Even.Life.Girlfriend = 7 ;
    // Even.Life.Hobby
    strcpy(Even.Life.Hobby , "陪女朋友");
    
    return 0;
}

变形3：

使用typedef 给结构体取别名。

// 结构体声明
typedef struct DataType
{
    int Num ;
    char Name[32];
} MyType_t ;

// 有typedef 的情况下可以直接省略标签，并不影响定义变量
typedef struct 
{
    int Num ;
    char Name[32];
} MyType_t ;

零长数组：

概念： 数组的大小在定义的时候设置为0 .

作用： 数组是唯一个允许越界访问的媒介，因此可以把零长数组安排在结构体的末尾，然后给结构体额外申请内存，然后再通过数组越界来访问额外的空间。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


typedef struct Monster
{
    char Name [32];
    int Num ;

    int Len ; // 长度用于记录是否存在稀有特性  如果没有则给0  如果有则记录稀有特性的内存空间大小
    char Msg [0];
} Monster_t;



int main(int argc, char const *argv[])
{
    Monster_t Wolf = {
        .Name = "XiaoYeLang",
        .Num = 34 
    };

    Monster_t *ptr1 = calloc(1, sizeof(Monster_t));

    Monster_t *ptr2 = calloc(1, sizeof(Monster_t) + 32);

    ptr2->Len = 32 ;
    strncpy (ptr2->Name , "YeLangWang" , 32 );
    ptr2->Num = 33 ;
    strncpy( ptr2->Msg , "所有野狼都喊他爸爸" , ptr2->Len );


    printf("Name:%s Num:%d Msg:%s\n" , ptr2->Name , ptr2->Num , ptr2->Msg);



    free(ptr1);
    free(ptr2);

    
    return 0;
}

CPU字长

字长的概念指的是处理器在一条指令中的数据处理能力，当然这个能力还需要搭配操作系统的设定，比如常见的32位系统、64位系统，指的是在此系统环境下，处理器一次存储处理的数据可以达32位或64位。

CPU字长的含义

地址对齐

CPU字长确定之后，相当于明确了系统每次存取内存数据时的边界，以32位系统为例，32位意味着CPU每次存取都以4字节为边界，因此每4字节可以认为是CPU存取内存数据的一个单元。

如果存取的数据刚好落在所需单元数之内，那么我们就说这个数据的地址是对齐的，如果存取的数据跨越了边界，使用了超过所需单元的字节，那么我们就说这个数据的地址是未对齐的。

地址未对齐的情形

从图中可以明显看出，数据本身占据了8个字节，在地址未对齐的情况下，CPU需要分3次才能完整地存取完这个数据，但是在地址对齐的情况下，CPU可以分2次就能完整地存取这个数据。

总结：如果一个数据满足以最小单元数存放在内存中，则称它地址是对齐的，否则是未对齐的。

地址对齐的含义用大白话说就是1个单元能塞得下的就不用2个；

2个单元能塞得下的就不用3个。

如果发生数据地址未对齐的情况，有些系统会直接罢工，有些系统则降低性能。

普通变量的m值

以32位系统为例，由于CPU存取数据总是以4字节为单元，因此对于一个尺寸固定的数据而言，当它的地址满足某个数的整数倍时，就可以保证地址对齐。这个数就被称为变量的m值。

根据具体系统的字长，和数据本身的尺寸，m值是可以很简单计算出来的。

• 举例：

char   c; // 由于c占1个字节，因此c不管放哪里地址都是对齐的，因此m=1
short  s; // 由于s占2个字节，因此s地址只要是偶数就是对齐的，因此m=2
int    i; // 由于i占4个字节，因此只要i地址满足4的倍数就是对齐的，因此m=4
double f; // 由于f占8个字节，因此只要f地址满足4的倍数就是对齐的，因此m=4

printf("%p\n", &c); // &c = 1*N，即：c的地址一定满足1的整数倍
printf("%p\n", &s); // &s = 2*N，即：s的地址一定满足2的整数倍
printf("%p\n", &i); // &i = 4*N，即：i的地址一定满足4的整数倍
printf("%p\n", &f); // &f = 4*N，即：f的地址一定满足4的整数倍

• 注意，变量的m值跟变量本身的尺寸有关，但它们是两个不同的概念。

• 手工干预变量的m值：

char c __attribute__((aligned(32))); // 将变量 c 的m值设置为32

语法：

• • attribute 机制是GNU特定语法，属于C语言标准语法的扩展。
  • attribute 前后都是双下划线，aligned两边是双圆括号。
  • attribute 语句，出现在变量定义语句中的分号前面，变量标识符（变量名）后面。
  • attribute 机制支持多种属性设置，其中 aligned 用来设置变量的 m 值属性。
  • 一个变量的 m 值只能提升，不能降低，且只能为正的2的n次幂。

拓展：__attribute__ 机制详解-CSDN博客

结构体的M值

• 概念：
  • 结构体的M值，取决于其成员的m值的最大值。即：M = max{m1, m2, m3, …};
  • 结构体的入口地址和尺寸，都必须等于M值的整数倍。
• 示例：

struct node
{
    short  a; // 尺寸=1，m值=2
    double b; // 尺寸=8，m值=4
    char   c; // 尺寸=1，m值=1
};

struct node n; // M值 = max{2, 4, 1} = 4;

• 以上结构体成员存储分析：

1. 结构体的M值等于4，这意味着结构体的地址、尺寸都必须满足4的倍数。
2. 成员a的m值等于2，但a作为结构体的首元素，必须满足M值约束，即a的地址必须是4的倍数
3. 成员b的m值等于4，因此在a和b之间，需要填充2个字节的无效数据（一般填充0）
4. 成员c的m值等于1，因此c紧挨在b的后面，占一个字节即可。
5. 结构体的M值为4，因此成员c后面还需填充3个无效数据，才能将结构体尺寸凑足4的倍数。

拓展：

结构体的占位符：

概念： 出现在标识符与分号之间，：4 表示该标识符占用4个二进制位。

struct C
{
    char t:4; // t占用4个二进制位
    char k:4; // k占用4个二进制位
    unsigned short i:8; // i占用8个二进制位
}

#pragma pack(2)

#pragma pack(2)  // 开始限制
    typedef struct{
        unsigned long index;  // 8
        char name[9];  //9
    
        char *attr[4];  // 32
        }tSA, *ptSA;
#pragma pack() // 取消限制

这是一个C语言结构体的定义，其中使用了#pragma pack(2)。这个指令是GCC编译器的一个特殊指令，用于指定结构体的大小。在这个例子中，#pragma pack(2)表示结构体的大小应该以2字节为边界对齐。

结构体tSA的定义如下：

typedef struct {
    unsigned long index;
    char name[9];
    char *attr[4];
} tSA, *ptSA;

这里，我们有一个 unsigned long 类型的成员变量 index，以及两个指针类型的成员变量 name 和 attr。name 是一个长度为9的字符数组，attr 是一个长度为4的指针数组。

需要注意的是，#pragma pack()解析后的代码没有实际的作用，它只是让编译器在内部进行了一些优化。在实际使用中，不需要使用#pragma pack()来指定结构体的大小，因为编译器通常会自动进行对齐优化。

可移植性

可移植指的是相同的一段数据或者代码，在不同的平台中都可以成功运行。

• 对于数据来说，有两方面可能会导致不可移植：
  • 数据尺寸发生变化
  • 数据位置发生变化

第一个问题，起因是基本的数据类型在不同的系统所占据的字节数不同造成的，解决办法是使用教案04讨论过的可移植性数据类型即可。本节主要讨论第二个问题。

考虑结构体：

struct node
{
    int8_t  a;
    int32_t b;
    int16_t c;
};

以上结构体，在不同的的平台中，成员的尺寸是固定不变的，但由于不同平台下各个成员的m值可能会发生改变，因此成员之间的相对位置可能是飘忽不定的，这对数据的可移植性提出了挑战。

解决的办法有两种：

• 第一，固定每一个成员的m值，也就是每个成员之间的塞入固定大小的填充物固定位置：

struct node
{
    int8_t  a __attribute__((aligned(1))); // 将 m 值固定为1
    int64_t b __attribute__((aligned(8))); // 将 m 值固定为8
    int16_t c __attribute__((aligned(2))); // 将 m 值固定为2
};

• 第二，将结构体压实，也就是每个成员之间不留任何空隙：
  • 取消结构体内部的对齐属性

struct node
{
    int8_t  a;
    int64_t b;
    int16_t c;
} __attribute__((packed));


使用Typedef的版本：
typedef struct node
{
    __int8_t  a; //1
                 //7 / 3 
    __int64_t b; //8
    __int16_t c; //2
} __attribute__((packed)) Node_t , *P_Node  ;

结构体尺寸：

代码实操：

代码理解：(文件名:struct_size)
//规则一：结构体中元素是按照定义顺序，依次放入到内存中。在存放的过程中，每个成员按照一定的偏移量进行存放，其中第一个成员的偏移量为0，
//其余成员的偏移量是 对齐数 = min(编译器默认的数字，该成员的大小) 的整数倍（以结构体变量首地址为0计算）。即每个类型成员都会有一个属于自己的对齐数。visual studio中编译器默认的数字是8（windows），gcc默认是4（Linux）。
 
//规则二：在经过规则一存放结构体中的数据后，计算总的存储单元是否是所有元素中最大对齐数的整数倍，是，则结束；不是，则补齐为它的整数倍。
 
//注1：结构体中内存对齐是针对基本类型的（char，short，int，long，float，double等）；
 
//注2：对于含有指针的情况，只要记住指针本身所占的存储空间是4个字节就行了，而不必看它是指向什么类型的指针
 
//注3：对于含有数组的情况，按数组的类型对齐，如int a[2]，则按照int类型对齐
 
//注4：对于含有其他结构体变量的情况，该结构体变量存储位置从自己的最大对齐数的整数倍处开始，而结构体的整体大小就是所有最大对齐数（含嵌套的结构体的对齐数）的整数倍
 
//注:以下linux下默认对齐数为4
#include<stdio.h>
struct A    
{   /*结果：A = 8
    首先char a放在偏移量为0的开头,接着short b 偏移量为2=(默认对齐数4,short大小2),char占了第一个2的位置,short到下一个2
    此时字节占4,接着偏移量4=(默认对齐数4,int大小4),int刚好占char和short接下去的下一个4字节位置,此时字节占8
    字节占8,三个数中最大对齐数为int 4,8为4的倍数,满足最大对齐数的整数倍,所以A占8个字节*/
    char a;    
    short b;   
    int c;     
};
struct B    
{   /*结果：B = 8
    首先int c放在偏移量为0的开头,此时占4个字节,接着short b 偏移量为2=(默认对齐数4,short大小2),int占了前面4的位置,short接着下去
    此时字节占6,接着偏移量1=(默认对齐数4,char大小1),char接着int和short,此时字节占7,因为不满足最大对齐数的整数倍,所以补齐到占8字节
    所以B占8个字节*/
    int c;
    short b;
    char a;
};
struct C    
{   /*结果：C=12
    首先char a放在偏移量为0的开头,接着int c 偏移量为4=(默认对齐数4,int大小4),char占了第一个4的位置,int到下一个4
    此时字节占8,接着偏移量2=(默认对齐数4,short大小2),short刚好占char和int接下去的下一个2字节位置,此时字节占10
    因为不满足最大对齐数的整数倍,所以补齐到占12字节,所以C占12个字节*/
    char a;
    int c;
    short b;
};
struct D
{   /*结果：D=8
    首先char a放在偏移量为0的开头,接着char d 偏移量为1=(默认对齐数4,char大小1),char d接着char a的位置
    此时字节占2,接着偏移量2=(默认对齐数4,short大小2),short刚好占char和char接下去的下一个2字节位置,此时字节占4
    接着int c 偏移量为4=(默认对齐数4,int大小4),刚好接着前面的4个字节到下一个4字节位置,此时字节占8
    满足最大对齐数的整数倍,所以D占8个字节*/
    char a;
    char d;
    short b;
    int c;
};
struct E
{   /*结果：E = 12
    首先char a放在偏移量为0的开头,接着short b 偏移量为2=(默认对齐数4,short大小2),char占了第一个2的位置,short到下一个2
    此时字节占4,接着char d 偏移量为1=(默认对齐数4,char大小1),char d接着前面的位置,此时字节占5,
    接着偏移量4=(默认对齐数4,int大小4),前面三个数占了第一二个4的位置,int到第三个4的位置,此时字节占12
    满足最大对齐数的整数倍,所以E占12个字节*/
    char a;
    short b;
    char d;
    int c;
};
struct F
{   /*结果：F = 16
    首先char a放在偏移量为0的开头,接着short b 偏移量为2=(默认对齐数4,short大小2),char占了第一个2的位置,short到下一个2
    此时字节占4,接着偏移量4=(默认对齐数4,int大小4),前面char和short占了第一个4的位置,int到第二个4的位置,此时字节占8,
    接着char d 偏移量为1=(默认对齐数4,char大小1),char d接着前面的位置,此时字节占9,接着short b 偏移量为
    2=(默认对齐数4,short大小2),接着前面四个数的位置,short接着字节占10的位置下去,此时字节占12,char e 偏移量为
    1=(默认对齐数4,char大小1),char e接着前面的位置,此时字节占13,因为不满足最大对齐数的整数倍,所以补齐到占16字节,
    所以F占16个字节*/
    char a;
    short b;
    int c;
    char d;
    short f;
    char e;
};
 
struct G{
    /*结果：G=16
     首先char a放在偏移量为0的开头,接着int b 偏移量为4=(默认对齐数4,int大小4),char占了第一个4的位置,int到下一个4
     此时字节占8,接着偏移量4=(默认对齐数4,double大小8),double刚好占char和int接下去的下一个8字节位置,此时字节占16
     满足最大对齐数的整数倍,所以G占16个字节*/
    char a;
    int b;
    double c;
};
 
struct H{
    /*结果：H=24
     首先char a放在偏移量为0的开头,接着偏移量4=(默认对齐数4,double大小8),char占了第一个8的位置,double接着下一个8的位置,
     此时字节占16,接着int b 偏移量为4=(默认对齐数4,int大小4),int接着char和double的16字节位置,此时字节占20
     因为不满足最大对齐数double = 8的整数倍,所以补齐到占24字节,所以H占24个字节*/
    char a;
    double c;
    int b;
};
 
struct J{
    /*结果：J=24
     首先double a放在偏移量为0的开头,占8个字节,接着char b 偏移量为1=(默认对齐数4,char大小1),char b接着前面的位置,此时字节占9,
    接着int c 偏移量为4=(默认对齐数4,int大小4),double和char占了前面9个字节的位置,int接着下去到第四个4字节的位置,此时字节占16,
    接着char d 偏移量为1=(默认对齐数4,char大小1),char d接着前面的位置,此时字节占17,
     因为不满足最大对齐数的整数倍double = 8的整数倍,所以补齐到占24字节,所以J占24个字节*/
    double a;
    char b;
    int c;
    char d;
};
 
 
 
struct K {
    /*结果：K=16,K与前面G一样成员,所以一样大小*/
    char a;
    int b;
    double c;
}K;
 
struct L {
    /*结果：L=24
    首先char a放在偏移量为0的开头,此时占1个字节,然后因为结构体变量S1 b的最大对齐数是8，因此从第8个字节开始存储，存储在第8-23字节，
    然后按照规则二检查存储大小是否是最大对齐数的整数倍，满足，则结束（最大对齐数是8（double类型变量的对齐数），总的存储大小是24）,
    所以L占24个字节
    */
    char a;
    struct K b;//这里S2中的成员b是成员名,是一个包含了S1结构体的变量。成员b本身并不是将结构体S1的成员b加起来，而是包含了整个S1结构体的变量
};
 
struct S1 {
    /*结果:S1=8
     * 对于含有指针的情况，只要记住指针本身所占的存储空间是8个字节就行了，而不必看它是指向什么类型的指针
     * 三个结构体中含有不同类型的指针变量，其结构体大小都为8个字节
     */
    char *a;
} s1;
 
struct S2 {
    /*结果:S2=8
     * 对于含有指针的情况，只要记住指针本身所占的存储空间是8个字节就行了，而不必看它是指向什么类型的指针
     * 三个结构体中含有不同类型的指针变量，其结构体大小都为8个字节
     */
    
    int *b;
} s2;
 
struct S3 {
    /*结果:S3=8
     * 对于含有指针的情况，只要记住指针本身所占的存储空间是8个字节就行了，而不必看它是指向什么类型的指针
     * 三个结构体中含有不同类型的指针变量，其结构体大小都为8个字节
     */
    
    double* a;
} s3;
 
struct S4 {
    /*结果:S4=16
     * 首先char a放在偏移量为0的开头,此时占1个字节,然后因为指针占8个字节,因为char占了第一个8的位置,
     * 所以指针b接着下一个8字节的位置,此时字节占16
     * 满足最大对齐数,所以S4占16个字节
     */ 
    char a;
    double* b;
} s4;
 
struct S5 {
    /*结果:S5=12
     * 含有数组的情况，按照数据的类型，进行对齐即可
     * 首先char a放在偏移量为0的开头,此时占1个字节,然后因为int偏移量为4=(默认对齐数4,int大小4),
     * char占了第一个4的位置,int有两个,所以b接着第二三个4字节的位置,此时字节占12
     * 满足最大对齐数的整数倍,所以S5占12个字节
     */ 
    char a;
    int b[2];
} s5;
 
int main(void)
{
    struct A aa;
    struct B bb;
    struct C cc;
    struct D dd;
    struct E ee;
    struct F ff;
    struct G gg;
    struct H hh;
    struct J jj;
    struct K kk;
    struct L ll;
 
 
    printf("A = %d\n", sizeof(aa));//结果：A= 8
    printf("B = %d\n", sizeof(bb));//结果：B= 8
    printf("C = %d\n", sizeof(cc));//结果：C= 12
    printf("D = %d\n", sizeof(dd));//结果：D= 8
    printf("E = %d\n", sizeof(ee));//结果：E= 12
    printf("F = %d\n", sizeof(ff));//结果：F= 16
    printf("G = %d\n", sizeof(gg));//结果：G= 16
    printf("H = %d\n", sizeof(hh));//结果：H= 24
    printf("J = %d\n", sizeof(jj));//结果：J=24
    printf("K = %d\n", sizeof(kk));//结果：K= 16
    printf("L = %d\n", sizeof(ll));//结果：L= 24
    printf("s1 = %d\n",sizeof(s1));//结果：s1 = 8
    printf("s2 = %d\n",sizeof(s2));//结果：s2 = 8
    printf("s3 = %d\n",sizeof(s3));//结果：s3 = 8
    printf("s4 = %d\n",sizeof(s4));//结果：s4 = 16
    printf("s5 = %d\n",sizeof(s5));//结果：s5 = 12
 
    return 0;
}

结语：

        在本文中，我们探讨了C语言中的结构体这一重要数据结构。结构体的引入极大地增强了我们的程序设计能力，它允许我们将不同类型的数据组合在一起，形成一个更复杂的数据类型，使得数据的组织和管理变得更加高效和有序。

        结构体是C语言中不可或缺的组成部分，掌握其用法不仅可以提高代码的可读性，还能增强程序的可维护性。希望您能在今后的编程实践中灵活运用结构体，使得代码更加清晰和高效。

标签：13,字节,--,偏移量,C语言,char,int,对齐,struct
From： https://blog.csdn.net/weixin_69902486/article/details/142094660