字符函数和字符串函数

最新推荐文章于 2024-06-11 05:40:28 发布

《黑巧克力》

最新推荐文章于 2024-06-11 05:40:28 发布

阅读量186

点赞数 30

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

本文链接：https://blog.csdn.net/HD_13/article/details/133186017

版权

C语言专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.前言

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

2.函数介绍

2.1strlen

size_t strlen ( const char * str )

字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
参数指向的字符串必须要以 ‘\0’ 结束。
注意函数的返回值为size_t，是无符号的（易错）
学会strlen函数的模拟实现
strlen函数的模拟实现
1.通过计数器来模拟实现strlen函数

size_t My_strlen(char* p)
{
	//计数器
	int count = 0;
	//计\0之前的数
	while (*p != '\0')
	{
		*p++;
		count++;
	}
	return count;
}
int main()
{
char str[20] = { "abcdef" };
	size_t ret=My_strlen(str);
	printf("%zd", ret);
	return 0;
}

2.通过指针来模拟实现strlen函数

size_t My_strlen(char* p)
{
	//定义一个中间变量来存储字符串数组的首元素地址
	char* start = p;
	while (*p != '\0')
	{
		*p++;
	}
	return p - start;//此时的p是\0之前最后的一个指针
}
int main()
{
	char str[20] = { "abcdef" };
	size_t ret=My_strlen(str);
	printf("%zd", ret);
	return 0;

}

2.2strcpy

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

Copies the C string pointed by source into the array pointed by destination, including the
terminating null character (and stopping at that point).
源字符串必须以 ‘\0’ 结束。
会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。
学会模拟实现。
strcpy函数的模拟实现

用指针模拟实现strcpy函数
#include<assert.h>
char* My_strcpy(char* dest, const char* src)
{
	//dest一直在改变，所以我们用一个变量先存储dest
	//因为这个函数返回的就是起始地址
	char* ret = dest;
	assert(dest && src);//源字符串和目标字符串的地址不能是空指针
	while (*dest++ = *src++)
	{
		;
	}
	return ret;//返回的是目标地址
}
int main()
{
	char str1[20] = { 0 };
	char str2[10] = { "abcdef" };
	My_strcpy(str1, str2);
	printf("%s", str1);
	return 0;
}

2.3strcat函数

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

源字符串必须以 ‘\0’ 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
字符串自己给自己追加，如何？
模拟实现strcat函数

自己模拟实现strcat库函数实现
返回的是目标字符串的起始地址
#include<assert.h>
char* My_strcat(char* dest,const char* src)
{
	//用一个变量start来存储目标字符串的起始地址
	char* start = dest;
	//先找到dest字符串的\0
	while (*dest != '\0')
	{
		*dest++;
	}
	assert(dest && src);//断言，dest指针和src指针不是空指针
	//将源字符串的第一个字符替换目标字符串的\0并且源字符串的字符全部都放在目标字符串之后包括源字符串的\0。
	while (*dest++ = *src++)
	{
		;
	}
	return start;
}
int main()
{
	char str1[20] = "abc";
	char str2[5] = "defg";
	My_strcat(str1, str2);
	printf("%s", str1);
	return 0;
}

2.4strcmp函数

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

第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
模拟实现strcmp函数

自己模拟实现strcmp函数
int My_strcmp(const char* str1,const char* str2)
{
	while (*++str1 == *++str2)
	{
		//因为在while循环中如果str1字符串和str2字符串相同，那么当*str1指向\0和*str2指向\0的时候这个循环的判断也是为真，所以可以进入这个循环体中
		//但是只有一个字符串指向\0，另一个字符串不指向\0，那么这个的循环判断条件为假，会跳出这个循环，那么两个字符串都指向\0的时候说明这个两个字符串相等，
		//所以最后只要判断其中一个字符串是否指向\0就可以判断出这个两个字符串是否相等了
		if (*str1 == '\0')
		{
			return 0;
		}
		/*str1++;
		str2++;*/
	}
	//if (*str1 > *str2)
	//{
	//	return 1;
	//}
	//else
	//{
	//	return -1;
	//}
	//改成
	return *str1 - *str2;
}
int main()
{
	char str1[10] = "abcdef";
	char str2[10] = "abcg";
	if (My_strcmp(str1, str2) > 0)
	{
		printf(">");
	}	
	else
	{
		printf("<=");
	}
	return 0;
}

2.5strncpy函数

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

拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
自己模拟实现一个strncpy函数

自己模拟实现strncpy函数
参数  3个
目标字符串的地址
源字符串的地址
需要复制几个字符数量的地址
返回值是目标字符串的初始地址
返回类型是char*
拷贝num个字符从源字符串到目标空间，如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个
sz是源字符串的长度
#include<assert.h>
char* My_strncpy(char* dest, const char* src, size_t num,size_t sz)
{
	//用一个变量start来存储目标字符串的起始地址
	char* start = dest;
	assert(dest && src);//断言，dest指针和src指针不是空指针
	//如果num<=sz
	if (num <= sz)
	{
		size_t i = 0;
		for (i = 0; i <num; i++)
		{
			*dest++ = *src++;
		}
	}
	//如果num>sz,则拷贝完源字符串之后，在目标的后边追加\0，直到num个
	else
	{
		size_t i = 0;
		for (i = 0; i < num; i++)
		{
			if (i < sz)
			{
				*dest++ = *src++;
			}
			else
			{
				*dest++ = '\0';
			}
		}
	}
	return start;
}
int main()
{
	char str1[20] = "****************";
	char str2[] = "abcdefg";
	//求str2数组的长度
	size_t sz = sizeof(str2) / sizeof(str2[0]);
	size_t n = 0;
	printf("请输入要复制几个字符:>\n");
	scanf("%zd", &n);
	My_strncpy(str1, str2, n,sz);
	printf("%s\n", str1);
	return 0;

}

