字符函数和字符串函数

搞点夜点心

已于 2023-09-17 19:56:24 修改

阅读量63

点赞数

分类专栏： c语言文章标签： c语言

于 2023-09-02 20:35:14 首次发布

本文链接：https://blog.csdn.net/2302_79180171/article/details/132639347

版权

c语言专栏收录该内容

37 篇文章 0 订阅

订阅专栏

字符分类函数

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

函数	如果他的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格’ ‘,换页’\f’,换行’\n’,回车’\r’，制表符’\t’或者垂直制表符’\v’
isdigit	十进制数字0~9
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	任何可打印的字符，包括图形字符和空白字符

例如：写⼀个代码，讲字符串中的小写字母转大写，其他字符不变。

#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 -= 32;
		putchar(c);
		i++;
	}
	return 0;
}

写⼀个代码，讲字符串中的小写字母转大写，其他字符不变。

字符转换函数

int tolower ( int c ); //将参数传进去的大写字母转小写
int toupper ( int c ); //将参数传进去的小写字母转大写
我们可将上面的程序进行优化：

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

strlen的使用和模拟实现

size_t strlen ( const char * str );

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

strlen使用的例子：

#include <stdio.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;
}

学会strlen函数的模拟实现

⽅式1：

//计数器
#include<stdio.h>
#include<assert.h>
int my_strlen(const char* str)
{
	assert(str);
	int count = 0;
	while(*str)
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char str[] = "abcdef";
	int tmp=my_strlen(str);
	printf("%d\n",tmp);
	return 0;
}

在这里插入图片描述
方法二：

