memcpy() 和 memmove() 有什么区别？

最新推荐文章于 2025-04-04 10:44:12 发布
最新推荐文章于 2025-04-04 10:44:12 发布
阅读量835 收藏 1
点赞数
分类专栏： 面试笔试 文章标签： dst 编译器 算法 string linux c
本文详细解析memcpy和memmove函数在处理内存复制时的不同行为，特别是面对内存重叠情况时的表现差异。同时，通过分析内核实现，揭示如何利用指令集特性实现更高效的内存复制操作，包括四倍速memmove优化策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

如果源和目的参数有重叠, memmove() 提供有保证的行为。而 memcpy()  则不能提供这样的保证, 因此可以实现得更加有效率。如果有疑问, 最好使用 memmove()。

参考资料: [K&R2, Sec. B3 p. 250]; [ISO, Sec. 7.11.2.1, Sec. 7.11.2.2]; [Rationale, Sec. 4.11.2]; [H&S, Sec. 14.3 pp. 341-2]; [PCS, Sec. 11 pp. 165-6]。

 

参考linux 内核实现：

 

memcpy：

  1. /**
  2.  * memcpy - Copy one area of memory to another
  3.  * @dest: Where to copy to
  4.  * @src: Where to copy from
  5.  * @count: The size of the area.
  6.  *
  7.  * You should not use this function to access IO space, use memcpy_toio()
  8.  * or memcpy_fromio() instead.
  9.  */
  10. void * memcpy(void * dest,const void *src,size_t count)
  11. {
  12.     char *tmp = (char *) dest, *s = (char *) src;
  13.     while (count--)
  14.         *tmp++ = *s++;
  15.     return dest;
  16. }

memmove：

  1. /* Normally compiler builtins are used, but sometimes the compiler calls out
  2.    of line code. Based on asm-i386/string.h.
  3.  */
  4. #define _STRING_C
  5. #include <linux/string.h>
  6. #undef memmove
  7. void *memmove(void * dest,const void *src,size_t count)
  8. {
  9.     if (dest < src) { 
  10.         __inline_memcpy(dest,src,count);
  11.     } else {
  12.         char *p = (char *) dest + count;
  13.         char *s = (char *) src + count;
  14.         while (count--)
  15.             *--p = *--s;
  16.     }
  17.     return dest;
  18. } 

memcpy函数假设要复制的内存区域不存在重叠，如果你能确保你进行复制操作的的内存区域没有任何重叠，可以直接用memcpy；   
  如果你不能保证是否有重叠，为了确保复制的正确性，你必须用memmove。   
    
  至于什么是重叠，例如：   
  你要把从0x00000040开始的10个字节的内容复制到从0x00000045开始的区域去，这就存在重叠了！

 

文章二：http://blog.chinaunix.net/u/22520/showart_430430.html

 

memcpy和memmove的区别
 
 
memcpy（）和memmove（）都是C语言中的库函数，在头文件string.h中，其原型分别如下：
 

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

 
它们都是从src所指向的内存中复制count个字节到dst所指内存中，并返回dst的值。当源内存区域和目标内存区域无交叉时，两者的结果是一样的，但如果有交叉呢？先看下图：
 

图的上半部分为源内存区域在目标内存区域右边，下半部分为源内存区域在目标区域左边，源内存区域和目标内存区域都有交叉。

memcpy（）是从src的起始部分开始复制，所以虽然第一种情况下没有问题，但如果遇到第二种情况，则会发生错误，如图所示，后两个字节在被复制前已经被覆盖掉了。而memmove（）则由于采用了不同的复制机制，所以可以正确处理第二种情况。

VS.NET2003中所附源码如下（有删）：

void * __cdecl memcpy (void * dst, const void * src, size_t count)
{
        void * ret = dst;

        /*
         * copy from lower addresses to higher addresses
         */
        while (count--) {
                *(char *)dst = *(char *)src;
                dst = (char *)dst + 1;
                src = (char *)src + 1;
        }

        return(ret);
}

