C++內存分配及變長數組的動態分配

//------------------------------------------------------------------------------------------------

第一部分 C++內存分配

//------------------------------------------------------------------------------------------------

一。關於內存

　一、內存分配方式

　　內存分配方式有三種：

　　（1）從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在

。例如全局變量，static變量。

　　（2）在棧上建立。在執行函數時，函數內局部變量的存儲單元均可以在棧上建立，函數執行結束時這些存

儲單元自動被釋放。棧內存分配運算內置於處理器的指令集中，效率很高，可是分配的內存容量有限。

　　（3） 從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc或new申請任意多少的內存，程序員自

己負責在什麼時候用free或delete釋放內存。動態內存的生存期由咱們決定，使用很是靈活，但問題也最多。

   2.內存使用錯誤
     　發生內存錯誤是件很是麻煩的事情。編譯器不能自動發現這些錯誤，一般是在程序運行時才能捕捉到。

而這些錯誤大多沒有明顯的症狀，時隱時現，增長了改錯的難度。有時用戶怒氣衝衝地把你找來，程序卻沒有

發生任何問題，你一走，錯誤又發做了。 常見的內存錯誤及其對策以下：
       * 內存分配未成功，卻使用了它。

　　編程新手常犯這種錯誤，由於他們沒有意識到內存分配會不成功。經常使用解決辦法是，在使用內存以前檢查

指針是否爲NULL。若是是用malloc或new來申請內存，應該用if(p==NULL) 或if(p!=NULL)進行防錯處理。

　　* 內存分配雖然成功，可是還沒有初始化就引用它。

　　犯這種錯誤主要有兩個原由：一是沒有初始化的觀念；二是誤覺得內存的缺省初值全爲零，致使引用初值

錯誤（例如數組）。 內存的缺省初值到底是什麼並無統一的標準，儘管有些時候爲零值，咱們寧肯信其無不

可信其有。因此不管用何種方式建立數組，都別忘了賦初值，即使是賦零值也不可省略，不要嫌麻煩。

　　* 內存分配成功而且已經初始化，但操做越過了內存的邊界。

　　例如在使用數組時常常發生下標「多1」或者「少1」的操做。特別是在for循環語句中，循環次數很容易搞

錯，致使數組操做越界。

　　* 忘記了釋放內存，形成內存泄露。

　　含有這種錯誤的函數每被調用一次就丟失一塊內存。剛開始時系統的內存充足，你看不到錯誤。終有一次

程序忽然死掉，系統出現提示：內存耗盡。

　　動態內存的申請與釋放必須配對，程序中malloc與free的使用次數必定要相同，不然確定有錯誤

（new/delete同理）。

　　* 釋放了內存卻繼續使用它。
　
　　有三種狀況：

　　（1）程序中的對象調用關係過於複雜，實在難以搞清楚某個對象到底是否已經釋放了內存，此時應該從新

設計數據結構，從根本上解決對象管理的混亂局面。

　　（2）函數的return語句寫錯了，注意不要返回指向「棧內存」的「指針」或者「引用」，由於該內存在函

數體結束時被自動銷燬。

　　（3）使用free或delete釋放了內存後，沒有將指針設置爲NULL。致使產生「野指針」。

　　【規則1】用malloc或new申請內存以後，應該當即檢查指針值是否爲NULL。防止使用指針值爲NULL的內存

　　【規則2】不要忘記爲數組和動態內存賦初值。防止將未被初始化的內存做爲右值使用。

　　【規則3】避免數組或指針的下標越界，特別要小心發生「多1」或者「少1」操做。

　　【規則4】動態內存的申請與釋放必須配對，防止內存泄漏。

　　【規則5】用free或delete釋放了內存以後，當即將指針設置爲NULL，防止產生「野指針」。

 
二. 詳解new，malloc，GlobalAlloc
    
 1.  new

  new和delete運算符用於動態分配和撤銷內存的運算符

new用法:

          1>     開闢單變量地址空間

               1)new int;  //開闢一個存放數組的存儲空間,返回一個指向該存儲空間的地址.int *a = new

int 即爲將一個int類型的地址賦值給整型指針a. 

               2)int *a = new int(5) 做用同上,可是同時將整數賦值爲5

          2>    開闢數組空間

               一維: int *a = new int[100];開闢一個大小爲100的整型數組空間

         通常用法: new 類型 [初值]

delete用法:

          1> int *a = new int;

               delete a;   //釋放單個int的空間

          2>int *a = new int[5];

               delete [] a; //釋放int數組空間

          要訪問new所開闢的結構體空間,沒法直接經過變量名進行,只能經過賦值的指針進行訪問.

          用new和delete能夠動態開闢,撤銷地址空間.在編程序時,若用完一個變量(通常是暫時存儲的數組),

