C++ 从入门到精通之十一

大纲

• C++ 从入门到精通之一、C++ 从入门到精通之二、C++ 从入门到精通之三
• C++ 从入门到精通之四、C++ 从入门到精通之五、C++ 从入门到精通之六
• C++ 从入门到精通之七、C++ 从入门到精通之八、C++ 从入门到精通之九
• C++ 从入门到精通之十、C++ 从入门到精通之十一、C++ 从入门到精通之十二
• C++ 从入门到精通之十三、C++ 从入门到精通之十四、C++ 从入门到精通之十五
• C++ 从入门到精通之十六

C++ 智能指针

直接内存管理

直接内存管理的示例代码

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class MyClass {
public:
    int m_i;
};

// 自动内存管理
void func() {
    int a = 0;          // 局部变量（临时）
    MyClass mc;         // 局部变量（临时）
    static int b = 30;  // 静态局部变量（全局）
}

// 直接内存管理
void func2() {
    // 初值未定义
    int* pint = new int;
    delete pint;

    // 初值为0，空括号()表示值初始化
    int* pint2 = new int();
    delete pint2;

    // 初值为10
    int* pint3 = new int(10);
    delete pint3;

    // 初值是空字符串，调用string的默认构造函数
    string* pstr = new string;
    delete pstr;

    // 调用string的默认构造函数，空括号()表示值初始化
    string* pstr2 = new string();
    delete pstr2;

    // 初值为AAAAA
    string* pstr3 = new string(5, 'A');

    // auto 配合 new 使用，pstr4 推断的类型是 string **
    auto pstr4 = new auto(pstr3);
    delete pstr3;
    delete pstr4;

    // 初始值为 1, 2, 3
    vector<int>* pvec = new vector<int>{1, 2, 3};
    delete pvec;

    // 调用MyClass的默认构造函数
    MyClass* pmc = new MyClass;
    delete pmc;

    // 调用MyClass的默认构造函数，空括号()表示值初始化
    MyClass* pmc2 = new MyClass();
    delete pmc2;

    // 动态分配const对象
    const int* pconst = new const int(100);
    delete pconst;
}

同一块内存不能 delete 多次

• 不能 delete 多次的根本原因是：
  • 设计假设：内存管理器假设每次 delete 的都是正在使用中的内存
  • 数据结构破坏：第二次 delete 会修改已被修改过的元数据，破坏空闲链表（Free List）
  • 性能取舍：为了性能，不维护复杂的 “是否已释放” 检测机制
  • 不可确定性：第一次 delete 的内存可能已被重新分配，导致第二次 delete 释放的是其他对象的内存

delete 操作	结果
delete p; delete p;	❌ 未定义行为（通常崩溃）
delete p; p=nullptr; delete p;	✅ 安全（delete nullptr 无效果）
两个指针指向同一内存，多次 delete	❌ 未定义行为
delete nullptr 多次	✅ 安全

• 错误写法一：同一指针的重复删除

int* p = new int(10);
delete p;
p = nullptr;  // ✅ 好习惯
delete p;     // ❌ 错误！同一指针重复删除

• 错误写法二：两个指针指向同一地址

int* p1 = new int(10);
int* p2 = p1;  // p2 指向同一内存
delete p1;     // ✅ 释放内存
delete p2;     // ❌ 错误！p1 和 p2 指向同一块内存

• 错误写法三：拷贝指针后重复删除

void badFunction(int* ptr) {
    delete ptr;  // 删除传入的指针
}

int main() {
    int* p = new int(42);
    badFunction(p);
    delete p;    // ❌ 错误！p 已经被删除
    return 0;
}

• 特殊情况：delete 空指针是合法的

int* p = nullptr;
delete p;  // ✅ 安全！C++ 标准保证 delete nullptr 不做任何事
delete p;  // ✅ 仍然安全，对 nullptr 重复 delete 是安全的

delete 操作的最佳实践总结

• delete 后立即置空

delete p;
p = nullptr;  // 后续 delete nullptr 是安全的

• 使用智能指针（推荐）

