【C进阶】字符串函数

待我称王封你为后i 2023-10-16 16:36 21阅读 0赞

C语言中对字符和字符串的处理很频繁，但是C语言本身是没有字符串类型的，字符串通常放在**常量字符串**中或者**字符数组**中

字符串常量适用于那些对它不做修改的字符串函数

本章重点介绍处理字符串函数的库函数的使用和注意事项

--------------------

### 一、字符串函数 ###

这些函数都要引头文件：**\#include<string.h>**

#### 1.1 strlen ####

> **size\_t strlen（const char \*str)**

（1）库函数，是用来求字符串长度的，本质上统计的是字**符串中\\0之前**的字符的个数（不包括’\\0‘）

（2）参数指向的字符串（传地址）必须要以 '\\0' 结束

（3）注意函数的返回值为size\_t，是**无符号的**(易错）

--------------------

下面看看这个代码：思考一下结果是什么？

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	const char* str1 = "abcdef";
    	const char* str2 = "bbb";
    	if (strlen(str2) - strlen(str1) > 0)
    	{
    		printf("str2>str1\n");
    	}
    	else
    	{
    		printf("srt1>str2\n");
    	}
    	return 0;
    }

**【答案】：srt2>str1**

**【解释】：两个无符号数相减得到的还是无符号数**，那么一个小的数减去一个大的数还是得不到负数，所以就会打印srt2>str1

**【改进】：将size\_t类型强转为int类型**

**if ((int)strlen(str2) - (int)strlen(str1) > 0)**

--------------------

##### **strlen函数的三种模拟实现：** #####

（1）计数器：

size_t my_strlen(const char* str)
    {
    	int count = 0;
    	while (*str++)
    	{
    		count++;
    	}
    	return count;
    }

（2）递归：

size_t my_strlen(const char* str)
    {
    	if (*str)
    		return my_strlen(str+1) + 1;
    	else
    		return 0;
    }

（3）指针-指针

size_t my_strlen(const char* str)
    {
    	char* p = str;
    	while (*p)
    	{
    		p++;
    	}
    	return p - str;
    }

--------------------

#### 1.2 strcpy ####

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

把 **source**所指向的字符串复制到 **destination**，而且会**覆盖destination中的字符****（字符串拷贝）**

（1） 源字符串必须以 '\\0' 结束

（2）会将**源字符串中的 '\\0' 拷贝**到目标空间（不然找不到‘\\0'没法结束，就可能会导致数组越界）

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

（4）**目标空间必须可变**

（5）返回值是目标空间的地址（参数前面是目标字符串的地址，后面是源头字符串的地址）

--------------------

验证strcpy会将源字符串中的'\\0'拷贝到目标空间：

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	char arr1[20] = "WORLDGOOD";
    	char arr2[] = "HELLO";
    
    	strcpy(arr1, arr2);
    	printf("%s\n", arr1);
    
    	return 0;
    }

未strcpy前的arr1：

![36671256f5bc4544a441cd28df69f48b.png][]strcpy后的arr1： 可以看到下标为5的元素就是'\\0'![ca61bbb1ff784f1aacf1bded46e03c78.png][]

--------------------

当目标空间为常量字符串时，不满足条件（4），那么就会出现错误：

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	char* p = "abcdefghi";//常量字符串
    	char arr2[] = "HELLO";
    
    	strcpy(p, arr2);//err
    	printf("%s\n", p);
    
    	return 0;
    }

--------------------

##### strcpy函数的模拟实现： #####

#include<assert.h>
    char* my_strcpy(char* dest, const char* src)
    {
    	char* ret = dest;
    	assert(dest && src);//防止dest和src是空指针
    
    	while (*dest++ = *src++)
    	{
    		;
    	}
    	return ret;
    }

--------------------

#### 1.3 strcat ####

> **char \* strcat（char \* destination ，const char \* source）**

把 **source**所指向的字符串追加到 **destination**所指向的字符串的结尾**（字符串追加）**

> **内部逻辑：**
> 
> <1>找到destination的末尾'\\0'
> 
> <2>再把source的内容追加到destination的后面，会把前面字符串的’\\0'覆盖

（1）**源字符串必须以'\\0'**结束（’\\0'也会追加过去）

（2）目标空间必须**足够大**，而且必须**可以修改**

（3）**目标字符串中也得有’\\0'**，保证可以找到目标空间的末尾进行追加

（4）字符串不能自己给自己追加：这样会进入死循环，前面的'**\\0'被覆盖**了，没有’\\0'无法结束

--------------------

#####  **strcpy函数的模拟实现：**  #####

