【C语言进阶】最常用的库函数大全——从入门到精通

﹏ヽ暗。殇╰゛Y 2024-03-29 16:16 90阅读 0赞

### **目录** ###

前言：

一.字符串函数

1.strlen——求字符串长度

strlen

2.长度不受限制的字符串函数

a.strcpy——字符串拷贝

strcpy

b.strcat——追加字符串

strcat

c.strcmp——字符串比较

strcmp

3.长度受限制的字符串函数——strncpy,strncat,strncmp

为什么会出现这些函数呢？

strncpy函数：

strncpy

strncat函数

strncat

strncmp函数：

strncmp

4.字符串查找

a.strstr——判断是否为子字符串

strstr

b.strtok——一个奇怪的函数

strtok

c.strerror——错误信息查找

strerror

perror

上面是字符串相关的函数，下面是一些字符分类的函数：

编辑 字符转换函数：

二.内存函数

1.内存拷贝函数

a.memcpy

b.memmove

2.内存填充函数——memset

3.内存比较函数——memcmp

总结：

###  ###

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

> 博客主页：[张栩睿的博客主页][Link 1]
> 
> 欢迎关注：点赞+收藏+留言
> 
> 系列专栏：[c语言学习][c]
> 
>  **家人们写博客真的很花时间的，你们的点赞和关注对我真的很重要，希望各位路过的朋友们能多多点赞并关注我，我会随时互关的，欢迎你们的私信提问，也期待你们的转发！**
> 
>  **希望大家*****关注我，*****你们将会看到更多精彩的内容！！！**

## 前言： ##

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在 常量字符串 中或者 字符数组中。 字符串常量 适用于那些对它不做修改的字符串函数。

**以下的函数都需要引用头文件<string.h>**

## 一.字符串函数 ##

### 1.strlen——求字符串长度 ###

#### [strlen][] ####

**函数原型：**

![bbdbd0d06f2841958686039ea6a1d89a.png][]

**函数作用：**

*  字符串以`'\0'`作为结束标志，`strlen`函数返回值是在**字符串中`'\0'`前面出现的字符个数**（不包含`'\0'`）
 *  参数是一个**字符指针变量**
 *  参数指向的字符串必须要以**`'\0'`**结束，否则计算出的长度是**随机值**
 *  注意函数的返回值为`size_t`，是无符号的

**函数注意事项：**

因为返回值是size\_t，所以就要避免出现下图这样的代码：strlen（“abc”）算出的结果是3， strlen("abcde")算出的结果是5，可能想着3-5得到-2，实际上并不是这样的，这里算出的3和5都是无符号整型，算出的-2也是一个无符号整型，-2在内存中以补码的形式存储，从无符号整型的视角看去，这串补码就表示一个很大的正数。  
![3cb5cd815eb14e0bbdbef478cbcf76ce.png][]

**3种模拟的方法：**

**递归：**

递归
    int my_strlen1(const char* str)
    {
    	assert(str != NULL);
    	if (*str != '\0')
    		return 1 + my_strlen(str + 1);
    	else
    		return 0;
    }

**指针-指针**

