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;

    }