C语言笔记第10篇：内存函数

上一篇的字符串函数只是针对字符串的函数，而内存函数是针对内存块的，不在乎内存中存储的数据！这就是字符串函数和内存函数的区别。

准备好爆米花，正片开始

1、memcpy的使用和模拟实现

memcpy库函数的功能：任意类型数组的拷贝

memcpy的函数声明：

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

destination是目标空间，source是源，size_t num是拷贝字节的个数。

为什么还有输入拷贝字节个数呢？

因为memcpy可以拷贝任意类型的数组，可以是字符，可以是int，也可以是struct自定义类型的，但是前提是要输入要拷贝的字节个数，因为传过去的地址被void类型的指针接收，所以不能得知元素大小。

memcpy函数的调用：

#include <stdlib.h>
#include <stdio.h>
int main()
{int arr1[10] = { 0 };int arr2[] = { 1,2,3,4,5,6,7,8,9,10 };memcpy(arr1, arr2, 20);//向拷贝20个字节也就是5个int类型大小的arr2元素到arr1数组中int i = 0;for (i = 0; i < 5; i++){printf("%d ", arr1[i]);}return 0;
}

memcpy函数的模拟实现：

#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* source, size_t num)
{assert(dest && source);void* ret = dest;while (num--){*(char*)dest = *(char*)source;dest = (char*)dest + 1;source = (char*)source + 1;}return ret;
}
int main()
{int arr1[10] = { 0 };int arr2[] = { 1,2,3,4,5,6,7,8,9,10 };my_memcpy(arr1, arr2, 20);//向拷贝20个字节也就是5个int类型大小的arr2元素到arr1数组中int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr1[i]);}return 0;
}

但是这个函数有一个缺点，就是不能重叠内存拷贝，什么意思呢？就是不能在同一个数组中拷贝，会导致打印信息不正确，例如：

#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* source, size_t num)
{assert(dest && source);void* ret = dest;while (num--){*(char*)dest = *(char*)source;dest = (char*)dest + 1;source = (char*)source + 1;}return ret;
}
int main()
{int arr[] = { 1,2,3,4,5,6,7,8,9,10 };my_memcpy(arr+2, arr, 20);更改位置int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr1[i]);}return 0;
}

我想将arr+2也就是第3个元素的位置开始，拷贝1-5，我们想象的答案是1 2 1 2 3 4 5 8 9 10，但是实际上的答案是1 2 1 2 1 2 1 8 9 10，因为是从前往后开始拷贝，拷贝信息和拷贝的位置重叠了，导致拷贝时更改了拷贝信息，打印出的结果有所差异。

那怎么办？其实还有memmove函数，他和memcpy的拷贝一样，任意类型都可以拷贝，不同的是memmove可以处理重叠内存拷贝。

2、memmove的使用和模拟实现

memmove库函数功能：拷贝任意类型的数组，也可以处理重叠内存拷贝问题

memmove函数的声明：

void* memmove(void* destination, const void* source, size_t num);

可以看到memmove和memcpy的返回类型和参数一模一样，唯一不同的只是memmove函数的实现细节

memmove函数的调用：

#include <stdlib.h>
#include <stdio.h>
int main()
{int arr1[10] = { 0 };int arr2[] = { 1,2,3,4,5,6,7,8,9,10 };memmove(arr1, arr2, 20);//向拷贝20个字节也就是5个int类型大小的arr2元素到arr1数组中int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr1[i]);}return 0;
}

memmove究竟是如何处理拷贝重叠的的呢？请继续往下看

memmove函数的模拟实现：

#include <stdio.h>
#include <assert.h>
void* my_memmove(void* dest, const void* source, size_t num)
{assert(dest && source);void* ret = dest;if (dest < source)//如果拷贝的地址小于拷贝信息的地址就可以从前向后拷贝{while (num--){*(char*)dest = *(char*)source;//从前向后拷贝dest = (char*)dest + 1;source = (char*)source + 1;}}else//如果拷贝的地址大于或等于拷贝信息的地址就从后向前拷贝{while (num--){*((char*)dest + num) = *((char*)source + num);//从后向前拷贝}}return ret;
}
int main()
{int arr[] = { 1,2,3,4,5,6,7,8,9,10 };my_memmove(arr + 2, arr, 20);int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr[i]);}return 0;
}

