简介：本文阐述了C++中智能指针的概念及其在内存管理中的作用，特别是如何实现一个带引用计数的智能指针。引用计数机制通过维护一个计数器来跟踪有多少智能指针指向同一对象，从而自动管理对象的生命周期，防止内存泄漏。文章首先介绍了引用计数的基础结构，然后展示了智能指针类 SharedPtr 的实现，包括构造函数、复制构造函数、赋值运算符和析构函数。此外，还指出了在多线程环境下实现引用计数时需要考虑的线程安全性问题，并强调了标准库中的 std::shared_ptr 是如何通过原子操作来保证线程安全的。通过理解并实现引用计数机制，开发者可以更有效地在项目中使用智能指针，并为自定义内存管理打下基础。
1. 智能指针的概念和重要性
智能指针是C++语言中一个高级特性，它解决了一个困扰开发人员多年的问题：手动内存管理。在C++早期版本中，动态分配的内存需要程序员明确地进行释放，否则会导致内存泄漏。智能指针的出现极大地简化了资源管理，减少了由于疏忽造成的内存泄漏和野指针问题。
智能指针的主要类型包括 std::unique_ptr 、 std::shared_ptr 和 std::weak_ptr ，它们代表了不同的资源管理策略。 std::unique_ptr 保证同一时刻只有一个所有者，而 std::shared_ptr 允许多个所有者共享资源，直到最后一个拥有者销毁。 std::weak_ptr 则是一种弱引用，它不拥有资源，但可以观察 std::shared_ptr ，用来解决潜在的循环引用问题。
智能指针的引入，不仅提高了代码的安全性，还提升了开发效率，使得资源管理更加自动化。现代C++编程几乎离不开智能指针的应用，无论是在并发环境中的线程安全，还是在提高代码可读性和可维护性方面，智能指针都扮演着不可或缺的角色。接下来的章节，我们将详细探讨这些智能指针的工作机制和最佳实践。
2. 引用计数的工作原理
2.1 引用计数基本原理
2.1.1 引用计数的定义与目的
引用计数是一种资源管理技术，用于跟踪资源被引用的次数。在智能指针的上下文中，每个资源对象都与一个计数器相关联。每当有一个新的引用指向该对象时，计数器就会增加；而当引用被销毁或不再指向该对象时，计数器就会减少。当计数器的值减少到零时，说明没有更多的引用指向该对象，资源就可以被安全地释放。这种方法简化了资源管理，因为程序员不需要手动调用释放函数，而是在对象生命周期的末尾，由引用计数机制自动进行清理。
2.1.2 引用计数的核心要素
引用计数的关键要素包括：
- 引用计数器 : 一个整数，记录资源的引用次数。
- 管理对象 : 智能指针本身，它包含了资源指针和引用计数器。
- 引用增加与减少的操作 : 当新的引用指向资源时，计数器增加；当引用结束时，计数器减少。
- 资源释放逻辑 : 当计数器减至零时，资源被释放。
2.2 引用计数的实现方式
2.2.1 内部引用计数
内部引用计数是指引用计数器直接嵌入在资源对象内部。这种方式的实现简单直接，但要求资源对象本身能控制自己的生命周期。在C++中，这通常意味着资源需要继承自一个共享的基类或者使用一个联合体来持有资源和计数器。内部引用计数的一个优点是容易管理，因为所有的信息都在同一个对象内部。然而，它也有一些局限性，比如无法应用于不支持继承的资源类型，或者当资源需要在多态的情况下被使用时。
2.2.2 外部引用计数
外部引用计数是将引用计数器与资源对象分离，通常会有一个控制块来管理计数器。控制块包含了引用计数器，以及可能的删除器和其他管理信息。这种设计允许对非继承资源的管理，并且可以灵活应对多态资源。外部引用计数的优点是灵活性和对多种资源类型的兼容性。但相对的，它也带来了额外的复杂性和内存分配开销。
2.3 引用计数的生命周期管理
2.3.1 资源的创建与销毁
资源的创建通常伴随着引用计数器的初始化。当一个新对象被创建时，引用计数被设置为1。随后，每当有新的引用指向该对象时，引用计数器会增加。相反地，当引用结束时，引用计数器减少。资源销毁的时机是在引用计数器减少至零时，此时没有任何引用指向资源，资源可以安全地被销毁。在智能指针中，这个销毁过程通常是由析构函数来完成。
2.3.2 引用与解引用操作
引用操作是指获得一个指向资源的指针，而解引用操作则是指访问或修改资源内容。在引用计数的智能指针中，每当发生引用操作时，计数器增加；每当发生解引用操作时，计数器减少。正确的实现应当确保引用计数器的增加与减少总是配对的，以避免内存泄漏或提前释放资源。此外，还需要特别处理复制构造函数和赋值运算符，保证它们能够正确地管理引用计数器。
代码示例
以下是一个简化的引用计数智能指针的代码示例，其中使用了内部引用计数的设计：
#include <iostream>
#include <memory>
template <typename T>
class SharedCounter {
public:
SharedCounter(T* ptr) : _ptr(ptr), _ref_count(new size_t(1)) {}
SharedCounter(const SharedCounter& other)
: _ptr(other._ptr), _ref_count(other._ref_count) {
++(*_ref_count);
}
~SharedCounter() {
if (--(*_ref_count) == 0) {
delete _ptr;
delete _ref_count;
}
}
T* get() const { return _ptr; }
size_t use_count() const { return *_ref_count; }
private:
T* _ptr; // Resource pointer
size_t* _ref_count; // Reference count
};
template <typename T>
class SharedPtr {
SharedCounter<T>* _counter;
public:
explicit SharedPtr(T* ptr = 0) : _counter(new SharedCounter<T>(ptr)) {}
SharedPtr(const SharedPtr& other) : _counter(other._counter) {}
~SharedPtr() {
delete _counter;
}
T* operator->() const { return _counter->get(); }
T& operator*() const { return *(_counter->get()); }
size_t use_count() const { return _counter->use_count(); }
};
逻辑分析和参数说明
代码中定义了一个 SharedCounter 模板类，它是一个辅助类，负责管理资源的引用计数。 SharedPtr 是一个智能指针类，它使用 SharedCounter 来追踪引用计数。
-
SharedCounter的构造函数接收一个指向资源的指针，并初始化引用计数为1。 -
SharedCounter的复制构造函数接收另一个SharedCounter对象作为参数，使得资源的引用计数增加。 - 当
SharedCounter对象被销毁时（即use_count减少至0），资源指针指向的内存被释放。 -
SharedPtr类通过SharedCounter对象管理资源的生命周期，它提供了访问资源的operator->和operator*，以及use_count方法来查询当前的引用计数。
这段代码展示了一个基本的引用计数智能指针的实现，其中使用了内部引用计数机制。然而，在实际应用中，智能指针的实现会更加复杂，需要考虑到异常安全性、线程安全性等因素。
3. SharedPtr 类实现概述
3.1 SharedPtr 类设计
在智能指针的实现中， SharedPtr 类的设计需要考虑如何存储和管理资源的引用计数，同时提供与普通指针类似的接口。这一部分将介绍 SharedPtr 类的成员变量设计和成员函数设计。
3.1.1 类成员变量设计
在设计 SharedPtr 类时，以下成员变量是必不可少的：
- 指针类型成员变量（
_ptr） ：存储指向实际对象的指针。 - 引用计数类型成员变量（
_ref_count） ：记录有多少SharedPtr实例指向同一个资源。
示例代码如下：
template <typename T>
class SharedPtr {
private:
T* _ptr; // 指向动态分配对象的指针
long* _ref_count; // 引用计数
};
这里使用模板 <typename T> 是为了支持不同数据类型的资源管理。
3.1.2 类成员函数设计
SharedPtr 类至少需要以下成员函数来实现智能指针的基本功能：
- 构造函数（
SharedPtr(T* ptr)） ：初始化指针和引用计数。 - 析构函数（
~SharedPtr()） ：减少引用计数并删除资源当它变为0。 - 复制构造函数（
SharedPtr(const SharedPtr& other)） ：复制指针并增加引用计数。 - 赋值运算符重载（
SharedPtr& operator=(const SharedPtr& other)） ：处理对象的赋值操作。 - 成员访问运算符重载（
T& operator*()和T* operator->()） ：允许通过SharedPtr访问资源。
示例代码如下：
template <typename T>
class SharedPtr {
public:
// 构造函数
explicit SharedPtr(T* ptr = nullptr) : _ptr(ptr), _ref_count(new long(1)) {}
// 析构函数
~SharedPtr() {
if (--(*_ref_count) == 0) {
delete _ptr;
delete _ref_count;
}
}
// 复制构造函数
SharedPtr(const SharedPtr& other) : _ptr(other._ptr), _ref_count(other._ref_count) {
++(*_ref_count);
}
// 赋值运算符重载
SharedPtr& operator=(const SharedPtr& other) {
if (this != &other) {
if (--(*_ref_count) == 0) {
delete _ptr;
delete _ref_count;
}
_ptr = other._ptr;
_ref_count = other._ref_count;
++(*_ref_count);
}
return *this;
}
// 成员访问运算符重载
T& operator*() const { return *_ptr; }
T* operator->() const { return _ptr; }
private:
T* _ptr; // 指向动态分配对象的指针
long* _ref_count; // 引用计数
};
在上述代码中， _ref_count 的增加和减少是通过原子操作（在多线程环境下）或者普通的 ++ 和 -- 操作来完成的。这在后面章节将详细探讨。
3.2 SharedPtr 类模板实现
3.2.1 模板类的声明与定义
模板类允许 SharedPtr 在编译时为任何类型创建一个专门的实例，这提供了很强的类型安全性和灵活性。在实现中，需要确保模板类的声明和定义都正确无误。
3.2.2 类内嵌类型别名与静态成员
模板类中，内嵌类型别名和静态成员是常见的做法，它们可以简化访问，增加代码的可读性。例如，我们可以定义一个 element_type 别名来代表模板参数 T 的类型。
示例代码如下：
template <typename T>
class SharedPtr {
public:
using element_type = T; // 内嵌类型别名
// ...
};
通过这样的设计， SharedPtr 类不仅提供内存管理的功能，而且还具备了相当的灵活性和扩展性。在接下来的章节中，我们将逐步深入探讨如何实现构造函数、复制构造函数、赋值运算符和析构函数等关键组件，并进一步讨论线程安全问题和如何避免内存泄漏。
4. 构造函数、复制构造函数和赋值运算符的具体实现
智能指针的关键特性之一就是能够自动管理内存资源，这需要通过正确地实现构造函数、复制构造函数和赋值运算符来确保。这些函数必须正确地处理资源的分配和引用计数的更新，以避免内存泄漏和双重删除等问题。让我们深入探讨这些函数的实现细节。
4.1 构造函数的实现
4.1.1 构造函数的作用与规则
构造函数是类的一种特殊的成员函数，它在对象创建时被调用。对于智能指针来说，构造函数的主要职责是初始化对象，并且获取资源的所有权。当智能指针被构造时，需要接收原始指针，并将引用计数设置为1，表示当前智能指针拥有该资源。值得注意的规则包括：
- 构造函数应该能够处理空指针（
nullptr）的情况。 - 构造函数不应该允许自身拥有同一资源的多个实例。
4.1.2 构造函数的代码示例
template <typename T>
class SharedPtr {
T* ptr;
long* ref_count;
public:
explicit SharedPtr(T* p = nullptr) {
ptr = p;
if (ptr) {
ref_count = new long(1); // 为资源创建引用计数
} else {
ref_count = new long(0); // 用于记录空智能指针的引用计数
}
}
// 其他成员函数和析构函数等...
};
在这个例子中，构造函数首先检查传入的原始指针是否为空。如果不为空，它将为引用计数分配内存并初始化为1，表示智能指针拥有该资源。如果传入的是空指针，引用计数则被设置为0，这可以用来表示一个空的 SharedPtr 实例。
4.2 复制构造函数的实现
4.2.1 深拷贝与浅拷贝的讨论
当一个对象被复制时，复制构造函数被调用。对于智能指针来说，关键在于决定是创建资源的深拷贝还是浅拷贝。智能指针通常实现浅拷贝，意味着它复制指针的值而不是它所指向的对象。浅拷贝要求用户必须保证原始指针指向的对象是动态分配的，且可以通过 new 和 delete 来管理。
4.2.2 复制构造函数的代码示例
template <typename T>
class SharedPtr {
// ...其他成员...
public:
SharedPtr(const SharedPtr& r) {
ptr = r.ptr;
ref_count = r.ref_count;
if (ref_count) {
++(*ref_count); // 增加引用计数
}
}
// 其他成员函数和析构函数等...
};
复制构造函数接收另一个 SharedPtr 实例作为参数，并增加该对象引用计数的值。这样，两个智能指针就共同拥有了同一个资源。引用计数机制确保当两个智能指针都销毁时，资源最终会被正确地释放。
4.3 赋值运算符的实现
4.3.1 赋值运算符的重载规则
赋值运算符的重载需要处理三种情况：自我赋值、普通赋值和资源的释放。自我赋值是指指针指向自己的情况，为了避免在此情况下删除自身资源，需要特别处理。普通赋值需要确保目标对象所管理的资源被释放，同时更新新资源的引用计数。
4.3.2 赋值运算符的代码示例
template <typename T>
class SharedPtr {
// ...其他成员...
public:
SharedPtr& operator=(const SharedPtr& r) {
if (this != &r) { // 避免自我赋值
if (--(*ref_count) == 0) { // 释放当前智能指针的资源
delete ptr;
delete ref_count;
}
ptr = r.ptr;
ref_count = r.ref_count;
if (ref_count) {
++(*ref_count); // 增加新资源的引用计数
}
}
return *this;
}
// 其他成员函数和析构函数等...
};
赋值运算符首先检查是否是自我赋值，然后减少当前智能指针引用计数的值。如果计数降至零，那么当前对象所管理的资源被释放。之后，复制传入的智能指针实例的成员变量，包括资源指针和引用计数，最后增加新资源的引用计数。
在实现智能指针时，确保对每个操作进行详细的逻辑分析和测试是非常重要的。特别是在复制构造函数和赋值运算符中，正确管理引用计数和资源释放是避免内存泄漏和野指针问题的关键。
5. 析构函数和引用计数的释放逻辑
析构函数是智能指针生命周期中的关键环节，它负责在智能指针销毁或重置时释放所管理的资源。正确的析构函数实现能够保证内存泄漏不会发生，并且资源得到妥善处理。引用计数的释放逻辑与析构函数的实现紧密相关，是智能指针正确工作的重要组成部分。本章将深入探讨析构函数的设计、引用计数的递减逻辑以及循环引用问题的处理方法。
5.1 析构函数的作用与设计
析构函数是对象生命周期结束时被调用的特殊成员函数，它用于执行清理工作，如释放资源等。对于智能指针来说，析构函数需要负责减少引用计数，并在计数降至零时释放资源。
5.1.1 析构函数的职责
析构函数的职责包括：
- 引用计数递减 ：当智能指针被销毁时，它需要减少指向资源的引用计数。
- 资源释放 ：如果引用计数降至零，说明没有其他对象需要该资源，此时应安全释放资源。
- 异常安全 ：析构函数在执行过程中应保证异常安全，即任何异常发生时不会导致资源泄露。
// 析构函数代码示例
template <typename T>
class SmartPtr {
public:
~SmartPtr() {
if (--counter_ == 0) {
delete ptr_;
}
}
private:
T* ptr_; // 指向资源的指针
int* counter_; // 引用计数指针
};
在上述代码中，析构函数检查引用计数器 counter_ 是否递减至零。如果是，则删除指向的资源 ptr_ 以释放内存。该操作保证了资源在不再需要时被正确释放，避免内存泄漏。
5.1.2 析构函数的安全设计
为了确保析构函数的安全性，需要考虑到多线程环境下的并发访问和异常安全性。以下是设计建议：
- 同步控制 ：如果
counter_的修改涉及到多个线程访问，应当使用适当的同步机制（如互斥锁）来确保线程安全。 - 异常安全性 ：确保析构函数在处理过程中，如抛出异常，能够保持资源的完整性，例如在释放资源前使用RAII资源管理技术。
5.2 引用计数的递减与释放时机
正确处理引用计数的递减和资源释放时机对于防止资源泄露至关重要。智能指针应当能够在适当的时候安全地减少引用计数，并且在计数变为零时释放资源。
5.2.1 引用计数递减的条件
智能指针的引用计数应当在以下情况下递减：
- 重置操作 ：当智能指针对象被重置时，引用计数应当减少。
- 离开作用域 ：当智能指针对象离开其作用域时，应当减少引用计数。
- 赋值操作 ：当智能指针对象被赋新值时，旧值的引用计数减少。
// 示例：赋值操作导致引用计数递减
template <typename T>
class SmartPtr {
public:
SmartPtr& operator=(SmartPtr other) {
swap(*this, other);
return *this;
}
// 其他成员函数...
private:
T* ptr_;
int* counter_;
};
// 交换函数
template <typename T>
void swap(SmartPtr& a, SmartPtr& b) {
std::swap(a.ptr_, b.ptr_);
std::swap(a.counter_, b.counter_);
}
在上述代码中，通过 swap 实现的赋值操作符确保了两个 SmartPtr 对象交换资源和引用计数。赋值后，原对象的引用计数减少，而新对象的引用计数增加。
5.2.2 引用计数为零时的资源释放
当智能指针所管理的资源引用计数降至零时，应当执行资源的释放逻辑。这通常包括删除原始资源，释放与之相关联的内存等。
// 示例：引用计数为零时释放资源
template <typename T>
class SmartPtr {
public:
// 析构函数
~SmartPtr() {
if (--*counter_ == 0) {
delete ptr_;
delete counter_;
}
}
private:
T* ptr_;
int* counter_;
};
在该代码段中，析构函数减少引用计数，并在引用计数降为零时释放资源。注意，此处为了简单起见，假设 counter_ 是一个指向单个引用计数的指针，实际使用中需要考虑多线程安全等其他因素。
5.3 循环引用的处理
循环引用是智能指针管理中的一种特殊情况，它会导致引用计数无法降为零，从而阻止资源被释放。本节将详细讨论循环引用的形成和解决方法。
5.3.1 循环引用的形成与问题
循环引用发生在两个或多个智能指针对象相互引用，形成闭环，导致它们的引用计数始终大于零。这种情况下，智能指针永远不会被销毁，资源也就得不到释放。
// 循环引用示例
class Node {
public:
Node(SmartPtr<Node> next) : next_(next) {}
private:
SmartPtr<Node> next_;
};
在这个例子中，类 Node 包含一个指向下一个 Node 的 SmartPtr 成员。如果两个 Node 对象互相引用，则它们各自的 SmartPtr 永远不会使引用计数归零，形成循环引用。
5.3.2 循环引用的检测与解决方法
循环引用的检测通常较为困难，因为它可能需要分析智能指针的整个引用图。一种常见的解决方法是引入弱引用（ std::weak_ptr ），它可以引用资源而不增加引用计数。
// 使用 std::weak_ptr 解决循环引用
class Node {
public:
Node(std::weak_ptr<Node> next) : next_(next) {}
private:
std::weak_ptr<Node> next_;
};
在修正后的例子中， Node 类使用 std::weak_ptr 来引用下一个节点。 std::weak_ptr 不拥有资源，因此不会增加引用计数，这样可以有效避免循环引用的问题。
总结
析构函数和引用计数的释放逻辑是智能指针核心机制的一部分，关系到资源的正确释放和程序的稳定性。通过精细设计析构函数，可以确保资源在适当的时候被释放，而且不会发生内存泄漏。循环引用问题需要特别注意，它可能导致资源无法被及时释放，影响程序性能和资源使用效率。在实际编程中，应当利用现代C++提供的工具和技术，如 std::weak_ptr ，来避免循环引用的发生。
6. 线程安全性考虑
在多线程环境下，智能指针的使用必须要考虑到线程安全性。在本章节中，我们将深入探讨线程安全的基本概念，并介绍在实现线程安全的智能指针时可以采取的策略。
6.1 线程安全的基本概念
6.1.1 什么是线程安全
线程安全指的是在多线程环境中，共享资源的访问是正确且一致的，不会出现资源竞争导致的数据不一致问题。当多个线程同时访问共享资源，例如智能指针所管理的内存时，线程安全是确保程序正确运行的关键。
6.1.2 线程安全的设计原则
为确保线程安全，设计时需要考虑以下原则：
- 原子操作 : 保证对共享资源的操作是不可分割的。
- 互斥锁 : 保证同一时刻只有一个线程可以访问特定资源。
- 无锁编程 : 利用原子操作和无锁数据结构设计出无需锁机制即可保证线程安全的代码。
6.2 线程安全的智能指针实现
6.2.1 互斥锁的使用
互斥锁是实现线程安全最直接的手段。在智能指针中，我们需要对引用计数的增加和减少操作进行保护。
#include <mutex>
template <typename T>
class ThreadSafeSharedPtr {
private:
mutable std::mutex mut;
T* pointer;
long* refCount;
void addRef() const {
std::lock_guard<std::mutex> lock(mut);
++(*refCount);
}
long release() const {
std::lock_guard<std::mutex> lock(mut);
long temp = --(*refCount);
if (temp == 0) {
delete pointer;
delete refCount;
}
return temp;
}
public:
ThreadSafeSharedPtr(T* p = nullptr) : pointer(p), refCount(new long(1)) {}
~ThreadSafeSharedPtr() {
release();
}
};
6.2.2 无锁编程技术的尝试
无锁编程技术尝试通过原子操作直接实现线程安全，避免互斥锁带来的性能损失。这通常涉及到复杂的内存操作和对CPU缓存行为的优化。
#include <atomic>
template <typename T>
class LockFreeSharedPtr {
private:
std::atomic<long>* refCount;
T* pointer;
void addRef() const {
refCount->fetch_add(1, std::memory_order_relaxed);
}
long release() const {
long temp = refCount->fetch_sub(1, std::memory_order_release);
if (temp == 1) {
delete pointer;
delete refCount;
temp = 0;
}
return temp;
}
public:
LockFreeSharedPtr(T* p = nullptr) : refCount(new std::atomic<long>(1)), pointer(p) {}
~LockFreeSharedPtr() {
release();
}
};
在无锁编程中， std::memory_order 参数定义了内存操作的顺序，这是一种权衡内存一致性与性能的方式。需要注意的是，无锁编程对代码的正确性和逻辑要求非常高，错误可能导致难以发现的竞态条件。
表格展示不同线程安全策略性能对比
| 策略 | 优点 | 缺点 |
|---|---|---|
| 互斥锁 | 简单易实现，减少并发冲突 | 性能开销大，有死锁和优先级倒置风险 |
| 读写锁 | 读操作并发性提高，适合读多写少场景 | 写操作依然受限，复杂度高 |
| 无锁编程 | 性能较高，无死锁风险 | 实现复杂，调试困难，错误难以发现 |
mermaid格式流程图展示互斥锁加锁流程
graph LR
A[开始] --> B{是否获得锁}
B -- 是 --> C[进行操作]
B -- 否 --> D[等待锁]
D --> B
C --> E[释放锁]
E --> F[结束]
智能指针的线程安全性实现是其在多线程编程中可靠性的关键。通过互斥锁和无锁编程技术的应用，可以提供不同程度的线程安全保护。在选择合适的策略时，开发者需要权衡操作的复杂性、预期的并发量以及性能需求。由于智能指针的复杂性，实施这些策略需要对C++模板、多线程编程、原子操作等有深入的理解。
7. std::shared_ptr 作为标准库中的引用计数智能指针实例
在现代C++编程中，智能指针是管理内存生命周期不可或缺的工具，尤其是 std::shared_ptr 这种引用计数智能指针，它允许多个指针共享同一资源的所有权。本章将详细介绍 std::shared_ptr 的用法、内部实现以及在实际应用中的最佳实践。
7.1 std::shared_ptr 的介绍与用法
7.1.1 标准库中智能指针的发展
从C++98开始，智能指针就成为了标准库的一部分，但早期的智能指针如 auto_ptr 存在诸多设计上的缺陷，例如不允许复制构造和赋值操作。到了C++11，引入了新的智能指针类型，包括 std::unique_ptr 、 std::shared_ptr 和 std::weak_ptr ，它们提供了更为安全和方便的内存管理方式。
std::shared_ptr 是一个引用计数智能指针，允许多个指针共享同一个对象的所有权。当 std::shared_ptr 的实例被销毁或重置时，它会自动减少引用计数，并在计数变为零时删除相关联的对象。这有助于避免内存泄漏，同时使得资源管理更为透明。
7.1.2 std::shared_ptr 的使用示例
下面展示了一个 std::shared_ptr 的基本使用示例：
#include <iostream>
#include <memory>
class MyClass {
public:
MyClass() { std::cout << "Constructing MyClass\n"; }
~MyClass() { std::cout << "Destructing MyClass\n"; }
};
int main() {
std::shared_ptr<MyClass> myPtr = std::make_shared<MyClass>(); // 使用make_shared创建
{
std::shared_ptr<MyClass> anotherPtr = myPtr; // anotherPtr和myPtr共享所有权
} // anotherPtr在此处离开作用域，但myPtr仍然存在
// 当main函数结束时，myPtr也将离开作用域，此时MyClass对象会被销毁
return 0;
}
上面的代码中， std::make_shared 用于创建一个 MyClass 实例，并返回一个指向它的 std::shared_ptr 。另一个 std::shared_ptr （anotherPtr）通过复制构造函数创建，与myPtr共享同一个资源。当anotherPtr离开作用域时，它对资源的引用计数会递减，但因为myPtr还持有资源，所以对象不会被销毁。当myPtr离开作用域时，资源引用计数减到零，资源被销毁。
7.2 std::shared_ptr 的内部实现细节
7.2.1 标准智能指针与自定义智能指针的比较
std::shared_ptr 作为标准库中提供的智能指针，其内部实现要比自定义的智能指针复杂许多。例如，它需要考虑到异常安全性、线程安全性以及与其他智能指针类型的交互等问题。
自定义智能指针通常只关注资源管理的基本逻辑，而 std::shared_ptr 的实现则需要考虑这些额外的因素。此外，标准库中的智能指针往往经过了优化，例如，为了避免每次拷贝或赋值操作时都进行引用计数的同步，某些实现可能会使用原子操作来管理引用计数。
7.2.2 标准库实现的优化与注意事项
std::shared_ptr 的实现通常涉及到一种被称为”控制块”的内部结构，该结构包含了引用计数和删除器等信息。当创建一个 std::shared_ptr 时，它会与一个控制块关联。如果另一个 std::shared_ptr 被创建来指向同一对象，它们都会引用同一个控制块，从而实现引用计数的共享。
在性能方面， std::shared_ptr 使用了引用计数的原子操作来保证线程安全性。这种方式虽然安全，但是会带来额外的性能开销，特别是在频繁进行引用计数更新的场景下。因此，开发者在使用 std::shared_ptr 时需要注意避免不必要的拷贝，尤其是在性能敏感的代码路径上。
7.3 实际应用中的最佳实践
7.3.1 避免循环引用的策略
在使用 std::shared_ptr 时，开发者需要特别注意循环引用的问题。循环引用是指两个或多个 std::shared_ptr 实例相互持有对方，从而导致即使没有任何外部引用，资源也无法被释放。解决循环引用的一个有效策略是使用 std::weak_ptr ，它可以保持对 std::shared_ptr 指向对象的弱引用，不增加引用计数。
7.3.2 std::weak_ptr 的使用场景
std::weak_ptr 是与 std::shared_ptr 配合使用的辅助类，它可以用来打破循环引用或者在必要时临时访问 std::shared_ptr 管理的对象。当 std::weak_ptr 转换为 std::shared_ptr 时，如果底层资源已被释放，转换结果将是一个空的 std::shared_ptr 。
std::shared_ptr<MyClass> sharedA = std::make_shared<MyClass>();
std::weak_ptr<MyClass> weakB = sharedA;
// 在某处，可能很久以后...
std::shared_ptr<MyClass> sharedB = weakB.lock();
if (sharedB) {
// 成功获取资源，没有发生循环引用
}
在上面的代码中，我们首先创建了一个 std::shared_ptr 指向一个 MyClass 对象，然后创建了一个 std::weak_ptr ，将其指向相同的对象。在需要使用资源但又担心循环引用时，可以使用 std::weak_ptr 的 lock 方法来尝试获取一个有效的 std::shared_ptr 。
总结
本章我们探讨了 std::shared_ptr 的标准库实现和实际应用中的使用方法，包括如何避免循环引用以及 std::weak_ptr 的使用场景。智能指针是现代C++开发中的重要工具，掌握它们的正确使用方式将对开发效率和代码稳定性产生显著的积极影响。在后续章节中，我们将进一步深入探讨智能指针的高级特性和最佳实践。
简介：本文阐述了C++中智能指针的概念及其在内存管理中的作用，特别是如何实现一个带引用计数的智能指针。引用计数机制通过维护一个计数器来跟踪有多少智能指针指向同一对象，从而自动管理对象的生命周期，防止内存泄漏。文章首先介绍了引用计数的基础结构，然后展示了智能指针类 SharedPtr 的实现，包括构造函数、复制构造函数、赋值运算符和析构函数。此外，还指出了在多线程环境下实现引用计数时需要考虑的线程安全性问题，并强调了标准库中的 std::shared_ptr 是如何通过原子操作来保证线程安全的。通过理解并实现引用计数机制，开发者可以更有效地在项目中使用智能指针，并为自定义内存管理打下基础。
扫一扫
1584
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
