C语言中，这些字符函数和字符串函数你了解吗？

于 2023-02-19 23:51:55 发布
阅读量105 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyx_bc/article/details/129061576
版权

字符函数和字符串函数

函数介绍

本篇重点：
介绍常见的字符函数和字符串函数

  • 求字符串长度
    strlen
  • 长度不受限制的字符串函数
    strcpy
    strcat
    strcmp
  • 长度受限制的字符串函数介绍
    strncpy
    strncat
    strncmp
  • 字符串查找
    strstr
    strtok
  • 错误信息报告
    strerror
  • 字符操作
  • 内存操作函数
    memcpy
    memmove
    memset
    memcmp

1.求字符串长度函数strlen

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

头文件：#include<string.h>

size_t strlen ( const char * str );

int main()
{
	char arr[] = "hello world";
	size_t ret = strlen(arr);
	printf("%u", ret);
	return 0;
}

注意返回的是size_t类型

#include <stdio.h>
int main()
{
 const char*str1 = "abcdef";
 const char*str2 = "bbb";
 if(strlen(str2)-strlen(str1)>0)//size_t-size_t=size_t,即结果是正数
 {
 printf("str2>str1\n");//正确
 } 
 else
 {
 printf("srt1>str2\n");
 }
 return 0;
}

模拟实现（3种）：

size_t my_strlen(const char* str)
{
  assert(str);
	size_t count = 0;
	while (*str != '\0')
	{
		str++;
		count++;
	}
	return count;
}
size_t my_strlen(const char* str)
{
  assert(str);
	if (*str != '\0')
		return 1 + my_strlen(str+1);
	else
		return 0;
}
size_t my_strlen(const char* str)
{
	assert(str);
	char* sta = str;
	while (*str)
	{
		str++;
	}
	return str - sta;

}

2.长度不受限制的字符串函数

头文件：#include<string.h>

2.1字符串拷贝函数strcpy函数

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

使用：

int main()
{
	char arr1[] = "**************";
	char arr2[6] = "hello";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

模拟实现：

char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	char* p = dest;
	while (*dest++ = *src++)
	{
		;
	}
	return p;
}

2.2字符串连接函数strcat函数

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

使用：

int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

如果自己连接自己呢？
程序会崩掉
模拟实现：

char* my_strcat(char* dest, const char* src)
{
	char* p = dest;
	assert(dest && src);
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return p;
}

2.3字符串内容比较函数strcmp函数

int strcmp ( const char * str1, const char * str2 );
  • 第一个字符串大于第二个字符串，则返回大于0的数字
  • 第一个字符串等于第二个字符串，则返回0
  • 第一个字符串小于第二个字符串，则返回小于0的数字

使用：

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abq";
	int ret=strcmp(arr1, arr2);
	printf("%d", ret);//-1
	return 0;
}

模拟实现：

int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
			return 0;
		s1++;
		s2++;
	}
	return *s1 - *s2;
}

3.长度受限制的字符串函数

头文件：#include<string.h>

3.1有限制的字符串拷贝函数strncpy

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

使用：

int main()
{
	char arr1[] = "********************";
	char arr2[] = "hello world";
	strncpy(arr1, arr2, 5);
	printf("%s\n", arr1);
	return 0;
}

3.2有限制的字符串连接函数strncat

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

使用：

int main()
{
	char arr1[20] = "*****";
	char arr2[] = "wooo";
	strncat(arr1, arr2, 1);
	printf("%s\n", arr1);
	return 0;
}

3.3有限制的字符串比较函数strncmp

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

使用：

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

4.字符串查找函数和字符串切割函数

头文件：#include<string.h>

4.1字符串查找函数strstr

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

返回的地址是在str1中与str2匹配的第一个地址

使用：

int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	char * p=strstr(arr1, arr2);
	printf("%s\n", p);
	return 0;
}


int main()
{
	char str[] = "This is a simple string";
	char* pch;
	pch = strstr(str, "simple");
	strncpy(pch, "sample", 6);
	puts(str);
	return 0;
}

模拟实现：

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

4.2字符串切割函数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 指针。

