内存操作函数（memcpy、memmove、memset、memcmp）---- C语言

摘要

本篇文章介绍了C语言中常用的内存操作函数，包括 memcpy、memmove、memset和memcpy。这些函数用于处理内存数据的复制、移动和初始化。文章中，对这几个函数进行了详细的解释和示例演示，并进行了模拟实现。

1. memcpy

1.1 函数介绍

函数原型：

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

• destination：目标地址，表示复制后数据存放的位置。
• source：源地址，表示要复制的数据的起始位置。
• num ：要复制的字节数。

memcpy是一个将一个内存区域的内容复制到另一个内存区域的库函数。该函数将源地址 src 指向空间的前 num 个字节的内容复制到目标地址 dest 指向的空间中去。
以下代码，展示了如何使用 memcpy 函数复制字符串：

#include 
#include 

int main() {
    const char* src = "Hello, world!";
    char dest[20];

    // 使用 memcpy 复制字符串
    memcpy(dest, src, src);

    // 打印复制后的字符串
    printf("复制后的字符串：%s\n", dest);

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

• 注意：
• memcpy 不会检查源地址和目标地址是否重叠，因此在使用时需要确保没有发生重叠。
• C语言标准规定：memcpy来完成不重叠的内存拷贝。如果要完成内存重叠的拷贝，可以使用 memmove 函数。

1.2 模拟实现

实现思路：

• 创建一个循环，逐字节地从源地址复制到目标地址。
• 在循环中，从源地址 src 指向的空间中读取一个字节的内容，然后将它写入目标地址 dest指向的空间中。
• 重复上述步骤，直到复制了 num 个字节。
• 复制完成后，返回目标空间的起始地址_dest。

#include 

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(src && dest);//检查参数是否有效
	void* _dest = dest;//保存目标空间起始地址
	// 逐字节复制，复制num个字节
	while (num--)
	{
		//从src指向的空间中读取一个字节的内容，然后将它写入目标地址空间dest指向的空间中
		*(char*)dest = *(char*)src;
		
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return _dest;
}

int main()
{
	const char *src = "Hello, world!";
	char dest[20];
	
	// 使用 my_memcpy 复制字符串
	my_memcpy(dest, src, strlen(src) + 1);
	
	// 打印复制后的字符串
	printf("复制后的字符串：%s\n", dest);
	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
25
26
27
28
29
30

2. memmove

2.1 函数介绍

函数原型：

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

• destination：目标地址，表示复制后数据存放的位置。
• source：源地址，表示要复制的数据的起始位置。
• num ：要复制的字节数。

memmove是一个用于将一个内存区域的内容复制到另一个内存区域的库函数，该函数将源地址 source 指向空间的前 num 个字节的内容复制到目标地址 destination指向的空间中去。与memcpy函数不同的是，该函数可以处理重叠的内存区域。
以下代码，展示了如何使用 memmove 函数处理重叠的内存区域：

#include 
#include 

int main() 
{
    char str[] = "abcdef";

    // 使用 memmove 将 "abcdef" 中的 "abcd" 移动到 "cdef" 的位置
    memmove(str + 2, str, 4);

    // 打印移动后的字符串
    printf("移动后的字符串：%s\n", str);

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

2.2 模拟实现

实现思路：
关于内存重叠可能存在两种情况：

• 情况一：src < dest
  
  此时应该从src指向空间的最后一个字节开始，逐字节的逆序拷贝。
  
• 情况二：src > dest
  
  这种情况下，从src指向空间的第一个字节开始往后拷贝就不会出现覆盖的问题，因此拷贝顺序如下：
  

#include 
#include 

void* my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);//检查参数是否合法
	void* _dest = dest;//保存目标空间的起始地址
	//检查复制方向
	if (src > dest)
	{
		//正序复制
		for (int i = 0; i < num; ++i)
		{
			 *(char*)dest = *(char*)src;
			 dest = (char*)dest + 1;
			 src = (char*)src + 1;
		}
	}
	else if(src < dest)
	{
		//逆序复制
		while (num--)
		{
			*((char*)dest + num)= *((char*)src + num);
		}
	}
	return _dest;// 返回目标空间起始地址
}
int main()
{
	char str[] = "abcdef";

	// 使用 my_memmove 将 "abcdef" 中的 "abcd" 移动到 "cdef" 的位置
	my_memmove(str, str + 2, 4);

	// 打印移动后的字符串
	printf("移动后的字符串：%s\n", str);

	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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3. memset

3.1 函数介绍

函数原型：

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

• ptr：要设置的内存区域的起始地址。
• value：要设置的值（通常是一个整数，被解释为无符号字符）。
• num ：要设置的字节数。

memset是一个用于将一块内存区域的内容设置为指定值的库函数，常用于初始化内存。该函数将从起始地址 ptr 开始的连续 num 个字节都设置为指定的值 value。
以下代码，展示了如何使用 memset 函数将整型数组的所有元素初始化为零：

#include 
#include 

int main() 
{
    int arr[5];

    // 使用 memset 初始化整型数组的所有元素为零
    memset(arr, 0, sizeof(arr));

    // 打印初始化后的数组
    for (int i = 0; i < 5; i++) 
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4. memcmp

4.1 函数介绍

函数原型：

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

• ptr1：要比较的内存区域1的起始地址。
• ptr2：要比较的内存区域2的起始地址。
• num：要比较的字节数。

memcmp是一个用于比较两个内存区域内容的库函数。该函数会比较 ptr1 和 ptr2 所指向的内存区域的前 num 个字节，并返回一个整数值，表示比较结果。返回值的含义如下：

• 如果 ptr1 和 ptr2 相等，则返回 0。
• 如果 ptr1 小于 ptr2 ，则返回一个负数。
• 如果 ptr1 大于 ptr2 ，则返回一个正数。

以下代码，演示了如何使用 memcmp 函数比较两个字符串是否相等：

#include 
#include 

int main() 
{
    const char *str1 = "abcdef";
    const char *str2 = "abcd";

    // 使用 memcmp 比较两个字符串是否相等
    int res = memcmp(str1, str2, 4);
    
    if (res == 0) 
    {
        printf("字符串相等\n");
    } 
    else {
        printf("字符串不相等\n");
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

至此，本片文章就结束了，若本篇内容对您有所帮助，请三连点赞，关注，收藏支持下。
创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！
如果本篇博客有任何错误，请批评指教，不胜感激 ！