深入浅出：如何手写高性能的 memcpy 与 memmove 函数

2026-02-10 08:34:01 0条评论 1次阅读 0人点赞

在系统编程和底层开发中，内存操作无疑是构建高效应用的基石。你可能每天都在使用标准库提供的内存拷贝函数，但你有没有想过，这些函数内部究竟是如何工作的？如果有一天你需要在一个受限的环境（比如嵌入式系统）中编写代码，或者你需要为了极致的性能优化而避开标准库时，你该如何实现一个属于自己的内存拷贝函数呢？

在这篇文章中，我们将抛开标准库，从零开始，深入探讨如何手写 INLINECODE9a169ae4 和 INLINECODE5d87a9ce 函数。我们将从最直观的字节拷贝开始，逐步深入到底层优化技巧，并重点分析为什么 INLINECODE2fff1230 在处理内存重叠时会失效，以及 INLINECODE3201c1b0 是如何优雅地解决这一问题的。准备好和我们一起探索 C 语言内存管理的奥秘了吗？

为什么我们需要自己实现内存拷贝？

在许多现代编程教程中，内存拷贝往往被一笔带过，但在高性能计算、操作系统内核开发或驱动编写中，理解数据的移动方式至关重要。标准 C 库提供的 memcpy 是为了速度而生的，它通常针对特定的处理器架构进行了汇编级别的优化。然而，理解其背后的逻辑不仅能让你成为更好的开发者，还能帮助你在调试复杂的内存损坏问题时游刃有余。

基础篇：实现一个简单的 memcpy

让我们从最基础的情况开始。INLINECODE1420087c 的核心任务非常简单：将 INLINECODE7d4f0ea5 个字节从源地址复制到目标地址。这里的关键在于，由于我们是在处理“字节”级别的数据，而 INLINECODE67e8a1e3 指针无法直接进行解引用操作，因此我们需要将这些指针强制转换为 INLINECODE1fbf1249（或 INLINECODE5047ecc1），因为 INLINECODE135c6486 类型的大小保证为 1 字节。

标准原型回顾

首先，让我们回顾一下标准函数的签名。这有助于我们理解函数的输入输出约定。

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

它接收目标地址、源地址和要复制的字节数，并返回目标地址的指针（为了方便链式调用）。

实现思路

  • 类型转换：将 INLINECODE7383a2e6 转换为 INLINECODEf8851937，以便逐字节操作。
  • 逐个拷贝：使用一个循环，从源地址读取数据并写入目标地址。
  • 返回值：为了保持与标准库一致，我们需要返回 destination 指针。

代码示例 1：基础版 memcpy

下面是一个清晰的实现，我们将其命名为 myMemCpy。代码中包含了详细的中文注释，帮助你理解每一步的操作。

#include 
#include 

/**
 * 自定义实现的 memcpy 函数
 * @param dest  目标地址
 * @param src   源地址
 * @param n     要复制的字节数
to * @return    返回目标地址 dest
 */
void* myMemCpy(void *dest, const void *src, size_t n) {
    // 将 src 和 dest 的地址转换为 char* 类型
    // 这样我们就可以每次操作一个字节
    char *csrc = (char *)src;
    char *cdest = (char *)dest;

    // 逐个字节地复制数据
    // 从 src[i] 复制到 cdest[i]
    for (size_t i = 0; i < n; i++) {
        cdest[i] = csrc[i];
    }

    // 返回目标地址，为了支持链式操作
    return dest;
}

