1. strcpy

char* strcpy(char *destStr, const char *sourStr)
{
//    if(sourStr == NULL || destStr == NULL)
//    {
//        return;
//    }
    assert((sourStr != NULL)&&(destStr != NULL));

    char *str = destStr;

    while(*sourStr!='\0')
    {
        *destStr = *sourStr;
        destStr++;
        sourStr++;
    }
    *destStr = '\0';
    return str;
}

注意点：

1. 源字符串参数需要const修饰。（const 在左边表示指针所指向内容的是常量，const在右边表示指针是常量，指针所指向的内容可以改变）
2. 判断源字符串和目的字符串是否为空
3. 最后记得要加‘\0’

2. memcpy

void* memcpy(void* dst, const void* srt, size_t count)
{
    assert((dst!=NULL)&&(srt!=NULL));
    unsigned char *pdst = (unsigned char*) dst;
    const unsigned char *psrt = (const unsigned char*) srt;
    //内存重叠
    assert(!(pdst <= psrt && psrt + count > pdst));
    assert(!(psrt >= pdst && pdst + count > psrt));

    while(count--)
    {
        *pdst = *psrt;
        pdst++;
        psrt++;
    }
    return dst;
}

注意点：

1. 源字符串参数需要const修饰。（const 在*左边表示指针所指向内容的是常量，const在*右边表示指针是常量，指针所指向的内容可以改变）
2. 判断源字符串和目的字符串是否为空
3. 要判断两块内存是否重叠，重叠报错
4. 参数类型和返回类型均为void*

memcpy和strcpy函数区别：

1. strcpy只能用作字符串的拷贝，memcpy可以用作任何类型的拷贝
2. strcpy没有指定拷贝数据的大小，直到遇到'\0'才结束拷贝，很可能造成缓冲区溢出。memcpy指定了拷贝大小，减小了这种可能性。

3.memmove

void* memmove(void *dst, const void *src, size_t count){
    // 容错处理
    if(dst == NULL || src == NULL){
        return NULL;
    }
    unsigned char *pdst = (unsigned char *)dst;
    const unsigned char *psrc = (const unsigned char *)src;
    //判断内存是否重叠
    bool flag1 = (pdst >= psrc && pdst < psrc + count);
    bool flag2 = (psrc >= pdst && psrc < pdst + count);
    if(flag1 || flag2){
        // 倒序拷贝
        while(count){
            *(pdst+count-1) = *(psrc+count-1);
            count--;
        }//while
    }
    else{
        // 拷贝
        while(count--){
            *pdst = *psrc;
            pdst++;
            psrc++;
        }//while
    }
    return dst;
}

注意点：

1. 源字符串参数需要const修饰。（const 在*左边表示指针所指向内容的是常量，const在*右边表示指针是常量，指针所指向的内容可以改变）
2. 判断源字符串和目的字符串是否为空
3. 要判断两块内存是否重叠，重叠后进行倒序拷贝。
4. 参数类型和返回类型均为void*