提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
C语言自定义类型详解和总结
提示：以下是本篇文章正文内容，下面案例可供参考
一、结构体
1.结构体的定义：
结构体是一些值的集合，这些值称为成员变量，结构体的每个成员可以是不同类型的变量。
2.结构体的声明：
声明主要由两个部分组成：成员列表，变量列表
2.1有名结构体
// 定义结构体
struct Stu {
char n[10];
char sex;
int age;
}s3 = { "ljh",'男',12 }, s4 = {.age=12,.n="123",.sex='女'};//.来指定顺序初始化
// 全局变量并初始化
struct Stu s1 = { "小明", '男', 23 };
struct Stu s2 = { "ljh", '女', 12 }; // 修改了这里的初始化方式
int main() {
// s4是局部变量
struct Stu s4 = { "www", 'n', 21 };
// 注意，如果我们想修改结构体中的数组数据，
// 错误的写法 s4.name = 'l';
s4.n[0] = 'W'; // 修改第一个字符为'W'，注意大小写
*(s4.n )= 'l';
//不能直接赋值给数组名，而应该通过索引访问并修改或者解引用 ，可以理解为是name是指针，指向的是数组地址同时也是首元素的地址
// 解引用首元素地址修改内容，但是这个name直接修改就把地址修改了，这是不可以的。
//s4.name = 'l';
// 打印修改后的结构体信息
printf("s4: %s, %c, %d\n", s4.n, s4.sex, s4.age);
return 0;
}
2.2匿名结构体
//匿名结构体类型
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
} *p;
struct {//匿名结构体只可以使用一次，不可以在创建变量使用
int age;
char sex;
}q;
int main()
{
q.age = 1;
q.sex = '男';
printf("%d %c", q.age, q.sex);
// p=&x; 非法，虽然这两个结构体看起来相同，但是编译器会把上面的两个声明当成完全不同的两个类型。
return 0;
}2.3结构体的嵌套
struct SN
{
char c;
int i;
}sn1 = { 'q', 100 }, sn2 = {.i=200, .c='w'};//全局变量
struct S
{
double d;
struct SN sn;
int arr[10];
};
int main()
{
struct SN sn3, sn4;//局部变量
printf("%c %d\n", sn2.c, sn2.i);
struct S s = { 3.14, {'a', 99}, {1,2,3} };//结构体嵌套初始化
printf("%lf %c %d\n", s.d, s.sn.c, s.sn.i);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", s.arr[i]);
}
return 0;
}3.结构体的访问
3.1访问操作符: . 和 ->
struct S {
int a;
char b;
}s={.b='e',.a=6}, * p;
int main()
{ //结构体
printf("%d %c\n", s.a, s.b);
p = &s;
//结构体指针
printf("%d %c\n", p->a,p->b);
printf("%d %c\n", (*p).a, (*p).b);
return 0;
}4.结构体的内存对齐
结构体的成员不是在内存中按顺序连续存放的，而是有一定的对齐规则
4.1 内存对齐规则
1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8 Linux中没有默认对齐数，对齐数就是成员自身的大小
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整 体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
4.2结构体大小计算方法
结构体：
struct S1
{
char c1;//1
int i;//4
char c2;//1
};
#include <stddef.h>
int main()
{
struct S1 s1 = { 0 };
printf("%d\n", sizeof(struct S1));//?
printf("%d\n", offsetof(struct S1, c1));//可以计算结构体成员相较于结构体起始位置的偏移量
printf("%d\n", offsetof(struct S1, i));
printf("%d\n", offsetof(struct S1, c2));
return 0;
}
详解：vs中默认对齐数是八，s1中c1是一个字节，规则默认结构体第一个成员偏移量是0，从这个位置占一个字节；然后往下看发现4的位置是 i最小对齐数的整数倍，所以要占4个字节；这时到了偏移量为八的位置，8是c2最小对齐的整数倍，从这个位置占一个字节，这时我们数一下一共有分配了9个字节内存，规则第三个点说到，结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍，s1中最大对数（i）4，9不是4的倍数，往下数到11的位置时内存大小是12，12是4的倍数所以s1大小就是12个字节
结构体嵌套：
struct S3
{
double d; //8 8 8 成员大小 默认对齐数 对齐数
char c;//1 8 1
int i;//4 8 4
};
struct S4
{
char c1;
struct S3 s3;
double d;
};
int main()
{
printf("%d %d %d %d\n", sizeof(struct S4),offsetof(struct S4,c1),offsetof(struct S4,s3),offsetof(struct S4,d));
return 0;
}
详解：c1从偏移量0位置开始占一个字节：s3是一个结构体，对齐数是自身成员变量（S3）中最大的对齐数 也就是double的对齐数8，从c1占一个字节那个位置往下看，偏移量为8的位置刚好是（S3）自身最大对齐数的整数倍，通过计算S3自身大小是16所以要占16个字节，这时也就到了偏移量为24的位置，24刚好是double d 对齐数8的倍数要占八个字节，这时我们看一下一共是32个字节同时32也是结构体S4自身最大对齐数的整数倍，所以这个结构体大小就是32.
4.3为什么要存在内存对齐
1. 平台原因(移植原因)： 不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特 定类型的数据，否则抛出硬件异常。
2. 性能原因： 数据结构(尤其是栈)应该尽可能地在自然边界上对齐。 原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访 问。
总体来说： 结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到： 让占用空间小的成员尽量集中在一起
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
//S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别
4.4如何修改默认对齐数
之前我们见过了 #pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。
修改默认对齐数：#pragma pack(8)//设置默认对齐数为8
还原默认对齐数：#pragma pack()//还原默认对齐数
当我们设置默认对齐数为1时，结构体大小就是自身成员的大小，两个结构体成员列表相同，也就大小相同了。
5.结构体传参
结构体传参一个是传地址，一个是结构体。我们一般用结构体指针传参，为什么呢？因为如果传结构体作为参数，会在内存中会拷贝结构体造成空间消耗而用指针我们只要传地址就好了。
struct S
{
int data[1000];
int num;
};
struct S s = {{1,2,3,4}, 1000};
//结构体传参
void print1(struct S s)
{
printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
printf("%d\n", ps->num);
}
int main()
{
print1(s); //传结构体
print2(&s); //传地址 优先选择
return 0;6.结构体实现位段
6.1什么是位段
位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字
struct A {
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
int main()
{
printf("%d", sizeof(struct A)); 结果是8
return 0;
}
详解：int 是开辟四个字节也就是32 位，_a占2位，_b占5位，_c占10位
注意重点来了明显32位被_a_b_c占了17位剩下的根本存不下_d的30位它就会舍弃剩下（有的平台不会舍弃接着用不够再开辟）另外在开辟一个int的大小来存放_d的30位。
结果就是开了8个字节
6.2 位段的内存分配
6.3 位段的跨平台问题
1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机 器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是 舍弃剩余的位还是利用，这是不确定的。
总结： 跟结构相比，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在
二，枚举
2.1什么是枚举
把可能的取值一一列举。 比如我们现实生活中： 一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举 这里就可以使用枚举了。
2.2 枚举类型的定义
enum color {
blue,
green,//green=6
red
};
int main()
{
printf("%d %d %d", blue, green, red);//0 1 2默认从0开始
// printf("%d", sizeof(blue));类型是int整型 大小占4个字节
// printf("%d %d %d", blue, green, red);0 6 7 枚举常量赋值
return 0;
}enum color 都是枚举类型。 {}中的内容是枚举类型的可能取值，也叫 枚举常量（这些枚举常量类型可以看作整型） 。 这些可能取值都是有值的，默认从0开始，依次递增1，当然在声明枚举类型的时候也可以赋初值。
2.3枚举的优点
枚举跟#define相比优点还是有很多的
1. 增加代码的可读性和可维护性
2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
3. 便于调试 4. 使用方便，一次可以定义多个常量
2.4枚举的使用
enum Color//颜色
{
RED = 1,
GREEN = 2,
BLUE = 4
};
int main()
{
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
printf("%d ", clr);
clr = 5;//可以认为枚举它是int类型的，这个是书上看到的
printf("%d",clr);
}
三，联合
3.1什么是联合
联合也是一种特殊的自定义类型 这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。
3.2 联合的特点
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联 合至少得有能力保存最大的那个成员）。
union Un
{
int i;
char c;
};
int main()
{
union Un un;
// 下面输出的结果是一样的吗？一样共用一块内存空间
printf("%d\n", &(un.i));
printf("%d\n", &(un.c));
//下面输出的结果是什么？联合体大小至少能容纳最大成员大小也就是4个字节，最后一个字节存储c,同时4也是联合体最大对齐的整数倍
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);
return 0;
}
3.3 联合大小的计算
联合的大小至少是最大成员的大小。 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
union Un1
{
char c[5];
int i;
};
union Un2
{
short c[7];
int i;
};
int main()
{
//下面输出的结果是什么？
printf("%d\n", sizeof(union Un1)); 8
printf("%d\n", sizeof(union Un2)); 16
}
联合体大小的计算比较简单，就是联合体中成员变量大小中最大的一个，然后还要满足大小是自身最大对齐数的整数倍比如：Un1 成员变量大小最大的是数组c，这时一共5个字节，但要满足联合体自身最大对齐数的整数倍也就是4的整数倍，也就是8.Un1的大小就是8.
2870
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
