智能指针std::unique_ptr 和 std::shared_ptr

std::unique_ptr 和 std::shared_ptr 是 C++11 引入的智能指针类型，它们分别用于不同的场景和需求。

std::unique_ptr

std::unique_ptr 提供独占所有权语义，意味着它独占地控制它所指向的对象的生命周期。一旦 std::unique_ptr 析构，它所拥有的对象也会被自动删除。std::unique_ptr 不支持拷贝，但可以移动，这意味着它可以在不同对象之间转移所有权。

使用示例：

#include 

int main() {
    // 创建一个unique_ptr实例
    std::unique_ptr<int> uptr(new int(10));
    std::cout << *uptr << std::endl;

    // 移动语义
    std::unique_ptr<int> uptr2 = std::move(uptr);
    std::cout << *uptr2 << std::endl;

    // 函数返回unique_ptr
    auto uptr3 = createUniquePtr();
    std::cout << *uptr3 << std::endl;

    // 管理动态数组
    std::unique_ptr<int[]> arrayPtr(new int[5]{1, 2, 3, 4, 5});
    for(int i = 0; i < 5; ++i)
        std::cout << arrayPtr[i] << " ";
    std::cout << std::endl;
    
    return 0;
}

std::unique_ptr<int> createUniquePtr() {
    return std::unique_ptr<int>(new int(20));
}

std::shared_ptr

std::shared_ptr 允许多个指针共享对同一对象的所有权。std::shared_ptr 使用引用计数机制来跟踪指向同一对象的指针数量。当最后一个 std::shared_ptr 对象析构或重置时，对象会被删除。

使用示例：

#include 
#include 

int main() {
    // 创建一个shared_ptr实例
    std::shared_ptr<int> sptr(new int(10));
    std::cout << *sptr << std::endl;

    // 可以拷贝
    std::shared_ptr<int> sptrCopy(sptr);
    std::cout << *sptrCopy << std::endl;

    // 可以赋值
    std::shared_ptr<int> sptrAssign;
    sptrAssign = sptr;
    std::cout << *sptrAssign << std::endl;

    return 0;
}

注意事项

• 使用 std::shared_ptr 时要注意循环引用问题，这可能导致内存泄漏。可以通过 std::weak_ptr 来解决这个问题。
• std::unique_ptr 更适合单个对象的所有权管理，而 std::shared_ptr 则适用于需要共享资源的场景。
• 在选择智能指针时，应优先考虑使用 std::unique_ptr，因为它更安全且效率更高。只有在确实需要共享资源时才使用 std::shared_ptr。

确保在实际编码时包含 头文件，因为 std::unique_ptr 和 std::shared_ptr 都定义在这个头文件中。

循环引用问题通常出现在编程中，尤其是在使用智能指针或引用计数机制的语言中，如C++、Python、JavaScript等。循环引用发生时，两个或更多的对象直接或间接地互相引用，导致没有单一的起点或终点来终止引用链。这可能导致一些问题，尤其是内存管理和性能问题。

在C++中
在C++中，使用std::shared_ptr时最常遇到循环引用问题。std::shared_ptr通过引用计数来决定何时删除对象。当一个std::shared_ptr对象被销毁或者它的引用计数减少到零时，它所管理的对象会被释放。然而，如果两个或多个std::shared_ptr对象相互引用，它们的引用计数将永远不会降到零，从而导致这些对象无法被释放，产生内存泄漏。

解决方法：

使用std::weak_ptr来打破循环引用。std::weak_ptr不增加引用计数，因此不会阻止对象被销毁。
设计对象的生命周期，避免不必要的相互引用。
如果可能，使用std::unique_ptr来明确拥有关系，std::unique_ptr不允许共享所有权。

std::unique_ptr

std::make_shared 则是一个工厂函数，用于创建 std::shared_ptr 对象。

std::shared_ptr 和 std::make_shared 之间的主要区别在于如何创建和初始化 shared_ptr 实例。以下是两者之间的一些关键差异：

创建方式

• 使用 new 显式创建并传递给 shared_ptr

  int *data = new int(10);
  std::shared_ptr<int> ptr(data);
  

  这种方法的一个问题是，如果构造 shared_ptr 时发生异常（比如抛出异常），那么原始的指针 data 将不会被释放，可能导致内存泄漏。

• 使用 make_shared 创建

  auto ptr = std::make_shared<int>(10);
  

  使用 make_shared 可以避免上述问题，因为它在内部会处理好资源管理，并且能够有效地处理异常情况。

性能

• std::make_shared 在性能上通常优于直接用 new 创建对象然后传递给 shared_ptr。这是因为 make_shared 会在一个步骤中同时分配对象和控制块（用于存储引用计数等信息），而使用 new 后再传递给 shared_ptr 需要两次分配操作。

异常安全性

• 当使用 std::make_shared 构造 shared_ptr 时，如果构造过程中抛出异常，则不会留下悬挂的裸指针，并且任何已经分配的资源都会被正确清理。
• 直接使用 new 并将结果传递给 shared_ptr 的构造函数则需要更谨慎地处理可能发生的异常，以避免内存泄漏。

参数转发

• make_shared 可以接受任意数量和类型的参数，并将它们传递给所构造的对象的构造函数。
• 直接使用 shared_ptr 的构造函数时，你需要先创建一个裸指针，然后再将其传递给 shared_ptr。

总结来说，std::make_shared 是创建 std::shared_ptr 的推荐方式，因为它更安全、更高效，并且可以更好地处理异常情况。在大多数情况下，应该优先使用 std::make_shared 而不是直接使用 new 和 shared_ptr 构造函数。