//不能创建中间临时变量
#include<stdio.h>
#include<assert.h>
int my_strlen(const char * str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
int main()
{
	char str[] = "abcdef";
	int tmp=my_strlen(str);
	printf("%d\n",tmp);
	return 0;
}

方法三：

//指针-指针
#include<stdio.h>
#include<assert.h>
int my_strlen(const char * str)
{
	assert(str);
	char *p = str;
	while (*p != '\0')
		p++;
	return p - str;
}
int main()
{
	char str[] = "abcdef";
	int tmp=my_strlen(str);
	printf("%d\n",tmp);
	return 0;
}

strcpy的使用和模拟实现

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

源字符串必须以 ‘\0’ 结束。
会将源字符串中的 ‘\0’ 拷⻉到⽬标空间。
⽬标空间必须⾜够⼤，以确保能存放源字符串。
⽬标空间必须可变。

strcpy使用的例子：

#include<stdio.h>
#include<string.h>

int main()
{
	char str1[]= "abcde";
	char str2[]= "fsnla";
	const char* strr1 = str1;
	char* strr2 = str2;
	strcpy(strr2, strr1);
	printf("%s\n", str2);
	return 0;
}

在这里插入图片描述

strcpy模拟实现

#include<stdio.h>
#include<assert.h>

char* my_strcpy(char* strr2, const char* strr1)
{
	char* ret=strr2;
	assert(strr1);
	assert(strr2);
	while (*strr2++ = *strr1++)
	{
		;
	}
	return ret;
}

int main()
{
	char str1[]= "abcde";
	char str2[]= "fsnla";
	my_strcpy(str2,str1);
	printf("%s\n", str2);
	return 0;
}

在这里插入图片描述

strcat的使用和模拟实现

char* strcat(char* destination,const char* source)

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

#include<stdio.h>

int main()
{
	char str1[] = "abc";
	char str2[100] = "def";
	const char* sou = str1;
	char* des = str2;
	strcat(des, sou);
	printf("%s\n", des);
	return 0;
}

在这里插入图片描述

模拟实现strcat函数：

#include<stdio.h>
#include<assert.h>
char* my_strcat(char* des, const char* sou)
{
	char* ret=des;
	assert(des);
	assert(sou);
	while (*des)
	{
		des++;
	}
	while (*des++ = *soc++)
	{
		;
	}
	return ret;
}

int main()
{
	char str1[] = "abc";
	char str2[100] = "def";
	my_strcat(str2,str1);
	printf("%s\n", str2);
	return 0;
}

在这里插入图片描述

strcmp 的使用和模拟实现

int strcmp(const char* str1, const char* str2)

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

那么如何判断两个字符串？⽐较两个字符串中对应位置上字符ASCII码值的大小。

#include<stdio.h>
#include<string.h>

int main()
{
	char str1[] = "abcd";
	char str2[] = "exhf";
	const char* strr1 = str1;
	const char* strr2 = str2;
	int tmp = strcmp(strr1, strr2);
	printf("%d\n", tmp);
	return 0;
}

在这里插入图片描述

strcmp函数的模拟实现：

#include<stdio.h>
#include<string.h>

int my_strcmp(const char* strr1, const char* strr2)
{
	int ret = 0;
	assert(strr1);
	assert(strr2);
	while (*strr1 == *strr2)
	{
		if (*strr1 == '\0')
		{
			return 0;
		}
		strr1++;
		strr2++;
	}
	return (*strr1-*strr2);
}

int main()
{
	char str1[] = "abcd";
	char str2[] = "exhf";
	int tmp = my_strcmp(str1, str2);
	printf("%d\n", tmp);
	return 0;
}

strncpy 函数的使用

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

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

#include<stdio.h>

int main()
{
	char str1[100] = "abc";
	char str2[] = "defgh";
	char* strr1 = str1;
	const char* strr2 = str2;
	strncpy(str1, str2, 10);
	printf("%s\n",str1);
	return 0;
}

在这里插入图片描述

strncpy的模拟

#include<stdio.h>
#include<assert.h>

char* my_strncpy(char* str1, const char* str2, size_t num)
{
	assert(str1 && str2);
	char* ret = str1;
	int len = strlen(str2);
	if (num <= len)
	{
		while (num--)
		{
			*str1 = *str2;
			str1++;
			str2++;
		}
	}
	else
	{
		while (num--)
		{
			if (len < 0)
			{
				break;
			}
			else
			{
				*str1 = *str2;
				str1++;
				str2++;
			}
			len--;
		}
	}
	return ret;
}


int main()
{
	char str1[20] = "abcdef";
	char str2[] = "rat";
	my_strncpy(str1, str2, 5);
	printf("%s\n", str1);
	return 0;
}

在这里插入图片描述

strncat 函数的使用

char* strcat(char* destination,const char* source,size_t num)

将源的前num个字符追加到目标，再加上一个终止的null字符。
如果源中的C字符串的长度小于num，则只有‘\0’之前的内容被复制。

/* 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);//在str1中追加str2的前6个元素
	printf("%s\n", str1);
	return 0;
}

在这里插入图片描述

strncat的模拟

#include<stdio.h>
#include<assert.h>

char* my_strncat(char* str1, const char* str2, size_t num)
{
	assert(str1 && str2);
	char* ret = str1;
	int count = 0;
	if (*str2 == 0)
	{
		return ret;
	}
	while (*str1)
	{
		str1++;
	}
	char str3[100] = "a";
	while (num-- && *str2++)
	{
		count++;
		str3[count] = *str2;
	}
	str2 = ret;
	int i = 0;
	for (i = 0; i <= count; i++)
	{
		*str1 = str3[i];
		str1++;
	}
	*str1 = '\0';
	return ret;
}

int main()
{
	char str[30] = "abcd";
	my_strncat(str, str, 5);
	printf("%s\n",str);
	return 0;
}

在这里插入图片描述

strncmp函数的使用

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

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

strstr的使用和模拟实现

char * strstr ( const char *, const char * );//字符串查找

Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.
The matching process does not include the terminating null-characters, but it stops there.

/* strstr example */
#include <stdio.h>
#include <string.h>
int main()
{
	char str[] = "This is a simple string";
	char * pch;
	pch = strstr(str, "simple");//返回的值为simple中s的地址
	strncpy(pch, "sample", 6);//再将sample拷贝到str数组simple的地址的值中
	printf("%s\n", str);
	return 0;
}

在这里插入图片描述

strstr的模拟实现：

#include<stdio.h>
#include<assert.h>

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

int main()
{
	char str1[] = "abbbcdef";
	char str2[] = "bbc";
	char* ret = my_strstr(str1, str2);
	if (ret != NULL)
	{
		printf("%s\n",ret);
	}
	else
	{
		printf("没找到\n");
	}
	return 0;
}

在这里插入图片描述

strtok函数的使用

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

sep参数指向⼀个字符串，定义了⽤作分隔符的字符集合
第⼀个参数指定⼀个字符串，它包含了0个或者多个由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))
	{
	//第一次str=192，strtok第一个参数不为NULL，因此找到第一个'.'将它变为'\0'，
	//str=192，因为str != NULL，因此第一次输出192
	//接着执行str=strtok(NULL,sep),因为第一个参数为NULL，因此将在同一个字符串中
	//被保存的位置开始，查找下一个'.'，也就是从第一个'.'的位置往后找，因此
	//str=168
	//......直到最后返回NULL	
		printf("%s\n", str);
	}
	return 0;
}

在这里插入图片描述

strerror函数的使用

char * strerror ( int errnum );

strerror函数可以把参数部分错误码对应的错误信息的字符串地址返回来。需要引用头文件errno.h.

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

在这里插入图片描述

#include <stdio.h>
#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函数

相当于优化上述程序的打印过程，直接将错误信息打印出来。

头文件：#include<stdio.h>
void perror(const char* str);

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

搞点夜点心

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
字符函数和字符串函数

C语⾔中有⼀系列的函数是专门做字符分类的，也就是⼀个字符是属于什么类型的字符的。strerror函数可以把参数部分错误码对应的错误信息的字符串地址返回来。那么如何判断两个字符串？⽐较两个字符串中对应位置上字符ASCII码值的大小。例如：写⼀个代码，讲字符串中的小写字母转大写，其他字符不变。相当于优化上述程序的打印过程，直接将错误信息打印出来。//将参数传进去的小写字母转大写。//将参数传进去的大写字母转小写。
复制链接

扫一扫

专栏目录