当前位置：首页 > news >正文

C语言实现memcpy、memmove库函数

news 2025/7/30 7:51:03

引言

关于memcpy和memmove这两个函数，不论是算法竞赛还是找工作面试笔试，对这两个函数必然是经常都会用到，而且面试的时候很有可能会让你把代码复现出来，也许会问你这两个库函数的区别，这都是你自学才能知道的，所以也是很能体现你实力的一种，所以说很重要，话不多说了，那就开始介绍吧。

一、库函数介绍

#include <cstring>  // CPP版头文件
#include <string.h>  //C版头文件void *memcpy(void *dest, const void *src, size_t count); 
void *memmove(void *dest, const void *src, size_t count);

功能：把从src开始的n个字节拷贝到以dest开始的内存区域中，返回dest（可进行链式嵌套调用）
在这里插入图片描述

区别: memcpy要求在使用时这两块区域不能有重叠，也就是不能出现自拷贝的情况，而memmove则保证在有重叠的情况下，结果是正确的。

二、库函数详解

memcpy:强转为char*，解引用从前到后依次赋值count次。

但是遇到如下图的情况：在src赋值的同时会把自己原本的值给覆盖掉，就会出现与使用者本意不相符的情况发生，所以memcpy不允许这两块区域重叠。
在这里插入图片描述

但如果是如下图这种情况：dest会跟本意一样，只不过src有些变了，但目的还是dest所以这个是没关系的，所以这种情况不考虑，因为设计者也是这么写的。
在这里插入图片描述

memmove：遇到有可能发生重叠的情况，从后往前赋值，就不会出错了，可以看图想想。
在这里插入图片描述

三、源码实现

这里值得注意的就是*d++这块，++优先级高，所以先d++，结果为d，然后*d，语句结束后d才++。

1.memcpy源码实现

void* memcpy(void* dest, const void* src, size_t count)
{if (dest == NULL || src == NULL || count == 0) return dest;char* d = (char*)dest;char* s = (char*)src;while (count--){*d++ = *s++;}return dest;
}

2.memmove源码实现

void* memmove(void* dest, const void* src, size_t count)
{if (dest == NULL || src == NULL || count == 0) return dest;char* d = (char*)dest;char* s = (char*)src;if (dest < src){while (count--){*d++ = *s++;}}else{d += count;s += count;while (count--)  // 从后往前赋值{*--d = *--s;  // 注意这里先减减}}return dest;
}

四、测试

1.memcpy函数

int main()
{const size_t size = 20;int a[size] = { 0,1,2,3,4,5,6,7,8,9 };int b[size];memcpy(b, a, 10 * sizeof(int));  //注意这里是字节数for (int i = 0; i < size; ++i) printf("%d ", b[i]);return 0;
}

在这里插入图片描述

可以看出如下的例子：说明memcpy不能自拷贝

int main()
{const size_t size = 20;int a[size] = { 0,1,2,3,4,5,6,7,8,9 };int b[size];memcpy(a+4, a, 10 * sizeof(int));  //注意这里是字节数for (int i = 0; i < size; ++i) printf("%d ", a[i]);return 0;
}

在这里插入图片描述

2.memmove函数

如下例子可以看出与memcpy的区别

int main()
{const size_t size = 20;int a[size] = { 0,1,2,3,4,5,6,7,8,9 };int b[size];memmove(a+4, a, 10 * sizeof(int));  //自拷贝for (int i = 0; i < size; ++i) printf("%d ", a[i]);return 0;
}

在这里插入图片描述

正常例子：

int main()
{const size_t size = 20;int a[size] = { 0,1,2,3,4,5,6,7,8,9 };int b[size] = {0};memmove(b, a, 10 * sizeof(int));  //注意这里是字节数for (int i = 0; i < size; ++i) printf("%d ", b[i]);return 0;
}

在这里插入图片描述

五、源码

1.memcpy源码

/***
*memcpy.c - contains memcpy routine*Purpose:
*       memcpy() copies a source memory buffer to a destination buffer.
*       Overlapping buffers are not treated specially, so propogation may occur.
***********/#include <cruntime.h>
#include <string.h>#pragma function(memcpy)/***
*memcpy - Copy source buffer to destination buffer
*
*Purpose:
*       memcpy() copies a source memory buffer to a destination memory buffer.
*       This routine does NOT recognize overlapping buffers, and thus can lead
*       to propogation.
*
*       For cases where propogation must be avoided, memmove() must be used.
*
*Entry:
*       void *dst = pointer to destination buffer
*       const void *src = pointer to source buffer
*       size_t count = number of bytes to copy
*
*Exit:
*       Returns a pointer to the destination buffer
*
*Exceptions:
*******************************************************************************/void * __cdecl memcpy (void * dst,const void * src,size_t count)
{void * ret = dst;#if defined (_M_IA64){__declspec(dllimport)void RtlCopyMemory( void *, const void *, size_t count );RtlCopyMemory( dst, src, count );}#else  /* defined (_M_IA64) *//** copy from lower addresses to higher addresses*/while (count--) {*(char *)dst = *(char *)src;dst = (char *)dst + 1;src = (char *)src + 1;}
#endif  /* defined (_M_IA64) */return(ret);
}

2.memmove源码

/***
*memmove - Copy source buffer to destination buffer
*
*Purpose:
*       memmove() copies a source memory buffer to a destination memory buffer.
*       This routine recognize overlapping buffers to avoid propogation.
*       For cases where propogation is not a problem, memcpy() can be used.
*
*   Algorithm:
*******************************************************************************/void* memmove(void* dest, void* source, size_t count)
{void* ret = dest;if (dest <= source || dest >= (source + count)){//Non-Overlapping Buffers//copy from lower addresses to higher addresseswhile (count --)*dest++ = *source++;}else{//Overlapping Buffers//copy from higher addresses to lower addressesdest += count - 1;source += count - 1;while (count--)*dest-- = *source--;l}return ret;
}