memcpy与memmove的实现

最新推荐文章于 2025-04-04 10:44:12 发布

chinaunixj

最新推荐文章于 2025-04-04 10:44:12 发布

阅读量687

点赞数

分类专栏：编程基础文章标签： dst null c

编程基础专栏收录该内容

12 篇文章

订阅专栏

本文详细解析memcpy和memmove的区别，重点讨论它们在处理内存区域重叠时的行为差异，并通过源码分析展示如何实现memmove以避免重叠区域的冲突。文章还提供了实际代码示例，帮助读者更好地理解和应用这两个函数。

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

/* memcpy是不管有否区域重叠的，重叠不重叠照样复制， memmove才会避免区域重叠，检测这个区域重叠很简单，如果目标地址在源区域内，那就会发生重叠. 处理重叠也很简单，从源地址的末尾开始反方向复制就OK了。未重叠的情况: 内存布局(little endian): higher address lower address

|--------------------------------------|

src

|------------|

|-----------| |------------|

dest dest

目标区域的首地址在源区域内，就发生重叠了。 higher address src(lower address) |---------------------| |---------------------| dest */ //下面是memmove源码的一段： #include <stdio.h> #include <string.h> #include <stdlib.h> /* ============== my_memmove() ==============*/ #if 1 void *my_memmove(void *dest, const void *src, size_t n) { void *pdest = dest; if(NULL == dest && NULL == src && (n == 0)) { return; } if((dest <= src) || (char *)dest >= ((char *)src + n)) { /* * Non Overlapping Buffers * copy from lower address to higher address * 正向拷贝 */ while(n--) { *(char *)dest = *(char *)src; dest = (char *)dest + 1; src = (char *)src + 1; } } else { /* * Overlapping Buffers * copy from higher address to lower address * 反向拷贝 */ dest = (char *)dest + n - 1; src = (char *)src + n - 1; while(n--) { *(char *)dest = *(char *)src; dest = (char *)dest - 1; src = (char *)src - 1; } } return pdest; } #else void* my_memmove(void *dest, const void *src,size_t n) { if(NULL == dest && NULL == src && (n == 0)) { return; } int i; char *pdest = (char *)dest; char *psrc = (char *)src; if((pdest <= psrc) || (pdest >= psrc + n)) { /* 正向拷贝 */ for(i = 0; i < n; ++i) { *pdest++ = *psrc++; } } else { /* 反向拷贝 */ pdest = pdest + n -1; psrc = psrc + n - 1; for(i = 0; i < n; ++i) { *pdest-- = *psrc--; } } return dest; } #endif /* =============== my_memcpy() ==============*/

//pDest < pSrc 顺序拷贝，否则逆序#if 1 void *my_memcpy(void *dest, const void *src, size_t n) { char *pdest = (char*)dest; const char *psrc = (char *)src; size_t i; if(NULL == dest && NULL == src && (n == 0)) { return; } if((pdest > psrc) && (pdest < psrc + n)) { /* 反向拷贝 */ for(i = n - 1; i <= 0; ++i) { pdest[i] = psrc[i]; } } else { /* 正向拷贝 */ for(i = 0; i < n; ++i) { pdest[i] = psrc[i]; } } pdest = '\0'; return pdest; } #else /* ================ libc ==================*/ void *memcpy(void *dst, const void *src, size_t n) { void *ret = dst; if(NULL == src && NULL == dst) { return; } while(n--) { *(char *)dst = *(char *)src; dst = (char *)dst + 1; src = (char *)src + 1; } return ret; } #endif

c++ 版:pDest < pSrc 顺序拷贝，否则逆序

void *memCopy(void *dest,const void *src,size_t count)
{
    char *pDest=static_cast<char *>(dest);
    const char *pSrc=static_cast<const char *>(src);
    if( pDest>pSrc && pDest<pSrc+count )
    {
        for(size_t i=count-1; i<=0; ++i)
        {
            pDest[i]=pSrc[i];
        }
    }
    else
    {
        for(size_t i=0; i<count; ++i)
        {
             pDest[i]=pSrc[i];
        }
    }
    return pDest;
}

另一个单不考虑不重叠的情况: memcpy, 拷贝不重叠的内存块
void *memcpy(void* pvTo, void* pvFrom, size_t size)
{
assert(pvTo != NULL && pvFrom != NULL);

void* pbTo = (char *)pvTo;
void* pbFrom = (char *)pvFrom;

    /* 内存块重叠吗？如果重叠，就使用memmove */
    assert(pbTo>=pbFrom+size || pbFrom>=pbTo+size);
    while(size--)
    {

*pbTo++ == *pbFrom++;
}

return pvTo;
}

int main(int argc, char *argv[]) { char *str = "I'm study c"; char *dst = NULL; dst = (char *)malloc(sizeof(char) + 1 * sizeof(char)); printf("after call my_memmove():\n"); my_memmove(dst, str, strlen(str)); printf("dst = %s\n", dst); printf("after call my_memcpy():\n"); my_memcpy(dst, str, strlen(str)); printf("dst = %s\n", dst); free(dst); return 0; }