深入理解 C++11 智能指针：独占、共享与弱引用的完美管理

文章目录

std::unique_ptr（独占式智能指针）
std::shared_ptr（共享式智能指针）
std::weak_ptr（弱引用智能指针）
示例展示：
智能指针的原理
内存泄漏
- **什么是内存泄漏，内存泄漏的危害**
- **如何检测内存泄漏**
- **如何避免内存泄漏**
C++11和boost中智能指针的关系
unique_ptr自己实现
shared_ptr

C++标准库提供了三种主要类型的智能指针：

std::unique_ptr（独占式智能指针）

unique_ptr是最常用的一种智能指针，它确保一个指针在同一时刻只能有一个所有者。当unique_ptr超出作用域时，它所持有的资源会自动被销毁。

特点：

不能被复制，只能被转移（通过std::move）。
负责管理指向对象的生命周期，自动释放资源。

std::unique_ptr<int> ptr(new int(5));  // 创建unique_ptr并指向动态分配的内存
// 当ptr超出作用域时，内存会被自动释放

适用场景：

用于表达资源的独占所有权，比如文件句柄、数据库连接等。

std::shared_ptr（共享式智能指针）

shared_ptr允许多个指针共享对同一个对象的所有权。当所有指向同一对象的shared_ptr都被销毁时，所管理的资源才会被释放。shared_ptr通过引用计数来管理对象的生命周期。

特点：

支持多个shared_ptr实例共同拥有一个对象。
引用计数：每当一个新的shared_ptr指向对象时，引用计数增加；当shared_ptr销毁时，引用计数减少；当引用计数为0时，资源被自动释放。

std::shared_ptr<int> ptr1 = std::make_shared<int>(10);  // 创建shared_ptr并初始化
std::shared_ptr<int> ptr2 = ptr1;  // 共享资源，引用计数为2

适用场景：

用于需要多个所有者共享一个资源的场景，比如共享的数据结构、图形界面中多个组件共享同一数据等。

std::weak_ptr（弱引用智能指针）

weak_ptr是与shared_ptr配合使用的智能指针，它不会增加引用计数，因此不会影响资源的生命周期。weak_ptr通常用于解决shared_ptr之间的循环引用问题。

特点：

不增加引用计数，因此不会导致资源无法释放。
可以通过 lock() 方法将其转换为shared_ptr，在获取资源之前，需要确保资源还存在。

std::weak_ptr<int> weakPtr = ptr1;  // 不增加引用计数
if (auto lockedPtr = weakPtr.lock()) 
{
    // 使用lockedPtr来访问资源
}

适用场景：

用于观察者模式，避免循环引用。
用于缓存系统，避免过度占用内存。

智能指针类型概览

unique_ptr：独占所有权，不能拷贝只能移动
shared_ptr：共享所有权，基于引用计数
weak_ptr：配合 shared_ptr 使用，解决循环引用问题
auto_ptr（已废弃）：C++98 的智能指针，不推荐使用

示例展示：

unique_ptr 示例（独占所有权）

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created\n"; }
    ~MyClass() { std::cout << "MyClass destroyed\n"; }
    void greet() { std::cout << "Hello from MyClass!\n"; }
};

int main() 
{
    // 创建 unique_ptr
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
    
    // 转移所有权
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);
    
    if(ptr2) 
    {
        ptr2->greet();  // 正常调用
    }
    
    if(!ptr1) 
    {
        std::cout << "ptr1 is now empty\n";
    }
    
    // 自动释放内存，无需手动delete
    return 0;
}

shared_ptr 示例（共享所有权）

#include <memory>
#include <iostream>

class Item 
{
public:
    Item() { std::cout << "Item created\n"; }
    ~Item() { std::cout << "Item destroyed\n"; }
};

int main() 
{
    // 创建共享指针
    std::shared_ptr<Item> ptr1 = std::make_shared<Item>();
    
    {
        std::shared_ptr<Item> ptr2 = ptr1;  // 引用计数变为2
        std::cout << "Use count: " << ptr2.use_count() << "\n";  // 输出2
    }  // 引用计数回到1
    
    std::cout << "Use count: " << ptr1.use_count() << "\n";  // 输出1
    
    // 离开作用域时引用计数归零，自动释放内存
    return 0;
}

weak_ptr 示例（解决循环引用）

#include <memory>
#include <iostream>

class Node;

class Parent 
{
public:
    std::shared_ptr<Node> child;
    ~Parent() { std::cout << "Parent destroyed\n"; }
};

