十六、字符函数和字符串函数

为了方便操作字符和字符串，C语言标准库中提供了一系列库函数。

1 字符分类函数

C语言中有一系列的函数专门用来字符分类，也就是判断一个字符是属于什么类型的字符的函数。

这些函数的使用都需要包含一个头文件：<ctype.h>

这些函数的使用方法非常类似，这里仅举一例：

int islower ( int c );

islower函数能够判断参数部分的c是否是小写字母。

islower通过返回值来说明是否是小写字母，如果是小写字母就返回非0的整数，否则返回0.

例：写一个代码，实现字符串中的小写字母转大写，而其他字符不变。

#include <stdio.h>
#include <ctype.h>
#include <string.h>
int main()
{
	char str[] = "I am a stduent.";
	size_t len = strlen(str);
	for (size_t = 0; i < len; i++)//遍历字符串
	{
		if (islower(str[i]))
		{
			str[i] = str[i] - 32;//发现小写字母，转大写
		}
	}
	printf("%s\n", str);
	return 0;
}

输出结果：

2 字符转换函数

C语言提供了两个字符转换函数：

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

刚才的代码，我们使用-32完成小写转大写的效果，有了转换函数就可以直接使用toupper函数。

if (islower(str[i]))
{
	str[i] = toupper(str[i]);//发现小写字母，转大写
}

3 strlen的使用和模拟实现

//strlen函数的声明
size_t strlen ( const char * str );

前面我们已经使用过strlen函数，细节便不再赘述，这里我们只讲一下使用要点：

1. 字符串以'\0'作为结束标志，strlen函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0'）。
2. 参数指向的字符串必须要以'\0'结束。
3. 函数的返回值是size_t，是无符号的。
4. 使用strlen函数需要包含头文件<string.h>。

例：

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

输出结果：

上面的例子中，str1的字符串长度大于str2的字符串长度，那么strlen(str2) - strlen(str1) > 0应该为假进而输出的结果应该是srt1>str2，可事实却并不是这样。虽然strlen(str2) - strlen(str1)的结果小于0，但是由于strlen函数的返回值是无符号整型，所以程序就认为其运算的结果也是一个无符号整型，进而也被看成了一个大于0的数。如果将strlen(str2) - strlen(str1)强制转换为整型后，结果就正常了。

下面我们来模拟实现strlen函数。

方法一：

//计数器方式
size_t my_strlen(const char* str)
{
	int count = 0;
	assert(str != NULL);
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

方法二：

//指针-指针方式
size_t my_strlen(const char* str)
{
	const char* start = str;	
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}

方法三：

//递归法——不创建临时变量
size_t my_strlen(const char* str)
{
	assert(str != NULL);
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}

4 strcpy的使用和模拟实现

//strcpy函数的声明
char* strcpy(char * destination, const char * source );

strcpy函数能将source指向的源字符串复制到destination指向的数组中，包括\0.

使用要点：

1. 源字符串必须以\0结束。
2. 目标空间必须足够大，以确保能存放源字符串。
3. 目标空间必须可修改。

例：

#include <stdio.h>
#include <ctype.h>
int main()
{
	char arr1[] = "hello world";
	char arr2[4] = "xxx";
	strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

输出结果：

上面的例子中，虽然输出的结果没有问题，但是由于目标空间arr2的大小不足以存放arr1，所以运行程序的时候编译器会弹出警告。

例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = { 'a','b','c' };
	char arr2[4] = "xxx";
	strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

输出结果：

上面的例子中，虽然目标空间能够存放arr1的内容，但是由于arr1中没有\0，而strcpy函数会一直复制到出现\0的时候才停止，这就会导致strcpy函数越界访问，进而导致复制出错。

例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = { 'a','b','c','\0' };
	char arr2[4] = "xxx";
	strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

当我们在arr1中再添加一个\0后，可以看到输出结果就正常了。

例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = { 'a','b','c','\0' };
	const char* p = "xxxxxxxxx";
	strcpy(p, arr1);
	printf("%s", p);
	return 0;
}

输出结果：

上面的例子中，由于p指向的是一个常量字符串，是不可以被修改的，所以无法将arr1中的内容复制到p所指向的数组中去。

注意：这里不是因为加了const所以不能修改，而是因为p指向的字符串就是不能修改的。

下面我们来模拟实现strcpy函数。

方法一：

void my_strcpy(char* dest, char* src)
{
	while (*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	//拷贝'\0'
	*dest = *src;
}

上面的方法虽然能够实现strcpy函数的基本功能，但我们希望src指向的空间不会被改变，所以可以在声明的地方用const对src进行修饰，除此之外，如果我们能够让函数返回目标空间的起始地址，这样我们就能以printf("%s", my_strcpy(arr2, arr1))的形式直接输出复制后的结果，要实现这样的效果我们就需要把函数的返回值类型设为char*类型，并在函数体中定义一个char*变量来存储目标空间的起始地址，等复制操作结束后再返回。

方法二：

char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest++ = *src++)//复制字符串
	{
		;
	}
	return ret;//返回目标空间起始地址
}

