std::shared_ptr＜void＞的工作原理，接管任意对象类并自动调用其析构函数-白红宇

std::shared_ptr＜void＞的工作原理，接管任意对象类并自动调用其析构函数

阅读量：393 次

发布时间：2019-03-05

本文共 2829 字，大约阅读时间需要 9 分钟。

前戏

先抛出两个问题

如果delete一个指针，但是它真实的类型和指针类型不一样会发生什么？

是谁调用了析构函数？

下面这段代码会发生什么有趣的事情？

// delete_diff_type.cpp#include 
   
    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 = reinterpret_cast
    
     (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 
   
    using namespace std;class Foo{
   public:    Foo() {
    cout << "Foo()" << endl; }    ~Foo() {
    cout << "~Foo()" << endl; }};int main(int argc, const char * argv[]) {
       shared_ptr
    
      vptr = shared_ptr
     
      (new Foo);    return 0;}

输出：

Foo()~Foo()

与第一段代码中类似，不过把void*换成了std::shared_ptr<void>，shared_ptr<void>能够调用到正确的析构函数。

原因参考https://blog.csdn.net/weixin_30633405/article/details/99586195。

一句话，任何类对象资源都可以被std::shared_ptr<void>接管，并且在离开其作用域，会自动调用其析构函数。

虚析构函数与shared_ptr的火花

首先，将FakeFoo改写为继承自Foo类

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

下面代码运行结果为

Foo* fptr = new FakeFoo();delete fptr;{
   std::shared_ptr
   
     sp1= std::make_shared
    
     ();}{
   std::shared_ptr
     
       spv= std::make_shared
      
       ();}

运行结果

Foo()FakeFoo()~Foo()Foo()FakeFoo()~FakeFoo()~Foo()Foo()FakeFoo()~FakeFoo()~Foo()

对比发现，用了shared_ptr以后带来的一个额外好处就是即便你的析构函数忘记写成virtual也能帮你正确的调用析构函数。

尽管有了该好处，但Effective C++ 条款07建议“要为多态基类声明 virtual 析构函数”在平时使用还是需要遵守的。

线程池、任务队列中，可以使用std::shared_ptr<void>封装任务。

你可能感兴趣的文章