模拟实现字符串函数和内存操作函数

1.实现strcpy

my_strcpy( ) 函数是把原字符串拷贝到目标空间里,也会拷贝最后的原字符串中的‘\0’。

<1>函数的参数设计：

int main()
{
    char arr[20] = { 0 };
    my_strcpy(arr, "hello world");
}

数组名arr是首元素地址，因为每个元素都是char，所以首元素地址就是char的地址，char的地址就是char*，所以第一个参数用char*接收；
helloworld传过去是首字符‘h’的地址，也应用char*接收；
设计如下：

char* my_strcpy(char* dest,const char* src)；

<2>代码实现

char* my_strcpy(char* dest,const char* src)
{
    while (*src != '\0')
    {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = *src;//拷贝\0
}

//以上my_strcpy()可以优化：
char* my_strcpy(char* dest,const char* src)
{
    char *ret = dest;
    assert(dest&&src);
    //++比*高级，先++，但由于是后置++  → 先使用，后自加
    //先拷贝后++
    //拷到最后一个\0的时候 \0 = \0   表达式值为0  跳出循环
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main()
{
    char arr[20] = { 0 };
    my_strcpy(arr, "hello world");
    printf("%s\n", arr);
    return 0;
}

2.实现strcat

strcat( )是 字符串连接/追加

char* my_strcat(char* dest, const char* src)
{
    char* ret = dest;
    assert(dest && src);
    //找des指向字符串的'\0'
    while (*dest)
    {
        dest++;
    }
    //拷贝字符串
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main()
{
    char arr1[20] = "hello";
    char arr2[] = "world";
    my_strcat(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}

3.实现strstr

<1>介绍

strstr （）函数是在字符串中查找一个子字符串，返回的是子字符串在字符串中第一次出现的位置。
例如：
字符串： “abcdefabcdef”中找子字符串：“bcd”
“bcd”出现两次 ，返回的是第一次出现bcd的位置，结果是bcdefabcdef

<2>代码

char* my_strstr(const char*str, const char*substr)
{
    assert(str && substr);
    const char* cur = str;
    const char* s1 = str;
    const char* s2 = substr;
    if (*substr == '\0')
    {
        return (char*)str;//
    }
    while (*cur)
    {
        s1 = cur;
        s2 = substr;
        while (*s1 && *s2 && *s1 == *s2)
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')
        {
            return (char*)cur;
        }
        if (*s1 == '\0')
        {
            return NULL;
        }
        cur++;
    }
    return NULL;
}
int main()
{
    char *p = "abcdefabcdef";
    char *q = "bcq";
    char* ret = my_strstr(p, q);
    if (ret != NULL)
    {
        printf("找到了%s\n", ret);

    }
    else
    {
        printf("找不到\n");
    }
    return 0;
}

4.实现strchr

strchr()函数是在字符串中搜索一个字符，并返回字符第一次出现的地址；

char* my_strchr(char *str, int x)
{
    assert(str != NULL);
    while (*str)
    {
        if (*str == x)
        {
            return str;
        }
        str++;
    }
    return NULL;
}
int main()
{
    char *p = "abcd";
    int ch = 'c';
    char *ret = my_strchr(p, ch);
    printf("%s\n", ret);
    return 0;
}

5.实现strcmp

<1>介绍

strcmp（） 是比较两个字符串之间每一对的大小，不是比较长度；
例如：
“abc” “abc”相等 返回0
“abc” “ab” 不相等 若第一个字符串大于第二个字符串返回大于0的数字，若小于返回小于0的数字

<2>代码

int my_strcmp(const char*s1,const char*s2)
{
    assert(s1 && s2);
    while(*s1 == *s2)
    {
        if (*s1 == '\0')
        {
            return 0;
        }
        s1++;
        s2++;
    }
    return *s1-*s2;
}
int main()
{
    char *p1 = "abcdef";
    char *p2 = "bbbbbb";
    printf("%d\n", my_strcmp(p1, p2));
    return 0;
}

6.实现memcpy

memcpy（）是内存拷贝，可以拷贝char型，int型等等；

<1>.分析一下为什么有了strcpy函数，还要有memcpy函数

(1) char arr1[10] = "abcdef";
        char arr2[5] = { 0 };
        strcpy(arr1, arr2);//拷贝的结果是只拷贝过去第一个0（\0），就停止了


(2) int arr1[10] = { 0 };
        int arr2[5] = { 1, 2, 3, 4, 5 };
        //01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
        //整型是四个字节，strcpy（）是一个字节一个字节的拷贝，第二个就遇到了00（\0）
        strcpy(arr1, arr2);
        //strcpy的参数是char*的，而这两数组是int*，有类型冲突，有警告

<2>代码

//void *   无类型指针
void* my_memcpy(void *dest,const void *src,size_t count)
{
    void *ret = dest;
    assert(dest && src);

    while (count--)
    {
        *(char *)dest = *(char *)src;
        dest = (char *)dest + 1;
        src = (char *)src +1;
    }
    return ret;
}
int main()
{
    int arr1[10] = { 0 };
    int arr2[5] = { 1, 2, 3, 4, 5 };
    my_memcpy(arr1, arr2,20);
    return 0;
}

7.实现memmove

<1>分析

<2>代码

void* my_memmove(void*dest, const void*src, size_t count)
{
    void*ret = dest;
    assert(dest && src);
    if (dest < src)
    {
        //从前向后拷贝
        while (count--)
        {
            *(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else
    {
        //从后向前拷贝
        while (count--)
        {
            *((char*)dest + count) = *((char*)src + count);
        }
    }
    return ret;
}
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    memmove(arr, arr + 2, 16);
    return 0;
}