C++智能指针在类成员中使用方法

使用智能指针作为类成员可实现自动内存管理，避免内存泄漏和悬空指针。通过RAII原则，智能指针在对象构造时获取资源，在析构时自动释放，无需手动delete。std::unique_ptr适用于独占所有权场景，开销小且安全；std::shared_ptr用于共享所有权，但需警惕循环引用问题，可用std::weak_ptr打破循环。推荐在构造函数初始化列表中使用std::make_unique和std::make_shared进行初始化，以保证异常安全和性能优化。避免将原始指针与智能指针混用，防止双重释放。智能指针的选择应遵循“优先unique_ptr，必要时再用shared_ptr”的原则，同时注意传递方式：const shared_ptr<T>&用于观察，值传递用于共享，unique_ptr<T>&&用于转移所有权。正确使用智能指针能显著提升代码安全性与可维护性。

在C++中，将智能指针作为类成员是一种非常推荐的做法，它能有效解决传统原始指针带来的内存管理难题，例如内存泄漏、悬空指针等。通过这种方式，我们可以利用RAII（Resource Acquisition Is Initialization）原则，让资源的生命周期与对象的生命周期绑定，从而实现自动化的内存管理，极大地简化了代码并提高了程序的健壮性。

解决方案

将智能指针（如

std::unique_ptr

登录后复制

或

std::shared_ptr

登录后复制

）声明为类的成员变量，是实现自动内存管理的核心策略。这样做，当包含智能指针的类对象被销毁时，智能指针会自动释放其所管理的资源，无需手动在析构函数中调用

delete

登录后复制

。这不仅避免了忘记释放内存的常见错误，也使得代码更简洁、更安全。

举个例子，假设我们有一个

Resource

登录后复制

类，我们希望

MyClass

登录后复制

拥有一个

Resource

登录后复制

实例：

#include <iostream> #include <memory> // 包含智能指针头文件  // 假设有一个资源类 class Resource { public:     int value;     Resource(int v) : value(v) {         std::cout << "Resource " << value << " created." << std::endl;     }     ~Resource() {         std::cout << "Resource " << value << " destroyed." << std::endl;     }     void doSomething() {         std::cout << "Resource " << value << " is doing something." << std::endl;     } };  class MyClass { public:     // 使用 std::unique_ptr 作为成员变量，表示独占所有权     std::unique_ptr<Resource> uniqueRes;      // 使用 std::shared_ptr 作为成员变量，表示共享所有权     std::shared_ptr<Resource> sharedRes;      // 构造函数中初始化智能指针     // 推荐使用 std::make_unique 和 std::make_shared     MyClass(int uniqueVal, int sharedVal)         : uniqueRes(std::make_unique<Resource>(uniqueVal)),           sharedRes(std::make_shared<Resource>(sharedVal)) {         std::cout << "MyClass object created." << std::endl;     }      // 也可以在运行时赋值或重新分配     void replaceUniqueResource(int newVal) {         uniqueRes = std::make_unique<Resource>(newVal); // 旧的uniqueRes会自动销毁     }      void showResources() {         if (uniqueRes) {             uniqueRes->doSomething();         }         if (sharedRes) {             sharedRes->doSomething();         }     }      ~MyClass() {         std::cout << "MyClass object destroyed." << std::endl;     } };  int main() {     { // 局部作用域，MyClass对象在此处创建和销毁         MyClass obj(10, 20);         obj.showResources();         obj.replaceUniqueResource(30); // 替换uniqueRes，旧的10会被销毁         obj.showResources();          // 也可以创建另一个共享指针来引用同一个资源         std::shared_ptr<Resource> anotherShared = obj.sharedRes;         std::cout << "Shared resource use count: " << obj.sharedRes.use_count() << std::endl;     } // obj在这里销毁，uniqueRes和sharedRes也会自动销毁其管理的资源     std::cout << "End of main." << std::endl;     return 0; }

登录后复制

这段代码清晰地展示了智能指针作为类成员的用法。

MyClass

登录后复制

的构造函数利用成员初始化列表来创建

Resource

登录后复制

对象，并将其所有权交给

uniqueRes

登录后复制

和

sharedRes

登录后复制

。当

MyClass

登录后复制

对象

obj

登录后复制

超出作用域时，其析构函数被调用，接着

uniqueRes

登录后复制

和

sharedRes

登录后复制

的析构函数也会被调用，从而自动、安全地释放它们所管理的

Resource

登录后复制

对象。

立即学习“C++免费学习笔记（深入）”；

为什么在类成员中使用智能指针比原始指针更优？

说实话，我个人觉得，在C++里处理资源（特别是堆内存）的生命周期，一直是个挺让人头疼的问题。你得记得

