[C++知识库]2021.9.17学习总结

结构体内存对齐

结构体内存对齐

想计算结构体内存的大小，就得先知道结构体内存对齐的规则：
1.第一个成员在与结构体变量偏移量为0的地址处。

2.其他成员变量要对齐到对齐数的整数倍的地址处。

对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。

3.结构体总大小为最大对齐数的整数倍。

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

结构体内存要对齐的原因：

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

2.性能原因：数据结构（尤其是栈）应该尽可能的在自然边界上对齐。因为在访问未对齐的内存时，处理器需要访问两次，而对齐的只需要访问一次。

修改默认对齐数

用#pragma这个预处理命令可以改变对齐数例如以下代码，我的编译器是vs2019默认对齐数是8，s1,s2的内存输出后分别是12,6，相同的数据，改变对齐数后他的内存就发生了变化。

struct s1
{
	char x;
	int i;
	char j;
};
#pragma pack(1)//设置默认对齐数为1
struct s2
{
	char a;
	int b;
	char c;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
	printf("%d\n", sizeof(struct s1));
	printf("%d\n", sizeof(struct s2));
	return 0;
}

结构体传参：在传参的时候传地址要比传整个结构体好，因为函数在传参的时候参数是需要压栈的，会有时间和空间上的系统开销。如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，会导致性能的下降。所以结构体传参时最好传结构体的地址。例如以下代码：当结构体的数据占用内存过大时，对性能的影响就会很大。

struct S
{
	int data[1000];
	int num;
};
void print1(const struct S tmp)
{
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", tmp.data[i]);
	}
	printf("\nnum=%d\n", tmp.num);
}
void print2(const struct S* pc)
{
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", pc->data[i]);		
	}
	printf("\nnum=%d\n", pc->num);
}
int main()
{
	struct S s = { {1,2,3,4},100 };
	print1(s);//传结构体
	print2(&s);//传地址
	return 0;
}

位段

位段的声明和结构体类似，但是有两个不同：
1.位段的成员必须是int,unsigned int,signed int。

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

3.结构体能出现的地方位段一般也能出现，位段的好处是节省空间，缺点是跨平台特性。

位段的内存分配：
1. 位段的空间上是按4个字节或者1个字节来开辟的。

2.位段涉及很多不确定因素，所以位段是不跨平台的。

例子：

//位段是可以用来节省空间的
//位段 - 二进制位
struct A
{
	int _a : 2;// 2个bit位
	int _b : 5;// 5个bit位
	int _c : 10;// 10个bit位
	int _d : 30;// 30个bit位
};
//因为他的成员是int型所以一次开辟一个整形，一个整形四个字节32个bit位，此时可以把abc都放进这32个bit位里
//此时d放不进去所以开辟第二个整形，所以结果为8个字节
int main()
{
	printf("%d\n", sizeof(struct A));//8个字节
	return 0;
}

位段的跨平台特性：

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

2.位段中最大位的数目不能确定。

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

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

枚举

可以一一列举的东西。

枚举的优点：

1.增加代码的可读性和可维护性。

2.和#define定义的标识符比较枚举有类型检查，更加严谨。

3.防止了命名污染（封装）。

4.便于调试。

5.使用方便，一次可以定义多个常量。

枚举在使用的时候，只能拿枚举常量给枚举变量赋值，这样才不会出现类型差异。

例子：

enum color//颜色
{
	red,
	green,
	blue,
	pink = 5,//定义时也可以赋初值
	black
};
int main()
{
	printf("%d\n", red);//0默认值,里面的值是枚举常量
	printf("%d\n", green);//1
	printf("%d\n", blue);//2
	printf("%d\n", pink);//5
	printf("%d\n", black);//6
	enum color c = green;
	if (c == green)
	{
		printf("绿色\n");
	}
	return 0;
}

共用体（也叫联合体）

共用体的成员是共用一块内存空间的，这样一个共用体的大小，最小是最大成员的大小（因为共用体最少要有能力保存最大的那个成员）。

例子：

union Un
{
	char c;//1
	int i;//4
};
int main()
{
	union Un u = { 0 };
	printf("%d\n", sizeof(u));//4
	printf("%p\n", &u);//003EFA74
	printf("%p\n",&(u.i));//003EFA74
	printf("%p\n", &(u.c));//003EFA74,共用同一块空间
	return 0;
}

运用共用体的特点判断当前机器的大小端存储：
?

//共用体判断当前机器的大小端
int check_sys()//相当于拿出四个字节的第一个字节
{
	union U
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;//返回1就是小端，返回0就是大端
}
int main()
{
	if (check_sys() == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

共用体大小的计算：

1.共用体的大小最小是最大成员的大小。

2.当最大成员的大小不是最大对齐数的整数倍时，就要对齐到最大对齐数的整数倍。

例子：

//联合体大小的计算
union u
{
	char c[5];//5,对齐数是1
	int i;//4，对齐数是4，5+3是4的倍数，所以是8个字节
};
union u1
{
	short a[7];//7，对齐数是2
	int b;//4，对齐数是4,14+2是4的倍数所以是16
};
int main()
{
	printf("%d\n", sizeof(union u));//8
	printf("%d\n", sizeof(union u1));//16
	return 0;
}