一、概述

std::shared_ptr 是通过指针保持对象共享所有权的智能指针。多个 shared_ptr 对象可占有同一对象。下列情况之一出现时销毁对象并解除这个指针指向的分配内存：

• 最后剩下的占有对象的 shared_ptr 被销毁；
• 最后剩下的占有对象的 shared_ptr 被通过 operator= 或 reset() 赋值为另一指针。

用 delete 表达式或在构造期间提供给 shared_ptr 的定制删除器销毁对象。

shared_ptr 能在存储指向一个对象的指针时共享另一对象的所有权。此特性能用于在占有其所属对象时，指向成员对象。存储的指针为 get() 、解引用及比较运算符所访问。被管理指针是在 use_count 抵达零时传递给删除器者。

shared_ptr 亦可不占有对象，该情况下称它为空 (empty) （空 shared_ptr 可拥有非空存储指针，若以别名使用构造函数创建它）。

shared_ptr 的所有特化满足可复制构造 (CopyConstructible) 、可复制赋值 (CopyAssignable) 和可小于比较 (LessThanComparable) 的要求并可按语境转换为 bool 。

多个线程能在 shared_ptr 的不同实例上调用所有成员函数（包含复制构造函数与复制赋值）而不附加同步，即使这些实例是副本，且共享同一对象的所有权。若多个执行线程访问同一 shared_ptr 而不同步，且任一线程使用 shared_ptr 的非 const 成员函数，则将出现数据竞争；原子函数的 shared_ptr 特化能用于避免数据竞争。

#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>struct Base
{Base() { std::cout << "  Base::Base()\n"; }// 注意：此处非虚析构函数 OK~Base() { std::cout << "  Base::~Base()\n"; }
};struct Derived: public Base
{Derived() { std::cout << "  Derived::Derived()\n"; }~Derived() { std::cout << "  Derived::~Derived()\n"; }
};void thr(std::shared_ptr<Base> p)
{std::this_thread::sleep_for(std::chrono::seconds(1));std::shared_ptr<Base> lp = p; // 线程安全，虽然自增共享的 use_count{static std::mutex io_mutex;std::lock_guard<std::mutex> lk(io_mutex);std::cout << "local pointer in a thread:\n"<< "  lp.get() = " << lp.get()<< ", lp.use_count() = " << lp.use_count() << '\n';}
}int main()
{std::shared_ptr<Base> p = std::make_shared<Derived>();std::cout << "Created a shared Derived (as a pointer to Base)\n"<< "  p.get() = " << p.get()<< ", p.use_count() = " << p.use_count() << '\n';std::thread t1(thr, p), t2(thr, p), t3(thr, p);p.reset(); // 从 main 释放所有权std::cout << "Shared ownership between 3 threads and released\n"<< "ownership from main:\n"<< "  p.get() = " << p.get()<< ", p.use_count() = " << p.use_count() << '\n';t1.join(); t2.join(); t3.join();std::cout << "All threads completed, the last one deleted Derived\n";
}
//输出：Base::Base()Derived::Derived()
Created a shared Derived (as a pointer to Base)p.get() = 0x2299b30, p.use_count() = 1
Shared ownership between 3 threads and released
ownership from main:p.get() = 0, p.use_count() = 0
local pointer in a thread:lp.get() = 0x2299b30, lp.use_count() = 5
local pointer in a thread:lp.get() = 0x2299b30, lp.use_count() = 3
local pointer in a thread:lp.get() = 0x2299b30, lp.use_count() = 2Derived::~Derived()Base::~Base()
All threads completed, the last one deleted Derived

二、成员函数

1. 构造函数

2. 析构函数

~shared_ptr();

若 *this 占有对象且它是最后一个占有该对象的 shared_ptr ，则通过占有的删除器销毁对象。

析构后，与 *this 共享所有权的智能指针若存在，则报告比先前值少一的 use_count() 。

不同于 std::unique_ptr ，即使被管理指针为空也调用 std::shared_ptr 的删除器。

#include <memory>
#include <iostream>struct S {S() { std::cout << "S::S()\n"; }~S() { std::cout << "S::~S()\n"; }struct Deleter {void operator()(S* s) const {std::cout << "S::Deleter()\n";delete s;}};
};int main()
{auto sp = std::shared_ptr<S>{ new S, S::Deleter{} };auto use_count = [&sp](char c) {std::cout << c << ") use_count(): " << sp.use_count() << '\n';};use_count('A');{auto sp2 = sp;use_count('B');{auto sp3 = sp;use_count('C');}use_count('D');}use_count('E');sp.reset();use_count('F');
}/*
因为用 {} 括起来的语句其实就是一个函数栈，可以看成一个函数，执行完就会被销毁掉
因此 use_count() 的个数才会变化
*/
//输出：S::S()
A) use_count(): 1
B) use_count(): 2
C) use_count(): 3
D) use_count(): 2
E) use_count(): 1
S::Deleter()
S::~S()
F) use_count(): 0

3. 修改器

1. reset

void reset() noexcept; (1)template< class Y >
void reset( Y* ptr ); (2)template< class Y, class Deleter >
void reset( Y* ptr, Deleter d ); (3)template< class Y, class Deleter, class Alloc >
void reset( Y* ptr, Deleter d, Alloc alloc ); (4)

