文章目录
- 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_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（资源获取即初始化）机制，它通过封装指针来管理资源（如内存、文件句柄等）的生命周期。智能指针在构造时获取资源，在析构时释放资源，确保在程序结束时自动清理，从而避免了内存泄漏和悬空指针等问题。
- 智能指针的基本原理
智能指针是封装了裸指针的类，它管理着指向对象的生命周期。当智能指针超出作用域时，它会自动释放资源，防止忘记手动删除内存等问题。智能指针的实现通常依赖于以下几个核心概念：
- 构造函数：在创建智能指针时，智能指针会初始化并持有一个裸指针，指向一个动态分配的资源。
- 析构函数：当智能指针超出作用域时，析构函数会自动调用，释放资源（例如：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;
}