unique_ptr<int> p1 = make_unique<int>(42);  // 自动管理
shared_ptr<int> p2 = make_shared<int>(42);  // 引用计数，自动处理

// 不需要手动 delete，不会出现指针双重删除问题

• 明确指针所有权

// 明确谁拥有指针，谁负责删除
class MyClass {
    int* data;
public:
    MyClass() : data(new int(42)) {}
    ~MyClass() { delete data; }  // 唯一删除点
    
    // 禁止拷贝或使用引用计数
};

最佳实践总结

• 每个 new 只对应一个 delete，delete 后立即将指针置为 nullptr，更好的是方案使用智能指针自动管理内存。

智能指针的使用

扩展阅读

• C++ 入门进阶之一 - 智能指针使用
• C++ 巩固进阶之四 - 智能指针使用

智能指针的类型

在 C++ 中，智能指针的类型有以下几种：

• (1) 带引用计数的智能指针：shared_ptr
• (2) 不带引用计数的智能指针：auto_ptr、scoped_ptr、unique_ptr
• (3) 特殊的智能指针：weak_ptr（不增加引用计数，可以用于避免 shared_ptr 发生循环引用）

智能指针	C++ 标准	所有权	带引用计数	适用场景	核心特性
auto_ptr	C++ 98	独占（拷贝时转移）	否	⚠ 已废弃，建议改用 unique_ptr	独占所有权，在复制或赋值时会转移所有权，导致原指针变为空（nullptr）
scoped_ptr	Boost	独占	否	生命周期受限于作用域，适用于简单的场景，避免资源泄漏	独占所有权，不可复制或赋值，不支持移动语义，即不可以使用 std::move() 函数转移所有权
unique_ptr	C++ 11	独占	否	资源独占，生命周期明确	独占所有权，不可复制（拷贝构造和赋值），但可以移动（移动构造和移动赋值），即支持使用 std::move() 函数转移所有权
shared_ptr	C++ 11	共享	是	资源共享，生命周期不固定	共享所有权（允许多个智能指针管理同一个资源）
weak_ptr	C++ 11	观察 shared_ptr	否	避免 shared_ptr 发生循环引用	不增加引用计数，用于避免 shared_ptr 发生循环引用，可以通过 lock() 函数转换为 shared_ptr

shared_ptr 智能指针

shared_ptr 的使用语法

正确的使用语法

• shared_ptr 的正确用法
  • 第一种正确用法
    • shared_ptr<int> sp(new int(100));
    • shared_ptr<MyClass> sp(new MyClass());
  • 第二种正确用法
    • shared_ptr<int> sp = make_shared<int>(100);
    • shared_ptr<MyClass> sp = make_shared<MyClass>();
  • 第三种正确用法
    • shared_ptr<int> sp;
    • sp 是指向 int 的智能指针，但目前指向的内存地址为空，即属于空指针

错误的使用语法

• shared_ptr 的错误用法
  • 第一种错误用法（代码编译失败）
    • shared_ptr<int> sp = new int(100);
    • 智能指针是 explicit，不可以进行隐式类型转换，必须用直接初始化形式
  • 第二种错误用法（代码可以正常运行，但不推荐使用）
    • int *pi = new int(100); shared_ptr<int> spi(pi);
    • 裸指针与智能指针尽量不要混用，否则会影响代码的健壮性

shared_ptr 的引用计数

特别注意

在 C++ 中，shared_ptr 的引用计数操作是线程安全的（使用原子操作），但 shared_ptr 指向的对象本身不是线程安全的，需要额外同步处理。

引用计数增加

• shared_ptr 引用计数增加的说明
  • 移动操作：移动构造 / 移动赋值不会增加原对象的引用计数，只是转移所有权

    shared_ptr<int> p1 = std::make_shared<int>(10);  // 引用计数为 1
    shared_ptr<int> p2 = std::move(p1);              // 移动构造，p1 变为空指针，p1 指向的原对象的引用计数仍为 1
    p1 = std::move(p2);                              // 移动赋值，同样不增加引用计数

---