指针-指针
    int my_strlen2(const char* str)
    {
    	const char* start = str;
    	assert(str != NULL);
    	while (*str)
    	{
    		str++;
    	}
    	return str - start;

**递推**

int my_strlen(const char* str)
    {
    	assert(str != NULL);
    	int count = 0;
    	while (*str != '\0')
    	{
    		count++;
    		str++;
    	}
    	return count;
    }

## 2.长度不受限制的字符串函数 ##

#### a.strcpy——字符串拷贝 ####

#### [strcpy][] ####

**函数原型:**

![c86d5e0564e54ba99f20232b24c76095.png][]

**函数作用：**

> **字符串拷贝函数，把源字符串拷贝到目标空间**

**注意事项：**

函数有两个参数，source指向待拷贝的字符串，也叫做源字符串。destination是目标空间的地址  
**源字符串必须以’\\0’结束**

目标空间必须足够大，**以确保能存放源字符串**，否则会出现非法访问

**特殊情况：**  
会把源字符串中的 ‘\\0’ 也拷贝到目标空间

![aca1562046ed4c1190a9b64529937d16.png][]  
目标空间必须可变，例如把源字符串拷贝到一个**字符串常量**里面是**不可取的**

![a0ca58aa75064a93a50f142c3ce07594.png][]

**模拟实现：**

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

#### b.strcat——追加字符串 ####

#### [strcat][] ####

**函数原型**：

![c9aa2d5666ed4f14aab39c147f977105.png][]

**函数作用：**

>  **字符串追加函数，将源字符串追加到目标字符串后面，目标中的终止字符’\\0’会被源字符串的第一个字符覆盖**

![79c701bf355448169331e23e454dbaea.png][]

**注意事项：**

函数有两个参数，其中source指向要追加的字符串，也叫做源字符串，destination是目标空间的地址  
目标空间中必须要有'\\0'，作为追加的起始地址  
源字符串中也必须要有'\\0'作为追加的结束标志  
目标空间必须足够大，能容纳下源字符串的内容  
目标空间必须可修改

以上与strcpy类似，但是有一点很特殊：  
**自己给自己追加会陷入死循环！**

同学们先看看模拟实现的代码可以知道，该函数本质是将\\0覆盖了，再最后追加\\0，但是自己改自己会把\\0覆盖不见，最后造成死循环。

**模拟实现：**

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

#### c.strcmp——字符串比较 ####

#### [strcmp][] ####

**函数原型：**

![34538c156e8e4635a51405131553c8d3.png][]

**函数作用：**

> 根据相同位置的ASCII值进行大小的比较。并不是比字符串长度

**注意事项：**

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

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

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

**该函数是按字典序来比较的。**

![3245f9441cd649cabd63c754bd482160.png][]

**模拟实现：**

int my_strcmp(const char* str1, const char* str2)
    {
    	assert(str1 && str2);
    	while (*str1 == *str2)//如果相等就进去，两个指针加加，但是可能会出现两个字符串相等的情况，两个指针都指向'\0'，此时比较就结束了
    	{
    		if (*str1 == '\0')
    		{
    			return 0;
    		}
    		str1++;
    		str2++;
    	}
    	if (*str1 > *str2)
    	{
    		return 1;
    	}
    	else
    	{
    		return -1;
    	}
    }

## 3.长度受限制的字符串函数——strncpy,strncat,strncmp ##

#### 为什么会出现这些函数呢？ ####

>  **前面三个函数压根不关心到底拷贝，追加，比较了几个字符。它们只关心是否找到了\\0，一旦找到了\\0就会停止。这样的话如果目标空间不够大，会造成越界。这些特点就会让人们决定它是不安全的，并且我们之前发现如果自己给自己追加会出现死循环的现象，因为这些缺点，下面介绍较安全的函数。**

### strncpy函数： ###

#### [strncpy][] ####

**函数原型：**

![6b446b4db9a7445482faa61f68abd532.png][]

**函数作用：**

> **长度受限的字符串拷贝**

**注意事项：**

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

**模拟实现：**

char* my_strncpy(char* dest, const char* src, int num)
    {
    	assert(dest && src);
    	char* ret = dest;
    	while (num)
    	{
    		if (*src == '\0')//此时说明src指针已经指向了待拷贝字符串的结束标志'\0'处，src指针就不用再++了
    		{
    			*dest = '\0';
    			dest++;
    		}
    		else
    		{
    			*dest = *src;
    			dest++;
    			src++;
    		}
    		num--;
    	}
    	return ret;
    }

### strncat函数 ###

#### [strncat][] ####

**函数原型：**

![baee1e59e3d24a839ed3bbbf5de0007f.png][]

**注意事项：**

*  从源字符串的第一个字符开始往后数num个字符追加到目标空间的后面，外加一个终止字符。
 *  如果源字符串的长度小于 num，则仅复制终止字符之前的内容。

**模拟实现：**

char* my_strncat(char* dest, const char* src, int sz)
    {
    	assert(dest && src);
    	char* ret = dest;
    	//找目标空间的\0
    	while (*dest != '\0')
    	{
    		dest++;
    	}
    	//追加
    	while (sz)
    	{
    		*dest++ = *src++;
    		sz--;
    	}
    	*dest = '\0';
    	return ret;
    }

### strncmp函数： ###

#### [strncmp][] ####

**函数原型：**

![0ca7daec77a345cd8a4d7a353e545694.png][]

**模拟实现：**

int my_strncmp(const char* str1, const char* str2, int sz)
    {
    	assert(str1 && str2);
    	while (sz)
    	{
    		if (*str1 < *str2)
    		{
    			return -1;
    		}
    		else if (*str1 > *str2)
    		{
    			return 1;
    		}
    		else if(*str1 == '\0'||*str2 =='\0')//当有一个为'\0'，说明比较就可以结束了
    		{
    			if (*str1 == '\0' && *str2 == '\0')//如果二者都是'\0'，说明两个字符串相等
    			{
    				return 0;
    			}
    			else if(*str1 =='\0')//如果str1为'\0'，说明str1小，str2大
    			{
    				return -1;
    			}
    			else//如果src为'\0'，说明str1大，str2小
    			{
    				return 1;
    			}
    		}
    		sz--;
    		str1++;
    		str2++;
    	}
    }

## **4.字符串查找** ##

### a.strstr——判断是否为子字符串 ###

### [strstr][] ###

**函数原型：**

![ba187df421d44b9190357d4c58c5fd3b.png][]

**函数作用：**

> 判断是否为子字符串

![0b485e3399de449f9066cd00deb6babf.png][]

**注意事项：**

*  在str1指向的字符串中查找str2指向的字符串
 *  返回一个**指向str1中第一次出现的str2的指针**
 *  如果 str2 不是 str1 的一部分，则**返回一个空指针NULL**
 *  匹配过程不包括终止空字符，但它到此为止

**BF算法(暴力枚举)模拟函数实现：**

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

**KMP算法模拟实现：**

void Getnext(char* next, char* str2)
    {
    	next[0] = -1;
    	next[1] = 0;
    	int k = 0;
    	int i = 2;
    	while (i <= strlen(str2))
    	{
    		if (str2[k] == str2[i-1])
    			next[i] = k + 1;
    		else if (str2[i] != str2[0])
    			next[k] = 0;
    		else if (str2[i] == str2[0])
    			next[k] = 1;
    		k++;
    		i++;
    	}
    }
    char* KMP(const char* str1, const char* str2)
    {
    	assert(str1 && str2);
    	int* next = (int*)malloc(sizeof(int) * strlen(str2));
    	assert(next);
    	Getnext(next, str2);
    	int i = 0;
    	int j = 0;
    	while (i < strlen(str1) && j < strlen(str2))
    	{
    		if (j==-1||str1[i] == str2[j])
    		{
    			i++;
    			j++;
    		}
    		else
    		{
    			j = next[j];
    		}
    	}
    	free(next);
    	if (i == strlen(str2))
    		return &str1[i - j];
    	return NULL;
    }

关于KMP算法可以通过这两篇博客来了解：

[一篇文章弄懂KMP算法][KMP]

[关于next数组][next]

### b.strtok——一个奇怪的函数 ###

### [strtok][] ###

**函数原型：**

![3d7eb47d9d9d44a8903f8414ddbc3483.png][]

**作用：**

> 通过分隔符分割字符串

**注意事项：**

1.sep参数是个字符串，定义了用作分隔符的字符集合第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

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

这个函数很奇怪，让我举个栗子：

> **用来分割字符串。一个例子，例如我的邮箱是xxxxx@163.com。这个邮箱起始由三部分组成，一个是xxxxxx，一个是163，一个是com。我现在想把这三部分分开。**

![1429f6cebe1943aa9b8af1d9b9e7a41d.png][]

![7892d5e0e2e843d9b8b7dcea1085a9d7.png][]

![87bf1b2fd2f64223875cbc61df443873.png][]

![a955a51990b24dc68b2f8e7e83cb495c.png][]

当然，我们可以用for循环简写：

![e2f3753a7ca44e75a9a85739297c06fe.png][]

该函数模拟较复杂，我们就先不模拟了。

### c.strerror——错误信息查找 ###

### [strerror][] ###

**函数原型：**

![e3e5073451ff4611a20d5080d64d489a.png][]

**作用：**

> **把错误码转换成错误信息**

**注意事项：**

*  C语言的库函数在运行的时候，如果发生错误，就会把错误码存在一个变量中，这个变量是：errno
 *  返回的指针指向静态分配的字符串（错误信息字符串）

**一些栗子：**

![0b092734e9784602a754c314bf367705.png][]

**用法：**

int main()
    {
    	//打开文件
    	FILE* pf = fopen("test.c", "r");
    	if (pf == NULL)
    	{
    		printf("%s\n", strerror(errno));//需要包含头文件#include<errno.h>
    		return 1;
    	}
    	//读文件
    	//关闭文件
    	fclose(pf);
    	return 0;
    }
    //打开失败时屏幕显示：
    No such file or directory

关于这里的errno，C语言的库函数在运行的时候，如果发生错误，就会将错误码存在一个变量中，这个变量是：errno，错误码是一些数字：1 2 3 4 5，我们需要讲错误码翻译成错误消息。

**perror函数：**

### [perror][] ###

**实际上就是printf和strerror的结合！**

![5c63de63789b4404ba28d1db12b0b26a.png][]

### 上面是字符串相关的函数，下面是一些字符分类的函数： ###

### ![e2bf356400734240ae85466b2b147c1e.png][] 字符转换函数： ###

[tolower][]：**将大写字母转换为小写字母**  
int tolower ( int c );  
[toupper][]：**将小写字母转换成大写字母**  
int toupper ( int c );

这些函数我就不一一讲解了，家人们有兴趣的话可以去官网了解一下哦！

## **二.内存函数** ##

上面我们介绍了处理字符串的函数，但是对于其他类型，我们该如何处理呢？通过下面的内存函数的介绍，相信你会有所感悟！

### 1.内存拷贝函数 ###

### a.memcpy ###

**函数原型：**

![87525a160282499c84e7d8b5f80ed144.png][]

**注意事项：**  
 这里的destination指向要在其中赋值内容的目标数组，source指向要复制的数据源，num是要复制的字节数，注意这里前两个指针的的类型还有函数返回值都是void\*，这是因为，memcpy这个函数是内存拷贝函数，它有可能拷贝整型，浮点型，结构体等等各种类型的数据……虽然返回类型是void\*，但他也是必不可少的，void\*也表示一个地址，用户可以把它强制转换成自己需要的类型去使用。

![f4927aacde074e8fb71e310b3ac5e8d6.png][]

![6e4e6791083b4463b67a0339e437b150.png][] **函数的模拟实现：**

void* my_memcpy(void* dest, const void* src, size_t num)
    {
    	void* ret = dest;
    	assert(dest && src);
    	//前->后
    	while (num--)
    	{
    		*(char*)dest = *(char*)src;
    		dest = (char*)dest + 1;
    		src = (char*)src + 1;
    	}
    	return ret;
    }

>  **注意：这里对于(char\*)dest不能++或--，因为虽然强制转化类型，但是他的类型实质是没有改变的。**

**然而，这个函数存在缺陷，就是当对于自己拷贝并且有重叠部分时，会出现bug**

>  **如果我们只在一个字符串里操作就会出现问题。例如我想把arr1里的1，2，3，4，5拷贝到3，4，5，6，7上就，理论上arr1\[\]应该变为1，2，1，2，3，4，5，8，9。**

**但是实际上：**

![fdc89f46dcc94fe980c87db3361a5944.png][]

为了修改这个bug，大佬们又写出了memmove函数！

### b.memmove ###

函数原型和memcpy一样，作用也是一样的，不同的就是可以拷贝自己，并且重叠不会出bug！

为什么之前的模拟实现会出现这个bug呢？

![7942aab0f932499fa73f3144f4ada4f3.png][]

原因是：当1拷贝到3上时，原来的3已经被1替换，当2拷贝到4上的时候，原来的4已将被2替换。所以当拷贝arr\[2\]到arr\[4\]上的时候，原本arr\[2\]里面存放的3已将被1替换了，同理，所以才得出了不符合我们预期的结果。那如何解决这个问题呢？先来分析这个问题产生的原因，这是因为源空间与目标空间之间有重叠，这里的arr\[2\]、arr\[3\]、arr\[4\]既是源空间也是目标空间，当拷贝1和2的时候把源空间中开没有拷贝的3和4就给覆盖了，此时源空间arr\[2\]和arr\[3\]里面存的就不再是3和4了，而是1和2，所以此时拷贝arr\[2\]和arr\[3\]里面的数据，其实拷贝的就是1和2。为了解决这个问题，我们可以从后往前拷贝，此时就不会出现这样的问题

但是，我们从后往前拷贝就可以解决这个问题吗？答案是当然不是，比如：

![97af0ceae6fb40aa949d2468fe45dca6.png][]

所以我们需要分类讨论：

![ab8e08b0a61c499aa0aee0e64049d5d5.png][] **模拟实现：**

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;
    }