memmove模拟实现逻辑：

我们可以使用地址于地址之间的关系运算，简单概述就是两个地址之间比较大小。因为该函数是排序数组的，数组又是连续存放的，所以可以比较两个地址。如果目标空间地址比源地址大，就从后往前拷贝。如果目标空间地址比源地址小，就可以从前往后拷贝。

3、memset的使用和模拟实现

memory - 记忆（内存），set - 设置。memset就是内存设置的意思。

memset库函数功能：将参数ptr的前num个字节设置成指定的value值。

memset的函数声明：

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

比如我有一个字符数组，字符串是 " hello world " ，我想把它改成 " hello xxxxx"，那我们就可以使用memset函数。

memset函数的调用：

#include <stdio.h>
#include <stdlib.h>
int main()
{char str[] = "hello world";memset(str + 6, 'x', 5);//参数1：字符数组下标6的位置 参数2：需替换的的源值 参数3：字节为单位，向后拷贝的字节大小printf("%s\n", str);//打印 "hello xxxxx"return 0;
}

打印结果确实是 " hello xxxxx "，但是我们也可以用它来改变整型数组：

#include <stdio.h>
#include <stdlib.h>
int main()
{int arr[] = {1,2,3,4,5,6,7,8,9,10};memset(arr, 1, 20);int sz = sizeof(arr)/sizeof(arr[0]);int i = 0;for(i=0;i<sz;i++){printf("%d ",arr[i]);}return 0;
}

我们想象的是改变前20个字节也就是前5个整型元素，打印为：1,1,1,1,1,6,7,8,9,10，但实际上却却是以每个字节更改为01，并不是我们想象的改为五个1，如下图：

所以你想让它的每个字节都是1是可以做的到的，但是你想让它每个整型都是1这个是做不到的，memset本身就是以字节为单位进行设置的。前面的memcpy和memmove虽然也是以字节为单位来拷贝的，但是它们两边都是在变化着拷贝的，所以能够拷贝正确答案。而这个需拷贝的源始终都是一个值，这个值是不会变化的，每次拷贝一个字节都从这里面的一个字节拷贝到另一个空间。

memset的模拟实现：

#include <stdio.h>
#include <stdlib.h>
void my_memset(void* str, int value, size_t num)
{assert(str != NULL);void* ret = str;while (num--){*(char*)str = (char)value;str = (char*)str + 1;}return ret;
}
int main()
{char str[] = "hello world";int arr[] = { 1,2,3,4,5,6,7,8,9,10 };int sz = sizeof(arr) / sizeof(arr[0]);my_memset(str+6, 'x', 5);my_memset(arr, 1, 20);int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}printf("\n");printf("%s\n", str);return 0;
}

4、memcmp的使用和模拟实现

memcmp库函数的功能：和strncmp的功能一样,strncmp是比较两个字符串的，memcmp是比较两个数组内存的

memcmp函数的声明：

int memcmp(void* ptr1, void* ptr2, size_t num);

memcmp返回值：如果ptr1比ptr2大就返回大于0的数字，如果ptr1比ptr2小就返回小于0的数字，如果相等就返回0

memcmp函数的调用：

#include <stdio.h>
#include <stdlib.h>
int main()
{int arr1[] = { 1,4,3,4,5 };int arr2[] = { 1,3,5,7,9 };int ret = memcmp(arr1, arr2, 5);printf("%d\n", ret);return 0;
}

memcmp函数的模拟实现：

#include <stdio.h>
#include <stdlib.h>
int my_memcmp(void* ptr1, void* ptr2, size_t num)
{assert(ptr1 && ptr2);while (num--){if (*(char*)ptr1 != *(char*)ptr2){return *(char*)ptr1 - *(char*)ptr2;}ptr1 = (char*)ptr1 + 1;ptr2 = (char*)ptr2 + 1;}return 0;
}
int main()
{int arr1[] = { 1,3,3,4,5 };int arr2[] = { 1,4,5,7,9 };int ret = my_memcmp(arr1, arr2, 5);printf("%d\n", ret);return 0;
}

                                                              end