> <1>找到目标空间的末尾
> 
> <2>数据的追加(跟strcpy函数一样）

char* my_strcat(char* dest,const char* src)
    {
    	char* ret = dest;
    	assert(dest && src);
    	//1.找到目标空间的末尾
    	while (*dest != '\0')
    	{
    		dest++;
    	}
    	//2.数据的追加(跟strcpy函数一样）
    	while (*dest++ = *src++)
    	{
    		;
    	}
    	return ret;
    }

--------------------

#### 1.4 strcmp ####

> **int strcmp （const char \* str1,const char \*str2)**

（string compare）字符串比较函数

（1）不是比较长度，而是**比较对应位置字符的大小（也就是ACSII值）**

> eg： str1=”abcdef“ str2=“abq"
> 
> 在这个两个字符串前面两个字符都一样，但是到第三个字符位置上，str1是c，str2是q，q的ACSII值大于c，那么最后str1<str2

（2）标准规定：

> str1>str2，则返回大于0的数
> 
> str1<str2,则返回小于0的数
> 
> str1和str2相等，则返回等于0的数

在VS中返回值就是-1，0，1，但是其他编译器就不一定

--------------------

#####  **strcmp函数的模拟实现：**  #####

**（1)初阶版：**

#include<assert.h>
    int my_strcmp(const char* str1, const char* str2)
    {
    	assert(str1 && str2);
    
    	while (*str1==*str2)
    	{
    		if (*str1 == '\0')
    			return 0;
    		str1++;
    		str2++;
    	}
    	if (*str1 > *str2)
    	{
    		return 1;
    	}
    	else
    	{
    		return -1;
    	}
    	
    }

**(2) 进阶版：这样简化了很多，而且返回值不只是1或者-1**

#include<assert.h>
    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;
    }

--------------------

上面介绍的都是长度不受限制的字符串函数（strcpy，strcat，strcmp）

下面再来学习一下长度受限制的字符串函数：（strncpy，strncat，strncmp）

#### 2.1 strncpy ####

> **char \* strncpy（char \* destination,const char \*source,size\_t num)**

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

（1）如果**源字符串的长度小于num**，则拷贝完源字符串之后，在**目标空间的后面追加’\\0',直到num个**

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	char arr1[20] = "XXXXXXXXXXXXX";
    	char arr2[] = "abc";
    	strncpy(arr1, arr2, 6);
    	printf("%s\n", arr1);
    	return 0;
    }

我们可以看到arr2只有四个元素，但是要传6个字符，那么就自动在后面补上’\\0'，直到补到num个为止(这里printf打印arr1时，后面的XXXX是不会打印的，因为**字符串遇到‘\\0'就结束了**，就不会再向后走了）

![1dfaa30ce3f947428f351dcaa872a135.png][]

--------------------

#### 2.2 strncat ####

> **char \* strncat(char \* destination,const char \*source,size\_t num)**

如果num大于源字符串的长度，只会**追加源字符串的长度**

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	char arr1[20] = "abc\0xxxxxxxxxxxxx";  //一定要有\0,不然找不到字符串的末尾
    	char arr2[] = "defghi";
    	strncat(arr1, arr2, 10);
    	printf("%s\n", arr1);
    
    	return 0;
    }

--------------------

#### 2.3 strncmp ####

> **int strncmp(const char \* str1, const char \*str2)**

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

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	char arr1[] = "abczef";
    	char arr2[] = "abcqw";
    
    	int ret = strncmp(arr1, arr2, 4);
    	printf("%d\n", ret);
    	return 0;
    }

--------------------

#### 3.1 strstr ####

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

string string 在字符串中找字符串

（1）strstr会返回str1中str2**第一次出现的位置**（多次出现只会返回第一次出现的地址）

如果str1中**没有**str2，**就返回NULL**

eg：代码结果：defghi

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	char arr1[] = "abcdefghi";
    	char arr2[] = "def";
    	char* ret = strstr(arr1, arr2);
    	if (ret == NULL)
    	{
    		printf("找不到\n");
    	}
    	else
    	{
    		printf("%s\n", ret);
    	}
    	return 0;
    }

#####  **strstr函数的模拟实现：** #####

（1）得有一个指针（cp）记录从哪开始str1和str2相匹配了

（2）对于str1="abbbcdef\\0" str2="bbc\\0”就没有那么简单了（当str1指向第三个b时，发现str2对应的不是b而是c，那么有得重新开始，所以还得有个指针指向str2的头部得以返回）

我们就考虑再加两个指针s1和s2分别去遍历str1和str2，str1和str2就指向这两个字符串的头部

![35086c66033d4a728f1b7eb0f8a0dcb1.png][]

