C++内存管理基础中引用计数机制原理解析-C++-PHP中文网

C++引用计数通过std::shared_ptr实现，利用控制块管理强/弱引用计数，确保对象在无所有者时自动释放；其核心机制为原子操作增减计数，避免内存泄漏，但需警惕循环引用问题。

c++内存管理基础中引用计数机制原理解析

C++的引用计数机制，在我看来，是现代C++内存管理中一个非常核心且优雅的解决方案，它允许对象在被多个地方共享时，能够自动地管理其生命周期。简单来说，就是通过追踪有多少个“所有者”指向一个对象，当这个计数归零时，对象就会被自动销毁。这大大减轻了手动管理内存的负担，也降低了内存泄漏和悬空指针的风险。

引用计数的核心原理其实并不复杂，它为每个被管理的对象维护一个引用计数器。

当一个智能指针（比如

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 <iostream>
#include <memory>

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<MyObject> ptr1 = std::make_shared<MyObject>(); // 强引用计数 = 1
    std::cout << "ptr1 ref count: " << ptr1.use_count() << std::endl;

    {
        std::shared_ptr<MyObject> ptr2 = ptr1; // 强引用计数 = 2
        std::cout << "ptr2 ref count: " << ptr2.use_count() << std::endl;
        ptr2->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 <iostream>
#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    A() { std::cout << "A constructed!" << std::endl; }
    ~A() { std::cout << "A destructed!" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> a_ptr;
    B() { std::cout << "B constructed!" << std::endl; }
    ~B() { std::cout << "B destructed!" << std::endl; }
};

void create_circular_reference() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    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;
}

登录后复制

在这个例子中，

登录后复制

持有

登录后复制

，

登录后复制

又持有

登录后复制

。当外部所有对

登录后复制

和

登录后复制

的

shared_ptr

登录后复制

都失效后，

登录后复制

和

登录后复制

内部的

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> a_ptr;

登录后复制

就能解决问题：

存了个图

视频图片解析/字幕/剪辑，视频高清保存/图片源图提取

查看详情

// ... (A和B的定义，B中的a_ptr改为std::weak_ptr<A>)
class B {
public:
    std::weak_ptr<A> 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> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    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
```
登录后复制
都可以接受自定义分配器作为模板参数，从而在保持智能指针便利性的同时，利用自定义分配器提升性能。