Simulation of character and string functions for summarizing

Analog character and string functions to achieve

Analog implementation strlen

method one:

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

Method Two:

//不能创建临时变量计数器
int my_strlen(const char * str)
{
    if(*str == '\0')
        return 0;
    else
        return 1+my_strlen(str+1);
}

Method three:

//指针-指针的方式
int my_strlen(char *s)
{
       char *p = s;
       while(*p != ‘\0’ )
              p++;
       return p-s;
}

Analog implementation strcpy

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

Analog implementation strcat

char *my_strcat(char *dest, const char*src)
{
    char *ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    while(*dest)
    {
        dest++;
    }
    while((*dest++ = *src++))
    {
        ;
    }
    return ret;
}

Analog implementation strstr

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

Analog implementation strcmp

int my_strcmp (const char * src, const char * dst)
{
        int ret = 0 ;
        assert(src != NULL);
        assert(dest != NULL);
        while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
                ++src, ++dst;
 
        if ( ret < 0 )
                ret = -1 ;
        else if ( ret > 0 )
                ret = 1 ;
 
        return( ret );
}

Analog implementation memcpy

void * memcpy ( void * dst, const void * src, size_t count)
{
        void * ret = dst;
        assert(dst);
        assert(src);
        while (count--) {
                *(char *)dst = *(char *)src;
                dst = (char *)dst + 1;
                src = (char *)src + 1;
        }
 
        return(ret);
}

Analog implementation memmove

void * memmove ( void * dst, const void * src, size_t count)
{
        void * ret = dst;
        if (dst <= src || (char *)dst >= ((char *)src + count)) {
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst + 1;
                        src = (char *)src + 1;
                }
        }
        else {
                dst = (char *)dst + count - 1;
                src = (char *)src + count - 1;
 
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst - 1;
                        src = (char *)src - 1;
                }
        }
 
        return(ret);
}