【c语言——字符函数和字符串函数】

文章目录

一、字符分类函数
二、字符转换函数
三、strlen的使⽤和模拟实现
四、strcpy的使⽤和模拟实现
五、strcat的使⽤和模拟实现
六、strcmp的使⽤和模拟实现
七、strncpy函数的使⽤
八、strncat函数的使⽤
九、strncmp函数的使⽤
十、strstr的使⽤和模拟实现
十一、strtok函数的使⽤
十二、strerror函数的使⽤

在编程的过程中，我们经常要处理字符和字符串，为了⽅便操作字符和字符串，C语⾔标准库中提供了⼀系列库函数，接下来我们就学习⼀下这些函数。

一、字符分类函数

C语⾔中有⼀系列的函数是专⻔做字符分类的，也就是⼀个字符是属于什么类型的字符的。这些函数的使⽤都需要包含⼀个头⽂件是
【c语言——字符函数和字符串函数】-LMLPHP
这些函数的使⽤⽅法⾮常类似，我们就讲解其中⼀个函数，其他的⾮常类似：

int islower ( int c );

islower 是能够判断参数部分的 c 是否是⼩写字⺟的。
通过返回值来说明是否是⼩写字⺟，如果是⼩写字⺟就返回⾮0的整数，如果不是⼩写字⺟，则返回0。

#include<ctype.h>

int main()
{
	/*int ret = islower('A');*///islower判断小写，是就返回非0，不是就返回0
	int ret = isspace('\n');//判断空白字符，是就非0，不是就0
	printf("%d\n", ret);
	return 0;
}

练习：写⼀个代码，将字符串中的⼩写字⺟转⼤写，其他字符不变。

//a-97  A-65   32
//b-98  B-66   32

#include<ctype.h>

int main()
{
	char arr[] = "i am a student";
	//	              i am a student\0
	//                0123
	int i = 0;
	while (arr[i] != '\0')
	{
		//if (arr[i] >= 'a' && arr[i] <= 'z')
		if (islower(arr[i]))//运用字符函数，是小写就返回非0整数
		{
			arr[i] -= 32;
			
		}
		i++;
	}
	printf("%s\n", arr);
	return 0;
}

二、字符转换函数

C语⾔提供了2个字符转换函数：

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

int main()
{
	printf("%c\n", toupper('a'));//转大写
	printf("%c\n", toupper('b'));
	printf("%c\n", tolower('b'));//转小写
	return 0;
}

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

#include<ctype.h>

int main()
{
	char arr[] = "i am a student";
	//	              i am a student\0
	//                0123
	int i = 0;
	while (arr[i] != '\0')
	{
		//if (arr[i] >= 'a' && arr[i] <= 'z')
		if (islower(arr[i]))//运用字符函数，是小写就返回非0整数
		{
			arr[i] = toupper(arr[i]);//字符转换函数		
		}
		i++;
	}
	printf("%s\n", arr);
	return 0;
}

三、strlen的使⽤和模拟实现

size_t strlen ( const char* str );

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

#include<string.h>

int main()
{
	if ((int)strlen("abc") -(int) strlen("abcdef") > 0)
	{
		printf(">\n");
	}
	else
	{
		printf("<=\n");
	}
	return 0;
}

strlen的模拟实现：
⽅式1：

//计数器⽅式 
#include<assert.h>

size_t my_strlen(const char* s)//s默认为初始位置的指针
{
	assert(s);
	int count = 0;//计数器
	while (*s != '\0')
	{
		count++;
		s++;
	}
	return count;
}

方式2：

//不创建临时变量count,求字符串的长度--递归
size_t my_strlen(const char* s)
{
	if (*s == '\0')
		return 0;
	else
		return 1 + my_strlen(s + 1);//s+1跳过一个字符指向第二个字符的地址
}

int main()
{
	char arr[] = "abcdef";
	size_t len = my_strlen(arr);
	printf("%zd\n", len);
	return 0;
}

⽅式3：

//指针-指针的⽅式 

int my_strlen(char* s)
{
	assert(str);
	char* p = s;
	while (*p != ‘\0’)
		p++;
	return p - s;
}

四、strcpy的使⽤和模拟实现

strcpy–string copy字符串拷贝 strncpy
strcat strncat
strcmp strncmp

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

