字符函数和字符串函数的介绍及模拟实现

于 2023-02-01 20:23:18 发布
阅读量58 收藏
点赞数
分类专栏： C语言知识点 文章标签： c语言 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72387202/article/details/128801202
版权

文章目录

本章重点
重点介绍处理字符和字符串的库函数的使用和注意事项
求字符串长度
strlen
长度不受限制的字符串函数
strcpy
strcat
strcmp
长度受限制的字符串函数介绍
strncpy
strncat
strncmp
字符串查找
strstr
strtok
错误信息报告
strerror
字符操作
内存操作函数
memcpy
memmove
memset
memcmp

0. 前言

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在 常量字符串中 或者 字符数组 中。
字符串常量 适用于那些对它不做修改的字符串函数.

1. 函数介绍

1.1 strlen(字符串拷贝函数)

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

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

int main()
{
	char arr[] = "abcdef";
	int ret = strlen(arr);
	printf("%d\n", ret);//6
	return 0;
}

1.2 strcpy(字符串追加函数)

char* strcpy(char * destination, const char * source );
源字符串必须以 ‘\0’ 结束。
会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "xxxxxxxxxxxx";//destination
	char arr2[] = "abcef\0";     //sourse
	strcpy(arr1, arr2);
	printf("%s\n", arr1);//abcdef\0
	return 0;
}

1.3 strcat(字符串追加函数)

char * strcat ( char * destination, const char * source );
源字符串必须以 ‘\0’ 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
字符串自己给自己追加，如何？

#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
	char arr1[20] = "hello ";//目标空间要足够
	//char* p = "hello ";
	//strcat(p, "word");
	//上面这种做法不可取，因为常量字符串放在p中（目标空间）不能被修改
	char arr2[] = "word";
	strcat(arr1, arr2);
	printf("%s\n", arr1);//hello word
	return 0;
}

但strcat自己给自己追加会导致字符串末尾缺少’\0’而产生bug，因此字符串追加自己的时候，有一个专门的库函数：strncat 在后文也会介绍。

1.4 strcmp(字符串比较函数）

int strcmp ( const char * str1, const char * str2 );
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
那么如何判断两个字符串？

#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcdef";
	//VS环境中
	//> 1
	//= 0
	//< -1
	int ret = strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}

1.5 strncpy(拷贝n个字符)

char * strncpy ( char * destination, const char * source, size_t num );
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
	char arr[20] = "xxxxxxxxxxx";
	strncpy(arr, "abcdef", 3);
	printf("%s\n", arr);//abcxxxxxxxx
	//strncpy(arr, "abcdef", 10);//当要拷贝的字符串数量超过总数量时，剩余的拷贝'\0'
	//printf("%s\n", arr);//abcdef\0\0\0\0
	return 0;
}

1.6 strncat(追加n个字符)

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

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[20] = "abcd";
	strncat(arr, "efghjk", 3);
	printf("%s\n", arr);//abcdefg
	return 0;
}

1.7 strncmp(比较n个字符)

int strncmp ( const char * str1, const char * str2, size_t num );
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
	char arr1[20] = "abcdefg";
	char arr2[20] = "abcdqwer";
	int ret = strncmp(arr1, arr2, 5);
	printf("%d\n", ret);//-1
	return 0;
}

1.8 strstr(字符串中找字符串)

char * strstr ( const char *str1, const char * str2);
在str1中找str2
如果找到，返回找到第一个字符的地址
如果没找到，则返回NULL

#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
	char arr1[] = "abbbcdefg";
	char arr2[] = "bbc";
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s\n", ret);//bbcdefg
	}
	return 0;
}

1.9 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>
#include<assert.h>

int main()
{
	char arr[] = "zpengwei@year.net";
	char* p = "@.";//不能用'\0'当分隔符
	char buf[20] = { 0 };
	strcpy(buf, arr);
	char* ret = NULL;
	for (ret = strtok(arr, p); ret != NULL;ret=strtok(NULL,p))//strtok记住了下一处的地址，用NULL接收
	{
		printf("%s\n", ret);
	}
	//zpengwei
	//year
	//net
	return 0;
}

1.10 strerror(报错函数)

char * strerror ( int errnum );
返回错误码，所对应的错误信息。

