memmove函数

memmove函数

写一个函数，完成内存之间的拷贝

1. void* mymemcpy( void *dest, const void *src, size_t count )  
2. {  
3.     char* pdest = static_cast<char*>( dest );  
4.     const char* psrc = static_cast<const char*>( src );  
5.     if( pdest>psrc && pdest<psrc+cout ) 能考虑到这种情况就行了  
6.     {  
7.         for( size_t i=count-1; i!=-1; --i )  
8.                 pdest[i] = psrc[i];  
9.     }  
10.     else  
11.     {  
12.         for( size_t i=0; i<count; ++i )  
13.             pdest[i] = psrc[i];  
14.     }  
15.     return dest;  
16. ｝  

 

原型：extern void *memmove(void *dest, const void *src, unsigned int count);
        
  用法：#include <string.h>
  
  功能：由src所指内存区域复制count个字节到dest所指内存区域。
  
  说明：src和dest所指内存区域可以重叠，但复制后src内容会被更改。函数返回指向dest的指针。
  

memmove和memcpy的区别：

1.memmove

函数原型：void *memmove(void *dest, const void *source, size_t count)

返回值说明：返回指向dest的void *指针

参数说明：dest,source分别为目标串和源串的首地址。count为要移动的字符的个数

函数说明：memmove用于从source拷贝count个字符到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。

2.memcpy

 函数原型：void *memcpy(void *dest, const void *source, size_t count);

返回值说明：返回指向dest的void *指针

函数说明：memcpy功能和memmove相同，但是memcpy中dest和source中的区域不能重叠，否则会出现未知结果。

3.两者区别

  函数memcpy()   从source  指向的区域向dest指向的区域复制count个字符，如果两数组重叠，不定义该函数的行为。  
  而memmove(),如果两函数重叠，赋值仍正确进行。

  memcpy函数假设要复制的内存区域不存在重叠，如果你能确保你进行复制操作的的内存区域没有任何重叠，可以直接用memcpy；  
  如果你不能保证是否有重叠，为了确保复制的正确性，你必须用memmove。

 memcpy的效率会比memmove高一些，如果还不明白的话可以看一些两者的实现：

1. void *memmove(void *dest, const void *source, size_t count)  
2. {  
3.  assert((NULL != dest) && (NULL != source));  
4.  char *tmp_source, *tmp_dest;  
5.  tmp_source = (char *)source;  
6.  tmp_dest = (char *)dest;  
7.  if((dest + count<source) || (source + count) <dest))  
8.  {// 如果没有重叠区域  
9.    while(count--)  
10.      *tmp_dest++ = *tmp_source++;  
11. }  
12. else  
13. { //如果有重叠  
14.  tmp_source += count - 1;  
15.  tmp_dest += count - 1;  
16.  while(count--)  
17.    *--tmp_dest = *--tmp;  
18. }  
19. return dest;  
20. }  

 

1. void *memcpy(void *dest, const void *source, size_t count)  
2. {  
3.  assert((NULL != dest) && (NULL != source));  
4.  char *tmp_dest = (char *)dest;  
5.  char *tmp_source = (char *)source;  
6.  while(count --)//不对是否存在重叠区域进行判断  
7.    *tmp_dest ++ = *tmp_source ++;  
8.  return dest;  
9. }  

 

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（）则由于采用了不同的复制机制，所以可以正确处理第二种情况。