12字符函数

一、函数strchr与strrchr

• 注意：

1. 这两个函数的功能，都是在指定的字符串 s 中，试图找到字符 c。
2. strchr() 从左往右找，strrchr() 从右往左找。
3. 字符串结束标记 ‘\0’ 被认为是字符串的一部分。

• 图解：

• 示例代码：

#include <stdio.h>
#include <string.h>

// 自己写的库
/**
  * @brief  查找字符c在字符串s的位置
  * @note   从左到右来查找这个字符的位置  
  * @param  s：指定要查找的字符串
            c：待查字符
  * @retval 成功：返回指向找到的字符的指针
            失败：返回NULL
  */
char* MyLib_StrLChr(const char *s, int c)
{
    // 1、如果传进来的字符串是空的，那就没有必要继续下面的判断了
    if ( s == NULL)
        return NULL;    // 失败，返回NULL


    // 2、移动指针s获取字符串的字符并与字符c判断是否一致，一致就退出
    while ( (*s != '\0') && (*s != c))
    {
        s++;        // 指针s会一直往字符串的末尾移动(一直到'\0'为止)
    }

    // 3、判断是结束符'\0'，还是找到的字符c
    if ( *s == '\0')
        return NULL;
    else
        return (char *)s;
} 

/**
  * @brief  查找字符c在字符串s的位置
  * @note   从右到左来查找这个字符的位置  
  * @param  s：指定要查找的字符串
            c：待查字符
  * @retval 成功：返回指向找到的字符的指针
            失败：返回NULL
  */
char* MyLib_StrRChr(const char *s, int c)
{
    // 1、如果传进来的字符串是空的，那就没有必要继续下面的判断了
    if ( s == NULL)
        return NULL;        // 失败，返回NULL

    const char *tmp_p = s;  // 记住最初的这个字符串的地址(也就是字符串首字符的地址)

    // 2、先将指针s移动到字符串的末尾
    while ( *s != '\0')
    {
        s++;
    }

    // 3、从右往左判断c是否存在
    while ( (*s != c) &&  ( s != tmp_p))
    {
        s--;        
    }

    // 3、判断是结束符'\0'，还是找到的字符c
    if ( s == tmp_p)
        return NULL;
    else
        return (char *)s;
}
// 主函数
int main(int argc, char const *argv[])
{
    // (1)、官方写的库
    // 1、strchr函数(从左往右找)
    const char *s1 = "shijienameda";
    int c1         = 'i';
    char * p1      = strchr(s1, c1);
    printf("p1 == %s\n", p1);

    // 2、strrchr函数(从右往左找)
    const char *s2 = "shijienameda";
    int c2         = 'i';
    char * p2      = strrchr(s2, c2);
    printf("p2 == %s\n", p2);

    // (2)、自己写的库
    // 1、MyLib_StrChr函数(从左往右找)
    const char *s3 = "shijienameda";
    int c3         = 'i';
    char * p3      = MyLib_StrLChr(s3, c3);
    printf("p3 == %s\n", p3);

    // 2、MyLib_StrRChr函数(从右往左找)
    const char *s4 = "shijienameda";
    int c4         = 'i';
    char * p4      = MyLib_StrRChr(s4, c4);
    printf("p4 == %s\n", p4);

    return 0;
}

二、函数strstr

• 图解：

• 示例代码：

#include <stdio.h>
#include <string.h>

// 自己写的库
/**
  * @brief  在指定的一个字符串中，找到一个子串
  * @note   None    
  * @param  s：指定要查找的字符串
            c：待查字符
  * @retval 成功：返回指向找到的字符的指针
            失败：返回NULL
  */