• shared_ptr 引用计数增加的情况
  • (1) 拷贝构造

    shared_ptr<int> p1 = std::make_shared<int>(42);  // 引用计数为 1
    shared_ptr<int> p2(p1);                          // 引用计数为 2
    shared_ptr<int> p3 = p1;                         // 引用计数为 3

  • (2) 拷贝赋值

    shared_ptr<int> p1 = std::make_shared<int>(10);  // 引用计数为 1
    shared_ptr<int> p2 = std::make_shared<int>(20);  // 引用计数为 1
    p2 = p1;                                         // p2 改为指向 p1 的对象，p2 指向原对象的引用计数从 1 减少到 0，释放资源
                                                     // p1 指向的对象引用计数从 1 增加到 2

  • (3) 从 weak_ptr 构造 shared_ptr

    shared_ptr<int> sp = std::make_shared<int>(5);
    std::weak_ptr<int> wp = sp;           // 不影响引用计数
    
    shared_ptr<int> sp2 = wp.lock();                 // 成功时返回 shared_ptr，引用计数加 1
    if (sp2) {
        // sp2 有效，原对象引用计数变为 2
    }

  • (4) 智能指针作为函数的形参（按值传递）

    // 注意：如果这里的形参是引用（按引用传递），那么智能指针的引用计数不会增加
    void func(shared_ptr<int> sp) {
    
    }
    
    shared_ptr<int> sp = make_shared<int>(100);  // 引用计数为 1
    func(sp);                                    // 引用计数为 2

  • (5) 智能指针作为函数的返回值

    std::shared_ptr<int> create() {
        shared_ptr<int> sp = std::make_shared<int>(50);  // 引用计数为 1
        return sp;                                       // 返回时可能移动或拷贝，但不一定增加引用计数
    }
    
    shared_ptr<int> sp = create();  // 通常会使用移动语义，引用计数保持 1
                                    // 但如果编译器没有优化，可能会临时增加引用计数到 2

  • (6) 容器操作（拷贝元素）

    std::vector<std::shared_ptr<int>> vec;
    shared_ptr<int> sp = std::make_shared<int>(10);     // 引用计数为 1
    vec.push_back(sp);                                  // 拷贝到容器，引用计数为 2
    vec.insert(vec.begin(), sp);                        // 再次拷贝到容器，引用计数为 3

引用计数减少

• shared_ptr 引用计数减少的说明
  • 当引用计数减少到 0 时，shared_ptr 会：
    • (1) 调用删除器释放管理的对象
    • (2) 释放控制块（如果没有 weak_ptr 指向它）
  • 移动操作：移动构造 / 移动赋值不会减少原对象的引用计数，只是转移所有权

    shared_ptr<int> p1 = std::make_shared<int>(42);    // 引用计数为 1
    shared_ptr<int> p2 = std::move(p1);                // 移动后 p1 变为空指针，但 p1 原来的引用计数不变（转移而非减少）

  • weak_ptr 不会影响引用计数，但 weak_ptr 可以延长控制块的生存时间

    shared_ptr<int> sp = std::make_shared<int>(10);
    std::weak_ptr<int> wp = sp;  // 不影响引用计数
    sp.reset();                  // 引用计数从 1 减到 0，对象销毁
                                 // 但控制块仍存在，直到 wp 也销毁

---

• shared_ptr 引用计数减少的情况
  • (1) 智能指针对象被销毁

    void func() {
        shared_ptr<int> p = std::make_shared<int>(42);  // 引用计数 = 1
        // ...
    } // 离开作用域，p 被销毁，引用计数减为 0，释放资源

  • (2) 智能指针指向新的对象

    shared_ptr<int> sp = make_shared<int>(100);  // 引用计数为 1
    shared_ptr<int> sp2 = sp;                    // 引用计数为 2
    sp = make_shared<int>(200);                  // sp 指向新对象，sp 指向的原对象的引用计数减为 1

  • (3) 智能指针的 reset() 方法被调用

    shared_ptr<int> p = std::make_shared<int>(10);     // 引用计数为 1
    p.reset();                                         // 引用计数为 0，释放资源
    p.reset(new int(20));                              // 先减原引用计数，再管理新资源

  • (4) 容器中移除或替换元素

    std::vector<std::shared_ptr<int>> vec;
    vec.push_back(std::make_shared<int>(1));    // 引用计数为 1
    vec.push_back(std::make_shared<int>(2));  
    vec.erase(vec.begin());                     // 第一个元素引用计数减 1
    vec[0] = std::make_shared<int>(3);          // 第二个元素引用计数减 1

