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

• 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_ptrstd::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";}// 自动释放内存，无需手动deletereturn 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;  // 引用计数变为2std::cout << "Use count: " << ptr2.use_count() << "\n";  // 输出2}  // 引用计数回到1std::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（资源获取即初始化）机制，它通过封装指针来管理资源（如内存、文件句柄等）的生命周期。智能指针在构造时获取资源，在析构时释放资源，确保在程序结束时自动清理，从而避免了内存泄漏和悬空指针等问题。

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

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

2. 智能指针的内存管理原理
   智能指针通过管理内存的生命周期来避免内存泄漏。它们利用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;
}