前言

🎈个人主页:🎈 :✨✨✨初阶牛✨✨✨
🐻推荐专栏: 🍔🍟🌯 c语言进阶
🔑个人信条: 🌵知行合一
🍉本篇简介:>:介绍c语言中有关指针更深层的知识.
金句分享:

✨未来如星辰大海般璀璨✨
✨不必踌躇于过去的半亩方塘.✨

一、memcpy函数

函数模型:

函数参数:

函数头文件:

#include <string.h>

函数功能:
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

注意:
要保证目的地址存的下源地址的内容,要守规矩哦!

1.为什么有了strcpy函数还要有memcpy函数呢?

因为strcpy函数是字符串拷贝,包括strncpy函数也是一样,只能拷贝字符串,对于其它类型,比如整形的拷贝就无能为力.

2.为什么要设置为void*类型?

如果看过前面qsort函数的模拟,这里应该也不难理解,因为要拷贝的类型是未知的,为了能够接收所有类型,所以设置为void*,使用时强制转换为char*类型,然后按字节个数拷贝即可.

函数的应用:

1.将arr2数组的前三个元素拷贝到arr1数组的前三个位置.
2.将字符串str2全部除了’\0’以外,拷贝到str1字符串.

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[10] = { 6,6,6,6,6,6,6,6,6,6 };
	int arr2[] = { 1,2,3,4,5,6,7,8 };
	int arr2sz= sizeof(arr2) / sizeof(arr2[0]);
	char str1[] = "XXXXXXXXXXXXXXXX";
	char str2[] = "Hello CSDN!";
	int str2sz= sizeof(str2) / sizeof(str2[0]);
	memcpy(arr1, arr2, sizeof(int) * 3);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	memcpy(str1, str2, sizeof(char) * str2sz - 1);//-1是因为这里使用的是sizeof()函数计算的长度,会包括\0
	printf("%s", str1);
	printf("\n");
	return 0;
}

运行结果:

1 2 3 6 6 6 6 6 6 6
Hello CSDN!XXXXX

函数的模拟实现:

#include<assert.h>
void* my_memcpy(void* destination, const void* source, size_t num)
{
	assert(destination);
	assert(source);
	while (num--)
	{
	//void*类型不可直接使用,要强制转化
		*(char*)destination = *(char*)source;//*是为了找到该地址所对应的字符串
		((char*)destination)++;//指针分别往后走,所以不需要解引用
		((char*)source)++;
	}
}

思考:
memcpy函数可以拷贝内存重叠的地址吗?
即source和destination有重叠的时候.(可以试试).

二、memmove函数

函数模型:

函数参数:

函数作用:
该函数与memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠
的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理,其实在有的编译器中,对于memcpy函数也进行了优化,也是允许内存重叠的.

但牛牛认为,还是有必要掌握这种更"稳妥"的函数的.

情况1

这种情况我们可以正常的从前向后(前->后) 拷贝.
即:先将6拷贝至2位置,再讲7拷贝至3位置……

这种情况我们使用从从前向后(前->后)拷贝则达不到我们的要求.
如果我们先将6拷贝至8处,7拷贝至9处,则原来的8 9都被修改了.
这时我们需要从后往前(后->前)拷贝.

即先将11拷贝至13处,再将9拷贝至12处……

其实这种情况并不是内存地址重叠,目的地址出现在前面也是一样的,都是可以从前向后(前->后)拷贝和从后往前(后->前)拷贝皆可.

函数模拟实现

#include <stdio.h>
#include<assert.h>
void* my_memmove(void* destination, const void* source, size_t num)
{
	void* ret = destination;//保留目的地原来的首地址
	assert(destination && source);//防止传错地址
	if (destination < source)//情况1时,目的地址的首地址小于源地址首地址
	{
		//前-->后
		while (num--)
		{
			*(char*)destination = *(char*)source;
			((char*)destination)++;
			((char*)source)++;
		}
	}
	else
	{
		//后->前
		while (num--)
		{
			*((char*)destination + num) = *((char*)source + num);//注意,这里如果以destination为1的偏移量,+num则是目的地地址的最后一个元素的地址.
		}
	}
	return ret;
}