上面的代码中，*dest++ = *src++如果单独放到函数体中还好理解，无非就是先进赋值操作然后各自的地址加一进而进行下一次的复制，但while (*dest++ = *src++)是怎么判断循环是否继续的呢？这里就利用到了赋值表达式的返回值就是=右边的值的特点，当src所指向的空间不是\0时，赋值后返回的值自然就是一个非零的值，判断为真，循环便可以继续进行。当src所指向的空间为\0时，由于因为char类型占1个字节也就是8个比特，而\0在二进制形式下8个比特位全为0，程序会将其视为逻辑值false，故当*dest接收到的字符为\0时，赋值表达式返回的值为0，于是循环不再进行。

5 strcat的使用和模拟实现

//strcat函数的声明
char* strcat(char* destination, const char* source);

strcat函数能将源字符串的副本附加到目标字符串的末尾，其中目标字符串末尾的\0会被源字符串的第一个字符覆盖，而在新字符串的末尾添加新的\0。

使用要点：

1. 源字符串必须以\0结束，否则没办法知道追加到什么时候结束。
2. 目标字符串中必须也有\0，否则没办法知道追加从哪开始。
3. 目标空间必须足够大。
4. 目标空间必须可修改。

例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[20] = "hello ";
	char* p = "world";
	strcat(arr1, p);
	printf("%s\n", arr1);
	return 0;
}

输出结果：

可以看到，p所指向的字符串成功追加到了arr1的后面。那么，如果arr1自己给自己追加呢？

int main()
{
	char arr1[20] = "hello ";
	char* p = "world";
	printf("%s\n", strcat(arr1, arr1));
	return 0;
}

输出结果：

从输出结果可以看到，程序崩了。这是因为strcat函数在实现追加字符串的时候，会先找到目标空间中的\0，找到之后，会从这个位置开始追加字符串，而由于我们追加的字符串是arr1本身，\0被覆盖后arr1中将不再有\0，也就意味着strcat函数不知道追加到什么时候才结束，导致程序崩溃。

知道了strcat函数如何使用，下面我们对它进行模拟实现。

#include <stdio.h>
#include <string.h>
#include <assert.h>
char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest != '\0')//找到目标空间中的`\0`
	{
		dest++;
	}
    //拷贝数据
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "hello ";
	char* p = "world";
	printf("%s\n", my_strcat(arr1, p));
	return 0;
}

输出结果：

6 strcmp的使用和模拟实现

strcmp函数能比较两个字符串的大小，从每个字符串的第一个字符开始，如果它们彼此相等，则继续比较下一对，直到字符不同或到达终止字符\0。

标准规定：

1. 第一个字符串大于第二个字符串，则返回大于0的数字。
2. 第一个字符串等于第二个字符串，则返回0。
3. 第一个字符串小于第二个字符串，则返回小于0的数字。