shared_ptr 的常用操作

use_count()

• use_count()：返回有多少个智能指针指向某个对象，主要用于代码调试目的

shared_ptr<int> sp = make_shared<int>(100);
int count1 = sp.use_count();
cout << count1 << endl;  // 输出 1

shared_ptr<int> sp2(sp);
int count2 = sp.use_count();
cout << count2 << endl;  // 输出 2

shared_ptr<int> sp3;
sp3 = sp;
int count3 = sp.use_count();
cout << count3 << endl;  // 输出 3

unique()

• unique()：判断该智能指针是否独占某个指向的对象，也就是如果只有一个智能指针指向某个对象，那么 unique() 会返回 1，否则返回 0

shared_ptr<int> sp = make_shared<int>(100);
cout << sp.unique() << endl;  // 输出 1，表示 true

shared_ptr<int> sp2(sp);
cout << sp.unique() << endl;  // 输出 0，表示 false

reset()

• reset()：用于改变或释放 shared_ptr 所管理的对象

  • reset() 不带参数：
    • 唯一指向时：若当前 shared_ptr 是唯一指向所管理对象的智能指针（即引用计数为 1），则释放原对象的内存，然后将当前 shared_ptr 置为空指针
    • 非唯一指向时：若有多个 shared_ptr 共享同一个对象（引用计数 > 1），则不释放原对象的内存，仅将原对象的引用计数减 1，然后将当前 shared_ptr 置为空指针
    • 无论是哪种情况，调用 reset() 后，当前 shared_ptr 都会变为空指针（nullptr）
  • reset(newPtr) 带参数：
    • 唯一指向时：若当前 shared_ptr 是唯一指向所管理对象的智能指针（即引用计数为 1），则释放原对象的内存，然后将当前 shared_ptr 指向新对象（newPtr）
    • 非唯一指向时：若有多个 shared_ptr 共享同一个对象（引用计数 > 1），则不释放原对象的内存，仅将原对象的引用计数减 1，然后将当前 shared_ptr 指向新对象（newPtr）
    • 无论是哪种情况，原对象的引用计数都会减少 1（唯一指向时减到 0 则释放原对象的内存，非唯一指向时仅减 1 不释放原对象内存），然后将当前 shared_ptr 转而管理新对象（newPtr）
    • 注意：参数 newPtr 是裸指针（通过 new 得到的原始指针），另外还有两个参数的重载版本 reset(newPtr, deleter)，用于替换并指定自定义删除器
  • 如果 reset() 抛出异常（如自定义删除器在释放内存时抛出异常），原对象保持原样（强异常保证）

• (1) 代码案例一

shared_ptr<int> sp = make_shared<int>(100);
shared_ptr<int> sp2 = sp;  // 引用计数为 2
sp.reset();                // 非唯一指向时：不释放原对象的内存，引用计数减为 1，sp 置空，此时 sp2 仍有效
sp2.reset();               // 唯一指向时：释放原对象的内存，引用计数减为 0，sp2 置空

• (2) 代码案例二

auto p1 = std::make_shared<int>(100);  // 对象 A
auto p2 = p1;                          // 对象 A，引用计数为 2

// 情况1：非唯一指向
p1.reset(new int(200));  // 对象 A 的引用计数减为 1（不释放原对象内存），p1 现在指向新对象 B(200)，此时 p2 仍指向原对象 A(100) 且有效

auto p3 = std::make_shared<int>(300);  // 对象 C，引用计数为 1

// 情况2：唯一指向
p3.reset(new int(400));  // 对象 C 的引用计数减为 0（释放原对象内存），p3 现在指向新对象 D(400)

• (3) 代码案例三

