C语言：字符串函数（strcpy，memcpy等）模拟实现

不受限制的字符串函数（strcpy，strcat，strcmp）

（1）字符串复制
C语言标准库函数strcpy，把从src地址开始且含有’\0’结束符的字符串复制到以dst开始的地址空间。
模拟实现strcpy：

char *my_strcpy(char *dst,const char*src)
{
    char *p = dst;
    assert(dst!=NULL&&src!=NULL);
    while((*dst++ = *src++)!='\0');
    return p;
}
int main()
{
    char str1[] = "abc";
    char str2[] = "defg";
    printf("将str1内存中内容拷贝到str2中:\n");
    my_strcpy(str2,str1);
    printf("%s\n",str2);
    return 0;
}

（2）字符串连接
strcat是把src所指字符串添加到dest结尾处(覆盖dest结尾处的‘\0’)，src和dst所指内存区域不可以重叠，所以dst必须有足够的空间来容纳。最后结果返回的是指向dst的指针。

char *my_strcat(char *dst,const char *src)
{
    char *p = dst;
    assert(dst&&src);
    while(*dst)
    {
        dst++;
    }
    while(*dst++ = *src++)
    {
        ;
    }
    return p;
}
int main()  
{  
    char str1[10] = "AB";  
    char str2[] = "EFGH";
    printf("将str2拼接到str1后面：\n");
    my_strcat(str1,str2);
    printf("%s\n",str1);
    return 0;
}

（3）字符串比较
比较两个字符串涉及对两个字符串对应的字符逐个比较，直到发现不匹配为止。
如果str1大于str2返回1，如果str2大于str1返回-1。

int my_strcmp(const char* str1,const char* str2)
{
    assert(str1&&str2);
    while(*(str1) ==*(str2))
    {
        if(*str1 == '\0')
            return 0;
        str1++;
        str2++;
    }
    if(*str1 >*str2)
        return 1;
    else 
        return -1;
}
int main()  
{  
    char str1[] = "AB";  
    char str2[] = "ABCDEFG";  
    printf("将str1与str2比较，大于输出1，小于输出-1，等于输出0\n");  
    printf("结果为：%d\n", my_strcmp(str2, str1));  
    return 0;
}

长度受限的字符串函数 （strncpy，strncat，strncmp）

标准库还包括了一些函数，这些函数接受一个显示的长度参数，用于限定进行复制或比较的字符数，可以防止难以预料的长字符串从它们的目标数组溢出。
（1）strncpy

char *my_strncpy(char *dst,const char *src,size_t n)
{
    char *p=dst;
    assert(dst!=NULL&&src!=NULL);
    while(n)
    {
        if((*dst++ =*src++)=='\0')
            break;
        n--;
    }
    return 0;
}

（2）strncat

char* my_strncat(char *dst,const char *src,size_t n)
{
    char *p = dst;
    assert(dst&&src);
    while(*dst)
    {
        dst++;
    }
    while(n--)
    {
        *dst++ = *src++;
    }
    *dst='\0';
    return p;
}

（3）strncmp

int my_strncmp(const char* str1, const char* str2,int n)  
{  
    assert(str1);  
    assert(str2);  
    while (n)  
    {  
        if (*str1 == *str2)  
        {  
            str1++;  
            str2++;  
        }  
        else  
        {  
            return *str1 - *str2;  
        }  
        n--;  
    }  
    return 0;  
}

内存操作

（1）模拟实现内存操作函数memcpy
memcpy是内存拷贝函数，功能是从源src所指的内存地址的起始位置开始拷贝num个字节到目标dst所指的内存地址的起始位置中

void *my_memcpy(void *dst,const void *src,size_t num)
{
    void *ret = dst;
    while(num--)
    {
         *(char*)dst = *(char *)src;  
         dst = (char*)dst + 1;
         src = (char*)src + 1;
    }
    return ret;
}
int main()
{
    char str1[] = "abccde";
    char str2[] = "1234";
    printf("%s\n",my_memcpy(str1,str2,3));
    return 0;
}

（2）模拟实现内存操作函数memcpy
memmove用于从src拷贝count个字节到dst，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。但复制后src内容会被更改。但是当目标区域与源区域没有重叠则和memcpy函数功能相同。

void * my_memmove(void * dst, const void * src, size_t num)  
{  
    void *ret = dst;  
    if (dst<src || ((char *)dst>(char*)src + num))  
    {  
        while (num--)  
        {  
            *(char*)dst = *(char *)src;  
            dst = (char *)dst + 1;  
            src = (char*)src + 1;  
        }  
    }  
    else  
    {  
        dst = (char*)dst + num - 1;  
        src = (char*)src + num - 1;  
        while (num--)  
        {  
            *(char*)dst = *(char *)src;  
            dst = (char *)dst + 1;  
            src = (char*)src + 1;  
        }  
    }  
    return ret;  
}
int main()  
{  
    char arr[10] = "abcdefg";  
    char arr0[10] = "abcdefg";  
    char arr1[10] = { 0 };  
    my_memmove(arr + 1, arr, 4);  
    my_memmove(arr1, arr0, 4);  
    printf("内存覆盖情况：%s\n", arr + 1);  
    printf("正常情况：%s\n", arr1);  
}