C++的智能指针是一种特殊的指针类型，它能够自动管理内存资源，避免常见的内存泄漏和多次释放等问题。C++11引入了三种主要的智能指针：unique_ptr、shared_ptr和weak_ptr。

目录

①unique_ptr

②shared_ptr

③weak_ptr

---

①unique_ptr

在C++中，unique_ptr是一个智能指针（smart pointer）类模板，用于管理动态分配的内存资源，它提供了自动释放内存的功能。与原始指针相比，unique_ptr有更高的安全性和易用性。

unique_ptr具有以下特点：

独占所有权：每个unique_ptr实例拥有对其所指向对象的唯一所有权。这意味着在任何时候只有一个unique_ptr可以指向一个特定的对象。

自动释放内存：当unique_ptr超出作用域或被重新赋值时，它所管理的内存会自动释放。这样就避免了内存泄漏的问题。

指针语义：unique_ptr的使用方式与原始指针相似，可以通过指针操作符（->）和解引用操作符（*）来访问所指向对象的成员。

不可拷贝：unique_ptr是不可拷贝的，即不能进行复制构造和赋值操作。这是为了确保独占所有权的特性，防止多个指针同时管理同一个对象的内存。

支持移动语义：unique_ptr支持移动构造和移动赋值操作，可以将所有权转移给新的unique_ptr，而无需进行内存拷贝。

可自定义删除器：unique_ptr可以通过模板参数来指定一个删除器（deleter）函数对象，用于在释放内存时执行额外的清理操作。

示例代码：

#include <memory>

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

    // 使用指针操作符和解引用操作符访问所指向对象的值
    std::cout << *ptr << std::endl;  // 输出: 42

    // 通过移动构造函数将所有权转移给另一个unique_ptr
    std::unique_ptr<int> ptr2 = std::move(ptr);

    // 注意，此时ptr已经为空指针，不再拥有对象的所有权
    std::cout << *ptr2 << std::endl;  // 输出: 42

    // 使用自定义删除器
    struct Deleter {
        void operator()(int* p) {
            std::cout << "Custom deleter called" << std::endl;
            delete p;
        }
    };

    std::unique_ptr<int, Deleter> ptr3(new int(100), Deleter());

    // unique_ptr超出作用域时会自动释放内存，同时调用自定义删除器
    return 0;
}

常见成员函数

operator*：解引用操作符，用于获取 unique_ptr 所指向对象的引用。

operator->：箭头操作符，用于通过 unique_ptr 访问对象的成员函数或成员变量。

get：返回指向所管理对象的裸指针。

reset：重置 unique_ptr，释放当前所管理的对象并接管新的对象。

release：释放对所管理对象的控制权，并返回该指针的裸指针。

swap：交换两个 unique_ptr 的内容。

②shared_ptr

在C++中，shared_ptr是一个智能指针（smart pointer）类模板，用于管理动态分配的内存资源。与unique_ptr相比，shared_ptr可以实现多个指针共享同一块内存，并且提供了自动释放内存的功能。

shared_ptr具有以下特点：

共享所有权：多个shared_ptr实例可以同时指向同一个对象，它们共享对所指向对象的所有权。只有当所有shared_ptr都超出作用域或被重新赋值时，才会释放所管理的内存。

自动释放内存：当最后一个指向对象的shared_ptr超出作用域或被重新赋值时，它会自动释放所管理的内存。这种机制称为引用计数（reference counting），通过计数器来追踪当前有多少个shared_ptr指向同一块内存。

指针语义：shared_ptr的使用方式与原始指针相似，可以通过指针操作符（->）和解引用操作符（*）来访问所指向对象的成员。

可拷贝：shared_ptr是可拷贝的，即可以进行复制构造和赋值操作。每次拷贝会增加引用计数。当引用计数变为0时，表示没有任何shared_ptr指向该内存，会释放内存。

循环引用问题：如果存在循环引用（两个或多个对象相互持有shared_ptr），会导致内存泄漏。为了解决这个问题，可以使用弱引用指针weak_ptr。

示例代码：

#include <memory>

int main() {
    // 创建一个shared_ptr，指向一个动态分配的int对象
    std::shared_ptr<int> ptr1(new int(42));

    // 使用指针操作符和解引用操作符访问所指向对象的值
    std::cout << *ptr1 << std::endl;  // 输出: 42

    // 复制构造函数，共享同一块内存
    std::shared_ptr<int> ptr2 = ptr1;

    // 增加引用计数
    std::cout << ptr1.use_count() << std::endl;  // 输出: 2

    // 通过弱引用指针weak_ptr解决循环引用问题
    std::weak_ptr<int> weakPtr = ptr1;

    // 使用lock()函数获取一个shared_ptr
    std::shared_ptr<int> ptr3 = weakPtr.lock();
    if (ptr3 != nullptr) {
        // 成功获取shared_ptr
    }

    // 减少引用计数
    ptr1.reset();

    return 0;
}