shared_ptr<int> sp;       // 空指针
sp.reset(new int(100));   // 空指针也可以通过 reset() 来初始化

* 解引用

• 通过 * 获取 shared_ptr 所指向的对象

shared_ptr<int> sp = make_shared<int>(100);
cout << *sp << endl;  // 输出 100

get()

• get()：返回 shared_ptr 存储的裸指针（通过 new 得到的原始指针）
  • shared_ptr 返回的裸指针，千万不要手动 delete，否则会导致程序运行崩溃（未定义行为）
  • 注意：如果 shared_ptr 释放了所指向对象的内存，那么 get() 返回的裸指针也会变得无效

shared_ptr<int> sp = make_shared<int>(100);
int *p = sp.get();
*p = 150;
cout << *p << endl;  // 输出 150

swap()

• swap()：用于交换两个 shared_ptr 所指向的对象

shared_ptr<int> sp = make_shared<int>(100);
shared_ptr<int> sp2 = make_shared<int>(300);
sp.swap(sp2);

cout << *sp << endl;   // 输出 300
cout << *sp2 << endl;  // 输出 100

= nullptr

• = nullptr
  • 唯一指向时：若当前 shared_ptr 是唯一指向所管理对象的智能指针（即引用计数为 1），则释放原对象的内存，然后将当前 shared_ptr 置为空指针
  • 非唯一指向时：若有多个 shared_ptr 共享同一个对象（引用计数 > 1），则不释放原对象的内存，仅将原对象的引用计数减 1，然后将当前 shared_ptr 置为空指针
  • 无论是哪种情况，执行 = nullptr 后，当前 shared_ptr 都会变为空指针（nullptr）

shared_ptr<int> sp = make_shared<int>(100);
shared_ptr<int> sp2 = sp;  // 引用计数为 2
sp = nullptr;              // 非唯一指向时：不释放原对象的内存，引用计数减为 1，sp 置空，此时 sp2 仍有效
sp2 = nullptr;             // 唯一指向时：释放原对象的内存，引用计数减为 0，sp2 置空

shared_ptr 的删除器

自定义删除器

• shared_ptr 会在一定的时机自动删除所指向的对象，并且底层使用 delete 操作符作为默认的资源析构方式

• shared_ptr 还支持指定自定义的删除器来取代 C++ 编译器提供的默认删除器

• (1) 代码案例一

void myDeleter(int *p) {
    delete p;
    p = nullptr;
}

// 这里不能使用 make_shared，因为它不支持自定义删除器
shared_ptr<int> sp(new int(100), myDeleter);
sp.reset();  // 唯一指向时：释放原对象的内存（会调用自定义删除器），引用计数减为 0，sp 置空

• (2) 代码案例二

// 自定义的删除器还可以是 Lambda 表达式
shared_ptr<int> sp(new int(100), [](int *p) {
    delete p;
    p = nullptr;
    cout << "delete int *" << endl;
});

make_shared 不支持自定义删除器的原因

• 设计目的：make_shared 是为了一次分配内存（控制块和对象内存在一起）和异常安全，而自定义删除器通常用于管理非 new 分配的资源，比如文件句柄、自定义释放逻辑（动态数组）等
• 类型推导问题：删除器的类型会改变 shared_ptr 的类型签名，而 make_shared 无法推断这种类型信息
• 语义清晰：需要自定义删除器说明资源不是普通方式分配的，此时使用 new 显式创建对象更符合意图

使用数组的问题

如果 shared_ptr 指向的是数组，那么就需要自定义删除器或者特殊语法，否则 C++ 编译器不会使用 delete [] 正确释放数组的内存，而是默认使用 delete 导致内存泄漏

// 自定义类（带自定义的析构函数）
class MyClass {
public:
    MyClass() {
    }
    ~MyClass() {
        cout << "~MyClass()" << endl;
    }
};

// 解决使用数组的问题
int main() {
    // 如果 shared_ptr 指向的是数组，那么就需要自定义删除器，否则不会使用 delete [] 正确释放数组的内存
    shared_ptr<MyClass> sp(new MyClass[3], [](MyClass *p) {
        delete[] p;
        cout << "delete MyClass []" << endl;
    });
}

