C语言修炼——还不会的字符函数和字符串函数给你一次讲明白！

一、字符分类函数

在编程的过程中，我们经常要处理字符和字符串，为了⽅便操作字符和字符串，C语⾔标准库中提供了⼀系列库函数，接下来我们就学习⼀下这些函数。
C语⾔中有⼀系列的函数是专⻔做字符分类的，也就是⼀个字符是属于什么类型的字符的。这些函数的使⽤都需要包含⼀个头⽂件ctype.h。

这些函数的使用方法都是类似的，我们举一例即可：

int islower(int c)；

islower能够判断参数c是否是⼩写字⺟的，但注意我们传参传递的是字符的ASCII
码值。
通过返回值来说明是否是⼩写字⺟，如果是⼩写字⺟就返回⾮0的整数，如果不是⼩写字⺟，则返回0。
练习：

#include <stdio.h>
#include <ctype.h>
int main()
{
	int i = 0;
	char str[] = "Test String.\n";
	char c;
	while (str[i])//当str[i]='\0'时跳出循环
	{
		c = str[i];
		if (islower(c))//如果c不是小写字母，返回值为0.不进入if语句，否则进入
			c -= 32;//小写字母的ASCII码值-32为大写字母的ASCII码值
		putchar(c);//输出字符c
		i++;
	}
	return 0;
}

相比于我们之前的写法：

if (c >= 'a' && c <= 'z')
	c -= 32;

我们多了另外一种显得比较简洁高效的写法。

二、字符转换函数

int tolower(int c);//将参数传进去的大写字母转小写
int toupper(int c);//将参数传进去的小写字母转大写

上⾯的代码，我们将⼩写转⼤写，是-32完成的效果，有了转换函数，就可以直接使⽤tolower函
数。

#include <stdio.h>
#include <ctype.h>
int main()
{
	int i = 0;
	char str[] = "Test String.\n";
	char c;
	while (str[i])
	{
		c = str[i];
		if (islower(c))
			c = toupper(c);
		putchar(c);
		i++;
	}
	return 0;
}

需要注意的是，toupper乃至tolower函数本身都能够对是否是大小写字母进行分辨，所以这里仍进行if语句判断的作用其实是节省内存，提高效率。如果我们不进行逻辑划分，每一个字符的判断都要调用一次toupper函数，使用起来效率可能就没那么高了。

三、strlen的使用和模拟实现

strlen,strcpy,strcat,strcmp这些函数大家或多或少都见过，下面带大家从知道、了解、会用到模仿实现这些函数，还有一些相类似的字符串函数的补充。

size_t strlen(const char* str);

可以看到strlen的返回值是一个无符号整型，参数部分是一个字符指针接收某个地址。

• 字符串以'\0'作为结束标志，strlen函数返回的是在字符串中'\0'前⾯出现的字符个数（不包
  含'\0')
• 参数指向的字符串必须要以'\0'结束
• 注意函数的返回值为size_t，是⽆符号的（易错）
• strlen的使⽤需要包含头⽂件string.h

strlen函数有3种实现方式：计数器，递归和指针运算。
计数器：创建一个临时变量记录遍历字符串的循环次数；
递归：长度为n的字符串可以分解为strlen("123...n")–>1+strlen("123...n-1")…–>n+strlen(" ")，当字符串长度为0时回归；
指针运算：可以创建临时指针变量记录字符串首元素的地址，然后遍历字符串，使该临时指针变量指向字符串尾。

#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{	//计数器⽅式
	int count = 0;
	assert(str);
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{	//递归
	assert(str);
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}

#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{	//指针-指针
	assert(str);
	char* p = str;
	while (*p)
		p++;
	return p - str;
}

四、strcpy,strcat,strcmp

4.1 strcpy的使用和模拟实现

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

• Copies the C string pointed by source into the array pointed by destination, including the
  terminating null character(and stopping at that point).
• 复制source指向的字符串到destination指向的字符串中，包括'\0'
• 源字符串source必须以'\0'结束
• 会将源字符串source中的'\0'拷⻉到⽬标空间destination
• ⽬标空间destination必须⾜够⼤，以确保能存放源字符串source
• ⽬标空间destination必须可修改

char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

先给出这样一条代码，不知道同学们能不能看出其中的妙处所在：