class Node 
{
public:
    std::weak_ptr<Parent> parent;  // 使用 weak_ptr 避免循环引用
    ~Node() { std::cout << "Node destroyed\n"; }
};

int main() 
{
    auto parent = std::make_shared<Parent>();
    auto node = std::make_shared<Node>();
    
    parent->child = node;
    node->parent = parent;  // 不会增加引用计数
    
    // 离开作用域后对象都能正常销毁
    return 0;
}

智能指针特点比较

特性	unique_ptr	shared_ptr	weak_ptr
所有权	独占	共享	无
拷贝操作	❌	✅	✅
移动操作	✅	✅	✅
引用计数	无	有	观察计数
线程安全	否	控制块安全	同shared
自定义删除器	✅	❌	❌

智能指针的原理

智能指针的原理主要依赖于C++的RAII（资源获取即初始化）机制，它通过封装指针来管理资源（如内存、文件句柄等）的生命周期。智能指针在构造时获取资源，在析构时释放资源，确保在程序结束时自动清理，从而避免了内存泄漏和悬空指针等问题。

智能指针的基本原理
智能指针是封装了裸指针的类，它管理着指向对象的生命周期。当智能指针超出作用域时，它会自动释放资源，防止忘记手动删除内存等问题。智能指针的实现通常依赖于以下几个核心概念：

构造函数：在创建智能指针时，智能指针会初始化并持有一个裸指针，指向一个动态分配的资源。
析构函数：当智能指针超出作用域时，析构函数会自动调用，释放资源（例如：delete）。
拷贝控制：智能指针需要对资源的所有权进行管理，避免多个指针共享同一资源时出现的问题。拷贝构造函数、赋值运算符和移动构造函数会控制资源的所有权转移。

智能指针的内存管理原理
智能指针通过管理内存的生命周期来避免内存泄漏。它们利用C++的构造和析构机制，当智能指针对象销毁时，自动调用析构函数，确保内存资源被正确释放。

unique_ptr：独占资源，不允许其他指针共享资源的所有权。当unique_ptr析构时，自动删除它所持有的资源。
shared_ptr：使用引用计数机制，当资源被多个shared_ptr共享时，资源在最后一个shared_ptr析构时才会被释放。
weak_ptr：通过不增加引用计数来避免循环引用问题，它是一个观察者，不负责资源的释放。

内存泄漏

什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使⽤的内存，⼀般是忘记释放或者发⽣异常释放程序未能执⾏导致的。内存泄漏并不是指内存在物理上的消失，⽽是应⽤程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因⽽造成了内存的浪费。
内存泄漏的危害：普通程序运⾏⼀会就结束了出现内存泄漏问题也不⼤，进程正常结束，⻚表的映射关系解除，物理内存也可以释放。⻓期运⾏的程序出现内存泄漏，影响很⼤，如操作系统、后台服务、⻓时间运⾏的客⼾端等等，不断出现内存泄漏会导致可⽤内存不断变少，各种功能响应越来越慢，最终卡死。

int main()
 {
	 // 申请⼀个1G未释放，这个程序多次运⾏也没啥危害 
	 // 因为程序⻢上就结束，进程结束各种资源也就回收了
 
	 char* ptr = new char[1024 * 1024 * 1024];
	 cout << (void*)ptr << endl;
	 return 0;
 }

如何检测内存泄漏

内存泄漏的本质
内存泄漏（Memory Leak）是指程序在动态分配内存后，失去了对该内存的控制权，导致无法释放，最终耗尽系统内存资源。

典型特征：

程序运行时间越长，内存占用持续增长
重复执行相同操作时内存消耗不断增加
最终可能导致程序崩溃或系统变慢

高级检测手段

工具名称	平台	特点
Dr. Memory	跨平台	比 Valgrind 更快
Intel Inspector	Windows	提供图形化界面
LeakSanitizer	Linux	与 ASan 集成

如何避免内存泄漏

⼯程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下⼀条智能指针来管理才有保证。
尽量使⽤智能指针来管理资源，如果⾃⼰场景⽐较特殊，采⽤RAII思想⾃⼰造个轮⼦管理。
定期使⽤内存泄漏⼯具检测，尤其是每次项⽬快上线前，不过有些⼯具不够靠谱，或者是收费。
总结⼀下：内存泄漏⾮常常⻅，解决⽅案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测⼯具。

C++11和boost中智能指针的关系

