异常教程

C 库函数 – memmove()（一文讲透）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言

在 C 语言编程中，内存操作是开发者必须掌握的核心技能之一。内存管理的高效性与安全性直接影响程序的性能和稳定性。C 库函数 – memmove() 是一个用于内存块复制的函数，它在处理动态内存和复杂数据结构时展现出独特优势。本文将从基础概念、实际应用到进阶原理，系统性地解析 memmove() 的功能与使用技巧，帮助读者在编程实践中灵活运用这一工具。

一、memmove() 函数基础：定义与语法

1.1 函数定义与作用

memmove() 是 C 标准库中的一个内存拷贝函数，其名称由“memory move”缩写而来。它的核心功能是将一块内存区域的内容复制到另一块内存区域，并且允许源和目标区域有重叠。这一特性是它与另一个常见函数 memcpy() 的关键区别之一。

函数原型如下：

void *memmove(void *dest, const void *src, size_t n);
  • 参数说明：
    • dest：目标内存区域的起始地址（可写）。
    • src：源内存区域的起始地址（只读）。
    • n：要复制的字节数（以 size_t 类型表示）。

1.2 与 memcpy() 的对比

memcpy() 是另一个常用的内存复制函数，但它的设计假设源和目标区域不重叠。如果这两个区域有重叠，memcpy() 可能会因覆盖源数据而导致不可预测的结果。例如：

char str[] = "HelloWorld";  
memcpy(str + 3, str + 5, 3); // 可能导致数据混乱

而 memmove() 在这种情况下能正确处理重叠区域，确保数据完整复制。

1.3 返回值与错误处理

memmove() 返回目标地址 dest 的指针，无需额外检查返回值。若传入的 n 值为 0，则函数无操作。

二、内存重叠场景的处理：memmove() 的核心优势

2.1 重叠场景的比喻

想象搬家时，如果两个房间（源和目标内存区域）有部分重叠区域（例如，搬动家具时需要先移开中间的障碍物），memcpy() 可能像“直接拖拽家具”导致碰撞，而 memmove() 则像“先打包再搬运”，确保重叠区域的数据不被破坏。

2.2 典型应用场景

案例 1：字符串逆序

假设需要将字符串 "abcd" 反转为 "dcba"：

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

int main() {  
    char str[] = "abcd";  
    size_t len = strlen(str);  

    // 使用 memmove() 实现逆序  
    for (size_t i = 0; i < len / 2; i++) {  
        memmove(str + i, str + (len - i), 1); // 每次移动一个字符  
    }  

    printf("%s\n", str); // 输出 "dcba"  
    return 0;  
}

这里，memmove() 的重叠处理能力确保了在循环中逐个字符移动时不会覆盖未处理的数据。

案例 2：动态内存扩展

在动态分配的内存块中追加数据时，若新数据与旧数据有重叠：

void append_data(char *buffer, char *new_data, size_t new_size) {  
    size_t old_size = strlen(buffer);  
    buffer = realloc(buffer, old_size + new_size + 1); // 扩展内存  

    // 使用 memmove() 将旧数据后移，为新数据腾出空间  
    memmove(buffer + old_size + 1, buffer + old_size, new_size);  
    memcpy(buffer + old_size, new_data, new_size); // 写入新数据  
}

此场景中，memmove() 确保了旧数据在扩展内存时不会因重叠而丢失。

三、深入理解 memmove() 的底层原理

3.1 内存拷贝的方向策略

memmove() 的安全性源于其对内存拷贝方向的智能判断：

  • 当 源地址 < 目标地址 时，内存块可能向后重叠，因此 memmove() 会从后向前逐字节复制。
  • 当 源地址 > 目标地址 时，则从前向后复制。

这种策略避免了覆盖未读取的源数据。

3.2 性能与 memcpy() 的对比

虽然 memmove() 更安全，但它的灵活性导致其性能通常略低于 memcpy()（尤其是在无重叠的场景）。因此，在已知内存区域无重叠时，优先使用 memcpy() 可能更高效。

四、实际应用案例与代码示例

4.1 案例 1：合并两个重叠的数组

假设需要将两个数组合并，且目标内存与源内存有部分重叠：

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

void merge_arrays(int *dest, const int *src, size_t dest_len, size_t src_len) {  
    // 确保 dest 的总容量足够  
    memmove(dest + dest_len, src, src_len * sizeof(int)); // 将 src 复制到 dest 末尾  
}  

int main() {  
    int arr1[] = {1, 2, 3}; // 长度为3  
    int arr2[] = {4, 5};    // 长度为2  
    size_t total_len = 5;  

    merge_arrays(arr1, arr2, 3, 2); // 合并后 arr1 成为 {1,2,3,4,5}  
    return 0;  
}

4.2 案例 2：动态内存管理中的安全操作

在扩展动态数组时，使用 memmove() 避免内存越界：

#include <stdlib.h>  

void enlarge_array(int **arr, size_t *size, size_t new_size) {  
    int *new_arr = realloc(*arr, new_size * sizeof(int));  
    if (!new_arr) return; // 内存不足时处理  

    // 若 new_size > *size，将原数据移动到新位置  
    if (new_size > *size) {  
        memmove(new_arr + *size, new_arr, (*size) * sizeof(int)); // 将原数据后移  
    }  

    *arr = new_arr;  
    *size = new_size;  
}

五、常见错误与注意事项

5.1 参数传递错误

  • 错误示例：传递 NULL 指针作为目标或源地址，导致程序崩溃。
  • 解决方法：在调用前始终检查指针的合法性。

5.2 内存越界风险

若复制的字节数 n 超出目标或源内存的容量，可能导致未定义行为。例如：

char buffer[10];  
memmove(buffer, "HelloWorld", 11); // "HelloWorld" 需要 11 字节（含 '\0'），而 buffer 只有 10 字节

此时应确保 dest 和 src 的内存空间足够。

5.3 误用场景

  • 误区：认为 memmove() 总比 memcpy() 更快。
  • 真相：在无重叠的场景中，memcpy() 的优化更好，性能更高。

六、与其他内存操作函数的对比

6.1 memmove() vs. memcpy()

特性memmove()memcpy()
是否支持重叠内存支持不支持
性能略低（智能处理重叠）更快（无额外判断）
推荐使用场景源和目标可能重叠时确认内存无重叠时

6.2 memmove() vs. strcpy()

strcpy() 专门用于复制以 '\0' 结尾的字符串，而 memmove() 可处理任意二进制数据（如结构体、数组）。例如：

struct Person {  
    char name[30];  
    int age;  
};  

struct Person p1, p2;  
memmove(&p2, &p1, sizeof(struct Person)); // 安全复制结构体

结论

C 库函数 – memmove() 是内存操作中不可或缺的工具，尤其在处理动态内存和复杂数据结构时，其对重叠区域的智能处理能力显著提升了程序的健壮性。通过本文的案例分析和代码示例，读者应能掌握 memmove() 的核心用法，并在实际开发中避免常见陷阱。建议开发者在以下场景优先选择 memmove()：

  1. 源和目标内存区域可能重叠；
  2. 需要复制非字符串的二进制数据（如结构体、动态数组）；
  3. 对程序稳定性要求高于性能优化的场景。

掌握 memmove() 的原理与最佳实践，将帮助开发者编写出更高效、更安全的 C 语言程序。

最新发布

查看更多文章