常见字符串函数的模拟实现（一）(c语言)

1.三种方式模拟实现strlen函数
2.模拟实现strcpy
3.模拟实现strcat
4.模拟实现strcmp
5.模拟实现strstr
6.模拟实现memcpy
7.模拟实现memmove

//模拟实现strlen（求字符串长度）

// 1>指针
int my_strlen(char const*s)
{
    char*p = s;
    while (*p != 0)
    {
        p++;
    }

    return p - s;
}
int my_strlen(char s[])
{
    int len = 0;
    while (*s++ != 0)
    {
        len++;
    }
    return len;
}


// 2>函数递归
int my_strlen(char*s)
{
    if (*s == '\0')
        return 0;
    else
        return 1 + my_strlen(s + 1);
}


// 3>计数
int my_strlen(char s[])
{
    int i = 0;
    int count = 0;
    while (s[i++] != '\0')
        count++;
    return count;
}

//模拟实现strcpy （拷贝字符串）


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

//模拟实现strcat（字符串链接）


char* my_strcat(char*dest, const char* src)
{
    char* ret = dest;
    assert(*dest != 'NULL');
    assert(*src != 'NULL');
    while (*dest != '\0')
        dest++;
    while (*dest++ = *src++)//将src链接到dest上
    {
        ;
    }
    return ret;
}

//模拟实现strcmp（字符串比较）

int my_strcmp(const char*src1, const char*src2)
{
    //判断两个源字符串都不为空
    assert(*src1 != '\0');
    assert(*src2 != '\0');                  
    while (!(*src1 - *src2) && src2)
    {
        *src1++;
        *src2++;
    }
    return*src1 - *src2;
}

//模拟实现strstr(查找子串)

char* my_strstr(const char*src, const char*sub)
{
    assert(src);
    assert(sub);
    char*p = src;
    char*s1 = p;
    char*s2 = sub;
    while (*s1)
    {
        s1 = p;
        s2 = sub;
        while ((*s1 != '\0') && (*s2 != '\0'))
        {
            if (*s1++ == *s2++)
            {
                ;
            }
            else
            {
                p++;
                break;
            }
            if (*s2 == '\0')
            {
                return p;
            }
        }
    }

}

//模拟实现memcpy(不考虑内存重叠时的内存拷贝)


void my_memcpy(void*dest, const void*src, int count)
{
    char *psrc, *pdest;
    psrc = (char *)src;
    pdest = (char *)dest;
    while (count--) 
    {
        *pdest++ = *psrc++;

    }
}

//模拟实现memmove(复制内存)


void* my_memmove(void*dest, const void*src, int count)
{
    char*psrc;
    char*pdest;
    if ((NULL ==dest) || (NULL == src))
    {
        return NULL;
    }
    if ((src<dest) && (char*)src + count>(char*)dest)
    {
        psrc = (char*)src + count - 1;
        pdest = (char*)dest + count - 1;
        while (count--)
        {
            *pdest-- = *psrc--;
        }
    }
    else
    {
        psrc = (char*)src;
        pdest = (char*)dest;
        while (count--)
        {
            *pdest++ = *psrc++;
        }
    }
    return dest;
}

以上代码均已运行测试过，如有错误，忘指出。