memcpy 与 memmove:一次“重叠“引发的分工
一、开场:两个签名几乎一样的函数
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 —— 一次几纳秒的判断,换来"永远不用为重叠操心"。
更多推荐



所有评论(0)