本文详细介绍了C语言中的结构体、位段、枚举和联合的概念及用法，包括结构体的声明、初始化、自引用、对齐规则，位段的特性，枚举的优势，以及联合如何共享内存空间。此外，还讨论了结构体的内存分配和大小计算，以及如何通过位段进行位操作。文章通过示例代码展示了各种情况下的实际应用，帮助读者深入理解这些概念。
目录
结构体
结构：结构是一些值的集合，这些值成为成员变量。结构的每个成员可以是不同类型变量。
结构的声明：
struct tag
{
member-list;
}variable-list;
// tag : 结构体标签
// member-list : 结构体成员
// variable-list : 结构体变量struct Stu
{
char name[20];
int id;
int age;
double score;
char sex[5];
};// 结构体的不完全声明
// 省略结构体标签
// 只能在声明的后面定义结构体变量
// p = &x; 非法的
struct Stu
{
char name[20];
int id;
char sex[5];
}x;
struct Stu
{
char name[20];
int id;
char sex[5];
}a[20], *p;结构体的自引用：
// erro 错误的
// 当为结构体开辟内存时，结构体的大小不能确定
// 当求结构体的大小时，会先求第一个，然后再求第二个时陷入死循环
struct Node
{
int data;
struct Node next;
};// 指针的大小在一个机器位数相同时，是一个确定值。
struct Node
{
int data;
Struct Node* next;
};typedef struct Node
{
int data;
struct Node* next;
}Node;结构体变量的定义和初始化：
struct point
{
int x;
int y;
}p1; // 声明结构体的类型，并定义p1
struct point p2; // 定义结构体变量p2
struct point pe = { 2, 3 };//定义结构体变量的同时初始化p3
struct Stu
{
char name[20];
int age;
int id;
char sex[7];
}s = {"zhangsan", 20, 123456, "male"}; // 声明结构体类型的同时定义s并初始化s
typedef struct Node
{
int data;
struct point p;
struct Node* next;
}Node; // 结构体嵌套申明
Node n = { 30, {3, 4}, NULL }; // 结构体嵌套的定义和初始化结构体的对齐：
对齐规则：
1.第一个成员在与结构体变量偏移量为0的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整倍数的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值（vs 8）
3.结构体总体大小为最大对齐数（每个成员变量都有一个对齐数）的整倍数。
4. 如果嵌套了结构体情况，嵌套的结构体对齐到自己的最大对齐数的整数倍数，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
为什么存在对齐：拿空间换时间（让占用空间小的成员尽量集中在一起）
1.平台原因：不是所有的硬件平台都能访问任意地址上的任意数据的；某些平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因：数据结构应该尽可能地在自然边界对齐。为了访问未对齐的内存，处理器需要做两次访问；而对齐的内存访问只需要一次访问。
#include <stdio.h>
struct s1
{
char c1; // 0
int i; // 4 5 6 7
char c2; // 8
};
// 12 4的整数倍
struct s2
{
char c1; // 0
char c2; // 1
int i; // 4 5 6 7
}; // 8
struct s3
{
int i; // 0 1 2 3
char c1; // 4
char c2; // 5
}; // 8
struct s4
{
double d; // 0 1 2 3 4 5 6 7
char c; // 8
int i; // 12 13 14 15
}; // 16
struct s5
{
char a; // 0
struct s4 b; // 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
double d; // 17 18 19 20 21 22 23 24
}; // 32
int main()
{
printf("%d\n", sizeof(struct s1));// 12
printf("%d\n", sizeof(struct s2));// 8
printf("%d\n", sizeof(struct s3));// 8
printf("%d\n", sizeof(struct s4));// 16
printf("%d\n", sizeof(struct s5));// 32
return 0;
}
修改默认对齐数
#pragma pack(2) // 设置默认对齐数为2 #pragma pack() // 取消对齐数，还原为默认
#include <stdio.h>
#pragma pack(1)
struct s1
{
char c1; // 0
int i; // int 4, 默认对齐 1 ---> 对齐数 1， 1是1的整数倍， 1 2 3 4
char c2; // 5
};// 6
struct s2
{
char c1; // 0
char c2; // 1
int i; // 2 3 4 5
}; // 6
struct s3
{
int i; // 0 1 2 3
char c1; // 4
char c2; // 5
}; // 6
struct s4
{
double d; // 0 1 2 3 4 5 6 7
char c; // 8
int i; // 9 10 11 12
}; // 13
struct s5
{
char a; // 0
struct s4 b; // 1 2 3 4 5 6 7 8 9 10 11 12 13
double d; // 14 15 16 17 18 19 20 21
}; // 2
#pragma pack()
int main()
{
printf("%d\n", sizeof(struct s1));// 6
printf("%d\n", sizeof(struct s2));// 6
printf("%d\n", sizeof(struct s3));// 6
printf("%d\n", sizeof(struct s4));// 13
printf("%d\n", sizeof(struct s5));// 22
return 0;
}
#include <stdio.h>
#pragma pack(2)
struct s1
{
char c1; // 0
int i; // 2 3 4 5
char c2; // 6
};// 8
struct s2
{
char c1; // 0
char c2; // 1
int i; // 2 3 4 5
}; // 6
struct s3
{
int i; // 0 1 2 3
char c1; // 4
char c2; // 5
}; // 6
struct s4
{
double d; // 0 1 2 3 4 5 6 7
char c; // 8
int i; // 10 11 12 13
}; // 14
struct s5
{
char a; // 0
struct s4 b; // 2 3 4 5 6 7 8 9 10 11 12 13 14
double d; // 16 17 18 19 20 21 22 23
}; // 24
#pragma pack()
int main()
{
printf("%d\n", sizeof(struct s1));// 8
printf("%d\n", sizeof(struct s2));// 6
printf("%d\n", sizeof(struct s3));// 6
printf("%d\n", sizeof(struct s4));// 14
printf("%d\n", sizeof(struct s5));// 24
return 0;
}
位段
位段：
1.位段的成员必须是int、unsigned int、signed int。
2.位段的成员名后有一个冒号和数字。
位段的内存分配：
1.位段的成员可以是int，unsigned int ， signed int或者是char类型
2.位段的空间是按照需求以4个字节或者1个字节的方式来开辟的
3.位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
位段的跨平台问题：
1.int位段被当作有符号数还是无符号数是不确定的。
2.位段中的最大位的数目是不确定的。
3.位段在内存中是从左向右分配内存还是从右向左分配内存标准尚未定义。
4.当一个结构包含两个位段，第二个成员位段较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
#include <stdio.h>
struct A
{
// 4byte -- 32
int _a : 2; // 30
int _b : 5; // 25
int _c : 10;// 15
// 4byte -- 32
int _d : 30; // 2
}; // 8byte
struct S
{
// 1byte -- 8
char a : 3; // 5
char b : 4; // 1
// 1byte -- 8
char c : 5; // 3
// 1byte -- 8
char d : 4; // 4
// 3 byte
};
// 在大端中，从高地址处开始
int main()
{
printf("%d\n", sizeof(struct A));
printf("%d\n", sizeof(struct S));
struct S s = { 0 };
s.a = 10; // 1010 --- 010 == 2
s.b = 12; // 1100 --- -1 *( 2 ^ 2) = -4
s.c = 3;
s.d = 4;
printf("%d %d %d %d\n", s.a, s.b, s.c, s.d);
return 0;
}
枚举
枚举就是一一列举，把所有可能的取值一一列举。
枚举的优点：
1.增加代码的可读性和可维护性
2.和#define定义的标识符比较枚举有类型检查，更加严谨。
3.防止命名的污染（封装）
4.便于调试
5.使用方便，一次可以定义多个常量。
#include <stdio.h>
enum Day
{
Mon, // 0
Tues,// 1
Wed, // 2
Thir,// 3
Fri, // 4
Sta, // 5
Sun // 6
};
enum Color
{
RED, // 0
GREEN = 5, // 5
BLUE // 6
};
typedef enum Sex
{
MALE = 5, // 5
FEMALE, // 6
SECRET // 7
}Sex;
int main()
{
enum Day s1 = Sun;
enum Color s2 = GREEN;
Sex s3 = SECRET;
printf("%d\n", sizeof(s1));
printf("%d\n", sizeof(s2));
printf("%d\n", sizeof(s3));
printf("%d\n", Mon);
printf("%d\n", Tues);
printf("%d\n", Wed);
printf("%d\n", Thir);
printf("%d\n", Fri);
printf("%d\n", Sta);
printf("%d\n", Sun);
printf("%d\n", RED);
printf("%d\n", GREEN);
printf("%d\n", BLUE);
printf("%d\n", MALE);
printf("%d\n", FEMALE);
printf("%d\n", SECRET);
return 0;
}
联合
这种类型定义的变量也包含一系列成员，特征是这些成员公用同一块空间
联合体的特点：
联合的成员是公用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（联合至少有能力保存最大成员的那个成员）
联合大小计算：
1.联合的大小至少是最大成员的大小
2.当最大成员的大小不是最大对齐数的整数倍时的时候，就要对齐到最大对齐数的整数倍。
#include <stdio.h>
union Un
{
char c;
int i;
};
union Un1
{
char c[5];
int i;
};
union Un2
{
short c[7];
int i;
};
int main()
{
union Un u = { 0 };
u.c = 'w';
u.i = 0x11223344;
printf("%d\n", sizeof(u));
printf("%d\n", sizeof(union Un1));
printf("%d\n", sizeof(union Un2));
printf("%p\n", &u);
printf("%p\n", &(u.i));
printf("%p\n", &(u.c));
return 0;
}
判断大小端：
#include <stdio.h>
int cheak_sys()
{
union Un
{
char c;
int i;
}u;
u.i = 1;
return u.c;
}
int main()
{
int ret = cheak_sys();
if (1 == ret) {
printf("小端\n");
} else {
printf("大端\n");
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
