棧：在函數內部聲明的所有變量都將占用棧內存。

堆：這是程序中未使用的內存，在程序運行時可用于動態分配內存。

可以使用特殊的運算符為給定類型的變量在運行時分配堆內的內存，這會返回所分配的空間地址。這種運算符即 new 運算符。

不再需要動態分配的內存空間，可以使用 delete 運算符，刪除之前由 new 運算符分配的內存。

new 和 delete 運算符

下面是使用 new 運算符來為任意的數據類型動態分配內存的通用語法：

new data-type;

在這里，data-type 可以是包括數組在內的任意內置的數據類型，也可以是包括類或結構在內的用戶自定義的任何數據類型。讓我們先來看下內置的數據類型。例如，可以定義一個指向 double 類型的指針，然后請求內存，該內存在執行時被分配。可以按照下面的語句使用 new 運算符來完成這點：

double* pvalue  = NULL; // 初始化為 null 的指針

pvalue  = new double;   // 為變量請求內存

如果自由存儲區已被用完，可能無法成功分配內存。所以建議檢查 new 運算符是否返回 NULL 指針，并采取以下適當的操作：

double* pvalue  = NULL;

if( !(pvalue  = new double ))

{

   cout << "Error: out of memory." <<endl;

   exit();

}

malloc() 函數在 C 語言中就出現了，在 C++ 中仍然存在，但建議盡量不要使用 malloc() 函數。new 與 malloc() 函數相比，其主要的優點是，new 不只是分配了內存，它還創建了對象。

在任何時候，當您覺得某個已經動態分配內存的變量不再需要使用時，可以使用 delete 操作符釋放它所占用的內存，如下所示：

delete pvalue;        // 釋放 pvalue 所指向的內存

#include <iostream>

using namespace std;

int main ()

{

   double* pvalue  = NULL; // 初始化為 null 的指針

   pvalue  = new double;   // 為變量請求內存

   *pvalue = 29494.99;     // 在分配的地址存儲值

   cout << "Value of pvalue : " << *pvalue << endl;

   delete pvalue;         // 釋放內存

   return ;

}

數組的動態內存分配

可以使用上面實例中的語法來為數組動態地分配內存，如下所示：

char* pvalue  = NULL;   // 初始化為 null 的指針

pvalue  = new char[]; // 為變量請求內存

要刪除我們剛才創建的數組，語句如下：

delete [] pvalue;        // 刪除 pvalue 所指向的數組

下面是 new 操作符的通用語法，可以為多維數組分配內存，如下所示：

一維數組

// 動態分配,數組長度為 m

int *array=new int [m]；

//釋放內存

delete [] array;

二維數組

int **array

// 假定數組第一維長度為 m， 第二維長度為 n

// 動態分配空間

array = new int *[m];

for( int i=; i<m; i++ )

{

    array[i] = new int [n]  ;

}

//釋放

for( int i=; i<m; i++ )

{

    delete [] arrary[i];

}

delete [] array;

二維數組實例測試：

#include <iostream>

using namespace std;

int main()

{

    int **p;

    int i,j;   //p[4][8]

    //開始分配4行8列的二維數據

    p = new int *[];

    for(i=;i<;i++){

        p[i]=new int [];

    }

    for(i=; i<; i++){

        for(j=; j<; j++){

            p[i][j] = j*i;

        }

    }

    //打印數據

    for(i=; i<; i++){

        for(j=; j<; j++)

        {

            if(j==) cout<<endl;

            cout<<p[i][j]<<"\t";

        }

    }

    //開始釋放申請的堆

    for(i=; i<; i++){

        delete [] p[i];

    }

    delete [] p;

    return ;

}

三維數組

int ***array;

// 假定數組第一維為 m， 第二維為 n， 第三維為h

// 動態分配空間

array = new int **[m];

for( int i=; i<m; i++ )

{

    array[i] = new int *[n];

    for( int j=; j<n; j++ )

    {

        array[i][j] = new int [h];

    }

}

//釋放

for( int i=; i<m; i++ )

{

    for( int j=; j<n; j++ )

    {

        delete[] array[i][j];

    }

    delete[] array[i];

}

delete[] array;

三維數組測試實例：

#include <iostream>

using namespace std;

int main()

{

    int i,j,k;   // p[2][3][4]

    int ***p;

    p = new int **[];

    for(i=; i<; i++)

    {

        p[i]=new int *[];

        for(j=; j<; j++)

            p[i][j]=new int[];

    }

    //輸出 p[i][j][k] 三維數據

    for(i=; i<; i++)

    {

        for(j=; j<; j++)

        {

            for(k=;k<;k++)

            {

                p[i][j][k]=i+j+k;

                cout<<p[i][j][k]<<" ";

            }

            cout<<endl;

        }

        cout<<endl;

    }

    // 釋放內存

    for(i=; i<; i++)

    {

        for(j=; j<; j++)

        {

            delete [] p[i][j];

        }

    }

    for(i=; i<; i++)

    {

        delete [] p[i];

    }

    delete [] p;

    return ;

}

對象的動態內存分配

對象與簡單的數據類型沒有什么不同。

#include <iostream>

using namespace std;

class Box

{

   public:

      Box() {

         cout << "調用構造函數！" <<endl;

      }

      ~Box() {

         cout << "調用析構函數！" <<endl;

      }

};

int main( )

{

   Box* myBoxArray = new Box[];

   delete [] myBoxArray; // 刪除數組

   return ;

}

如果要為一個包含四個 Box 對象的數組分配內存，構造函數將被調用  次，同樣地，當刪除這些對象時，析構函數也將被調用相同的次數（4次）。