char* MyLib_StrStr(const char *haystack, const char *needle)
{
    // 初始化
    const char *tmp_p1 = haystack;
    const char *tmp_p2 = needle;

    const char *p1     = haystack;
    const char *p2     = needle;

    // 1、判断输入的两个字符串是否为NULL，为NULL就直接退出
    if ( (haystack == NULL) || (needle == NULL))
    {
        return NULL;
    }

    // 2、遍历haystack字符串，找到所有可能
    while ( *tmp_p1 != '\0')
    {
        // 在进去比较循环之前，将p1和p2的最初的的位置(循环之前)进行保留
        p1 = tmp_p1;
        p2 = tmp_p2;

        // 进入循环依次比较两个字符串的字符是否一致,防止比较的字符串在末尾
        while ( (*p1 == *p2) && (*p1 != '\0') && (*p2 != '\0'))
        {
            p1++;
            p2++;
        }

        if ( *p2 == '\0')           // 判断p2是否指向'\0'，是的话，就意味着找到了s1中的子串s2
        {
            return (char *)tmp_p1;  // 返回s1中的子串的地址
        }

        tmp_p1++;
    }

    // 3、没有找到该子串，就返回NULL
    return NULL;
}

// 主函数
int main(int argc, char const *argv[])
{
 
    // (1)、官方写的库 
    const char *s1 = "chuangqianmingyueguang,yishidishangshuang";
    const char *s2 = "yishi";

    char *p1 = strstr(s1, s2);
    printf("p1 == %s\n", p1);
    
    // (2)、自己写的库 
    const char *s3 = "chuangqianmingyueguang,yishidishangshuang";
    const char *s4 = "yishi";

    char *p2 = MyLib_StrStr(s3, s4);
    printf("p2 == %s\n", p2);
    
    return 0;
}

三、函数strlen

• 图解：

• 示例代码：

#include <stdio.h>
#include <string.h>

// 给类型取个别名
typedef  unsigned long  my_size_t;

// 自己写的库
/**
  * @brief  求一个指定字符串的长度
  * @note   None    
  * @param  s：需要求长度的字符串
  * @retval 成功：返回字符串的长度，不包含字符串结束标记'\0'
            失败：返回0
  */
my_size_t MyLib_StrLen(const char *s)
{
    // 1、如果传进来的字符串是空的，那就没有必要继续下面的判断了
    if ( s == NULL)
        return 0;    // 失败，返回0

    // 2、计算从左到右，一直到'\0'，有多少个字符
    my_size_t cnt = 0;
    while ( *s != '\0')
    {
        cnt++;
        s++;
    }
    
    // 3、返回计算的字符串的长度
    return cnt;
}

// 主函数
int main(int argc, char const *argv[])
{
    // (1)、官方写的库
    const char buf1[256] = "wuaiyousan,riyueyuqing,riweizhao,yueweimu,qingweizhaozhaomumu";
    size_t len1 = strlen(buf1);
    printf("len1 == %lu\n", len1);


    // (2)、自己写的库
    const char buf2[256] = "wuaiyousan,riyueyuqing,riweizhao,yueweimu,qingweizhaozhaomumu";
    size_t len2 = MyLib_StrLen(buf2);
    printf("len2 == %lu\n", len2);
    

    return 0;
}

四、函数strcpy与strncpy

• 注意：

1. 复制src字符串的时候，也会将'\0'，一并复制到dest中
2. 这两个函数的功能，都是将 src 中的字符串，复制到 dest 中。
3. strcpy() 没有边界控制，因此可能会由于 src 的过长而导致内存溢出。
4. strncpy() 有边界控制，最多复制 n+1 个字符（其中最后一个是 ‘\0’ ）到 dest 中。

• 图解：

• 示例代码：

#include <stdio.h>
#include <string.h>

// 自己写的库
/**
  * @brief  复制字符串
  * @note   None    
  * @param  dest：指向目标内存，存储复制的字符串
            src： 指向待复制的字符串
  * @retval 成功：返回一个指针，指向复制后的字符串，等价于dest
            失败：返回NULL
  */
