WHCSRL 技术网

C | 常见内存函数的使用及其模拟实现

前言

在C语言中,我们除了会经常用到与字符相关的函数,我们还会使用到与内存相关的库函数。今天我们就来学习几个常见的内存函数吧!

在这里插入图片描述

memcpy

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

这是一个内存复制函数,该函数会从source的位置开始向后复制num个字节的数据到destination的内存位置。

这个函数在遇到 ‘’ 的时候并不会停下来。

用法如下:

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

int main()
{
	char arr1[] = "Pierre de Fermat";
	char arr2[40];

	memcpy(arr2, arr1, strlen(arr1) + 1);

	printf("%%%%s
", arr2);

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

上述代码的arr2的输出结果为arr1中的内容。

我们要注意,在目标空间中,要保证有足够的空间放得下要拷贝的内容,以免造成越界。

模拟实现如下:

//memcpy的模拟实现
#include<stdio.h>
#include<string.h>
#include<assert.h>



//不会考虑内存重叠的情况
void* my_memcpy(void* dest, const void* source, size_t nums) {

	//先记录下dest的初始位置,便于后续返回
	void* ret = dest;

	//判断传入的两个指针是否为空
	assert(dest, source);

	//利用循环来控制拷贝字节的个数
	while (nums--) {

		//由于传入的是void*类型的指针,所以在使用前要强制转换为char*
		*(char*)dest = *(char*)source;
		dest = ((char*)dest) + 1;
		source = ((char*)source) + 1;

	}

	return ret;

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

memcmp

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

这个函数是用来比较指定字节数的内存空间是否相同。

返回值如下:

在这里插入图片描述
上图来自于这里

当ptr1的内容小于ptr2的内容,就返回一个小于零的数,当ptr1的内容大于ptr2的内容,就返回一个大于零的数,相等则返回零。

由于用法比较简单,就不进行演示啦!

模拟实现如下:

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

int my_memcmp(const void* p1, const void* p2, size_t num) {

	//判断传入的两个指针是否为空
	assert(p1 && p2);

	//利用循环依次比较
	int i = 0;
	for (i = 0; i < num; i++) {

		if (*((char*)p1 + i) > (*(char*)p2 + i)) {
			return 1;
		}
		else if(*((char*)p1 + i) < (*(char*)p2 + i)){
			return -1;
		}
	}
	return 0;


}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

memmove

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

上面我们已经学习过memcpy 函数的使用了,但是,如果我们的源空间和目标空间有重复的部分,那么memcpy这个函数就会出现错误,为了避免出错,我们就来学习一下memmove这个函数吧!

int main() {


	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr+2, arr, 16);

	printf("%%%%s
", arr);


	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

上面的代码执行后,arr会变成{3,4,5,6,5,6,7,8,9,10}

这个函数的模拟实现要分情况讨论

1.如果dest在source前面,那么就有可能会出现有一部分内存重叠的情况,我们就需要在source中,先拷贝前面的数据在拷贝后面的数据,即从前往后拷贝。

2.如果dest在source后面,两个指针相减的数值小于要移动的字节数,那么也会有内存重叠的情况,那么此时,我们就需要先拷贝后面的数据,在拷贝前面的数据,即从后向前拷贝。

3.如果dest与source之间的差值大于要拷贝的字节数,那么此时就属于是两块不重叠的内存之间的拷贝,此时即使是用memcpy也不会有问题。

综上,我们可以已dest在source前后作为分界线。

如果dest在source前面,那么我们就从前往后拷贝,如果dest在source后面,那么我们就从后往前拷贝。

具体代码实现如下:

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


void* my_memmove(void* dest, void* source, size_t num) {

	assert(dest &&  source);

	//记录初始dest的位置,方便后续返回
	void* ret = dest;

	//如果dest在source的前面,那么我们可以从前往后拷贝,防止数据被覆盖
	if (dest < source) {

		while (num--) {

			*(char*)dest = *(char*)source;
			dest = (char*)dest + 1;
			source = (char*)source + 1;
		}
	}
	else {

		while (num--) {

			//下面的num在第一次进入循环的时候已经减过1了
			*((char*)dest + num)= *((char*)source + num);

		}
	}

	return ret;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

memset

void * memset ( void * ptr, char value, size_t num );

这个函数一般用于初始化一段内存。

我们只需要传入内存空间的地址,需要初始化的字符,还有需要初始化的字节数即可。

由于这个函数的用法也比较简单,所以我们也不进行用法演示啦!

模拟实现如下:

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


void* my_memset(void* dest, char ch, size_t num) {

	void* ret = dest;
	assert(dest);

	while (num--) {

		*(char*)dest = ch;
		((char*)dest)++;

	}
	return ret;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

结语

今天的分享就到这里啦,由于本人水平有限,难免会有出错或者不够好的地方,希望各位小伙伴们能够指出!

创作不易呀,希望各位友友可以点个赞,点个关注,在给我一个评论,你们的支持是我创作的最大动力!

在这里插入图片描述

推荐阅读