代码测试:
情况1;

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,11,12,13 };
	//情况1
	my_memmove(arr + 1, arr + 5, sizeof(int) * 5);
	int sz= sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

运行结果:

1 6 7 8 9 11 7 8 9 11 12 13

情况2:

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,11,12,13 };
	//情况1
	my_memmove(arr +7, arr + 5, sizeof(int) * 5);
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

运行结果:

1 2 3 4 5 6 7 6 7 8 9 11

三、memcmp函数

函数模型:

函数参数:

函数头文件:

#include <string.h>

函数功能
比较从ptr1和ptr2指针开始的num个字节.

注意与strcmp函数区分:

strcmp函数:用于比较字符串是否相等,只用于比较字符

memcmp:按字节比较,两个指针所指向的内容是否相等.可用于比较不同类型的元素,但是是按字节比较.

函数应用:

试着猜一下这段代码的值?(vs2022环境(小端))

//memcmp函数模拟
#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[] = { 1,4,7,255 };
	int arr2[] = { 1,4,7,511 };
	int ret=memcmp(arr1, arr2, 13);
	printf("%d", ret);
	return 0;
}

答案:

0

解析:
首先这里是小端存储模式.则这两个数组在内存中存储的是:

arr1 :01 00 00 00 04 00 00 00 07 00 00 00 FF 00 00 00 (16进制,两位代表一个字节)
arr2 :01 00 00 00 04 00 00 00 07 00 00 00 FF 10 00 00

很明显,这里前四个元素(1,4,7)是相等的,而元素255和元素511则是第一个字节的内容相等,所以当比较的元素是[0,13]时,memcmp函数会认为这两个指针所指向的内容是相同的,故返回值是0.

可以试着改成14字节,返回值会是-1,因为第14个字节,arr1是00.arr2是1,则arr1<arr2;

模拟实现

#include<assert.h>
int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
	assert(ptr1 && ptr2);
	while (num--)//比较num个字节
	{
		if (*(char*)ptr1 == *(char*)ptr2)//相等继续往后比较
		{
			((char*)ptr1)++;
			((char*)ptr2)++;
		}
		else if (*(char*)ptr1 > *(char*)ptr2)//str1大则返回大于0的数
		{
			return 1;
		}
		else//str2大返回小于0的数
		{
			return -1;
		}
	}
	return 0;//比完了num个字节都相等则返回0
}

四、memset函数

函数模型:

头文件:

#include <string.h>

函数参数

函数功能:
将ptr所指向的空间,的num个字节设置为value值,注意这里也是按字节设置.

示例:

#include <stdio.h>
#include <string.h>
int main()
{
	int arr[5] = { 0 };
	memset(arr, 1, 20);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

结果会是下面这个吗?

1 1 1 1 1

正确答案:

16843009 16843009 16843009 16843009 16843009

为什么呢?
我们可以试着通过调试找到答案.

执行语句memset(arr, 1, 40);后

很显然,这里是将20个字节设置为了1,而一个整形占4个字节;

那么怎样才可以将每个元素都设置为1呢?

#include <stdio.h>
#include <string.h>
int main()
{
	int arr[5] = { 0 };
	for (int i = 0; i < 5; i++)
	{
		memset(arr+i, 1, 1);
	}
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

其实这样才能达到我们想要的结果,这里是将一个字节设置为1,然后跳过四个字节(下一个元素),再将这个元素的首字节设置为1.
但是这样是不是有点太麻烦了,所以一般memset函数一般不会这么用,一般memset函数用来将一段空间的元素按字节都初始化为0,在后面我们用到malloc函数向内存申请空间时,得到的空间里面存放的值都是随机值,这时我们可以使用它来帮助我们完成初始化操作.

好了,今天的内存操作函数就讲到这里了,我们下周再见!
最后，如果文章对大家有帮助的话，求一波三连吧！
💗💗💗886