19.字符函数和字符串函数

Flying`

已于 2022-01-23 18:18:29 修改

阅读量849

点赞数 11

分类专栏： C语言学习(bit) 文章标签： c++ c语言

于 2022-01-21 18:09:42 首次发布

本文链接：https://blog.csdn.net/qq_52276036/article/details/122612102

版权

C语言学习(bit) 专栏收录该内容

29 篇文章 2 订阅

订阅专栏

字符函数和字符串函数

函数介绍：

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

函数介绍：

1.strlen函数——计算字符串长度

size_t strlen ( const char * str );

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

2.strcpy函数——字符串复制函数

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

注意事项：
1.源字符串必须以 ‘\0’ 结束。
2.会将源字符串中的 ‘\0’ 拷贝到目标空间。
3.目标空间必须足够大，以确保能存放源字符串。
4.目标空间必须可变。

3.strcat函数——字符串追加函数

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

注意事项：
1.源字符串必须以 ‘\0’ 结束。
2.目标空间必须有足够的大，能容纳下源字符串的内容。
3.目标空间必须可修改。

4.strcmp函数——字符串比较函数

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

标准规则：
1.第一个字符串大于第二个字符串，则返回大于0的数字
2.第一个字符串等于第二个字符串，则返回0
3.第一个字符串小于第二个字符串，则返回小于0的数字

5.strncpy函数——有长度限制的字符串复制函数

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

注意事项：
1.拷贝num个字符从源字符串到目标空间。
2.如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

6.strncat函数——有长度限制的字符串追加函数

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

Appends the first num characters of source to destination, plus a terminating null-character.
If the length of the C string in source is less than num, only the content up to the terminating null-character is copied

7.strncmp函数——有长度限制的字符串比较函数

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

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

8.strstr函数——字符串查找函数

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

Each of these functions returns a pointer to the first occurrence of strCharSet in string, or NULL if strCharSet does not appear in string. If strCharSet points to a string of zero length, the function returns string.

9.strtok函数——字符串分割函数

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

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

实际应用实例：

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

int main()
{
	const char *p = "@.";//sep
	char arr[] = "3020104637@qq.com";//str
	char buf[50] = { 0 };
	strcpy(buf, arr);
	char *str = NULL;
	for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
	{
		printf("%s\n", str);
	}
}

10.strerror函数——字符串报错函数

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

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
	//实例1
	for (int i = 0; i < 10; i++)
	{
		printf("%s\n", strerror(i));
	}
	printf("\n");
	
	//实例2
	FILE *pf = fopen("test.txt", "r");
	if (NULL == pf)//没有读取到文件
	{
		printf("%s\n", strerror(errno));
		//当库函数使用的时候，发生错误会把 errno 这个全局变量的错误变量设置为本次执行库函数产生的错误码
		//errno 时C语言提供的一个全局变量，可以直接使用，存放在errno.h文件中
		return 0;
	}
	return 0;
}

11.memcpy函数——内存复制函数

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

注意事项：
0. size_t 表示字节数
1.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
2.这个函数在遇到 ‘\0’ 的时候并不会停下来。
3.如果source和destination有任何的重叠，复制的结果都是未定义的。

操作实例：

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

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int arr2[10] = { 0 };
	int size = sizeof(arr1[0]);
	memcpy(arr2, arr1+3,5*size);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
}

12.memmove函数——memcpy的升级

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

注意事项：
1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
2.如果源空间和目标空间出现重叠，就得使用memmove函数处理。
操作实例：

//memcpy函数的操作
#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int size = sizeof(arr1[0]);
	memmove(arr1, arr1+3,5*size);
	for (int i = 0; i < 9; i++)
	{
		printf("%d ", arr1[i]);
	}
}

运行结果：
在这里插入图片描述

13.memcmp函数——逐个字节的比较

int memcmp ( const void * ptr1, const void * ptr2, size_t num );
比较从ptr1和ptr2指针开始的num个字节

14.memset函数——逐个字节设置内存

**void memset( void dest, int c, size_t count );

将内存dest 开始的 count 个字节设置成 c；

应用实例：
在这里插入图片描述
原因分析：

15.字符分类函数——头文件为 #include<ctype.h>

在这里插入图片描述
应用实例：

#include<stdio.h>
#include<ctype.h>
int main()
{
	char ch = '0';
	if (isdigit(ch))//判断是否为0~9的数字
	{
		printf("该字符是0~9的数字\n");
	}
	else
	{
		printf("该字符不是0~9的数字\n");
	}
	return 0;
}

库函数的模拟实现：

1.strlen函数模拟实现

#include<stdio.h>
#include<assert.h>
int my_strlen(const char* str)
{
  assert(str);
	int count = 0;
	while (*str)
	{
		str++;
		count++;
	}
	return count;
}

int main()
{
	char ch[20] = { 0 };
	printf("请输入一个字符串:");
	scanf("%s", ch);
	int len = my_strlen(ch);
	printf("字符串长度为：%d\n", len);
	return 0;
}

2.strcpy函数模拟实现

#include<stdio.h>
#include<assert.h>
void *my_memcpy(void *dest, const void *src, size_t count)
{
	arrert(dest&&src);
	void *ret = dest;
	while (count--)
	{
		*((char*)dest) = *((char*)src);
		((char*)dest)++;
		((char*)src)++;
	}
	return ret;
}


int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int arr2[10] = { 0 };
	int size = sizeof(arr1[0]);
	my_memcpy(arr2, arr1+3,5*size);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

3.strcmp函数模拟实现

#include<stdio.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++;
	}
	return (*str1 - *str2);
}
int main()
{
	char str1[20] = { 0 };
	char str2[20] = { 0 };
	printf("请输入str1：");
	scanf("%s", str1);
	printf("请输入str2：");
	scanf("%s", str2);
	int ret = my_strcmp(str1, str2);
	if (ret > 0)
		printf("str1 > str2\n");
	else if (ret < 0)
		printf("str1 < str2\n");
	else
		printf("str1 = str2\n");
}

4.strcat函数模拟实现

#include<stdio.h>
#include<assert.h>
//将source字符串接在dest后面
char *my_strcat(char *dest, const char *source)
{
	assert(dest&&source);
	char *ret = dest;
	while (*dest != '\0')
	{
		dest++;
	}
	while (*dest++=*source++)
	{
		;
	}
	return ret;
}

int main()
{
	char str1[20] = { 0 };
	char str2[20] = { 0 };
	printf("请输入str1：");
	scanf("%s", str1);
	printf("请输入str2：");
	scanf("%s", str2);
	my_strcat(str1, str2);
	printf("%s\n", str1);
	return 0;
}

5.strstr函数模拟实现

#include<stdio.h>
#include<assert.h>
char * my_strstr(const char *str, const char *substr)//在str1中查找str2
{
	assert(str&&substr);
	const char *s1 = str;
	const char *s2 = substr;
	const char *cur = str;
	if (*substr == '\0')
	{
		return (char*)str;
	}
	while (*s1)
	{
		s1 = cur;
		s2 = substr;
		while (*s1 == *s2 && *s1 && *s2)
		{
			s1++;
			s2++;
			if (*s2 == '\0')
			{
				return (char*)cur;
			}
		}
		cur++;
	}
	return NULL;
}

int main()
{
	char str1[20] = { 0 };
	char str2[20] = { 0 };
	printf("请输入str1：");
	scanf("%s", str1);
	printf("请输入str2：");
	scanf("%s", str2);
	char *ret=my_strstr(str1, str2);
	if (ret == NULL)
	{
		printf("没有找到！\n");
	}
	else
	    printf("%s\n", ret);
}

6.memcpy函数的模拟实现

不·考虑内存重叠的情况

#include<stdio.h>
#include<assert.h>
void *my_memcpy(void *dest, const void *src, size_t count)
{
	assert(dest&&src);
	void *ret = dest;
	while (count--)
	{
		*((char*)dest) = *((char*)src);
		((char*)dest)++;
		((char*)src)++;
	}
	return ret;
}


int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int arr2[10] = { 0 };
	int size = sizeof(arr1[0]);
	my_memcpy(arr2, arr1+3,5*size);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

7.memmove函数的模拟实现

考虑内存重叠的情况

情况1：dest > src

复制方法：从前向后

情况2：dest <=src

复制方式：从后向前

在这里插入图片描述

//memmove 的模拟实现
#include<stdio.h>
#include<assert.h>
void *my_memcpy(void *dest, const void *src, size_t count)
{
    void *ret = dest;
	assert(dest&&src);
	if (dest < src)
	{
		for (size_t i = 0; i < count; i++)
		{
			*(char*)dest = *(char*)src;
			((char*)dest)++;
			((char*)src)++;
		}
	}
	else
	{
		(char*)dest = (char*)dest + count;
		(char*)src = (char*)src + count;
		for (size_t i = 0; i < count; i++)
		{
			*(char*)dest = *(char*)src;
			((char*)dest)--;
			((char*)src)--;
		}
	}
	return ret;
}

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int arr2[10] = { 0 };
	int size = sizeof(arr1[0]);
	my_memcpy(arr2, arr1+3,5*size);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

Flying`

关注

11
点赞
踩
3

收藏

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

前言：C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。字符串常量适用于那些对它不做修改的字符串函数.函数介绍：1.strlen函数——计算字符串长度size_t strlen ( const char * str );注意事项：1.字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。2.参数指向的字符串必须要以 ‘\0’ 结束。3.注意函数的返回.
复制链接

扫一扫