目录
结构体：
C语言中，我们之前使用的都是C语言中内置的类型，比如整形（int）、字符型（char）、单精度浮点型（float）等。但是我们知道，我们现实世界中，还有很多其他类型。比如书，水杯，人等各种类型。
结构体的使用：
在使用结构体之前，我们先来看看结构体的基本使用语法：
当内置类型无法满足我们的我们的需求（像定义一本书），此时就会用到结构体了，它就可以自定义一个类型。比如书就是一种类型，组成它的元素就是木头，墨水，胶水等，这些就是组成书的基本元素。而在编程语言中，我们定义一本书，它的基本元素就可以理解为C语言的内置类型，由这些内置类型组合而成。
struct Book
{
//书由一下属性（元素）组成
char Book_Name[20];//书的名字
char Writer_Name[20];//作者姓名
int edition;//版本号
};//此时变量列表为空此时我们就自定义了一种书的类型，这时就可以定义多个书的变量。书是类，那么具体的一本书就是一个书变量（也可以理解为对象），此时我们第一定义一个书的变量，并打印。注：变量列表可以为空
struct Book
{
//书由一下属性（元素）组成
char Book_Name[20];//书的名字
char Writer_Name[20];//作者姓名
int edition;//版本号
};
int main()
{
struct Book Book1 = { "大话数据结构", "张三", 20 };
printf("书名是:%s\n", Book1.Book_Name);
printf("作者是:%s\n", Book1.Writer_Name);
printf("版本是:%d\n", Book1.edition);
return 0;
}
我们用 . 来访问变量中的每一个成员（这不是使用指针的情况）。要按照顺序来定义每一个变量，. 就是一个操作符，意思可以理解为“的”。
每一种类型都有对应的指针，所以结构体也有指针，就是结构体指针。我们用指针访问结构体变量时就需要用到 -> 来指定访问变量的哪一个具体成员属性。
struct Book* p = &Book1;
//定义结构体指针指向变量Book1
//因为其他类型只需要解引用，但是结构体有多个成员
//用指针找到结构体变量的每一个成员需要用到 ->
printf("书名是:%s\n", p->Book_Name);
当然也可以对其解引用之后再使用 . 操作符访问具体成员属性。
//通过解引用再使用 . 来访问具体属性
printf("书名是:%s\n", (*p).Book_Name);
现在我们来举例成员列表的使用。比如此时我们使用成员列表，声明多个成员：
struct Book
{
//书由一下属性（元素）组成
char Book_Name[20];//书的名字
char Writer_Name[20];//作者姓名
int edition;//版本号
}Book1, Book2, Book3;//这3个相当于全局结构体变量
int main()
{
struct Book Book4;//局部变量
return 0;
} 就相当于全局变量。但是C语言并不支持直接在主函数中直接对全局结构体变量进行赋值。
此时对赋值属性的字符串赋值也不能使用以下方法赋值：
Book1.Book_Name = "大话数据结构";
我们只能使用strcpy函数赋值；但对于整数属性的赋值可以直接赋值：
strcpy(Book1.Book_Name, "大话数据结构");
printf("书名是：%s\n", Book1.Book_Name);
Book1.edition = 20;
printf("版本是：%d\n", Book1.edition);
之后有人就经常和typedef搞混，因为用法相似：
typedef struct Book
{
//书由一下属性（元素）组成
char Book_Name[20];//书的名字
char Writer_Name[20];//作者姓名
int edition;//版本号
}book;此时我们相当于将struct Book重命名了（重命名具体用法可先查看其他文章），之后定义该结构体变量不需要使用struct Book，而直接使用book声明该变量的类型即可：
book Book1 = { "大话数据结构", "张三", 20 };这里相当于定义了一本书，由于使用了typedef函数，可以省略struct关键字，写出结构体名称，创建变量即可，这里创建了2个变量，之后打印变量名.成员。
//两种形式都可以使用
book Book1 = { "大话数据结构", "张三", 20 };
struct Book Book2 = { "C语言", "我", 1 };
printf("书名是:%s\n", Book1.Book_Name);
printf("书名是:%s\n", Book2.Book_Name);
结构体成员可以是结构体，要用大括号来说明结构体中另外的结构体。
struct s
{
int a;
char c;
char arr[20];
double d;
};
struct t
{
char ch[10];
struct s s;
//结构体成员可以是结构体
char* pc;
};
int main()
{
char arr[] = "holle bit";
struct t t1 = { "hehe",{3,'u',"holle world",3.14},arr };
printf("%s\n", t1.ch);//hehe
printf("%s\n", t1.s.arr);//holle world
printf("%d\n", t1.s.a);//3
printf("%lf\n", t1.s.d);//3.140000
printf("%s\n", t1.pc);//holle bit
return 0;
} 这里结构体成员中有指针，我们创建一个数组，把数组名放进去。 
结构体的传参：
我们知道，形参是实参的一份临时拷贝，我们对结构体进行传参时，如果是传值，就是函数中把这个结构体变量临时复制一份，这样无疑会浪费很多空间。
所以我们一般进行传址调用，就是传入结构体的指针：
typedef struct stu
{
char name[20];
short age;
char tele[12];
char sex[5];
}stu;
void print1(stu s)
{
printf("%s\n", s.name);//张三
printf("%d\n", s.age);//40
printf("%s\n", s.tele);//15568886688
printf("%s\n", s.sex);//男
//不是指针就用"."
}
void print2(stu* p)
{
printf("%s\n", p->name);
printf("%d\n", p->age);
printf("%s\n", p->tele);
printf("%s\n", p->sex);
//指针就用箭头
}
int main()
{
stu s = { "张三",40,"15568886688","男" };
print1(s);//用这个不太好
print2(&s);//用这个函数比较好
return 0;
}
函数传参时，参数是需要压栈的。如果传递一个结构体对象的时候，结构体过大，参数压栈系统开销比较大，所以会导致性能的下降。结论：结构体传参的时候，要传结构体的地址。
匿名结构体：
匿名结构体，顾名思义，就是没有名字的结构体，意味着没有标签，但有一个成员变量。
struct
{//匿名结构体类型
int a;
char c;
}sa;
struct
{//匿名结构体类型
int a;
char c;
}*psa;//匿名结构体指针类型
int main()
{
psa = &sa;//编译器会认为这是两种不同的类型
return 0;
}一般最好不要使用，使用一次以后就最好不要使用了。
结构体的自引用：
结构体可以自信用，并不是递归。结构体类型中可以有一个同类型的结构体指针，结构体自引用牵扯到数据结构，先大致了解。
//结构体的自引用
//数据结构:链表
//在内存中,每个数据是随机分布的,为了让他们有规律的连接起来,就要用到链表
//
struct Node
{
int data;
struct Node *next;
};
int main()
{
return 0;
}
因为typedef可以定义数据类型的名字，所以可以：
typedef struct Node
{
int data;
struct Node* next;
}Node;
int main()
{
struct Node n1;
Node n2;
return 0;
}结构体的大小：
这是结构体最重要的部分，因为我们一定要知道每个类型在内存中的占据规则。结构体在内存中的占据规则是很复杂的。
结构体内存占据规则：
结构体占据内存遵循地址对齐。第一个成员在与结构体变量偏移量为0的地址处对齐。所有成员都会遵循字节对齐，且第一个成员总是在与结构体变量偏移量为0的地址处对齐。其实结构体是先在内存中找到能被第一个类型整除的地址。
结构体每个成员都遵循地址对齐，对齐数是根据系统对齐数和当前成员大小对齐的。
对齐数 = 编译器默认的对齐数 与 改成员大小的较小值
vs编译器默认对齐数为8。
struct S3
{
double d;
char c;
int i;
}; 先看第一个成员，占据8个字节，所以先在内存中找到能被8整除的地址，偏移量为0（我们一会再解释）,所以先占据8个字节，之后又找能被下一个成员内存（较小的对齐数是1）整除的地址，最后又找能被4整除的地址，最后整体结构体大小必须是当前最大成员属性大小的整数倍。
即使VS默认对齐数是8，但是结构体大小是根据自己本身成员属性最大整数倍对齐的。
结构体嵌套：
结构体可是可以嵌套的。
struct S3
{
double d;
char c;
int i;
};
struct s4
{
char c1;
struct S3 s3;
double d;
};
使用pragma来指定对齐数：
我们可以自己设置默认对齐数，提高空间利用效率，因为对齐数总是等于较小值。先设置默认对齐数为2几次方。要加入预处理指令#pragma pack(设置的默认对齐数)
#pragma pack(1)//设置默认对齐数为4
struct S
{
char c1;//1
double d;//8
};
#pragma pack()//取消设置的默认对齐数
int main()
{
struct S s;
printf("%d\n", sizeof(s));
return 0;
}
此时最小默认对齐数为1，所以所有属性都找到能被1整除的地址即可。结构在对齐方式不合适的时候，我蛮可以自己更改默认对齐数。一般是2几次方。
相对偏移函数offsetof：
我们可以求出它相对于结构体偏移了几个字节。要引入头文件stddef.h。
#include<stddef.h>//offsetof的头文件
struct S1
{
char c1;
char c2;
int i;
};
int main()
{
printf("%zd\n", offsetof(struct S1, c1));
printf("%zd\n", offsetof(struct S1, c2));
printf("%zd\n", offsetof(struct S1, i));
return 0;
}
相对起始位置的偏移量。
内存对齐的意义：
- 平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的数据的，某些硬件只能在某某些地址处去某些特定类型的数据，否则抛出异常。
- 性能原因：对于未对齐的内存，处理器需要两次内存访问；而对齐的的内存访问仅需要一次。假设一个处理器总是从内存中取8个字节，则地址必须是8的倍数，如果我们能保证将所有的doubl类型数据的地址都对齐成8的倍数，就可以用一个内存操作来读取或者写值了，否则，我们可能需要执行两次内存访问，因为对象可能分放在两个8字节内存中。
总体来说，结构体的内存对齐是拿空间来换时间的做法。我们在设计结构体是，既要满足对齐，又要节省空间，所以我们让占用空间小的成员尽量集中在一起。
位段：
位段是什么？
位段的出现就是为了节省空间，因为结构体遵循内存对齐，有时候会造成空间浪费，于是衍生出来了位段。位段的声明和结构体是类似的，有两个不同：
-
位段成员必须是int、 unsigned int 、signed int或者char等类型。
-
位段的成员名后面有一个冒号和一个数字。
位段的使用和大小：
位段的使用是类似于结构体的。
//1.位段的成员必须是int、unsigned int、signed int
//2.位段的成员名后有一个冒号和数字
//位段 - 二进制位
struct A
{
int a : 2;//2
//冒号后面的数字表示a只需要两个比特位就够了
int b : 5;//5
int c : 10;
int d : 30;
};
//47bit - 6个字节*8 = 48bit
//因为位段有自己的对齐方式
int main()
{
struct A s;
printf("%d\n", sizeof(s));//8个字节
return 0;
}
上图中A就是一个位段类型。A的大小是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 = 20;
s.c = 3;
s.d = 4;
return 0;
}
上面的代码就是相当于先创建一个位段类型，之后声明每个成员占多少个bit，之后有给成员赋值，但很明显，给a赋值10所占据的比特位已经超过了3个bit，于是只将10的二进制前后3个为给成员a。如果不够，高位补0。之后以此类推。
位段成员的赋值：
位段的几个成员共有一个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。
内存中每个字节分配一个地址，一个字节内部的bit位是没有地址的，所以不能对位段成员使用&操作，这样就不能使用scanf直接给位段的成员输入值，只能是先输入放在一个变量中，然后赋值给位段的成员。
struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
int main()
{
struct A sa = { 0 };
//scanf("%d", &sa._b);//这里报错
//只能这样赋值
int b = 0;
scanf("%d", &b);
sa._b = b;
printf("%d\n", sa._b);
return 0;
}
位段存在的意义：
学过网络的都知道，我们的数据都是封装成帧发送的，我们一般采用IP数据报的形式发送，我们观察IP数据报的格式：
因为地址最小的的地址编号是字节，1个字节8个bit位，若使用结构体，必然会造成空间的浪费，位段的出现使我们将每一个bit位都合理的使用，但有人会问？既然现在硬件内存都那么大了，还有必要限制内存吗？
我们可以将网络通道想象成一条高速公路，如果都是大型文件，就像是都是大卡车，这样势必会造成交通拥挤；但是如果都是小文件，就是小客车，即使会用交通拥挤也会比都是大卡车的路况好。
位段的跨平台问题：
- int位段被当做有符号数还是无符号数是不确定的。
-
位段中最大位的数目不确定。(16位机器int是2个字节,写成27会出问题)。
-
位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
-
当一个结构包括两个位段，第二位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这个是不确定的。
最后我们来看几道关于位段的练习题：
习题一：
int main()
{
unsigned char puc[4];
struct tagPIM
{
unsigned char ucPim1;
unsigned char u0 : 1;
unsigned char u1 : 2;
unsigned char u2 : 3;
}*p;
p = (struct tagPIM*)puc;
memset(puc, 0, 4);//设置4个字节,每个内容为0
p->ucPim1 = 2;
p->u0 = 3;
p->u1 = 4;
p->u2 = 5;
printf("%02x %02x %02x %02x\n", puc[0], puc[1], puc[2], puc[3]);//%02x打印出两个16进制的数
return 0;
}
习题二：
#define A 2
#define B 3
#define MAX_SIZE A+B
struct s
{
unsigned char E : 4;
unsigned char P1 : 2;
unsigned char state;
unsigned char a1 : 1;
}*p;
int main()
{
struct s* ptr = (struct s*)malloc(sizeof(struct s) * MAX_SIZE);
return 0;
} 问开辟了多大的空间？首先我们要知道结构体的大小。
这里面的成员列表中的*p并没有使用，就是在迷惑你。
因为这里使用的是宏定义的运算，没有带括号，所以带入运算也不会带有括号，是整体带入。所以拆分下来就是：
struct s* ptr = (struct s*)malloc(sizeof(struct s) * MAX_SIZE);
//sizeof(struct s) = 3
//MAX_SIZE = A + B = 2 + 3
//3 * 2 + 3 = 9所以最终分配了9个字节。
1003
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