下次須要再用,但卻又想省去從新初始化的功夫,能夠在每次開始使用時開闢一個空間,在用完後撤銷它.

2.  malloc
  原型：extern void *malloc(unsigned int num_bytes); 
　　用法：＃i nclude <malloc.h>或＃i nclude <stdlib.h> 
　　功能：分配長度爲num_bytes字節的內存塊 
　　說明：若是分配成功則返回指向被分配內存的指針，不然返回空指針NULL。 
　　當內存再也不使用時，應使用free()函數將內存塊釋放。 
　　malloc的語法是：指針名=（數據類型*）malloc（長度）,（數據類型*）表示指針. 
說明：malloc 向系統申請分配指定size個字節的內存空間。返回類型是 void* 類型。void* 表示未肯定類型

的指針。C,C++規定，void* 類型能夠強制轉換爲任何其它類型的指針。

malloc（）函數的工做機制 
　　malloc函數的實質體如今，它有一個將可用的內存塊鏈接爲一個長長的列表的所謂空閒鏈表。調用malloc

函數時，它沿鏈接表尋找一個大到足以知足用戶請求所須要的內存塊。而後，將該內存塊一分爲二（一塊的大

小與用戶請求的大小相等，另外一塊的大小就是剩下的字節）。接下來，將分配給用戶的那塊內存傳給用戶，並

將剩下的那塊（若是有的話）返回到鏈接表上。調用free函數時，它將用戶釋放的內存塊鏈接到空閒鏈上。到

最後，空閒鏈會被切成不少的小內存片斷，若是這時用戶申請一個大的內存片斷，那麼空閒鏈上可能沒有能夠

知足用戶要求的片斷了。因而，malloc函數請求延時，並開始在空閒鏈上翻箱倒櫃地檢查各內存片斷，對它們

進行整理，將相鄰的小空閒塊合併成較大的內存塊。
 
和new的不一樣
從函數聲明上能夠看出。malloc 和 new 至少有兩個不一樣: new 返回指定類型的指針，而且能夠自動計算所需

要大小。好比：
int *p;
p = new int; //返回類型爲int* 類型(整數型指針)，分配大小爲 sizeof(int);
或：
int* parr;
parr = new int [100]; //返回類型爲 int* 類型(整數型指針)，分配大小爲 sizeof(int) * 100;
而 malloc 則必須由咱們計算要字節數，而且在返回後強行轉換爲實際類型的指針。
int* p;
p = (int *) malloc (sizeof(int));
第1、malloc 函數返回的是 void * 類型，若是你寫成：p = malloc (sizeof(int)); 則程序沒法經過編譯，

報錯：「不能將 void* 賦值給 int * 類型變量」。因此必須經過 (int *) 來將強制轉換。
第2、函數的實參爲 sizeof(int) ，用於指明一個整型數據須要的大小。若是你寫成：
int* p = (int *) malloc (1);
代碼也能經過編譯，但事實上只分配了1個字節大小的內存空間，當你往裏頭存入一個整數，就會有3個字節無

家可歸，而直接「住進鄰居家」！形成的結果是後面的內存中原有數據內容所有被清空。

3.  GlobalAlloc
 
   VC中關於GlobalAlloc，GlobalLock，GlobalUnLock

調用GlobalAlloc函數分配一塊內存，該函數會返回分配的內存句柄。 
調用GlobalLock函數鎖定內存塊，該函數接受一個內存句柄做爲參數，而後返回一個指向被鎖定的內存塊的指

針。 您能夠用該指針來讀寫內存。 
調用GlobalUnlock函數來解鎖先前被鎖定的內存，該函數使得指向內存塊的指針無效。 
調用GlobalFree函數來釋放內存塊。您必須傳給該函數一個內存句柄。
  
GlobalAlloc 
說明 
分配一個全局內存塊 
返回值 
Long，返回全局內存句柄。零表示失敗。會設置GetLastError 
參數表 
參數 類型及說明 
wFlags Long，對分配的內存類型進行定義的常數標誌，以下所示： 
             GMEM_FIXED 分配一個固定內存塊 
             GMEM_MOVEABLE 分配一個可移動內存塊 
             GMEM_DISCARDABLE 分配一個可丟棄內存塊 
             GMEM_NOCOMPACT 堆在這個函數調用期間不進行累積 
             GMEM_NODISCARD 函數調用期間不丟棄任何內存塊 
             GMEM_ZEROINIT 新分配的內存塊所有初始化成零 
dwBytes Long，要分配的字符數

  GlobalLock  
