【C语言】自定义类型：结构体，位段，枚举，联合

结构是一些值的集合，这些值称为成员变量。结构的每个成员都可以是不同类型的变量。

结构体的声明：

struct tag  //结构标签
{
  member-list;  //成员列表
}variable-list;  //变量列表

结构体成员的访问：
【（.）点操作符】

假如描述一个学生：
#include<stdio.h>
#include<string.h>
struct Stu  //Stu  是结构体标签
{
   char name[20];  //名字  |
   int age;   //年龄       | ------成员列表
   char sex[5];  //性别    |
 }；// 分号不能丢
 int main()
 {
   struct Stu S1;
   strcpy(s1.name,"zhangsan"); //应该用strcpy,name是数组名，相当于首元素地址，应放到地址指向的空间里。使用（.）访问name成员
   s1.age = 20;  //使用（.）访问age成员

   strcpy(s1.sex,"男");
   printf("%s\n",s1.name,);
   return 0;

 }

结构体访问指向变量的成员，有时候我们得到的不是一个结构体变量，而是一个指向结构体的指针。
【箭头操作符】

> printf("%s %d %s\n",(*ps).name,(*ps).age,(*ps).sex);

> printf("%s %d %s\n",ps->name,ps->age,ps->sex);

ps->name 通过ps找到它所指向的对象，再拿出它的成员name。

结构的自引用

struct Node
{
  int data;
  struct Node* next;
};

结构体的不完整声明：

struct B;
struct A
{
  int_a;
  struct B* pb;
};
struct B
{
   int _b;
   struct A* pa;
};

结构体变量的定义和初始化：

struct Stu
{
char name[20];
int age;
};
int main()
{
struct Stu s = {“zhangsan",20};//结构体的初始化要带大括号，把整体放在一起，因为它的成员很多。
printf(%s %d\n",s.name,s.age);//打印出来，结果是 zhangsan 20。
int n = 0;//对于n的初始化
return 0;
//这些是结构体一些非常简单的初始化。但结构体的初始化可不仅限于此。。。
}

我们来看看下面的代码：

struct Stu  //类型声明
{
char name[15];  //名字
int age;   //年龄
}；
struct Stu s = {"zhangsan",20};  //初始化

-----------------------------------------------------

struct S
{
int age;
char *p;
};

struct A
{
char c;
int a;
char arr1[10];
int arr2[10];
struct S s;
double d;
};

int main()
{
struct A sa = {'a',2,{'a','b','c'},{1,2,3},{20,null},3.14};
sa.s.age = 30;
}
-------------------------------------------------------------
struct Node
{
int data;
struct Point p;
struct Node* next;
}n1 = {10,{4,5},NULL};  //结构体嵌套初始化

struct Node n2 = {20,{5,6},NULL};//结构体嵌套初始化
}
//其实也很简单。

结构体内存对齐： 以空间换取时间的一种做法

结构体的对齐规则：

1.第一个成员在与结构体变量偏移量为0的地址处。
2.其他成员变量要对其到某个数字，（对齐数）的整数倍的地址处。对齐数=编译器默认的一个对齐数与该成员大小的较小值。vs中默认为8 ， Linux中默认为4。
3.结构体的总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

为什么存在内存对齐？

1.平台原因（移植原因）：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因：
数据结构（尤其时栈）应该尽可能的在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要做两次内存访问；而对齐的内存访问仅需要一次访问。

总体来说：

结构体的内存对齐是拿空间换取时间的做法。

struct S1
{
int a;
char c1;
char c2;
};
struct S2
{
char c1;
int a;
char c2;
};
int main()
{
printf("%d\n",sizeof(struct S1));  //8
printf("%d\n",sizeof(struct S2));  //12
}
两个结构体内容一样，为什么结果却有出入呢？这个跟偏移量是有关系的。
这个先暂且放到一边，我们看一下这个：

**pragma pack(1)**
 struct S1
{
int a;
char c1;
char c2;
};
**pragma pack()** 
 //结果是6 
pragma pack()可以修改默认对对齐数。
好了，现在我们回头看一下怎么计算结构体大小：
在不同的平台上，默认对齐数是不一样的，在Windows平台上，它的默认对齐数是8，Linux平台默认对齐数是4.Linux平台主要是gcc环境。
在对齐数不合适的时候，我们可以自己更改默认对齐数。最好是2的倍数。

struct S1
{
char c1;  //大小是1，第一个成员放到0偏移处。
int a;  
a的大小是4，默认对齐数是8，4和8其中的较小值是4，a的对齐数就为4，
从第二个成员开始，每个对齐数都要对齐到某个对齐数的整数倍数，
这个对齐数就是自身大小和默认对齐数的较小值，a的自身大小是4，默认对齐数是8，
那么较小值是4，那么a就要对齐到4的倍数处，对于a来说就占了4个字节。
//结构体的总大小是所有对齐数中最大对齐数的整数倍。
}//所以这个结构体大小是8.
int main()
{
printf("%d\n",sizeof(struct S1));
}
--------------------------------------------------------------------
struct S1
{
char c1;
int a;
};
printf("%d\n",offsetof(struct S1,c1));  //0
printf("%d\n",offsetof(struct S1,a));  //4
拓展：offsetof  计算一个结构体成员在这个结构的偏移量。头文件#include<stddef.h>
return 0;
}
划重点：面试可能会考！！！