程序运行输出的结果如下：

~MyClass()
~MyClass()
~MyClass()
delete MyClass []

除了上面通过函数或者 Lambda 表达式作为自定义删除器来释放数组内存，还可以使用 std::default_delete 来做删除器，std::default_delete 是标准库（STL）里的模板类，同样可以正确释放数组的内存

// 自定义类（带自定义的析构函数）
class MyClass {
public:
    MyClass() {
    }
    ~MyClass() {
        cout << "~MyClass()" << endl;
    }
};

// 解决使用数组的问题
int main() {
    // 如果 shared_ptr 指向的是数组，还可以使用 default_delete 来正确释放数组的内存
    shared_ptr<MyClass> sp(new MyClass[3], default_delete<MyClass[]>());
}

程序运行输出的结果如下：

~MyClass()
~MyClass()
~MyClass()

如果实在不想通过自定义删除器或者 std::default_delete 来正确释放数组的内存，还可以使用数组特化版本 shared_ptr<T[]>，同样可以正确释放数组内存（从 C++ 17 开始支持以下写法）

class MyClass {
public:
    MyClass() {
    }
    ~MyClass() {
        cout << "~MyClass()" << endl;
    }
};

// 解决使用数组的问题
int main() {
    // 从 C++ 17 开始正式支持以下写法，使用数组特化版本 shared_ptr<T[]>，同样可以正确释放数组内存
    shared_ptr<MyClass[]> sp2(new MyClass[3]);
}

程序运行输出的结果如下：

~MyClass()
~MyClass()
~MyClass()

同样的，还可以封装一个函数模板来正确释放数组内存

class MyClass {
public:
    MyClass() {
    }
    ~MyClass() {
        cout << "~MyClass()" << endl;
    }
};

// 函数模板
template <typename T>
shared_ptr<T> make_shared_array(size_t size) {
    return shared_ptr<T>(new T[size], default_delete<T[]>());
}

// 解决使用数组的问题
int main() {
    // 调用自定义的函数模板
    shared_ptr<MyClass> sp = make_shared_array<MyClass>(3);
}

程序运行输出的结果如下：

~MyClass()
~MyClass()
~MyClass()

同一种类型的说明

特别注意

如果两个 shared_ptr 指定了不同的删除器，只要它们所指向的对象类型是相同的，那么这两个 shared_ptr 也属于同一种类型。这就代表只要类型相同，就可以将它们放入到元素类型为该对象类型的容器里面。

int main() {
    auto lambda1 = [](int *p) {
        delete p;
        cout << "delete by lambda1" << endl;
    };

    auto lambda2 = [](int *p) {
        delete p;
        cout << "delete by lambda2" << endl;
    };

    shared_ptr<int> p1(new int(100), lambda1);

    shared_ptr<int> p2(new int(200), lambda2);

    // 类型相同，就可以放入到元素类型为该对象类型的容器里面
    // vector<shared_ptr<int>> vec{p1, p2};

    p2 = p1;  // p2 先调用 lambda2 释放自己所指向的对象，然后 p2 重新指向 p1 所指向的对象，此时 p1 所指向对象的引用计数为 2
              // 当作用域结束后，最终还会调用 lambda1 释放 p1、p2 共同指向的对象
}

程序运行输出的结果如下：

delete by lambda2
delete by lambda1

shared_ptr 的使用陷阱

裸指针与智能指针混合使用

将一个裸指针绑定到一个 shared_ptr 之后，那内存管理的责任就应该交给 shared_ptr 了，这个时候就不能够再通过裸指针来访问 shared_ptr 所指向的内存。简而言之，在 C++ 中应该尽量避免同时使用裸指针和智能指针（如 shared_ptr）。

• 错误使用案例

#include <iostream>
#include <memory>

using namespace std;

void proc(shared_ptr<int> sp) {
    return;
}

int main() {
    int *p = new int(100);     // 裸指针
    proc(shared_ptr<int>(p));  // 使用 shared_ptr 临时对象作为函数参数
    *p = 45;                   // 错误写法（存在未定义行为），因为 proc() 执行结束后，p 指向的内存已经被 shared_ptr 临时对象释放掉
    return 0;
}