那么如何判断两个字符串？ 实际上是通过比较两个字符串中对应位置上字符ASCII码值的大小来实现的。

例：

#include <stdio.h>
#include <string.h>
int main()
{
	int ret1 = strcmp("abwdef", "abq");//第三个字符，w>q
	int ret2 = strcmp("abq", "abq");//两字符串相等
	int ret3 = strcmp("abcdef", "abq");//第三个字符，c<q
	printf("%d\n", ret1);
	printf("%d\n", ret2);
	printf("%d\n", ret3);
	return 0;
}

输出结果：

知道了strcmp函数如何使用，下面我们对它进行模拟实现。

#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* p1, const char* p2)
{
	assert(p1 && p2);
	while (*p1 == *p2)
	{
		if (*p1 == '\0')
			return 0;
		p1++;
		p2++;
	}
	if (*p1 > *p2)
		return 1;
	else
		return -1;
}
int main()
{
	int ret1 = my_strcmp("abwdef", "abq");
	int ret2 = my_strcmp("abq", "abq");
	int ret3 = my_strcmp("abcdef", "abq");
	printf("%d\n", ret1);
	printf("%d\n", ret2);
	printf("%d\n", ret3);
	return 0;
}

输出结果：

7 strncpy的使用

//strncp函数的声明
char* strncpy(char* destination, const char* source, size_t num);
//第三个参数表示的是拷贝字符的数量，通常是

和strcpy相似，strncpy函数也能将source指向的源字符串复制到destination指向的数组中，包括\0.不同的是strncpy在复制时，如果source 中C字符串的长度小于num，则不够的字符将用\0补充。

例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[10] = "xxxxxxxxxx";
	char arr2[] = "ab";
	strncpy(arr1, arr2, 5);
	printf("%s\n", arr1);
	return 0;
}

输出结果：

调试结果：

8 strncat函数的使用

和strcat相似，strncat函数也能将源字符串的副本附加到目标字符串的末尾，其中目标字符串末尾的\0会被源字符串的第一个字符覆盖，而在新字符串的末尾添加新的\0。不同的是strncat在追加字符时，如果source 中C字符串的长度小于num，则不够的字符将用\0补充。

例：

#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);
	return 0;
}

输出结果：

9 strncmp函数的使用

//strncmp函数的声明
int strncmp(const char* str1, const char* str2, size_t num);

strncmp函数用来比较str1和str2函数前num个字符，如果相等就继续往后比较，最多比较num个字母，如果提前发现不一样，就提前结束。如果num个字符都相等，则返回0。

例：

#include <stdio.h>
#include <string.h>
int main()
{
	char str1[20] = "abcdef";
	char str2[20] = "abcqef";
	printf("%d\n", strncmp(str1, str2, 3)); 
	printf("%d\n", strncmp(str1, str2, 4));
	return 0;
}

输出结果：

10 strtok函数的使用

//strtok函数的声明
char* strtok(char* str, const char* sep);

strtok函数的功能把一条字符串分解为一组字符串，其中str指向要分解的字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记；sep指向另一个字符串，该字符串定义了用作分隔符的字符集合。

比如如果我们想分解字符串"23333@qq.com"，用作分隔符的字符串为"@."，那么2333、qq、com就可以看作是3个被分隔符分割的标记。

strtok函数在执行时，会找到str中的下一个标记，并将其用 \0 结尾，并返回一个指向这个标记的指针。比如strtok函数在分割"23333@qq.com"时，会把@改成\0，同时会返回2的地址

注意：strtok函数会改变被操作的字符串，所以使用strtok函数分割的字符串一般都是临时拷贝的内容并且可修改。

当strtok函数的第一个参数为非空指针（即不为 NULL）时 ，函数将在str中找到第一个标记，也就是在"23333@qq.com"中找到"@"，并且将其改为\0，并且保存它在字符串中的位置。

当strtok函数的第一个参数为空指针（即为 NULL时） ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

