内存对齐及内存操作函数

结构体内存对齐规则

1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
   对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
   VS中默认的值为8
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

struct S1
{
	char c1;//对齐数为（1和8中的最小值）1；  存于0(偏移量为对齐数的整数倍)
	int i;//对齐数为（4和8中的最小值）4；    存于4-7(偏移量为对齐数的整数倍)
	char c2;//对齐数为（1和8中的最小值）1；  存于8(偏移量为对齐数的整数倍)
	//结构体总大小为最大对齐数(4)的整数倍，最终结构体大小为12；
};
int main()
{
	printf("%d", sizeof(struct S1));//结果为12
}

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

struct S2
{
	int i;//0-3
	short s;//4-5
	struct S1 s1;//8-19
};
int main()
{
	printf("%d", sizeof(struct S2));//结果为20
}

联合体内存对齐

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

union Un1
{
	char c[5];//0-5
	int i;
	//联合体的最大对齐数为4，总大小应为4的整数倍，即8
};
int main()
{
	printf("%d", sizeof(union Un1));//结果为8
}

memcpy与memmove

memmove自实现

void* MyMemmove(void* str1, void* str2, int num)
{
	assert(str1 != NULL && str2 != NULL);
	int* p = str1;
	if (str1 < str2)
	{
		while (num)
		{
			*((char*)str1) = *((char*)str2);
			((char*)str1)++;
			((char*)str2)++;
			num--;
		}
	}
	else
	{
		num--;
		while (num>=0)
		{
			*((char*)str1+num) = *((char*)str2+num);
			num--;
		}
	}
	return p;
}
int main()
{
	int a[] = {1,3,4,6,7,8,9};
	int b[] = {1,6,4,5,6,7,8};
	int*p= MyMemmove(b+2, b, sizeof(int) * 4);
	for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
	{
		printf("%d ", b[i]);
	}
}

memcpy自实现

void* MyMemcpy(void* str1, void* str2,int num)
{
	assert(str1 != NULL && str2 != NULL);
	int* p = str1;
	while (num)
	{
		*((char*)str1) = *((char*)str2);
		((char*)str1)++;
		((char*)str2)++;
		num--;
	}
	return p;
}
int main()
{
	int a[] = {1,3,4,6,7,8,9};
	int b[] = {1,6,4,5,6,7,8};
	int*p= MyMemcpy(a, b, sizeof(int) * 4);
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

memcpy使用注意

函数memcpy从源空间的位置开始向后复制num个字节的数据到目标空间的内存位置。
这个函数在遇到 ‘\0’ 的时候并不会停下来。
如果源空间和目标空间有任何的重叠，复制的结果都是未定义的，这种情况应该用memmove