1. 首先是assert断言，当函数被调用时，我们先对两个指针参数进行判断，确保两个指针接收到了有效地址，非常严谨，但也是必须的，我们对于指针的使用必须慎重周全
2. 当我们确保指针指向有效地址后，我们就可以进行字符串复制了。我们当然需要进行循环遍历，但写出优质的高效简洁的代码很关键。while (*dest++ = *src++)，这一条循环语句非常巧妙。首先后置++的优先级是高于解引用操作符*的，所以可以实现把当前地址的src复制给dest再同时地址向后跳的效果，而且我们需要知道=等号赋值表达式的结果是右边表达式的结果，也就是说*dest++ = *src++这个赋值表达式最终的结果是*src++这个表达式的结果。当源字符串遍历到'\0'，会通过赋值表达式复制给目标字符串，这个赋值表达式的结果就是'\0'，当判断条件为0时循环体也就自动结束了。
3. 再是const修饰src，当我们结束函数主要部分以后发现，我们并不需要对源字符串进行任何改变，我们只需要将其复制给目标字符串，所以我们加上const修饰源字符串可以很好的保护我们源字符串的内容不被错误操作改变。
4. 最后是返回值，我们知道strcpy函数的原型的返回值是char*，复制完毕后需要返回目标字符串的地址，但这里我们涉及到了指针变量自增无法得到目标字符串的初始位置了，所以我们额外创建临时指针变量记录初始位置，最后返回这个临时指针变量。

4.2 strcat的使用和模拟实现

• 将源字符串连接至目标字符串之后，目标字符串原本包含的'\0'会被源字符串的第一个字符覆盖，而源字符串的'\0'则会被添加至最终字符串的末尾。需注意两个字符串不能重叠（例如同一个字符串"abcd"，不能dest指向’a’，src指向’c’，'cd’就重叠了），相应地，字符串自己给自己追加也是无法实现的。
• 源字符串必须以'\0'结束。
• ⽬标字符串中也得有\0，否则没办法知道追加从哪⾥开始。
• ⽬标空间必须有⾜够的⼤，能容纳下源字符串的内容。
• ⽬标空间必须可修改。

#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while (*dest)//*dest最终等于'\0'
	{
		dest++;
	}
	while ((*dest++ = *src++))
	{
		;
	}
	return ret;
}

strcat的模拟实现与strcpy大体一致，只需要把strcpy的重点——复制替换为连接即可。怎么连接呢？我们只需要找到目标字符串的'\0'的位置即可，从目标字符串'\0'这个位置开始，将源字符串复制到目标字符串之后，如上。

4.3 strcmp的使用和模拟实现

• 函数从两字符串的第一个字符开始比较，如果两字符相等则继续比较，直到字符不相等或遇见'\0'
• 第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字
• 第⼀个字符串等于第⼆个字符串，则返回0
• 第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字
• 那么如何判断两个字符串？ ⽐较两个字符串中对应位置上字符ASCII码值的⼤⼩。