## 2.内存填充函数——memset ##

![1f697d34a7214ace80f9383f1f07978e.png][] **函数作用：**

> **内存设置**

**注意事项：**

*  以字节为单位来设置内存中的数据，把从ptr开始往后的num个字节设置成value
 *  形参value也可以是字符，字符其实也是整型，因为字符在内存中存的是其ASCII
 *  value如果是整数的话，需要注意它的取值范围，因为一个字节最大可以存储255，超过255就会发生截断
 *  由于这个函数是一个字节一个字节的改变，所以有些初始化是不成立的，比如对于整形数组初始化为1是不可能实现的，因为每个字节都变成01，一个整形事实上是一个很大的数字。所以对于整形数组初始化，一般都是初始化为0或-1.当然对于字符，不必担心，他本身也是一个字符一个字符改变的！

![0b73730b74c44fe896987081928876a0.png][]

## 3.内存比较函数——memcmp ##

**函数原型：**

![e1ab956f292044bcbaa7e471ab2cc8a2.png][]

**注意事项：**

*  比较从ptr1和ptr2指针开始的num个字节
 *  两个内存块中不匹配的第一个字节在 ptr1 中的值低于 ptr2 中的值返回一个小于零的数子，相等返回零，两个内存块中不匹配的第一个字节在 ptr1 中的值大于在 ptr2 中的值返回一个大于零的数子

