C语言篇 + 字符串处理函数和内存函数的介绍及模拟实现(避开你的语法坑,请注意查收)

Posted IT莫扎特

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C语言篇 + 字符串处理函数和内存函数的介绍及模拟实现(避开你的语法坑,请注意查收)相关的知识,希望对你有一定的参考价值。


前言

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

C语言的库函数分类

  • IO函数 prntf、scanf

    字符函数

    字符串函数

    内存函数

    时间日期函数

    数学函数

重点会讲解常用的,本次的内容主要在介绍内存函数和字符串函数

求字符串长度

strlen

  • 字符串已经 ‘\\0’ 作为结束标志,strlen函数返回的是在字符串中 ‘\\0’ 前面出现的字符个数(不包含 ‘\\0’ )。

    参数指向的字符串必须要以 ‘\\0’ 结束。

    注意函数的返回值为size_t,是无符号的( 易错 )

    学会strlen函数的模拟实现

char arr[] = "hello Mozart";
size_t len = strlen()

strlen的一些小细节

void functest() 
{
	char arr1[] = "abdc";
	char arr2[] = "abdef";

	if (strlen(arr1) - strlen(arr2) > 0) 
	{
		printf("hehe\\n");
	}
	else
	{
		printf("haha\\n");
	}
}

会打印hehe,因为返回值类型是size_t,是一个无符号类型的结果,(并不会存在负数),当然强制类型转换就会得到一个有符号类型的结果(存在负数)

void functest() 
{
	char arr1[] = "abdc";
	char arr2[] = "abdde";

	if ((int)strlen(arr1) - (int)strlen(arr2) > 0) 
	{
		printf("hehe\\n");
	}
	else
	{
		printf("haha\\n");
	}
}

strlen函数的模拟实现

非递归写法

//非递归写法
int my_strlen(char* str)
 {
 	int count = 0;
 	while('\\0' != *str)
 	{
 		count++;
 		str++;
 	}
 	return count;
 }

递归写法

//递归写法
nt my_strlen(char *str)
{
	if('\\0' == *str)
		return 0;
	else
		return 1+my_strlen(1+str);
}

指针相减法

int my_strlen(char* str)
 {
 	char *dest = str;
	while(*dest++)
 	{
 		;
 	}
 	//除去‘\\0’
 	return dest - str - 1;
 }

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

strcpy


使用时注意事项

  • 源字符串必须以 ‘\\0’ 结束。

    会将源字符串中的 ‘\\0’ 拷贝到目标空间。

    目标空间必须足够大,以确保能存放源字符串。

    目标空间必须可变。

    学会模拟实现。

举例1、

void functest() 
{
	char arr1[] = "xxxxxxxxxxxx";
	char arr2[] = "abcd";

	strcpy(arr1,arr2);
	printf("%s ",arr1);
}

会将字符串的结束标记 ’ \\0’也给拷贝进去,直到遇到 ’ \\0 ',strcpy的工作也就结束了

举例2、

目标空间足够大

依然是使用原来的代码,方便大家理解,在这里可以看到要想将arr2的内容拷贝至arr1,arr1的空间必须足够大,实际上并没有给出一块合适的空间来预存arr2的内容,那么后果也是可想而知

void functest() 
{
	char arr1[] = "xxx";
	char arr2[] = "abcd";

	strcpy(arr1,arr2);//err
	printf("%s ",arr1);
}

举例3、

目标空间必须可变,在学习指针的时候还记得字符指针用来存放字符首地址吗
char *ptr = "hello Mozart"
为了保护字符串习惯于在前面加const
const char *ptr = "hello Mozart"

代码可不能这样写哦,受const保护的字符串是不允许被修改的

void functest() 
{
	const char* ptr1 = "xxxxxxx";
	char* ptr2 = "abc";
	strcpy(ptr1,ptr2);//err
	printf("%s ",ptr1);
}

strcpy模拟实现

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

strcat

又叫字符串链接和字符串追加

  • 源字符串必须以 ‘\\0’ 结束。

    目标空间必须有足够的大,能容纳下源字符串的内容。

    目标空间必须可修改。

    字符串自己给自己追加,如何?

    使用示范

void func3()
{
	char arr[20] = "abcdef";
	//char arr[] = "abcdef";  err,空间不够
	strcat(arr,"def");
	printf("%s ",arr);
}

int main() 
{
	func3();
	return 0;
}

如果你在使用strcat的时候遇到过这种情况,只需要在程序最开始的位置处加一个宏定义



错误示范

void func3()
{
	char arr1[20] = "abcdef";
	char arr2[20] = {'a','b','c'}; //字符数组末尾没加‘\\0’
	strcat(arr1, arr2);
	printf("%s ",arr1);
}

