C++ 内存管理简明教程_c++ vs 如何配置编译 临时变量回收重置内存

C++ 在运行时给变量或数组分配内存，也称为动态内存分配。其他语言(如Java, Python)由编译器控制内存，但C++需要手动维护，当不需要时也要手动回收动态创建的内存。本文介绍C++动态内容管理，并通过示例进行说明。

内存管理目的

数组包括相同类型数据，大多数情况下声明数组时，内存已经分配。如果分配太小，可能不够使用，反之可能造成浪费。那么最好的办法使用new操作符在运行时动态分配。

new操作符

下面示例使用new操作符给指针变量分配内存.

// 声明 int 指针
int* pointerVar;

// 动态分配内存
pointerVar = new int;

// 给地址赋值
*pointerVar = 55;
1
2
3
4
5
6
7
8

动态分配内存返回地址赋值给指针变量。如果是数组，则返回数组的首地址。

new 语法如下：

pointerVar = new dataType;

delete操作符

已分配的指针变量，当不再使用我们可以使用delete操作符回收内存。
delete操作符语法：

delete pointerVar;

// 声明int指针
int* pointVari;

// 动态分配内存
pointVari = new int;

// 赋值给指针对应地址
*pointVari = 55;

// 打印内存值
cout << *pointVari;

// 回收内存
delete pointVari;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

关于delete操作符，下面几点需要说明：

• 必须确保该变量是通过new分配的，不是在栈的局部变量、全局变量(命名空间范围的)或其他对象的成员变量
• 必须确保该变量不再被使用，如果不确定，可以与nullptr比较。

动态分配内存方式

每个C++软件的内存结构可简化为：

• 代码段

是保存包含执行指令的编译程序的地方。它们是只读的，代码段处在堆栈和堆的后面，以避免被覆盖。

• 数据段

是维护全局变量和静态变量的地方，可进行读写。

• 栈

堆栈是一种预先分配的内存类型。堆栈是后进先出的数据结构。当变量不在作用域内时，内存会被释放。当堆栈变量被移除时，其他变量就可以访问它所使用的内存空间。当函数调用时，会push和pop局部变量，堆栈会扩展和收缩。它跟踪局部变量，返回值地址、实参以及内存状态。

• 堆

应用程序运行时分配的内存区域。使用new操作符分配内存，而使用delete操作符处理内存。

动态分配基本类型

下面示例展示动态分配基本数据类型。

#include <iostream>
using namespace std;
int main() {
    // 声明指针
    int* pntInt;

    // 声明float类型指针
    float* pntFloat;

    // 动态分配内存
    pntInt = new int;
    pntFloat = new float;

    // 赋值
    *pntInt = 55;
    *pntFloat = 55. 55f;
    cout << *pntInt << endl;
    cout << *pntFloat << endl;

    // 回收内存
    delete pntInt;
    delete pntFloat;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出结果：

55
55. 55
1
2

动态分配数组

下面示例展示输入学生数量，动态分配数组大小。

#include <iostream>
using namespace std;

int main() {
    int numb;
    cout << "输入学生总数: ";
    cin >> numb;
    float* pntr;

    // 分配内存
    pntr = new float[numb] ;
    cout << "输入成绩：" << endl;
    for (int c = 0; c < numb; ++c) {
        cout << "Student" << c + 1 <<  ": ";
        cin >> *(pntr + c) ;
    }

    cout << "\n显示成绩：" << endl;
    for (int c = 0; c < numb; ++c) {
        cout << "Student" << c + 1 << " : " << *(pntr + c) << endl;
    }

    // 回收内存
    delete[] pntr;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

输出结果：

输入学生总数: 5
输入成绩：
Student1: 4.4
Student2: 5
Student3: 3
Student4: 7
Student5: 8
显示成绩：
Student1: 4.4
Student2: 5
Student3: 3
Student4: 7
Student5: 8
1
2
3
4
5
6
7
8
9
10
11
12
13

注意这里使用 delete[] pntr ，[] 表示回收整个数组。

动态分配对象类型

下面示例定义Stud类，其中包括私有变量age，缺省构造函数初始化age为10。main函数中使用new操作符动态构建pntr对象指针。

#include <iostream>
using namespace std;
class Stud {
    int age;
public:
    // 构造函数初始化age
    Stud() : age(10) {}
    void getAge() {
        cout << "Age: " << age << endl;
    }
};

int main() {

    // 动态声明 Student类型对象
    Stud* pntr = new Stud() ;

    // 通过指针调用成员函数
    pntr->getAge();

    // 回收内存
    delete pntr;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出结果：

Age: 10
1