## 总结： ##

本文通过函数使用的介绍来初步学习，函数的模拟实现来深刻理解了库函数的使用。辛苦各位小伙伴们动动小手，三连走一波最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！

[Link 1]: https://blog.csdn.net/qq_74310471?spm=1000.2115.3001.5343
[c]: https://blog.csdn.net/qq_74310471/category_12157207.html?spm=1001.2014.3001.5482
[strlen]: https://legacy.cplusplus.com/reference/cstring/strlen/?kw=strlen
[bbdbd0d06f2841958686039ea6a1d89a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/580fdbc327924d44902f04ee19894d54.png
[3cb5cd815eb14e0bbdbef478cbcf76ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/3985f163a6814634a7a190e286f9b305.png
[strcpy]: https://legacy.cplusplus.com/reference/cstring/strcpy/?kw=strcpy
[c86d5e0564e54ba99f20232b24c76095.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/adebb2cf8e4d4ab58edf607beec57eb2.png
[aca1562046ed4c1190a9b64529937d16.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/0f28ab69a822496aa29df44b8ddb3195.png
[a0ca58aa75064a93a50f142c3ce07594.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/2cc25e857b8e4552b5da9838058015c8.png
[strcat]: https://legacy.cplusplus.com/reference/cstring/strcat/?kw=strcat
[c9aa2d5666ed4f14aab39c147f977105.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/e60c1162a132417790521bbca542271e.png
[79c701bf355448169331e23e454dbaea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/586588495894464a9b08aac84ced8919.png
[strcmp]: https://legacy.cplusplus.com/reference/cstring/strcmp/?kw=strcmp
[34538c156e8e4635a51405131553c8d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/0004ba7059c4477891a75877708effcf.png
[3245f9441cd649cabd63c754bd482160.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/359982adc5b8476890f341140be0c8ef.png
[strncpy]: https://legacy.cplusplus.com/reference/cstring/strncpy/?kw=strncpy
[6b446b4db9a7445482faa61f68abd532.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/60e3976079004a64940df798c4077841.png
[strncat]: https://legacy.cplusplus.com/reference/cstring/strncat/?kw=strncat
[baee1e59e3d24a839ed3bbbf5de0007f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/f25ad5082cc345eca265df2900e95476.png
[strncmp]: https://legacy.cplusplus.com/reference/cstring/strncmp/?kw=strncmp
[0ca7daec77a345cd8a4d7a353e545694.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/0feee7f34f5845e3abd4abeceb83b7e8.png
[strstr]: https://legacy.cplusplus.com/reference/cstring/strstr/?kw=strstr
[ba187df421d44b9190357d4c58c5fd3b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/bddac85c64e545348a42c73769df75a8.png
[0b485e3399de449f9066cd00deb6babf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/2c90011bfcbc48cd9d218bc25446d461.png
[KMP]: http://t.csdn.cn/HoQqe
[next]: http://t.csdn.cn/8R6vc
[strtok]: https://legacy.cplusplus.com/reference/cstring/strtok/?kw=strtok
[3d7eb47d9d9d44a8903f8414ddbc3483.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/f92c5cb5038d4163b957c2fd881cd45b.png
[1429f6cebe1943aa9b8af1d9b9e7a41d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c24c279b7aa74f10870964267bff9038.png
[7892d5e0e2e843d9b8b7dcea1085a9d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c6b4f109b9904e9f90fffda74c336fd4.png
[87bf1b2fd2f64223875cbc61df443873.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/49f174a7fa034949b81fd668e6dcc428.png
[a955a51990b24dc68b2f8e7e83cb495c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/a6dcb80683ae493aa8a9e4bb475d2294.png
[e2f3753a7ca44e75a9a85739297c06fe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/17f80eb8274142f7a7ecd65ec33bd8da.png
[strerror]: https://legacy.cplusplus.com/reference/cstring/strerror/?kw=strerror
[e3e5073451ff4611a20d5080d64d489a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/641bac56eee8409dae2f79ec4a9d02b0.png
[0b092734e9784602a754c314bf367705.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/189b6358fbce4b2092e50867bb8be5b8.png
[perror]: https://legacy.cplusplus.com/reference/cstdio/perror/?kw=perror
[5c63de63789b4404ba28d1db12b0b26a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c04ae1d4d0824ed0861a002a44469acc.png
[e2bf356400734240ae85466b2b147c1e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/2605694d827f4700a4f2727c9e51dd79.png
[tolower]: https://legacy.cplusplus.com/reference/cctype/tolower/?kw=tolower
[toupper]: https://legacy.cplusplus.com/reference/cctype/toupper/?kw=toupper
[87525a160282499c84e7d8b5f80ed144.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/60e311de9ea24309b9e61fd5e5bf52a0.png
[f4927aacde074e8fb71e310b3ac5e8d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/892ce732e1a44adb99a2b82979575a6d.png
[6e4e6791083b4463b67a0339e437b150.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/e1aa0b00b5c94d57b2de58fb4a4c1030.png
[fdc89f46dcc94fe980c87db3361a5944.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/f79afe0835944865b8aa4493b56eebb7.png
[7942aab0f932499fa73f3144f4ada4f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/0e971f436cb048a5a3647374d7710570.png
[97af0ceae6fb40aa949d2468fe45dca6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/3dd6006c73af41d5880c424eab869dc1.png
[ab8e08b0a61c499aa0aee0e64049d5d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/40f1fa7f21ea4ce182cf46f32baa237f.png
[1f697d34a7214ace80f9383f1f07978e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/6ad87de36b1542028c2c7084ae76e9ca.png
[0b73730b74c44fe896987081928876a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/b5237bbaa0fb44ca867f9e655afaf4d3.png
[e1ab956f292044bcbaa7e471ab2cc8a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c8c58209405f473caae30932a2762adb.png