自定义类型：结构体

1.结构体类型的声明

1.1结构体声明

结构体是一些值的集合，这些值就叫做成员变量。结构的每个成员可以是不同类型的变量，如：标量，数组，指针，甚至是其他的结构体。

下面是结构体声明的模板：

struct tag

{
      member-list;//成员列表,可以有一个或多个成员

}variable-list;//变量列表

 例如描述一个学生：
 

struct stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//姓名
	char id[20];//学号
};//后边必须有分号

 结构体变量的定义：
1.创建类型时顺便创建变量：

struct stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//姓名
	char id[20];//学号
}s1;//声明类型的同时定义变量是s1

2.：创建结构体后单独创建变量：

struct stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//姓名
	char id[20];//学号
};
struct stu s1;//创建结构体类型后单独创建变量s1

 结构体变量的初始化：

1.按顺序初始化：
 

struct stu
{
	int x;
	int y;
};
struct stu s1 = { 10,20 };

2.使用.变量名的方法初始化：

struct stu
{
	int x;
	int y;
};
struct stu s1 = { .y=10,.x=20 };

1.2结构体的访问

1.结构体成员的直接访问：
结构体成员的直接访问是通过点操作符（.）进行访问的，点操作符的使用方法如下所示：

#include<stdio.h>
struct Point
{
	int x;
	int y;
}p={1,2};

int main()
{
	printf("%d %d\n", p.x, p.y);//通过.操作符访问
	return 0;
}

以上就是.操作符的使用方式。

2.结构体成员的间接访问：
结构体成员的间接访问时通过指针来完成的：

 使用方法：结构体指针->成员名

以下是这种方法的使用举例：

#include<stdio.h>
struct Point
{
	int x;
	int y;
}p={1,2};

int main()
{
	struct Point* str = &p;
	str->x = 10;
	str->y = 20;
	printf("%d %d", str->x, str->y);
	return 0;
}

通过这两种方法我们都能实现对结构体成员的访问。

如果今后我们遇到需要访问结构体成员的时候用这两个方法就行。

1.3结构体的不完全声明：

在声明结构体时我们也可以进行不完全的声明：
所谓不完全声明也就是匿名结构体。

struct //省略了结构体名字
{
	int a;
	char b;
	float c;
}p;

注意：

1.如果同时有两个匿名结构体，编译器会将它们当成两个完全不同的类型，所以是非法的。

2.匿名的结构体类型，如果没有对结构体重命名的话，基本只能使用1次。

1.4结构体的自引用

现在我们来试一下在结构体中包含一个类型为该结构本身的成员可以吗？

比如，定义一个链表的节点：
 

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

 其实这样是不行的，一个结构体中再包含一个同类型的结构体，这样结构体变量的大小就会无穷的大，是不合理的。

以下是正确的自引用方式：
 

struct Node
{
	int data;//数据域存放数据
	struct Node* next;//指针域存放下一个节点的地址
};

注：存在自引用的结构体定义结构体时不能使用匿名结构体。

2.结构体的对齐

2.1对齐规则

1.结构体的第一个成员对齐到和结构体变量的起始位置偏移量位0的地址处

                               第一个字节处等价于起始位置等价于偏移量位0的位置

2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处

对齐数=编译器默认对齐数与该成员变量大小的较小值 

VS中的默认对齐数是8

Linux系统中的gcc没有默认对齐数，对齐数就是成员本身的大小

3.结构体的总大小位为最大对齐数 （结构体中的每个成员都有一个对齐数，所有对齐数中最大的就是最大对齐数）的整数倍

4.如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中的最大对齐数的整数倍处，结构体的整体大小就是所有的最大对齐数（含嵌套结构体中成员对齐数）的整数倍

我们来看一下下面这几个实例：

2.2具体用例

例1：

struct s1
{
	char c1;
	int i;
	char c2;
};
printf("%zd\n", sizeof(struct s1));

 以上代码的运行结果是什么呢？

这里就能用上我们结构体对齐的知识了。

由于第一个成员是char类型，放在偏移量为0的第一个字节处，又由于第二个成员的类型int类型，因此要根据对齐规则将第二个成员变量放在从偏移量为4的字节处开始放，向后放四个字节到偏移量为7处，最后的一个char放在int的后边，一共9个字节，但是根据对齐规则结构体总字节数要是最大字节数的整数倍，那么这个结构体的大小就是12个字节。

例2：

struct s2
{
	char c1;
	char c2;
	int i;
};
printf("%zd", sizeof(struct s2));

我们来分析下这段代码的结果：首先，第一个成员在0偏移处，第二个成员也是char类型在1偏移处

，第三个变量为int类型从偏移量为4的位置向后放4个字节到偏移量为7的位置，一共8个字节并且符合最大对齐数的整数倍这一规则因此这段代码的结果就是12。

例3:

struct s3
{
	double d;
	char c;
	int i;
};
printf("%zd", sizeof(struct s3));

我们来看这段代码，第一个成员是double型变量，从偏移量0处放到偏移量7处，第二个成员为char型变量，放在偏移量8处，第三个成员是int类型的，根据规则要放在对齐数的整数倍，因此要从偏移量为12出开始放到15处，一共16个字节，并且满足最大对齐数的整数倍，因此这段代码的结果就是16。

例4：

结构体嵌套问题

                 

struct s4
{
	char c;
	struct s3 a;
	double d;
};
printf("%zd", sizeof(struct s4));