函數功能描述:鎖定一個全局的內存對象，返回指向該對象的第一個字節的指針
函數原型：
LPVOID GlobalLock( HGLOBAL hMem )
參數：
hMem：全局內存對象的句柄。這個句柄是經過GlobalAlloc或GlobalReAlloc來獲得的
返回值：
調用成功，返回指向該對象的第一個字節的指針
調用失敗，返回NULL，能夠用GetLastError來得到出錯信息
注意：
調用過GlobalLock鎖定一塊內存區後，必定要調用GlobalUnlock來解鎖
  
  GlobalUnlock
函數功能描述:解除被鎖定的全局內存對象
函數原型：BOOL GlobalUnlock( HGLOBAL hMem );
參數：hMem：全局內存對象的句柄
返回值：
非零值，指定的內存對象仍處於被鎖定狀態
0，函數執行出錯，能夠用GetLastError來得到出錯信息，若是返回NO_ERROR，則表示內存對象已經解鎖了
注意：    這個函數其實是將內存對象的鎖定計數器減一，若是計數器不爲0，則表示執行過多個GlobalLock

函數來對這個內存對象加鎖，須要對應數目的GlobalUnlock函數來解鎖。若是經過GetLastError函數返回錯誤

碼爲ERROR_NOT_LOCKED，則表示未加鎖或已經解鎖。

  示例：
// Malloc memory
hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, nSize);
// Lock memory
pMem = (BYTE *) GlobalLock(hMem);
..................
// Unlock memory
GlobalUnlock(hMem);
GlobalFree(hMem);

三 總結

靈活自由是C/C++語言的一大特點，而這也爲C/C++程序員出了一個難題。當程序愈來愈複雜時，內存的管理也

會變得越加複雜，稍有不慎就會出現內存問 題。內存泄漏是最多見的內存問題之一。內存泄漏若是不是很嚴重

，在短期內對程序不會有太大的影響，這也使得內存泄漏問題有很強的隱蔽性，不容易被發現。 然而無論內

存泄漏多麼輕微，當程序長時間運行時，其破壞力是驚人的，從性能降低到內存耗盡，甚至會影響到其餘程序

的正常運行。另外內存問題的一個共同特色 是，內存問題自己並不會有很明顯的現象，當有異常現象出現時已

時過境遷，其現場已非出現問題時的現場了，這給調試內存問題帶來了很大的難度。

 下載Windows Debug 工具, http://www.microsoft.com/whdc/devtools/debugging/default.mspx
安裝後,使用其中的gflags.exe工具打開PageHeap,
gflags -p /enable MainD.exe /full
從新使用VS用調試方式運行,很快就找到了出錯位置,由於在某個靜態函數中筆誤致使

在編寫穩定的服務器程序時,這個工具尤其有用。

//------------------------------------------------------------------------------------------------

第二部分 數組的動態分配及實例

//------------------------------------------------------------------------------------------------

一 

動態分配二維數組的通常方法是這樣：假設數組存的數據類型是int
int **p=NULL; 
p=new int*[nWidth];
    if (!p){
        return NULL;
    }
    for (int j=0;j<nWidth;j++){
        p[j]=new int[nHeight];
        if (!p[j]){
            return NULL;
        }
    }
這段代碼淺顯易懂，先分配第1維，在循環分配第2維。假設二維數組是3×2的，每一句運行完後的內存狀況如圖所示（方格表示內存，xx表示隨機數。下面是內存地址。固然，這個地址是個示意，事實不會分配到那的。）：
第一句完後分配了3個內存單元

循環分配後，注意下面3段內存是不連續的。這樣用下表p[n][m]操做數組沒問題,若是整塊內存操做就會有問題了。

原意是想把下面的3塊6個內存單元清0，但是事與願違，把從p開始後面6個內存單元清0了，p[]不能用了。p後面只有3個已分配的內存單元，卻要操做6個，另外3個是未知區域。清了後面虛線的3塊未知區域，這就很危險了，可能致使程序崩潰。
這樣分配的內存須要循環釋放。

對這個方法有一改進，以下：

int **p=NULL; 
   p=new int *[nWidth];
if (!p){
        return NULL;
    }
    p[0]=new int[nWidth*nHeight];
if (!p[0]){
   delete[] p;
        return NULL;
    }
    ZeroMemory(p[0],nWidth*nHeight*sizeof(int));
    for (int i=1;i<nWidth;i++){
        p[i]=p[i-1]+nHeight;
    }

這段代碼解決了分配的空間不連續的問題。每一句運行完後的內存狀況如圖所示：

第一句和上面同樣。

這6個內存單元是一次分配的，因此連續。


這個二維數組的數據首地址是p[0],p是第2維的索引首地址。因此若是要對二維數組進行總體的內存（緩衝區 buffer）操做，要以p[0]爲操做對象的首地址。

