使用智能指针作为类成员可实现自动内存管理，避免内存泄漏和悬空指针。通过RAII原则，智能指针在对象构造时获取资源，在析构时自动释放，无需手动delete。std::unique_ptr适用于独占所有权场景，开销小且安全；std::shared_ptr用于共享所有权，但需警惕循环引用问题，可用std::weak_ptr打破循环。推荐在构造函数初始化列表中使用std::make_unique和std::make_shared进行初始化，以保证异常安全和性能优化。避免将原始指针与智能指针混用，防止双重释放。智能指针的选择应遵循“优先unique_ptr，必要时再用shared_ptr”的原则，同时注意传递方式：const shared_ptr&用于观察，值传递用于共享，unique_ptr&&用于转移所有权。正确使用智能指针能显著提升代码安全性与可维护性。
在C++中，将智能指针作为类成员是一种非常推荐的做法，它能有效解决传统原始指针带来的内存管理难题，例如内存泄漏、悬空指针等。通过这种方式，我们可以利用RAII（Resource Acquisition Is Initialization）原则，让资源的生命周期与对象的生命周期绑定，从而实现自动化的内存管理，极大地简化了代码并提高了程序的健壮性。
解决方案
将智能指针（如
std::unique_ptr
或
std::shared_ptr
）声明为类的成员变量，是实现自动内存管理的核心策略。这样做，当包含智能指针的类对象被销毁时，智能指针会自动释放其所管理的资源，无需手动在析构函数中调用
delete
。这不仅避免了忘记释放内存的常见错误，也使得代码更简洁、更安全。
举个例子，假设我们有一个
Resource
类，我们希望
MyClass
拥有一个
Resource
实例：
#include #include // 包含智能指针头文件// 假设有一个资源类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 uniqueRes; // 使用 std::shared_ptr 作为成员变量，表示共享所有权 std::shared_ptr sharedRes; // 构造函数中初始化智能指针 // 推荐使用 std::make_unique 和 std::make_shared MyClass(int uniqueVal, int sharedVal) : uniqueRes(std::make_unique(uniqueVal)), sharedRes(std::make_shared(sharedVal)) { std::cout << "MyClass object created." << std::endl; } // 也可以在运行时赋值或重新分配 void replaceUniqueResource(int newVal) { uniqueRes = std::make_unique(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 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::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
初始化：
class MyClassWithUnique {private: std::unique_ptr myResource;public: // 推荐：使用 std::make_unique 在初始化列表中创建对象 MyClassWithUnique(int val) : myResource(std::make_unique(val)) { // ... } // 如果资源可能为空，或者在构造后才决定创建 MyClassWithUnique() : myResource(nullptr) { // 显式初始化为nullptr // 之后再创建 // myResource = std::make_unique(some_value); } // 接受一个已存在的 unique_ptr (所有权转移) MyClassWithUnique(std::unique_ptr res) : myResource(std::move(res)) { // ... }};
std::make_unique
的好处是它在一个内存分配中完成
Resource
对象和
unique_ptr
的创建，避免了两次内存分配，并且提供了异常安全。
使用
std::shared_ptr
初始化：
class MyClassWithShared {private: std::shared_ptr mySharedResource;public: // 推荐：使用 std::make_shared 在初始化列表中创建对象 MyClassWithShared(int val) : mySharedResource(std::make_shared(val)) { // ... } // 接受一个已存在的 shared_ptr (共享所有权) MyClassWithShared(std::shared_ptr res) : mySharedResource(res) { // ... } // 如果资源可能为空，或者在构造后才决定创建 MyClassWithShared() : mySharedResource(nullptr) { // 显式初始化为nullptr // 之后再创建 // mySharedResource = std::make_shared(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_ptr; ~A() { std::cout << "A destroyed." << std::endl; }};class B {public: std::shared_ptr a_ptr; ~B() { std::cout << "B destroyed." << std::endl; }};// 在某个函数中创建循环引用// std::shared_ptr pa = std::make_shared();// std::shared_ptr pb = std::make_shared();// 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_ptr; ~A() { std::cout << "A destroyed." << std::endl; }};class B {public: std::weak_ptr 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 s_ptr1(res);std::shared_ptr 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(...)
之间发生异常）和两次内存分配的开销。在构造函数初始化列表中初始化智能指针：这是C++的最佳实践，能确保成员在对象构造前被正确初始化，避免了在构造函数体内部赋值可能带来的额外开销和潜在问题。智能指针作为函数参数传递：按
const std::shared_ptr&
传递：如果你只是想观察或使用资源，但不改变其所有权，这是最安全、最有效的方式。按
std::shared_ptr
值传递：如果你需要共享所有权，并且希望函数内部能延长资源的生命周期，或者需要将其存储起来，可以按值传递。这会增加引用计数。按
std::unique_ptr
右值引用传递 (即
std::unique_ptr&&
)：如果你想转移资源的所有权给函数，这是正确的做法。函数内部会
std::move
这个
unique_ptr
。按原始指针或引用传递：如果函数只是临时访问资源，且不涉及所有权管理，可以传递原始指针或引用。但要确保资源在函数调用期间是有效的。这避免了智能指针的额外开销。避免
get()
的滥用：
get()
方法返回智能指针管理的原始指针。除非与C API或其他只接受原始指针的代码交互，否则尽量避免使用它。一旦你有了原始指针，你就失去了智能指针提供的所有安全保障。自定义删除器 (Custom Deleters)：智能指针不仅可以管理堆内存，还可以管理其他类型的资源（如文件句柄、网络连接等）。你可以为
unique_ptr
和
shared_ptr
提供自定义删除器，告诉它们如何释放这些非内存资源。这使得智能指针成为一个通用的资源管理工具。
通过遵循这些实践并警惕常见陷阱，智能指针将成为你C++编程中一个极其强大且可靠的伙伴，让你的代码更加健壮和易于维护。
以上就是C++智能指针在类成员中使用方法的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1474948.html
微信扫一扫 
支付宝扫一扫 
