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'，还是找到的字符cif ( *s == '\0')return NULL;elsereturn (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;        // 失败，返回NULLconst char *tmp_p = s;  // 记住最初的这个字符串的地址(也就是字符串首字符的地址)// 2、先将指针s移动到字符串的末尾while ( *s != '\0'){s++;}// 3、从右往左判断c是否存在while ( (*s != c) &&  ( s != tmp_p)){s--;        }// 3、判断是结束符'\0'，还是找到的字符cif ( s == tmp_p)return NULL;elsereturn (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、没有找到该子串，就返回NULLreturn 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};               // 目标内存1const char str_buf1[128] = "shijienameda";    // 要复制的字符串1char *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};               // 目标内存2const char str_buf2[128] = "shijienameda";    // 要复制的字符串2char *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};               // 目标内存1const char str_buf3[128] = "shijienameda";    // 要复制的字符串1char *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};               // 目标内存2const char str_buf4[128] = "shijienameda";    // 要复制的字符串2char *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)   // 两个字符串的字符都相等，返回0printf("(strcmp)密码输入正确！\n");elseprintf("(strcmp)密码输入错误！\n");// 2、strncmp函数const char password2[128] = "fhq9127";char input_pw2[128]       = "fhq9128";if ( strncmp(password2, input_pw2, 3) == 0)   // 两个字符串的字符都相等，返回0printf("(strcmp)密码输入正确！\n");elseprintf("(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";   // 要拼接的字符串1const char src_buf2[128] = ",zhendejiade";  // 要拼接的字符串2char *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";   // 要拼接的字符串3const char src_buf4[128] = ",zhendejiade";  // 要拼接的字符串4char *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、将上一次返回的指向，赋值给现在的strif (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指针遇到分隔符delimwhile ( (*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，译音八分贝，道友，下期见！