2. 程式人生 > >c++中記憶體拷貝函式(C++ memcpy)詳解

c++中記憶體拷貝函式(C++ memcpy)詳解

阿新 • • 發佈：2019-02-11

原型：void*memcpy(void*dest, const void*src,unsigned int count); 

功能：由src所指記憶體區域複製count個位元組到dest所指記憶體區域。

說明：src和dest所指記憶體區域不能重疊，函式返回指向dest的指標。

舉例：

[cpp] view plain copy print?
  1. //   memcpy.c                       
  2. #include   <stdlib.h>           
  3. #include   <string.h>           
  4. main()             
  5. {                 
  6.     char *s= "Golden  Global   View ";  
  7.     char d[20];  
  8.     clrscr();  
  9.     memcpy(d,s,strlen(s));  
  10.     d[strlen(s)]=0;  
  11.     printf( "%s ",d);  
  12.     getchar();  
  13.     return   0;  
  14. }  

下面自行實現這個函式

程式清單 1 V0.1版程式 

[cpp] view plain copy print?
  1. void MyMemMove(char *dst,char *src,int count)   
  2. {   
  3.     while(count--)   
  4.         *dst++ = *src++;   
  5. }   
程式清單 2 測試V0.1用例 
[cpp] view plain copy print?
  1. void Test()   
  2. {   
  3.     char p1[256] = ”hello,world!”;   
  4.     char p2[256] = {0};   
  5.     MyMemMove(p2,p1,strlen(p1));   
  6.     printf(“%s”,p2);   
  7. }   
    客觀地講，相比那些交白卷或者函式宣告都不會寫的同學來說，能夠寫出這段程式碼的同學已經非常不錯了，至少在C語言這門課程上已經達到了現行高校的教育目標，但是離企業的用人要求還有一定的距離。我們不妨將上面的程式稱為V0.1版本，看看還有沒有什麼地方可以改進。 
   首先我們看看函式宣告是否合理，V0.1版的程式將源地址和目的地址都用char *來表示，這樣當然也沒有什麼問題，但是讓其他人使用起來卻很不方便，假如現在要將count個連續的結構體物件移動到另外一個地方去，如果要使用v0.1的程式的話，正確的寫法如下： 
    MyMemMove((char *)dst,(char *)src,sizeof(TheStruct)*count); 
也就是說我們需要將結構體指標強制轉換成char * 才能夠正常工作，這樣除了字串以外其它的型別都不可避免地要進行指標強制轉換，否則編譯器就會呱呱叫，比如在VC++2008下就會出現這樣的錯誤： 
error C2664: 'MyMemMove' : cannot convert parameter 1 from 'TheStruct *'to 'char *' ;那麼如何解決這個問題呢？其實很簡單，我們知道有一種特別的指標，任何型別的指標都可以對它賦值，那就是void *，所以應該將源地址和目的地址都用void*來表示。當然函式體的內容也要作相應的改變，這樣我們就得到了V0.2版的程式。 
程式清單 3 V0.2版程式 

[cpp] view plain copy print?
  1. void MyMemMove(void *dst,void *src,int count)   
  2. {   
  3.     while (count--)   
  4.     {   
  5.         *(char *)dst = *(char *)src;   
  6.         dst = (char *)dst + 1;   
  7.         src = (char *)src + 1;   
  8.     }   
  9. }   
有的同學可能會問，這裡面不是還有指標強制轉換嗎？只不過是換了地方。沒錯，強制指標轉換確實是從使用者的程式碼轉移到了庫的程式碼裡，但我們可以將 MyMemMove理解為庫，而將Test理解為使用者，事實上通過調整之後的效果卻有天壤之別，V0.1是一逸永勞，而V0.2是一勞永逸！ 
     還有幾個細節需要注意，為了實現鏈式表示式，我們應該將返回值也改為void *。此外，如果我們不小心將“*(char *)dst = *(char *)src;”寫反了，寫成“*(char *)src =*(char *)dst;”編譯照樣通過，而為了找出這個錯誤又得花費不少時間。注意到src所指向的內容在這個函式內不應該被改變，所有對src所指的內容賦值都應該被禁止，所以這個引數應該用const修飾，如果有類似的錯誤在編譯時就能夠被發現： 