Boost库是为C++语⾔标准库提供扩展的⼀些C++程序库的总称，Boost社区建⽴的初衷之⼀就是为C++的标准化⼯作提供可供参考的实现，Boost社区的发起⼈Dawes本⼈就是C++标准委员会的成员之⼀。在Boost库的开发中，Boost社区也在这个⽅向上取得了丰硕的成果，C++11及之后的新语法和库有很多都是从Boost中来的。
C++98中产⽣了第⼀个智能指针auto_ptr。
C++boost给出了更实⽤的scoped_ptr/scoped_array和shared_ptr/shared_array和weak_ptr等
C++TR1，引⼊了shared_ptr等，不过注意的是TR1并不是标准版。
C++11，引⼊了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

unique_ptr自己实现

#include <iostream>

template <typename T>
class MyUniquePtr 
{
private:
    T* ptr;

public:
    // 构造函数
    explicit MyUniquePtr(T* p = nullptr) : ptr(p) {}

    // 析构函数，自动释放资源
    ~MyUniquePtr() 
    {
        delete ptr;
    }

    // 移动构造函数
    MyUniquePtr(MyUniquePtr&& other) noexcept : ptr(other.ptr) 
    {
        other.ptr = nullptr; // 转移所有权
    }

    // 移动赋值运算符
    MyUniquePtr& operator=(MyUniquePtr&& other) noexcept 
    {
        if (this != &other) 
        {
            delete ptr; // 释放当前资源
            ptr = other.ptr;
            other.ptr = nullptr; // 转移所有权
        }
        return *this;
    }

    // 禁用拷贝构造函数和拷贝赋值运算符
    MyUniquePtr(const MyUniquePtr&) = delete;
    MyUniquePtr& operator=(const MyUniquePtr&) = delete;

    // 解引用操作符
    T& operator*() const { return *ptr; }

    // 指针操作符
    T* operator->() const { return ptr; }

    // 获取裸指针
    T* get() const { return ptr; }
};

class MyClass 
{
public:
    void show() 
    {
        std::cout << "MyClass show method\n";
    }
};

int main() 
{
    // 创建 MyUniquePtr，并自动释放资源
    MyUniquePtr<MyClass> ptr1(new MyClass());
    ptr1->show();

    // 使用移动语义
    MyUniquePtr<MyClass> ptr2 = std::move(ptr1);

    // ptr1 现在为空，ptr2 拥有 MyClass 的所有权
    if (!ptr1.get()) 
    {
        std::cout << "ptr1 is null\n";
    }
    ptr2->show();

    return 0;
}

shared_ptr

#include <iostream>

template <typename T>
class MySharedPtr 
{
private:
    T* ptr;
    int* ref_count;

public:
    // 构造函数
    explicit MySharedPtr(T* p = nullptr) : ptr(p), ref_count(new int(1)) {}

    // 析构函数
    ~MySharedPtr() 
    {
        --(*ref_count);
        if (*ref_count == 0) 
        {
            delete ptr;
            delete ref_count;
        }
    }

    // 拷贝构造函数
    MySharedPtr(const MySharedPtr& other) : ptr(other.ptr), ref_count(other.ref_count) 
    {
        ++(*ref_count);
    }

    // 拷贝赋值运算符
    MySharedPtr& operator=(const MySharedPtr& other) 
    {
        if (this != &other) 
        {
            // 先减少当前对象的引用计数
            --(*ref_count);
            if (*ref_count == 0) 
            {
                delete ptr;
                delete ref_count;
            }

            // 赋新值
            ptr = other.ptr;
            ref_count = other.ref_count;
            ++(*ref_count);
        }
        return *this;
    }

    // 解引用操作符
    T& operator*() const { return *ptr; }

    // 指针操作符
    T* operator->() const { return ptr; }

    // 获取裸指针
    T* get() const { return ptr; }

    // 获取引用计数
    int use_count() const { return *ref_count; }
};

class MyClass 
{
public:
    void show() 
    {
        std::cout << "MyClass show method\n";
    }
};

int main() 
{
    // 创建 MySharedPtr，并自动管理引用计数
    MySharedPtr<MyClass> ptr1(new MyClass());
    std::cout << "Reference count: " << ptr1.use_count() << std::endl;

    {
        MySharedPtr<MyClass> ptr2 = ptr1;  // ptr2 共享 ptr1 的所有权
        std::cout << "Reference count: " << ptr1.use_count() << std::endl;
        ptr2->show();
    }

    // ptr2 离开作用域后，ptr1 的引用计数减一
    std::cout << "Reference count after ptr2 goes out of scope: " << ptr1.use_count() << std::endl;

    return 0;
}