M的C语言备忘录——字符函数和字符串函数

1、strlen

size_t strlen ( const char * str )

        返回字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。

        参数指向的字符串必须要以 '\0' 结束。

        函数的返回值为size_t，是无符号的

模拟实现：

int my_strlen(char* str) 
{ 
    int len = 0; 
    while (*str) 
    {     
        str++; 
        len++; 
    } 
    return len; 
}

2、strcpy

char* strcpy(char * destination, const char * source )

原字符串必须以 '\0' 结束。

会将原字符串中的 '\0' 拷贝到目标空间。

目标空间必须足够大，以确保能存放源字符串。

目标空间必须可变

模拟实现：

char* my_strcpy(char* str1, const char* str2) 
{ 
    assert(str1 && str2); 
    char* ret = str1; 
    while (*str1++ = *str2++) 
    { 
        ; 
    } 
    return ret; 
}

3、strcat

char * strcat ( char * destination, const char * source )

原字符串必须以 '\0' 结束。

目标空间必须有足够的大，能容纳下原字符串的内容。

目标空间必须可修改。

模拟实现：

char* my_strcat(char* str1, const char* str2) 
{     
    char* ret = str1; 
    assert(str1 && str2); 
    while (*str1) 
    { 
        str1++; 
    } 
    while (*str1++ = *str2++) 
    { 
        ; 
    } 
    return ret; 
}

4、strcmp

int strcmp ( const char * str1, const char * str2 )

标准规定：

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

模拟实现：

int my_strcmp(const char* str1,const char* str2) 
{ 
    assert(str1 && str2); 
    while (*str1 == *str2) 
    { 
        if (str1 == '\0') 
        { 
            return 0; 
        } 
        str1++; 
        str2++; 
    } 
    return *str1 - *str2; 
}

5、strncpy

char * strncpy ( char * destination, const char * source, size_t num )

拷贝num个字符从源字符串到目标空间。

如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

6、strncat

char * strncat ( char * destination, const char * source, size_t num )

7、strncmp

int strncmp ( const char * str1, const char * str2, size_t num )

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

8、strstr

char * strstr ( const char *str1, const char * str2)

模拟实现：

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

9、strtok

char * strtok ( char * str, const char * sep )

sep参数是个字符串，定义了用作分隔符的字符集合

第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标

记。

strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：

strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容

并且可修改。）

strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串

中的位置。

strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标

记。

如果字符串中不存在更多的标记，则返回 NULL 指针。

10、strerror

char * strerror ( int errnum )

11、memcpy

void * memcpy ( void * destination, const void * source, size_t num )

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

这个函数在遇到 '\0' 的时候并不会停下来。

如果source和destination有任何的重叠，复制的结果都是未定义的。

模拟实现：

void* my_memcpy(void* str1, const void* str2, int num) 
{ 
    void* cur = str1; 
    while (num--) 
    { 
        *(char*)str1 = *(char*)str2; 
        str1 = (char*)str1 + 1; 
        str2 = (char*)str2 + 1; 
    } 
    return cur; 
}

12、memmove

void * memmove ( void * destination, const void * source, size_t num )

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

如果源空间和目标空间出现重叠，就得使用memmove函数处理。

模拟实现：

void* my_memmove(void* str1, const void* str2, int num) 
{ 
    void* cur = str1; 
    if (str1 <= str2 || (char*)str1 >= (char*)str2 + num) 
    { 
        while (num--) 
        { 
            *(char*)str1 = *(char*)str2; 
            str1 = (char*)str1 + 1; 
            str2 = (char*)str2 + 1; 
        } 
    } 
    else 
    { 
        str1 = (char*)str1 + num - 1; 
        str2 = (char*)str2 + num - 1; 
        while (num--) 
        { 
            *(char*)str1 = *(char*)str2; 
            str1 = (char*)str1 - 1; 
            str2 = (char*)str2 - 1; 
        } 
    } 
    return cur; 
}

13、memcmp

int memcmp ( const void * ptr1, const void * ptr2, size_t num )

比较从ptr1和ptr2指针开始的num个字节