std::shared_ptr<void>的工作原理
前戏
先抛出两个问题
- 如果
delete一个指针，但是它真实的类型和指针类型不一样会发生什么？ - 是谁调用了析构函数？
下面这段代码会发生什么有趣的事情？
// delete_diff_type.cpp #include <iostream> using namespace std; class Foo { public: Foo() { cout << "Foo()" << endl; } ~Foo() { cout << "~Foo()" << endl; } }; class FakeFoo { public: FakeFoo() { cout << "FakeFoo()" << endl; } ~FakeFoo() { cout << "~FakeFoo()" << endl; } }; int main(int argc, const char * argv[]) { void* vptr = new Foo(); delete vptr; // warning // FakeFoo* ffptr = static_cast<FakeFoo*>(new Foo()); // error FakeFoo* ffptr = reinterpret_cast<FakeFoo*>(new Foo()); delete ffptr; Foo* fptr = new Foo(); delete fptr; return 0; } 输出: Foo() Foo() ~FakeFoo() Foo() ~Foo()
看一下汇编代码可以看到main函数主要做了下面这几件事
; symbol stub for: operator new(unsigned long) ; Foo::Foo at delete_diff_type.cpp:8 ; symbol stub for: operator delete(void*) ; symbol stub for: operator new(unsigned long) ; Foo::Foo at delete_diff_type.cpp:8 ; FakeFoo::~FakeFoo at delete_diff_type.cpp:16 ; symbol stub for: operator delete(void*) ; symbol stub for: operator new(unsigned long) ; Foo::Foo at delete_diff_type.cpp:8 ; Foo::~Foo at delete_diff_type.cpp:9 ; symbol stub for: operator delete(void*)
从汇编中可以看出，构造造函数和析构函数是编译器根据指针的类型生成的调用代码。而且编译器是不允许没有继承关系的指针之间进行转换的，void* 是个例外，只要不作死用reinterpret_cast把指针转换成不相关的类型是不会有问题的。
所以上面两个问题大概就有答案了。delete语句会至少产生两个动作，一个是调用指针对应类型的析构函数，然后去调用operator delete释放内存。所以如果delete的指针和其指向的真实类型不一样的时候，编译器只会调用指针类型的析构函数，这也就为什么基类的析构函数需要声明称虚函数才能够保证delete基类指针的时候子类析构函数能够被正确的调用。
operator delete是都会被调用到的，所以指针指向的那块内存是能够“正常的”被释放掉用。
std::shared_ptr<void> 的行为
那么这个跟std::shared_ptr<void> 有什么关系呢？
先看一段代码
#include <iostream> using namespace std; class Foo { public: Foo() { cout << "Foo()" << endl; } ~Foo() { cout << "~Foo()" << endl; } }; int main(int argc, const char * argv[]) { shared_ptr<void> vptr = shared_ptr<Foo>(new Foo); return 0; } 输出： Foo() ~Foo()
与第一段代码中类似，不过把void*换成了std::shared_ptr<void>，那么shared_ptr<void>为什么能够调用到正确的析构函数呢？一定是shared_ptr里面搞了什么鬼。
std::shared_ptr<void> 为啥能正常工作
那么就看看源代码看看到底为啥这货能够工作，下面是libcxx中shared_ptr的部分源码，把关键的部分抠出来了。
/** C1. shared_ptr 构造函数 **/ template<class _Tp> template<class _Yp> shared_ptr<_Tp>::shared_ptr(_Yp* __p, typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) : __ptr_(__p) { unique_ptr<_Yp> __hold(__p); typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, _AllocT > _CntrlBlk; __cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), _AllocT()); __hold.release(); __enable_weak_this(__p, __p); } /** C2. shared_ptr 拷贝构造 **/ template<class _Tp> inline shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) { if (__cntrl_) __cntrl_->__add_shared(); } /** C3. shared_ptr::__cntrl_ 类型 **/ __shared_weak_count* __cntrl_; /** C4. shared_ptr 析构函数 **/ template<class _Tp> shared_ptr<_Tp>::~shared_ptr() { if (__cntrl_) __cntrl_->__release_shared(); } /** C5. __shared_weak_count::__release_shared **/ bool __release_shared() _NOEXCEPT { if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) { __on_zero_shared(); return true; } return false; } /** C6. __shared_ptr_pointer::__release_shared **/ template <class _Tp, class _Dp, class _Alloc> /* 重点 !!! virtual !!! */ void __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT { // __data__ 是 内部工具类__compressed_pair // __data_.first().second()是 deleter // __data_.first().first() 是 shared_ptr<T> 中T类型的指针 __data_.first().second()(__data_.first().first()); __data_.first().second().~_Dp(); } /** C7. default deleter **/ template <class _Tp> struct _LIBCPP_TEMPLATE_VIS default_delete { // ... 此处省略若干行 void operator()(_Tp* __ptr) const _NOEXCEPT { delete __ptr; } };
不要慌，给你慢慢道来。
这个故事简单得说是这样的：
- 每一个shared_ptr 内部有一个control block，里面会存放一个要维护的指针，一个计数，一个删除器(deleter)，一个分配(allocator)。这里我们要关心的是删除器。顾名思义，它是用来删除指针的。
- shared_ptr中的 有一个__cntrl_即control block。字段的类型是__shared_weak_count指针，这个类是一个非模板类。shared_ptr<T>创建的control block的类型是一个类模板template <class _Tp, class _Dp, class _Alloc> __shared_ptr_pointer继承自__shared_weak_count。 见代码C3。
- 当创建一个新的shared_ptr的时候，构建一个新的control block。见代码C1。
- 当一个shared_ptr A赋值或者拷贝构造给另一个shared_ptrB的时候（当然是在类型能够转换的前提下），B会把A的__cntrl_拷一份，同时将其引用加一。注意，这个时候拷贝的是指针，__cntrl_还是指向最初创建的那个对象。见代码C2。
- 当shared_ptr被析构或者重置的时候会调用__cntrl_->__release_shared()。见代码C4。
- __cntrl_->__release_shared()如果发现当前的计数为-1的时候，调用__on_zero_shared()。见代码C5。
- __on_zero_shared是一个虚方法，那么它就会调用到最初创建的__shared_ptr_pointer的实现。
- __shared_ptr_pointer的实现中是有完整的类型和删除器的信息的。见代码C6。
- 默认的删除器很简单的执行了delete __ptr操作，因为类型是已知的所以能够正确的调用到析构函数。见代码C7。
这种实现方式给shared_ptr带来额外好处
Effective C++ 条款07告诉我们“要为多态基类声明 virtual 析构函数”。当然我认为建议依然有效，但是用了shared_ptr以后带来的一个额外好处就是即便你的析构函数忘记写成virtual也能帮你正确的调用析构函数。
