C++ 智能指针：内存管理的利器

2. std::shared_ptr（共享型智能指针）

• 核心特性：共享所有权，多个 shared_ptr 可指向同一块内存，通过引用计数（refcount）管理：
  • 新增一个 shared_ptr 指向该内存，引用计数 +1；
  • 某个 shared_ptr 销毁 / 重置，引用计数 -1；
  • 引用计数为 0 时，自动释放内存。
• 适用场景：需要多个指针共享同一资源（如容器存储指针、多模块共享对象）

示例

#include <iostream>
#include <memory>

int main() {
    // 1. 创建（推荐 std::make_shared，效率更高，减少内存分配次数）
    std::shared_ptr<Test> ptr1 = std::make_shared<Test>(1);
    std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 1

    // 2. 共享所有权（引用计数 +1）
    std::shared_ptr<Test> ptr2 = ptr1;
    std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 2

    // 3. 重置（引用计数 -1）
    ptr1.reset();
    std::cout << "引用计数：" << ptr1.use_count() << "\n"; // 输出 0

    // 4. 最后一个 shared_ptr 销毁，内存释放
    return 0;
}

注意：避免循环引用（如两个 shared_ptr 互相指向对方），会导致引用计数无法归 0，内存泄漏。此时需要配合 std::weak_ptr 解决

3. std::weak_ptr（弱引用智能指针）

• 核心特性：弱引用，不拥有资源所有权，仅观察 shared_ptr 管理的资源；
  • 不增加引用计数；
  • 可通过 lock() 方法获取有效的 shared_ptr（若资源未释放），否则返回空 shared_ptr。
• 适用场景：解决 shared_ptr 的循环引用问题，或需要观察资源但不影响其生命周期的场景。

示例

#include <iostream>
#include <memory>

class B; // 前向声明
class A {
public:
    std::weak_ptr<B> b_ptr; // 弱引用，避免循环引用
    ~A() { std::cout << "A 析构\n"; }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // 弱引用
    ~B() { std::cout << "B 析构\n"; }
};

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a; // 无循环引用，a/b 销毁时引用计数归 0，析构函数正常调用
    return 0;
}

三、delete 删除器

• 智能指针析构时默认是进行 delete 释放资源，这也就意味着如果不是 new 出来的资源（如：malloc、new[]、fopen...），交给智能指针管理，析构时就会崩溃
• 为了解决上面这个问题：智能指针支持用户提供一个删除器，在删除器中实现资源的释放。 但是提供位置不同 unique_ptr：作为模板参数提供（建议提供仿函数） shared_ptr：作为构造函数参数提供（仿函数、lambda、函数指针等都可以，建议 lambda） 删除器的本质是一个可调用对象。当提供了删除器，在智能指针析构的时候，就会调用这个删除器去释放资源。（这个删除器的调用在智能指针析构函数内部）

示例：释放 malloc 分配的内存（替代 free）

#include <iostream>
#include <memory>
#include <cstdlib> // malloc/free

// 自定义删除器：释放 malloc 分配的内存
void free_deleter(int* ptr) {
    std::cout << "自定义删除器：调用 free 释放内存\n";
    std::free(ptr);
}

int main() {
    // 用 malloc 分配内存，绑定自定义删除器
    int* raw_ptr = (int*)std::malloc(sizeof(int));
    *raw_ptr = 100;

    // shared_ptr 创建时指定删除器
    std::shared_ptr<int> ptr(raw_ptr, free_deleter);
    std::cout << *ptr << "\n"; // 输出 100

    // 超出作用域时，自动调用 free_deleter，而非默认的 delete
    return 0;
}

示例：释放数组（默认 unique_ptr<T[]> 用 delete[]，这里自定义）

#include <iostream>
#include <memory>

// 自定义数组删除器
struct ArrayDeleter {
    template <typename T>
    void operator()(T* ptr) const {
        std::cout << "自定义删除器：释放数组\n";
        delete[] ptr;
    }
};

int main() {
    // 方式 1：显式指定删除器类型
    std::unique_ptr<int, ArrayDeleter> ptr1(new int[5]{1,2,3,4,5});

    // 方式 2：用 lambda（需要推导类型，C++14 及以上）
    auto lambda_deleter = [](int* ptr) {
        std::cout << "lambda 删除器：释放数组\n";
        delete[] ptr;
    };
    std::unique_ptr<int, decltype(lambda_deleter)> ptr2(new int[3]{6,7,8}, lambda_deleter);
    return 0;
}