浅析C++中的动态内存分配

目录

• new运算符
• delete 操作符

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

new运算符

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

1.分配基础类型内存存储空间

#include <IOStream>

using namespace std;

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

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

2.动态分配一维数组空间

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

#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);
}

3.动态分配二维数组

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

因为使用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_dipythonmensional(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;
}

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

到此这篇关于浅析C++中的动态内存分配的文章就介绍到这了,更多相关C++动态内存分配内容请搜索编程客栈(www.www.devze.comcppcns.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！