养成良好的 C++ 编程习惯之内存管理的应用详解

1. 什么是内存管理

内存管理是指在程序运行时，对于计算机内存的的使用进行动态分配、释放和优化的过程，可以有效避免内存泄漏、重复申请等问题。C++ 中常用的内存管理方法包括动态内存分配和智能指针。

2. 动态内存分配

动态内存分配是指在程序执行过程中，手动申请内存并在不需要使用该内存时释放内存，从而获得更大的自由度和更高的效率。常用的动态内存分配方式包括 new 操作符和 delete 操作符。

2.1 new 操作符

new 操作符可以在程序运行时申请指定大小的内存，并返回该内存的地址。例如，可以使用 new 操作符申请一个指向 int 类型的空间：

int* p = new int;

申请后，p 指向的是一个 int 类型的空间。在申请完成后，需要使用 delete 操作符手动释放内存：

delete p;

这里需要注意，在使用 new 申请内存时，如果指定了数组大小，需要使用对应的 delete[] 释放内存，例如：

int* arr = new int[10];
delete[] arr;

2.2 智能指针

智能指针是为了更方便、更安全地管理内存而产生的技术。常用的智能指针包括 unique_ptr 和 shared_ptr。

unique_ptr 是指只能单个对象拥有的智能指针，不能复制，但可以移动。例如：

unique_ptr<int> p(new int(5));

shared_ptr 是指多个对象可以共享的智能指针，会自动管理其指向对象的引用计数。例如：

shared_ptr<int> p1(new int(5));
shared_ptr<int> p2(p1);

在此示例中，p1 和 p2 指向同一个 int 类型的对象，并且引用计数为 2。当 p1 和 p2 都超出其作用域时，会自动释放该对象的内存。

3. 示例说明

3.1 动态内存分配的示例

下面的示例是一个对 int 类型的数组进行排序的程序。其中，使用了动态内存分配的技术，可以保证程序对于不同长度的数组都能正确处理。

#include <iostream>

using namespace std;

void sort_array(int* arr, int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            if (arr[i] > arr[j])
            {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

int main()
{
    int n;
    cout << "Enter the length of the array: ";
    cin >> n;

    int* arr = new int[n];
    cout << "Enter the numbers:" << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }

    sort_array(arr, n);

    cout << "The sorted array is:" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

    delete[] arr;

    return 0;
}

3.2 智能指针的示例

下面的示例是一个模拟栈的程序。在该程序中，使用了 shared_ptr 实现了对象的自动管理。

#include <iostream>
#include <memory>

using namespace std;

template<class T>
class Stack
{
public:
    void push(T t)
    {
        auto p = make_shared<T>(t);
        stk.push_back(p);
    }

    void pop()
    {
        stk.pop_back();
    }

    T top()
    {
        return *stk.back();
    }

private:
    vector<shared_ptr<T>> stk;
};

int main()
{
    Stack<int> stk;
    stk.push(1);
    stk.push(2);
    stk.push(3);

    cout << "Top of the stack: " << stk.top() << endl;

    stk.pop();
    cout << "Top of the stack after pop: " << stk.top() << endl;

    return 0;
}

在此示例中，stk 中存储的是 shared_ptr<int>，当该对象超出其作用域时，会自动释放被指向内存的引用计数。