了解动态内存在 C++ 中是如何工作的是成为一名合格的 C++ 程序员必不可少的。C++ 程序中的内存分为两个部分：

  • 栈：在函数内部声明的所有变量都将占用栈内存。
  • 堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。

很多时候，您无法提前预知需要多少内存来存储某个定义变量中的特定信息，所需内存的大小需要在运行时才能确定。 在 C++ 中，您可以使用特殊的运算符为给定类型的变量在运行时分配堆内的内存，这会返回所分配的空间地址。这种运算符即new运算符。 如果您不再需要动态分配的内存空间，可以使用delete运算符，删除之前由 new 运算符分配的内存。

new 和 delete 运算符

下面是使用 new 运算符来为任意的数据类型动态分配内存的通用语法：

  1. new data-type;

在这里，data-type可以是包括数组在内的任意内置的数据类型，也可以是包括类或结构在内的用户自定义的任何数据类型。让我们先来看下内置的数据类型。例如，我们可以定义一个指向 double 类型的指针，然后请求内存，该内存在执行时被分配。我们可以按照下面的语句使用new运算符来完成这点：

  1. double* pvalue  = NULL; // 初始化为 null 的指针
  2. pvalue  = new double;   // 为变量请求内存

如果自由存储区已被用完，可能无法成功分配内存。所以建议检查 new 运算符是否返回 NULL 指针，并采取以下适当的操作：

  1. double* pvalue  = NULL;
  2. if( !(pvalue  = new double ))
  3. {
  4.    cout << "Error: out of memory." <<endl;
  5.    exit(1);
  7. }

malloc()函数在 C 语言中就出现了，在 C++ 中仍然存在，但建议尽量不要使用 malloc() 函数。new 与 malloc() 函数相比，其主要的优点是，new 不只是分配了内存，它还创建了对象。
在任何时候，当您觉得某个已经动态分配内存的变量不再需要使用时，您可以使用 delete 操作符释放它所占用的内存，如下所示：

  1. delete pvalue;        // 释放 pvalue 所指向的内存

下面的实例中使用了上面的概念，演示了如何使用 new 和 delete 运算符：

  1. #include <iostream>
  2. using namespace std;
  4. int main ()
  5. {
  6.    double* pvalue  = NULL; // 初始化为 null 的指针
  7.    pvalue  = new double;   // 为变量请求内存
  9.    *pvalue = 29494.99;     // 在分配的地址存储值
  10.    cout << "Value of pvalue : " << *pvalue << endl;
  12.    delete pvalue;         // 释放内存
  14.    return 0;
  15. }

数组的动态内存分配

假设我们要为一个字符数组（一个有 20 个字符的字符串）分配内存，我们可以使用上面实例中的语法来为数组动态地分配内存，如下所示：

  1. char* pvalue  = NULL;   // 初始化为 null 的指针
  2. pvalue  = new char[20]; // 为变量请求内存

要删除我们刚才创建的数组，语句如下：

  1. delete [] pvalue;        // 删除 pvalue 所指向的数组

下面是 new 操作符的通用语法，可以为多维数组分配内存，如下所示：

一维数组

  1. // 动态分配,数组长度为 m
  2. int *array=new int [m];
  4. //释放内存
  5. delete [] array;

二维数组

  1. int **array
  2. // 假定数组第一维长度为 m， 第二维长度为 n
  3. // 动态分配空间
  4. array = new int *[m];
  5. for( int i=0; i<m; i++ )
  6. {
  7.     array[i] = new int [n]  ;
  8. }
  10. //释放
  11. for( int i=0; i<m; i++ )
  12. {
  13.     delete [] array[i];
  14. }
  15. delete [] array;

二维数组实例测试：

  1. #include <iostream>
  2. using namespace std;
  4. int main()
  5. {
  6.   int **p;
  7.   int i, j; //p[4][8]
  8.   //开始分配4行8列的二维数据
  9.   p = new int *[4];
  10.   for (i = 0; i < 4; i++)
  11.   {
  12.     p[i] = new int[8];
  13.   }
  15.   for (i = 0; i < 4; i++)
  16.   {
  17.     for (j = 0; j < 8; j++)
  18.     {
  19.       p[i][j] = (j + 1) * (i + 1);
  20.     }
  21.   }
  22.   //打印数据
  23.   for (i = 0; i < 4; i++)
  24.   {
  25.     for (j = 0; j < 8; j++)
  26.     {
  27.       if (j == 0)
  28.         cout << endl;
  29.       cout << p[i][j] << "\t";
  30.     }
  31.   }
  32.   cout << endl;
  34.   //开始释放申请的堆
  35.   for (i = 0; i < 4; i++)
  36.   {
  37.     delete[] p[i];
  38.   }
  39.   delete[] p;
  40.   return 0;
  41. }
  43. /*
  44. 1       2       3       4       5       6       7       8
  45. 2       4       6       8       10      12      14      16
  46. 3       6       9       12      15      18      21      24
  47. 4       8       12      16      20      24      28      32
  48. */