error C3892: 'src' : you cannot assign to a variable that is const ;作為程式設計師犯錯誤在所難免，但是我們可以利用相對難犯錯誤的機器，也就是編譯器來降低犯錯誤的概率，這樣我們就得到了V0.3版的程式。 
程式清單 4 V0.3版程式 
[cpp] view plain copy print?
  1. void * MyMemMove(void *dst,constvoid *src,int count)   
  2. {   
  3.     void *ret=dst;   
  4.     while (count--)   
  5.     {   
  6.         *(char *)dst = *(char *)src;   
  7.         dst = (char *)dst + 1;   
  8.         src = (char *)src + 1;   
  9.     }   
  10.     return ret;  
  11. }   
     現在再來考慮這樣一種情況，有使用者這樣呼叫庫：MyMemMove(NULL,src, count)，這是完全可能的，因為一般來說這些地址都是程式計算出來的，那就難免會算錯，出現零地址或者其它的非法地址也不足為奇。可以預料的是，如果出現這種情況的話，則程式馬上就會down掉，更糟糕的是你不知道錯誤出在哪裡，於是不得不投入大量的精力在浩瀚的程式碼中尋找bug。解決這類問題的通用辦法是對輸入引數作合法性檢查，也就是V0.4版程式。 
程式清單 5 V0.4版程式 
[cpp] view plain copy print?
  1. void * MyMemMove(void *dst,constvoid *src,int count)   
  2. {   
  3.     void *ret=dst;   
  4.     if (NULL==dst||NULL ==src)   
  5.     {   
  6.         return dst;   
  7.     }   
  8.     while (count--)   
  9.     {   
  10.         *(char *)dst = *(char *)src;   
  11.         dst = (char *)dst + 1;   
  12.         src = (char *)src + 1;   
  13.     }   
  14.     return ret;   
  15. }   

     上面之所以寫成“if(NULL==dst||NULL ==src)”而不是寫成“if (dst == NULL || src == NULL)”，也是為了降低犯錯誤的概率。我們知道，在C語言裡面“==”和“=”都是合法的運算子，如果我們不小心寫成了“if (dst = NULL || src = NULL)”還是可以編譯通過，而意思卻完全不一樣了，但是如果寫成“if (NULL=dst||NULL =src)”，則編譯的時候就通不過了，所以我們要養成良好的程式設計習慣：常量與變數作條件判斷時應該把常量寫在前面。V0.4版的程式碼首先對引數進行合法性檢查，如果不合法就直接返回，這樣雖然程式dwon掉的可能性降低了，但是效能卻大打折扣了，因為每次呼叫都會進行一次判斷，特別是頻繁的呼叫和效能要求比較高的場合，它在效能上的損失就不可小覷。如果通過長期的嚴格測試，能夠保證使用者不會使用零地址作為引數呼叫MyMemMove函式，則希望有簡單的方法關掉引數合法性檢查。我們知道巨集就有這種開關的作用，所以V0.5版程式也就出來了。 

程式清單 6 V0.5版程式