到此，索引與對應的數據地址關聯上了。這個二維數組既能夠經過下表p[][]來操做，又能夠操做緩衝區。操做緩衝區的函數好比memcpy，cfile的writehuge和readhuge使用起來很方便，省去了2次循環的麻煩。

至於釋放，沒必要循環釋放。由於new了2次，因此只需delete2次就好了：
if(!p){
   return;
}
    delete []p[0];
    p[0]=NULL;
    delete[] p;
    p=NULL;

 

（可參考 http://hi.baidu.com/jiaon/item/52017c5a145debcfd2e10c52）

 

二  實例

<span style="font-size:14px;">// malloc2d.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

//第一種方法，參考http://blog.csdn.net/blind20/article/details/5214507，分配連續空間
void **malloc2d(int row,int col,int size)
{
    void **arr;
    int indexsize=sizeof(void*)*row;//空出indexsize大小的空間用做？ void*爲何不行？
    int totalsize=size*row*col;
    arr=(void**)malloc(indexsize+totalsize);
    if(arr!=NULL)
    {
        unsigned char *head;//博客中是void *head版本，但編譯都經過不了，改爲unsigned char* 後編譯經過，但不明白運行結果爲何不對
        head=(unsigned char *)arr+indexsize;
        memset(arr,0,indexsize+totalsize);
        for(int i=0;i<row;i++)
            arr[i]=head+size*i*col;
    }
    return arr;
}

void free2d(void **arr)
{
    if(arr!=NULL)
        free(arr);
}



//第二中方法，分配連續空間，C++的實現版，
template <typename T>
T **darray_new(int row, int col)
{
    int size=sizeof(T);
    void **arr=(void **) malloc(sizeof(void *) * row + size * row * col);
    if (arr != NULL)
    {
        unsigned char * head;
        head=(unsigned char *) arr + sizeof(void *) * row;
        for (int i=0; i<row; ++i)
        {
            arr[i]= head + size * i * col;
            for (int j=0; j<col; ++j)
                new (head + size * (i * col + j)) T;//這一句比較有意思，想想爲何？
        }
    }
    return (T**) arr;
}

template <typename T>
void darray_free(T **arr, int row, int col)//注意要一個一個delete了，蛋疼，不過對於自定義的數據類型，頗有必要
{
    for (int i=0; i<row; ++i)
        for (int j=0; j<col; ++j)
            arr[i][j].~T();//這是什麼玩意兒？！模板析構？由於使用了new？因此用析構函數的delete？
    if (arr != NULL)
        free((void **)arr);
}

int _tmain(int argc, _TCHAR* argv[])
{
    //一維數組動態分配
    //int n;
    //cin>>n;
    ////int *p=new int[n];//一維數組動態分配方法一
    //int *p=(int*)malloc(n*sizeof(int));//一維數組動態分配方法二
    //for(int i=0;i<n;i++)
    //  cin>>p[i];
    //cout<<endl;
    //for(int i=0;i<n;i++)
    //  cout<<p[i]<<" ";

    //二維變長數組的動態分配，本人喜歡這種方法，雖然空間不連續，但一樣能夠進行p[i][j]的尋址，爲何博客中特地寫上面介紹的函數來實現還沒找到太好的理由
    //int n;
    //cin>>n;
    //int *p[2];
    //p[0]=new int[n];
    //p[1]=new int[n+1];
    //for(int i=0;i<n;i++)
    //  cin>>p[0][i];
    //cout<<&p[0]<<"      "<<&p[1]<<endl;//p[0]，p[1]是連續的
    //cout<<&p[0]<<"     "<<&p[0][0]<<"     "<<&p[0][1]<<endl;//p[0]!=p[0][0]，但p[0][0],p[0][1]是連續的


    ////C版本的，分配連續空間
    //int**m=(int**)malloc2d(5,5,sizeof(int));
    //int i,j;
    //for( i=0;i<5;i++)                           //void* 泛型指針，有待剖析
    //  for( j=0;j<5;j++)
    //      m[i][j]=0;
    //for( i=0;i<5;i++)
    //{
    //  for( j=0;j<5;j++)
    //      cout<<m[i][j]<<" ";
    //  cout<<endl;
    //}
    //free2d((void**)m);


    int** m=darray_new<int>(5,5);//注意模板函數怎麼實現的 <int>!
    int i,j;
    for( i=0;i<5;i++)
        for( j=0;j<5;j++)
            m[i][j]=1;
    for( i=0;i<5;i++)
    {
        for( j=0;j<5;j++)
            cout<<m[i][j]<<" ";
        cout<<endl;
    }
    darray_free(m,5,5);
    return 0;
}
</span>