memcpy函数较memmove相比，存在的不足是没有考虑到目的地址与源地址相重合，本文对memcpy作了修改，弥补其不足。
    memcpy函数的特点是：
        1. 使用memcpy函数前，实参dest必须初始化，否则可能会出错，原因见2。
        2. 函数原理是将void *src 强制转换为char *s，然后只负责拷贝n个字节到dest里，不负责在最后加上'\0'。
    下面的代码其实是实现了memmove的功能，然后根据memcpy的参数为void*，给其分别尝试传入int*和char*，以此来掌握int*是如何转化为char*，及强制转化后是什么结果，涉及到大端和小端...等等。

 
  
  1. #include <stdio.h>    
  2. #include <string.h>  
  3. void * mymemcpy(void *dest,void *src, int n)  
  4. {  
  5.     char *d;  
  6.     char *s;  
  7.     int i=0;  
  8.  
  9.     s=(char *)src;  
  10.     d=(char *)dest;  
  11.     if(dest==NULL || src==NULL || n<0)  
  12.         return 0;  
  13.     if(d>=s && d<=s+n-1)  
  14.     {  
  15.         i=n-1;  
  16.         printf("%d\n",i);  
  17.         while(i>=0)  
  18.         {  
  19.             d[i]=s[i];  
  20.             i--;  
  21.         }  
  22.     }  
  23.     else 
  24.     {  
  25.         while(i<n)  
  26.         {  
  27.             //printf("%x ",s[i]);  
  28.             d[i]=s[i];  
  29.             //printf("i=%d %x\n",i,d[i]);             
  30.             i++;  
  31.         }  
  32.         d[i]='\0';  
  33.     }  
  34.     dest=(void *)d;  
  35.     return dest;  
  36. }  
  37.  
  38. int main(char **argv,int argc)    
  39. {    
  40.     //情况1  
  41.     char src[100]="helloworldhui";    
  42.     //如果是特殊情况mymemcpy(src+2,src,7);，则不可写成char *src="helloworld"; 因为文字常量区内容不可被改变  
  43.     //char dest[100]="";        //必须初始化  
  44.     char *dest;  
  45.     dest=(char *)mymemcpy(src+2,src,7);  
  46.     printf("%s\n",dest);//*/  
  47.  
  48.     //情况2  
  49. /*  int src=123456789 ;     //对应十六进制：75BCD15  
  50.     int dest=0;               
  51.     //dest必须初始化，不然，如果只拷贝3个字节时，dest的第四个字节未被赋值，这样输出会出错。  
  52.     memcpy(&dest,&src,3);  //只能传递参数4，不然出错  
  53.     //mymemcpy(&dest,&src,3)     //则拷贝前3个字节  
  54.     printf("dest=%d %x\n",dest,dest);//*/  
  55.  
  56.     //情况3  
  57. /*  int src[100]={1234,12345,123456,11234567,14,15};  
  58.     int dest[100]={0};  
  59.     int i;  
  60.     memcpy(dest,src,13);    //只拷贝13个字节    
  61.     //不能保证拷贝一个完整的整数，一个元素，即如果你输入13，3*4=12，只能保证前3个整数完整拷贝，  
  62.     //到了第4个整数，只拷贝它的第一个字节，如例为7  
  63.     //mymemcpy(dest,src,13);  
  64.     for( i=0;i< 5;i++)  
  65.         printf("*%d*\n",dest[i]);//*/ 
  66.     return 0;    
  67. }   
 
  
下图为情况3的输出结果：
 
  
 
  
  1. #include <stdio.h>  
  2. int main(void)  
  3. {  
  4. //  int src[10]={50,61,72,83,94};  
  5.     _int64 src=123456789; //0x75BCD15,它在内存中的存放从低地址，低字节开始：15,cd,5b,7  
  6.     char *p;  
  7.     int count;  
  8.  
  9.     p=(char *)(&src);  
  10.     for(count=0; count<sizeof(int);p++,count++)  
  11.         printf("第%d字节处十六进制值是: %02x\n",count,*p);  
  12.     return 0;  
  13. }  
  14.