[cpp] view plain copy print?
  1. void * MyMemMove(void *dst,constvoid *src,int count)   
  2. {   
  3.     void *ret=dst;   
  4. #ifdef DEBUG 
  5.     if (NULL==dst||NULL ==src)   
  6.     {   
  7.         return dst;   
  8.     }   
  9. #endif 
  10.     while (count--)   
  11.     {   
  12.         *(char *)dst = *(char *)src;   
  13.         dst = (char *)dst + 1;   
  14.         src = (char *)src + 1;   
  15.     }   
  16.     return ret;   
  17. }   
     如果在除錯時我們加入“#defineDEBUG”語句，增強程式的健壯性，那麼在除錯通過後我們再改為“#undef DEBUG”語句，提高程式的效能。事實上在標準庫裡已經存在類似功能的巨集：assert，而且更加好用，它還可以在定義DEBUG時指出程式碼在那一行檢查失敗，而在沒有定義DEBUG時完全可以把它當作不存在。assert(_Expression)的使用非常簡單，當_Expression為0時，偵錯程式就可以出現一個除錯錯誤，有了這個好東西程式碼就容易多了。 
程式清單 7 V0.6版程式 
[cpp] view plain copy print?
  1. void * MyMemMove(void *dst,constvoid *src,int count)   
  2. {   
  3.     assert(dst);   
  4.     assert(src);   
  5.     void *ret=dst;   
  6.     while (count--)   
  7.     {   
  8.         *(char *)dst = *(char *)src;   
  9.         dst = (char *)dst + 1;   
  10.         src = (char *)src + 1;   
  11.     }   
  12.     return ret;   
  13. }   
    到目前為止，在語言層面上，我們的程式基本上沒有什麼問題了，那麼是否真的就沒有問題了呢？這就要求程式設計師從邏輯上考慮了，這也是優秀程式設計師必須具備的素質，那就是思維的嚴謹性，否則程式就會有非常隱藏的bug，就這個例子來說，如果使用者用下面的程式碼來呼叫你的程式。 
程式清單 8 重疊的記憶體測試 
[cpp] view plain copy print?
  1. void Test()   
  2. {   
  3.     char p [256]= "hello,world!";   
  4.     MyMemMove(p+1,p,strlen(p)+1);   
  5.     printf("%s\n",p);   
  6. }   
    如果你身邊有電腦，你可以試一下，你會發現輸出並不是我們期待的“hhello,world!”（在“hello world！”前加個h），而是“hhhhhhhhhhhhhh”，這是什麼原因呢？原因出在源地址區間和目的地址區間有重疊的地方，V0.6版的程式無意之中將源地址區間的內容修改了！有些反映快的同學馬上會說我從高地址開始拷貝。粗略地看，似乎能解決這個問題，雖然區間是重疊了，但是在修改以前已經拷貝了，所以不影響結果。但是仔細一想，這其實是犯了和上面一樣的思維不嚴謹的錯誤，因為使用者這樣呼叫還是會出錯： 
MyMemMove( p, p+1, strlen(p)+1); 所以最完美的解決方案還是判斷源地址和目的地址的大小，才決定到底是從高地址開始拷貝還是低地址開始拷貝，所以V0.7順利成章地出來了。 
程式清單 9 V0.7版程式 
[cpp] view plain copy print?
  1. void * MyMemMove(void *dst,constvoid *src,int count)   
  2. {   
  3.     assert(dst);   
  4.     assert(src);   
  5.     void * ret = dst;   
  6.     if (dst <= src || (char *)dst >= ((char *)src + count)) {   
  7.         while (count--) {   
  8.             *(char *)dst = *(char *)src;   
  9.             dst = (char *)dst + 1;   
  10.             src = (char *)src + 1;   
  11.         }   
  12.     }   
  13.     else {   
  14.         dst = (char *)dst + count - 1;   
  15.         src = (char *)src + count - 1;   
  16.         while (count--) {   
  17.             *(char *)dst = *(char *)src;   
  18.             dst = (char *)dst - 1;   
  19.         src = (char *)src - 1;   
  20.         }   
  21.     }   
  22.     return(ret);   
  23. }   
    經過以上7個版本的修改，我們的程式終於可以算是“工業級”了。回頭再來看看前面的測試用例，就會發現那根本就算不上是測試用例，因為它只調用了最正常的一種情況，根本達不到測試的目的。有了上面的經歷，測試用例也就相應地出現了，我們不妨用字元陣列來模擬記憶體。 