new

登录后复制

了就得

delete

登录后复制

，还得考虑异常安全，复制构造函数、赋值运算符、析构函数（所谓的大三/大五法则）都得手动去写，一不小心就内存泄漏或者双重释放。这玩意儿，真不是一般人能完全不出错的。

智能指针的出现，在我看来，就是为了解决这些“人祸”。当我们将智能指针作为类成员时，它的优势简直是压倒性的：

自动化内存管理 (RAII)：这是最核心的优点。智能指针遵循RAII原则，它在构造时获取资源（例如通过
```
new
```
登录后复制
分配内存），在析构时自动释放资源。这意味着你不再需要在类的析构函数里手动写
```
delete
```
登录后复制
。当包含智能指针的类对象被销毁时，智能指针自己会搞定它管理的内存，这大大降低了内存泄漏的风险。
异常安全：如果构造函数或某个方法在中间抛出异常，原始指针可能导致资源无法释放。但智能指针作为局部变量或成员变量，即使发生异常，它的析构函数也会被调用，从而确保资源被正确释放。这让我们的代码在面对不可预知的错误时更加健壮。
清晰的所有权语义：
```
std::unique_ptr
```
登录后复制
明确表示独占所有权，一个资源只能被一个
```
unique_ptr
```
登录后复制
管理。这非常适合那些“我的就是我的，别人不能抢”的资源。而
```
std::shared_ptr
```
登录后复制
则表示共享所有权，多个
```
shared_ptr
```
登录后复制
可以共同管理一个资源，直到最后一个
```
shared_ptr
```
登录后复制
被销毁时，资源才会被释放。这种清晰的语义让代码的意图一目了然，避免了“谁来释放这块内存？”的疑惑。
减少样板代码：有了智能指针，你通常就不需要自己去实现复制构造函数、赋值运算符和析构函数了（除非你的类有其他非内存资源需要管理）。编译器生成的默认版本对于智能指针成员通常是正确的（
```
unique_ptr
```
登录后复制
是移动语义，
```
shared_ptr
```
登录后复制
是复制语义），这简直是解放了生产力。
避免悬空指针和双重释放：原始指针很容易出现这些问题。一个指针
```
delete
```
登录后复制
之后，如果还有其他指针指向那块内存，它们就成了悬空指针。或者，如果对同一块内存
```
delete
```
登录后复制
了两次，就会导致未定义行为。智能指针通过内部的引用计数（
```
shared_ptr
```
登录后复制
）或独占机制（
```
unique_ptr
```
登录后复制
）有效地规避了这些问题。

总的来说，使用智能指针作为类成员，不仅让我们的代码更安全、更易维护，也让开发者能更专注于业务逻辑，而不是疲于应对底层内存管理的细节。

std::unique_ptr

登录后复制

和

std::shared_ptr

登录后复制

作为类成员时如何选择和初始化？

这确实是很多初学者会纠结的问题，毕竟这俩哥们儿看着都能管内存，但骨子里差别挺大。选择哪个，很大程度上取决于你的类对它所管理的资源是“独占”还是“共享”的关系。

选择策略：

std::unique_ptr

登录后复制

：独占所有权，首选
- 何时选择：当你的类是资源的唯一所有者时，毫不犹豫地选择
```
unique_ptr
```
  登录后复制
  。这意味着这个资源只属于这个类的实例，当这个类的实例被销毁时，资源也跟着被销毁。比如，一个
```
Car
```
  登录后复制
  类拥有一个
```
Engine
```
  登录后复制
  对象，那么
```
Engine
```
  登录后复制
  通常就应该由
```
Car
```
  登录后复制
  独占。
- 特点：
```
unique_ptr
```
  登录后复制
  不能被复制，只能被移动。这意味着资源的所有权可以从一个
```
unique_ptr
```
  登录后复制
  转移到另一个，但不能同时被多个
```
unique_ptr
```
  登录后复制
  拥有。它的开销非常小，几乎和原始指针一样高效，因为它不需要维护引用计数。
- 思考场景：如果你不确定该用哪个，那就先考虑
```
unique_ptr
```
  登录后复制
  。只有当你明确需要多个对象共享同一个资源的生命周期时，才考虑
```
shared_ptr
```
  登录后复制
  。
std::shared_ptr

登录后复制

：共享所有权，次选
- 何时选择：当多个类的实例需要共同拥有同一个资源，并且这个资源的生命周期应该持续到所有拥有它的对象都销毁时，
```
shared_ptr
```
  登录后复制
  就派上用场了。比如，多个
```
User
```
  登录后复制
  对象可能共享一个
```
DatabaseConnection
```
  登录后复制
  实例。
