内存操作函数（c语言）

最新推荐文章于 2024-05-16 20:47:16 发布

御翮

最新推荐文章于 2024-05-16 20:47:16 发布

阅读量1.4k

点赞数 30

文章标签： c语言开发语言后端

本文链接：https://blog.csdn.net/2301_81988400/article/details/136377165

版权

概述

C语言提供了一些非常有用的内存操作函数，其中包括memcpy、memcmp、memset和memmove。这些函数可以帮助我们在程序中对内存进行复制、比较和设置操作。本文将介绍这些函数的用法和模拟实现。

1. `memcpy`函数

memcpy函数用于将一个内存区域的内容复制到另一个内存区域。它的原型如下：

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

其中，destination是目标内存区域的指针，source是源内存区域的指针，number是要复制的字节数。下面是一个使用memcpy函数的示例：

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

int main() 
{
    char src[] = "Hello, World!";
    char dest[20];
    
    memcpy(dest, src, 10);
    
    printf("复制后的字符串：%s", dest);
    
    return 0;
}

输出结果：

上述代码将字符串src的前十个字节的内容复制到了dest数组中，但是并没有复制到'\0'，所以在输出"Hello,Wor"之后是随机值。

2.`memcpy`函数的模拟实现

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

void* my_memcpy(void* dst, void* src, size_t num)//（拷贝目标地址，拷贝来源地址，要拷贝的字节大小）
{
	assert(dst && src);//assert()里面的条件必须为真，否则报错终止程序，这里是防止传过来的指针为NULL
	void* ret = dst;//memcpy函数拷贝完成后会返回目标的地址，这里先用ret将dst储存起来
	while (num--)
	{
		*(char*)dst = *(char*)src;//强制类型转换为char*，是为了让程序一个字节一个字节的拷贝
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return ret;
}

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

输出结果

3. `memcmp`函数

memcmp函数用于比较两个内存区域的内容是否相等。它的原型如下：

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

其中，ptr1和ptr2分别是待比较的两个内存区域的指针，num是要比较的字节数。下面是一个使用memcmp函数的示例：

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

int main() 
{
    char str1[] = "Hello";
    char str2[] = "Hello";
    
    int result = memcmp(str1, str2, strlen(str1));
    
    if (result == 0) 
    {
        printf("两个字符串相等");
    } 
    else 
    {
        printf("两个字符串不相等");
    }
    
    return 0;
}

输出结果

上述代码比较了两个字符串str1和str2是否相等，并根据比较结果输出相应的信息。

4.`memcmp`函数的模拟实现

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

int my_memcmp(void* dst, void* src, size_t num)
{
	assert(dst && num);
	while (num--)
	{
		if (*(char*)dst != *(char*)src)
			return *(char*)dst - *(char*)src;
	//memcmp函数的返回值是一个整型
	//当dst大于src时返回一个大于0的数
	//当dst等于src时返回0
	//当dst小于src时返回一个小于0的数
	//所以返回 dst - src 会方便很多	
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return 0;
}

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int arr2[] = { 1, 2, 3, 4, 6 };
	int ret = my_memcmp(arr1, arr2, 20);
	if (ret == 0)
		printf("相等");
	else if (ret > 0)
		printf("arr1大于arr2");
	else
		printf("arr1小于arr2");
	return 0;
}

输出结果

上述代码比较的是arr1和arr2的前20个字节的内容，即比较了arr1的1，2，3，4，5和arr2的1，2，3，4，6。

5. `memset`函数

memset函数用于将一个内存区域的所有字节设置为指定的值。它的原型如下：

void *memset(void *dst, int src, size_t num);

其中，dst是要设置的内存区域的指针，src是要设置的值，num是要设置的字节数。下面是一个使用memset函数的示例：

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

int main() 
{
    char str[20];
    
    memset(str, 'A', sizeof(str));
    
    printf("设置后的字符串：%s", str);
    
    return 0;
}

输出结果

上述代码将字符串str中的所有字节都设置为字符'A'，但是没有设置'\0'，所以输出完20个'A'之后是随机值。

6.`memset`函数的模拟实现

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

void* my_memset(void* dst, int src, size_t num)
{
	assert(dst);
	void* ret = dst;
	while (num--)
	{
		*(char*)dst = (char)src;
		dst = (char*)dst + 1;
	}
	return ret;
}

int main()
{
	char arr[10];
	my_memset(arr, '*', 10);
	for (int i = 0; i < 10; i++)
		printf("%c ", arr[i]);
	return 0;
}

输出结果

7. `memmove`函数

memmove函数用于将一个内存区域的内容移动到另一个内存区域，即使这两个区域有重叠。它的原型如下：

void *memmove(void *dst, const void *src, size_t n);

其中，dst是目标内存区域的指针，src是源内存区域的指针，num是要移动的字节数。下面是一个使用memmove函数的示例：

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

int main() 
{
    char str[] = "Hello, World!";
    
    memmove(str + 7, str, strlen(str) + 1);
    
    printf("移动后的字符串：%s", str);
    
    return 0;
}

输出结果

上述代码将字符串str中的内容"Hello, World!"移动到了字符串str的第7个元素之后，结果如上图。

8.`memmove`函数的模拟实现

模拟memmove函数的注意事项：
1、当在内存中的地址dst < src时，memmove函数要将数据从前往后移动数据，否则会达不到想要的结果。
2、当在内存中的地址dst = src时，从前往后和从后往前移动数据都可行。
3、当在内存中的地址dst > src时，memmove函数要将数据从后往前移动数据，否则会达不到想要的结果。
假设我们要将int arr[] = { 1,2,3,4,5,6,7,8,9,10 };中的前5个元素移动到第3个元素开始的位置，即将数组里的1，2，3，4，5移动到3，4，5，6，7。
因为第3个元素的地址小于第1个元素的地址，所以我们模拟的memmove函数要从后往前移动前5个元素，才能得到我们想要的结果
- 下图分别是从前往后移动和从后往前移动的结果

在这里插入图片描述

模拟实现代码：

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

void* my_memmove(void* dst, void* src, size_t num)
{
	assert(dst && src);
	void* ret = dst;
	if (dst < src)
	{
		while (num--)
		{
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dst + num ) = *((char*)src + num );//这里的num是经过--的，指向的是dst和src的最后一个元素的最后一个字节，如果不经过--，则会从dst和src的最后一个字节的后一个字节开始移动，会造成结果错误
			
		}
	}
	return ret;
}

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