程式清單 10 相對全面的測試用例 
[cpp] view plain copy print?
  1. void Test()   
  2. {   
  3.     char p1[256] = "hello,world!";   
  4.     char p2[256] = {0};   
  5.     MyMemMove(p2,p1,strlen(p1)+1);   
  6.     printf("%s\n",p2);   
  7.     MyMemMove(NULL,p1,strlen(p1)+1);   
  8.     MyMemMove(p2,NULL,strlen(p1)+1);   
  9.     MyMemMove(p1+1,p1,strlen(p1)+1);   
  10.     printf("%s\n",p1);   
  11.     MyMemMove(p1,p1+1,strlen(p1)+1);   
  12.     printf("%s\n",p1);   
  13. }    
[cpp] view plain copy print?
  1. void * memcpy ( void * dst,constvoid * src,size_t count)  
  2. {  
  3.     void * ret = dst;  
  4.     while (count--) {  
  5.         *(char *)dst = *(char *)src;  
  6.         dst = (char *)dst + 1;  
  7.         src = (char *)src + 1;  
  8.     }  
  9.     return(ret);  
  10. }  
  11. char *strcpy(char *des, constchar *src){  
  12.     assert((des != NULL) && (src != NULL));  
  13.     char *ret = des; // 防止改變des的地址
  14.     while ((*des++ = *src++) !='\0') ;  
  15.     return ret;  
  16. } 

相關推薦

c++中記憶體拷貝函式(C++ memcpy)詳解

原型：void*memcpy(void*dest, const void*src,unsigned int count);  功能：由src所指記憶體區域複製count個位元組到dest所指記憶體區域。 說明：src和dest所指記憶體區域不能重疊，函式返回指向dest的指

C/c++中記憶體拷貝函式memcpy詳解

原型：void*memcpy(void*dest, const void*src,unsigned int count);  功能：由src所指記憶體區域複製count個位元組到dest所指記憶體區域。 說明：src和dest所指記憶體區域不能重疊，函式返回指向des

C#中Serializable序列化實例詳解

磁盤 close ear 但是 如果 mat 更新數據 eat 新的 本文實例講述了C#中Serializable序列化。分享給大家供大家參考。具體分析如下： 概述： 序列化就是是將對象轉換為容易傳輸的格式的過程，一般情況下轉化打流文件，放入內存或者IO文件 中。例如，可

C++中this指針的用法詳解

編譯 ++ call 高級 隱含參數 才有 == 可見 產生 轉自：http://blog.chinaunix.net/uid-21411227-id-1826942.html 1. this指針的用處: 　　一個對象的this指針並不是對象本身的一部分，不會影響sizeo

C++中 queue 、 deque、priority_queue詳解

最近看到一道題用到了佇列，在這裡就具體的分析一下C++中的這三種佇列的區別 queue 用法： #include <iostream> #include <queue> using namespace std; int mai

C++中 sort 函數的使用詳解

result != fir string std sort函數 dom cte 模板類 STL主要包含容器，叠代器，算法三塊內容，用戶可以對容器進行一系列的操作，比如遍歷和計算，而STL提供的叠代器和容器完美地提供了這樣的接口。其中std::vector是最常用的容器之一，

c++中呼叫Com元件的方法詳解

轉載自：http://www.cppblog.com/woaidongmao/archive/2011/01/10/138250.html需求： 1.建立myCom.dll,該COM只有一個元件,兩個介面：    IGetRes--方法Hello(),    IGetResEx--方法HelloEx() 2

C++中呼叫ActiveX元件的方法詳解

　　本文以 "msscript.ocx" 作為參考 　　第一步： 　　獲取標頭檔案 　　#import "msscript.ocx" 　　得到兩個檔案 "msscript.tlh" 和 "msscript.tli" 整合下的到個頭檔案"msscript.h"如下： 　　+