常见成员函数

operator*：解引用操作符，用于获取 shared_ptr 所指向对象的引用。

operator->：箭头操作符，用于通过 shared_ptr 访问对象的成员函数或成员变量。

get：返回指向所管理对象的裸指针。

reset：重置 shared_ptr，释放当前所管理的对象并接管新的对象。

release：释放对所管理对象的控制权，并返回该指针的裸指针。

swap：交换两个 shared_ptr 的内容。

use_count：返回当前被所有 shared_ptr 指向的对象的引用计数。

③weak_ptr

在 C++ 中，weak_ptr 是一种智能指针（smart pointer），用于解决循环引用问题。它是由 shared_ptr 派生而来，但不会增加引用计数，只是对所指向对象进行观察，并不拥有对象的所有权。

循环引用问题

循环引用问题指的是在使用shared_ptr管理对象时，存在两个或多个对象相互持有shared_ptr，形成一个循环引用的情况。这种情况下，每个对象的引用计数都不会变为0，导致内存泄漏。

具体来说，当两个对象相互持有shared_ptr时，它们的引用计数始终大于0，因此它们所指向的内存块永远不会被释放。即使程序使用结束，这部分内存也无法回收，造成了内存泄漏的问题。

循环引用问题的实际场景可能是两个对象之间存在双向关联，比如A对象持有shared_ptr指向B对象，而B对象也持有shared_ptr指向A对象。当这两个对象的生命周期延长，超过了程序实际需要它们的时间时，就会造成循环引用和内存泄露。

为了解决循环引用问题，C++中引入了弱引用指针weak_ptr。弱引用指针和shared_ptr不同，它不会增加引用计数，只是对所指向对象进行观察，并不拥有对象的所有权。通过弱引用指针，我们可以在需要时使用lock()函数获取一个有效的shared_ptr来操作对象，一旦对象的引用计数变为0，弱引用指针将自动失效。

使用弱引用指针可以破坏循环引用，让所有的shared_ptr都能够正常析构并释放所管理的内存，避免了潜在的内存泄漏风险。

weak_ptr 具有以下特点和用法：

弱引用：因为 weak_ptr 不会增加引用计数，所以当所有 shared_ptr 都释放后，weak_ptr 将自动失效。它允许你观察一个对象，但不影响其生命周期。

通过 shared_ptr 创建：通常，我们使用 shared_ptr 来初始化 weak_ptr。这样可以确保 weak_ptr 观察的对象仍然存在。

使用 lock() 获取 shared_ptr：要操作 weak_ptr 所观察的对象，可以使用 lock() 函数获取一个有效的 shared_ptr。如果原始的 shared_ptr 已经被释放，lock() 返回一个空的 shared_ptr。

判断是否有效：可以使用 expired() 函数来检查 weak_ptr 是否已经失效，即所观察的 shared_ptr 是否已经被释放。

解决循环引用问题：由于 weak_ptr 不增加引用计数，可以用于解决两个或多个对象之间的循环引用问题，避免内存泄漏。

示例代码：

#include <memory>
#include <iostream>

class B; // 前置声明

class A {
public:
    std::shared_ptr<B> bPtr;

    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> aWeakPtr;

    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<A> aPtr = std::make_shared<A>();
    std::shared_ptr<B> bPtr = std::make_shared<B>();

    aPtr->bPtr = bPtr;
    bPtr->aWeakPtr = aPtr;

    std::cout << "Use count of aPtr: " << aPtr.use_count() << std::endl;
    std::cout << "Use count of bPtr: " << bPtr.use_count() << std::endl;

    // 使用 lock() 获取有效的 shared_ptr
    std::shared_ptr<A> lockedAPtr = bPtr->aWeakPtr.lock();
    if (lockedAPtr) {
        // 使用 lockedAPtr 操作所观察的对象
        std::cout << "A exists" << std::endl;
    } else {
        std::cout << "A does not exist" << std::endl;
    }

    return 0;
}

常见成员函数

expired：检查 weak_ptr 所观察的 shared_ptr 是否已经失效。

lock：获取一个有效的 shared_ptr，用于操作所观察的对象。如果原始的 shared_ptr 已经被释放，返回一个空的 shared_ptr。

use_count：返回当前被所有 shared_ptr 指向的对象的引用计数。

reset：重置 weak_ptr。