char* MyLib_StrCpy(char *dest, const char *src)
{
    // 1、如果传进来的指针是有误的(比如：NULL)，没有必要继续下面的内容了
    if ( (dest == NULL) || (src == NULL))
    {
        return NULL;
    }

    char *tmp_p = dest;     // 记录dest指针最初指向的地方
    // 2、根据str字符串的结束符'\0'，来进行移位赋值给dest内存
    while ( *src != '\0' )
    {
        *tmp_p = *src;   // 赋值操作，将src内存里面的内容复制到dest内存中
        tmp_p++;
        src++;
    }

    // 3、返回指向dest内存的地址
    return dest; 
}


/**
  * @brief  复制字符串
  * @note   None    
  * @param  dest：指向目标内存，存储复制的字符串
            src： 指向待复制的字符串
            n:    规定最多将src中的n个字符复制到dest内存中
  * @retval 成功：返回一个指针，指向复制后的字符串，等价于dest
            失败：返回NULL
  */
char* MyLib_StrNCpy(char *dest, const char *src, unsigned long n)
{
    // 1、如果传进来的指针是有误的(比如：NULL)，没有必要继续下面的内容了
    if ( (dest == NULL) || (src == NULL))
    {
        return NULL;
    }

    char *tmp_p = dest;     // 记录dest指针最初指向的地方
    // 2、根据n来限定复制src字符串内容给dest内存的范围
    int len  = strlen(src);
    if (n >= len)
    {
        n = len;
    }
    
    while ( n -- )
    {
        *tmp_p = *src;   // 赋值操作，将src内存里面的内容复制到dest内存中
        tmp_p++;
        src++;
    }

    // 3、返回指向dest内存的地址
    return dest; 
}

// 主函数
int main(int argc, char const *argv[])
{
    // (1)、官方写的库
    // 1、strcpy函数
    char      dest_buf1[256] = {0};               // 目标内存1
    const char str_buf1[128] = "shijienameda";    // 要复制的字符串1

    char *p1 = strcpy(dest_buf1, str_buf1);       // 有点危险，没有边界
    printf("dest_buf1 == %s\n", dest_buf1);
    printf("p1        == %s\n", p1);
    
    // 2、strncpy函数
    char      dest_buf2[256] = {0};               // 目标内存2
    const char str_buf2[128] = "shijienameda";    // 要复制的字符串2

    char *p2 = strncpy(dest_buf2, str_buf2, 5);   // 比较安全，可以控制复制的范围
    printf("dest_buf2 == %s\n", dest_buf2);
    printf("p2        == %s\n", p2);

    // (2)、自己写的库
    // 1、MyLib_StrCpy函数
    char      dest_buf3[256] = {0};               // 目标内存1
    const char str_buf3[128] = "shijienameda";    // 要复制的字符串1

    char *p3 = MyLib_StrCpy(dest_buf3, str_buf3); // 有点危险，没有边界
    printf("dest_buf3 == %s\n", dest_buf3);
    printf("p3        == %s\n", p3);
    
    // 2、MyLib_StrNCpy函数
    char      dest_buf4[256] = {0};               // 目标内存2
    const char str_buf4[128] = "shijienameda";    // 要复制的字符串2

    char *p4 = MyLib_StrNCpy(dest_buf4, str_buf4, 5);   // 比较安全，可以控制复制的范围
    printf("dest_buf4 == %s\n", dest_buf4);
    printf("p4        == %s\n", p4);
    return 0;
}

五、函数strcmp与strncmp

• 注意：
  • 比较字符串大小，实际上比较的是字符的 ASCII码值的大小。
  • 从左到右逐个比较两个字符串的每一个字符，当能“决出胜负”时立刻停止比较。
• 图解：

• 示例代码：

#include <stdio.h>
#include <string.h>
// 

