①  strlen（字符串长度）

size_t strlen (const char* str);

//计数器方式
int my_strlen(const char* str)
{
    int count = 0;
    assert(str != NULL);
    while(*str++ != '\0')
    {
        count++;
    }
    return count;
}

//递归实现
int my_strlen(const char* str)
{
    if(*str == '\0')
    {
        return 0;
    }
    else
    {
        return 1+my_strlen(str+1);
    }
}

//指针实现
int my_strlen(char* s)
{
    char* p = s;
    while(*p != '\0')
    {
        p++;
    }
    return p-s;
}

 
② strcpy（字符串拷贝）
 

char* strcpy(char* des, const char* str);

char* my_strcpy(char* des,const char* str)
{
    char* ret = des;
    assert(des != NULL);
    assert(str != NULL);
    while(*des++ = *str++)
    {
        ;
    }
    return ret;
}

 ③ strncpy（字符串拷贝n个）
 

char* strncpy(char* des, const char* str, size_t num);

char* my_strncpy(char* dest, const char* src, size_t num)
{
    char* ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    while (num--)
    {
        if (*src != '\0')
        {
            *dest = *src;
            dest++;
            src++;
        }
        else
        {
            *dest = 0;
            dest++;
        }
    }
    return ret;
}

 ④ strcat（字符串追加）

char* strcat(char* dest, const char* str);

char* my_strcat(char* dest, const char* str)
{
    char* ret = dest;
    assert(dest != NULL);
    assert(str != NULL);
    //找到目标空间的'\0'
    while(*dest)
    {
        dest++;
    }
    //拷贝
    while(*dest++ = *str++)
    {
        ;
    }
    return ret;
}

 ⑤ strncat（字符串追加n个）
 

char* strncat(char* dest, const char* str, size_t num);

char* my_strncat(char* dest, const char* str, size_t num)
{
    char* ret = dest;
    assert(dest != NULL);
    assert(str != NULL);
    while(*dest++)
    ;
    while(num--)
    {
        *dest++ = *str++;
    }
    return ret;
}

⑥  strcmp（字符串比较）

int strcmp(const char* str1, const char*str2);

int my_strcmp(const char* str1, const char*str2)
{
    assert(str1 != NULL);
    assert(str2 != NULL);
    while(*str1 == *str2)
    {
        if(*str1 == '\0')
        {
            return 0;
        }
        str1++;
        str2++;
    }
    return *str1 - *str2;
}

⑦  strncmp（字符串比较n个）

int strncmp(const char* str1, const char*str2, size_t num);

比较到出现两个字符不一样，或者一个字符串结束，或者num个字符全部比较完

int my_strncmp(const char* dest,const char* src,size_t num)
{
    int ret = 0;
 
    while (num--)
    {
        if (src == '\0')
            return 0;
        if (!(*dest == *src))
        {
            ret = *(unsigned char*)dest - *(unsigned char*)src;
        }
        dest++;
        src++;
    }
    return ret;
}

 ⑧ strstr（找子字符串）

char* strstr(const char* str1, const char* str2);

返回str2第一次在str1中出现的一个指针，若str2没有在str1中出现则返回空指针

char* my_strstr(const char* str1, const char* str2)
{
    const char* cur = str1;
    const char* s1 = str1;
    const char* s2 = str2;
    assert(str1 != NULL);
    assert(str2 != NULL);
 
    while (*cur)
    {
        s1 = cur;
        s2 = str2;
        while ((*s1)&&(*s2)&&(*s1 == *s2))
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')
        {
            return (char*)cur;
        }
        cur++;
    }
    return NULL;
}

⑨  memcpy

void* memcpy(void* dest,const void* src, size_t num);

//void*接收任意类型数据，void*不能解引用，不能自增自减
void* my_memcpy(void* dest,const void* src, size_t num)
{
    void* ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    
    //一个字节一个字节拷贝
    while(num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest+1;
        src = (char*)src+1;
    }
    return ret;
}

⑩  memmove

void* memmove(void* dest,const void* src,size_t num);

//方式一
void* my_memmove(void* dest,const void* src,size_t num)
{
    void* ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    
    if (dest < src)//前->后
    {
        while (num--)
        {
            *(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else //后->前
    {
        while (num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
    return ret;
}

//方式二
void* my_memmove(void* dest,const void* src,size_t num)
{
    void* ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    
    if (dest>src && dest<(char*)src+num)//后->前
    {
        while (num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
    else   //前->后
    {
        while (num--)
        {
            *(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    return ret;
}