C字符串处理函数（重写）

函数： strcpy
原型： char * strcpy( char* _Dest, const char *_Source );
功能： 复制源串_Source到目标串_Dest所指定的位置, 包含NULL结束符. 不能处理源串与目标串重叠的情况. 函数返回_Dest值.
char * Strcpy( char* _Dest, const char *_Source )
{
    assert((_Dest != NULL) && (_Source != NULL));

    while( ( *_Dest++ = *_Source++) != '\0'){
        NULL;
    }

    return _Dest;

}
*/

char * Strcpy( char* _Dest, const char *_Source )
{
    assert((_Dest != NULL) && (_Source != NULL));

    while(*_Source != '\0'){
        *_Dest++ = *_Source++;
    }
    *_Dest = '\0';

    return _Dest;

}
函数： strlen的实现代码
功能： size_t strlen( const char *_Str );
功能： 获取字符串长度, 字符串结束符NULL不计算在内. 没有返回值指示操作错误.
int Strlen( const char *_Str )
{
    int length = 0;

    assert(_Str != NULL);

    while(*_Str++ != '\0'){
        length++;
    }

    return length;
}
函数： strcat
原型： char * strcat( char *_Dest, const char *_Source );
功能： 将源串_Src字符添加到目标串_Dst后. 本函数不能处理源串与目标串重叠的情况.
char * Strcat( char *_Dest, const char *_Source )
{
    assert((_Dest != NULL) && (_Source != NULL));

    char *_Temp = _Dest;

    while( *_Temp != '\0')
        _Temp++;

    while(*_Source != '\0'){
        *_Temp++ = *_Source++;
    }
    *_Temp = '\0';

    return _Dest;
}

char * Strcat( char *_Dest, const char *_Source )
{
    assert((_Dest != NULL) && (_Source != NULL));

    char *_Temp = _Dest;

    while( *_Temp != '\0'){
        _Temp++;
    }

    while((*_Temp++ = *_Source++ ) != '\0');

    return _Dest;
}
函数说明: memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。
与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'/0'而结束
memcpy功能和memmove相同，但是memcpy中dest和source中的区域不能重叠，否则会出现未知结果。
返回值说明：返回指向dest的void *指针
附加说明: 指针src和dest所指的内存区域不可重叠
void *Memcpy(void* _Dest , const void* _Source, int count)
{
    assert((_Dest != NULL) && (_Source != NULL));

    char* str1 = (char*)_Dest;
    char* str2 = (char*)_Source;

    while(count--)
    {
        *str1++ = *str2++;    //不对是否存在重叠区域进行判断
    }

    return _Dest;
}

void *Memset(void *src, int c, size_t count)
{
    assert( NULL != src);

    char* str = (char*)src;

    while(count--){
        *str++ = (char)c;
    }

    return src;
}


函数： strstr的实现
原型： char * strstr( char *_Str, const char *_SubStr );
功能： 在字符串_Str中查找_SubStr子串. 返回子串_SubStr在_Str中首次出现位置的指针.
如果没有找到子串_SubStr, 则返回NULL. 如果子串_SubStr为空串, 函数返回_Str值.

#include <stdio.h>
#include <assert.h>
#include <string.h>
char * Strstr( char *_Str, const char *_SubStr )
{
    assert( _Str != NULL);

    if(_SubStr == NULL)
        return _Str;

    int i = 0;
    int j = 0;
    int flag = 1;
    int str1_len = strlen(_Str);
    int str2_len = strlen(_SubStr);

    while( (i < str1_len) && (j < str2_len))
    {
        if(_Str[i] == _SubStr[j]){
            i++;
            j++;
            flag = 1;
        }
        else{
            j = 0;
            i++;
            flag = 0;
        }
    }

    if(flag == 0){
        return NULL;
    }
    else if(flag == 1){
        return (_Str + i - j);
    }
}

int main()
{
    char str1[] = "abcdef";
    char str2[] = "ccde";
    printf("%s\n", Strstr(str1, str2) );
    return 0;
}
函数说明：memmove用于从source拷贝count个字符到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。
返回值说明：返回指向dest的void *指针
void *Memmove(void *dest, const void *src, size_t count)
{
    assert( (dest!=NULL)&&(src!=NULL) );

    char *tmp_dest=(char*)dest;
    char *tmp_src=(char*)src;

    if( (tmp_dest + count < tmp_src) || (tmp_src + count < tmp_dest) )
    {// 如果没有重叠区域
        while(count--)
            *tmp_dest++=*tmp_src++;
    }
    else
    {// 如果有重叠区域
        tmp_dest+=count-1;
        tmp_src+=count-1;
        while(count--)
            *tmp_dest--=*tmp_src--;
    }
    return dest;
}