- 特点：
```
shared_ptr
```
  登录后复制
  可以被复制，每个复制品都指向同一个资源，并且内部会维护一个引用计数。当引用计数降为零时，资源才会被释放。
- 潜在开销：
```
shared_ptr
```
  登录后复制
  的开销比
```
unique_ptr
```
  登录后复制
  大，因为它需要额外的内存来存储引用计数和自定义删除器等信息（通常称为控制块），并且在复制和销毁时涉及到原子操作，这会带来一些性能损耗。

初始化方法：

无论选择哪种智能指针，初始化都应该尽可能在成员初始化列表中完成，并强烈推荐使用

std::make_unique

登录后复制

和

std::make_shared

登录后复制

。

使用

std::unique_ptr

登录后复制

初始化：

Gnomic智能体平台

国内首家无需魔法免费无限制使用的ChatGPT4.0，网站内设置了大量智能体供大家免费使用，还有五款语言大模型供大家免费使用~

查看详情

class MyClassWithUnique { private:     std::unique_ptr<Resource> myResource; public:     // 推荐：使用 std::make_unique 在初始化列表中创建对象     MyClassWithUnique(int val) : myResource(std::make_unique<Resource>(val)) {         // ...     }      // 如果资源可能为空，或者在构造后才决定创建     MyClassWithUnique() : myResource(nullptr) { // 显式初始化为nullptr         // 之后再创建         // myResource = std::make_unique<Resource>(some_value);     }      // 接受一个已存在的 unique_ptr (所有权转移)     MyClassWithUnique(std::unique_ptr<Resource> res) : myResource(std::move(res)) {         // ...     } };

登录后复制

std::make_unique

登录后复制

的好处是它在一个内存分配中完成

Resource

登录后复制

对象和

unique_ptr

登录后复制

的创建，避免了两次内存分配，并且提供了异常安全。

使用

std::shared_ptr

登录后复制

初始化：

class MyClassWithShared { private:     std::shared_ptr<Resource> mySharedResource; public:     // 推荐：使用 std::make_shared 在初始化列表中创建对象     MyClassWithShared(int val) : mySharedResource(std::make_shared<Resource>(val)) {         // ...     }      // 接受一个已存在的 shared_ptr (共享所有权)     MyClassWithShared(std::shared_ptr<Resource> res) : mySharedResource(res) {         // ...     }      // 如果资源可能为空，或者在构造后才决定创建     MyClassWithShared() : mySharedResource(nullptr) { // 显式初始化为nullptr         // 之后再创建         // mySharedResource = std::make_shared<Resource>(some_value);     } };

登录后复制

std::make_shared

登录后复制

与

std::make_unique

登录后复制

类似，也是在一个内存分配中完成资源对象和控制块的创建，效率更高，也更安全。

在选择和初始化时，核心原则是：先考虑独占，再考虑共享；优先使用

make_unique

登录后复制

make_shared

登录后复制

；总是在初始化列表中完成智能指针的初始化。

使用智能指针作为类成员时需要注意哪些常见陷阱和最佳实践？

虽然智能指针极大地简化了内存管理，但它也不是万能药，使用不当同样会引入问题。这里我总结了一些常见的陷阱和一些我个人觉得很实用的最佳实践。

常见陷阱：

std::shared_ptr

登录后复制

的循环引用 (Circular References)：这大概是

shared_ptr

登录后复制

最臭名昭著的陷阱了。当两个或多个

shared_ptr

登录后复制

互相引用对方时，它们的引用计数永远不会降到零，导致它们管理的资源永远不会被释放，这实际上就是内存泄漏。

class B; // 前向声明 class A { public:     std::shared_ptr<B> b_ptr;     ~A() { std::cout << "A destroyed." << std::endl; } }; class B { public:     std::shared_ptr<A> a_ptr;     ~B() { std::cout << "B destroyed." << std::endl; } };  // 在某个函数中创建循环引用 // std::shared_ptr<A> pa = std::make_shared<A>(); // std::shared_ptr<B> pb = std::make_shared<B>(); // pa->b_ptr = pb; // pb->a_ptr = pa; // 此时 pa 和 pb 的引用计数都为 2，它们永远不会被销毁

登录后复制

解决方案：使用

std::weak_ptr

登录后复制

来打破循环引用。

weak_ptr

登录后复制

是一种不拥有资源的智能指针，它只是对

shared_ptr

登录后复制

管理资源的一个“观察者”。它不增加引用计数，因此不会阻止资源被释放。当需要访问资源时，可以尝试将其提升为

shared_ptr

登录后复制

。

class B; class A { public:     std::shared_ptr<B> b_ptr;     ~A() { std::cout << "A destroyed." << std::endl; } }; class B { public:     std::weak_ptr<A> a_ptr; // 使用 weak_ptr     ~B() { std::cout << "B destroyed." << std::endl; } }; // 这样，当 pa 和 pb 离开作用域时，它们的引用计数会降到 0，资源就能正常释放了。

登录后复制

智能指针与原始指针的混用：当你从智能指针中取出原始指针（例如通过
```
get()
```
登录后复制
方法），然后又尝试用这个原始指针来创建一个新的智能指针，或者手动
```
delete
```
登录后复制
它，这几乎肯定会出问题。
- 问题：
```
std::unique_ptr
```
  登录后复制
  或
```
std::shared_ptr
```
  登录后复制
  会认为它是资源的唯一管理者。如果你把它的原始指针传给另一个智能指针，就会导致同一个资源被两个智能指针管理，最终导致双重释放。如果你手动
```
delete
```
  登录后复制
  了从智能指针
```
get()
```
  登录后复制
  出来的原始指针，那么当智能指针自己析构时，它会再次尝试
```
delete
```
  登录后复制
  一块已经被释放的内存，这是未定义行为。
- 最佳实践：除非万不得已（比如调用一些只接受原始指针的C风格API），尽量避免从智能指针中取出原始指针。如果确实需要，要非常清楚原始指针的生命周期，绝不能用它来创建新的智能指针，也不能手动
```
delete
```
  登录后复制
  它。
不正确的

std::shared_ptr

登录后复制

构造：直接用原始指针构造多个
```
shared_ptr
```
登录后复制
。
```
Resource* res = new Resource(100); std::shared_ptr<Resource> s_ptr1(res); std::shared_ptr<Resource> s_ptr2(res); // 错误！双重释放
```
登录后复制
最佳实践：始终使用
```
std::make_shared
```
登录后复制
来创建
```
shared_ptr
```
登录后复制
，或者在只有一个原始指针的情况下，只用它构造一个
```
shared_ptr
```
登录后复制
。其他
```
shared_ptr
```
登录后复制
应该通过复制这个已有的
```
shared_ptr
```
登录后复制
来获得。

最佳实践：

优先使用

std::unique_ptr

登录后复制

：如果你的类对资源拥有独占所有权，那么
```
unique_ptr
```
登录后复制
是首选。它开销小，语义清晰，并且能够通过
```
std::move
```
登录后复制
转移所有权。只有当你明确需要共享所有权时，才考虑
```
shared_ptr
```
登录后复制
。
使用

std::make_unique

登录后复制

和

std::make_shared

登录后复制

：这不仅仅是语法上的偏好，更是为了异常安全和效率。它们能确保在一次内存分配中完成对象和智能指针控制块的创建，避免了潜在的内存泄漏（例如，在
```
new T()
```
登录后复制
和
```
std::shared_ptr<T>(...)
```
登录后复制
之间发生异常）和两次内存分配的开销。
在构造函数初始化列表中初始化智能指针：这是C++的最佳实践，能确保成员在对象构造前被正确初始化，避免了在构造函数体内部赋值可能带来的额外开销和潜在问题。
智能指针作为函数参数传递：
- 按
  