• 源字符串必须以 ‘\0’ 结束。

• 会将源字符串中的 ‘\0’ 拷⻉到⽬标空间。

• ⽬标空间必须⾜够⼤，以确保能存放源字符串。

• ⽬标空间必须可修改。

• 学会模拟实现。
strcpy的模拟实现:

//1.参数顺序 
//2.函数的功能，停⽌条件 
//3.assert
//4.const修饰指针 
//5.函数返回值 
//6.题目出自《⾼质量c/c++编程》书籍最后的试题部分 

#include<assert.h>
#include<string.h>
char* my_strcpy(char* dest,const char* src)
{
	assert(src != NULL);
	assert(dest != NULL);
	char* ret = dest;
	/*拷贝\0之前的内容*/
	while (*src != '\0')
	{
		/* *dest = *src;
		dest++;
		src++; */
		*dest++ = *src++;//后置++是先使用后++
	}
	*dest = *src;//拷贝\0
	
	/*超级改进*/
	//while (*dest++ = *src++)//遇到\0，\0的ASCII码值为0，停止计算
	//{
	//	;
	//}
	return ret;
}


src
+
hello  bit
xxxxxxxxxx
+
dest

模拟实现举例：

include<assert.h>
#include<string.h>
char* my_strcpy(char* dest, const char* src)
{
	assert(src != NULL);
	assert(dest != NULL);
	char* ret = dest;
	while ((*dest++ = *src++) != '\0') {
		// 循环体为空，直接依赖赋值操作和自增来移动指针  
	}
	return ret;
}

int main()
{
	char arr1[] = "hello bit";
	char arr2[20] = "xxxxxxxxxxxxx";
//	char* p = "xxxxxxxxxxxxxxxxxxxxxxxx";//常量字符串是不能改变的
/*	strcpy(arr2, arr1);*///,拷贝函数：拷贝arr1的内容放在arr2中
	char* ret = my_strcpy(arr2, arr1);//模拟实现字符串拷贝
	printf("%s\n", arr2);//两种打印方式
	printf("%s\n", ret);
	return 0;
}

五、strcat的使⽤和模拟实现

源字符串必须以 ‘\0’ 结束。
⽬标字符串中也得有 \0 ，否则没办法知道追加从哪⾥开始。
⽬标空间必须有⾜够的⼤，能容纳下源字符串的内容。
⽬标空间必须可修改。
字符串⾃⼰给⾃⼰追加，如何？

模拟实现strcat函数：

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

//strcat--函数用来连接字符串
#include<string.h>
#include<assert.h>
char* my_strcat(char* dest,const char* src)//dest对应目标空间，src对应连接的内容
{
	assert(dest && src);
	char* ret = dest;
	/*1.找到目标空间的\0*/
	while (*dest != '\0')
		dest++;
	/*2.拷贝*/
		while (*dest++ = *src++)
			;//空语句
	return ret;
}

int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "world";
	/*char arr2[] = { 'w','o','r','l','d' };*///连接的内容不能没有\0
	/*strcat(arr1, arr2);*///连接函数：连接arr2的内容到arr1中
	char* s = my_strcat(arr1, arr2);//模拟实现连接函数
	printf("%s\n", arr1);
	printf("%s\n", s);
	return 0;
}


              +
arr1    hello_\0    
arr2    world\0
        +
1.找到目标空间的\0
2.拷贝数据

#include<string.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;//dest初始化
	assert(dest && src);
		//1.找到目标空间中的\0
		while (*dest != '\0')//遇到\0才停止循环，此时dest在\0的位置
		{
			dest++;
		}
	//2.数据的拷贝
	while (*dest++ = *src++)//*src就是g,赋值给此时的dest相当于在后面连接上了
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "abcdef";
	char arr2[20] = "ghi";
	/*my_strcat(arr1, arr1);*///用模拟库函数实现自己连接自己 1.死循环 2.程序崩溃，但是直接使用strcat函数可以实现
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

常见错误：

#include<string.h>

