【C语言】一组内存函数—

hello~~，我是~小鹿，这是我的第二篇博客，算是接着上一篇的字符串函数写的吧，这一篇讲的是内存函数，能够直接操作内存，内存函数不需要知道被操作的内容类型，只需要告知内存即可。
有什么不对的地方希望指正，有什么不好地方可以给我些意见呀~
这篇文章讲解了以下四种内存函数以及它们的模拟函数(自定义函数)

[C语言]一组内存函数—memory

1.memcpy()-内存拷贝（不可重叠）
2.memmove()-内存拷贝（可重叠）
3.memcmp()-内存比较
4.memset()--内存设置

1.memcpy()-内存拷贝（不可重叠）

函数的声明方式：
void* memcpy(void* destination, const void* source, size_t num);

· 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置；
· 这个函数在遇到 ‘\0’ 的时候并不会停下来；
· 参数的类型是无类型指针(void*)，可以拷贝任意类型数据；
· 如果source和destination有任何重叠，复制的类型都是未定义的；
· 返回值：返回目标空间的起始地址；
· memcpy()函数的头文件是#include <string.h> 。

memcpy()函数代码示例：
将arr1中的前五个数据复制到arr2中

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>//memcpy函数的头文件
int  main()
{int i = 0;int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0 };memcpy(arr2, arr1, 20);//从arr1中复制20个字节的数据到arr2中（int类型一个数据占四个字节，20个字节相当于五个int类型的数据）for (i = 0; i < 10; i++){printf("%d ", arr2[i]);}return 0;
}

运行结果：1 2 3 4 5 0 0 0 0 0

memcpy()函数的模拟实现，代码示例：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>//assert函数的头文件
void* my_memcpy(void* dest, const void* src, size_t num)
{assert(dest && src);//断言，确保dest与src不是空指针void* ret = dest;while (num--){*(char*)dest = *(char*)src;//void类型解引用时不知访问几个字节，需强制转换，char*类型最为合适dest = (char*)dest + 1;src = (char*)src + 1;}return ret;//需要返回dest的起始位置
}
int  main()
{int i = 0;int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0 };int* ret = my_memcpy(arr2, arr1, 20);for (i = 0; i < 10; i++){printf("%d ", *(ret+i));}return 0;
}

如果source和destination有任何重叠，复制的类型都是未定义的：
例如：

 int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };memcpy(arr1 + 2, arr1, 20);//此时目标数据与源头数据内存重叠，会发生数据拷贝内容被覆盖

arr[0]的值赋给arr[2]，此时arr[2]=1;同理arr[3]=2;然后将arr[2]的值赋给arr[4],因为此时的arr[2]=1,所以赋给arr[4]后，arr[4]为1；以此类推，给arr[5],arr[6]赋值。
所以此时memcpy函数后的arr1为1 2 1 2 1 2 1 8 9 10

2.memmove()-内存拷贝（可重叠）

函数声明：
void* memmove(void* destination, void* source, size_t num);

memmove函数与memcpy函数用法相同
区别：memmove 函数可以处理内存重叠的情况
· · · · · memcpy 函数可以拷贝内存不重叠的情况

memmove()函数代码示例：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>//memmove函数的头文件
#include <assert.h>//assert函数的头文件
int  main()
{int i = 0;int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };memmove(arr1+2, arr1, 20);for (i = 0; i < 10; i++){printf("%d ", arr1[i]);}return 0;
}

运行结果：1 2 1 2 3 4 5 8 9 10

memmove()函数的模拟实现
原理：
1.若目标空间（dest）的地址在源头数据（src）的地址前方： 将源头数据（就是图中黑色框中的内容）依次从前往后拷贝（即从4开始拷贝，依次是5，6，7）将目标空间中的数据（橙色框中的内容）依次覆盖，此时就不会造成内存重叠。

2.当目标空间（dest）的地址在源头数据（src）的地址后方： 将源头数据从后向前一次拷贝（即从7开始，然后依次是6，5，4）将目标空间中的数据依次覆盖，此时就不会造成内存重叠。

