# C++ 智能指针和 RAII 掌握 C++ 智能指针和资源获取即初始化 (RAII) 模式，以实现自动、异常安全的资源管理。该技能涵盖 unique_ptr、shared_ptr、weak_ptr、自定义删除器以及现代 C++ 内存管理的最佳实践。 ## RAII 原则资源获取即初始化是一个基本的 C++ 习惯用法，其中资源生命周期与对象生命周期相关。 ### 核心理念 // 不好：手动资源管理无效 process_file_bad() { FILE* 文件 = fopen("data.txt", "r"); if (!file) 返回； // ... 处理文件 ... // 如果发生异常，文件永远不会关闭！ fclose(文件); } // 好：带有智能指针的 RAII 无效 process_file_good() { 自动删除器 = [](FILE* f) { if (f) fclose(f); }; std::unique_ptr file(fopen("data.txt", "r"), 删除器); if (!file) 返回； // ... 处理文件 ... // 当unique_ptr被破坏时文件自动关闭 } // 更好：自定义 RAII 包装器文件句柄类 { 文件* 文件；公众：显式 FileHandle(const char* 文件名, const char* 模式) : 文件(fopen(文件名, 模式)) { if (!file) throw std::runtime_error("无法打开文件"); } 〜文件句柄（）{ 如果（文件）fclose（文件）； } // 删除复制操作 FileHandle(const FileHandle&) = 删除; FileHandle& 运算符=(const FileHandle&) = 删除; // 允许移动操作 FileHandle(FileHandle&& other) noexcept : file(other.file) { 其他.file = nullptr; } FileHandle& 运算符=(FileHandle&& 其他) noexcept { 如果（这个！=＆其他）{ 如果（文件）fclose（文件）；文件=其他.文件；其他.file = nullptr; } 返回*这个； } FILE* get() const { 返回文件; } }; ### RAII 的好处 // 异常安全无效交易（）{ std::lock_guard 锁(互斥体); // RAII 锁 std::unique_ptr 资源 = acquire_resource(); // RAII内存 // 如果抛出异常，则自动释放锁并释放内存有风险的操作（）； } // 自动清理所有路径 std::unique_ptr create_buffer(size_t 大小) { 自动缓冲区 = std::make_unique(size); 如果（大小>最大大小）{ 返回空指针； // 缓冲区已清理 } 初始化(buffer.get(), 大小); 返回缓冲区； // 所有权转移 } ## 唯一指针 `std::unique_ptr` 提供动态分配对象的独占所有权。 ### Unique Ptr 基本用法 #include <内存> // 创建unique_ptr std::unique_ptr ptr1(new int(42)); 自动 ptr2 = std::make_unique(100); // 首选 (C++14) // 数组 unique_ptr std::unique_ptr arr(new int[10]); 自动 arr2 = std::make_unique(10); // 首选 // 自定义类型类我的类{ 公众： MyClass(int x, std::string s) : 值(x), 名称{} void print() const { std::cout << 名称 << ": " << 值 << std::endl; } 私人：整数值； std::字符串名称； }; auto obj = std::make_unique(42, "测试"); 对象->打印(); ### 所有权转让 // Unique_ptr 只能移动，不可复制 std::unique_ptr ptr1 = std::make_unique(42); // std::unique_ptr ptr2 = ptr1; // 错误：复制已删除 // 移动所有权 std::unique_ptr ptr2 = std::move(ptr1); // ptr1 现在为 nullptr，ptr2 拥有该资源 // 接受所有权的函数无效消耗（std :: unique_ptr ptr）{ std::cout << *ptr << std::endl; // ptr在这里被销毁，资源被删除 } 消耗(std::move(ptr2)); // 将所有权转移给函数 // 返回所有权的函数 std::unique_ptr create() { 自动 ptr = std::make_unique(100); 返回指针； // 移动语义，不需要显式的 std::move } 自动结果=创建（）； // 所有权转移给结果 ### 自定义删除器 // 函数指针删除器无效custom_delete（int * ptr）{ std::cout << "删除：" << *ptr << std::endl; 删除指针； } std::unique_ptr ptr(new int(42), custom_delete); // Lambda 删除器自动删除器 = [](int* ptr) { std::cout << "Lambda 删除：" << *ptr << std::endl; 删除指针； }; std::unique_ptr ptr2(new int(100), 删除器); // 带有自定义删除器的 FILE* 自动 file_deleter = [](FILE* f) { 如果（f）{ std::cout << "关闭文件" << std::endl; f关闭(f); } }; std::unique_ptr file( fopen("data.txt", "r"), 文件删除器）； // 带有自定义删除器的套接字 struct SocketDeleter { void 操作符()(int* 套接字) const { 如果（套接字&& *套接字> = 0）{ 关闭（*套接字）；删除套接字； } } }; std::unique_ptr socket(new int(create_socket())); ### 独特的 Ptr 操作 std::unique_ptr ptr = std::make_unique(42); // 访问 int 值 = *ptr; // 解引用 int* raw = ptr.get(); // 获取原始指针（不转移所有权） // 检查是否拥有对象如果（指针）{ std::cout << "拥有资源" << std::endl; } // 释放所有权（返回原始指针，unique_ptr 变为 nullptr） int* 已释放 = ptr.release(); // 必须手动删除释放的指针删除发布； // 重置（删除当前对象，可选择获取新对象的所有权） ptr.reset(); // 删除并变为nullptr ptr.reset(new int(100)); //删除旧的，拥有新的 // 交换 std::unique_ptr ptr1 = std::make_unique(1); std::unique_ptr ptr2 = std::make_unique(2); ptr1.swap(ptr2); // 或 std::swap(ptr1, ptr2); ## 共享指针 `std::shared_ptr` 提供共享所有权和自动引用计数。 ### 共享 Ptr 基本用法 #include <内存> // 创建shared_ptr std::shared_ptr ptr1(new int(42)); 自动 ptr2 = std::make_shared(100); // 首选（更高效） // 共享所有权自动 ptr3 = ptr2; // 引用计数 = 2 自动 ptr4 = ptr2; // 引用计数 = 3 std::cout << "使用计数：" << ptr2.use_count() << std::endl; // 3 // 最后一个shared_ptr被销毁会删除该对象 { 自动 ptr5 = ptr2; // 引用计数 = 4 } // ptr5 被销毁，引用计数 = 3 ### 共享 // 优先使用 make_shared 而不是 new 自动 ptr1 = std::make_shared(arg1, arg2); // 为什么？单一分配而不是两次： // new: 分配对象+单独的控制块 // make_shared：两者的单一分配 // 异常安全 func(std::shared_ptr(new int(1)), std::shared_ptr(new int(2))); // 有风险 func(std::make_shared(1), std::make_shared(2)); // 安全 // 数组支持（C++17 及更高版本可能因实现而异） std::shared_ptr arr(new int[10]); // 注意：make_shared 用于 C++20 中添加的数组 ### 共享 Ptr 操作 std::shared_ptr ptr1 = std::make_shared(42); std::shared_ptr ptr2 = ptr1; // 访问 int 值 = *ptr1; int* raw = ptr1.get(); // 引用计数 std::cout << "计数：" << ptr1.use_count() << std::endl; std::cout << "唯一：" << ptr1.unique() << std::endl; // 如果计数 == 1，则为真 // 检查是否拥有对象如果（ptr1）{ std::cout << "拥有资源" << std::endl; } // 重置 ptr1.reset(); // 减少引用计数，变成 nullptr ptr1.reset(new int(100)); // 减少旧的引用计数，拥有新对象 ptr1 = nullptr； // 与重置（）相同 // 交换 ptr1.swap(ptr2); std::swap(ptr1, ptr2); ### 别名构造函数结构数据{ 整数x；整数y； }; 自动数据 = std::make_shared(); 数据->x = 10；数据->y = 20； // 创建shared_ptr作为成员，但共享整个对象的所有权 std::shared_ptr x_ptr(data, &data->x); std::shared_ptr y_ptr(data, &data->y); // 数据的引用计数为3 // 当data、x_ptr、y_ptr全部销毁时，Data对象被删除 ## 弱指针 `std::weak_ptr` 提供对shared_ptr 管理的对象的非拥有引用。 ### 弱指针基本用法 std::shared_ptr 共享 = std::make_shared(42); std::weak_ptr 弱 = 共享； // 弱引用，不会增加引用计数 std::cout << "共享计数：" << shared.use_count() << std::endl; // 1 std::cout << "弱计数：" < 下一个； ~Node() { std::cout << "节点被破坏" << std::endl; } }; 无效内存_泄漏（）{ 自动节点1 = std::make_shared(); 自动node2 = std::make_shared(); 节点1->下一个=节点2；节点2->下一个=节点1； // 循环引用！ // node1和node2超出范围但对象从未被删除 // 引用计数永远不会达到零 } // 解决方案：使用weak_ptr进行反向引用结构体 NodeFixed { std::shared_ptr 接下来； std::weak_ptr 上一个； // 用weak_ptr中断循环 ~NodeFixed() { std::cout << "NodeFixed 被破坏" << std::endl; } }; 无效 no_leak() { 自动node1 = std::make_shared(); 自动node2 = std::make_shared(); 节点1->下一个=节点2；节点2->上一个=节点1； //weak_ptr 不会增加引用计数 // 当shared_ptr销毁时对象被正确删除 } ### 观察者模式类主题；类观察者{ std::weak_ptr 主题；公众：无效观察（std::shared_ptr <主题> s）{ 主题= s； } 无效检查（）{ if (auto s = subject.lock()) { std::cout << "主题仍然存在" << std::endl; // 安全地使用 s } 否则{ std::cout << "对象被摧毁" << std::endl; } } }; 类主题{ 公众：无效 do_something() { std::cout << "主体在做某事" << std::endl; } }; // 用法自动观察者 = std::make_shared(); { 自动主题 = std::make_shared(); 观察者->观察（主题）；观察者->检查(); // 主题存在 } 观察者->检查(); // 对象被销毁 ### 缓存模式类资源缓存{ std::unordered_map> 缓存；公众： std::shared_ptr get(const std::string& key) { // 尝试从缓存中获取 auto it = cache.find(key); if (it!=cache.end()) { if (auto 资源 = it->second.lock()) { 返回资源； // 缓存命中 } 否则{ 缓存.擦除（它）； // 过期条目 } } // 缓存未命中：加载资源自动资源 = std::make_shared(load_resource(key)); 缓存[键] = 资源； // 存储弱引用返回资源； } 无效清理（）{ // 删除过期条目 for (auto it =cache.begin(); it!=cache.end();) { if (it->second.expired()) { 它 = 缓存.擦除(它); } 否则{ ++它； } } } }; ## 自定义删除器和分配器 ### 高级删除器模式 // 记录删除器模板<类型名称 T> 结构 LoggingDeleter { void 运算符()(T* ptr) const { std::cout << "删除位于 " << ptr << std::endl 的对象；删除指针； } }; std::unique_ptr> ptr(new int(42)); // unique_ptr 的数组删除器模板<类型名称 T> 结构体ArrayDeleter { void 运算符()(T* ptr) const { 删除[] ptr； } }; std::unique_ptr> arr(new int[10]); // 条件删除器模板<类型名称 T> 类条件删除器 { 布尔应该删除；公众：显式 ConditionalDeleter(bool del = true) : should_delete(del) {} void 运算符()(T* ptr) const { 如果（应该删除）{ 删除指针； } } }; // 资源池删除器模板<类型名称 T> 类 PoolDeleter { std::shared_ptr> 池；公众：显式 PoolDeleter(std::shared_ptr> p) : pool(p) {} void 运算符()(T* ptr) const { 池->return_to_pool(ptr); // 返回池而不是删除 } }; ### 自定义分配器 //shared_ptr 的自定义分配器模板<类型名称 T> 类 TrackingAllocator { 公众：使用 value_type = T; TrackingAllocator() = 默认值；模板<类型名称 U> TrackingAllocator(const TrackingAllocator&) {} T* 分配(std::size_t n) { std::cout << "分配 " << n << " 对象" << std::endl; return static_cast(::operator new(n * sizeof(T))); } void deallocate(T* ptr, std::size_t n) { std::cout << "解除分配 " << n << " 对象" << std::endl; ::运算符删除(ptr); } }; // 与shared_ptr一起使用自动 ptr = std::allocate_shared(TrackingAllocator(), 42); ## 智能指针转换 ### 安全转换 // unique_ptr到shared_ptr（所有权转移） std::unique_ptr unique = std::make_unique(42); std::shared_ptr 共享 = std::move(unique); // unique 现在为 nullptr // 从shared_ptr到weak_ptr std::weak_ptr 弱 = 共享； // 从weak_ptr 到shared_ptr（带空检查） if (自动锁定=weak.lock()) { // 使用锁定的shared_ptr } // 指向shared_ptr的原始指针（危险 - 请参阅陷阱） int* 原始 = 新 int(42); // std::shared_ptr 共享(raw); // 危险的！ ### 使用智能指针向下转型基类{ 公众：虚拟 ~Base() = 默认值；虚拟无效 foo() = 0; }; 派生类：公共基类{ 公众： void foo() 覆盖 {} 无效栏（）{} }; // static_pointer_cast (类似 static_cast) std::shared_ptr 基 = std::make_shared(); std::shared_ptr 派生 = std::static_pointer_cast(base); //dynamic_pointer_cast（与dynamic_cast一样，失败时返回nullptr） std::shared_ptr base2 = std::make_shared(); if (自动衍生2 = std::dynamic_pointer_cast<衍生>(base2)) { 派生2->bar(); // 安全调用派生方法 } // const_pointer_cast (类似 const_cast) std::shared_ptr const_ptr = std::make_shared(42); std::shared_ptr mutable_ptr = std::const_pointer_cast(const_ptr); ## 性能考虑因素 ### 内存开销 // 大小比较 sizeof(int*) // 8 字节（64 位） sizeof(std::unique_ptr) // 8 个字节（与原始指针相同） sizeof(std::shared_ptr) // 16字节（指针+控制块ptr） sizeof(std::weak_ptr) // 16字节（与shared_ptr相同） // 控制shared_ptr的块开销 // 包含：引用计数、弱计数、删除器、分配器 // 大小各不相同，但通常为 24-32 字节 // make_shared 与 new 的shared_ptr 自动 ptr1 = std::make_shared(42); // 1 分配 std::shared_ptr ptr2(new int(42)); // 2 次分配 ### 性能优化 // 尽可能首选 unique_ptr std::unique_ptr<资源> create_resource() { 返回 std::make_unique(); } // 仅在需要时才转换为shared_ptr 自动唯一= create_resource(); std::shared_ptr 共享 = std::move(unique); // 避免不必要的shared_ptr副本 void process(const std::shared_ptr& res) { // 通过 const ref 传递 // 使用 res，不会增加引用计数 } // 转移所有权时移动 std::shared_ptr<资源> 传输(std::shared_ptr<资源> res) { 返回资源； // RVO 或移动 } // 对非拥有引用使用weak_ptr 类观察者{ std::weak_ptr 主题； // 不增加引用计数 }; ## 异常安全 ### 强大的例外保证类异常安全{ std::unique_ptr<资源1> res1; std::unique_ptr<资源2> res2; 公众：无效更新（整数值）{ // 创建新资源 auto new_res1 = std::make_unique(value); auto new_res2 = std::make_unique(value); // 如果上面抛出异常，则不进行任何更改（强保证） // 提交更改（noexcept 操作） res1 = std::move(new_res1); res2 = std::move(new_res2); } }; ### 交易 RAII 类交易{ std::unique_ptr conn; 布尔提交=假；公众：显式事务(std::unique_ptr c) : conn(std::move(c)) { conn->begin_transaction(); } 〜交易（）{ 如果（！提交）{ 尝试{ conn->回滚(); } 抓住 (...) { // 记录错误，不要从析构函数中抛出 } } } 无效提交（）{ conn->commit(); 承诺=真； } }; // 用法无效执行事务（）{ 自动 conn = std::make_unique(); 交易 txn(std::move(conn)); // 做工作 // 如果抛出异常，事务自动回滚 txn.commit(); // 成功时显式提交 } ## 容器中的智能指针 ### 智能指针向量 // unique_ptr 的向量 std::vector> 小部件； // 添加元素（必须移动） widgets.push_back(std::make_unique(1)); widgets.push_back(std::make_unique(2)); // 无法复制向量 // 自动 vec2 = 小部件; // 错误 // 可以移动向量 auto vec2 = std::move(小部件); // 小部件现在为空 // 迭代 for (const auto& widget : vec2) { 小部件->process(); } // 删除元素（自动删除） vec2.erase(vec2.begin()); //shared_ptr 向量 std::vector>shared_widgets; Shared_widgets.push_back(std::make_shared(1)); // 可以复制向量（增加引用计数）自动shared_vec2=shared_widgets； ### 带有智能指针的地图 // 具有 unique_ptr 值的映射 std::map> resources_map; // 插入 resource_map["key1"] = std::make_unique<资源>(1); resource_map.emplace("key2", std::make_unique(2)); // 查找并使用 auto it = resource_map.find("key1"); if (it!=resource_map.end()) { 它->第二个->process(); } // 提取所有权自动提取= std::move(resource_map["key1"]); resource_map.erase("key1"); // 映射到共享所有权的shared_ptr std::map>shared_map; Shared_map["key"] = std::make_shared<资源>(1); // 多个map可以共享同一个资源 std::map>shared_map2; 共享地图2["密钥"] = 共享地图["密钥"]; // 股份所有权 ## 常见模式 ### 工厂模式产品类{ 公众：虚拟 ~Product() = 默认值；虚拟无效 use() = 0; }; 类 ConcreteProductA ：公共产品 { 公众： void use() override { std::cout << "使用 A" << std::endl; } }; 类 ConcreteProductB ：公共产品 { 公众： void use() override { std::cout << "使用 B" << std::endl; } }; 类工厂{ 公众：静态 std::unique_ptr create(const std::string& type) { 如果（类型==“A”）{ 返回 std::make_unique(); } else if (type == "B") { 返回 std::make_unique(); } 返回空指针； } }; // 用法汽车产品 = Factory::create("A"); 如果（产品）{ 产品->使用(); } ### 粉刺成语 // 小部件.h 类小部件{ 公众：小部件（）；〜小部件（）； // 必须声明但不能在标头中定义小部件(小部件&&) noexcept; Widget& 运算符=(Widget&&) noexcept; 无效 do_something(); 私人：类实现； // 前向声明 std::unique_ptr pimpl; }; // 小部件.cpp 类 Widget::Impl { 公众：无效 do_something_impl() { // 隐藏实现细节 } 私人： // 私有成员不在公共头中 std::vector 数据； std::字符串名称； }; Widget::Widget() : pimpl(std::make_unique()) {} // Impl完成后在.cpp中定义析构函数小部件::~小部件() = 默认值； Widget::Widget(Widget&&) noexcept = 默认； Widget& Widget::operator=(Widget&&) noexcept = 默认值； void Widget::do_something() { pimpl->do_something_impl(); } ### 单例模式类单例{ 公众：静态单例&实例() { 静态单例实例； // C++11 中的线程安全返回实例； } // 删除复制并移动 Singleton(const Singleton&) = 删除; Singleton& 运算符=(const Singleton&) = 删除; 单例（单例&&）=删除； Singleton& 运算符=(Singleton&&) = 删除；无效 do_something() { std::cout << "单例方法" << std::endl; } 私人：单例（）=默认； ~Singleton() = 默认值； }; // 替代方案：用于显式控制的智能指针类 ManagedSingleton { 公众：静态 std::shared_ptr 实例() { 静态自动安装 = std::make_shared(PrivateTag{}); 返回实例； } 私人：结构私有标签{}；公众：显式 ManagedSingleton(PrivateTag) {} }; ## 最佳实践 1. **首选 make_unique 和 make_shared** ：比直接使用 new 更高效且异常安全 2. **默认使用 unique_ptr** ：仅当您确实需要共享所有权时才使用shared_ptr 3. **通过const引用传递智能指针**：避免使用shared_ptr进行不必要的引用计数更改 4. **使用weak_ptr打破循环**：防止循环shared_ptr引用造成内存泄漏 5. **所有权转移按值返回**：让移动语义处理高效转移 6. **永远不要从同一个原始指针创建多个shared_ptr**：导致双重删除 7. **非内存资源的自定义删除器**：用于文件、套接字、互斥体等。 8. **将移动操作标记为 noexcept** ：在标准容器中启用优化 9. **在容器中使用智能指针**：允许多态对象的容器 10. **不要将智能指针与原始指针所有权混合在一起**：选择一种所有权模型 ## 常见陷阱 1. **从原始this指针创建shared_ptr**：使用enable_shared_from_this代替 2. **循环shared_ptr引用**：使用weak_ptr作为反向引用或父指针 3. **从同一个原始指针创建多个shared_ptr**：导致双重删除 4. **使用 get() 创建新的智能指针**：打破所有权模型 5. **忘记将 move 与 unique_ptr 一起使用**：unique_ptr 不可复制 6. **将智能指针与手动删除混合**：始终使用一种所有权模型 7. **当unique_ptr足够时使用shared_ptr**：不必要的开销 8. **不检查weak_ptr.lock()返回值**：如果对象被删除，可能返回nullptr 9. **自定义删除器问题**：删除器类型错误或未处理 nullptr 10. **使用智能指针切片**：存储基类指针以保留多态性 ## 何时使用在以下情况下使用此技能： * 在C++中管理动态分配的内存 * 实施 RAII 模式进行资源管理 * 使用容器中的多态对象 * 防止内存泄漏和悬空指针 * 实现异常安全代码 * 创建工厂模式或对象层次结构 * 通过引用计数管理共享资源 * 打破弱引用的循环依赖 * 通过自动清理来包装 C API * 教授或学习现代 C++ 内存管理 ## 资源 * [C++ 参考 - unique_ptr]() * [C++ 参考 - shared_ptr]() * [C++ 参考 -weak_ptr]() * [C++ 参考 - make_unique]() * [C++ 参考 - make_shared]() * [C++ 参考 - enable_shared_from_this]() * [GotW #91：智能指针参数]() * [Scott Meyers 的《有效现代 C++》]() * [CppCoreGuidelines - 资源管理]()

Cpp 智能指针

包含技能