#include<stdio.h>
    #include<assert.h>
    const char *my_strstr(const char* str1, const char* str2)
    {
    	const char* cp=str1;//记录开始匹配的位置
    	const char* s1 ;
    	const char* s2 ;//分别去遍历字符串
    
    	assert(str1 && str2);
    
    	if (*str2 == '\0')
    		return str1;//空字符串是所有字符串的子字符串
    
    	while (*cp)//如果str1是空字符就是直接跳出循环
    	{
    		s1 = cp;//重新开始s1就得从cp开始
    		s2 = str2;//s2从str2开始
    		while (*s1&&*s2&& *s1 == *s2)//s1和s2不相等或者都为0就停下来
    		{
    			s1++;
    			s2++;
    		}
    		if (*s2 == '\0')
    			return cp;
    		cp++;//s1和s2不相等就cp向后走一个位置
    	}
    	return NULL;//找不到返回空指针
    }

这个strstr的模拟实现是一种暴力求解的方式，算法不够高效，有兴趣可以去研究KMP算法

--------------------

#### 3.2 strtok ####

> **char \* strtok （char \*str ，const char \*sep）**

这个函数是用来**切割字符串**的

> eg：shenyu@yeah.net(yeah是域名，.net是后缀）//@和.就切割了字符串
> 
> 192.168.101.23 //IP地址，点分十进制
> 
> （IP地址本来是一个无符号整数，这个整数不方便记忆，所以将这个整数转化为点分十进制的表示方式）

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

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

（3）strtok函数找到str中的下一个标记，并将其用 \\0 结尾（把这个**标记改为‘\\0'**)，**返回一个指向这个标记的指针（有记忆功能）**（注： strtok函数会改变被操作的字符串，所以在使用strtok函数**切分的字符串一般都是临时拷贝的内容并且可修改）**

（4）strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置**（第一次传参：s = strtok(arr, p)）**

（5）strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记**（后面传参：s = strtok(NULL, p)）**

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

**理解怎么使用：**

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	char arr[] = "shenyu@yeah.net";
    
    	char buf[200] = { 0 };
    	strcpy(buf, arr);//拷贝一份
    
    	char* p = "@.";
    	char* s = strtok(buf, p);
    	printf("%s\n", s);
    
    	s = strtok(NULL, p);
    	printf("%s\n", s);
    
    	s = strtok(NULL, p);
    	printf("%s\n", s);
    
    	return 0;
    }

**代码结果：**

![43b643201b7344a283aee881f7ff3a23.png][]

奇葩的函数：第一次调用和后面的调用传递的参数不一样

**真正使用strtok函数的代码：这个代码的结果和上面一样，for直接打印所有分割的字符**

#include<stdio.h>
    #include<string.h>
    int main()
    {
    	char arr[] = "shenyu@yeah.net";
    
    	char buf[200] = { 0 };
    	strcpy(buf, arr);//拷贝一份
    
    	char* p = "@.";
    	char* s = NULL;
    
    	for (s = strtok(arr, p); s != NULL; s = strtok(NULL, p))
    	{
    		printf("%s\n", s);
    	}
    
    	return 0;
    }

--------------------

#### 3.3 strerror ####

> **char \* strerror (int errnum)**

**将错误码翻译错误信息，返回错误信息的字符串的起始地址**

当使用库函数或者进行整个的软件设计的过程中，可能会有错误码 eg：404

C语言中使用库函数的时候，如果**发生错误**，就会**将错误码放在errno的变量中**

errno是一个全局的变量，可以直接使用的 eg：0，1，2，3，4，5...

下面我们来看看错误码对应的错误信息:

#include<stdio.h>
    int main()
    {
    	for (int i = 0; i < 10; i++)
    	{
    		printf("%d: %s\n", i, strerror(i));
    	}
    	return 0;
    }

结果如下：

![5bd16b0cbc1e46358fe26636b455ea5b.png][]

再来个打开文件的例子：

> fopen以读的形式打开文件  
> 如果文件存在，打开成功  
> 如果文件不存在，打开失败

用errno变量要引头文件：**\#include<errno.h>**

#include<stdio.h>
    #include<errno.h>
    #include<string.h>
    int main()
    {
    	FILE *pf=fopen("add.txt", "r");
    	if (pf == NULL)
    	{
    		printf("打开文件失败，原因是：%s\n", strerror(errno));
            return 1;
    	}
    	else
    	{
    		printf("打开文件成功\n");
    	}
    	return 0;
    }

拓展：**perror函数**：直接打印错误所对应的错误信息

相当于printf+strerror（打印规则：自定义信息+xxxxx）

#include<stdio.h>
    int main()
    {
    	FILE *pf=fopen("add.txt", "r");
    	if (pf == NULL)
    	{
    		perror("打开文件失败");
    	}
    	else
    	{
    		printf("打开文件成功\n");
    	}
    	return 0;
    }

![a2fb10fb9f614a8e8dff7363621753f9.png][]