• 正确使用案例

#include <iostream>
#include <memory>

using namespace std;

void proc(shared_ptr<int> sp) {
    return;
}

int main() {
    shared_ptr<int> sp = make_shared<int>(100);  // 定义 shared_ptr 变量，避免使用裸指针
    proc(sp);                                    // 直接传递 shared_ptr 变量，而不是临时对象
    *sp = 45;                                    // 可以更改 shared_ptr 所指向的对象，不会出现未定义行为
    return 0;
}

使用裸指针初始化多个智能指针

C++ 禁止使用同一个裸指针初始化多个独立的 shared_ptr，核心原因是避免重复释放内存。每个 shared_ptr 都有自己的控制块，如果从同一个裸指针分别创建，它们会互不知情，导致析构时对同一块内存释放两次，造成未定义行为。正确的做法是先创建一个 shared_ptr，然后用它拷贝构造其他 shared_ptr，这样它们才能共享同一个控制块和引用计数。

• 错误使用案例

#include <iostream>
#include <memory>

using namespace std;

int main() {
    int * p = new int(100);
    shared_ptr<int> sp1(p);
    shared_ptr<int> sp2(p);
    return 0;
    // 离开作用域后，p 指向的内存会被 delete 两次（因为 sp1 与 sp2 的引用计数是互相独立的，没有任何关联关系），导致程序运行崩溃
}

• 正确使用案例

#include <iostream>
#include <memory>

using namespace std;

int main() {
    shared_ptr<int> sp1 = make_shared<int>(100);  // 避免使用裸指针
    shared_ptr<int> sp2(sp1);                     // 使用拷贝构造
    return 0;
}

谨慎使用 get () 返回的裸指针

在 C++ 中，需要谨慎使用 shared_ptr 的 get() 返回的裸指针，是因为这个裸指针不参与引用计数管理。如果你 delete 这个裸指针，会导致原始内存被释放，但 shared_ptr 仍认为它拥有这块内存，最终在析构时会再次尝试释放，造成重复释放内存的未定义行为。此外，如果用这个裸指针去初始化另一个 shared_ptr，也会造成独立的控制块，同样导致重复释放内存。get() 返回的裸指针仅适合用于那些不转移所有权、不延长生命周期的只读访问场景。

• 错误使用案例

#include <iostream>
#include <memory>

using namespace std;

int main() {
    shared_ptr<int> sp = make_shared<int>(100);
    int *p = sp.get();
    shared_ptr<int> sp2(p);  // 错误写法，不能将 get() 返回的裸指针绑定到其他 shared_ptr，否则会重复释放内存，导致程序运行崩溃
    delete p;                // 错误写法，不能将 get() 返回的裸指针 delete 掉，否则会重复释放内存，导致程序运行崩溃
}

• 正确使用案例

#include <iostream>
#include <memory>

using namespace std;

int main() {
    shared_ptr<int> sp = make_shared<int>(100);
    int *p = sp.get();
    // 作用域结束后，p 指向的内存会被 shared_ptr 自动释放掉
}

不要将 this 作为 shared_ptr 返回

在 C++ 中，将 this（类对象指针）作为 shared_ptr 返回是危险的，因为 this 本质上是一个原始指针，用它直接构造 shared_ptr 会创建一个独立于现有引用计数体系的新控制块。这会导致同一个对象被多个相互不知晓的 shared_ptr 管理，从而在析构时引发重复释放内存（Double Free）的未定义行为。正确的做法是让类继承自 enable_shared_from_this，然后通过 shared_from_this() 返回安全的智能指针。

• 错误使用案例

class MyClass {
public:
    shared_ptr<MyClass> getSelf() {
        return shared_ptr<MyClass>(this);  // 错误写法（危险操作）
    }
};

shared_ptr<MyClass> p1 = make_shared<MyClass>();
shared_ptr<MyClass> p2 = p1->getSelf();  // p1 和 p2 独立管理同一对象（不共享引用计数），会导致重复释放内存