  const std::shared_ptr<T>&
  
  登录后复制
  
  传递：如果你只是想观察或使用资源，但不改变其所有权，这是最安全、最有效的方式。
- 按
  
  std::shared_ptr<T>
  
  登录后复制
  
  值传递：如果你需要共享所有权，并且希望函数内部能延长资源的生命周期，或者需要将其存储起来，可以按值传递。这会增加引用计数。
- 按
  
  std::unique_ptr<T>
  
  登录后复制
  
  右值引用传递 (即
  
  std::unique_ptr<T>&&
  
  登录后复制
  
  )：如果你想转移资源的所有权给函数，这是正确的做法。函数内部会
```
std::move
```
  登录后复制
  这个
```
unique_ptr
```
  登录后复制
  。
- 按原始指针或引用传递：如果函数只是临时访问资源，且不涉及所有权管理，可以传递原始指针或引用。但要确保资源在函数调用期间是有效的。这避免了智能指针的额外开销。
避免

get()

登录后复制

的滥用：
```
get()
```
登录后复制
方法返回智能指针管理的原始指针。除非与C API或其他只接受原始指针的代码交互，否则尽量避免使用它。一旦你有了原始指针，你就失去了智能指针提供的所有安全保障。
自定义删除器 (Custom Deleters)：智能指针不仅可以管理堆内存，还可以管理其他类型的资源（如文件句柄、网络连接等）。你可以为
```
unique_ptr
```
登录后复制
和
```
shared_ptr
```
登录后复制
提供自定义删除器，告诉它们如何释放这些非内存资源。这使得智能指针成为一个通用的资源管理工具。