内存拷贝函数memcpy

memcpy是memory copy的缩写，意为内存复制，在写C语言程序的时候，我们常常会用到它。它的函原型如下：

void * memcpy(void*dest,const void*src,size_tn);

它的功能是从src的开始位置拷贝n个字节的数据到dest。如果dest存在数据，将会被覆盖。memcpy函数的返回值是dest的指针。memcpy函数定义在string.h头文件里。

自己实现的时候，最简单的方法是用指针按照字节顺序复制即可。但是性能太低，因为其一，一次一个字节效率太低，地址总线一般是32位，能搬运4字节，一次一个肯定慢的不行；其二，当内存区域重叠时会出现混乱情况。一下根据以上两方面考虑提高memcpy函数的性能。首先考虑速度，可以按照CPU位宽搬运数据，效率更高，代码如下：

  1. void*Memcpy1(void*dst,const void*src,size_t num)
  2. {int nchunks = num/
  3. sizeof(dst);
  4. /*按CPU位宽拷贝*/
  5. cout<<"sizeof(dst)是："<<sizeof(dst)<<endl;
  6. int slice = num%
  7. sizeof (dst);
  8. /*剩余的按字节拷贝*/
  9. unsigned long* s = ( unsigned long *)src;
  10. unsigned long* d = (unsigned long *)dst;
  11. while(nchunks--)
  12. *d++ = *s++;
  13. while (slice--)
  14. *((char*)d++) =*((char*)s++);
  15. return dst;
  16. }

sizeof(dst)是4，即大部分数据每次按照4字节拷贝，最后不足4字节的再分别拷贝。但是内存区域出现重叠时，这种方法无法规避内存混乱问题。下面的方法能够规避内存重叠的bug，代码如下：

  1. void*Memcpy2(void*dest,const void*src,size_tcount)
  2. {char*d;const char *s;
  3. if(((int)dest > ((int)src+count)) || (dest < src))
  4. {d = (char*)dest;
  5. s = (char*)src;
  6. while(count--)
  7. *d++ = *s++;
  8. }
  9. else
  10. /* overlap */
  11. {d = (char*)((int)dest + count -1);
  12. /* 指针位置从末端开始，注意偏置 */
  13. s = (char*)((int)src + count-1);
  14. while(count --)
  15. *d-- = *s--;
  16. }
  17. return dest;}
  18. 如果检测到内存区域有重叠部分，则从末端开始对每个字节进行拷贝。但数据量大时速度慢，将两种方法结合后能够提高拷贝函数性能，代码如下：
  19. void*Memcpy(void*dest,constvoid*src,size_tcount)
  20. {
  21. cout<<"sizeof(dest)是："<<sizeof(dest)<<endl;
  22. int bytelen=count/sizeof(dest);
  23. /*按CPU位宽拷贝*/
  24. int slice=count%
  25. sizeof (dest);
  26. /*剩余的按字节拷贝*/
  27. unsigned int * d = (unsigned int*)dest;
  28. unsigned int * s = (unsigned int*)src;
  29. if(((int)dest > ((int)src+count)) || (dest < src))
  30. {while(bytelen--)
  31. *d++ = *s++;
  32. while(slice--)*(char*)d++ = *(char*)s++;
  33. }
  34. else
  35. /* overlap重叠 */
  36. {d = (unsigned int *)((unsigned int)dest + count -4);
  37. /*指针位置从末端开始，注意偏置 */
  38. s = (unsigned int*)((unsigned int)src + count-4);
  39. while(bytelen --)
  40. *d-- = *s--;
  41.       d++;s++;
  42. char * d1=(char*)d;
  43. char* s1=(char*)s;
  44. d1--;s1--;
  45. while(slice --)*(char*)d1-- = *(char*)s1--;
  46. }
  47. return dest;
  48. }
  49. 对比一下，测试代码如下：
  50. int main()
  51. {chara[20]="1133224466558877990";
  52. // Memcpy1(a+2,a,5);
  53. // Memcpy2(a+2,a,5);
  54. Memcpy(a+2,a,5);
  55. cout<<a<<endl;
  56. cin.get();
  57. }

运行结果：Memcpy1：

1111333466558877990

Memcpy2：

1111332466558877990

Memcpy：

1111332466558877990

后两种方法正确，第一种方法拷贝时无法规避内存重叠的bug。