注意：如果字符串中不存在更多的标记，则返回 NULL 指针。

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "23333@qq.com";
	char buf[30] = { 0 };
	strcpy(buf, arr);
	char* p = "@.";
	char* s = strtok(buf, p);
	printf("%s\n", s);
	s = strtok(NULL, p);//如果这个地方第一个参数还是buf，那么strtok函数将还是从第一个标记开始查找。
	printf("%s\n", s);
	s = strtok(NULL, p);
	printf("%s\n", s);
	return 0;
}

输出结果：

上述代码在实现分割字符串的时候，strtok函数调用了3次，但我们会发现一个问题，就是实际上我们无法事先确定字符串中究竟有多少个标记，要解决这点，我们可以利用strtok函数在找不到更多标记时会返回空指针的特性来让程序来确定标记的数目。

例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "23333@qq.com";
	char buf[30] = { 0 };
	strcpy(buf, arr);
	char* p = "@.";
	char* r = NULL;
	for (r = strtok(buf, p); r != NULL; r = strtok(NULL, p))
	{
		printf("%s\n", r);
	}
	return 0;
}

输出结果：

11 strstr函数的使用和模拟实现

//strstr函数的声明
char* strstr(const char*, const char*);

strstr函数能在一个字符串str1中找到另一个字符串str2，如果str2有在str1中出现，它会返回str2在str1中首次出现的位置，如果str2不是str1的一部分，则返回空指针。

例：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "def";
	char arr3[] = "defq";
	char* ret1 = strstr(arr1, arr2);
	char* ret2 = strstr(arr1, arr3);
	printf("%s\n", ret1);
	printf("%s\n", ret2);
	return 0;
}

输出结果：

在上述例子中可以看到，由于strstr函数返回的是def首次出现的位置，因此打印时候它会从那个位置开始把后面所有的字符串都打印出来。

知道了strstr函数如何使用，下面我们对它进行模拟实现。

例：

#include <stdio.h>
#include <assert.h>
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* cp = str1;//最好加const，否则编译器会警告，因为把一个不可修改的指针赋给一个可修改的指针是不安全的
	const char* s1 = NULL;
	const char* s2 = NULL;
	if (*str2 == '\0')
		return str1;//特殊处理，如果子串是空字符串，就直接返回str1
	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 == *s2 && *s1 != '\0' && *s2 != '\0')
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')//s2已经匹配完了，说明已经找到
			return cp;
		cp++;//没找到，从下一个字符重新匹配
	}
	return NULL;
}
int main()
{
	char arr1[] = "abcdefg";
	char arr2[] = "def";
	char arr3[] = "defq";
	char* ret1 = my_strstr(arr1, arr2);
	char* ret2 = my_strstr(arr1, arr3);
	printf("%s\n", ret1);
	printf("%s\n", ret2);
	return 0;
}

输出结果：

12 strerror函数的使用

当我们的库函数在调用过程中发生各种错误时，要记录下来，这时候记录的就是错误码。C语言的库函数中，设计了一些错误码，这些错误码一般放在<errno.h>这个头文件中。

C语言程序启动的时候，会使用一个全局变量errno来记录程序当前的错误码，只不过程序启动的时候errno是0，表示没有错误，当我们在使用标准库中的函数的时候如果发生了某种错误，就会将对应的错误码，存放在errno中，而由于一个错误码的数字是整数，很难理解是什么意思，所以每一个错误码都有对应的错误信息。strerror函数就可以将错误码所对应的错误信息字符串的地址返回。

//strerror函数的声明
char* strerror(int errnum);

例：

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

输出结果：

例：

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

输出结果：

上面的代码中，第一个代码我们打印了部分错误码所对应的错误信息，第二个代码我们利用错误码来帮助我们判断文件是否打开。

实际上，C语言库函数中还有一个perror函数可以直接将错误码所对应的错误信息打印出来：

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

输出结果：

可以看到，perror函数会先将括号里面的字符串打印出来，然后打印:和一个空格再打印错误信息。