【C语言进阶】---常见内存函数

内存函数

🎈🎈 作者 ： @whispar
🎈🎈专栏 ： C语言从无到有
✨放低姿态，空杯心态✨

---

内存函数可在任意类型使用，字符串函数只能比较字符串,内存函数不关注’\0’， 只关注要拷贝的字节数

一、memcpy

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

✔功能演示：参数类型必须是void*。因为memcpy函数是内存拷贝函数，它必须什么类型都能接收。

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置，这个函数在遇到 ‘\0’ 的时候并不会停下来。

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

模拟实现memcpy

✔void 类型不能进行解引用操作和++运算，在解引用操作和++运算之前，要进行强制类型转换。并且因为此函数是一个字节一个字节的拷贝，所以要将ptr1和ptr2变量强制类型转化为char*类型
✔目标变量dest的地址需要存放在一个临时指针变量中，因为dest在循环体中一直是变化的
✔将dest和sour指针变量assert断言，使其不为NULL。并且因为sour是不能改变的，所以用const修饰，以保护起来。*

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

memcpy不支持自身内部拷贝，可能存在覆盖，主要负责拷贝两块独立空间中的数据，重叠内存拷贝使用memmove

二、memmove

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

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

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

模拟实现memmove

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

为避免出现空间重叠现象，根据dest 和 sour 的位置分情况处理，选择从前向后或从后向前拷贝

#include<assert.h>
#include<stdio.h>
void* my_memmove(void* dest, const void* sour, size_t num) {
	assert(dest && sour);
	void* ret = dest;
	if (dest < sour)
	{
	//前向后拷贝
		while (num--) 
		{
			*(char*)dest = *(char*)sour;
			dest = (char*)dest + 1;
			sour = (char*)sour + 1;
		}
	}
	else
	{
	//后向前拷贝
		while (num--)
		{
			*((char*)dest + num) = *((char*)sour + num);
		}
	}
	return ret;
}

三、memcmp

---

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

✔功能实现：比较两个内存块，将 ptr1 所指向的内存块的前 num 个字节与 ptr2 指向的前num字节数进行比较, 返回不同意义的值

返回值	表明
>0	在两个内存块中不匹配的第一个字节在 ptr1 中的值大于在 ptr2 中的值
0	两个内存块的内容相等
<0	在两个内存块中不匹配的第一个字节在 ptr1 中的值小于在 ptr2 中的值

#include<stdio.h>
#include<string.h>
int main(){
	int arr1[] = { 1,5,4,5 };//01 00 00 00/ 05 00 00 00/ 04 00 00 00 /05 00 00 00
	int arr2[] = { 1,3,5,6 };//01 00 00 00/ 03 00 00 00 /05 00 00 00/ 06 00 00 00
	int ret = memcmp(arr1, arr2, 12);//arr1 > arr2
	printf("%d", ret);
	return 0;
}

模拟实现 memcpy()

✔void 类型不能进行解引用操作和++运算，在解引用操作和++运算之前，要进行强制类型转换。并且因为此函数是一个字节一个字节的拷贝，所以要将ptr1和ptr2变量强制类型转化为char*类型*

#include<stdio.h>
#include<assert.h>
int my_memcmp(const void* ptr1, const void* ptr2, size_t num) {
	assert(ptr1 && ptr2);
	while (num-- && *(char*)ptr1 == *(char*)ptr2){
		      ptr1 = (char*)ptr1 +1;
		      ptr2 = (char*)ptr2 +1;
	    }
	return(*(char*)ptr1 - *(char*)ptr2);
}
int main(){
	//char arr1[] = "hello world";
	//char arr2[] = "hello bilibili";
	int arr1[] = { 1,5,7,5 };
	int arr2[] = { 1,5,7,6};
	int ret = my_memcmp(arr1, arr2, 12);
	if (ret == 0)
		printf("==\n");
	else if (ret < 0)
		printf("<\n");
	else
		printf(">\n");
	return 0;
}

四、memset()

---

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

✔功能实现：将 ptr 所指向的内存块的前num个字节数设置为指定值

#include<stdio.h>
int main() {
	char arr[] = "hello bilibili";
	memset(arr, 'x', 5);
	printf("%s", arr);
	return 0;
}

模拟实现memset()

void* my_memset(void* ptr, int value, size_t num) {
	assert(ptr);
	void* ret = ptr;
	while (num--){
		*(char*)ptr = value;  //赋值
		ptr = (char*)ptr + 1; //前移
	}
	return ret;
}

相信看到这里，大家已经对常见的内存函数已经有一定了解，如果你感觉这篇博客对你有帮助的话，不要忘了一键三连支持一下再离开噢！