// 主函数
int main(int argc, char const *argv[])
{
    // (1)、官方写的库
    // 1、strcmp函数
    const char password1[128] = "fhq9127";
    char input_pw1[128]       = "fhq9127";

    if ( strcmp(password1, input_pw1) == 0)   // 两个字符串的字符都相等，返回0
        printf("(strcmp)密码输入正确！\n");
    else
        printf("(strcmp)密码输入错误！\n");

    // 2、strncmp函数
    const char password2[128] = "fhq9127";
    char input_pw2[128]       = "fhq9128";

    if ( strncmp(password2, input_pw2, 3) == 0)   // 两个字符串的字符都相等，返回0
        printf("(strcmp)密码输入正确！\n");
    else
        printf("(strcmp)密码输入错误！\n");

    

    
    return 0;
}

六、函数strcat与strncat

• 注意：

1. 这两个函数的功能，都是将 src 中的字符串，复制拼接到 dest 的末尾。
2. strcat() 没有边界控制，因此可能会由于 src 的过长而导致内存溢出。
3. strncat() 有边界控制，最多复制 n+1 个字符（其中最后一个是 ‘\0’ ）到 dest 的末尾。

• 图解：

• 示例代码：

#include <stdio.h>
#include <string.h>
// 自己写的库


/**
  * @brief  将两个字符串拼接起来
  * @note   None    
  * @param  dest：指向目标内存，最终存储拼接之后的字符串
            src： 指向需要拼接的字符串，最终将src拼接到dest的后面
  * @retval 成功：返回一个指针，指向拼接后的字符串，等价于dest
            失败：返回NULL
  */
char* MyLib_StrCat(char *dest, const char *src)
{
    char *p1       = dest;
    const char *p2 = src;

    // 1、如果传进来的指针是有误的(比如：NULL)，没有必要继续下面的内容了
    if ( (dest == NULL) || (src == NULL))
    {
        return NULL;
    }

    // 2、将指针p1移动到字符串末尾(这个'\0'符号的位置)
    while ( *p1 != '\0')
    {
        p1++;
    }

    // 3、将src字符串的字符，复制到dest中
    while ( *p2 != '\0')
    {
        *p1 = *p2;
        p1++;
        p2++;
    }

    // 4、补回一个'\0'字符给dest字符串
    *p1 = '\0';

    // 5、返回dest最初指向的内存位置
    return dest;
}

/**
  * @brief  将两个字符串拼接起来
  * @note   None    
  * @param  dest：指向目标内存，最终存储拼接之后的字符串
            src： 指向需要拼接的字符串，最终将src拼接到dest的后面
            n：   规定最多将src中的n个字节拼接到dest的后面
  * @retval 成功：返回一个指针，指向拼接后的字符串，等价于dest
            失败：返回NULL
  */
char* MyLib_StrNCat(char *dest, const char *src, unsigned long int n)
{
    char *p1       = dest;
    const char *p2 = src;

    // 1、如果传进来的指针是有误的(比如：NULL)，没有必要继续下面的内容了
    if ( (dest == NULL) || (src == NULL) || (n<=0)) 
    {
        return NULL;
    }

    // 2、将指针p1移动到字符串末尾(这个'\0'符号的位置)
    while ( *p1 != '\0')
    {
        p1++;
    }

    // 3、将src字符串的字符，复制到dest中
    while ( (*p2 != '\0') && (n--))
    {
        *p1 = *p2;
        p1++;
        p2++;
    }

    // 4、补回一个'\0'字符给dest字符串
    *p1 = '\0';

    // 5、返回dest最初指向的内存位置
    return dest;
    
}

// 主函数
int main(int argc, char const *argv[])
{
    // (1)、官方写的库
    // 1、strcat函数
    char dest_buf[256]       = "qingge";        // 目标字符串
    const char src_buf1[128] = ",nihaoshuai";   // 要拼接的字符串1
    const char src_buf2[128] = ",zhendejiade";  // 要拼接的字符串2

    char *p1 = strcat(dest_buf, src_buf1);
    printf("p1 == %s\n", p1);
    
    // 2、strncat函数
    char *p2 = strncat(dest_buf, src_buf2, 7);
    printf("p2 == %s\n", p2);
    

    // (2)、自己写的库
    // 1、MyLib_StrCat函数
    char dest_buf1[256]       = "qingge";       // 目标字符串
    const char src_buf3[128] = ",nihaoshuai";   // 要拼接的字符串3
    const char src_buf4[128] = ",zhendejiade";  // 要拼接的字符串4

    char *p3 = strcat(dest_buf1, src_buf3);
    printf("p3 == %s\n", p3);
    
    // 2、MyLib_StrNCat函数
    char *p4 = MyLib_StrNCat(dest_buf1, src_buf4, 7);
    printf("p4 == %s\n", p4);

    return 0;
}