int main()
{
	/*int a = 10;
	int b = 20;
	b = a;*/
	char arr1[] = "abcdef";
	char arr2[20] = { 0 };
	//arr2 = arr1;//不行的，因为数组名是数组首元素的地址，就是一个常量的值
	strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

六、strcmp的使⽤和模拟实现

两个字符串的比较

数据库：
用户名，密码
标准规定：

第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字
第⼀个字符串等于第⼆个字符串，则返回0
第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字

那么如何判断两个字符串？⽐较两个字符串中对应位置上字符ASCII码值的⼤⼩。
strcmp函数的模拟实现：

int main()
{
	//char arr1[] = "abcdef";
	//char arr2[] = "abcdef";
	//if (arr1 == arr2)//比较的是地址
	//{

	//}
	 
	//char* p = "abcdef";
	//if ("abcdef" == "abc")//也是在比较地址
	//{

	//}
	//如果要比较两个字符串的内容，需要使用strcmp
	char arr1[] = "abcdef";
	char arr2[] = "abq";
	int ret = strcmp(arr1, arr2);
	printf("%d\n", ret);//<0
	return 0;
}


    大
    +
a b c d  e  f  \0  大
a b b q  \0        小

a b c d e f \0     小
a b q \0           大
    +
	大

//模拟实现
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)//返回值是int类型，整数
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')//其中一个是\0，说明另一个也是\0
			return 0;
		str1++;
		str2++;
	}
	/*if (*str1 > *str2)
	{
		return 1;
	}
	else
	{
		return -1;
	}*/

	return *str1 - *str2;
}
int main()
{
	char arr1[] = "abq";
	char arr2[] = "abcdef";
	int ret = my_strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}

七、strncpy函数的使⽤

strcpy strncpy
strcat strncat
strcmp strncmp
长度不受限制的字符串函数 (不安全的) 长度受限制的字符串函数(相对安全的)

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

• 拷⻉num个字符从源字符串到⽬标空间。

• 如果源字符串的⻓度⼩于num，则拷⻉完源字符串之后，在⽬标的后边追加0，直到num个。

#include<string.h>

int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = "xxxxxxxxxxxx";
	strncpy(arr2, arr1, 3);
	printf("%s\n", arr2);
	return 0;
}

【c语言——字符函数和字符串函数】-LMLPHP

八、strncat函数的使⽤

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

• （将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加⼀个 \0 字
符）。

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

int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = "xx\0xxxxxx";
	strncat(arr2, arr1, 3);//数字大了，只补一个\0
	printf("%s\n", arr2);
	return 0;
}

【c语言——字符函数和字符串函数】-LMLPHP

/* strncat example */

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

九、strncmp函数的使⽤

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

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

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abqdefghi";
	int ret = strncmp(arr1, arr2, 2);
	printf("%d\n", ret);
	return 0;
}

【c语言——字符函数和字符串函数】-LMLPHP

十、strstr的使⽤和模拟实现

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

在字符串st1中找到字符串str2，并返回字符串str2第一次出现的地址,再往后展现，没出现返回空指针

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

int main()
{
	char arr1[] = "this is an apple\n";
	const char* p1 = "is";//p1存放的首字符i的地址
	const char* p2 = "appl";
	const char* p3 = "Appl";
	char* ret1 = strstr(arr1, p1);
	char* ret2 = strstr(arr1, p2);
	char* ret3 = strstr(arr1, p3);
	printf("%s\n", ret1);//is is an apple
	printf("%s\n", ret2);//apple
	printf("%s\n", ret3);//（null）
	return 0;
}

int main()
{
	char arr1[] = "this is an apple\n";
	/*const char* p = "Apple";*/
	char arr2[] = "is";//arr2也是指针，是个地址
	char* ret = strstr(arr1, arr2);
	if (ret != NULL)
	{
		printf("%s\n", ret);
	}
	else
	{
		printf("找不到\n");
	}
	return 0;
}

【c语言——字符函数和字符串函数】-LMLPHP

strstr的模拟实现：

char* my_strstr(const char* str1, const char* str2)
{
	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* cur = str1;//这是赋值，不是等于
	if (*str2 == '\0')//特殊场景，*str就是传的字符串如果是空的
		return (char*)str1;

	while (*cur)//cur遍历上面整个字符串，当遇到\0就终止
	{
		s1 = cur;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
		{
			s1++;
			s2++;
			//s1和s2只要相等，就都往后走一步再比
		}
		if(*s2 == '\0')
		{
			return (char*)cur;//返回匹配的地址
		}
		cur++;//cur++让匹配的位置往后走一位，s1再到cur的新位置开始
	}
	return NULL;
}