C++中的 .h 和 .cpp 區別詳解

在C++程式設計過程中，隨著專案的越來越大，程式碼也會越來越多，並且難以管理和分析。於是，在C++中就要分出了頭(.h)檔案和實現(.cpp)檔案，並且也有了Package的概念。 對於以C起步，C#作為“母語”的我剛開始跟著導師學習C++對這方面還是感到很模糊。雖然我

JAVA中的主函式main方法詳解

main方法詳解 主函式是靜態的 public static void main(String[] args){      } 主函式是什麼：主函式是一個特殊的函式，作為程式的入口，可以被jvm識別。 主函式的定義：   

Python中types.MethodType函式的用法詳解

看了網上好多的博文對這個函式的用法解釋都覺得少了些什麼，故自己寫這麼一篇博文來記錄一下我的上機操作結果及一些心得體會（操作環境：ubuntu 16.04/python2.7)1.公共部分程式碼#!/usr/bin/python2.7 from types import Met

C/C++中函式引數傳遞詳解（從記憶體的分析）

   昨天看了記憶體管理的有關內容，有一點了解，但不是很深入，發現之前寫程式碼時有很多細節問題沒有注意到，只知道這樣做可以實現功能，卻不知道為什麼可以這樣，對於採用自己的方法造成的隱患也未知，更不曉得還有其他方法可以實現，我們知道C++強大的一個原因是因為對於一個問題的答案多種解答方法或思路，我想著也許就是

C++中，getline函式的詳解

C++中本質上有兩種getline函式，一種在標頭檔案<istream>中，是istream類的成員函式。一種在標頭檔案<string>中，是普通函式。 在<istream>中的getline函式有兩種過載形式： istream&am

C++中的拷貝建構函式

轉載自：http://blog.csdn.net/lwbeyond/article/details/6202256 一. 什麼是拷貝建構函式 首先對於普通型別的物件來說，它們之間的複製是很簡單的，例如： [c-sharp]

C++中的freopen()函式使用詳解

所謂重定向輸出，就是可以把原本只是輸出在控制檯的字元，輸出到你指定的路徑檔案中。(輸入類似，就是從指定的檔案中讀取，而不是讀取在控制檯中的輸入。)重定向函式可以在任何時候開啟、關閉。   函式名：freopen  標準宣告：FILE *freopen( const c

C++中 sort 函式的使用詳解

STL主要包含容器，迭代器，演算法三塊內容，使用者可以對容器進行一系列的操作，比如遍歷和計算，而STL提供的迭代器和容器完美地提供了這樣的介面。其中std::vector是最常用的容器之一，vector是一個模板類，定義在名稱空間namespace下，使用vector需要在包含相關標頭檔案。今天主要講解對ve

詳解C語言和C++中的main()函式返回值

返回值main應指示程式如何退出。返回值為0表示正常退出main。異常退出通常通過非零返回來表示，但是關於非零程式碼沒有明確的標準。另外，void main()在C ++標準庫明確被禁止，不應該被使用。在C++中合法的main函式使用方法如下： int main() 以及： int

c中記憶體分配與釋放（malloc，realloc，calloc，free）函式內容的整理

程式例2    從這個例子可以看出calloc分配完儲存空間後將元素初始化。   #include<stdio.h>   #include<stdlib.h>   int main(void)   {   int i;   int *pn=(int

C++中sprintf()函式的使用詳解

轉載文章：http://www.jb51.net/article/36937.htm 參考文章：sprintf用法  http://blog.sina.com.cn/s/blog_980cf62a0100ya0z.html 在將各種型別的資料構造成字串時，sprintf 的

C++中的const成員函式（函式聲明後加const，或稱常量成員函式）用法詳解

在C++的類定義裡面，可以看到類似下面的定義： 01 class List { 02 private: 03 Node * p_he