--------------------

### 二、字符分类函数： ###

这些函数都需要引头文件：**\#include <ctype.h>**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td><strong>函数</strong></td> 
   <td><strong>如果他的参数符合以下条件就返回真</strong></td> 
  </tr> 
  <tr> 
   <td>iscntrl</td> 
   <td>任何控制字符</td> 
  </tr> 
  <tr> 
   <td>isspace</td> 
   <td> <p>空白字符：空格’ ‘，换页’\f',换行‘\n'，回车’\r',制表符‘\t'或者垂直制表符’\v'</p> </td> 
  </tr> 
  <tr> 
   <td>isdigit</td> 
   <td>十进制数字0~9</td> 
  </tr> 
  <tr> 
   <td>isxdigit</td> 
   <td>十六进制数字，包括所以十进制数字，小写字母a~f，大写字母A~F</td> 
  </tr> 
  <tr> 
   <td>islower</td> 
   <td>小写字母a~z</td> 
  </tr> 
  <tr> 
   <td>isupper</td> 
   <td>大写字母A~Z</td> 
  </tr> 
  <tr> 
   <td>isalpha</td> 
   <td>字母a~z或A~Z</td> 
  </tr> 
  <tr> 
   <td>isalnum</td> 
   <td>字母或者数字，a~z,A~Z,0~9</td> 
  </tr> 
  <tr> 
   <td> <p>ispunct</p> </td> 
   <td>标点符号，任何不属于数字或者字母的图形字符（可打印）</td> 
  </tr> 
  <tr> 
   <td>isgraph</td> 
   <td>任何图形字符</td> 
  </tr> 
  <tr> 
   <td>isprint</td> 
   <td>任何可打印字符，包括图形字符和空白字符</td> 
  </tr> 
 </tbody> 
</table>

eg1：判断一个字符是否是小写字母 **（**  **int islower （int c） ）**

#include<stdio.h>
    int main()
    {
    	char ch = 'w';
    	if (islower(ch))
    	{
    		printf("小写\n");
    	}
    	else
    	{
    		printf("非小写\n");
    	}
    	return 0;
    }

eg2：判断一个字符是不是十六进制数字

#include<stdio.h>
    int main()
    {
    	int ret = isxdigit('q');
    	printf("%d\n", ret);
    
    	return 0;
    }

--------------------

### 三、字符转换函数 ###

这些函数都需要引头文件：**\#include <ctype.h>**

> **int tolower（int c）；**
> 
> **int toupper（int c）；**

eg1：大写转小写，小写转大写

#include<stdio.h>
    int main()
    {
    	int ret = tolower('a');
    	printf("%c\n", ret);//A
    
    	ret = tolower(ret);
    	printf("%c\n", ret);//a
    	return 0;
    }

eg2：字符串大写字母全部转为小写

#include<stdio.h>
    int main()
    {
    	char arr[] = "Test String.\n";
    	char* p = arr;
    	while (*p)
    	{
    		if (isupper(*p))
    		{
    			*p = tolower(*p);
    		}
    		p++;
    	}
    	printf("%s", arr);
    	return 0;
    }

--------------------

本次内容就到此啦，欢迎评论区或者私信交流，觉得笔者写的还可以，或者自己有些许收获的，麻烦铁汁们动动小手，给俺来个一键三连，万分感谢 !

![3f281409025f47c38ec0b9f7333946b3.jpeg][]

[36671256f5bc4544a441cd28df69f48b.png]: https://img-blog.csdnimg.cn/36671256f5bc4544a441cd28df69f48b.png
[ca61bbb1ff784f1aacf1bded46e03c78.png]: https://img-blog.csdnimg.cn/ca61bbb1ff784f1aacf1bded46e03c78.png
[1dfaa30ce3f947428f351dcaa872a135.png]: https://img-blog.csdnimg.cn/1dfaa30ce3f947428f351dcaa872a135.png
[35086c66033d4a728f1b7eb0f8a0dcb1.png]: https://img-blog.csdnimg.cn/35086c66033d4a728f1b7eb0f8a0dcb1.png
[43b643201b7344a283aee881f7ff3a23.png]: https://img-blog.csdnimg.cn/43b643201b7344a283aee881f7ff3a23.png
[5bd16b0cbc1e46358fe26636b455ea5b.png]: https://img-blog.csdnimg.cn/5bd16b0cbc1e46358fe26636b455ea5b.png
[a2fb10fb9f614a8e8dff7363621753f9.png]: https://img-blog.csdnimg.cn/a2fb10fb9f614a8e8dff7363621753f9.png
[3f281409025f47c38ec0b9f7333946b3.jpeg]: https://img-blog.csdnimg.cn/3f281409025f47c38ec0b9f7333946b3.jpeg