#include <stdio.h>
#include <string.h>
#include <errno.h>//必须包含的头文件
int main()
{
	//打开文件
	FILE* pf = fopen("text.txt", "r");//fopen是一个打开文件的库函数
	if (pf == NULL)
	{
	                                    //strerro是将错误码转换成错误信息的一个库函数
		printf("%s\n", strerror(errno));//errron是一个存放错误信息的变量
		//perror()函数可以直接打印错误信息
		return 1;
		
	}
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

代码结果：
在这里插入图片描述
字符分类函数：

函数 如果他的参数符合下列条件就返回真
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 任何可打印字符，包括图形字符和空白字符

字符转换(大小写转换)：

int tolower ( int c );
int toupper ( int c );

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
	char arr[] = "I Have Appe";
	int i = 0;
	while (arr[i])
	{
		if (isupper(arr[i]))
		{
			arr[i] = tolower(arr[i]);
		}
		printf("%c", arr[i]);//i have appe
		i++;
	}
}

1.11 memcpy(内存拷贝函数)

void * memcpy ( void * destination, const void * source, size_t num );
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 ‘\0’ 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	memcpy(arr2, arr1 + 2, 20);//20的单位是字节，以字节为单位进行拷贝
	//arr2:3456700000
	return 0;
}

1.12 memmove(重叠内存拷贝函数)

void * memmove ( void * destination, const void * source, size_t num );
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

#include <stdio.h>
#include <string.h>
#include<assert.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr+2, arr, 20);
	//arr:1 2 1 2 3 4 5 8 9 10
	return 0;
}

1.13memcmp(内存比较函数)

int memcmp ( const void * ptr1,
const void * ptr2,
size_t num );
比较从ptr1和ptr2指针开始的num个字节
返回值如下：
在这里插入图片描述

#include <stdio.h>
#include <string.h>
#include<assert.h>
int main()
{
	int arr1[] = { 1,2,5 };//01 00 00 00 02 00 00 00 05 00 00 00
	int arr2[] = { 1,2,4 };//01 00 00 00 02 00 00 00 04 00 00 00
	int ret = memcmp(arr1, arr2, 9);//9的单位是字节
	printf("%d\n", ret);
	return 0;
}

1.14memset(内存设置函数)

void *memset( void *dest, int c, size_t count );
设置count个字节的c（c是自定义的值）

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "hello word";
	memset(arr, 'x', 5);
	printf("%s\n", arr);//xxxxx word
	return 0;
}

2. 库函数的模拟实现

2.1 模拟实现strlen

#include<stdio.h>
#include<string.h>
#include<assert.h>
//计数器求字符串长度
int my_strlen1(const char* str)
{
	assert(str);//对str进行断言，如果是空指针报错，不是则什么都不发生
	int count = 0;
	while (*str!='\0')
	{
		count++;
		str++;
	}
	return count;
}
//递归
int my_strlen2(const char* str)
{
	assert(str);//对str进行断言，如果是空指针报错，不是则什么都不发生
	if (*str != '\0')
	{
		return 1 + my_strlen2(str + 1);
	}
	else
		return 0;

}
//指针-指针
int my_strlen3(const char* str)
{
	assert(str);//对str进行断言，如果是空指针报错，不是则什么都不发生
	const char* start = str;
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}
int main()
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d\n", ret);//6
	return 0;
}

要注意:库里面size_t strlen ( const char * str )返回类型是size_t，而上面的模拟返回类型使用的是int，为什么这么用？

#include<stdio.h>
#include<string.h>
int main()
{
	//3-6=-3 但一个size_t类型的值 - 一个size_t类型的值得到的还是size_t类型的值
	//-3作为size_t的类型是一个很大的值
	//所以打印的是 >
	if (strlen("abc") - strlen("abcdef") > 0)
		printf(">\n");
	else
		printf("<\n");
	return 0;
}

所以用int还是size_t要根据实际情况来使用

2.2 模拟实现strcpy

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcpy(char*dest, const char*src)
{
	assert(dest && src);
	char* start = dest;
	while (*dest++ = *src++)//'\0'拷贝到目标空间后为假，循环结束
	{
		;
	}
	return start;
}
int main()
{
	char arr1[] = "xxxxxxxxxxxx";
	char arr2[] = "abcef\0";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);//abcdef
	return 0;
}

