模拟实现strcpy,memcpy,memovestrcat,

用于复制字符串的函数是strcpy,他的原型如下：
char *strcpy(char *dest, char const *src)

这个函数是把参数src复制到参数dest中，由于dest将进行修改，所以他不能是一个常量，必须是一个字符数组或者指向一块动态分配内存区域的指针，另外，新的字符串是以null结尾，所以老字符串最后剩余几个字符也会被有效的删除，也无法被字符串函数访问。其次，程序员必须保证目标字符串的空间足以容纳需要复制的字符串，因为strcpy无法判断目标字符串的长度，容易产生大量调试工作，例如

char arr1[] = "original";
...
if (...)
strcpy(message, "diffent");

条件为真并且顺序执行，数组将包含下面内容

下面将模拟实现strcpy

#include<assert.h>
char *my_strcpy( char *dest, const char *src)
{
    assert(dest != NULL);//检验是否为空
    assert(src != NULL);
    char *ret = dest;//指向目标字符串的指针

    while (*dest++ = *src++)//先拷贝，然后指针后移，一个一个依次拷贝
    {

    }
    return ret;//返回一个指向目标字符串的指针


}
int main()
{
    char *p = "abcdehy";
    char buff[64];
    printf("%s", my_strcpy(buff, p));
    printf("\n");
    system("pause");
    return 0;

}

memcpy是内存拷贝函数，与数据类型无关，即可以拷贝任意类型数据，（需要传递数据类型长度），而strcpy只能拷贝字符串。两者相同的是程序员必须保证目标字符串的空间足以容纳需要复制的字符串，都会拷贝字符’\0’,其函数原型如下

void *memcpy(void *dest,const void *src,size_count)
下面模拟实现memcpy 函数

void *my_memcpy(void *dest, const void *src, int count)
{
    void *ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    while (count--)
    {
        *(int *)dest = *(int *)src;//开始拷贝
        dest = (int *)dest + 1;
        src = (int *)src + 1;

    }
    return ret;


}
int main()
{

    int arr[] = { 1,2,3,4,5 };
    int buff[64];
    int len = sizeof(arr) / sizeof(arr[1]);
    printf("%d", my_memcpy(buff, arr, len));
    system("pause");
    return 0;
}

函数strcpy和memcpy都存在一个问题，即程序员必须保证目标字符串的空间足以容纳需要复制的字符串，那如果不满足该条件时，就会发生内存重叠现象，导致输出错误，而函数memmove便能很好的解决这个问题。同时也可以拷贝任何类型，内存图如下

.实现memmove

#define _CRT_SECURE_NO
#include<stdio.h>
#include <assert.h>
#include <windows.h>

void *my_memmove(void  *dest, void *src, int count)
{
    char *ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    //内存不重叠，从地地址向高地址拷贝
    if (dest<=src||(char *)dest >=((char *) src + count))
    {



        while (count--)
        {


            *dest = *src;
            dest = (char *)dest + 1;
            src = (char *)src + 1;
        }

    }

    //内存重叠，由高地址向地地址拷贝
    else
    {
        dest = (char *)dest + count;//内存重叠，由高地址向地地址拷贝
        src = (char *)src + count;

        while (count--)
        {
            *dest = *src;
            dest = (char *)dest - 1;
            src = (char *)src - 1;

        }

    }
    return ret;


}
int main()
{
    char arr[] = "abcd123";
    char buff[64];
    int len = sizeof(arr) / sizeof(arr[1]);
    my_memmove(buff, arr, len);
    printf("%s", buff);
    system("pause");

    return 0;

}

#define _CRT_SECURE_NO
#include<stdio.h>
#include <assert.h>
#include <windows.h>
//模拟实现strcat
char *my_strcat(char *dest, const char *src)
{
    assert(dest != NULL);
    assert(src != NULL);
    char *ret = dest;
    while (*dest)//先遍历一边目标字符串，找到'\0'，跳出循环，开始拷贝，拷贝过程与strcpy同理
    {
        dest++;

    }
    while (*dest++ = *src++)//先将*src拷贝到*dest,然后指针后移
    {
        ;
    }
    return ret;
}
int main()
{
    char arr1[64] = "abcd";
    char arr2[64] = "efgh";
    printf("%s\n", my_strcat(arr1,arr2));
    system("pause");
    return 0;
}