自定义类型
一、结构体
在面对复杂对象的时候，描述这个对象的类型不会是单一的。例如我们想介绍一个学生，我们要知道他的姓名，性别，学号……。而结构体就是一些这样的值 的集合，这些值即所谓的成员变量，使C语言有能力描述复杂对象。
1. 简单介绍
①声明
-
结构体声明：
-
匿名结构体声明
在声明结构体时，可以不完全声明，就比如匿名结构体类型
//匿名结构体类型只能使用一次
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
}a[20], *p;
//上面两个结构体在声明的时候省略掉了结构体标签（tag）
p = &x;//这个是非法的，编译器会把上面两个声明当成完全不同的两个类型
理解匿名结构体类型只能使用一次：一旦定义了匿名结构体，不能显式地创建该匿名结构体的对象了
②结构体的自引用
eg1：
// error方式
struct Node
{
int data;
struct Node next; //这个结构体会一直向下开辟空间（有点像递归），我们不知道这个结构体的大小
};
//正确的自引用方式
struct Node
{
int data;
struct Node* next; //这里我们明确知道结构体大小是：一个整型 + 一个指针
};
注：遵循先来后到的原则，不能说后面刚定义，前面都用了
eg2：
//错误
typedef struct Node
{
int data;
Node* next; //这样不行，后面刚定义，而这里就已经使用。所以这里只能正常定义
}Node;
③成员变量的定义和初始化
eg：
#include <stdio.h>
struct Point
{
int x;
int y;
}p1;
struct Point p2;
//p1,p2结构体变量都是全局变量
//初始化：定义的同时赋初值
struct Point p3 = { 3,4 };
struct Stu
{
char name[20];
int age;
};
struct Stu s = { "zhangsan",20 };
struct Node
{
int data;
struct Point p; // 结构体类型的成员变量
struct Node* next;
}n1 = { 10,{4,5},NULL }; // 结构体嵌套初始化
struct Node n2 = { 20,{5,6},NULL }; //结构体嵌套初始化
//不一定是完整的初始化，也可以初始化一部分
//乱序初始化
struct Node n3 = { .p.x = 3,.p.y = 5,.data = 4 };//*************
④结构体传参
可以直接把结构体对象传过去，也可以传结构体对象的地址（传地址，减少压栈、拷贝等消耗）
结论：结构体传参，要传结构体地址
2. 结构体内存对齐
①结构体大小
想要计算结构体大小，就要晓得结构体对齐规则，先介绍规则，再举例
- 结构体对齐规则
- 第一个成员在结构体开辟内存的第一个位置（也就是结构体变量偏移量为0的地址处）。
- 其他成员变量要对齐到对齐数的整数倍的地址处。
对齐数 = min(编译器默认的对齐数, 该成员大小（字节）)
（在vs中默认对齐数为8----gcc没有最大对齐数，只有本身的大小。）
eg：int 是4而默认对齐数是8，则对齐数就是4. - 结构体大小为最大对齐数（每个成员变量都有自己的对齐数）的整数倍。
- 如果出现结构体嵌套的情况，嵌套的结构体对齐到自己最大对齐数的整数倍处。最后结构体整体的大小就是所有最大对齐数的整数倍（包含嵌套结构体的最大对齐数）。
介绍一个宏offsetof ：用来计算结构体成员相对起始位置的偏移量。使用时要包含头文件<stddef.h> （小结部分，模拟实现offsetof）
eg1：
#include <stdio.h>
#include <stddef.h>
struct S2
{
double d;//8 8-->8--对齐数
char c; //1 8-->1--对齐数
int i; //4 8-->4--对齐数
};
int main()
{
printf("%d ", sizeof(struct S2));
printf("%d ", offsetof(struct S2,d));
printf("%d ", offsetof(struct S2, c));
printf("%d ", offsetof(struct S2, i));
return 0;
}
// 输出:16 0 8 12
eg2：结构体嵌套
#include <stdio.h>
#include <stddef.h>
struct S2
{
double d;//8 8-->8--对齐数
char c; //1 8-->1--对齐数
int i; //4 8-->4--对齐数
};
struct S3
{
char c1;
struct S2 s2; //最大对齐数是8
double d;
};
int main()
{
printf("%d ", sizeof(struct S3));
printf("%d ", offsetof(struct S3,c1));
printf("%d ", offsetof(struct S3, s2));
printf("%d ", offsetof(struct S3, d));
return 0;
}
// 输出:32 0 8 24
②修改默认对齐数
#pragma pack(1) //设置默认对齐数为1
struct S2
{
char c1;
int i;
char c2;
};
#pragma pack() //取消设置的默认对齐数，还原为默认
③小结
对齐的原因：拿空间换时间
小结：在设计结构体时，尽量让占用空间小的成员经量集中在一起。
offsetof模拟实现：
// 注意：这个函数并不完全等同于 offsetof 宏，知识简单的用函数模拟实现，存在问题
size_t my_offsetof(const void *struct_ptr, const void *member_ptr)
{
const char *struct_char_ptr = (const char *)struct_ptr;
const char *member_char_ptr = (const char *)member_ptr;
return (size_t)(member_char_ptr - struct_char_ptr);
}
3. 位段
①介绍
位段的声明和结构体是类似的，区别在于
- 位段的成员只能是整型家族。
- 位段的成员名后有一个冒号和一个数字。
eg：
#include <stdio.h>
//位段-->位-->二进制位
struct A
{
int _a : 2; //_a只占2个二进制位
int _b : 5; //....
int _c : 10;
int _d : 30;
//冒号后面的数字不能超过32
};
int main()
{
printf("%d\n", sizeof(struct A)); // 8
return 0;
}
②位段的内存分配`
- 位段的空间上是按照四个字节（int）或者一个字节（char）的方式开辟的。
- 位段涉及很多不确定的因素，位段不具备跨平台性，所以可移植程序要避免使用位段。
eg：
#include <stdio.h>
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;
printf("%d\n", sizeof(struct S)); // 3
return 0;
}
解释：
根据图，可以看出一共三个字节。接下来我们观察三个字节的值看是不是这样。
十六进制 二进制
0x62 --> 0110 0010
0x03 --> 0000 0011
0x04 --> 0000 0100
③位段存在的问题
- int位段被当初有符号数还是无符号数是不确定的。
- 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32）
- 位段中的成员在内存中从左向右分配，还是从右向左分配，标准尚未定义。
- 当一个结构体包含两个位段，第二个位段成员较大；无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
④小结
跟结构体相比，位段可以达到同样的效果，但是可以很好的节省空间。但是存在跨平台的问题。
在位段应用在计网中
二、枚举
1. 介绍
枚举顾名思义就是一一列举。
eg：以下定义的enum Day, enum Sex, enum Color都是枚举类型，{}中的内容叫做枚举常量。
enum Day
{
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun
};
enum Sex
{
MALE,
FEMALE,
SECRET
};
enum Color
{
RED,
GREEN,
BLUE
};
eg2：枚举常量是有值的，默认是0,一次递增1，当然定义的时候也可以赋初值
enum Color
{
// 如果只有第一个枚举常量赋初值，则下面的递增1.
// 如果只有第二个赋初值，则第一个为0，第二个之后递增1
// 也可以每个都自定义赋值
RED=1,
GREEN=2,
BLUE=4
};
优点：
- 增加代码的可读性和可维护性。
- 和#define定义的标识符比较枚举有类型检查，更加严谨。
- 防止命名污染（封装）。
- 便于调试。（#define不调试）
- 使用方便一次可以定义多个常量。
2. 使用
eg：
#include <stdio.h>
enum Color
{
RED = 1,
GREEN = 2,
BLUE = 4
};
enum Color clr = GREEN; // ok 只能拿枚举常量给枚举变量赋值
//clr = 5; //error 这样不行
int main()
{
printf("%d ", sizeof(enum Color));
printf("%d\n", sizeof(RED));
return 0;
}
//output:4 4
枚举的大小相当于enum中元素最大的那个
三、联合
1. 介绍
联合也是一种特殊的自定义类型。但这种类型定义的变量也包含一系列成员，特征是这些成员共用同一块空间（因此联合也叫共用体）。
注：
- 联合体中的成员在内存中具有相同的首地址，因此它们可以相互覆盖。这意味着在某一时刻，只有最新存储的成员是有效的，因为所有成员都位于同一内存位置
- 联合体的大小取决于其最大成员的大小
- 注意成员之间的覆盖和有效性的问题
eg：
//联合类型的声明
union Un
{
char c;
int i;
};
//联合变量的定义
union Un un;
//&un、&(un.c)和&(un.i)地址相同
int main()
{
//计算联合变量大小
printf("%d\n", sizeof(un));
}
//output:4
2. 特点
联合的成员是共用同一块内存空间，这样一个联合变量的大小，至少是最大成员的大小（因为联合要有能力保存最大的那个成员）
eg1：
#include <stdio.h>
union Un
{
int i;
char c;
};
union Un un;
int main()
{
printf("%p\n", &(un.i));
printf("%p\n", &(un.c));
un.i = 0x11223344;
un.c = 0x55; // 会覆盖i的低位部分
printf("%x\n", un.i);
return 0;
}
//output:
//0002A13C
//0002A13C
//11223355
解释输出内容：
- 联合的成员空间是共用的，所以地址是一样的。
- 第一个字节共用，所以不能同时使用，不然会出现问题
eg2：判断当前计算机的大小端存储
#include <stdio.h>
union Un
{
char c;
int i;
}un;
int main()
{
un.i = 1;
if (un.c == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
3. 联合大小的计算
- 联合的大小至少是最大成员的大小。
- 当最大成员不是最大对齐数的整数倍时，就要对齐到最大对齐数的整数倍
eg：
#include <stdio.h>
union Un1
{
char c[5];//1 8--->1
int i; //4 8--->4
};
union Un2
{
short c[7];//2 8-->2
int i; //4 8-->4
};
int main()
{
printf("%d ", sizeof(union Un1));
printf("%d\n", sizeof(union Un2));
return 0;
}
// 输出:8 16
265
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