int my_strcmp(const char* str1, const char* str2)
{
	int ret = 0;
	assert(str1 != NULL);
	assert(str2 != NULL);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

strcmp的模拟实现需要注意，我们应该在两字符串相同位序下字符不同的时候去比较，所以我们可以直接用一个循环结构遍历字符串，直到遇见相异字符或'\0'停止，这样子我们直接返回该位序下两字符的差值即可。

五、strncpy,strncat,strncmp

上面我们学了三个字符串函数strcpy,strcat,strcmp，这三个其实都是长度不受限制的字符串函数，相应地，我们有三个长度受限制的字符串函数strncpy,strncat,strncmp可以实现相同的功能。所谓长度受限制的字符串函数，就是我们使用这些函数时多加了一个参数，去指定这些字符串函数复制、连接或比较时对参与操作的字符串长度作限制。
为什么要有这种区分呢？
其实是因为strcpy,strcat,strcmp的使用是相对不安全的，
例如：

char str1[5] = "ab";
char str2[] = "cdefghi";
strcat(str1, str2);//长度不受限容易造成越界访问，缺少了对于数组容量的检查

所以出于安全的考量，就有了类似的三个字符串函数strncpy,strncat,strncmp，当然这样子也只是相对安全，可却多了一层考虑与检查

5.1 strncpy

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

可以看到strncpy与strcpy的不同之处就是多了一个size_t num的参数，其余没有什么不同，但我们需要注意这几个情况：

char str1[10] = "XXXXXXXXX";
char str2[5] = "abcd";
char str3[6] = "edcba";
strncpy(str1, str2, 3);//结果1：str1 == "abcXXXXXX"
strncpy(str1, str2, 7);//结果2：str1 == "abcd%0%0%0XX"
strncpy(str1, str3, 5);//结果3：str1 == "edcba%0%0XX"

从结果可以知道：

• strncpy函数是严格按照指定的长度来进行复制的，如结果1；
• 指定长度过大时，源字符串长度不够，strncpy就会用'\0'补齐，如结果2。
• 复制过去的三个字符"abc"后不会自动补'\0'，所以我们需要严格设定指定长度，必须考虑并把'\0'也一起复制过去，如结果3；

5.2 strncat

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

• 将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加⼀个\0字符
• 如果source指向的字符串的⻓度⼩于num的时候，只会将字符串中到\0的内容追加到destination指向的字符串末尾

/* strncat example */
#include <stdio.h>
#include <string.h>
int main()
{
	char str1[20];
	char str2[20];
	strcpy(str1, "To be ");
	strcpy(str2, "or not to be");
	strncat(str1, str2, 6);
	printf("%s\n", str1);//结果：To be or not
	return 0;
}

5.3 strncmp

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

⽐较str1和str2的前num个字符，如果相等就继续往后⽐较，最多⽐较num个字⺟，如果提前发现不⼀样，就提前结束，⼤的字符所在的字符串⼤于另外⼀个。如果num个字符都相等，就是相等返回0。

六、strstr的使用和模拟实现

char* strstr(const char* str1, const char* str2);

• 函数返回字符串str2在字符串str1中第⼀次出现的位置
• 字符串的⽐较匹配不包含\0字符，以\0作为结束标志

/* strstr example */
#include <stdio.h>
#include <string.h>
int main()
{
	char str[] = "This is a simple string";
	char* pch;
	pch = strstr(str, "simple");//pch指向"simple string"
	strncpy(pch, "sample", 6);//pch被复制更改为"sample string"
	printf("%s\n", str);//打印字符串str
	return 0;
}

模拟实现：

char* my_strstr(const char* str1, const char* str2)
{
	char* cp = (char*)str1;
	char* s1, * s2;
	if (!*str2)//确保str2指针不为空
		return((char*)str1);
	while (*cp)//遍历字符串str1
	{
		s1 = cp;
		s2 = (char*)str2;
		while (*s1 && *s2 && !(*s1 - *s2))//当s2='\0'时，或*s1，*s2不匹配时退出
			s1++, s2++;
		if (!*s2)//s2='\0'时，匹配成功
			return(cp);
		cp++;
	}
	return(NULL);
}

对于字符串str2，我们想找到它在str1中第一次出现的位置，首先我们肯定不是单单比较一个字符就够的，我们肯定需要遍历字符串str2，确保str2每一个字符都能在str1中找到连续且相等的字符。同时，我们需要先遍历str1，在str1中找到str2的第一个字符才开始比较判断是否匹配。
所以我们不仅需要两个变量指向比较字符，还需要一个变量来记录在str1中能够匹配str2首字符的字符的地址。
例如：
现在有字符串str1[] = "abacadae"和字符串str2[] = "ad"，我们需要找出字符串str2在str1中第一次出现的地址。
str2的第一个字符'a'有4个匹配的位置，我们用char* cp来记录每一次可能匹配与开始比较的位置，同时我们再创建两个变量char* s1, s2，使用s1,s2去比较判断。
每一次开始比较判断，我们都用s1去接收cp记录的可能匹配的位置，而s2接收str2的首地址，通过操作s1,s2不断比较，向后，比较，直至s2 = '\0'可以判断是完全匹配的，否则不匹配。

七、strtok函数的使用

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

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

样例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "192.168.6.111";
	char* sep = ".";
	char* str = NULL;
	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
	{
		printf("%s\n", str);
	}
	return 0;
}

结果：

八、strerror函数的使用

char* strerror(int errnum);

strerror函数可以把参数部分错误码对应的错误信息的字符串地址返回来，我们就可以根据这个地址通过打印等操作得到确切的错误信息，知道出现了什么错误。

在不同的系统和C语⾔标准库的实现中都规定了⼀些错误码，⼀般是放在errno.h这个头⽂件中说明的，C语⾔程序启动的时候就会使⽤⼀个全局的变量errno来记录程序的当前错误码，只不过程序启动的时候errno是0，表⽰没有错误，当我们在使⽤标准库中的函数的时候发⽣了某种错误，就会将对应的错误码，存放在errno中，⽽⼀个错误码的数字只是一个整数，我们很难理解其代表的含义，所以每⼀个错误码都是有对应的错误信息的。strerror函数就可以将错误码对应的错误信息字符串的地址返回。

使用举例：

#include <errno.h>
#include <string.h>
#include <stdio.h>
//我们打印⼀下0~10这些错误码对应的信息
int main()
{
	for (int i = 0; i <= 10; i++)
	{
		printf("%s\n", strerror(i));
	}
	return 0;
}

在Windows11+VS2022环境下的输出结果：

举例：

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
	FILE* pFile;//文件类型指针，简称文件指针，只需关注该操作是为了打开文件
	pFile = fopen("unexist.ent", "r");//以'r'(只读)的模式打开文件名为"unexist.ent"的文件，只需要关注该文件不存在且会导致错误
	if (pFile == NULL)
		printf("Error opening file unexist.ent: %s\n", strerror(errno));//错误打开文件，errno会自动存放对应的错误码，这时我们用strerror获取该错误码对应的错误信息字符串的地址
	return 0;
}

输出：

也可以了解⼀下perror函数，perror函数相当于⼀次完成了错误信息的获取与打印。perror函数打印完参数部分的字符串后，再打印⼀个冒号和⼀个空格，再打印错误信息。

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
	FILE* pFile;
	pFile = fopen("unexist.ent", "r");
	if (pFile == NULL)
		perror("Error opening file unexist.ent");//打印完参数部分的字符串再打印一个冒号和一个空格，再打印错误信息
	return 0;
}