C++之智能指针

智能指针是C++中的一种资源管理工具，用于自动管理动态分配的内存。它们通过在不再需要时自动释放内存来防止内存泄漏。C++标准库提供了几种不同类型的智能指针，每种都有其特定的用途和行为。

主要的智能指针类型

1. std::unique_ptr
2. std::shared_ptr
3. std::weak_ptr

1. std::unique_ptr

std::unique_ptr 是一种独占所有权的智能指针。它确保只有一个指针指向某个对象，并且当 std::unique_ptr 被销毁时，它所管理的对象也会被自动删除。

示例代码

#include <iostream>
#include <memory>

int main() {
    // 创建一个 unique_ptr，管理一个动态分配的 int 对象
    std::unique_ptr<int> ptr(new int(10));

    // 或者使用 make_unique (C++14 及以后)
    auto ptr2 = std::make_unique<int>(20);

    // 使用指针
    std::cout << "ptr: " << *ptr << std::endl;
    std::cout << "ptr2: " << *ptr2 << std::endl;

    // unique_ptr 不支持拷贝构造和赋值
    // std::unique_ptr<int> ptr3 = ptr; // 编译错误

    // 但是支持移动构造和赋值
    std::unique_ptr<int> ptr3 = std::move(ptr);
    std::cout << "ptr3: " << *ptr3 << std::endl;

    // 此时 ptr 已经为空
    if (!ptr) {
        std::cout << "ptr 已经为空" << std::endl;
    }

    return 0;
}

2. std::shared_ptr

std::shared_ptr 是一种共享所有权的智能指针。多个 std::shared_ptr 可以指向同一个对象，当最后一个 std::shared_ptr 被销毁时，它所管理的对象才会被删除。

示例代码

#include <iostream>
#include <memory>

int main() {
    // 创建一个 shared_ptr，管理一个动态分配的 int 对象
    std::shared_ptr<int> ptr1 = std::make_shared<int>(10);

    // 创建另一个 shared_ptr，共享同一个对象
    std::shared_ptr<int> ptr2 = ptr1;

    // 使用指针
    std::cout << "ptr1: " << *ptr1 << ", 引用计数: " << ptr1.use_count() << std::endl;
    std::cout << "ptr2: " << *ptr2 << ", 引用计数: " << ptr2.use_count() << std::endl;

    // 创建第三个 shared_ptr，共享同一个对象
    std::shared_ptr<int> ptr3 = ptr1;
    std::cout << "ptr3: " << *ptr3 << ", 引用计数: " << ptr3.use_count() << std::endl;

    // 当最后一个 shared_ptr 被销毁时，对象会被删除
    return 0;
}

3. std::weak_ptr

std::weak_ptr 是一种观察型智能指针，它不增加引用计数，也不会阻止对象被删除。std::weak_ptr 主要用于解决循环引用问题。

示例代码

#include <iostream>
#include <memory>

int main() {
    // 创建一个 shared_ptr，管理一个动态分配的 int 对象
    std::shared_ptr<int> ptr1 = std::make_shared<int>(10);

    // 创建一个 weak_ptr，观察同一个对象
    std::weak_ptr<int> wptr = ptr1;

    // 使用 weak_ptr 获取 shared_ptr
    if (auto sptr = wptr.lock()) {
        std::cout << "wptr 锁定的对象: " << *sptr << std::endl;
    } else {
        std::cout << "wptr 锁定的对象已失效" << std::endl;
    }

    // 释放最后一个 shared_ptr
    ptr1.reset();

    // 再次尝试锁定 weak_ptr
    if (auto sptr = wptr.lock()) {
        std::cout << "wptr 锁定的对象: " << *sptr << std::endl;
    } else {
        std::cout << "wptr 锁定的对象已失效" << std::endl;
    }

    return 0;
}

总结

• std::unique_ptr：适用于独占所有权的场景，性能最高，推荐优先使用。
• std::shared_ptr：适用于共享所有权的场景，内部使用引用计数管理对象生命周期。
• std::weak_ptr：主要用于解决循环引用问题，不增加引用计数。

通过合理使用这些智能指针，可以有效地管理动态分配的内存，避免内存泄漏和其他资源管理问题。