当前位置：首页 > article >正文

[C/C++]智能指针是什么？实现原理是什么？

article 2024/12/26 8:25:31

智能指针

智能指针是C++提供的一种资源管理工具，用于自动管理动态分配的内存，避免手动调用 new 和 delete 时可能出现的内存泄漏、悬挂指针等问题。智能指针通过封装原始指针，并在适当的时候自动释放资源，从而简化了内存管理。

智能指针在C++11版本之后提供，包含在头文件<memory>中，主要包括以下几种shared_ptr、unique_ptr、weak_ptr：

std::unique_ptr

独占所有权的智能指针

每个 unique_ptr 对象只能拥有一个指向的对象，不能复制，但可以转移所有权。

std::shared_ptr

共享所有权的智能指针

多个 shared_ptr 可以同时指向同一个对象，当最后一个 shared_ptr 被销毁或重置时，才会释放所指向的对象。

std::weak_ptr

弱引用智能指针

配合shared_ptr引入的一种智能指针，它不增加引用计数，主要用于解决 shared_ptr 之间的循环引用问题。

简述

unique_ptr：独占式指针，同一时刻只能有一个指针指向同一个对象
shared_ptr：共享式指针，同一时刻可以有多个指针指向同一个对象
weak_ptr：用来解决shared_ptr相互引用导致的死锁问题

理解

智能指针利用了RAII（Resource Acquisition Is Initializatio 资源获取即初始化）
对普通的指针进行封装，这使得智能指针实质是一个对象，行为表现的却像一个指针
智能指针防止
①忘记调用delete释放内存
②程序异常的进入catch块忘记释放内存
③多次释放同一个指针(会造成程序崩溃)
智能指针把值语义转换成引用语义

实现原理

1. std::unique_ptr 的实现原理

std::unique_ptr 是最简单的智能指针，它的实现基于 RAII（Resource Acquisition Is Initialization）原则。unique_ptr 在构造时获取资源，在析构时自动释放资源。由于它是独占所有权的，因此不允许复制，但可以通过 std::move 来转移所有权。

2. std::shared_ptr 的实现原理

std::shared_ptr 通过引用计数机制来管理对象的生命周期。多个 shared_ptr 可以共享同一个对象，只有当所有共享该对象的 shared_ptr 都被销毁或重置时，才会释放该对象。

引用计数：shared_ptr 内部维护一个控制块（control block），其中包含两个计数器：

强引用计数：记录有多少个 shared_ptr 正在共享该对象。当强引用计数为 0 时，对象会被销毁。

弱引用计数：记录有多少个 weak_ptr 正在引用该对象。弱引用计数用于管理控制块的生命周期，当弱引用计数也为 0 时，控制块也会被释放。

线程安全：shared_ptr 的引用计数操作是线程安全的，即多个线程可以同时对同一个 shared_ptr 进行增减引用计数，而不会导致竞争条件。

3. std::weak_ptr 的实现原理

std::weak_ptr 是 shared_ptr 的一种弱引用形式，它不增加强引用计数，因此不会影响对象的生命周期。weak_ptr 主要用于解决 shared_ptr 之间的循环引用问题。

弱引用：weak_ptr 不直接持有对象的所有权，它只是通过 shared_ptr 的控制块来访问对象。如果对象已经被销毁，weak_ptr 会感知到这一点，并返回一个空的 shared_ptr。

锁机制：通过 lock() 方法，weak_ptr 可以临时获得一个 shared_ptr，从而安全地访问对象。如果对象已经被销毁，lock() 会返回一个空的 shared_ptr。

代码示例

#include <iostream>
#include <memory>  // 引入智能指针的头文件

// 定义一个简单的类
class Resource {
public:
    Resource() { std::cout << "Resource created\n"; }
    ~Resource() { std::cout << "Resource destroyed\n"; }

    void doSomething() const {
        std::cout << "Doing something...\n";
    }
};

int main() {
    // === 使用 unique_ptr ===
    {
        // 创建一个 unique_ptr，独占所有权
        std::unique_ptr<Resource> uniquePtr = std::make_unique<Resource>();

        // 调用对象的方法
        uniquePtr->doSomething();

        // 尝试复制 unique_ptr（编译错误）
        // std::unique_ptr<Resource> anotherUniquePtr = uniquePtr;

        // 移动所有权
        std::unique_ptr<Resource> movedUniquePtr = std::move(uniquePtr);

        // uniquePtr 现在为空，无法再访问资源
        if (!uniquePtr) {
            std::cout << "uniquePtr is now empty\n";
        }

        // movedUniquePtr 仍然持有资源
        movedUniquePtr->doSomething();
    }  // 当作用域结束时，movedUniquePtr 自动释放资源

    std::cout << "After unique_ptr scope\n";

    // === 使用 shared_ptr ===
    {
        // 创建一个 shared_ptr，共享所有权
        std::shared_ptr<Resource> sharedPtr1 = std::make_shared<Resource>();

        // 获取引用计数
        std::cout << "Reference count: " << sharedPtr1.use_count() << "\n";

        // 创建另一个 shared_ptr，共享同一个对象
        std::shared_ptr<Resource> sharedPtr2 = sharedPtr1;
        std::cout << "Reference count after copying: " << sharedPtr1.use_count() << "\n";

        // 调用对象的方法
        sharedPtr1->doSomething();

        // 当 sharedPtr2 超出作用域时，引用计数减1
    }  // sharedPtr2 超出作用域，引用计数变为1

    // sharedPtr1 仍然存在，对象不会被销毁
    std::cout << "After shared_ptr2 scope\n";

    // === 使用 weak_ptr ===
    {
        // 创建一个 shared_ptr，用于创建 weak_ptr
        std::shared_ptr<Resource> sharedPtr3 = std::make_shared<Resource>();

        // 创建一个 weak_ptr，弱引用 sharedPtr3 所指向的对象
        std::weak_ptr<Resource> weakPtr = sharedPtr3;

        // 检查 weak_ptr 是否仍然有效
        if (auto lockedPtr = weakPtr.lock()) {
            // 如果对象仍然存在，lockedPtr 是一个有效的 shared_ptr
            std::cout << "Object is still alive\n";
            lockedPtr->doSomething();
        } else {
            // 对象已被销毁
            std::cout << "Object has been destroyed\n";
        }

        // 释放 sharedPtr3，对象将被销毁
        sharedPtr3.reset();

        // 再次检查 weak_ptr
        if (auto lockedPtr = weakPtr.lock()) {
            // 对象已被销毁，lockedPtr 为空
            std::cout << "Object is still alive\n";
        } else {
            std::cout << "Object has been destroyed\n";
        }
    }

    return 0;
}

代码输出

Resource created
Doing something...
uniquePtr is now empty
Doing something...
Resource destroyed
After unique_ptr scope
Resource created
Reference count: 1
Reference count after copying: 2
Doing something...
Resource destroyed
After shared_ptr2 scope
Resource created
Object is still alive
Doing something...
Resource destroyed
Object has been destroyed

智能指针是C++中非常重要的工具，能够有效管理动态分配的内存，避免常见的内存管理问题。std::unique_ptr 适用于独占所有权的场景，std::shared_ptr 适用于共享所有权的场景，而 std::weak_ptr 则用于解决循环引用问题。

查看全文

http://www.kler.cn/a/451898.html