字符函数与字符串函数

在编程的过程中，我们经常要处理字符和字符串，为了方便操作字符和字符串，C语言标准库提供了一系列库函数。

1.字符分类函数

C语言中有一系列的函数是专门做字符分类的，也就是一个字符是属于什么类型的字符的，这些函数的使用都需要包含一个头文件是ctype.h。

函数	如果它的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格‘ ’，换页‘\f’，换行‘\n’，回车‘\r',制表符’\t'
isdigit	十进制数字
isxdigit	十六进制数字，包括所有十进制数字，小写字母a~f,大写字母A~F
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a~z,或者 A~Z
isalnum	字母或者数字，a~z，A~Z，0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符
isgraph	任何图形字符
isprint	任何可以打印的字符，包括图型字符和空白字符

这些函数的使用方法类似，举例一个，其他的雷同：

int islower(int c);

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

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

练习：写一个代码，将字符串的小写字母转大写，其他字符不变。

1.不用函数

#include<stdio.h>
int main()
{
	char arr[] = "I am a student";
	int i = 0;
	while (arr[i] != '\0')//说明arr[i]到\0就结束循环
	{
		if (arr[i] >= 'a' && arr[i] <= 'z')//a的ASCLL是97，z为122；
		{
			arr[i] -= 32;
		}
		i++;
	}
	printf("%s\n", arr);//%s字符串型格式符
	return 0;
}

2.用函数

int main()
{
	int i = 0;
	char str[] = "Test String.\n";
	char c;
	while (str[i])
	{
		c = str[i];
		if (islower(c))
			c -= 32;
		putchar(c);
		i++;
	}
	return 0;
}

2.字符转换函数

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

1.int tolower(int c);//将参数传进去的大写字母转小写
2.int topper（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;
}

3.strlen的使用和模拟实现

1.size_t strlen( const char*strr);

• 字符串以'\0'作为结束标志，strlen函数返回的是在字符串中'\0',前面出现的字符个数（不含’\0').
• 参数指向的字符串必须要以’\0'结束。
• 注意函数的返回值为size_t,是无符号的。
• strlen的使用需要包含头文件。

#include<stdio.h>
#include<string.h>
int main()
{
	const char* str1 = "abcdef";
	const char* str2 = "bbb";
	if (strlen(str2) - strlen(str1) > 0)//计算字符串s的（unsigned int型）长度，不包括’\0’在内
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("str1>str2\n");
	}
	return 0;
}

依据：无符号数-无符号数=无符号数>0

strlen的模拟实现：

模拟实现

1.计算机的方式

2.指针-指针

3.递归

计算器：

#include<stdio.h>
#include<string.h>
#include<assert.h>
size_t my_strlen(const char* s)
{
	assert(s);//指针不为空
	int count = 0;//计算器
	while (*s != '\0')
	{
		count++;
		s++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	size_t len = my_strlen(arr);
	printf("%zd\n", len);
	return 0;
}

递归：

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

指针：

int my_strlen(char* s)
{
	assert(s);
	char* p = s;
	while (*p != '\n')
		p++;
	return p - s;
}

4.strcpy的使用和模拟实现

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

• 源字符串必须以 '\0'结束（不然找不到什么时候停下来的位置）
• 会将源字符串中的'\0'拷贝到目标空间。
• 目标空间必须足够大，以确保能够存放字符串
• 目标空间必须可以修改
• 学会模拟实现

strcpy的模拟实现

#include<stdio.h>
#include<assert.h>
#include<string.h>
char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;//在++之前存起来（拷贝）
	assert(dest != NULL);
	assert(src != NULL);//确保指针不为空
	while (*src != '\0')//拷贝‘'\0'之前的字符
	{
		*dest = *src;//复制
		dest++;//目标地址往后+1
		src++;//源地址往后+1
	}
	*dest = *src;//再将结尾的'\0'复制过去
	return ret;//返回目的数组的首地址
}
int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "world";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

改进一下while循环可以写成更简单的形式

while(*dest++=*src++)
{
  ;
}

5.strcat的使用和模拟实现

追加一个字符串

• 源字符串必须以'\0'结束。
• 目标字符串也得有'\0'，否则没办法知道追加从哪里开始。
• 目标空间必须足够大，能容纳下源字符串的内容
• 目标空间必须可以修改

模拟实现strcat函数：