• 正确使用案例

class MyClass : public enable_shared_from_this<MyClass> {
public:
    shared_ptr<MyClass> getSelf() {
        return shared_from_this();  // 安全
    }
};

shared_ptr<MyClass> p1 = make_shared<MyClass>();
shared_ptr<MyClass> p2 = p1->getSelf();  // p1, p2 共享引用计数，不会导致重复释放内存

应避免 shared_ptr 发生循环引用

在 C++ 中，循环引用是指两个或多个 shared_ptr 互相持有对方的引用，导致每个对象的引用计数始终无法降为零，从而永远不会被自动析构，造成内存泄漏。这是因为 shared_ptr 基于引用计数机制工作，只有当计数变为零时才会释放对象，而循环引用使得每个对象至少还被一个其他对象强引用着。解决方法是使用 weak_ptr 来打破循环：将其中一个方向的引用改为弱引用，weak_ptr 不会增加引用计数，因此不影响对象的生命周期。当需要访问弱引用所指向的对象时，可以临时将其提升为 shared_ptr，若对象仍存在则操作成功，否则说明对象已被释放。

• 错误使用案例

class CB;

class CA {
public:
    shared_ptr<CB> m_cb;
    ~CA() {
        cout << "~CA()" << endl;
    }
};

class CB {
public:
    shared_ptr<CA> m_ca;
    ~CB() {
        cout << "~CB()" << endl;
    }
};

int main() {
    shared_ptr<CA> sp_ca = make_shared<CA>();
    shared_ptr<CB> sp_cb = make_shared<CB>();
    sp_ca->m_cb = sp_cb;
    sp_cb->m_ca = sp_ca;
    // 离开作用域后，由于存在循环引用，CA 和 CB 的对象都不会自动析构（释放内存），导致内存泄漏
}

• 正确使用案例

class CB;

class CA {
public:
    shared_ptr<CB> m_cb;
    ~CA() {
        cout << "~CA()" << endl;
    }
};

class CB {
public:
    weak_ptr<CA> m_ca;  // 使用 weak_ptr 打破循环引用
    ~CB() {
        cout << "~CB()" << endl;
    }
};

int main() {
    shared_ptr<CA> sp_ca = make_shared<CA>();
    shared_ptr<CB> sp_cb = make_shared<CB>();
    sp_ca->m_cb = sp_cb;
    sp_cb->m_ca = sp_ca;
    // 离开作用域后，由于不存在循环引用，CA 和 CB 的对象都会自动析构（释放内存），不会导致内存泄漏
}

shared_ptr 的性能分析

shared_ptr 的指针大小

在 C++ 中，weak_ptr 和 shared_ptr 的大小是一样的，是裸指针（通过 new 得到的指针）大小的两倍；其中包括两个指针（如下图所示），第一个是指向 T 类型对象的指针，第二个是指向控制块的指针。

int *p;
shared_ptr<int> sp;
int length1 = sizeof(p);   // 8 个字节（64 位系统）
int length2 = sizeof(sp);  // 16 个字节（64 位系统）

提示

控制块是由第一个指向某个对象的 shared_ptr 创建的。

shared_ptr 的移动语义

shared_ptr<int> sp = make_shared<int>(100);
shared_ptr<int> sp2 = (move(sp));  // 移动构造一个新的 shared_ptr 对象 sp2
cout << sp2.use_count() << endl;   // sp 不再指向原对象（置为空），但原对象的引用计数仍然是 1

shared_ptr<int> sp3;
sp3 = move(sp2);                  // 移动赋值
cout << sp3.use_count() << endl;  // sp2 不再指向原对象（置为空），但原对象的引用计数仍然是 1

note

对于 shared_ptr，移动构造函数的效率高过拷贝构造函数，移动赋值运算符的效率高过拷贝赋值运算符，因为拷贝需要增加引用计数，而移动语义不需要增加引用计数。

线程安全问题的解决

使用智能指针（如 shared_ptr）后，可以解决在多个线程同时访问同一个对象（共享对象）时产生的线程安全问题，详细介绍可以看 这里。