1、模拟实现strcpy
思路分析： 源字符串的字符逐个赋值给目标字符串
代码如下：

#include<stdio.h> 
#include<assert.h>
char* my_strcpy(char *dest,const char *src)
{
    char *ret = dest;
    assert(dest && src);
    while(*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main()
{
    char arr1[] = "abcdef";
    char arr2[10] = {0};    
    my_strcpy(arr2,arr1);
    printf("拷贝完成后的字符串：%s\n",arr2);
    return 0;
} 

结果如下：

2、模拟实现strcat
思路分析： 先找到目标字符串的’\0’，接着把源字符串的字符逐个拷贝到目标字符串
代码如下：

#include<stdio.h> 
#include<assert.h>
char* my_strcat(char *dest,const char *src)
{
    char *ret = dest;
    assert(dest && src);
    while(*dest)
    {
        dest++;
    }
    while(*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main()
{
    char arr1[] = "abcdef";
    char arr2[10] = "bbb";  
    my_strcat(arr2,arr1);
    printf("字符串连接完成后：%s\n",arr2);
    return 0;
} 

运行结果如下：

3、模拟实现strstr
思路分析：strstr函数是在字符串中查找子字符串，如果有，输出子字符串的位置；否则输出空。

#include<stdio.h>  
#include<assert.h> 

char *my_strstr(const char *str1, const char *str2)
{
    assert(str1 && str2);

    char *cp = (char *)str1;       //cp用来保存首地址
    char *substr = (char *)str2;
    char *s = NULL;
    if(*str2 == '\0')
        return NULL;

    while(*cp)
    {
        s = cp;
        substr = (char *)str2;
        while(*s && *substr && (*s == *substr))
        {
            s++;
            substr++;
         } 
        if(*substr == '\0')
            return cp;
        cp++;
    }
}
int main()
{
    char arr1[20] = "abbbcdef";
    char arr2[10] = "bbcde";
    printf("%s\n", my_strstr(arr1, arr2));
    return 0;
}

结果如下：

4、
1）模拟实现strchr
在已知字符串中查找第一次出现的字符，如果有，输出子字符的位置；否则输出空。

#include<stdio.h>
#include<assert.h>
char*my_strchr(const char *str, char c)
{
    assert(str);
    while (*str!=NULL)
    {
        if (*str == c)
        {
            return (char *)str;//如果找到，返回该字符的地址
        }
        else
        {
            str++;
        }
    }
    return NULL;//找完全部，如果没有，则返回NULL
}

int main()
{
    char arr[] = "abcdefe";
    char p = 'e';
    printf("%s", my_strchr(arr, p));
    return 0;
}

结果如下：

2）模拟实现strrchr
在已知字符串中查找最后一次出现的字符，如果有，输出子字符的位置；否则输出空。

#include<stdio.h>
#include<assert.h>
char *my_strrchr(const char *str, char c)
{
    assert(str);
    char*pos = 0;
    while (*str != NULL)
    {
        if (*str == c)
        {
            pos = (char *)str;
            str++;
        }
        else
        {
            str++;
        }       
    }
    if (pos == 0)
        return NULL;
    else
        return pos;
}

int main()
{
    char arr[] = "abcdefegh";
    char p = ' i';
    printf("%s", my_strrchr(arr, p));
    return 0;
}

结果如下：

5、模拟实现strcmp
字符串比较 比较的是字符串中字符的大小，并非字符串的长度。
当str1中的含有大于str2的字符时（ASCII），则str1 > str2。
具体的代码实现方法如下：

#include<stdio.h>
#include<assert.h>
int my_strcmp(const char *src, const char *dest)
{
    assert(src && dest);
    while (!(*(unsigned char *)src - *(unsigned char *)dest) && *dest)
    {
        ++src;
        ++dest;
    }
    return *src - *dest;
}
int main()
{
    int ret = 0;
    char str1[] = "abbdef";
    char str2[] = "abcdef";
    ret =(int) my_strcmp(str1, str2);
    if (ret > 0)
        ret = 1;
    else if (ret < 0)
        ret = -1;
    printf("%d\n", ret);
    return 0;
}

str1 > str2时的输出 “1” ；
str1 < str2时的输出 “-1” ；
str1 = str2时的输出 “0” 。
6、模拟实现memcpy
从src的位置开始向后复制count个字节的数据到dest的内存位置，这个函数在遇到\0的时候并不会停下来，如果两个字符串有任何的重复，复制的结果是未定义的。

#include<stdio.h>
#include<assert.h>
void *my_memcpy(void *dest,const void *src,size_t count)
{
    assert(dest && src);
    while(count--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest+1;
        src = (char*)src+1;
    }
}

7、模拟实现memmove
memmove与memcpy大致相同，两者的差别在于memmove函数处理的源内存块可以与目标内存块进行重叠。

#include<stdio.h>
#include<assert.h>
void *my_memmove(void *dest,const void *src,size_t count)
{
    assert(dest && src);
    if(dest <= src || (char*)dest >= (char*)src+count )
    {
        while(count--)
        {
        *(char*)dest = *(char*)src;
        dest = (char*)dest+1;
        src = (char*)src+1;
        }
    }
    else
    {
        while(count--)
        {
            *((char*)dest+count) = *((char*)src+count);
        }
     } 

}