我们来看下这段代码，这段代码运用了结构体嵌套，我们在上面已经计算了struct s3的大小为16字节，并且它的最大对齐数是8，第一个成员是char类型的放在偏移量0处，由于第二个成员的类型是结构体类型，结构体类型的成员要放在自己最大对齐数的整数处 ，因此第二个成员从偏移量8处放到23处，第三个成员类型是double型从偏移量24处放到31处，一共32个字节并且满足总字节数是最大对齐数的倍数这一规则，因此这段代码的结果就是32。

2.3内存对齐的存在原因

既然内存对齐会浪费空间，那么为什么还会有内存对齐呢？原因主要是下面几点：
1.平台移植原因：

由于不是所有的硬件平台都能访问任意地址的任意数据的，有的硬件平台上只能在某些地址处取某些特定类型的数据，否则就抛出硬件异常。

2.性能原因：

数据结构应该尽可能地在自然边界上对齐。原因在在于为了访问未对齐的内存，处理器需要作两次内存访问，而对齐的内存访问只需要一次访问。

总体来说，结构体的内存就是牺牲空间换取时间的做法。

那么我们在使用结构体时，我们既要满足对齐又要节省空间，该怎么办呢？

答案就是：让占用空间小的成员尽量集中在一起。

2.4.修改默认对齐数 

#pragma 这个预处理指令，可以改变编译器的默认对齐数。

 使用方法：

#pragma pack(n）//将默认对齐数改为n

再次使用

#pragma pack()//括号里空着，取消设置的对齐数，还原为默认对齐数

 下面是使用实例：
 

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#pragma pack(1)//设置默认对齐数为1
struct S
{
	char c1;
	int i;
	char c2;
};
int main()
{
	printf("%zd", sizeof(struct S));

	return 0;
}

 下面是代码的运行结果：

 可以看出通过这个预处理指令确实是把默认对齐数修改为1了。

通过这个预处理指令在对齐方式不合适的时候，我们可以自己更改默认对齐数。

3.结构体传参

3.1传值和传址

#include<stdio.h>
struct S
{
	int data[1000];
	int num;
};
struct S s = { {1,2,3,4},1000 };
void Print1(struct S s)
{
	printf("%d\n", s.num);
}
void Print2(struct S* ps)
{
	printf("%d\n", ps->num);
}
int main()
{
	Print1(s);
	Printf2(&s);

	return 0;
}

我们来看下以上代码，Printf1函数的形参是用结构体接收的，形参是临时拷贝的，Print2函数的形参是用指针接收的，是传址调用。

函数传参的时候，参数是需要压栈，会用时间和空间上的开销。

如果传递一个结构体对象时，结构体过大，参数压栈的系统开销就会很大，所以导致性能下降。

因此对于结构体传参时，最好使用地址传参。

4.结构体实现位段

4.1什么是位段

位段的声明与结构体是相似的只有两点不同：

 1.位段的成员必须是int，unsigned int或signed int，在C99中位段成员的类型也可以是其他类型，常见的是char类型。

2.位段的成员名后边有一个冒号和一个数字。

冒号后面的数字代表bit位

 下面我们来看一个位段实例：
 

struct A
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};

 A就是一个位段类型。

4.2位段的内存分配

1.位段的成员可以是int，unsigned int，signed int或者是char类型

2.位段的空间是按照需要以4个字节（int）或者1个字节（char）来开辟的。

3.位段涉及很多不确定因素，位段是不跨平台的，可移植程序应该避免使用位段。

位段的空间分配根据编译器的不同而不同。

下面我们来看一段代码实例：
 

struct S
{
	char a : 3;//3个bit位，1010有四位，取低位010
	char b : 4;//1100
	char c : 5;//00011
	char d : 4;//0100
};
int main()
{
	struct S s = { 0 };
	s.a = 10;//1010
	s.b = 12;//1100
	s.c = 3;//011
	s.d = 4;//100
	return 0;
}

通过我们来调试这段代码发现：

 VS位段存储习惯是：
1.从用向左使用

2.如果剩余的空间不够下一个成员使用时，就浪费掉。

4.3位段的跨平台问题

1.int位段被当成有符号数还是无符号数是不确定的。

int-4个字节-32个bit位，但是在16位的机器上，int类型是2个字节-16个bit位

2.位段中最大位的数目不能确定，16位机器最大位是16位，32位机器最大是32，如果是超过16位的位段在16位机器上会出问题。

3.位段的成员在内存中从左向右分配，还是从右向左分配的标准尚未定义。

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

因此，跟结构体相比，位段虽然可以达到相同的效果，并且可以节省空间，但是会有跨平台的问题存在。

4.4位段的应用

位段可以应用在网络协议中的IP数据报中，这样既能达到效果，而且网络传输的数据报大小也会更小一些，能够使得网络更加畅通。

 上图就是一个IP数据报的格式。

4.5位段使用的注意事项

位段的几个成员可以共有同一个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的，内存中每个字节分配一个地址，一个字节内部的bit位是没有地址的。

因此，不能对位段中的成员使用&操作符，这样也就意味着不能使用scanf函数直接为位段的成员输入值，只能先输入放在一个变量中，然后赋值给位段的成员。

下面就是一个给位段成员值的实例：

#include<stdio.h>
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;//正确使用
	return 0;
}

 这篇博客到这里就结束了，希望通过这篇博客能让大家对结构体的内存对齐和位段有更深刻的理解。