结构体和位段

结构体：

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;
}