C++引用计数通过std::shared_ptr实现，利用控制块管理强/弱引用计数，确保对象在无所有者时自动释放；其核心机制为原子操作增减计数，避免内存泄漏，但需警惕循环引用问题。
C++的引用计数机制，在我看来，是现代C++内存管理中一个非常核心且优雅的解决方案，它允许对象在被多个地方共享时，能够自动地管理其生命周期。简单来说，就是通过追踪有多少个“所有者”指向一个对象，当这个计数归零时，对象就会被自动销毁。这大大减轻了手动管理内存的负担，也降低了内存泄漏和悬空指针的风险。
引用计数的核心原理其实并不复杂，它为每个被管理的对象维护一个引用计数器。
当一个智能指针（比如
std::shared_ptr
）“指向”或“拥有”一个堆上的对象时，这个对象的引用计数就会增加。你可以把它想象成，每多一个地方对这个对象感兴趣，计数器就加一。反之，当一个智能指针不再指向这个对象，或者它自己被销毁（例如，超出作用域），那么引用计数就会减少。当这个引用计数最终减少到零时，就意味着没有任何地方再关心这个对象了，此时，该对象所占用的内存就会被自动释放。这种模式巧妙地解决了多所有权场景下的内存管理难题，避免了传统裸指针可能带来的“谁来删除”的困境。
std::shared_ptr
std::shared_ptr
是如何实现引用计数的，其内部机制是怎样的？
当我们谈到C++中的引用计数，
std::shared_ptr
无疑是其最典型的代表。它实现引用计数的方式远比我们想象的要精妙，并非简单地在对象内部加一个计数器。实际上，
std::shared_ptr
通常采用一个独立的“控制块”（control block）来管理这些元数据。
这个控制块通常包含以下几个关键部分：
立即学习“C++免费学习笔记（深入）”；
强引用计数（Strong Reference Count）：这就是我们通常说的引用计数，记录有多少个
std::shared_ptr
实例正在共享这个对象。当它归零时，被管理的对象会被删除。弱引用计数（Weak Reference Count）：记录有多少个
std::weak_ptr
实例正在观察这个对象。
std::weak_ptr
不会增加强引用计数，因此它不会阻止对象被删除。当强引用计数归零后，即使弱引用计数不为零，对象也会被销毁。只有当弱引用计数也归零时，控制块本身才会被销毁。原始指针（Raw Pointer）：指向被管理对象的实际内存地址。自定义删除器（Custom Deleter）：如果用户提供了自定义的删除函数（例如，为了处理C风格的资源释放），它也会存储在这里。自定义分配器（Custom Allocator）：如果使用了自定义的内存分配器，相关信息也会在这里。
每次你创建一个
std::shared_ptr
或者拷贝一个已有的
std::shared_ptr
，强引用计数就会原子性地增加。当
std::shared_ptr
离开作用域或者被重新赋值时，强引用计数就会原子性地减少。正是这种原子操作保证了在多线程环境下引用计数的正确性。例如：
#include #include class MyObject {public: MyObject() { std::cout << "MyObject constructed!" << std::endl; } ~MyObject() { std::cout << "MyObject destructed!" << std::endl; } void doSomething() { std::cout << "Doing something..." << std::endl; }};int main() { std::shared_ptr ptr1 = std::make_shared(); // 强引用计数 = 1 std::cout << "ptr1 ref count: " << ptr1.use_count() << std::endl; { std::shared_ptr ptr2 = ptr1; // 强引用计数 = 2 std::cout << "ptr2 ref count: " << ptr2.use_count() <doSomething(); } // ptr2超出作用域，强引用计数 = 1 std::cout << "ptr1 ref count after ptr2 scope: " << ptr1.use_count() << std::endl; // ptr1 也超出作用域，强引用计数 = 0，MyObject 被析构 return 0;}
这里值得一提的是
std::make_shared
。它比直接使用
new
和
std::shared_ptr
构造函数更高效，因为它可以在一次内存分配中同时为对象和控制块分配内存，减少了两次独立的堆分配，从而提升了性能和缓存局部性。
引用计数机制在实际开发中会遇到哪些常见问题，如何有效避免？
引用计数虽然强大，但它并非银弹，在实际开发中确实会遇到一些挑战，其中最臭名昭著的莫过于“循环引用”（Circular Reference）。
1. 循环引用 (Circular Reference)
这是引用计数最常见的陷阱。当两个或多个对象通过
std::shared_ptr
相互持有对方的引用时，就会形成一个闭环。例如：
#include #include class B; // 前向声明class A {public: std::shared_ptr b_ptr; A() { std::cout << "A constructed!" << std::endl; } ~A() { std::cout << "A destructed!" << std::endl; }};class B {public: std::shared_ptr a_ptr; B() { std::cout << "B constructed!" << std::endl; } ~B() { std::cout << "B destructed!" << std::endl; }};void create_circular_reference() { std::shared_ptr a = std::make_shared(); std::shared_ptr b = std::make_shared(); a->b_ptr = b; // A持有B的shared_ptr b->a_ptr = a; // B持有A的shared_ptr // 此时，a和b的强引用计数都为2。 // 当create_circular_reference函数结束时，a和b的shared_ptr局部变量被销毁， // 它们的强引用计数都变为1。因为不为0，所以A和B都不会被析构，造成内存泄漏。}int main() { create_circular_reference(); std::cout << "End of main." << std::endl; // 你会发现A和B的析构函数没有被调用 return 0;}
在这个例子中，
a
持有
b
，
b
又持有
a
。当外部所有对
a
和
b
的
shared_ptr
都失效后，
a
和
b
内部的
shared_ptr
仍然保持着对对方的引用，导致它们的强引用计数永远不会降到零，从而造成内存泄漏。
避免方法：使用
std::weak_ptr
std::weak_ptr
是解决循环引用的利器。它是一个“弱引用”，不会增加对象的强引用计数。你可以用它来观察一个对象，但它不拥有这个对象。当所有
std::shared_ptr
都失效后，即使有
std::weak_ptr
指向该对象，对象也会被销毁。要访问
std::weak_ptr
指向的对象，你需要先将其转换为
std::shared_ptr
（通过
lock()
方法），如果对象已被销毁，
lock()
会返回一个空的
std::shared_ptr
。
将上面例子中的
b->a_ptr
改为
std::weak_ptr a_ptr;
就能解决问题：
// ... (A和B的定义，B中的a_ptr改为std::weak_ptr)class B {public: std::weak_ptr a_ptr; // 改为weak_ptr B() { std::cout << "B constructed!" << std::endl; } ~B() { std::cout << "B destructed!" << std::endl; }};void create_correct_reference() { std::shared_ptr a = std::make_shared(); std::shared_ptr b = std::make_shared(); a->b_ptr = b; // A持有B的shared_ptr (强引用) b->a_ptr = a; // B持有A的weak_ptr (弱引用) // 当函数结束时，a和b的局部shared_ptr失效。 // 此时，B对A的引用是弱引用，不影响A的强引用计数。 // A的强引用计数变为0，A被析构。 // A被析构后，a->b_ptr失效，B的强引用计数也变为0，B被析构。}int main() { create_correct_reference(); std::cout << "End of main." << std::endl; // A和B的析构函数会被调用 return 0;}
2. 性能开销
引用计数机制的每次增减操作都需要原子性地执行，以确保多线程环境下的正确性。原子操作通常比普通操作有更高的开销。此外，每个
shared_ptr
都需要额外分配一个控制块，这增加了内存消耗和堆分配的频率。
避免方法：
使用
std::make_shared
：前面提到过，它能减少一次内存分配，提升性能。优先使用
std::unique_ptr
：如果对象没有多所有权的需求，
std::unique_ptr
是更好的选择。它没有引用计数的开销，性能更高。避免不必要的拷贝：尽量通过引用传递
shared_ptr
，而不是值传递，以减少引用计数的增减操作。考虑自定义分配器：对于性能极度敏感的场景，可以为
shared_ptr
或其内部对象提供自定义的内存分配器，但通常不建议过度优化。
3. 线程安全
std::shared_ptr
本身的引用计数操作是线程安全的（即增减计数是原子的）。但这并不意味着被它管理的对象也是线程安全的。如果多个线程同时访问和修改
shared_ptr
指向的同一个对象，仍然需要额外的同步机制（如互斥锁）来保护对象的内部状态。
避免方法：
保护被管理对象：对被
shared_ptr
管理的对象进行并发访问时，务必使用互斥锁或其他同步原语来保护其内部数据。不可变对象：如果可能，设计被
shared_ptr
管理的对象为不可变的（immutable），这样可以避免并发修改的问题。
除了引用计数，C++内存管理还有哪些常用策略？引用计数与它们相比有何优劣？
C++的内存管理策略多种多样，引用计数只是其中一种，每种都有其适用场景和权衡。
1. 手动内存管理 (
new
和
delete
)
策略：开发者直接使用
new
在堆上分配内存，使用
delete
释放内存。优劣：优点：最灵活，对内存有最细粒度的控制，性能理论上最高（没有智能指针的额外开销）。缺点：极易出错，容易导致内存泄漏（忘记
delete
）、悬空指针（
delete
后继续使用）、二次释放（
delete
两次）等问题。代码量大，维护复杂。与引用计数对比：引用计数自动管理生命周期，大大减少了手动管理的错误。手动管理需要开发者承担全部责任，而引用计数则将部分责任转移给运行时系统。
2. 独占所有权 (
std::unique_ptr
)
策略：
std::unique_ptr
确保一个对象在任何时候只有一个所有者。当
unique_ptr
被销毁时，它所管理的对象也会被销毁。它不支持拷贝，但支持移动语义，可以将所有权从一个
unique_ptr
转移到另一个。优劣：优点：零运行时开销（与裸指针几乎相同），在编译时强制执行独占所有权，避免了内存泄漏和悬空指针。比
shared_ptr
更轻量级。缺点：无法实现多所有权共享。与引用计数对比：
unique_ptr
适用于明确只有一个所有者的情况，性能优于
shared_ptr
。
shared_ptr
适用于需要多方共享对象生命周期的场景。如果一个对象在程序生命周期内只有一个明确的管理者，
unique_ptr
是首选；如果对象需要在不同模块、不同生命周期的对象之间共享，
shared_ptr
则更合适。
3. 垃圾回收 (Garbage Collection, GC)
策略：在C++标准中没有内置的垃圾回收机制，但在某些特定的C++运行时环境或库中可能会引入（例如，Qt的QObject系统，或者一些特定领域的C++框架）。垃圾回收器会自动识别并回收不再被程序任何部分引用的内存。优劣：优点：彻底解放开发者，几乎完全消除了内存管理错误。缺点：通常会带来显著的运行时开销（暂停程序执行进行回收），难以预测内存回收的时机，可能导致性能峰谷。与C++的“零开销抽象”理念不符。与引用计数对比：垃圾回收通常更“懒惰”，它会在后台周期性地进行扫描和回收。引用计数是即时的，当计数归零时立即释放。引用计数对性能的影响通常更可预测，但需要处理循环引用问题；垃圾回收则可以处理循环引用，但性能开销更大且难以预测。
4. 自定义内存分配器 (Custom Allocators)
策略：开发者可以编写自己的内存分配器，以优化特定场景下的内存使用，例如：池分配器 (Pool Allocator)：预先分配一大块内存，然后从中分配固定大小的小块内存，减少系统调用开销，避免内存碎片。竞技场/线性分配器 (Arena/Linear Allocator)：在一段生命周期内，只向前移动指针分配内存，最后一次性释放整块内存，效率极高。优劣：优点：对内存使用有极致的控制和优化能力，可以显著提升特定场景的性能，减少内存碎片。缺点：实现复杂，需要深入理解内存管理，容易引入新的bug。通常只在性能瓶颈非常明确的场景下使用。与引用计数对比：自定义分配器通常是底层优化，可以与智能指针结合使用。例如，
std::shared_ptr
和
std::unique_ptr
都可以接受自定义分配器作为模板参数，从而在保持智能指针便利性的同时，利用自定义分配器提升性能。
总的来说，引用计数 (
std::shared_ptr
) 在C++中提供了一种在多所有权场景下自动管理内存的强大而便捷的机制。它牺牲了一定的性能开销来换取编程的便利性和安全性，但需要警惕循环引用问题并善用
std::weak_ptr
来解决。在选择内存管理策略时，核心原则是根据对象的生命周期、所有权模型和性能需求进行权衡。对于独占所有权，
std::unique_ptr
是首选；对于共享所有权，
std::shared_ptr
是明智之选；对于极度性能敏感且结构简单的场景，自定义分配器可能会有所助益。而手动管理，除非有非常特殊的理由，否则在现代C++中应尽量避免。
以上就是C++内存管理基础中引用计数机制原理解析的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1475016.html
微信扫一扫 
支付宝扫一扫 