> #define offsetof(s,m)  (size_t)&(((s *)0)->m)
> S1就是s   m就是c1
> 我们把它替换进去：
> #define offsetof(S,m)  (size_t)&(((struct S1 *)0)->c1);
> printf("%d\n",(size_t)&(((struct S1 *)0)->c1);
 这里是把0强制类型转换成结构体指针，->c1,是指向它的成员。
 这句话的意思是找0地址处存放那个结构体变量的成员c1，既然这个变量从0地址处开始的，
 那么c1的地址就跟它的偏移量一样，偏移量就是它从起始位置开始的一个差值，
 所以c1的地址就是从0开始向后走了几个字节。所以当我们找到c1之后，进行取地址，
 取得地址就是它的偏移量，既然取得是地址那么把它转换成size_t变成整型就是偏移量。

小练习：
写出下面结构体的大小：

1.
 struct S
 {
 char c1;
 int a;
 char c2;
}//12

2.
struct S1
{
char c1;
char c2;
int a;
}//8

3.
struct S2
{
double d;
char c;
int i;
}//16

4.
struct S3
{
char c;
double d;
int i;
}//24

5.结构体嵌套问题  (请看对齐规则第四条）
struct S4
{
char c1;
struct S3 s3;
double d;
};

6.  把默认对齐数改成4再来看一看

#pragma pack(4)
struct S3
{
char c;
double d;
int i;
}//16

struct S4
{
char c1;
struct S3 s3;
double d;
};//28
#pragma pack()

pragma once //表示把一个头文件只引一次，防止它被多次使用。

pragma commnet(lib,”xxx.lib”) // xxx就是这个文件的名字

结构体传参

struct S
{
 char name[20];
 int age;
};

void Set(struct S* ps)
 {
   strcpy(ps->name,"zhangsan");
   ps->age = 20;
 }
 void print(struct S s)
 {
   printf("name=%s  age = %d\n",s.name,s.age);
 }
 int main()
 {
  struct S s = {0};
  Set(&s);
  Print(s);
  return 0;
}
//name = zhangsan  age  =20;
相对于传值，传地址应该好一点。
函数传参，参数需要压栈，如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。
传地址：节省参数压栈的系统开销，提高性能。

位段

位段的声明和结构是类似的，区别有两个：
1.位段成员必须是int ,unsigned int ,signed int.
2.位段的成员后边有一个冒号和一个数字。
比如：

struct A
 {
   int _a:2;//说明a只用2个bit位。开辟一个整型，整型4个字节32个bit位，a用掉2个还有30个
   int _b:5;  //说明b只用5个bit位。b用掉5个后还有25个，
   int _c:10; //c用掉10个还有15个
   int _d:30; //d不够用了，那就再开辟一个整型，所以 一共开辟了8个字节。
 };
 int main()
 {
 printf("%d\n",sizeof(struct A));//8
 return 0;
 }

位段的跨平台问题：
1.int 位段被当作是有符号数还是无符号数是不确定的。
2.尾端中最大位的数目是不能确定的。（16位机器最大位是16，32位机器最大位是32，写成27，16位的机器会出问题。
3.位段的成员在内存中从左向右分配，还是从右向左分配尚未定义。

总结：当一个结构包含两个位段，第二个位段成员比较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，是不确定的。

枚举

枚举顾名思义就是一一列举。
把可能的取值一一列举。
颜色可以一一列举，月份可以一一列举…
枚举类型的定义：

enum Day  //星期
{
Mon;
Tues;
Wed;
Thur;   // 枚举的可能取值
Fir;
Sta;
Sun;
};

enum Sex
{
MALE = 3;  //刚开始给它值叫做初始化。默认是从0开始，一次递增1.
FEMALE = 7;
SECREAT
}
int main()
{

printf("%d %d %d\n",MALE,FEMALE,SECRET);
return 0;
}

枚举的优点：

我们可以用#define定义常量，为什么要使用枚举？
枚举的优点：
1，增加代码的可读性和可维护性。
2.和#define定义的标识符比较枚举有类型检查，更加严谨,#define是定义全局。
3.防止了命名污染。（封装）
4.便于调试
5.使用方便，一次可以定义多个常量。

枚举的使用

enum Color  //颜色
{
  RED = 1;
  GREEN = 2;
  BLUE = 4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
clr = 5;

联合（共用体）

联合的定义：
联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。

//联合类型的声明
union Un
{
  char c;
  int i;
};

//联合变量的定义
union Un un;

联合的特点：
联合的成员是公用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

union Un
{
  char c;  //1
  int i;   //4
};
  int main()
  {
   printf("%d\n",sizeof(union Un))//4;
   union Un u;
   printf("%p\n",&(u.c));
   printf("%p\n",&(u.i));  //我们会发现它们用的是同一块空间，所以联合体也叫共用体。它的大小是4.
   return 0;
   }

联合大小的计算：
联合的大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。