使用：

int main()
{
	char arr[] = "qwer@12345.ooo.999";
	char* p = "@.";
	char* ret = strtok(arr, p);
	printf("%s\n", ret);
	ret = strtok(NULL, p);
	printf("%s\n", ret);
	ret = strtok(NULL, p);
	printf("%s\n", ret);
	ret = strtok(NULL, p);
	printf("%s\n", ret);
	return 0;
}

int main()
{
	char arr[] = "qwer@12345.ooo.999";
	char* p = "@.";
	char* ret = NULL;
	for (ret = strtok(arr, p); ret != NULL; ret=strtok(NULL, p))
	{
		printf("%s\n", ret);
	}
	return 0;
}

5.错误信息报告函数

5.1strerror函数

头文件#include<string.h>,#include<errno.h>

char * strerror ( int errnum );

C语言中的库函数使用出现错误时，会有一个错误码，这个错误码就在errno中，而strerror函数就是将错误码转化为字符串；
使用：

int main()
{
	FILE* p = fopen("text.txt", "r");
	if (p == NULL)
	{
		printf("%s", strerror(errno));
		return 1;
	}
	fclose(p);
	return 0;
}

结果：No such file or directory

5.2perror

头文件：#include<stdio.h>

perror==printf+strerror，先打印自定义的字符串再打印错误字符串

int main()
{
	FILE* p = fopen("text.txt", "r");
	if (p == NULL)
	{
		perror("open");
		return 1;
	}
	fclose(p);
	return 0;
}

结果：open: No such file or directory

6.字符分类函数

头文件：#include<ctype.h>

在这里插入图片描述
在这里插入图片描述
字符转换函数：
在这里插入图片描述
在这里插入图片描述

7.内存操作函数

7.1内存拷贝函数memcpy函数

头文件：#include<string.h>

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

使用：

#include<string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10];
	memcpy(arr2, arr1 + 1, 16);//注意第三个参数是拷贝字节数
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

运行结果：2 3 4 5

模拟实现：

#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* p = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;
		++(char*)src;
	}
	return p;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10];
	my_memcpy(arr2, arr1 + 1, 16);
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

7.2内存拷贝函数memmove函数

头文件：#include<string.h>

既然都是内存拷贝函数，那么memcpy和memmove有什么区别呢？

#include<string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	memcpy(arr1+1, arr1 , 16);
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", arr1[i]);
	}

	return 0;
}

这段代码是拷贝不成功的，虽然我们在vs上是可以实现的但是原始的memcpy是不能实现的，即在vs上对strcpy进行了优化；
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

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

使用：

#include<string.h>
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1+2, arr1 , 16);
	int i = 0;
	for (i = 0; i < 6; i++)
	{
		printf("%d ", arr1[i]);
	}

	return 0;
}

在这里插入图片描述
实现：

#include<assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);
	void* p = dest;
	if (dest < src)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			++(char*)dest;
			++(char*)src;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}

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

	return 0;
}

逻辑：
在这里插入图片描述

在这里插入图片描述

7.3内存比较函数memcmp

头文件：#include<string.h>

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

使用：

#include <stdio.h>
#include <string.h>
int main ()
{
  char buffer1[] = "DWgaOtP12df0";
  char buffer2[] = "DWGAOTP12DF0";
  int n;
  n=memcmp ( buffer1, buffer2, sizeof(buffer1) );
  if (n>0) printf ("'%s' is greater than '%s'.\n",buffer1,buffer2);
  else if (n<0) printf ("'%s' is less than '%s'.\n",buffer1,buffer2);
  else printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);
  return 0;
}

7.4内存初始化函数memset函数

头文件：#include<string.h>
memset(首地址,初始化内容,初始化多少字节);
使用：

#include<string.h>
int main()
{
	char arr[] = "abcdefg";
	memset(arr, 'x', 3);
	printf(arr);
	return 0;
}

在这里插入图片描述

总结：

以上就是本篇的所有内容啦，如果喜欢本篇不妨留下你的足迹，如果想要了解更多，那就关注我吧！

梦呓dream
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值