内存操作函数（memcpy、memove、memset）、结构体详解、位段

内存操作函数

memcpy

void* memcpy (void* destination , const void* source , size_t num)

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置
• 这个函数在遇到 ‘\0’ 的时候并不会停下来，按照字节一个一个的拷贝过去。
• 如果source和destination有任何的重叠，复制结果都是未定义的
• 返回值支持连续拷贝memcpy (a , ( memcpy ( b , c , 10 ) , 10 )
• memcpy的模拟实现

#include
void* my_memcpy(void* dst, const void* src, size_t num)
{
     
	char* ch_dst = (char*)dst;
	char* ch_src = (char*)src;
	for (int i = 0; i < num; ++i)
	{
     
		ch_dst[i] = ch_src[i];
	}
	return dst;
}
int main()
{
     
	char a[] = "abcdefghijk ";
	char b[11];
	my_memcpy(b, a, 11);
	for (int i = 0; i < 11; ++i)
	{
     
		printf("%c", b[i]);
	}
	return 0;

}

memove

void* memove( void* destination , const void* source , size_t num)

• 和memcpy的差别就是memove函数处理的原内存块和目标内存块是可以重叠的。
• 如果原空间和目标空间出现重叠，就得使用memove函数处理。
• 这里的重叠会出现两种情况前重叠和后重叠
• 
• memove的模拟实现

#include
void* my_memmove(void* dst, const void* src, size_t num)
{
     
	char* ch_dst = (char*) dst;
	const char* ch_src = (const char*)src;
	if (ch_dst >= ch_src&&ch_dst <= ch_src + num)
	{
     
		for (int i = num-1; i >=0; --i)
			ch_dst[i] = ch_src[i];
	}
	if (ch_dst +num>= ch_src&&ch_dst+num <= ch_src + num)
	{
     
		for (int i = 0; i < num; ++i)
			ch_dst[i] = ch_src[i];
	}
	return dst;
}
int main()
{
     
	int a3[9] = {
      1, 2, 3, 4, 5 };//这里的数组空间一定要满足拷贝后所需要空间大小
	my_memmove(a3 + 4, a3, 20);
	return 0;
}

memset

void* memset(viod* ptr，int value , size_t num);

• 将每一个字节初始化
• 但是存在局限性

#include
#include
int main()
{
     
	int a[10];
	memset(a, 0, sizeof(a));//将每一个字节初始化为0
	//存在局限性，防止误用
	memset(a, 1, sizeof(a));
	//这样初始化就是将整型的每一个字节初始化为1，就变成了00000001 00000001 00000001 00000001（16843009）
	return 0;

}

结构体

结构体类型的声明

• 结构是一些值的集合，这些值称为成员变量。结构的每一个成员可以是不同类型的变量
• 结构体在声明时没有开空间，定义之后才会开空间
• 访问结构体成员时可以使用 -> 或 .
• 例如描述一个学生时

struct Stu
{
     
	char name[20];
	int age;
	char sex[5];
	char id[20];
};

• 在声明的时候，可以不完全声明，结构体在声明的时候可以省略掉结构体标签，比如：

//匿名结构体类型
struct
{
     
	int a;
	char b;
	float c;
}x;
struct
{
     
	int a;
	char b;
	float c;
}a[20],*p;//结构体变量，这里的变量是全局变量，但是并不推荐这样写。

typedef struct Teacher
{
     
	// 结构体的成员
	char name[30];
	int age;
	char addr[100];
	int tel;
}Tea, T, *PT;
//Tea,T是typedef出来的struct Teacher 类型；*PT是typedef出来的指针
//等价于typedef  struct  Teacher  Tea;
//等价于typedef  struct  Teacher* Pt;

注意：编译器会把以上两个结构体当成完全不同的两个类型，所以p=&x是非法的。

结构体的自引用

• 在结构体中可以包含一个类型为该结构本身的成员

struct Node
{
     
    int val;
    struct Node next;//这里是非法定义，这样会存在无数多个结构体
}
struct Node
{
     
    int val;
    struct Node* next;//应该定义为指针形式
}

结构体的定义和初始化

有了结构体类型，就可以定义变量

struct Point
{
     
    int x;
    int y;
}p1;//声明类型的同时定义变量p1
struct Point p2;//定义结构体变量p2

struct Point p3={
     x,y};//初始化：定义变量的同时赋初值

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

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. 其他成员变量要对齐到某个数字（对其数）的整数倍的地址处。
   对其数 = 编译器默认的一个对其数 与 该成员大小的较小值。

3. vs中默认的值为8

4. 结构体总大小为最大对其数（每个成员变量都有一个对其数）的整数倍。

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

那么为什么存在内存对齐呢？

1. 平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2. 性能原因：数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要做两次内存访问；而对齐的内存访问仅需要一次访问。
   总体来说：
   结构体的内存对齐是拿空间换取时间的做法。
   那么在设计结构体的时候，既要满足对齐，又要节省空间，那么我们就要占用空间小的成员尽量集中在一起。下面有两个例子：

struct s1
{
     
     char c1;
     int i;
     char c2;//所占内存为12个字节
};
struct s2
{
     
    char c1;
    char c2;
    int i;//所占内存为8个字节
};

虽然s2于s1类型的成员一模一样，但是他们所占空间的大小有一些区别

修改默认对齐数

#include
#pragma pack(8)//设置默认对齐数为8
struct s1
{
     
     char c1;//1个字节（占位0）
     int i;//4个字节（占位4，5，6，7）
     char c2;//一个字节（占位8）
     //所以所占空间为9个字节，但是结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍
};
#pragma pack()//取消设置的默认对其数，还原为默认
int main()
{
     
     printf("%d\n",sizeof(struct s1));//输出结果为12
     return 0;
}

对齐方式不合适的时候，我们可以自己更改默认对其数

结构体传参

函数传参的时候，参数需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。
所以，结构体传参的时候，要传结构体的地址。

struct S
{
     
     int data[1000];
     int num;
};
struct S s={
     {
     1,2,3,4},1000};
void print1(struct S*ps)
{
     
     printf("%d\n",ps->num);
}
int main()
{
     
     print1(&s);
     return 0;
}

位段

位段的声明和结构体是类似的，但是存在两个不同：

1. 位段成员必须是int、unsigned int 或 signed int 。
2. 位段的成员名后边有一个冒号和一个数字。比如：

struct A
{
     
   int _a:2;
   int _b:5;
   int _c:10;
   int _d:30;
};//这里的A就是一个位段

那么位段A的大小是多少呢？
位段的内存分配

1. 位段的成员可以是int unsigned int signed int 或是 char (属于整型家族)类型
2. 位段的空间上是按照需要以4个字节( int )或者1个字节（char）的方式来开辟的。
3. 位段涉及很多不确定的因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
4. 下面举例说明
   
   

位段的跨平台问题

1. int位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。(16位机器最大16,32位机器最大32，写成27，在16位机器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确的。
   总结
   跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。