C++的智能指针

FHKHH

已于 2024-04-13 11:33:39 修改

阅读量733

点赞数 11

分类专栏： C++学习文章标签： c++ 开发语言

于 2024-04-13 10:59:02 首次发布

本文链接：https://blog.csdn.net/FHKHH/article/details/137710607

版权

C++学习专栏收录该内容

20 篇文章 0 订阅

订阅专栏

智能指针

智能指针是C++中用于自动管理动态分配内存的对象，它通过包装原始指针，提供了类似指针的接口，并在适当的时候自动释放内存，从而帮助避免内存泄露。C++标准库提供了几种智能指针，其中最常用的是std::unique_ptr、std::shared_ptr和std::weak_ptr。

std::unique_ptr

std::unique_ptr是一种独占所有权的智能指针，保证同一时间内只有一个智能指针实例可以拥有某个对象的所有权。当std::unique_ptr被销毁时，它所指向的对象也会被自动销毁。

#include <iostream>
#include <memory> // 包含智能指针的头文件

class Entity {
public:
    Entity() { std::cout << "Entity created" << std::endl; }
    ~Entity() { std::cout << "Entity destroyed" << std::endl; }
    void sayHello() { std::cout << "Hello!" << std::endl; }
};

int main() {
    {
        std::unique_ptr<Entity> myEntity = std::make_unique<Entity>(); // 使用std::make_unique创建实例
        myEntity->sayHello(); // 使用->操作符访问Entity的成员
    } // myEntity离开作用域，自动销毁Entity实例
}

std::shared_ptr

std::shared_ptr是一种共享所有权的智能指针，允许多个std::shared_ptr实例共同拥有同一个对象。当最后一个拥有该对象的std::shared_ptr被销毁时，对象会被自动删除。

#include <iostream>
#include <memory>

class Entity {
public:
    Entity() { std::cout << "Entity created" << std::endl; }
    ~Entity() { std::cout << "Entity destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<Entity> sharedEntity1 = std::make_shared<Entity>(); // 创建一个Entity实例
    {
        std::shared_ptr<Entity> sharedEntity2 = sharedEntity1; // sharedEntity2现在与sharedEntity1共享Entity实例
        // 此作用域结束时，sharedEntity2被销毁，但Entity实例不会被删除，因为sharedEntity1仍然存在
    }
    // 离开最外层的作用域，sharedEntity1被销毁，Entity实例也随之被删除
}

std::weak_ptr

std::weak_ptr是一种不拥有对象的智能指针，它被设计用来解决std::shared_ptr之间的循环引用问题。std::weak_ptr持有一个对象的引用，但不计入所有权计数，因此不会阻止其被销毁。

#include <iostream>
#include <memory>

class Entity {
public:
    std::weak_ptr<Entity> other; // 使用weak_ptr避免循环引用
    Entity() { std::cout << "Entity created" << std::endl; }
    ~Entity() { std::cout << "Entity destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<Entity> first = std::make_shared<Entity>();
    std::shared_ptr<Entity> second = std::make_shared<Entity>();
    
    first->other = second; // first拥有指向second的弱引用
    second->other = first; // second拥有指向first的弱引用
    
    // 即使它们互相引用，对象也能被正确销毁
}

智能指针通过自动管理内存的生命周期，减少了手动内存管理的错误和复杂性。在现代C++开发中，智能指针是推荐的资源管理方式。

更详细地探讨智能指针，包括它们的工作原理、使用场景以及优势。

std::unique_ptr

std::unique_ptr是一个模板类，提供了对动态分配内存的独占所有权。它保证同一时间内只有一个std::unique_ptr可以指向一个给定的资源。这种独占所有权的特性意味着std::unique_ptr不能被复制，只能被移动，这保证了资源的唯一性和安全性。

工作原理：

当std::unique_ptr的实例被销毁（例如，离开其作用域）时，它会自动删除它所拥有的对象。
你可以使用std::move()将所有权从一个std::unique_ptr转移给另一个std::unique_ptr，这会使原始指针失去所有权（变为空指针）。

使用场景：

管理具有明确生命周期的资源。
作为类成员，当类实例被销毁时自动清理资源。

std::shared_ptr

std::shared_ptr是一个引用计数的智能指针，它允许多个指针实例共享同一个资源的所有权。每当一个新的std::shared_ptr指向一个资源时，内部的引用计数会增加；当std::shared_ptr被销毁时，引用计数减少。当引用计数降到零时，资源会被自动删除。

工作原理：

std::shared_ptr通过一个控制块来维护资源的引用计数。控制块包含了资源指针、引用计数和任何自定义删除器的信息。
可以通过std::make_shared创建一个std::shared_ptr，这是推荐的方式，因为它可以原子性地分配控制块和资源，优化内存使用。

使用场景：

适用于资源需要被多个所有者共享的情况。
当需要将资源的所有权传递给外部API或系统而不放弃本地所有权时。

std::weak_ptr

std::weak_ptr是为了配合std::shared_ptr使用而设计的，它不对对象的生命周期进行管理，只是提供了一种访问std::shared_ptr管理资源的方式，而不增加引用计数。

工作原理：

std::weak_ptr持有对控制块的引用，但不增加或减少引用计数。因此，它不会影响其指向的对象的生命周期。
使用std::weak_ptr可以避免std::shared_ptr之间的循环引用问题，这种问题会导致内存泄漏。

使用场景：

当需要观察一个由std::shared_ptr管理的对象，但不需要拥有它时。
解决std::shared_ptr循环引用问题，例如，在父子关系中，父亲拥有对子女的std::shared_ptr，而子女仅持有对父亲的std::weak_ptr。

循环引用是指两个或多个对象通过引用（如指针或引用类型的变量）相互持有对方，形成一个闭环的情况。这种情况在使用普通指针时可能不会导致问题，但在使用智能指针，特别是 std::shared_ptr 的情况下，可能会导致内存泄漏。

如何形成循环引用？

假设有两个类 A 和 B，它们互相持有对方的 std::shared_ptr：

#include <memory>

class B; // 前置声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destructor\n"; }
};

class B {
public:
    std::shared_ptr<A> a_ptr;
    ~B() { std::cout << "B destructor\n"; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a;
    return 0;
}

在上面的例子中，A 的实例持有 B 的实例的智能指针，同时 B 的实例也持有 A 的实例的智能指针。这样，它们就形成了一个循环引用。当 main 函数结束时，即使 a 和 b 的 std::shared_ptr 被销毁，A 和 B 的实例的引用计数仍然各自为 1（由于相互引用），导致它们的析构函数不会被调用，内存不会被释放。

循环引用的解决方法

循环引用的一个常见解决方法是使用 std::weak_ptr 来替换其中一个 std::shared_ptr。std::weak_ptr 不增加引用计数，因此不会阻止所指向的对象被正确销毁。

修改上述代码使用 std::weak_ptr 可以避免内存泄漏：

#include <memory>

class B;

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destructor\n"; }
};

class B {
public:
    std::weak_ptr<A> a_ptr;  // 使用 weak_ptr 替代 shared_ptr
    ~B() { std::cout << "B destructor\n"; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a;
    return 0;
}

在这个修改后的例子中，B 类中的 a_ptr 是一个 std::weak_ptr，它指向 A 的实例但不增加引用计数。因此，当 main 函数中的 std::shared_ptr 被销毁时，由于 A 的实例引用计数变为0，它会被销毁，并相应地减少 B 实例的引用计数，最终导致 B 实例也被销毁，避免了内存泄漏。