一、字符串库函数

001、求字符串长度strlen

size_t strlen ( const char * str );

注意size_t是一个无符号类型，没有正负

#include <stdio.h>
#include <string.h>
int main()
{
    char*str1 = "abcdef";strcmp
    char*str2 = "bbb";
    if( strlen(str2) - strlen(str1) > 0 )
    {
        printf("str2 > str1\n");//输出“>”，本质原因是size_t是一个无符号整型
    }
    else
    {
        printf("srt1 > str2\n");
    }
    return 0;
}

002、长度不受限制的字符串函数

（1）拷贝字符串strcpy

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

注意拷贝目标空间一定要足够大
注意目标空间要能被修改，不要把字符串常量字符串放到目标处，它是不可被修改的

#include <stdio.h>
#include <string.h>
int main()
{
    char* arr1 = "abcdef";
    char arr2[] = "xxxx";
    strcpy(arr1, arr2);//程序会发生异常
    return 0;
}

（2）追加字符串strcat

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

注意追加目标空间一定要足够大
注意目标空间要能被修改，不要把字符串常量字符串放到目标处，它是不可被修改的
目标空间的’\0’被覆盖，并且源空间的’\0’也会被追加过来（这也意味着目标空间和源空间都必须有’\0’，这样才能知道“从何开始追加”，“从何结束追加”）
不能自己给自己追加

（3）比较字符串strcmp

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

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

003、受限制的字符串函数介绍

（1）strncpy，如不够则vs有可能会拿’\0’填补

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

在这里插入图片描述

（2）strncat，如不够则vs有可能不会再凑’\0’填补多余的

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

在这里插入图片描述

注意这个函数可以自己给自己追加的，但是strcat不一定可以自己与自己追加（尽管有些编译器对strcat进行了优化，使得字符串可以自己给自己追加，但是C标准并没有要求strcat必须有自己给自己追加的能力……）

（3）strncmp

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

004、字符串查找

（1）字符串中找字符串strstr

char * strstr ( const char *str1, const char * str2);//找不到返回空指针

（2）字符串找字符（第一次出现的）strchr

const char * strchr ( const char * str, int character );
      char * strchr (       char * str, int character );

（3）字符串找字符（最后一次出现的）strrchr

const char * strrchr ( const char * str, int character );
      char * strrchr (       char * str, int character );

这里使用的是暴力求解，即BF算法。还有一种方法叫KMP算法，这个算法比较高效，比较经典

（4）分割字符串strtok

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

sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记
如果字符串中不存在更多的标记，则返回 NULL 指针

/*写法一*/
#include <stdio.h>
#include <string.h>
int main()
{
    char arr[] = "limou@3434.com";//注意这个地方只能使用数组
    char buf[30] = { 0 };
    strcpy(buf, arr);

    const char*p = "@.";

    char* str = strtok(buf, p);
    printf("%s\n", str);

    str = strtok(NULL, p);
    printf("%s\n", str);

    str = strtok(NULL, p);
    printf("%s\n", str);
    return 0;
}

/*写法二*/
#include <stdio.h>
#include <string.h>
int main()
{
    char arr[] = "limou@3434.com";//注意这个地方只能使用数组
    char buf[30] = { 0 };
    strcpy(buf, arr);
    
    const char*p = "@.";
    char* str = NULL;
    for(str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
    {
        printf("%s\n", str);
    }
    return 0;
}

005、错误信息报告strerror

char8 strerror( int errnum );

返回错误码所对应的错误信息

//实际上C语言的库函数在调用失败的时候，会将一个错误码存放在一个叫errno的变量中，当我们想要根据错误码得到具体的错误信息时，就可以将strerror和errno配合使用
//例如下面的代码
#include <stdio.h>
#include <string.h>
#include <errno.h>//必须包含的头文件
int main()
{
    FILE* pf = fopen("某个不存在的文件", "r");
    if(pf == NULL)
    {
        printf("%s\n",  strerror(errno));
    }
    return 0;
}

另外还有另外一个perror函数，更加方便perror的效果==printf+strerror的效果

二、字符分类函数

C语言还提供了大量判断字符为大小写、空白字符、十进制数字字符等有助于字符分类的函数，这些函数比较容易理解，这里就不详细指出（比如iscntrl、isspace、isdigit等函数）

三、内存操作函数

优点是无论是什么类型的数据都可以进行操作

001、内存块拷贝memcpy

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

参数设计：目标，源数据，数据内存大小（单位为字节）
遇到’\0’并不会停下来
返回目标的地址
如果destination和source有任何的重叠，复制的结果都是未定义的

#include <stdio.h>
#include <string.h>
struct 
{
    char name[40];
    int age;
} person, person_copy;

int main ()
{
    char myname[] = "Pierre de Fermat";
    memcpy (person.name, myname, strlen(myname)+1);//补回'\0'这个字符
    person.age = 46;

    memcpy (&person_copy, &person, sizeof(person));
    printf ("person_copy: %s, %d \n", person_copy.name, person_copy.age);
    return 0;
}

002、内存拷贝函数memmove

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

比memcpy更加强大，能解决destination和source的重叠问题

003、内存设置函数memset

void * memset ( void* ptr, int value, size_t num );

参数解释：目标，替换值，
注意是以字节单位为设置的，因此无法给一些数据进行预期的改动（例如int类型的数组）

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[10] = "bcdef";
    memset(arr, 'x', 4);
    printf("%s", arr);
}

