一、开场:两个签名几乎一样的函数

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

参数列表完全相同,返回值也相同。它们唯一的区别写在标准里,却决定了程序是"能跑"还是"随时可能翻车":

  • memcpy:源和目标区域重叠时,行为未定义(undefined behavior,UB)。

  • memmove:源和目标区域重叠时,行为完全确定,结果就是"把 src 的 n 个字节搬到 dst"。

二、memcpy 的原理:能有多简单就多简单

/* 最朴素的实现:只是把字节一个个搬过去,不做任何检查 */
void *memcpy(void *dst, const void *src, size_t n)
{
    unsigned char       *d = dst;
    const unsigned char *s = src;

    while (n--)
        *d++ = *s++;          /* 注意:这里没有考虑 s 和 d 是否重叠 */

    return dst;
}

这段代码能编译、能运行、性能也不算差,但它有一个致命前提:d 和 s 指向的两段内存不能重叠。

一旦重叠,*d++ = *s++ 的执行顺序就会把"还没读的源字节"提前覆盖掉:

/* 反例:src 与 dst 重叠 11 个字节 */
unsigned char buf[16] = {0};
memcpy(buf, buf + 1, 12);       /* UB! */

/* 正序执行时的实际过程: */
/* buf[0] = buf[1]  -> buf[1] 被改写,但它早已读出,OK */
/* buf[1] = buf[2]  -> buf[2] 还没被碰过,OK   */
/* buf[2] = buf[3]  -> OK                      */

这一次恰好是 dst < src,正序拷贝"碰巧"是对的。但换个方向就全错:

/* dst 在后:必须倒序抄,正序就毁了数据 */
unsigned char buf[16] = {0};
memcpy(buf + 1, buf, 12);       /* UB! */

/* 正序执行时: */
/* buf[1] = buf[0]   -> buf[1] 被改写  */
/* buf[2] = buf[1]   -> 读到的 buf[1] 已经是改过的值  ❌ */
/* buf[3] = buf[2]   -> 同样是改过的值                ❌ */

memcpy 的优点与缺点

优点:路径最短、性能天花板最高、可被编译器内联成向量 load/store、无重叠判断开销。

缺点:重叠时行为未定义;结果可能"看起来对"从而掩盖 bug;编译器有权据此做激进优化。

三、memmove 的原理:多做一个方向判断

memmove 的实现核心,只有一件事——比较 dst 和 src 的地址谁小,然后选一个不会破坏未读源数据的拷贝方向。

void *memmove(void *dst, const void *src, size_t n)
{
    unsigned char       *d = dst;
    const unsigned char *s = src;

    if (d == s || n == 0)
        return dst;

    if (d < s) {
        /* 目标在前(地址更低):正序写,每次写的目标位置都已经读完了 */
        for (size_t i = 0; i < n; i++)
            d[i] = s[i];
    } else {
        /* 目标在后(地址更高):倒序写,保证未读的源字节不被提前覆盖 */
        for (size_t i = n; i > 0; i--)
            d[i - 1] = s[i - 1];
    }
    return dst;
}

正序拷贝 dst = base, src = base + 1 时:

base[0] = base[1]   ← base[1] 已被覆盖,但它早就读完了
base[1] = base[2]   ← base[2] 还没被碰过 ✓
base[2] = base[3]   ✓

倒序拷贝 dst = base + 1, src = base 时:

base[3] = base[2]   ← base[2] 还没被碰过 ✓
base[2] = base[1]   ✓
base[1] = base[0]   ✓

memmove 的优点与缺点

优点:重叠时结果完全确定,语义有标准背书;dst == src 有快速返回;写通用库时的默认安全选择。

缺点:比 memcpy 多一次指针比较和方向分支;重叠时可能走倒序路径,硬件预取器不友好,有额外惩罚;超大块 + 重叠是实测最慢的分支。

四、什么时候用哪个

用 memcpy:

  • 源和目标确定不重叠(dst 和 src 来自不同的分配、不同对象、或明确知道地址差大于 n)。

  • 拷贝的是 POD / 平凡可复制类型的内容。

  • 想让编译器尽可能把它优化成内联的向量 load/store。

用 memmove:

  • 你无法确定是否重叠 —— 比如写通用库、内部数据结构自己也不知道调用方会不会传重叠的缓冲区。这是最常见也最重要的理由。

  • 原地搬移:数组插入/删除、区间合并、环形缓冲区展开、滑动窗口。

  • memcpy 的替代品出现在你只是想"把一段数据挪个位置"的场景。

一个实用原则:如果你在写的是"只给自己用的一次性代码",且你能证明不重叠,用 memcpy 换取一点点性能;如果你在写给别人用的代码(库、组件、基础设施),默认用 memmove —— 一次几纳秒的判断,换来"永远不用为重叠操心"。

Logo

更多推荐