七、函数strtok

• 注意：

1. 该函数会将改变原始字符串 str，使其所包含的所有分隔符变成结束标记 ‘\0’ 。
2. 由于该函数需要更改字符串 str，因此 str 指向的内存必须是可写的。
3. 首次调用时 str 指向原始字符串，此后每次调用 str 用 NULL 代替。

• 图解：

• 示例代码：

#include <stdio.h>
#include <string.h>
/**
  * @brief  将某个字符串，按照指定的分隔符拆解为子串
  * @note   None    
  * @param  str： 指定要拆解的字符串
            delim： 分隔符，此处可以指定多个分隔符，形成一个分隔符串
  * @retval 成功：指向子串的指针
            失败：返回NULL，代表拆解完毕    
  */
char* MyLib_StrTok(char *str, const char *delim)
{
    static  char  *last_str_p = NULL;        // 记住上一次调用函数时使用 last_str_p的地方；
            char  *p1         = str;
            char  *p2         = NULL;

    // 1、将上一次返回的指向，赋值给现在的str
    if (p1 == NULL)
    {
        p1 = last_str_p;
    }

    // 2、判断输入的两个字符串是否为NULL，是的话就直接退出
    if ( (p1 == NULL) || (delim == NULL))
    {
        return NULL;
    }

    // 3、退出函数的准备
    // 判断p1是否指向了字符串的末尾，是的话退出此函数
    if (*p1 == '\0')
    {
        return NULL;
    }

    // 4、将str的值给p2，记录p1现在的位置
    p2 = p1;

    // 5、移动p1的位置，直到字符串结束，或者p1指针遇到分隔符delim
    while ( (*p1 != '\0') && (*p1 != *delim))
    {
        p1++;
    }

    // 6、将分隔符设置为'\0'，方便字符串获取
    if (*p1 != '\0')
    {
        *p1 = '\0';
        last_str_p = p1+1;  // 将位置移动下一次要分隔的字符串的首字符上
    }
    else
    {
        last_str_p = p1;    // 字符串分割到末尾了，让其指向字符串末尾的'\0',方便下一次进行判断
    }
    
    return p2;
    
}


// 主函数
int main(int argc, char const *argv[])
{
    // (1)、官方写的库
    char dest_buf[256] = "www.yueqian.com.cn";  // 目标字符串，必须是可写内存
    
    char *p1 = strtok(dest_buf, ".");           // 这里的分隔符(准确来说应该是分隔符串)，是字符串，但是一般情况下以字符形式来切割
    while ( p1 != NULL)
    {
        printf("p1 == %s\n", p1);               // 不是说一定要用printf函数来表示，而是代表现在这个p1代表的子串，现在正在被我所用
        p1 = strtok(NULL, ".");
    }


    // (2)、自己写的库
    char dest_buf1[256] = "www.yueqian.com.cn";  // 目标字符串，必须是可写内存

    char *p2 = MyLib_StrTok(dest_buf1, ".");           // 这里的分隔符(准确来说应该是分隔符串)，是字符串，但是一般情况下以字符形式来切割
    while ( p2 != NULL)
    {
        printf("p2 == %s\n", p2);                // 不是说一定要用printf函数来表示，而是代表现在这个p1代表的子串，现在正在被我所用
        p2 = MyLib_StrTok(NULL, ".");
    }
    
        
    return 0;
}

至此，希望看完这篇文章的你有所收获，我是Bardb，译音八分贝，道友，下期见！