以 ptr 所指向的对象替换被管理对象。能可选地提供删除器 d ，之后在无 shared_ptr 对象占有该对象时以之销毁新对象。默认以 delete 表达式为删除器。始终选择对应提供类型的 delete 表达式，这是函数以使用分离的形参 Y 的模板实现的理由。

若 *this 已占有对象，且它是最后一个占有该对象的 shared_ptr ，则通过所占有的删除器销毁对象。

若 ptr 所指向的对象已被占有，则函数通常会导致未定义行为。

1. 释放被管理对象的所有权，若存在。调用后， *this 不管理对象。等价于 shared_ptr().swap(*this); 。

2-4) 以 ptr 所指向对象替换被管理对象。 Y 必须是完整类型且可隐式转换为 T 。另外：

2. 以 delete 表达式为删除器。合法的 delete 表达式必须可用，即 delete ptr 必须为良式，拥有良好定义行为且不抛任何异常。等价于 shared_ptr(ptr).swap(*this); 。

3. 以指定的删除器 d 为删除器。 Deleter 必须对 T 类型可调用，即 d(ptr)必须为良构，拥有良好定义行为且不抛任何异常。 Deleter 必须可复制构造 (CopyConstructible) ，且其复制构造函数和析构函数必须不抛异常。等价于 shared_ptr(ptr, d).swap(*this); 。

4. 同 (3) ，但额外地用 alloc 的副本分配内部使用的数据。 Alloc 必须是分配器 (Allocator) 。复制构造函数和析构函数必须不抛异常。等价于 shared_ptr(ptr, d, alloc).swap(*this); 。

#include <memory>
#include <iostream>struct Foo {Foo(int n = 0) noexcept : bar(n) {std::cout << "Foo: constructor, bar = " << bar << '\n';}~Foo() {std::cout << "Foo: destructor, bar = " << bar << '\n';}int getBar() const noexcept { return bar; }
private:int bar;
};int main()
{std::shared_ptr<Foo> sptr = std::make_shared<Foo>(1);std::cout << "The first Foo's bar is " << sptr->getBar() << "\n";// 重置，交与新的 Foo 实例// （此调用后将销毁旧实例）sptr.reset(new Foo);std::cout << "The second Foo's bar is " << sptr->getBar() << "\n";
}
// 输出：Foo: constructor, bar = 1
The first Foo's bar is 1
Foo: constructor, bar = 0
Foo: destructor, bar = 1
The second Foo's bar is 0
Foo: destructor, bar = 0

2. swap

void swap( shared_ptr& r ) noexcept;

交换 *this 与 r 的存储指针值与所有权。不调整引用计数，若它们存在。

4. 观察器

1. get

T* get() const noexcept;  (C++17 前) 

存储的指针。

shared_ptr 可能在存储指向一个对象的指针时共享另一对象的所有权。 get() 返回存储的指针，而非被管理指针。

#include <iostream>
#include <memory>
#include <string_view>void output(std::string_view msg, int const* pInt)
{std::cout << msg << *pInt << "\n";
}int main()
{int* pInt = new int(42);std::shared_ptr<int> pShared = std::make_shared<int>(42);output("Naked pointer ", pInt);// output("Shared pointer ", pShared); // 编译错误output("Shared pointer with get() ", pShared.get());delete pInt;
}// 输出：
Naked pointer 42
Shared pointer with get() 42

2. use_count

long use_count() const noexcept;

返回管理当前对象的不同 shared_ptr 实例（包含 this ）数量。若无管理对象，则返回 ​0​ 。

多线程环境下， use_count 返回的值是近似的（典型实现使用 memory_order_relaxed 加载）

注意

常用使用包括

• 与 ​0​ 比较。若 use_count 返回零，则智能指针为空且不管理对象（无论被存储指针是否为空）。多线程环境下，这不隐含被管理对象的析构函数已完成。
• 与 1 比较。若 use_count 返回 1 ，则无其他拥有者。（被弃用成员函数 unique() 为此使用情况提供。）多线程环境中，这不隐含对象可以安全修改，因为先前拥有者对被管理对象的访问可能未完成，而因为新的共享拥有者可以同时引入，例如用 std::weak_ptr::lock 。

#include <memory> 
#include <iostream> void fun(std::shared_ptr<int> sp)
{std::cout << "fun: sp.use_count() == " << sp.use_count() << '\n'; 
}int main() 
{ auto sp1 = std::make_shared<int>(5);std::cout << "sp1.use_count() == " << sp1.use_count() << '\n'; fun(sp1);
}//输出：
sp1.use_count() == 1
fun: sp.use_count() == 2

3. operator bool

explicit operator bool() const noexcept;

检查 *this 是否存储非空指针，即是否有 get() != nullptr 。

注意：空 shared_ptr （其中 use_count() == 0 ）可能存储能以 get() 访问的非空指针，例如若它以别名使用构造函数创建。

#include <iostream>
#include <memory>void report(std::shared_ptr<int> ptr) 
{if (ptr) {std::cout << "*ptr=" << *ptr << "\n";} else {std::cout << "ptr is not a valid pointer.\n";}
}int main()
{std::shared_ptr<int> ptr;report(ptr);ptr = std::make_shared<int>(7);report(ptr);
}//输出：
ptr is not a valid pointer.
*ptr=7