【C++】的智能指针

智能指针

C++ 中的智能指针是一类用于管理动态分配的内存资源的指针对象，它们可以自动释放资源，避免了手动释放内存和内存泄漏的问题。C++ 标准库提供了三种智能指针：std::unique_ptr、std::shared_ptr 和 std::weak_ptr，它们分别适用于不同的所有权和共享需求。

C++ 中的智能指针是一类用于管理动态分配的内存资源的指针对象，它们可以自动释放资源，避免了手动释放内存和内存泄漏的问题。C++ 标准库提供了三种智能指针：std::unique_ptr、std::shared_ptr 和 std::weak_ptr，它们分别适用于不同的所有权和共享需求。

1. std::unique_ptr：

   • 独占式智能指针，每个资源只能由一个 std::unique_ptr 拥有，不能共享。
   • 在 std::unique_ptr 离开作用域时，它所拥有的资源会被自动释放。
   • 使用 std::move 可以转移 std::unique_ptr 的所有权。

2. std::shared_ptr：

   • 共享式智能指针，多个 std::shared_ptr 可以共享同一个资源。
   • 采用引用计数机制，记录有多少个 std::shared_ptr 共享同一个资源，当引用计数变为零时，资源会被自动释放。
   • 使用 std::make_shared 创建 std::shared_ptr 更加安全和高效。

3. std::weak_ptr：

   • 弱引用指针，用于解决 std::shared_ptr 的循环引用问题。
   • std::weak_ptr 不增加引用计数，不影响资源的生命周期。
   • 可以通过 std::weak_ptr::lock 获得一个有效的 std::shared_ptr 对象，用于临时共享资源。

智能指针的优点：

• 自动管理资源：智能指针在离开作用域时，会自动调用适当的析构函数释放资源，避免了手动释放内存的繁琐工作和内存泄漏。
• 提高代码安全性：智能指针减少了手动内存管理带来的错误，例如 double delete 和悬空指针等问题。
• 简化代码：使用智能指针可以简化代码，并使代码更加易读和维护。

选择智能指针的准则：

• 使用 std::unique_ptr：当资源拥有唯一的所有权，不需要共享或者转移所有权时，使用 std::unique_ptr。
• 使用 std::shared_ptr：当资源需要共享给多个对象，并且可能存在循环引用时，使用 std::shared_ptr。
• 使用 std::weak_ptr：当需要解决 std::shared_ptr 循环引用问题时，使用 std::weak_ptr。

总结：

智能指针是 C++ 中非常有用的特性，它们能够简化内存管理，提高代码安全性，并减少资源泄漏的可能性。在现代 C++ 编程中，建议优先使用智能指针来管理动态分配的资源。

1.unique_ptr

std::unique_ptr 是C++11中引入的智能指针（Smart Pointer）之一，用于管理动态分配的内存指针，避免内存泄漏和手动释放资源的麻烦，std::unique_ptr 只能拥有唯一的所有权，不能共享，因此它是一个独占式智能指针。

std::unique_ptr 的特点和用法如下：

特点

1. 独占式拥有资源：一个 std::unique_ptr 只能拥有唯一的资源，不能与其他指针共享同一个资源，因此在转移所有权或者释放资源时不会发生冲突。
2. 自动释放资源：当 std::unique_ptr 离开其作用域时，它所拥有的资源会自动被释放，无需手动调用 delete。

用法

1.创建 std::unique_ptr：

#include <memory>

// 使用 new 创建资源，并将所有权交给 uniquePtr1
std::unique_ptr<int> uniquePtr1(new int(42));

// C++14 及以上版本可以使用 make_unique，更加安全和简洁
auto uniquePtr2 = std::make_unique<int>(42);

2.获取指针和访问资源：

int* rawPtr = uniquePtr1.get(); // 获取指向资源的原始指针（谨慎使用）
int value = *uniquePtr1;       // 通过解引用操作符访问资源

// 对 unique_ptr 进行条件判断
if (uniquePtr1) {
    // uniquePtr1 拥有资源，且资源不为 nullptr
    // 执行相关操作
}

3.转移所有权：

std::unique_ptr<int> uniquePtr3 = std::move(uniquePtr1); // 将资源从 uniquePtr1 转移给 uniquePtr3
// 现在 uniquePtr1 不再拥有资源，uniquePtr3 拥有资源

4.自动释放资源：

// 当 uniquePtr2 离开其作用域时，它所拥有的资源会自动被释放
// 无需手动调用 delete

5.使用自定义的删除器（Deleter）：

std::unique_ptr 允许使用自定义的删除器来释放资源，例如对于 C 风格的资源，可以使用自定义的释放函数或者 Lambda 表达式。

#include <cstdio>
#include <memory>

// 自定义删除器：使用 fclose 关闭文件指针
struct FileDeleter {
    void operator()(FILE* file) const {
        if (file) {
            fclose(file);
        }
    }
};

int main() {
    // 使用自定义删除器创建 unique_ptr
    std::unique_ptr<FILE, FileDeleter> filePtr(fopen("example.txt", "w"));

    // 使用文件指针进行操作（这里仅示意）
    if (filePtr) {
        fprintf(filePtr.get(), "Hello, unique_ptr!");
    }

    // 离开作用域时，自动调用 FileDeleter 的 operator() 关闭文件
    return 0;
}

总结：

std::unique_ptr 是 C++ 中用于独占式拥有资源的智能指针。它简化了动态内存管理，避免了内存泄漏，能够自动释放资源，并且提供了转移所有权的功能。建议在使用动态分配资源时优先考虑使用 std::unique_ptr，它是现代 C++ 中的重要工具之一。