三维数组

  1. int ***array;
  2. // 假定数组第一维为 m， 第二维为 n， 第三维为h
  3. // 动态分配空间
  4. array = new int **[m];
  5. for( int i=0; i<m; i++ )
  6. {
  7.     array[i] = new int *[n];
  8.     for( int j=0; j<n; j++ )
  9.     {
  10.         array[i][j] = new int [h];
  11.     }
  12. }
  14. //释放
  15. for( int i=0; i<m; i++ )
  16. {
  17.     for( int j=0; j<n; j++ )
  18.     {
  19.         delete[] array[i][j];
  20.     }
  21.     delete[] array[i];
  22. }
  23. delete[] array;

三维数组测试实例：

  1. #include <iostream>
  2. using namespace std;
  4. int main()
  5. {   
  6.     int i,j,k;   // p[2][3][4]
  8.     int ***p;
  9.     p = new int **[2]; 
  10.     for(i=0; i<2; i++) 
  11.     { 
  12.         p[i]=new int *[3]; 
  13.         for(j=0; j<3; j++) 
  14.             p[i][j]=new int[4]; 
  15.     }
  17.     //输出 p[i][j][k] 三维数据
  18.     for(i=0; i<2; i++)   
  19.     {
  20.         for(j=0; j<3; j++)   
  21.         { 
  22.             for(k=0;k<4;k++)
  23.             { 
  24.                 p[i][j][k]=i+j+k;
  25.                 cout<<p[i][j][k]<<" ";
  26.             }
  27.             cout<<endl;
  28.         }
  29.         cout<<endl;
  30.     }
  32.     // 释放内存
  33.     for(i=0; i<2; i++) 
  34.     {
  35.         for(j=0; j<3; j++) 
  36.         {   
  37.             delete [] p[i][j];   
  38.         }   
  39.     }       
  40.     for(i=0; i<2; i++)   
  41.     {       
  42.         delete [] p[i];   
  43.     }   
  44.     delete [] p;  
  45.     return 0;
  46. }
  48. /* 
  49. 0 1 2 3 
  50. 1 2 3 4 
  51. 2 3 4 5 
  53. 1 2 3 4 
  54. 2 3 4 5 
  55. 3 4 5 6  
  56. */

对象的动态内存分配

对象与简单的数据类型没有什么不同。例如，请看下面的代码，我们将使用一个对象数组来理清这一概念：

  1. #include <iostream>
  2. #include <unistd.h>
  3. using namespace std;
  5. class Box
  6. {
  7. public:
  8.   Box()
  9.   {
  10.     cout << "+调用构造函数！" << endl;
  11.   }
  12.   ~Box()
  13.   {
  14.     cout << "~调用析构函数！" << endl;
  15.   }
  16. };
  18. int main()
  19. {
  20.   double start, end;
  22.   Box *myBoxArray = new Box[4];
  23.   // start = clock();
  24.   start = time(NULL);
  25.   sleep(2);
  26.   delete[] myBoxArray; // 删除数组
  27.   // end = clock();
  28.   end = time(NULL);
  29.   cout << "程序耗时：" << ((double)(end - start)) / CLK_TCK << "s" << endl;
  30.   cout << "程序耗时：" << (double)difftime(end, start) << "s" << endl;
  31.   return 0;
  32. }

如果要为一个包含四个 Box 对象的数组分配内存，构造函数将被调用 4 次，同样地，当删除这些对象时，析构函数也将被调用相同的次数（4次）。
当上面的代码被编译和执行时，它会产生下列结果：

  1. +调用构造函数！
  2. +调用构造函数！
  3. +调用构造函数！
  4. +调用构造函数！
  5. ~调用析构函数！
  6. ~调用析构函数！
  7. ~调用析构函数！
  8. ~调用析构函数！
  9. 程序耗时：0.02s
  10. 程序耗时：2s