本篇文章用于模拟实现 "string.h" 中的部分函数.

介绍

1.memcpy

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

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到 '\0' 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。

2.memmove

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

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

memcpy

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <assert.h>

//void * memcpy ( void * destination, const void * source, size_t num );
//直接操作内存,所以接受类型为void*(就可以接受任意类型) 强制转换为char* 进行复制
//由于可能覆盖原有的内存	也由于大小端存放问题
//所以拷贝的有时候不会是理想数据,要细心认真
//void* 返回值 返回目标数组的首地址 用于后续调用时可以直接用返回值调用数组
void* my_memcpy(void* dest, const void* src, size_t n)
{
	void* ret = dest;
	assert(dest);
	assert(src);
	while (n--)
	{
		*(char*)dest = *(char*)src;
		//((char*)dest)++;
		//((char*)src)++;
		//上述方式在一些编译器上是不可行的
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr[] = {1,2,3,4,5,6,7,8};
	int arr2[10] = {0};
	my_memcpy(arr2, arr, 20);

	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", arr2[i]);
	}
	return 0;
}

memmove

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>

//和memcpy函数类似   只是此函数考虑了覆盖内存的情况
void* my_memmove(void* dst, const void* src, size_t count)
{
    void* ret = dst;
    if (dst <= src || (char*)dst >= ((char*)src + count)) {
        while (count--) {
            *(char*)dst = *(char*)src;
            dst = (char*)dst + 1;
            src = (char*)src + 1;
        }
    }
    else {
        dst = (char*)dst + count - 1;
        src = (char*)src + count - 1;
        while (count--) {
            *(char*)dst = *(char*)src;
            dst = (char*)dst - 1;
            src = (char*)src - 1;
        }
    }
    return ret;
}

int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8 };
    int arr2[10] = { 0 };
    my_memmove(arr2, arr, 20);

    for (int i = 0; i < 10; i++)
    {
        printf("%d\n", arr2[i]);
    }
    return 0;
}