// 驱动程序来测试我们的函数
int main() {
    // 测试用例 1：复制字符串
    char csrc[] = "HelloWorld";
    char cdest[100];
    myMemCpy(cdest, csrc, strlen(csrc) + 1); // +1 是为了包含字符串结束符 '\0'
    printf("复制后的字符串: %s
", cdest);

    // 测试用例 2：复制整型数组
    int isrc[] = {10, 20, 30, 40, 50};
    int n = sizeof(isrc) / sizeof(isrc[0]);
    int idest[n];
    
    myMemCpy(idest, isrc, sizeof(isrc));
    printf("复制后的整型数组: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", idest[i]);
    }
    printf("
");

    return 0;
}

输出结果：

复制后的字符串: HelloWorld
复制后的整型数组: 10 20 30 40 50

时间复杂度分析： 这个实现的时间复杂度是 O(n)，因为我们必须遍历每一个字节。
空间复杂度分析： 是 O(1)，我们只使用了固定的局部变量，没有分配额外的与 n 相关的内存。

进阶篇：内存重叠带来的隐患

虽然上面的 INLINECODE6355738d 在大多数情况下都能正常工作，但它存在一个致命的缺陷：它不检查源内存和目标内存是否重叠。标准规定，INLINECODE198698ec 的行为在内存重叠时是未定义的。这意味着结果可能是正确的，也可能是一团乱麻，这取决于具体的编译器和数据分布。

让我们看一个导致数据损坏的例子

假设我们要在一个字符串内部进行复制，将数据从开头移动到偏移 5 个字节的位置。这就像是把桌子上的书往后挪，如果操作不当，你会踩到还没移动的书。

#include 
#include 

int main() {
    // 源字符串
    char csrc[100] = "Geeksfor"; 

    // 这里试图将 csrc 的内容复制到 csrc+5 的位置
    // 这将导致内存区域重叠：[0...8] 和 [5...13] 重叠
    memcpy(csrc + 5, csrc, strlen(csrc) + 1);
    
    printf("最终结果: %s
", csrc);
    return 0;
}

可能的输出（具体取决于运行环境）：

最终结果: GeeksGeeksGeek

为什么会出现乱码？

当你执行 INLINECODE1879c96f 且 INLINECODEdacd9e31 但两者有重叠时：

  • 机器首先复制 INLINECODE3b369aec (‘G‘) 到 INLINECODE6cc64542。注意这里的 INLINECODEa638c443 其实就是原始字符串的 INLINECODE7cc75425 位置。现在 src[5] 变成了 ‘G‘，原来的 ‘f‘ 被覆盖了。
  • 接下来机器复制 INLINECODE359ce0d6 到 INLINECODEb414d791。但是等等，此时 src 的内容已经被上一步的操作修改了！

这种“破坏性读取”导致了数据丢失。为了解决这个问题，我们需要一个更强大的函数：memmove。

解决方案：实现稳健的 memmove

memmove 函数的设计初衷就是为了处理内存重叠的情况。它保证即使源和目标区域重叠，数据也能被正确复制。

方法一：使用临时缓冲区（直观但低效）

最直观的方法是引入一个“中转站”。我们先把源数据复制到一个临时的缓冲区，然后再从临时缓冲区复制到目标地址。这样，无论原始数据怎么被覆盖，我们手里都有一份完整的备份。

#include 
#include 
#include  // 需要用于动态内存分配

/**
 * 实现版本 A：使用临时数组的 memmove
 * 优点：逻辑简单，易于理解，总是正确的。
 * 缺点：需要额外的 O(n) 空间，且由于多了一次拷贝，速度较慢。
 */
void* myMemMove_Buffer(void *dest, const void *src, size_t n) {
    char *csrc = (char *)src;
    char *cdest = (char *)dest;

    // 分配一个临时数组来保存数据
    // 注意：在真实系统中需要检查 malloc 是否成功，这里为了演示简洁省略
    char *temp = (char *)malloc(n);

    if (temp == NULL) {
        return NULL; // 内存分配失败
    }

    // 第一步：将数据从 src 复制到 temp
    for (size_t i = 0; i < n; i++) {
        temp[i] = csrc[i];
    }

    // 第二步：将数据从 temp 复制到 dest
    for (size_t i = 0; i < n; i++) {
        cdest[i] = temp[i];
    }

    // 释放临时内存
    free(temp);

    return dest;
}

// 测试程序
int main() {
    char csrc[100] = "Geeksfor";
    
    // 这次我们使用自己的 memmove
    myMemMove_Buffer(csrc + 5, csrc, strlen(csrc) + 1);
    printf("使用临时缓冲区修复后的结果: %s
", csrc);
    
    return 0;
}

输出结果：

使用临时缓冲区修复后的结果: GeeksGeeksfor

虽然这个方法解决了正确性问题，但它并不是最优解。它占用了双倍的带宽（从 RAM 读到临时数组，再写回 RAM），这在性能敏感的场景下是不可接受的。

方法二：智能判断拷贝方向（标准做法）

真正高效的 memmove 实现并不会分配临时内存。相反，它会通过比较源地址和目标地址的大小，智能地选择拷贝的方向：正向拷贝或反向拷贝。

核心逻辑：

  • 无重叠：如果 INLINECODE8fac4875 和 INLINECODE266062ef 没有重叠，或者 INLINECODE38e74ab3（目标在源之前），我们可以放心地从前向后复制。这和 INLINECODE71115710 是一样的。
  • 有重叠且 dest > src：如果目标地址在源地址之后且发生重叠，我们必须从后向前复制。想象一下搬运书，如果你要把书往后挪（源在前，目标在后），你必须从最后那本书开始搬，否则你会踩到还没搬的书。同理，如果你要把书往前挪（源在后，目标在前），你必须从第一本开始搬。

#### 代码示例 2：高性能版 memmove（反向拷贝逻辑）

这个实现展示了系统库级别代码的智慧。

#include 
#include 

/**
 * 实现版本 B：智能判断拷贝方向的 memmove
 * 优点：不需要额外内存 O(1) 空间，只需一次遍历，性能极高。
 */
void* myMemMove_Optimized(void *dest, const void *src, size_t n) {
    char *csrc = (char *)src;
    char *cdest = (char *)dest;

    // 检查是否存在重叠并且目标地址在源地址之后
    if (cdest > csrc && cdest  必须从后向前拷贝
        // 我们将指针移动到数组的末尾
        csrc = csrc + n - 1;
        cdest = cdest + n - 1;

        while (n--) {
            // 从尾部开始，反向逐个字节复制
            *cdest-- = *csrc--;
        }
    } else {
        // 情况 1: 没有重叠，或者目标在源之前 -> 从前向后拷贝
        // 这是和 memcpy 一样的逻辑
        while (n--) {
            *cdest++ = *csrc++;
        }
    }

    return dest;
}

int main() {
    char csrc[100] = "Geeksfor";
    
    printf("原始字符串: %s
", csrc);
    
    // 这里的目标地址 csrc+5 大于源地址 csrc，且发生重叠
    // 函数将自动选择反向拷贝
    myMemMove_Optimized(csrc + 5, csrc, strlen(csrc) + 1);
    
    printf("智能拷贝后的结果: %s
", csrc);
    
    // 验证另一种情况：目标在源之前
    char csrc2[100] = "HelloWorld";
    printf("
原始字符串 2: %s
", csrc2);
    myMemMove_Optimized(csrc2, csrc2 + 5, strlen(csrc2 + 5) + 1);
    printf("移动后(左移): %s
", csrc2);
    
    return 0;
}

性能优化的进阶视野

我们现在的实现已经是非常健壮的 O(n) 级别代码了。但在现代 CPU 架构上，memcpy 的速度往往是纳秒级的。标准库（如 glibc）的实现通常比我们上面的循环要快得多。为什么？因为它们利用了硬件特性。

字对齐与宽指令

现在的 CPU 通常是 32 位或 64 位的。这意味着 CPU 一次性可以读写 4 个字节或 8 个字节。如果我们一次只复制 1 个字节（char），实际上浪费了 CPU 87.5% (32位机) 甚至 93.75% (64位机) 的总线带宽。

优化思路：

  • 处理头部：如果源地址不是 4 或 8 字节对齐的，先用字节拷贝的方式将指针对齐到下一个边界。
  • 循环主体：一旦对齐，我们可以使用 INLINECODEf69c53f9（4字节）或 INLINECODE7f739374（8字节）甚至 SIMD 寄存器（128/256/512字节）来进行批量拷贝。这将循环次数减少到了原来的 1/4 或 1/8。
  • 处理尾部：最后剩下的不足 4 或 8 字节的部分，再切换回字节拷贝。

这种优化极大地减少了指令的执行次数，从而显著提升了性能。

指针限制说明

在许多嵌入式系统中，访问未对齐的内存地址可能会导致硬件异常。因此，标准库实现通常会极其小心地处理对齐问题，或者使用编译器内置的指令（如 __builtin_memcpy）来生成最优的汇编代码。

总结与最佳实践

通过这篇文章，我们从零构建了属于自己的内存操作函数，并深入探究了底层的实现细节。让我们回顾一下关键点：

  • memcpy 是简单的：它只是一个逐字节复制的循环，适用于不重叠的内存块。它速度快，但在重叠时数据不安全。
  • memmove 是稳健的：它通过检查指针重叠情况，智能选择正向或反向拷贝，从而保证了数据的完整性。
  • 优化无止境：从 O(1) 空间的算法优化，到利用 CPU 字长进行批量拷贝，每一层优化都能带来巨大的性能提升。

实战建议

在日常开发中，我们通常不需要自己写 memcpy，编译器自带的通常是最优的。但是，理解这些原理能帮助你：

  • 调试内存错误：当你遇到奇怪的字符乱码时，你能迅速联想到是否发生了内存重叠覆盖。
  • 嵌入式开发：在无法使用标准库的裸机开发中，你可以自信地写出高效的内存操作代码。
  • 性能分析：当你看到 profiler 显示热点在内存拷贝时，你会知道如何思考（是否对齐？是否重叠？是否可以用 SIMD？）。

希望这次探索能让你对 C 语言的内存管理有更深的理解。现在，不妨打开你的 IDE，尝试修改上面的代码，加入对 int 类型的批量拷贝支持，看看性能会有怎样的变化！祝你编码愉快！

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/42345.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年