int main()
{
	char arr1[] = "abcdefabcdef";
	char arr2[] = "cdef";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
		printf("找不到\n");
	else
		printf("%s\n", ret);
	return 0;
}

1.最简单
str1
++
abdcef\0   上面先走，匹配到了，上下一起走,碰到\0停
bdc\0
+
str2  

结论：1，得有一个指针变量，记录开始匹配的位置


2.复杂 
+++
abbbcdef\0  上面先走，匹配到了，上下一起走，有歧义，上面回到匹配的后一个位置，下面回到开始重新一起走
bbc\0
+

结论2：还得有2个指针变量记录起始位置

cur
s1
+
abbbcdef\0
+
str1



s2
+
bbc\0
+
str2

十一、strtok函数的使⽤

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

zpenwei@yeah.net   "@ ."--分隔符的集合--sep
192.168.112.43      "."

strtok切分字符串
会把第一个分隔符变成\0,并记录\0的位置，第二次就从这里开始找
如果第一个参数为null，就会把第二个分隔符变成\0，并记录\0的位置

• sep参数指向⼀个字符串，定义了⽤作分隔符的字符集合

• 第⼀个参数指定⼀个字符串，它包含了0个或者多个由sep字符串中⼀个或者多个分隔符分割的标记。

• strtok函数找到str中的下⼀个标记，并将其⽤ \0 结尾，返回⼀个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使⽤strtok函数切分的字符串⼀般都是临时拷⻉的内容并且可修改。）
• strtok函数的第⼀个参数不为 NULL ，函数将找到str中第⼀个标记，strtok函数将保存它在字符串中的位置。

• strtok函数的第⼀个参数为 NULL ，函数将在同⼀个字符串中被保存的位置开始，查找下⼀个标记。

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

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

int main()
{
	/*char arr[] = "zpengwei@yeah.net";*/
	char arr[] = "zpengwei@yeah.net@hehe";
	char arr2[30] = { 0 };
	strcpy(arr2, arr);//拷贝一份
	const char* sep = "@.";
	char* ret = NULL;//赋值为空指针
	for (ret = strtok(arr, sep); ret != NULL; ret = strtok(NULL, sep))//for循环的三个部分
	{
		printf("%s\n", ret);
	}
	//ret = strtok(arr2, sep);//提取内容1
	//printf("%s\n", ret);

	//ret = strtok(NULL, sep);//提取内容2
	//printf("%s\n", ret);

	//ret = strtok(NULL, sep);//提取内容3
	//printf("%s\n", ret);
	return 0;
}

十二、strerror函数的使⽤

char* strerror ( int errnum );

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

我们打印⼀下0~10这些错误码对应的信息：

#include <errno.h>

int main()
{
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		printf("%d:  %s\n", i, strerror(i));//打印1-10对应的错误信息
	}
	return 0;
}

【c语言——字符函数和字符串函数】-LMLPHP

举例：

#include <string.h>
#include <errno.h>

int main()
{
	FILE* pFile;
	pFile = fopen("unexist.ent", "r");//以读的方式打开文件
	if (pFile == NULL)
		printf("Error opening file unexist.ent: %s\n", strerror(errno));
	return 0;
}

输出：

也可以了解⼀下perror函数，perror函数相当于⼀次将上述代码中的第9⾏完成了，直接将错误信息
打印出来。perror函数打印完参数部分的字符串后，再打印⼀个冒号和⼀个空格，再打印错误信息。

#include<errno.h>
int main()
{
	//fopen以读的形式打开文件的时候，如果文件不存在，就打开失败
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//读文件

	//关闭文件
	fclose(pf);
	return 0;
}

perror函数
perror有能力直接打印错误信息，打印的时候，先打印传给perror的字符串，然后打印冒号，再打印空格，最后打印错误码对应的错误信息

perror==printf+strerror
int main()
{
	//fopen以读的形式打开文件的时候，如果文件不存在，就打开失败
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("zhangsan");
		perror("");
		return 1;
	}
	//读文件

	//关闭文件
	fclose(pf);
	return 0;
}

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

输出：

Error opening file unexist.ent: No such file or directory

怀旧,