2.shared_ptr

std::shared_ptr 是 C++ 标准库中的一种智能指针，用于管理动态分配的内存资源。它允许多个 std::shared_ptr 共享同一个资源，并且在所有 std::shared_ptr 离开作用域或者不再需要资源时，自动释放资源。std::shared_ptr 使用引用计数机制来追踪共享资源的引用次数，当引用计数为零时，资源会被释放。

特点和用法：

1. 共享所有权：多个 std::shared_ptr 可以同时拥有同一个资源，它们共享对资源的所有权。
2. 引用计数：每次创建一个新的 std::shared_ptr 对象时，引用计数会增加；当 std::shared_ptr 离开作用域或者通过 std::shared_ptr::reset() 手动释放资源时，引用计数会减少。当引用计数为零时，资源会被释放。
3. 安全和高效：std::shared_ptr 的引用计数机制可以防止重复释放资源和内存泄漏，使得内存管理更加安全和高效。
4. 使用 std::make_shared：为了避免手动创建 std::shared_ptr 对象，最好使用 std::make_shared 来创建，它可以减少一次内存分配并更加高效。

示例代码

#include <memory>
#include <iostream>

int main() {
    // 创建一个 shared_ptr，拥有一个动态分配的整数资源
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);

    // 使用 shared_ptr 进行操作
    if (sharedPtr) {
        std::cout << "Value: " << *sharedPtr << std::endl;
    }

    // 创建另一个 shared_ptr，共享同一个资源
    std::shared_ptr<int> sharedPtr2 = sharedPtr;

    // shared_ptr 的引用计数增加为 2

    // 使用 sharedPtr2 也可以访问资源
    if (sharedPtr2) {
        std::cout << "Value from sharedPtr2: " << *sharedPtr2 << std::endl;
    }

    // 当 shared_ptr2 离开作用域时，引用计数减少为 1

    // sharedPtr 离开作用域时，引用计数减少为 0，资源被释放

    return 0;
}

需要注意的是，std::shared_ptr 适用于共享资源的情况，但是由于引用计数机制，可能导致循环引用的问题。循环引用会导致资源无法正常释放，造成内存泄漏。为了解决循环引用的问题，C++ 提供了 std::weak_ptr 来处理弱引用情况。

总结：

std::shared_ptr 是 C++ 中管理动态分配资源的一种智能指针，它允许多个智能指针共享同一个资源，使用引用计数机制来自动释放资源。使用 std::shared_ptr 可以避免资源泄漏和重复释放资源的问题，提高代码的安全性和可维护性。但要注意避免循环引用的情况，可使用 std::weak_ptr 解决这个问题。

3.weak_ptr

std::weak_ptr 是 C++ 标准库中的一种智能指针，用于解决 std::shared_ptr 可能引发的循环引用问题。循环引用是指多个对象相互持有对方的 std::shared_ptr 导致引用计数无法降为零，从而造成资源无法正常释放，导致内存泄漏。std::weak_ptr 允许观察一个由 std::shared_ptr 管理的资源，但是不会增加资源的引用计数，因此不会导致循环引用的问题。

特点和用法：

1. 弱引用：std::weak_ptr 是一种弱引用，它允许观察 std::shared_ptr 拥有的资源，但不会增加资源的引用计数。当资源被释放后，std::weak_ptr 会自动失效，指向空对象。
2. 防止循环引用：通过使用 std::weak_ptr，可以避免 std::shared_ptr 之间可能造成的循环引用问题，从而解决资源无法释放的情况，防止内存泄漏。
3. 使用 std::weak_ptr：通常通过 std::weak_ptr 的 lock() 方法来获取一个有效的 std::shared_ptr。如果原始的 std::shared_ptr 资源还存在，则 lock() 方法返回有效的 std::shared_ptr；否则返回空指针。

示例代码：

#include <memory>
#include <iostream>

int main() {
    // 创建一个 shared_ptr，拥有一个动态分配的整数资源
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);

    // 创建一个 weak_ptr，观察 sharedPtr 所拥有的资源
    std::weak_ptr<int> weakPtr = sharedPtr;

    // 使用 weakPtr 获取 sharedPtr 的资源
    if (auto lockedPtr = weakPtr.lock()) {
        std::cout << "Value from weakPtr: " << *lockedPtr << std::endl;
    } else {
        std::cout << "Resource is no longer available." << std::endl;
    }

    // 释放 sharedPtr 资源
    sharedPtr.reset();

    // 使用 weakPtr 获取 sharedPtr 的资源
    if (auto lockedPtr = weakPtr.lock()) {
        std::cout << "Value from weakPtr: " << *lockedPtr << std::endl;
    } else {
        std::cout << "Resource is no longer available." << std::endl;
    }

    return 0;
}

在上面的示例中，我们创建了一个 std::shared_ptr 对象 sharedPtr 来管理动态分配的整数资源，并且创建了一个 std::weak_ptr 对象 weakPtr 来观察 sharedPtr 所拥有的资源。通过 weakPtr.lock() 方法，我们可以获取 sharedPtr 的资源，如果资源还存在，则返回有效的 std::shared_ptr；如果资源已被释放，则返回空指针。

总结：

std::weak_ptr 是 C++ 中解决 std::shared_ptr 循环引用问题的一种智能指针。它允许观察 std::shared_ptr 管理的资源，但不会增加引用计数，避免了循环引用可能导致的资源无法释放的问题。通过使用 std::weak_ptr，可以提高代码的安全性和可维护性，避免内存泄漏。在需要获取资源时，可以使用 lock() 方法获取有效的 std::shared_ptr，并在资源不存在时，正确地处理资源不可用的情况。