内存函数

以下函数的头文件：string.h

• 针对内存块进行处理的函数

memcpy

函数原型：

void* memcpy(void* destination, const void* source, size_t num);
					目标空间地址                源空间地址

• num，被拷贝的字节个数

• 返回目标空间的起始地址

• 从source函数向后拷贝num字节个数据到目标空间

• 目标空间地址和源空间地址有重叠部分，有重叠内存的拷贝，结果是未定义的

• C语言标准规定：memcpy可以不负责有重叠内存的拷贝

  • 而vs编译器的库函数也可以实现重叠内存的拷贝。

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[20] = { 1, 2, 3, 4, 5, 6 };
	int arr2[20] = { 0 };
	memcpy(arr2, arr1, sizeof(int) * 5);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

通过函数原型也发现，这个memcpy函数是一个函数参数，函数返回类型都是void无符号类型，这是说明该函数是一个，泛型函数，它可以接收任意类型的参数，使同一个函数能用于多种类型的数据。

该用例说明了，将数组arr1从第一个元素开始的20个字节拷贝到arr2中。

模拟memcpy函数

void* my_memcpy(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    while(num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }
	return ret;
}

该函数是泛型函数，在返回类型和参数上要保持一致，后面的size_t num参数用来接收拷贝的字节个数。

能够进行任意数据类型的拷贝，这里只能将源空间一个一个字节拷贝到目标空间里，而void类型不是4个字节，所以将，dest和src强制类型转换为char类型，这样每循环一次就拷贝一个字节的内容，然后让指针dest和src向后走一个字节。

(char*)dest++;与dest = *(char*)dest + 1;的区别：

c/c++里的强制类型转换，是临时的，（char*）dest++；试图将一个 void *类型的dest强制类型转换，然后++，语法是有问题的，对 （char *）dest使用++，实际上是 (char* dest) = dest + 1;，将无符号类型的指针赋给 char *类型的指针编译器会报错的

最后将目标空间的起始地址返回即可。

使用assert断言是因为，目标空间和源空间都不能为空，否则就是对空指针解引用，加一条assert是代码具有更好的健壮性。

memmove

函数原型：

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

• 负责重叠内存的拷贝
• 用法与memcpy相同。
• memmove可以是memcpy的替代，它支持更多的使用场景，重叠内存的拷贝。

模拟memmove函数

俩个函数的功能及其相似，它们在实现上的不同，模拟memcpy函数是，对字节进行拷贝时，是将source里的字节从前向后一个一个拷贝的，如图：

source里一共有12个字节，模拟的memcpy函数将从数字2开始的第一个字节，一个一个拷贝到目标空间里。

若两快空间重叠时会发生哪些情况：

• dest指针大于source指针，目标空间与源空间重叠，但目标空间起始地址小于源空间，此时针对情况一，如上图橘色与蓝色重叠部分
• dest指针小于source指针，目标空间与源空间重叠，但目标空间起始地址大于源空间，此时针对情况二，如上图绿色与蓝色重叠部分

情况一：

• 当使用从前向后一个一个字节的拷贝时， 0 被拷贝为 2，1 被拷贝为 3，2 被拷贝为 4，结果与预期相符和，所以当目标空间与源空间重叠，但目标空间起始地址小于源空间时，采用从前向后一个字节一个字节的拷贝。

情况二：

• 对应情况二使用从前向后一次拷贝字节时，将源空间内容拷贝到密目标空间，此时 4 被拷贝为 2 ， 5 被拷贝为 3 ， 6被拷贝为2。

• 与预期结果并不相符和，预期拷贝后的结果时 0 1 2 3 2 3 4。

• 实际结果为，0 1 2 3 2 3 2。

可以发现，使用从前向后一起拷贝字节时，源空间的内容覆盖掉，它还没有拷贝就已经被覆盖了，并将其放置在目标空间的最后一个位置。解决这种办法也很好理解，既然从前向后拷贝不行，那我们从后向前拷贝不久可以了。这样就避免了，还没有将源空间的数据拷贝到目标空间就被覆盖的情况。

将source指针和destination指针向后偏移num个字节， (char*)dest + num (char*)src + num，这样它两就指向最后一个字节，从后向前拷贝，每拷贝完一个字节后 num–。

void* my_memmove(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    if(dest > src)//后向前
    {
        while(num--)
        {
             *((char*)dest + num) = *((char*)src + num);
		}
	}
    else
    {
        while(num--)
    	{
        	*(char*)dest = *(char*)src;
        	dest = *(char*)dest + 1;
            src = *(char*)src + 1;
        }
	}
    return ret;
}

当dest > src时，从后向前，第一步将dest和src偏移到最后一个位置， (char*)dest + num (char*)src + num，然后进行赋值 ，

*((char *)dest ) = *((char *)src );，其代码内讲多块内容合并在一起操作，通过控制num大小，来控制了dest和src偏移的位置，而循环结束的条件的num为0，这样就有了一条很精简的代码。

memset

函数原型：

void* memset(void* ptr, int value, size_t num);
             被填充空间    改变的内容 设置的字节个数       

memset，是用来设置内存的，将内存以字节为单位，

• 将每个字节设置为 value的内容

很朴素的用法，没有过多的变化，但结果往往会让人出乎意料~。

int main()
{
	int arr1[20] = { 1, 2, 3, 4, 5, 6 };
	int arr2[20] = { 0 };
	memset(arr2, 9, 5);
	memset(arr1, 8, 5);
	for (int i = 0; i < 6; i++)
	{
		printf("%d ", arr1[i]);
	}
    printf("\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

这不是一个使用的案例，通过运行代码能够发现数组arr1和arr2的结果相当的大，这是因为memset是在字节上设置内容，这里的第一条memset语句，将数组arr2里的五个字节内容，都放置了一个数字9，而内存里的 09 09 09 09实际上是16进制数，0x09090909，所以在打印的结果上会很大。

数字arr1的结果，同数组arr2一样，即使在传递的数组这块内容已经放的有值，memset还会将其覆盖。

这里以字符串为例，字符串的大小是一个字节，这里我试图将字符数组arr1里的前三个字节内容置为x。

int main()
{
	char arr1[10] = "abcdef";
	memset(arr1, 'x', 3);
	return 0;
}

观察结果，memset函数指哪打哪~，也没有在最后一个x后多余的放置 '\0'。

memcmp

函数原型：

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

比较字节大小：

• ptr1 > ptr2 返回大于0
• ptr1 < ptr2 返回小于0
• 等于返回 0
• num是指比较字节个数

memcmp函数与字符串函数里的strncmp功能很类似，前者是通过比较字节大小，后者是比较字符大小。

int main()
{
	int arr1[] = { 1, 2, 5 };
	int arr2[] = { 1, 2, 6 };
	printf("%d \n", memcmp(arr1, arr2, 8));
	return 0;
}

arr1前12个字节：

01 00 00 00 02 00 00 00 05 00 00 00

arr2前12个字节

01 00 00 00 02 00 00 00 06 00 00 00

试图比较前8个字节的大小时，返回的结果是0，每个字节上的内容都是相等的，而 memcmp(arr1, arr2, 9)；，比较前9个字节大小时，将返回小于0的数字， 06 > 05 。

cmp(arr1, arr2, 8));
return 0;
}
arr1前12个字节：

01 00 00 00 02 00 00 00 05 00 00 00

arr2前12个字节

01 00 00 00 02 00 00 00 06 00 00 00

试图比较前8个字节的大小时，返回的结果是0，每个字节上的内容都是相等的，而 memcmp(arr1, arr2, 9)；，比较前9个字节大小时，将返回小于0的数字， 06 > 05 。