C语言篇 + 字符串处理函数和内存函数的介绍及模拟实现(避开你的语法坑，请注意查收)_void logfunctemp(const std string text)(1)

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

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 = \*(char \*)src;
		//dest指向下一个字节
		dest = (char \*)dest + 1;
		//src指向下一个字节
		src = (char \*)src + 1;
	}
	return tmp;
}
int main()
{
	int arr1[10] = {0,1,2,3,4,5,6,7,8,9};
	int arr2[10] = { 0 };
	my\_memcpy(arr2,arr1,sizeof(int) \* 10);
	for (int i = 0; i < 10; i++) 
	{
		printf("%d ",arr2[i]);
	}
}

最终的效果

memcpy内存重叠问题继续探讨，memmove的引入

这里会有一个内存被覆盖的问题

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

从起始地址arr每每间隔两个整形(arr + 2)，每次拷贝一字节，循环16次（4 * 4）int * 4，相当于用前两个整形元素覆盖掉后面两个整形元素

执行结果也确是如此要想解决这个问题就得引入memmove

memmove

• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

如果源空间和目标空间出现重叠，就得使用memmove函数处理

使用memmove后，可以看出效果还是很明显的不会发生内存重叠

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

memmove的模拟实现

思路：要想实现内存不重叠，将原数据src拷贝到目标数据dest，那么前提是从前往后拷贝呢？还是从后往前拷贝？

从前往后拷贝

思考：可以看出如果是从前往后拷贝，那么3 4就已经被覆盖了，原本的数据也被改成了1 2，再将数据拷贝到5 6的时候那么就是1 2 1 2 1
2 7 8 9 10了，很明显不符合我们想达到的预期结果

从后往前拷贝

思考：那么这种情况就很符合我们的预期结果了

但仅仅是这样思考 还是不够

思考：如果dest和src的位置互换了之后呢？ 即使是从后向前拷贝数据还是被覆盖了

解决方案： dest 在 src的左边，从前往后拷贝

src在dest的左边，从后向前拷贝

重叠的情况，从后向前

dest 在 src的右边，从后往前拷贝，从后往前拷贝都可以

梳理逻辑

实现代码

void \*my\_memove(void \*dest,const void \*src,size\_t count) 
{
	assert(dest && src);
	void \*ret = dest;

	if (dest < src) 
	{
		//从前向后拷贝

		while (count--) 
		{
			\*(char \*)dest = \*(char \*)src;
			//指针往后偏移
			dest = (char\*)dest + 1;
			src = (char\*)src + 1;
		}	
	}
	else 
	{
		//从后向前拷贝
		while (count--) //count的大小决定了指针偏移到了哪个位置
		{
			\*((char\*)dest + count) = \*((char\*)src + count);
		}
	}

	return ret;
}

memset

将ptr指向的内存块的第一个num字节设置为指定的值(解释为unsigned char)。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

ge/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTojqvmiY7nibk=,size_20,color_FFFFFF,t_70,g_se,x_16)

将ptr指向的内存块的第一个num字节设置为指定的值(解释为unsigned char)。

[外链图片转存中…(img-1wxpLnL6-1715742387468)]
[外链图片转存中…(img-yCAViFWK-1715742387469)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！