004、内存比较函数memcmp

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

四、字符串库函数的模拟实现

001、my_strlen

①计数器

#include <assert.h>
int my_strlen_1(const char* str)
{
    int count = 0;
    assert(str);//防止空指针危险
    while(*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

②递归（适用于不创建变量）

#include <assert.h>
int my_strlen_2(const char* str)
{
    if(*str != '\0')
    {
        return (1 + my_strlen_2(str + 1));
    }
    else
    {
        return 0; 
    }
}

③指针-指针

这个比较简单，直接数组末尾指针和第一个指针相减再加一就行，这里就不写了

002、my_strcpy

#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{
    char* ret = dest;
    assert(dest && src);//保证指针的有效性
    while(*dest++ = *src++);//利用'\0'可以停下
    return ret;
}

003、my_strcat

#include <assert.h>
char* my_strcat_1(char* dest, const char* src)
{
    assert(dest && src);
    char* ret = dest;
    while(*dest != '\0')
    {
        dest++;
    }
    while(*dest++ = *src++);
    return ret;
}
//但是没有办法自己给自己追加，因为'\0'被改了，找到开始覆盖的位置，却遗失了结束的位置，并且陷入死循环当中
//注意，const只是不能改src指向的字符串，但是另外一个指向同一串字符串的指针若是没有const修饰，依旧可以通过改指针修改字符串

004、my_strcmp

int my_strcmp(const char* str1, const char* str2)
{
    assert(str1 && str2);
    while(*str1 == *str2)
    {
        if(*str1 > *str2)
        {
            return 0;
        }
        str1++;
        str2++;
    }
    return *str1 - *str2;
/*
    if(*str1 > *str2)
    {
        return 1;
    }
    else
    {
        return 0;
    }
*/
}

005、my_strstr

/*别人帮我实现的*/
char* my_strstr(const char* str1, const char* str2)
{
    char* s1 = NULL;
    char* s2 = NULL;
    char* cp = (char*)str1;//由于str1被const修饰，所以这里加上强制类型转化可以消除警告

    while(*cp)
    {
        s1 = cp;
        s2 = (char*)str2;//由于str2被const修饰，所以这里加上强制类型转化可以消除警告
        while(*s1 && *s2 && *s1 == *s2)//有一个字符串遇到'\0'都可以不用循环了
        {
            s1++;
            s2++;
        }
        cp++;
        if(*s2 == '\0')
        {
            return cp;
        }
    }
    return NULL;//没找到
}

/*自己实现的*/
char* my_strstr(const char* str1,const char* str2)
{
    assert(str1, str2);//判断是否为空指针
    char* s1 = str1;
    char* s2 = str2;
    while (*str1)
    {
        s1 = str1;
        s2 = str2;
        while (*s1 != *s2)//找到第一处相等的地方
        {
            s1++;
            if (*s1 == '\0')//一直都没找到相等的地方，就返回空指针
            {
                return NULL;
            }
        }
        char* t = s1;//记下这个第一处相等的地方
        while (*s1 == *s2)
        {
            s1++;
            s2++;
            if (*s2 == '\0')//直到s2结束都相等，说明找到了
            {
                return t;
            }
        }
        str1++;
    }
    return NULL;//没找到
}

画图会容易理解一些，可以拿"abbbcdef\0"和"bcd\0"画下图

五、内存操作函数的模拟实现

001、memcpy

#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)//注意void*是不能进行解引用和加减操作的
{
    void* ret;
    assert(dest && src);
    while(num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }
    return ret;
}

002、memmove

这个代码就比较难理解一下，主要是要有分类的意识

void my_memmove(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    if(dest < src)
    {
        while(num--)
        {
            *(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else
    {
        while(num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
    return ret;
}