void * __cdecl memmove (void * dst, const void * src, size_t count)
{
        void * ret = dst;

        if (dst <= src || (char *)dst >= ((char *)src + count)) {
                /*
                 * Non-Overlapping Buffers
                 * copy from lower addresses to higher addresses
                 */
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst + 1;
                        src = (char *)src + 1;
                }
        }
        else {
                /*
                 * Overlapping Buffers
                 * copy from higher addresses to lower addresses
                 */
                dst = (char *)dst + count - 1;
                src = (char *)src + count - 1;

                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst - 1;
                        src = (char *)src - 1;
                }
        }

        return(ret);
}

文章三：写程序是一种态度（二）四倍速memmove

http://www.chinaitpower.com/A/2001-10-17/2036.html

 

我提到MS run-time用C来实现函数如strcmp只是算法的表征，相对应的都有asm文件如strcmp.asm才是对其算法的具体的针对Intel指令集的高效实现。如此可以做一个也许不恰当的类比，strcmp.c是一个伪码描述，而strcmp.asm才是具体实现；因为用某种c编译器编译后的strcmp.c很可能没有直接的strcmp.asm更高效，尽管算法的思路没有变化。借着这个话题我们在看一看经典的memcpy和memmove：

 

void * __cdecl memcpy (

        void * dst,

        const void * src,

        size_t count

        )

{

        void * ret = dst;

 

        /*

         * copy from lower addresses to higher addresses

         */

        while (count--) {

                *(char *)dst = *(char *)src;

                dst = (char *)dst + 1;

                src = (char *)src + 1;

        }

 

        return(ret);

}

 

void * __cdecl memmove (

        void * dst,

        const void * src,

        size_t count

        )

{

        void * ret = dst;

 

        if (dst <= src || (char *)dst >= ((char *)src + count)) {

                /*

                 * Non-Overlapping Buffers

                 * copy from lower addresses to higher addresses

                 */

                while (count--) {

                        *(char *)dst = *(char *)src;

                        dst = (char *)dst + 1;

                        src = (char *)src + 1;

                }

        }

        else {

                /*

                 * Overlapping Buffers

                 * copy from higher addresses to lower addresses

                 */

                dst = (char *)dst + count - 1;

                src = (char *)src + count - 1;

 

                while (count--) {

                        *(char *)dst = *(char *)src;

                        dst = (char *)dst - 1;

                        src = (char *)src - 1;

                }

        }

 

        return(ret);

}

 

这里我省掉了

#if defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC) || defined (_M_IA64)

编译开关里的CODE，针对这些目标机有另外的处理，我们现在只定位于Intel 32-bit上。

1．文档中说的很清楚memcpy不考虑内存重叠，而memmove会考虑，实际上代码中很明显，memcpy只是memmove的一个子集，所以建议总是用memmove这样可以不考虑内存重叠问题。

 

2．考虑能否用C++去描述更精炼？如从低地址到高地址的赋值可以简单写成：

 

        while (count--) {

                *dst ++ = *src ++;

        }

 

3．c编译器对以上代码编译后所产生的指令是否是一个字节一个字节拷贝？

 

4．问题3将带来我们对副标题的讨论--四倍速

 

Intel 80386以上支持的指令集中MOVSD指令和REP指令配合将DWORD（32bit）在内存间移动，即在一个时钟周期copy四个字节，整整比MOVSB（8bit）指令快了四倍。但是使用MOVSD移动到的目的内存地址必须是32bit对齐的（DWORD-aligned）。简单说明从低位到高位的内存copy如下。

设L为要拷贝的总字节数，Dest为目的起始地址，X为从Dest开始没有DWORD-aligned的字节数，Y为要拷贝的DWORD个数，Z为剩余的没有DWORD-aligned字节数。那么有公式如下：

 