int main() 
{
	func3();
	char arr;
	scanf("%s ",&arr);
	return 0;
}

当想将一个字符数组arr2的内容追加到另外一个字符数组arr1中去,strcat是遇到 ‘\\0’ 才会停止追加字符的,而arr2中并未出现
‘\\0’,由于在内存中‘\\0’的出现时机并不是很明确,可能在‘\\0’还未出现之前,追加过去的字符内容就已经足以导致arr1越界了,可能存在越界,但是程序是明显崩了,这一点请务必注意

模拟实现strcat

整体思路就是找到源字符串的末尾位置,存放‘\\0’的位置处,从这里开始将待追加字符串全部拷贝过去

char * my_strcat(char *s1, const char * s2)
{
	//防止对空指针解引用
	assert(s1 && s2);
	char *dest = s1;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *s2++)
	{
		;
	}
	// strcat返回的是目标空间的起始地址
	return s1;
}

strcmp

是比较字符串的内容(Ascii码值),并不是比较长度

  • 标准规定:

    第一个字符串大于第二个字符串,则返回大于0的数字

    第一个字符串等于第二个字符串,则返回0

    第一个字符串小于第二个字符串,则返回小于0的数字

    那么如何判断两个字符串?

可以通过strcmp的返回值来比较字符串的大小

void func3()
{
	char arr1[] = "abdc";
	char arr2[] = "abdc";
	int ret = strcmp(arr1,arr2);
	if (ret > 0)
		printf(">\\n");
	else if (ret == 0)
		printf("==\\n");
	else
		printf("<\\n");
}

模拟实现strcmp

//模拟实现strcmp
int my_strcmp(const char *s1, const char * s2)
{
   //防止对空指针解引用
	assert(s1 && s2);

	while (*s1 == *s2)
	{
		if (!(*s1))
			return 0;
		++s1;
		++s2;
	}
	return *s1 - *s2;
}

长度受限制的字符串函数介绍

相对于上面的函数使用起来会更安全,但是功能上是一样的

strncpy

  • 拷贝num个字符从源字符串到目标空间。

    如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后边追加0,直到num个

void func3()
{
	char arr1[12] = "abdc";
	char arr2[] = "abdc";
	strncpy(arr1,"xxxxxxxxxxx",11);
	printf("%s ",arr1);
}

源字符串的长度刚好等于num

当源字符串的长度刚好小于num,在字符串后面补0

strncat

  • 将源的第一个num字符附加到目标,再加上一个结束的空字符。

    如果source中的C字符串长度小于num,则只复制到终止空字符’\\0’之前的内容

可以指定追加num个字符

void func3()
{
	char arr1[] = "abcd\\0xxxxxxxxxx";
	char arr2[] = "defg";
	strncat(arr1, arr2,3);
	printf("%s ",arr1);
}

可以看出是在目标字符串的‘\\0’位置开始追加3个字符,末尾自动补‘\\0’

strncmp

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

指定比较两个字符串出现的前num个字符

void func3()
{
	char arr1[] = "abcdxxxxxxxxxx";
	char arr2[] = "abcd";
	//比较字符串的内容
	if(!strncmp(arr1, arr2, 4))
		printf("相等\\n");
	else
		printf("不相等\\n");

}

字符串查找

strstr

  • 返回一个指向str1中第一次出现的str2的指针,如果str2不是str1的一部分,则返回一个空指针。
void func3()
{
	char arr1[] = "abcdxxxxxxxxxx";
	char *ret = strstr(arr1,"abcd");
	if (ret == NULL)
		printf("找不到");
	else
	//找到了就打印该字符串
		printf("%s ", ret);

}

模拟实现

基本思路:备份两个字符串的起始地址,s1表示字符串的首地址,s2表示子串的首地址,
1、s1和s2同时走的情况,*s1 == *s2
2、如果 * s1 != * s2,那么cp++,因为前一个字符都已经不相等了,就可以从后面的字符中开始找字串
3、s1找着找着中途不与s2相等了,那么s1回到它的开始处查找(cp的位置),而s2依然是从它的起始位置开始,s1和s2继续比较

char *my_strstr(const char *str1, const char *str2)
{
	assert(str1 && str2);
	char *cp = str1, *s1 ,*s2;
	while (*cp) 
	{
		//cp记录str1起始位置
		s1 = cp;
		//s2记录sr2的起始位置
		s2 = str2;
		while (*s1 != '\\0' && *s2 != '\\0' && *s1 == *s2) 
		{
			s1++;
			s2++;
		}
		//找到的情况
		if (*s2 == '\\0')
			return cp;
		//如果没有找到cp++
		cp++;
	}
	return NULL;
}

