目录
结构体
? ? ? ? ?结构体类型的声明
结构体的基础知识
结构是一些值的集合，这些值称为成员变量。结构体的每个成员可以是不同类型的变量。
结构的声明
struct tag
{
member-list;
}variable_list;例如描述一本书:
//结构体
//声明一个结构体类型
struct Book
{
char name[20];//书名
char author[20];//作者
int price;//定价
}b1,b2;//全局变量
struct Book b3;//全局变量
int main()
{
struct Book b4;//局部变量
}特殊的声明
在声明结构的时候，可以不完全的声明。
比如：
//匿名结构体类型 ->只能用一次，一次性用品
struct
{
int a;
char c;
double d;
}s1, s2;
struct
{
int a;
char c;
double d;
}*ps;上面两个结构在声明的时候省略掉了结构体标签（tag）
那么问题来了？
//在上面代码的基础上，下面的代码合法嘛？
p=&s1;警告：编译器会把上面的两个声明当成完全不同的两个类型，所以是非法的。
? ? ? ? ? 结构的自引用
在结构体中包含一个类型为该结构体本身的成员是否可以呢？
struct Node
{
int data;
struct Node n;
};
//可行否
//这样写是错误的那正确的写法是怎样的呢？
struct Node
{
int data;//数据域
struct Node* next;//指针域
};那么问题又来了，下面这种写法可以嘛？
typedef struct
{
int data;
Node* next;
}Node;
这种写法是不行的，因为我们不知道Node*是哪里来的，这个Node是对于这个匿名结构体类型重命名产生了Node之后才有了这个Node.所以这种写法是不行的，我们应该先定义后使用，这种就跟先有鸡还是先有蛋的问题一样.
那么正确的写法是怎么样的呢？
//正确写法
typedef struct Node
{
int data;
struct Node *next;
}Node;? ? ? ? ? 结构体变量的定义和初始化
看了结构体类型，那么如何定义变量与初始化呢？其实很简单
//结构体变量的定义
struct Point
{
int x;
int y;
}p3,p4;//声明类型的同时定义变量p3,p4
struct Point p2;//定义结构体变量p2
int main()
{
struct Point p1;//定义结构体变量p1
return 0;
}
//结构体变量的初始化
struct Point
{
int x;
int y;
}p3 = { 5,6 }, p4 = { 7,8 };
struct Point p2 = { 1, 2 };
struct S
{
double d;
struct Point p;
char name[20];
};
int main()
{
struct Point p1 = { 3, 4 };//初始化
struct S s = { 3.14, { 1, 5 },"zhangsan" };结构体嵌套初始化
printf("%lf\n", s.d);
printf("%d %d\n", s.p.x, s.p.y);
printf("%s\n", s.name);
return 0;
}
? ? ? ? ? 结构体内存对齐
我们已经掌握了结构体的基本使用了。
现在我们深入讨论一个问题：计算结构体的大小。
这也是一个特别热门的考点：结构体内存对齐。
int main()
{
//练习1
struct S1
{
char c1;
int i;
char c2;
};
printf("%d\n", sizeof(struct S1));
//练习2
struct S2
{
char c1;
char c2;
int i;
};
printf("%d\n", sizeof(struct S2));
//练习3
struct S3
{
double d;
char c;
int i;
};
printf("%d\n", sizeof(struct S3));
//练习4
struct S4
{
char c1;
struct S3 s3;
double d;
};
printf("%d\n", sizeof(struct S4));
}你们可以思考一下上面的四个打印结果分别是什么呢？
打印的结果分别是12 、8、16、32.
?考点 如何计算？首先得掌握结构体的对齐规则：
1.结构体的第一个成员永远放在结构体起始位置偏移量为0的位置
2.结构体成员从第二个成员开始，总是放在偏移量为一个对齐数的整数倍数。
? ?对齐数=编译器默认对齐数和变量自身大小的较小值
? ?Linux-没有默认对其数
? ?VS下-默认对其数是8
3.结构体的总大小必须是各个成员的对齐数中最大那个对齐数的整数倍。
4，如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有对齐数（含嵌套结构体的对齐数）的整数倍。
了解了上面结构体的对其规则之后，下面我们来用这些规则来解析上面的四个练习题吧
练习1.
//练习1 struct S1 { char c1;//自身大小1 默认对其数8 所以对齐数为1 int i;// 自身大小4 默认对其数8 所以对齐数为4 char c2;//自身大小1 默认对其数8 所以对齐数为1 }; printf("%d\n", sizeof(struct S1));
练习2.
//练习2 struct S2 { char c1;//自身大小是1 默认对其数是8 所以对齐数为1 char c2;//自身大小是1 默认对其数是8 所以对齐数为1 int i;//自身大小是4 默认对其数是8 所以对齐数是4 }; printf("%d\n", sizeof(struct S2));
?练习3.
//练习3 struct S3 { double d;// 自身大小是8 默认对其数是8 所以对齐数为8 char c;// 自身大小是1 默认对其数是8 所以对齐数是1 int i;// 自身大小是4 默认对其数是8 所以对齐数是8 }; printf("%d\n", sizeof(struct S3));
练习4.
?
//练习4 struct S4 { char c1;// 自身大小是1 默认对其数是8 所以对齐数是1 struct S3 s3;//因为是嵌套结构体，该结构体中成员变量的最大对齐数是8，所以对齐数是8 double d;// 自身大小是8 默认对其数是8 所以对齐数是8 }; printf("%d\n", sizeof(struct S4));
为什么会存在内存对齐呢？?
大部分的参考资料都是这样说的：
1.平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因：数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对其的内存，处理器需要作两次内存访问；而对其的内存访问仅需要一次访问。
总体来说：
结构体的内存对齐是拿空间换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到呢？
让占用空间小的成员尽量集中在一起。
//例如:
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};?S1和S2类型的成员一模一样，但是S1和S2所占的空间大小有了一些区别。
修改默认对其数
之前我们见过了#pargma这个预处理指令，这里我们再次使用，可以改变我们的默认对其数
#pragma pack(8)//设置默认对齐数为8
struct S1
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对其数，还原为默认
#pragma pack(1)//设置默认对其数为1
struct S2
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对其数，还原为默认
int main()
{
//输出的结果是什么？
printf("%d\n", sizeof(struct S1));//12
printf("%d\n", sizeof(struct S2));//6
return 0;
}结论：
结构体在对齐方式不合适的时候，我们可以自己更改默认对其数。
? ? ? ? ? 结构体传参
struct S
{
int data[1000];
int num;
};
//结构体传参
void print1(struct S tmp)
{
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%d ", tmp.data[i]);
}
printf("\nnum = %d\n", tmp.num);
}
void print2(struct S *ps)
{
//->
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%d ", ps->data[i]);
}
printf("\nnum = %d\n", ps->num);
}
int main()
{
struct S s = { { 1, 2, 3, 4 }, 1000 };
print1(s);//传结构体
print2(&s);//传地址
return 0;
}上面的print1和print2函数哪个好些？
答案是：首选print2函数。原因：
函数传参的时候，参数是需要压栈的，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。
结论：结构体传参的时候，要穿结构体的地址。
? ? ? ? ? 结构体实现位段（位段的填充&可移植性）
什么是位段
位段的声明和结构体是类似的，有两个不同：
1.位段的成员必须是int、unsigned int或者signed int
2.位段的成员名后边有一个冒号和一个数字。
比如：
//位段是可以节省空间的
//位段-二进制位
struct A
{
int _a : 2;//_a 2个bit位
int _b : 5;//_b 5个bit位
int _c : 10;//_c 10个bit位
int _d : 30;//_d 30个bit位
};A就是一个位段类型
那么位段A的大小是多少呢？
printf("%d\n", sizeof(struct A));//8
?
位段的内存分配
1.位段的成员可以是int、unsigned int、signed int或者是char（属于整形家族）类型
2.位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的
3.位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段
//一个例子
struct S
{
char a : 3;
char b : 4;
char c : 5;
char d : 4;
};
int main()
{
struct S s = { 0 };
s.a = 10;
s.a = 12;
s.c = 3;
s.d = 4;
}
//空间是如何开辟的呢？
位段的跨平台问题
1.int位段被当成有符号数还是无符号数是不确定的
2.位段中最大位的数目不能确定（16位及其最大16，32位及其最大32，写在27，在16位机器会出问题。
3.位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4.当一个结构包含两个位段，第二个位段成员较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
总结：
?跟结构相比，位段可以达到通用的效果，但是可以很好的节省空间，但是有跨平台的问题存在。
位段的应用:
我们在网络上使用数据的时候，需要对数据进行封装，这是会就需要存放一些与数据相关的信息，我们暂时把它称为一个数据包。
假如我们不使用位段，那么这个包就会比较大，而且如果网络上所有的数据都背着这样的一个大包，那么网络上那么庞大的数据量，就会造成许多空间的浪费，整个网络也会显得很拥挤，网络状态也会很不好。
而当我们使用位段，包中的信息我们只需要给它分配足够大空间，那么这个包就会小很多，这样的话整个网络就会变得很通畅，网络状态就会更好一些。
枚举
枚举顾名思义就是一 一列举
把可能的取值一 一列举。
比如我们现实生活中：
一周的星期一到星期日是有限的7天，可以一 一列举。
性别有：男、女、保密，也可以一 一列举。
月份有12个月，也可以一 一列举。
颜色也可以一 一列举。
? ? ? ? ? ?枚举类型的定义
//枚举类型的定义
enum Day//星期
{
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun
};
enum Sex//性别
{
MALE,
FEMALE,
SECRET
};
enum Color//颜色
{
RED,
GREEN,
BLUE
};以上的enum Day，enum Sex，enum Color都是枚举类型。{}中的内容是枚举类型的可能取值，也叫枚举常量。
?我们可以看到，这些枚举常量是有值的，默认从0开始，一次递增1.
当然我们也可以在定义的时候给它赋值
?我们要注意的是，Color是一个枚举类型，它里面放的是枚举类型变量的未来可能的取值。我们只能在定义枚举类型的时候给它们赋初值，但是不能在后面创建变量的时候修改它的值。
? ? ? ? ? ?枚举的优点
为什么使用枚举？
我们可以使用#define定义常量，为什么非要使用枚举？枚举的优点：
1.增加代码的可读性和维护性
2.和#define定义的标识符比较枚举有类型检查，更加严谨
3.#define定义的常量是直接暴露在全局范围内的，而我们定义的枚举常量是被封装在一个类型里面的，防止了命名污染（封装）
4.便于调试。通过枚举类型创建变量，我们是可以在程序中通过调试来观察，而#define定义的标识符常量实际上只是一种等价替换我们调试的时候只会看到数值，压根就不会看到GREEN的存在。
??
5.使用方便，一次可以定义多个常量
? ? ? ? ? ?枚举的使用
记得我们之前写过简易的计算器
int main()
{
int input = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
//加法
break;
case 2:
//减法
break;
case 3:
break;
case 4:
break;
case 0:
break;
}
} while (input);
return 0;
}我们这样写，我们想要知道1，2，3，4，0代表的是什么就必须得往上看菜单所以这样写多少会有点别扭。
但是我们如果定义了一个枚举类型，那么我们就可以一目了然了（增加了代码的可读性）
enum Option
{
EXIT,//0
ADD,//1
SUB,//2
MUL,//3
DIV//4
};
void menu()
{
printf("*****************************\n");
printf("*****1.add 2.sub *******\n");
printf("*****3.mul 4.div *******\n");
printf("*****0.exit *******\n");
printf("*****************************\n");
}
int main()
{
int input = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case ADD:
//加法
break;
case SUB:
//减法
break;
case MUL:
break;
case DIV:
break;
case EXIT:
break;
}
} while (input);
return 0;
}联合（共用体）
? ? ? ? ? ?联合类型的定义
联合也是一种特殊的自定义类型 这种类型定义的变量也包含一系列的成员，特征是这些成员共用同一块空间（使用联合也叫共用体）比如：
//联合类型的声明
union Un
{
char c;
int i;
};
//联合变量的定义
union Un un；
? ? ? ? ? ?联合的特点
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）
//联合类型的声明
union Un
{
char c;
int i;
};
int main()
{
union Un u = { 0 };
//printf("%d\n", sizeof(u));
printf("%p\n", &u);
printf("%p\n", &(u.c));
printf("%p\n", &(u.i));
return 0;
}你认为后面打印的三个结果是一样的嘛？
答案是一样的。
?
?这也就是为什么联合体也叫共用体。并且需要注意的是，我们改变i的时候c也会被改变，改变c的时候也会改变了i的值。
那么利用联合体我们也可以来判断当前机器使用的是大端字节序还是小端字节序。（关于机器大小端字节序的内容，忘记的同学可以看看我前面的这篇文章——https://blog.csdn.net/weixin_51885188/article/details/119782258）
union Un
{
char c;
int i;
};
//判断当前计算机的大小端存储
int main()
{
int a = 1;//0x 00 00 00 01
//低---------------------->高
//01 00 00 00 - 小端存储
//00 00 00 01 - 大端存储
union Un u = { 0 };
u.i = 1;
if (u.c == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
?
? ? ? ? ? ?联合大小的计算
联合体的大小至少是最大成员的大小
当最大成员大小不是最大对其数的整数倍的时候，就要对齐到最大对其数的整数倍
比如:
union Un1
{
//对齐数
char c[5];//5 1
int i;//4 4
};
union Un2
{
short c[7];//14 2
int i;//4 4
};
int main()
{
//下面输出的结果是什么呢？
printf("%d\n", sizeof(union Un1));//8
printf("%d\n", sizeof(union Un2));//16
return 0;
}
?以上就是C语言中的自定义类型，如果觉得博主的文章对你有帮助或者对它感兴趣的话可以点赞评论收藏一波哦！