函数返回的是目标空间的起始地址

char* my_strcat(char* dest, char* src)
{
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while (*dest)//=while(*dest!='\0')
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;//空语句
	}
	return 0;
}
int main()
{
	char arr1[20] = "hello";
	char arr2[20] = "world";
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

6.strcmp的使用和模拟实现

两个字符串内容的比较

标准规定：

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

那么如何判断两个字符串的大小呢？

答案是：比较两个字符串中对应位置上的字符ASCII码值的大小

strcmp的模拟实现

int my_strcmp(const char* str1, const char* str2)
{
	int ret = 0;
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == "\0")
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abc";
	int len=my_strcmp(arr1, arr2);
	printf("%d\n", len);
	return 0;
}

7.strncpy函数的使用

我们之前学习了strcpy,strcat,strcmp,他们都是长度不受限制的字符串函数，而我们接下来学习的strncpy,strncat,strncmp,则是受限制的（长度），在基础上多了一个参数。

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

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

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

结果：

若将3改为8，则输出abcdef\0\0（补齐8个）

8.strncat函数的使用

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

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

  #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函数的使用

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

作用：比较str1和str2的前num个字符，如果相等就继续往后比较。最多比较num个字母，如果提前发现不一样，就提前结束，大的字符所在的字符串大于另一个。如果num个字符都相同，就是相等返回0。

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

结果：-1

加个参数进行比较，会相对安全

10.strstr的使用和模拟实现

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

该函数返回值指针，函数返回字符串str2在字符串中的第一次出现的位置，字符串的比较匹配不包含\0字符，以\0作为结束标志。

int main()
{
	char str[] = "This is a simple string";
	const char* p = "is";
	char* ret = strstr(str, p);
	printf("%s\n", ret);
	return 0;
}

p检测到字符is就开始打印了

strstr的模拟实现

char* strstr(const char* str1, const char* str2)
{
	char* cp = (char*)str1;//强制转换为字符指针
	char* s1, * s2;
	if (!*str2)//str2!='\0'
		return((char*)str1);
	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;
		while (*s1 && *s2 && !(*s1 - *s2))
			s1++, s2++;
		if (!s2)//s2!='\0'
			return(cp);
		cp++;
	}
	return(NULL);
}
int main()
{
	char arr1[] = "abcdefabcdef";
	char arr2[] = "cdf";
	char* ret =strstr(arr1, arr2);
	if (ret == NULL)
		printf("找到了\n");
	else
		printf("没找到\n");
	return 0;
}

不希望char*str所指向的内容被修改，加上const限制

char*cp的作用：得有一个指针变量记录开始匹配的位置

1.简单

 str1从ak开始向后移动，abcdef\0 

str2从b开始向后移动，bcd\0

str1从b开始匹配，直至str2移动到\0,匹配结束，一次性匹配完

2.复杂（可能 存在多次匹配）

str1从a或第一个d开始都无法与 str2匹配，abbbcdef\0

要专门有个指针记录str2的起始位置，以便重新匹配，bbc\0

所以还得有两个指针变量，记录起始位置

3.不可能找到

abcdef\0   bbg\0

11strtok函数的使用

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

• sep参数指向一个字符串，定义了用作分隔符的字符集合
• 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
• strtok函数找到str中的下一个标记，并将其用\0结尾返回一个指向这个标记的指针。（注意：strtok函数会改变被操作的字符串，所以在使用strtok函数分割的字符串一般都是临时拷贝的内容并且可修改。）
• strtok函数的第一个参数不为NULL,函数将找到str中的第一个标记，strtok函数将保存它在字符串中的位置。
• sttok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
• 如果字符串不存在更多的标记，则返回NULL指针。

  int main()
  {
  	char arr1[] = "zpengwei@yuah,net";
  	char* sep = "@";
  	char* str = NULL;
  	for (str = strtok(arr1, sep); str != NULL; str = strtok(NULL, sep))
  	{
  		printf("%s\n", str);
  	}
  	return 0;
  }

  

找到@的标志改为\0，同时返回z的地址，同时它会记录下\0这个地址的位置

8.strerror函数的使用

它可以把参数部分错误码对应的错误信息的字符串地址返回来

在不同的系统和C语言标准库的实现中都规定了一些错误码，一般放在errno.h这个头文件中说明

打印0~10错误码对应的信息

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

在windows11下vs2022环境下输出的：