2.6strncat函数

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

自己模拟实现一个strncat函数

模拟实现strncat函数
返回的值还是目标字符串的起始地址
#include<assert.h>
char* My_strncat(char* dest, const char* src, size_t num)
{
	先用一个变量存储目标字符串的起始地址
	char* start = dest;
	先让dest指向\0
	while (*dest != '\0')
	{
		dest++;
	}
	需要追加几个字符就循环几次
	size_t i = 0;
	断言一下，dest和src不是空指针
	assert(dest && src);
	for (i = 0; i < num; i++)
	{
		*dest++ = *src++;
	}
	返回目标字符串的起始地址
	return start;
}
int main()
{
	char str1[20] = "abc";
	char str2[15] = "defghijk";
	size_t n = 0;
	printf("请输入要追加几个字符:>\n");
	scanf("%zd", &n);
	My_strncat(str1, str2, n);
	printf("%s", str1);
	return 0;
}

2.7strncmp函数

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

strncmp库函数的使用

strncmp函数
int strncmp ( const char * str1, const char * str2, size_t num );
strncmp函数的使用
#include<string.h>
int main()
{
	char str1[20] = "abcdefg";
	char str2[10] = "abcz";
	int ret = strncmp(str1, str2, 4);
	printf("%d", ret);
	return 0;
}

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
2.8strstr函数

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

自己模拟实现一个strstr函数

#include<assert.h>
const char* My_strstr(const char* str1, const char* str2)
{
	const char* s1;//遍历str1指向的字符串
	const char* s2;//遍历str2指向的字符串
	const char* cp;//记录开始匹备的位置，cp指针是一个标志，返回的时候就返回cp这个指针
	//断言 *str1和*str2不能为空指针
	assert(str1 && str2);
	//特殊情况
	if (*str2 == '\0')//如果要找一个空的字符串，就直接返回str1字符串
	{
		return str1;
	}
	cp = str1;//将str1的指针位置赋值给cp指针
	while (*cp)//如果*cp指向\0，那么说明在str1中找不到str2，则返回NULL指针
	{
		s1 = cp;
		s2 = str2;
		//如果*s1一直向后遍历到\0,\0的ASCII码值为0，则为假跳出这个循环 并且在str1字符串里找不到字符串str2
		//如果*s2一直向后遍历到\0，\0的ASCII码值为0，则为假跳出这个循环 说明字符串str2这个字符串已经遍历完了
		//如果*s1!=*s2，说明这个循环判断条件为假，也跳出这个循环
		while (*s1 == *s2 && *s1 && *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return cp;
		}
		cp++;
	}
	return NULL;
}
int main()
{
	char str1[] = "acccdefg";
	char str2[] = "ccd";
	const char* ret = My_strstr(str1, str2);
	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s", ret);
	}
	return 0;
}

2.9strtok函数

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

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

char * strerror ( int errnum );

返回错误码，所对应的错误信息。

字符函数

3.1字符分类函数：

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

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

4.内存函数

4.1memcpy函数

void * memcpy ( void * destination, const void * source, size_t num );

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 ‘\0’ 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的
自己模拟实现memcpy函数

模拟实现memcpy函数
#include<assert.h>
void* My_memcpy(void* dest, const void* src, size_t num)
{
	//断言
	assert(dest && src);
	//用一个变量存储dest的起始地址
	void* start = dest;
	//一个一个字节去复制
	while (num--)
	{
		*(char*)dest = *(char*)src;//将src的一个字节复制给dest中
		dest=(char*)dest + 1;//将dest向后移动一个字节
		src = (char*)src + 1;//将src向后移动一个字节
	}
	return start;
}
void print(int arr1[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);
	}
}
int main()
{
	int arr1[10] = { 0 };
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	int arr2[] = { 1,2,3,4,5 };
	My_memcpy(arr1, arr2, 20);
	//打印函数
	print(arr1, sz);
	return 0;
}

4.2memmove函数

void * memmove ( void * destination, const void * source, size_t num );

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。
自己模拟实现memmove函数

模拟实现menmove函数
分两种情况
1.dest<src------->前到后复制
2.dest>src&&dest<(char*)src+20------->后到前复制
#include<assert.h>
void* My_memmove(void* dest, const void* src, size_t num)
{
	void* start = dest;
	//断言
	assert(dest && src);
	if (dest < src)
	{
		//前->后
	//	01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 08 00 00 00 09 00 00 00 0a 00 00 00
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后->前
		/*while (num)
		{
			*((char*)dest + num - 1) = *((char*)src + num - 1);
			num--;
		}*/
		//优化一下
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return start;
}
int main()
{
	int num = 0;
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("请输入你要复制多少字节:>\n");
	scanf("%d", &num);
	My_memmove(arr+2, arr, num);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

4.3memcmp函数

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

比较从ptr1和ptr2指针开始的num个字节

《黑巧克力》

关注

30
点赞
踩
24

收藏

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

2.1strlen字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。参数指向的字符串必须要以 ‘\0’ 结束。注意函数的返回值为size_t，是无符号的（易错）学会strlen函数的模拟实现strlen函数的模拟实现1.通过计数器来模拟实现strlen函数//计数器//计\0之前的数while (*p!count++;
复制链接

扫一扫