先來看一個常見的C++面試題目：

void test()
{
　charstring[10],str1[10];
　int i;
　for(i=0; i<10; i++)
　{
　　str1[i] ='a';
　}
　strcpy( string, str1 );
}

這個題目錯誤在於哪裡？

答：陣列越界，在對str[i] = 'a';迴圈賦值過程中最後沒有'/0'識別符號，導致在strcpy進行拷貝的時候越界，會導致程式崩潰，

看strcpy的內部實現：

char *  strcpy(char * dst, const char * src)
{
        char * cp = dst;

        while( *cp++ = *src++ )
                ;               /* Copy src over dst */

        return( dst );
}
 

現在我們將程式改一下，如下：

char* strcpy_1(char* dest, const char* src)
{
	char * ret = dest;
	memmove(ret, src, strlen(src)+1);
	return ret;
}
void test()
{
<span style="white-space:pre">	</span>char string[10],str1[10];
	 int i;
	 for(i=0; i<10; i++)
	 {
		 str1[i] ='a';
		
	 }
	 printf("str1 = %s,str1 address = %d\n", str1, str1);
	 strcpy_1( string, str1 );
	 //strcpy(string,str1);
	 printf("str = %s,str1 address = %d\n", str1, str1);
	 printf("string = %s,string address = %d\n", string, string);
	 getchar();
	 getchar();
	 return 0;
}
 

從列印資訊就可以看出，陣列str1後面已經是亂碼了。對比str1與string的地址可以看出，相差20個位元組，在拷貝後str1地址後的第21個位元組起被string覆蓋了。

同樣，用memcpy也會出現這種情況。這裡考慮不考慮記憶體重疊都無濟與事了，所以在進行逐個賦值時最好加上‘\0’，我改過後的程式為：

void test()
{
　charstring[10],str1[10];
　int i;
　for(i=0; i<10; i++)
　{
      if (i == (sizeof(str1)-1))
      {
	str1[i] = '\0';
	break;
      }
　　  str1[i] ='a';
　}
　strcpy( string, str1 );
}
 

附：memcpy與memove的實現細節

1：系統的memcpy沒有考慮記憶體重疊的問題，其程式碼為：

void *  memcpy (void * dst,const void * src,size_tcount)
{
        void * ret = dst;
        /*
         * copy from lower addresses to higher addresses
         */
        while (count--) {
                *(char *)dst = *(char *)src;
                dst = (char *)dst + 1;
                src = (char *)src + 1;
        }
        return(ret);
}

void *  memmove (void * dst, const void * src,size_t count )
{
        void * ret = dst;
        if (dst <= src || (char *)dst >= ((char *)src + count)) {
                /*
                 * Non-Overlapping Buffers
                 * copy from lower addresses to higher addresses
                 */
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst + 1;
                        src = (char *)src + 1;
                }
        }
        else {
                /*
                 * Overlapping Buffers
                 * copy from higher addresses to lower addresses
                 */
                dst = (char *)dst + count - 1;
                src = (char *)src + count - 1;


                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst - 1;
                        src = (char *)src - 1;
                }
        }
        return(ret);
}

以下摘自：http://www.cnblogs.com/xulb597/archive/2012/05/23/2515215.html

strcpy、memcpy、memmove的區別

strcpy和memcpy都是標準C庫函式，它們有下面特點：
strcpy提供了字串的複製。即strcpy只用於字串複製，並且它不僅複製字串內容外，還會複製字串的結束符。
strcpy的函式原型是：char* strcpy(char* dest, const char* src);

memcpy只提供一般的記憶體複製，即memcpy對於需要複製的內容沒有限制，因此用途更廣。
memcpy的函式原型是：void *memcpy(void *dest,  const char* src,  size_t count);

strcpy 和 memcpy主要有以下三方面的區別：
1、複製的內容不同。strcpy只能複製字串，而memcpy可以複製任意內容，例如字串、整型、結構體、類等。
2、複製的方法不同。strcpy不需要指定長度，它遇到被複制字串的結束符"\0”才結束，所以容易溢位。memcpy則是根據第3個引數決定複製的長度。
3、用途不同。通常在複製字串時用strcpy，而需要複製其它型別的資料是用memcpy。

memcpy 和 memmove 都是C語言中的庫函式，在庫函式 string.h中，其原型相似，它們都是從src所指向的記憶體中複製count個位元組到dest所指記憶體中。並返回dest的值。
當源記憶體區域 和 目標記憶體區域無交叉重疊時，兩者的結果是一樣的，但如果有交叉呢？
memcpy是從src的其實部分開始複製，所以雖然第一種情況下沒有問題，但如果遇到第二種情況，則會發生錯誤，交叉部分的src內容就會被覆蓋掉了。
而memmove則由於採用不同的複製機制，所以可以正確處理第二種情況。