memmove()函数的模拟实现，代码示例：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>//assert函数的头文件
void* my_memmove(void* dest, void* src, size_t num)
{assert(dest && src);//断言，确保不是空指针void* ret = dest;if (dest < src)//从前往后拷贝{while (num -- ){*(char*)dest = *(char*)src;dest = (char*)dest + 1;src = (char*)src + 1;}}else//从后往前拷贝{while (num--){*((char*)dest + num) = *((char*)src + num);}}
}
int  main()
{int i = 0;int arr[] = { 1,2,3,4,5,6,7,8,9,10 };my_memmove(arr+2, arr, 20);for (i = 0; i < 10; i++){printf("%d ",arr[i]);}return 0;
}

运行结果：1 2 1 2 3 4 5 8 9 10

总结：
memcpy只需要实现不重叠的拷贝就可以了
memmove是需要实现重叠内存的拷贝的
可以说memmove包含memcpy，但不可以反

3.memcmp()-内存比较

函数声明：int memcmp（const void* ptr1,const void* ptr2,size_t num);

· 比较从ptr1和ptr2指针开始的num个字节；
· 参数的类型是无类型指针(void*)，可以比较任意类型数据；
· 这个函数在遇到 ‘\0’ 的时候并不会停下来；
· 返回值：ptr1 > ptr2 时返回 > 0 的值；
· ptr1 < ptr2 时返回 < 0 的值；
· ptr1 = ptr2 时返回 = 0 的值；
· memcmp()函数的头文件是#include <string.h> 。

memcmp()函数代码示例：
比较数组arr1与arr2中前13个字节的大小

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>//memcmp函数的头文件
int main()
{int arr1[] = { 1,2,3,4,5 };//内存中：  01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 int arr2[] = { 1,2,3,0,0 };//内存中：  01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00int ret = memcmp(arr1, arr2, 13);//比较前13个字节的大小，一个一个字节比较，前12个字节的内容相同，比较到第13个字节时，arr1中存的04>arr2中存的00，说明在前13个字节中，arr1>arr2printf("%d\n", ret);             return 0;
}

运行结果：1

memcmp()的模拟实现，代码示例：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>//assert函数的头文件
int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{assert(ptr1 && ptr2);//断言，确保不是空指针while ((--num) && (*(char*)ptr1 == *(char*)ptr2)){ptr1 = (char*)ptr1 + 1;ptr2 = (char*)ptr2 + 1;}if (*(char*)ptr1 > *(char*)ptr2)return 1;else if (*(char*)ptr1 == *(char*)ptr2)return 0;elsereturn -1;
}
int main()
{int arr1[] = { 1,2,3,4,5 };//内存中：  01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 int arr2[] = { 1,2,3,0,0 };//内存中：  01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00 00 00 00 00int ret = my_memcmp(arr1, arr2, 13); //比较前13个字节的大小，一个一个字节比较printf("%d\n", ret);             return 0;
}

运行结果：1

4.memset()–内存设置

函数声明：void* memset(void* ptr, int value,size_t num);

· 将指针变量ptr所指向的前num字节的内存单元用value替换；
· 可以内存设置为字符型，整型与字符型是互通的（ASCII码）；
· 参数的类型是无类型指针(void*)，可以设置任意类型数据；
· 这个函数在遇到 ‘\0’ 的时候并不会停下来；
· 返回值：返回ptr的起始地址；
· memset()函数的头文件是#include <string.h>。

memset()函数代码示例：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>//memset函数的头文件
int main()
{int arr[] = { 1,2,3,4,5 };//内存中：     01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00memset(arr, 0, 9);//arr中前九个字节变为0：00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 05 00 00 00int i = 0;for (i = 0; i < 5; i++){printf("%d ", arr[i]);}return 0;
}

运行结果：0 0 0 4 5

memset()的模拟实现，代码示例：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>//assert函数的头文件
int my_memset(void* ptr, int val, size_t num)
{assert(ptr);//断言，确保不是空指针void* ret = ptr;while (num--){*(char*)ptr = val;ptr = (char*)ptr + 1;}return ret;
}
int main()
{int arr[] = { 1,2,3,4,5 };//内存中：                 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00int* ret=my_memset(arr, 0, 9);//arr中前九个字节变为0：00 00 00 00 00 00 00 00 00 00 00 00 04 00 00 00 05 00 00 00int i = 0;for (i = 0; i < 5; i++){printf("%d ", arr[i]);}return 0;
}

好啦，文章到这里就结束了，求求求求求求求求求求三连呀(*≧▽≦)~，文章对你有所帮助的话可以给我点个赞嘛(。’▽’。)♡欸嘿 ~