C++动态内存分配

动态内存分配

程序在运行过程对内存进行分配申请与释放

new运算符

运行时存储分配，返回可以存放对应类型数据的内存地址，指向分配的内存空间

• 分配基础类型内存存储空间

#include <iostream>

using namespace std;

int main() {
    string *name;
    // 动态在堆空间分配存储空间，字符串值 北门吹雪 值存储到分配的内存空间
    name = new string("北门吹雪");

    cout << *name << endl;
    delete name;
}

• 动态分配一维数组空间

很多函数使用一维或二维数组，这些数组是在编译时大小未知的，数组容量的大小随着函数调用动态变大或者变小

#include <iostream>

using namespace std;

void alloc_one_dimensional(int len) {
    int *nums;
    // 内存分配可能会失败，通过try捕获程序中的异常
    try {
        // new对数组分配内存，返回数组中第一个元素的指针
        nums = new int[len];
    } catch (bad_alloc& e) {
        cout << "内存分配失败" << endl;
    }
    cout << "动态分配内存大小:" << len  << endl;
    // 是否动态分配的内存
    delete[] nums;
}

int main() {
    alloc_one_dimensional(10);
    alloc_one_dimensional(12);
    alloc_one_dimensional(13);
}

• 动态分配二维数组

如果形参是一个二维数组，必须指定第一维度的大小，a[][10] 合法，但是 a[][]非法，编译时就确定数组的长度，但很多场景下需要每个长度不一的二维数组

1. 因为使用new对数组进行动态分配，返回数组中第一个元素的地址，所有创建二维数组则第二维度只保留指针

#include <iostream>

using namespace std;

template<class T>
void alloc_two_dimensional(T _, int number_of_rows, int number_of_columns) {
    // 先动态创建保存数组元素的指针
    int **matrix = new T *[number_of_rows];

    // 然后再依次创建一维数组
    for (int row = 0; row < number_of_rows; row++) {
        matrix[row] = new T[number_of_columns];
    }

    // 修改二维数组的值
    matrix[1][1] = 10;
    matrix[2][2] = 10;
    matrix[3][3] = 10;
    matrix[4][4] = 10;

    // 遍历二维数组
    for (int i = 0; i < number_of_rows; i++) {
        for (int j = 0; j < number_of_columns; j++) {
            cout << matrix[i][j] << "\t";
        }
        cout << endl;
    }

    // 释放内存
    // 首先释放保存在数组中的每一个元素指向的数组
    for (int i=0; i < number_of_rows; i++) {
        delete[] matrix[i];
    }
    
    // 释放最外层的数组
    delete[] matrix;
}

int main() {
    int a;
    alloc_two_dimensional(a, 9, 12);
}

delete 操作符

释放由new操作符动态分配的内存空间，调用对象关联类型的析构函数

• 只能操作指针类型对象
• 单个对象使用delete运算符，但多个对象的数组则需要使用delete[]运算符

#include <iostream>

int main() {
    int* y = new int(10);
    // 释放指针指向的单个对象的内存，调用对象的析构函数
    delete y;
	
    int *a = new int[10]{1, 2, 3, 4};
    // 释放指针指向的数组对象所有内存，遍历依次调用数组中元素对应的析构函数
    delete[] a;
}

使用场景：动态分配的内存空间(存储空间)不在需要时