C++面向对象基础--动态内存（new的用法）

C++ 程序中的内存分为两个部分：

栈：在函数内部声明的所有变量都将占用栈内存。

堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。

在 C++ 中，我们可以使用new运算符为给定类型的变量在运行时分配堆内的内存，这会返回所分配的空间地址。如果不再需要动态分配的内存空间，可以使用 delete 运算符，删除之前由 new 运算符分配的内存。

1.new和delete的常规简要用法

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

new data-type;

其中，data-type可以是包括数组在内的任意内置的数据类型，也可以是包括类或结构在内的用户自定义的任何数据类型。例如我们可以定义一个指向int类型数据的指针p，然后请求内存，该内存在执行时被分配。

int* p = NULL;  // 初始化为null的指针
p = new int;     // 为变量请求内存

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

int* p = NULL; 
if (!(p = new int))
{
    cout << "Error: out of memory." << endl;
    exit(1);

}
p = new int;

如果某个已经动态分配内存的变量不再需要使用时，我们可以使用 delete 操作符释放它所占用的内存，如下所示：

delete p;   // 释放p所指向的内存

new和delete完整用法示例：

#include <iostream>
using namespace std;

int main()
{
    int* p = NULL; // 初始化为 null 的指针
    p = new int;   // 为变量请求内存
    *p= 12345;     // 在分配的地址存储值
    cout << "Value of p : " << *p << endl;
    delete p;         // 释放内存
    return 0;
}

运行结果：

Value of p : 12345

2.数组的动态内存分配

（1）一维数组：

// 动态分配,数组长度为 n
int *array=new int [n]；
 
//释放内存
delete [] array;

（2）二维数组：

int **array
// 假定数组第一维长度为 m， 第二维长度为 n
// 动态分配空间
array = new int *[m];
for( int i=0; i<m; i++ )
{
    array[i] = new int [n]  ;
}
//释放
for( int i=0; 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* [4];
    for (i = 0; i < 4; i++) 
    {
        p[i] = new int[8];
    }

    for (i = 0; i < 4; i++) 
    {
        for (j = 0; j < 8; j++) 
        {
            p[i][j] = j * i;
        }
    }
    //打印数据  
    for (i = 0; i < 4; i++) 
    {
        for (j = 0; j < 8; j++)
        {
            if (j == 0)
            {
                cout << endl;
            }
            cout << p[i][j] << "	";
        }
    }
    //开始释放申请的堆  
    for (i = 0; i < 4; i++) 
    {
        delete[] p[i];
    }
    delete[] p;
    return 0;
}

代码运行结果：

（3）三维数组：

    int*** array;
    // 假定数组第一维为 m， 第二维为 n， 第三维为h
    // 动态分配空间
    array = new int** [m];
    for (int i = 0; i < m; i++)
    {
        array[i] = new int* [n];
        for (int j = 0; j < n; j++)
        {
            array[i][j] = new int[h];
        }
    }
    //释放
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; 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** [2];
    for (i = 0; i < 2; i++)
    {
        p[i] = new int* [3];
        for (j = 0; j < 3; j++)
        {
            p[i][j] = new int[4];
        }
    }

    //输出 p[i][j][k] 三维数据
    for (i = 0; i < 2; i++)
    {
        for (j = 0; j < 3; j++)
        {
            for (k = 0; k < 4; k++)
            {
                p[i][j][k] = i + j + k;
                cout << p[i][j][k] << " ";
            }
            cout << endl;
        }
        cout << endl;
    }

    // 释放内存
    for (i = 0; i < 2; i++)
    {
        for (j = 0; j < 3; j++)
        {
            delete[] p[i][j];
        }
    }
    for (i = 0; i < 2; i++)
    {
        delete[] p[i];
    }
    delete[] p;
    return 0;
}

代码运行结果：

3.对象的动态内存分配

示例代码：

#include <iostream>
using namespace std;

class test
{
public:
    test() {
        cout << "调用构造函数！" << endl;
    }
    ~test() {
        cout << "调用析构函数！" << endl;
    }
};

int main()
{
    test* testArray = new test[4];
    delete[] testArray; // 删除数组
    return 0;
}

代码运行结果：

如果要为一个包含四个test对象的数组分配内存，构造函数将被调用 4 次，同样地，当删除这些对象时，析构函数也将被调用相同的次数（4次）。