C++ 智能指针 shared_ptr
C++ 智能指针 shared_ptr
最近接触智能指针比较多，对智能指针的使用做下基本的总结。
shared_ptr 是C++11提供的一种智能指针类，本质上是一个类，具有构造函数和析构函数，于是能够自动释放没有指针引用的资源。
其核心实现便是计数。
每个 shared_ptr 对象在内部指向两个内存位置：
1、指向对象的指针。
2、用于控制引用计数数据的指针。
共享所有权如何在参考计数的帮助下工作：
1、当新的 shared_ptr 对象与指针关联时，则在其构造函数中，将与此指针关联的引用计数增加1。
2、当任何 shared_ptr 对象超出作用域时，则在其析构函数中，它将关联指针的引用计数减1。如果引用计数变为0，则表示没有其他 shared_ptr 对象与此内存关联，在这种情况下，它使用delete函数删除该内存。
同时：
(1) 智能指针主要的用途就是方便资源的管理，自动释放没有指针引用的资源。
(2) 使用引用计数来标识是否有多余指针指向该资源。(注意，shart_ptr本身指针会占1个引用)
(3) 在赋值操作中, 原来资源的引用计数会减一，新指向的资源引用计数会加一（计数是在堆上）。
std::shared_ptr<Test> p1(new Test); std::shared_ptr<Test> p2(new Test); p1 = p2;
(4) 引用计数加一/减一操作是原子性的，所以线程安全的。
(5) make_shared要优于使用new，make_shared可以一次将需要内存分配好。
std::shared_ptr<Test> p = std::make_shared<Test>(); std::shared_ptr<Test> p(new Test);
(6) std::shared_ptr的大小是原始指针的两倍，因为它的内部有一个原始指针指向资源，同时有个指针指向引用计数。
(7) 引用计数是分配在动态分配的，std::shared_ptr支持拷贝，新的指针获可以获取前引用计数个数。
示例：
ps：尽量不用使用get函数去获取，可能会出错。
include <iostream> #include <memory> #include <thread> #include <chrono> #include <mutex> struct Test { Test() { std::cout << " Test::Test()\n"; } ~Test() { std::cout << " Test::~Test()\n"; } }; //线程函数 void thr(std::shared_ptr<Test> p) { //线程暂停1s std::this_thread::sleep_for(std::chrono::seconds(1)); //赋值操作, shared_ptr引用计数use_cont加1(c++11中是原子操作) std::shared_ptr<Test> lp = p; { //static变量(单例模式),多线程同步用 static std::mutex io_mutex; //std::lock_guard加锁 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() { //使用make_shared一次分配好需要内存 std::shared_ptr<Test> p = std::make_shared<Test>(); //std::shared_ptr<Test> p(new Test); std::cout << "Created a shared Test\n" << " p.get() = " << p.get() << ", p.use_count() = " << p.use_count() << '\n'; //创建三个线程,t1,t2,t3 //形参作为拷贝, 引用计数也会加1 std::thread t1(thr, p), t2(thr, p), t3(thr, p); 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\n"; return 0; }
详细解释
创建空的 shared_ptr 对象
因为带有参数的 shared_ptr 构造函数是 explicit 类型的，所以不能像这样std::shared_ptr<int> p1 = new int();隐式调用它构造函数。创建新的shared_ptr对象的最佳方法是使用std :: make_shared：
std::shared_ptr<int> p1 = std::make_shared<int>();
std::make_shared 一次性为int对象和用于引用计数的数据都分配了内存，而new操作符只是为int分配了内存。
分离关联的原始指针
要使 shared_ptr 对象取消与相关指针的关联，可以使用reset()函数：
不带参数的reset()：
p1.reset();
它将引用计数减少1，如果引用计数变为0，则删除指针。
带参数的reset()：
p1.reset(new int(34));
在这种情况下，它将在内部指向新指针，因此其引用计数将再次变为1。
使用nullptr重置：
p1 = nullptr;
shared_ptr是一个伪指针
shared_ptr充当普通指针，我们可以将*和->与 shared_ptr 对象一起使用，也可以像其他 shared_ptr 对象一样进行比较;
代码如下
#include <iostream> #include <memory> // 需要包含这个头文件 int main() { // 使用 make_shared 创建空对象 std::shared_ptr<int> p1 = std::make_shared<int>(); *p1 = 78; std::cout << "p1 = " << *p1 << std::endl; // 输出78 // 打印引用个数：1 std::cout << "p1 Reference count = " << p1.use_count() << std::endl; // 第2个 shared_ptr 对象指向同一个指针 std::shared_ptr<int> p2(p1); // 下面两个输出都是：2 std::cout << "p2 Reference count = " << p2.use_count() << std::endl; std::cout << "p1 Reference count = " << p1.use_count() << std::endl; // 比较智能指针，p1 等于 p2 if (p1 == p2) { std::cout << "p1 and p2 are pointing to same pointer\n"; } std::cout<<"Reset p1 "<<std::endl; // 无参数调用reset，无关联指针，引用个数为0 p1.reset(); std::cout << "p1 Reference Count = " << p1.use_count() << std::endl; // 带参数调用reset，引用个数为1 p1.reset(new int(11)); std::cout << "p1 Reference Count = " << p1.use_count() << std::endl; // 把对象重置为NULL，引用计数为0 p1 = nullptr; std::cout << "p1 Reference Count = " << p1.use_count() << std::endl; if (!p1) { std::cout << "p1 is NULL" << std::endl; // 输出 } return 0; }
自定义删除器 Deleter
下面将讨论如何将自定义删除器与 std :: shared_ptr 一起使用。
当 shared_ptr 对象超出范围时，将调用其析构函数。在其析构函数中，它将引用计数减1，如果引用计数的新值为0，则删除关联的原始指针。
析构函数中删除内部原始指针，默认调用的是delete()函数。
delete Pointer;
有些时候在析构函数中，delete函数并不能满足我们的需求，可能还想加其他的处理。
当 shared_ptr 对象指向数组
std::shared_ptr<int> p3(new int[12]);
像这样申请的数组，应该调用delete []释放内存，而shared_ptr析构函数中默认delete并不能满足需求。
给shared_ptr添加自定义删除器
在上面在这种情况下，我们可以将回调函数传递给 shared_ptr 的构造函数，该构造函数将从其析构函数中调用以进行删除，即
// 自定义删除器 void deleter(Sample * x) { std::cout << "DELETER FUNCTION CALLED\n"; delete[] x; } // 构造函数传递自定义删除器指针 std::shared_ptr<Sample> p3(new Sample[12], deleter);
下面看一个完整的示例：
#include <iostream> #include <memory> struct Sample { Sample() { std::cout << "Sample\n"; } ~Sample() { std::cout << "~Sample\n"; } }; void deleter(Sample * x) { std::cout << "Custom Deleter\n"; delete[] x; } int main() { std::shared_ptr<Sample> p3(new Sample[3], deleter); return 0; }
输出： Sample Sample Sample Custom Deleter ~Sample ~Sample ~Sample
使用Lambda 表达式 / 函数对象作为删除器
class Deleter { public: void operator() (Sample * x) { std::cout<<"DELETER FUNCTION CALLED\n"; delete[] x; } }; // 函数对象作为删除器 std::shared_ptr<Sample> p3(new Sample[3], Deleter()); // Lambda表达式作为删除器 std::shared_ptr<Sample> p4(new Sample[3], [](Sample * x){ std::cout<<"DELETER FUNCTION CALLED\n"; delete[] x; });
shared_ptr 相对于普通指针的优缺点
缺少 ++, – – 和 [] 运算符
与普通指针相比，shared_ptr仅提供-> 、*和==运算符，没有+、-、++、--、[]等运算符。
示例：
#include<iostream> #include<memory> struct Sample { void dummyFunction() { std::cout << "dummyFunction" << std::endl; } }; int main() { std::shared_ptr<Sample> ptr = std::make_shared<Sample>(); (*ptr).dummyFunction(); // 正常 ptr->dummyFunction(); // 正常 // ptr[0]->dummyFunction(); // 错误方式 // ptr++; // 错误方式 //ptr--; // 错误方式 std::shared_ptr<Sample> ptr2(ptr); if (ptr == ptr2) // 正常 std::cout << "ptr and ptr2 are equal" << std::endl; return 0; }
NULL检测
当我们创建 shared_ptr 对象而不分配任何值时，它就是空的；普通指针不分配空间的时候相当于一个野指针，指向垃圾空间，且无法判断指向的是否是有用数据。
shared_ptr 检测空值方法
std::shared_ptr<Sample> ptr3; if(!ptr3) std::cout<<"Yes, ptr3 is empty" << std::endl; if(ptr3 == NULL) std::cout<<"ptr3 is empty" << std::endl; if(ptr3 == nullptr) std::cout<<"ptr3 is empty" << std::endl;
创建 shared_ptr 时注意事项
不要使用同一个原始指针构造 shared_ptr
创建多个 shared_ptr 的正常方法是使用一个已存在的shared_ptr 进行创建，而不是使用同一个原始指针进行创建。
示例：
int *num = new int(23); std::shared_ptr<int> p1(num); std::shared_ptr<int> p2(p1); // 正确使用方法 std::shared_ptr<int> p3(num); // 不推荐 std::cout << "p1 Reference = " << p1.use_count() << std::endl; // 输出 2 std::cout << "p2 Reference = " << p2.use_count() << std::endl; // 输出 2 std::cout << "p3 Reference = " << p3.use_count() << std::endl; // 输出 1
假如使用原始指针num创建了p1，又同样方法创建了p3，当p1超出作用域时会调用delete释放num内存，此时num成了悬空指针，当p3超出作用域再次delete的时候就可能会出错。
不要用栈中的指针构造 shared_ptr 对象
shared_ptr 默认的构造函数中使用的是delete来删除关联的指针，所以构造的时候也必须使用new出来的堆空间的指针。
示例：
#include<iostream> #include<memory> int main() { int x = 12; std::shared_ptr<int> ptr(&x); return 0; }
当 shared_ptr 对象超出作用域调用析构函数delete 指针&x时会出错。
建议使用 make_shared
为了避免以上两种情形，建议使用make_shared()<>创建 shared_ptr 对象，而不是使用默认构造函数创建。
std::shared_ptr<int> ptr_1 = make_shared<int>(); std::shared_ptr<int> ptr_2 (ptr_1);
另外不建议使用get()函数获取 shared_ptr 关联的原始指针，因为如果在 shared_ptr 析构之前手动调用了delete函数，同样会导致类似的错误。
再论shared_ptr 的线程安全
虽然我们借shared_ptr 来实现线程安全的对象释放，但是shared_ptr 本身不是100% 线程安全的。它的引用计数本身是安全且无锁的，但对象的读写则不是，因为shared_ptr 有两个数据成员，读写操作不能原子化。根据文档11，shared_ptr 的线程安全级别和内建类型、标准库容器、std::string 一样，即：
一个shared_ptr 对象实体可被多个线程同时读取；
两个shared_ptr 对象实体可以被两个线程同时写入，“析构”算写操作；
如果要从多个线程读写同一个shared_ptr 对象，那么需要加锁。
请注意，以上是shared_ptr 对象本身的线程安全级别，不是它管理的对象的线程安全级别。
要在多个线程中同时访问同一个shared_ptr，正确的做法是用mutex 保护：
MutexLock mutex; // No need for ReaderWriterLock shared_ptr<Foo> globalPtr; // 我们的任务是把globalPtr 安全地传给doit() void doit(const shared_ptr<Foo>& pFoo);
globalPtr 能被多个线程看到，那么它的读写需要加锁。注意我们不必用读写锁，而只用最简单的互斥锁，这是为了性能考虑。因为临界区非常小，用互斥锁也不会阻塞并发读。
为了拷贝globalPtr，需要在读取它的时候加锁，即：
void read() { shared_ptr<Foo> localPtr; { MutexLockGuard lock(mutex); localPtr = globalPtr; // read globalPtr } // use localPtr since here，读写localPtr 也无须加锁 doit(localPtr); }
写入的时候也要加锁：
void write() { shared_ptr<Foo> newPtr(new Foo); // 注意，对象的创建在临界区之外 { MutexLockGuard lock(mutex); globalPtr = newPtr; // write to globalPtr } // use newPtr since here，读写newPtr 无须加锁 doit(newPtr); }
注意到上面的read() 和write() 在临界区之外都没有再访问globalPtr，而是用了一个指向同一Foo 对象的栈上shared_ptr local copy。下面会谈到，只要有这样的local copy 存在，shared_ptr 作为函数参数传递时不必复制，用reference to const 作为参数类型即可。
另外注意到上面的new Foo 是在临界区之外执行的，这种写法通常比在临界区内写globalPtr.reset(new Foo) 要好，因为缩短了临界区长度。如果要销毁对象，我们固然可以在临界区内执行globalPtr.reset()，但是这样往往会让对象析构发生在临界区以内，增加了临界区的长度。
一种改进办法是像上面一样定义一个localPtr，用它在临界区内与globalPtr 交换（swap()），这样能保证把对象的销毁推迟到临界区之外。练习：在write() 函数中，globalPtr = newPtr; 这一句有可能会在临界区内销毁原来globalPtr 指向的Foo 对象，设法将销毁行为移出临界区。