X = (4 – Dest & 3 ) & 3 (bytes)           //低两位为0的地址是DWORD-aligned

Y = (L – X) >> 2 (DWORDs)             //整除以4是DWORD个数

Z = (L – X – Y * 4) (bytes)

            再做相应的处理。   

 

总结一下，对大段的内存移动，用memmove将是非常优化的，相反若用c写的code会降低四倍效率，这就是为什么要用ASM直接实现的原因。

深入理解memcpy与memmove：内存操作的基石
2301_80176093的博客
08-08 3830
在C语言（以及许多其他支持指针和内存操作的编程语言）中，memcpy和memmove是两个非常重要的函数，它们用于内存块的复制。虽然它们的目标相似，但在处理重叠内存区域时，它们的行为却截然不同。本文将深入探讨这两个函数的特性、区别及应用场景。memcpymemcpy函数是C标准库（string.h）中的一个函数，用于从源内存地址的起始位置开始拷贝n个字节到目标内存地址。srcn。
C语言的memcpy和memmove
gogo0707的博客
05-05 1252
浅谈memcpy和memmove POSIX和C标准明确表示，使用重叠区域的mem‐cpy()会产生未定义的行为。 他们两个唯一的区别是：当内存发生局部重叠时memmove函数能够保证拷贝结果的正确性，而memcpy则不能保证拷贝结果的正确性；当内存没有发生重叠的时候两个函数的结果是一样的。 为什么说memcpy不能保证拷贝结果的正确性，可以看看下面这个例子。 当src和dst重合（即内存重叠），如下图所示： ...
memmove 和 memcpy的区别
Change
06-19 1153
原文链接：http://blog.chinaunix.net/uid-26495963-id-3080058.html memcpy和memmove（）都是C语言中的库函数，在头文件string.h中，作用是拷贝一定长度的内存的内容，原型分别如下： void *memcpy(void *dst, const void *src, size_t count); void *memm
memcpy and memmove
10-25 645
12.25 memcpy() 和 memmove() 有什么区别？     如果源和目的参数有重叠, memmove() 提供有保证的行为。而 memcpy()  则不能提供这样的保证, 因此可以实现得更加有效率。如果有疑问, 最好使用 memmove()。 参考资料: [K&R2, Sec. B3 p. 250]; [ISO, Sec. 7.11.2.1, Sec. 7.11.2.2]; [
memmove和memcpy区别
热门推荐
bajianxiaofendui的博客
02-12 2万+
memmov和memcpy区别 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;memcpy()和memmove()都是c语言的库函数，在头文件string.h 中，作用是拷贝一定长度内存的内容。它们唯一的区别是当内存发生局部重叠时，memmove可以保证拷贝正确，memcpy拷贝的结果是未定义的（取决于编译平台内部对memcpy的优化处理）。函数声明如下： void * memmov...
memmove和memcpy的区别
谦言万语的专栏
08-14 1477
1.memmove 函数原型：void *memmove(void *dest, const void *source, size_t count) 返回值说明：返回指向dest的void *指针 参数说明：dest,source分别为目标串和源串的首地址。count为要移动的字符的个数 函数说明：memmove用于从source拷贝count个字符到dest，如果目标区域和源区域有重叠的
关于memcpy和memmove的一点重要说明
12-25
今天看到书上降到memcpy和memmove的区别才突然发现原来两者之间有如此区别,以前只知道这两个函数是 实现同样的功能，没有接触到其不同。 memcpy和memmove在MSDN的定义如下： 从两者的声明来看的确没有区别,我们来...
C++中memcpy和memmove的区别总结
12-31
那么既然memcpy和memmove二者都是内存拷贝，那二者究竟有什么区别呢？ 先说memcpy 你有没有好好的参加过一场C++笔试。让你写出memcpy的实现，这是多么常见的笔试题啊。现在，拿起你的演算纸和笔;是的，是笔和纸，...
# 深入解析 C 语言中的 memcpy 与 memmove：内存操作的双雄
最新发布
lhxcc_fly的博客
04-04 868
memcpy` 和 `memmove` 是 C 语言中用于内存操作的两个重要函数。`memcpy` 假设源内存和目标内存之间没有重叠，因此在没有重叠的情况下效率更高；而 `memmove` 能够正确处理内存重叠的情况，虽然可能会稍微慢一些，但提供了更高的安全性。在实际编程中，如果不确定内存是否重叠，建议优先使用 `memmove`，以确保程序的健壮性。
memcpy与memmove区别？
alane1986的专栏
10-22 622
memcpy与memmove都是实现内存的拷贝，但是在实现方式上不同。memcpy没有考虑源地址与目标地址内存空间是否重叠，均采用从低向高字节拷贝。而memmove考虑了内存重叠与内存不重叠的情况。当内存区域有重叠的时候memmove是从高往低开始copy的，当内存区域没有重叠的时候memmove是从低向高开始copy的。   举例来说：void main(){     char s
memcpy和memmove的区别
little train的博客
01-21 292
memcpy和memmove函数作用都是拷贝一定长度内存的内容，函数存在头文件string.h中，函数原型如下： //将src指向的内存内容的count长度内容拷贝到dst指向的内存中 void* memcpy(void* dst, const void* src, size_t count); void* memmove(void* dst, const void* src, size_t count); 两个函数作用一样，但是当拷贝内存发生重叠时，memmove能够保证拷贝结果的正确，memcpy
memcpy与memmove的区别
m0_62126248的博客
03-28 2285
快速区分memcpy与memmove函数
库函数memcpy()与memmove()实现
maimang1001的专栏
09-16 505
根据MSDN文档，当源区域与目标区域存在重叠时，memcpy()函数报错，而memmove()函数可以处理重叠情况！  1/*   2 * 函数名: memcpy   3 * 功  能: 从源source中拷贝n个字节到目标destin中   4 * 用  法: vo
memcpy vs memcpy_toio
chaos的博客
03-16 2231
环境：Linux kernel 5.15.78 aarch64 armv8现象：使用vmap()以nocache的形式映射一段物理地址，使用memcpy()往其中写入数据，在写入最后64字节时发生如下错误确认并未发生溢出，且使用memcpy_toio()或以cache形式映射则不会有这个问题。网上搜了一圈没发现很好的解释，遂read the fxxking source code，趁热记录下来。本文主要探讨两个问题：1.memcpy()及memcpy_toio()的差别；
linux内核编程memcpy,Linux内核中memcpy和memmove函数的区别和实现
weixin_27379781的博客
04-30 302
● memcpy是把src指向的对象中的size个字符拷贝到dest所指向的对象中，返回指向结果对象的指针。● memmove也是把src指向的对象中的size个字符拷贝到dest所指向的对象中，返回指向结果对象的指针，但这两个函数在处理内存区域重叠的方式不同。注意memmove这个函数名称中有“move”这个单词，而实际上src处的数据仍然还在，并没有真的被“移动”了！这个函数名称有它的历史原因...
memcpy和memmove区别
03-14
<think>好的，用户之前询问了关于memcpy优化插入排序的问题，现在他们想了解memcpy和memmove的区别。我需要确保解释清楚这两个函数的区别，尤其是在处理内存重叠时的不同行为。 首先，用户可能是在学习C语言的内存操作函数，或者在优化代码时遇到了问题。他们可能已经知道memcpy和memmove的基本用法，但需要更深入的理解，特别是在插入排序中使用memmove的原因。 我需要明确两者的核心区别：memcpy不处理内存重叠，而memmove可以。必须强调为什么在插入排序中使用memmove是必要的，比如在移动数组元素时，源和目标区域可能重叠，这时候memcpy会导致未定义行为，而memmove能正确处理这种情况。 另外，用户可能对性能有疑问，比如为什么memmove有时候被认为更慢，但实际在需要处理重叠时它是唯一安全的选择。需要解释两者的实现机制，可能涉及复制方向的不同，比如从前往后还是从后往前复制，以避免数据覆盖。 还要举一些具体的例子，比如当源地址在目标地址之前或之后时，memmove如何处理，而memcpy在这种情况下可能出错。这会帮助用户更直观地理解两者的差异。 最后，总结适用场景，明确什么时候使用memcpy，什么时候必须用memmove。这可能帮助他们在未来的编程中避免错误，并优化代码的正确性和效率。</think>#### memcpy与memmove的核心区别 --- ##### **1. 内存重叠处理能力** | 函数 | 是否允许内存重叠 | 行为特点 | |----------|------------------------------|----------------------------| | `memcpy` | **不允许**（未定义行为） | 假设源地址和目标地址**完全独立** | | `memmove`| **允许**（自动处理重叠） | 检测重叠区域，智能选择复制方向 | --- ##### **2. 实现原理对比** - **`memcpy`**：简单**正向逐字节复制** ```c // 伪代码示例 void* memcpy(void* dest, const void* src, size_t n) { char* d = (char*)dest; const char* s = (const char*)src; while(n--) *d++ = *s++; // 从低地址向高地址复制 return dest; } ``` - **`memmove`**：根据内存重叠情况**动态选择复制方向** ```c // 伪代码示例 void* memmove(void* dest, const void* src, size_t n) { char* d = (char*)dest; const char* s = (const char*)src; if(s < d && s + n > d) { // 检测正向复制是否会导致覆盖 d += n; s += n; // 改为从高地址向低地址复制 while(n--) *--d = *--s; } else { while(n--) *d++ = *s++; } return dest; } ``` --- ##### **3. 典型场景演示** **场景1：内存无重叠** ```c char str[] = "ABCDEF"; memcpy(str+2, str, 3); // 危险！实际存在重叠 memmove(str+2, str, 3); // 安全复制 ``` **场景2：内存正向重叠（源地址 < 目标地址）** ```plaintext 原内存： [A][B][C][D][E] (地址递增) 操作： 复制前3个元素到位置2 memcpy结果： [A][B][A][B][C] ❌ 错误覆盖 memmove结果：[A][B][A][B][C] ✅ 正确（实际反向复制） ``` **场景3：内存反向重叠（源地址 > 目标地址）** ```plaintext 原内存： [A][B][C][D][E] 操作： 复制后3个元素到位置0 memcpy结果： [C][D][E][D][E] ❌ 错误 memmove结果：[C][D][E][D][E] ✅ 正确（正向复制） ``` --- ##### **4. 性能差异** | 指标 | memcpy | memmove | |------------|----------------------|----------------------| | **速度** | 更快（无额外检测） | 稍慢（有方向判断） | | **安全性** | 低（需手动确保安全） | 高（自动处理重叠） | --- ##### **5. 使用规范** - **必须用`memmove`的场景**： ```c // 插入排序元素移动（源与目标区域重叠） memmove(&arr[pos+1], &arr[pos], (i-pos)*sizeof(int)); // 缓冲区滑动窗口处理 memmove(buffer, buffer+100, 500); // 前移数据 ``` - **可以用`memcpy`的场景**： ```c // 结构体到结构体的复制 struct Data a, b; memcpy(&b, &a, sizeof(struct Data)); // 独立内存块复制 char src[100], dest[200]; memcpy(dest+50, src, 100); // 确保无重叠 ``` --- #### 总结对比表 | 特征 | memcpy | memmove | |--------------|---------------------------------|---------------------------------| | 内存重叠 | 导致数据损坏 | 自动正确处理 | | 性能 | 更快 | 稍慢但安全 | | 使用复杂度 | 需开发者保证无重叠 | 无需考虑重叠问题 | | 典型应用场景 | 独立内存块快速复制 | 滑动窗口、排序算法等重叠操作 |
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值