2.3 模拟实现strcat

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* start = dest;
	//1.找到'\0'
	while (*dest)
	{
		dest++;
	}
	//2.追加
	while (*dest++ = *src++)
	{
		;
	}
	return start;
}
int main()
{
	char arr1[20] = "hello ";//目标空间要足够
	char arr2[] = "word";
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);//hello word
	return 0;
}

2.4 模拟实现strcmp

#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);

	while (*str1==*str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	/*if (*str1 > *str2)
		return 1;
	else
		return -1;*/
	//有些编译器是直接返回两个数的差值
	return *str1 - *str2;

}
int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcdef";
	//VS环境中
	//> 1
	//= 0
	//< -1
	int ret = my_strcmp(arr1, arr2);
	if (ret > 0)
		printf(">\n");
	else if (ret < 0)
		printf("<\n");
	else
		printf("=\n");
	return 0;
}

2.5 模拟实现strncpy

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strncpy(char* dest,const char* src, int sz)
{
	assert(dest && src);
	char* start = *dest;
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		if (*src != '\0')
			*dest++ = *src++;
		else
			*dest = '\0';
	}
	return start;
}
int main()
{
	char arr[20] = {0};
	my_strncpy(arr, "abcdef", 10);
	printf("%s\n", arr);
	return 0;
}

2.6 模拟实现strncat

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strncat(char* dest, const char* src, int sz)
{
	assert(dest && src);
	char* start = dest;
	//找到'\0'
	while (*dest)
	{
		dest++;
	}
	//追加
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		*dest++ = *src++;
	}
	//补上'\0'
	*dest = '\0';
	return start;
}
int main()
{
	char arr[20] = "abcd";
	my_strncat(arr, "efghjk", 3);
	printf("%s\n", arr);
	return 0;
}

2.7 模拟实现strncmp

#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strncmp(const char* str1, const char* str2, int sz)
{
	assert(str1 && str2);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		if (*str1 == *str2)
		{
			if (*str1 == '\0')
				return 0;
			str1++;
			str2++;
		}
		if (*str1 > *str2)
			return 1;
		if (*str1 < *str2)
			return -1;
	}
}
int main()
{
	char arr1[20] = "abcde";
	char arr2[20] = "abcdq";
	int ret = my_strncmp(arr1, arr2, 6);
	printf("%d\n", ret);
	return 0;
}

2.8 模拟实现strstr

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	if (*str2 == '\0')
	{
		return str1;
	}
	char* s1 = str1;
	char* s2 = str2;
	char* cp = str1;

	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return cp;
		}
		cp++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "abbbcdefg";
	char arr2[] = "bbc";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s\n", ret);//bbcdefg
	}
	return 0;
}

2.9 模拟实现memcpy

#include <stdio.h>
#include <string.h>
#include<assert.h>
char* my_memcpy1(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	char* start = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return start;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	my_memcpy1(arr2, arr1 + 2, 20);//20的单位是字节
	//根据拷贝数据类型进行相应的打印
	return 0;
}

2.10模拟实现memmove

#include <stdio.h>
#include <string.h>
#include<assert.h>
char* my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	char* start = dest;
	if (src > dest)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else if (src < dest)
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return start;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr+2, arr, 20);
	//arr:1 2 1 2 3 4 5 8 9 10
	return 0;
}

2.11模拟实现memcmp

#include <stdio.h>
#include <string.h>
#include<assert.h>
int my_memcmp(const void* str1, const void* str2, size_t num)
{
	assert(str1 && str2);

	while (num--)
	{
		if (*(char*)str1 == *(char*)str2)
		{
			if (*(char*)str2 = '\0')
			{
				return 0;
			}
			str1 = (char*)str1 + 1;
			str2 = (char*)str2 + 1;
			continue;
		}
	}
	return *(char*)str1 - *(char*)str2;
}
int main()
{
	int arr1[] = { 1,2,5 };//01 00 00 00 02 00 00 00 05 00 00 00
	int arr2[] = { 1,2,4 };//01 00 00 00 02 00 00 00 04 00 00 00
	int ret = my_memcmp(arr1, arr2, 9);//9的单位是字节
	printf("%d\n", ret);//1
	return 0;
}
CC小师弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CC小师弟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值