比较的好的情况

不好的情况

strtok

  • sep参数是个字符串,定义了用作分隔符的字符集合

    第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

    strtok函数找到str中的下一个标记,并将其用 \\0 结尾,返回一个指向这个标记的指针。(注:strtok函数会改
    变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。)

    strtok函数的第一个参数不为 NULL ,函数将找到str中第一个标记,strtok函数将保存它在字符串中的位置。

    strtok函数的第一个参数为 NULL ,函数将在同一个字符串中被保存的位置开始,查找下一个标记。

    如果字符串中不存在更多的标记,则返回 NULL 指针

int main()
{
	char arr1[] = "CSDN@IT莫扎特.Mozart";
	char arr2[40] = { 0 };
	// 临时拷贝的内容
	strcpy(arr2,arr1);
	//用作分隔符的字符集合
	char tmp[] = "@.";
	
	for (char *ret = strtok(arr2, tmp); ret != NULL; ret = strtok(NULL, tmp))
	{
	//打印返回的字符串
		printf("%s \\n",ret);
	}
}

使用效果还是很明显的

希望我梳理的流程图对你有所帮助

错误信息报告

strerror

解释errnum的值,生成一个带有描述错误条件的消息的字符串,就像被库的函数设置为errno一样。
返回的指针指向一个静态分配的字符串,程序不能修改该字符串。对这个函数的进一步调用可能会覆盖它的内容(不需要特定的库实现来避免数据竞争)。
strerror产生的错误字符串可能是特定于每个系统和库实现的。

c语言会将库函数的错误信息存放到errnum
这个变量当中,每个错误码都会有一条它的具体信息,strerror可以返回c语言错误码对应的信息,

以下举得几个例子就当对这个函数的了解,有兴趣可以自己去研究研究

	printf("%s \\n", strerror(0));
	printf("%s \\n", strerror(1));
	printf("%s \\n", strerror(2));
	printf("%s \\n", strerror(3));

int main()
{
	 FILE *pf = fopen("test.txt","r");
	 if(pf == NULL)
	 {
	 	printf("%s \\n",strerror(errno));
	 	写成下面这个函数也是可以
	 	//perror("错误信息:\\n");
	 }
	 else
	 {
	 	printf("文件打开成功\\n");
	 }
	 
	return 0;
}
 

内存操作函数

memcpy


官方文档

  • 将num字节的值从source所指向的位置直接复制到destination所指向的内存块。

    源指针和目标指针所指向的对象的底层类型与此函数无关;结果是数据的二进制副本。

    该函数不检查source中是否有任何终止的空字符——它总是精确地复制num字节。

    为了避免溢出,目标和源参数所指向的数组的大小必须至少为num字节,并且不能重叠(对于重叠的内存块,memmove是一种更安全的方法)。

C语言中文网解读

memcpy() 用来复制内存,其原型为:
void * memcpy ( void * dest, const void * src, size_t num );

memcpy() 会复制 src 所指的内存内容的前 num 个字节到 dest 所指的内存地址上。

memcpy() 并不关心被复制的数据类型,只是逐字节地进行复制,这给函数的使用带来了很大的灵活性,可以面向任何数据类型进行复制。

需要注意的是: dest 指针要分配足够的空间,也即大于等于 num 字节的空间。如果没有分配空间,会出现断错误。 dest 和 src
所指的内存空间不能重叠(如果发生了重叠,使用 memmove() 会更加安全)。
稍后再来解决memcpy函数内存重叠的问题

与 strcpy() 不同的是,memcpy() 会完整的复制 num 个字节,不会因为遇到“\\0”而结束。

【返回值】返回指向 dest 的指针。注意返回的指针类型是 void,使用时一般要进行强制类型转换。

举例使用

将一个数组中的内容拷贝到另一个数组中去

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

模拟实现

思路:
原数组拷贝到目标数组中,拷贝的是数据,而数据又分类型,为了更方便的达到实现的目的,将使用一个字节一个字节地拷贝

一个字节一个字节拷贝

void * my_memcpy(void * dest, const void * src, size_t num)
{
	assert(dest && src);
	void * tmp = dest;
	while (num--) 
	{
		//一个字节拷贝
		*(char *)dest C语言进阶—— 字符操作函数+内存操作函数详解  (吐血爆肝 !!!)

超详细的C进阶教程!字符串及内存函数的使用及其模拟实现

C语言篇 + 内存管理及柔性数组话题

C语言进阶:字符串和内存函数

C语言中memcpymemmove等内存函数的介绍

c语言深入浅出,玩爆常见字符串,内存操作库函数(爆肝最长时间之作)