结构体（C语言）

“点赞，留言，收藏，关注”

就是对阿林最大的支持

1.自定义类型

什么是自定义类型？C语言中有一些自带的数据类型，比如说char，int，float，double，long等数据类型就是C语言的内置类型

在生活中，要描述一件东西，往往有很多的参数 ，只是靠内置类型就显得数据零散，或者说不太够用，所以C语言除了内置类型之外又有了自定义类型，结构体、联合体便是自定义类型

2.结构体 

结构体定义是由关键字 struct 和结构体名组成，结构体名可以根据需要自行定义。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：

struct tag                    //结构体类型

{
        member-list        //结构体成员
        member-list …   //结构体成员
} variable-list  ；

tag是结构体标签，定义结构体类型，如book，student等
member-list 是标准的变量定义，比如 int i; 或者 float f;，也可以定义数组char s[20]
variable-list 结构变量，定义在结构的末尾，最后一个分号之前，表示全局的结构体，可以指定一个或多个结构变量，也可省略

给出一个简单的结构的例子：

2.1普通结构体

struct student            //假设这是一个学生信息的结构体
{
    int age;                 //年龄      
    char name[20];    //名字
    char ID[25];         //学号
    char sex[6];         //性别
};
int main()
{
    struct student zhangsan = { .age = 18, .ID = "12023", .sex = "男", .name = "张三" };
    return 0;
}

2.2嵌套结构体 

和函数一样，结构体也可以嵌套使用，也就是在一个结构体中使用另外一个结构体，也可以包含指向自己结构体类型的指针，而通常这种指针的应用是为了实现一些更高级的数据结构如链表等。

struct student
{
    int age;               //年龄
    char sex[6];        //性别
    int weight;          //体重
};
struct people
{
    int num;             //序号
    struct student s; //学生s
};

2.3匿名结构体 

如下： 

 struct//匿名结构体
{
    int num;
    char name[20];
};
struct
{
    int a;
    char b;
    float c;
}x;
struct
{
    int a;
    char b;
    float c;
}*p;
p = &x;       //两种结构体不同无法赋值

匿名结构体是不定义结构体名称，直接定义其成员，这种结构体只能使用一次。并且两个匿名结构体的成员如果都相同的话，这两个匿名结构体也是不同的 

注意：匿名结构体在程序中只能使用一次 

2.4typedef重命名结构体 

结构体名称在使用时，类型和名称较长，这时我们就可以使用typedef来简化 

写法如下：

typedef struct student
{
    int age;
    char sex[6];
    int weight;
}stu;

//这样写完后，可以用stu代替struct student 

但是需要注意的是：不能在重命名前使用重命名后的结构体

typedef struct student
{
    int age;
    char sex[8];
    int weight;
    char tele[20];
    stu* next;        //这里使用了重命名后的结构体

                          
}stu；                 //实际上代码走到这里才知道结构体重命名为stu

2.5结构体的访问 

 struct student            //假设这是一个学生信息的结构体
{
    int age;                 //年龄      
    char name[20];    //名字
    char ID[25];         //学号
    char sex[6];         //性别
};
int main()
{
    struct student zhangsan = { .age = 18, .ID = "12023", .sex = "男", .name = "张三" };

                                               //这里使用了" . 成员名"进行访问
    return 0;
}

2.6结构体对齐 

既然一个结构体里面有多个变量，那他们是怎么存储的呢？一个结构体的大小是多少呢？ 

struct example
{
    int num;
    char a;
    float b;
    int p;
}s;
int main()
{
    size_t sz = sizeof(s);
    printf("大小为%zd\n", sz);
    return 0;
} 

按照我们的直觉，int是4个字节，char是1个字节，float是4个字节

全部加起来是 13个字节

实际上运行结果（VS2022）：

16

其实我们之前一直学的都是，数据 在内存中连续存储，，而C语言存在内存对齐

内存对齐规则：

》结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处
》其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处
》对⻬数 = 编译器默认的⼀个对⻬数与该成员变量⼤⼩的较⼩值。(VS 中默认的值为 8 ，          Linux中gcc没有默认对齐数，对⻬数就是成员⾃⾝的⼤⼩)
》结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤      的）的整数倍
》如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处      结构体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍

为什么要内存对齐呢？

》平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件        平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常

》性能原因：数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未        对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个      处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double      类型的数据的地址都对⻬成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否            则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两个8字节内存块中

用例子说明内存对齐： 

 #include<stddef.h>
struct Stu
{
    char ch;
    int i;
    char ch2;
};
int main()
{
    return 0;
}

左侧数字是偏移量，上图可描述结构体的内存对齐

未填充颜色的区域，表示未使用的内存，说明内存被浪费了

》c1是一个char类型占一个字节，根据内存对齐第一条规则，放在偏移量为0处
》i是int类型占四个字节，根据内存对齐第二，三规则，默认对齐数是4，对齐至4的整数           倍，  中间浪费三个字节，偏移量为4
》c2也是char类型占一个字节，默认对齐数是1的整数倍，偏移量为8 

