模拟库函数实现字符串的操作

//求字符串的长度
size_t Strlen(const char* string)
{
    const char* str = string;
    assert(string);
    while (*string ++)
        ;
    return (string - str - 1);
}

//比较字符串大小
int Strcmp(const char* str1, const char* str2)
{
    int ret = 0;
    assert(str1&&str2);
    while ( !(ret = (*str1 - *str2)) && *str2)
        ++str1, ++str2;
    if (ret<0)
        ret = -1;
    else if (ret > 0)
        ret = 1;
    return (ret);
}
//把src所指字符串的前n个字符添加到dest所指字符串的结尾处，并覆盖
//dest所指字符串结尾的'\0'，从而实现字符串的连接。

char* Strncat(char* dest, const char* src, size_t n)
{
    char* start = dest;
    assert(dest && src);
    while (*dest ++)
        ;
    dest --;
    while (n --)
        if(!(*dest = *src))
            return start;
        else 
            dest++, src++;
    *dest = '\0';
    return start;
}
//翻转字符串
char* Strrev(char* str)
{
    char* start = str;
    char* end = str;
    assert(str);
    while (*end ++)
        ;
        end-=2;
    while (str < end)
    {
        char temp = *str;
        *str = *end;
        *end = temp;
        str ++;
        end --;
    }
    return start;
}

//strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。
//如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。
char* Strstr(const char* str1, const char* str2)
{
    char* start ;
    char* end;
    assert(str1 && str2);
    start = (char*)str1;
    if (!*str2)
        return str1;
    while (*str1)
    {
        start = str1;
        end = (char*)str2;
        while (*start && *end && !(*start - *end))
            start++, end++;
        if (!(*end))
            return str1;
        str1++;
    }
    return NULL;

}
//c和c++使用的内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始
//位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。
void* Memcpy(void* dest, const void* src, size_t n)
{
    void* start = dest;
    assert(dest && src);

    while (n --)
    {
        *(char*)dest = *(char*)src;
        dest = (char*) dest + 1;
        src = (char*) src + 1;
    }

    return start;
}
//memmove用于从src拷贝count个字节到dest，如果目标区域和源区域有重叠的话，
//memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。
void* Memmove(void* dest,const void* src, size_t n)
{
    void *start = dest;
    assert(dest && src);

    if ((dest <= src) || (char*)dest >= (char*)src + n)
    {
        while (n--)
        {
            *(char*)dest = *(char*)src;
            (char*)dest = (char*)dest +1;
            (char*)src = (char*)src +1;
        }
    }
    else
    {
        (char*)dest = (char*)dest + n - 1;
        (char*)src = (char*)src + n - 1;
        while (n --)
        {
            *(char*)dest = *(char*)src;
            (char*)dest = (char*)dest - 1;
            (char*)src = (char*)src - 1;
        }
    }
    return start;
}