避免内存泄漏及泄漏后的排查方法【C++】

内存泄漏

前言
编码
- std::unique_ptr
- - 申请单个对象
  - 申请对象数组
- std::shared_ptr
- - 申请单个对象
  - 申请对象数组
编码总结

前言

最近在工作中被内存泄漏疯狂折磨，整理一下自己的思考。

编码

最近在工作中被内存泄漏疯狂折磨，我真的奉劝各位，如果你的业务代码中存在new，一定要把所有的new都干掉。已经2024年了，现在是很多程序员跟不上编译器适配新标准的节奏，而智能指针是在C++11上面就提供的特性。连 new 和 delete关键字都不要出现，因为一旦你的程序有内存泄漏，你就开始怀疑自己是不是 new 了没有 delete，这个过程非常折磨，而且肉眼去非常容易出错。我这里提供简单的实现，完全不去用 new 和 delete 关键字。

std::unique_ptr

std::unique_ptr 提供了对单个对象的独占所有权语义。
当 std::unique_ptr 离开作用域时，它所管理的对象会被自动销毁。

申请单个对象

#include <iostream>
#include <memory>

class MyClass 
{
public:
    MyClass(int x = 20) : value(x) { std::cout << "MyClass constructed\n"; }
    ~MyClass() { std::cout << "MyClass destroyed\n"; }
    int value;
};

int main()
{
    // 对于内置基本类型
    std::unique_ptr<int> p1 = std::make_unique<int>(10); // 创建一个int对象，初始化为10
    //备注：make_unique 在C++14才支持。

    // 对于自定义类型
    std::unique_ptr<MyClass> p2 = std::make_unique<MyClass>(20); // 创建一个MyClass对象

    std::cout << *p1 << std::endl;
    std::cout << p2->value << std::endl;

    return 0;
}

运行结果：

申请对象数组

#include <iostream>
#include <memory>

class MyClass 
{
public:
    MyClass(int x = 20) : value(x) { std::cout << "MyClass constructed\n"; }
    ~MyClass() { std::cout << "MyClass destroyed\n"; }
    int value;
};

int main()
{
    // 对于内置基本类型
    std::unique_ptr<int[]> arr1 = std::make_unique<int[]>(5); // 创建一个含有5个int的数组
    // 对于自定义类型
    std::unique_ptr<MyClass[]> arr2 = std::make_unique<MyClass[]>(5); // 创建一个含有5个MyClass对象的数组

    for (int i = 0; i < 5; ++i)
    {
        std::cout << arr1[i] << " " << arr2[i].value << std::endl;
    }

    return 0;
}

运行结果：

std::shared_ptr

std::shared_ptr 提供了共享所有权的语义，多个 std::shared_ptr 可以同时拥有同一个对象的所有权。
当最后一个拥有某个对象的std::shared_ptr被销毁时，该对象将被自动删除。

申请单个对象

#include <iostream>
#include <memory>

class MyClass 
{
public:
    MyClass(int x = 20) : value(x) { std::cout << "MyClass constructed\n"; }
    ~MyClass() { std::cout << "MyClass destroyed\n"; }
    int value;
};

int main()
{
    // 对于内置基本类型
    std::shared_ptr<int> p1 = std::make_shared<int>(10); // 创建一个int对象，初始化为10

    // 对于自定义类型
    std::shared_ptr<MyClass> p2 = std::make_shared<MyClass>(20); // 创建一个MyClass对象

    std::cout << *p1 << std::endl;
    std::cout << p2->value << std::endl;
    return 0;
}

运行结果：

申请对象数组

std::shared_ptr 没有直接支持数组的语法糖像 std::unique_ptr 那样默认情况下，std::shared_ptr 会使用 delete 而不是 delete[] 来释放它所管理的资源，这对于动态分配的数组来说是不正确的。

如果你需要使用 std::shared_ptr 管理动态数组，需要提供自定义的删除器。（不建议使用)

#include <iostream>
#include <memory>

class MyClass 
{
public:
    MyClass(int x = 20) : value(x) { std::cout << "MyClass constructed\n"; }
    ~MyClass() { std::cout << "MyClass destroyed\n"; }
    int value;
};

int main()
{
    std::shared_ptr<int> arr(new int[5], std::default_delete<int[]>());
    for (int i = 0; i < 5; ++i)
    {
        arr.get()[i] = i;
        std::cout << arr.get()[i] << " ";
    }
    std::cout << std::endl;

    // 创建一个std::shared_ptr来管理MyClass的一个数组
    // 注意：使用自定义删除器来确保使用delete[]来释放数组
    std::shared_ptr<MyClass> arr2(new MyClass[5],
        [](MyClass* p) {delete[] p; });
    for (int i = 0; i < 5; ++i)
    {
        std::cout << arr2.get()[i].value << " ";
    }
    std::cout << std::endl;

    // 现在myArray智能指针负责管理这个动态分配的数组，当myArray离开作用域或被重置时，
    // 自定义删除器会被调用来正确删除数组。

    return 0;
}

运行结果：

我们提供另外一种方式 shared + vector：

#include <iostream>
#include <memory>
#include <vector>

int main() {
    // 创建一个std::shared_ptr来管理一个std::vector<int>
    auto sharedVector = std::make_shared<std::vector<int>>();

    // 向vector中添加一些元素
    sharedVector->push_back(10);
    sharedVector->push_back(20);
    sharedVector->push_back(30);

    // 使用auto关键字遍历并打印vector的元素
    std::cout << "Vector elements: ";
    for (auto elem : *sharedVector) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 创建一个新的shared_ptr实例，共享原有vector的所有权
    std::shared_ptr<std::vector<int>> sharedVectorCopy = sharedVector;

    // 通过共享的vector添加更多元素
    sharedVectorCopy->push_back(40);
    sharedVectorCopy->push_back(50);

    // 再次打印vector的元素，展示更改
    std::cout << "Vector elements after modification: ";
    for (auto elem : *sharedVector) {  // 注意：此处使用sharedVector或sharedVectorCopy访问的是同一个vector
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 当sharedVector和sharedVectorCopy都离开作用域时，
    // 它们管理的vector会被自动删除，不需要手动释放内存。

    return 0;
}