用一个实例验证：

#include<stdio.h>
struct stu
{
    char ch;
    int a;
    int b;
};
int main()
{
    printf("%zd\n", sizeof(struct stu));
    return 0;
} 

根据结构体的对齐规则，

char类型的ch放在偏移量为0的位置

int类型的a对齐数是4，放在偏移量4-7的位置，与上一个数据间隔了3个字节

int类型的b对齐数是4，放在偏移量8-11的位置

整个结构体占用的内存应该是4的整数倍，能存下最小内存是12个字节 

VS2022运行结果： 12

2.7修改默认对齐数 

既然对齐数被c语言默认了，我们能不能自行更改呢？答案是可以的 

#pragma 这个预处理指令，我们可以通过它来改变编译器的默认对⻬数 

#include <stdio.h>
#pragma pack(1)
struct Stu
{
    char ch;
    int i;
    char ch2;
};
#pragma pack()
int main()
{
    printf("大小为%d\n", sizeof(struct Stu));
    return 0;
}

我们可以看到，使用了两次pragma 

因为使用#pragma（1）修改对齐数后，便会以这个对齐数向下执行，需要及时恢复为默认对齐数，以免对后续代码造成影响

运行结果：6 

因为对齐数是1，结构体数据在内存中是连续存储的，就等于各成员占用空间之和 

2.8位段 

什么是位段？

有些数据在存储时并不需要占用一个完整的字节，只需要占用一个或几个二进制位即可，所以C 语言有一种特别的数据结构名为位段，允许我们按位对成员进行定义，指定占用的位数，单位为比特位(bit)。一般是用来节约内存，与结构体有两个不同 

》位段的成员必须是 int、unsigned int 或signed int ，char等整型。到了 C99，_Bool 也被支持了。

》位段的成员名后边有⼀个冒号和⼀个数字

使用方法如下：

struct stu
{
    int _a : 2;    //为a分配2个比特位
    int _b : 3;    //为b分配3个比特位
    int _c : 4;    //为c分配4个比特位
    int _d : 5;    //为d分配5个比特位
}; 

特别需要注意的是：位段使用的单位是比特位 

并且，内存中一个字节给一个地址，由于修改了变量占用的内存空间，所以，不能对位段的成员使用&操作符 

不能使⽤scanf直接给位段的成员输⼊值，只能是先输⼊放在⼀个变量中，然后赋值给位段的成员

struct stu
{

    int _a : 1;
    int _b : 20;
    int _c : 2;
    int _d : 3;
};
int main()
{
    struct stu sa = { 0 };
    scanf("%d", &sa._b);   //这是错误的
    int b = 0;             //这里才是正确的
    scanf("%d", &b);
    sa._b = b;
    return 0;
}

注意：由于一些平台不支持位段，需要可移植性好的程序，要避免使用位段 

struct stu
{
    int _a : 2;
    int _b : 5;
    int _c : 10;
    int _d : 30;
};
int main()
{
    printf("大小为%zd\n", sizeof(struct A));
    return 0;
} 

运行结果： 大小为8

以下面这个代码为例，说明内存的分配：

struct S
{
    char a : 3;
    char b : 4;
    char c : 5;
    char d : 4;
};
int main()
{
    struct S s = { 0 };
    s.a = 10;
    s.b = 12;
    s.c = 3;
    s.d = 4;
    return 0;
}

C语言中，位段在一个字节内部是从高地址到低地址分配

当一个结构体包含两个位段，第二个位段比较大，无法容纳于第一个位段剩余的位时， 舍弃

》12先转换为二进制01010，因为假设位段在一个字节内部是从高地址到低地址分配，所以      从右往左分配，又因为只给a分配了三个比特位，所以只存进010
》然后12转换为二进制01100，因为只分配给b四个比特位，所以只存进1100
》3转换为二进制为00011，因为分配了c五个比特位，所以存进00011
》最后4转换为二进制00100，分配进四个比特位0100

2.9位段的缺陷 

位段在跨平台问题上有很大的缺陷 

因为：

》位段中最大位数目是不确定的（在16位机器上int型最大为16，而在32为机器上int型最大       为 32，如若写成27，那么16位机器就会出问题 

》int型位段成员会被当成有、无符号数是不确定的

》位段的成员在内存中到底是从左向右分配，还是从右向左分配尚未定义

》当一个结构体包含两个位段，第二个位段比较大，无法容纳于第一个位段剩余的位时， 舍弃剩余的位还是利用，是不确定的

2.10结构体传参 

函数传参可以传参，也可以传址 

#include<stdio.h>
struct stu
{
    char name[20];
    int height;
    char ID[20];
};
void print1(struct stu zan)
{

    printf("%s\n", zan.name);   //传值调用
}
void print2(struct stu* zan)
{
    printf("%s\n", zan->name);  //传址调用
}
int main()
{
    struct stu zan = { .name = "zhangsan", 180, .ID = "12023" };
    print1(zan);
    print2(&zan);
    return 0;
}

传址调用的效率高，节约内存占用，因为地址在内存中占用4或8个字节"