boost共享指针构造函数析构函数

Question

以下代码

struct Base
{
  public:
  Base()
  {
    std::cout<<"Base Ctr";
  }

  ~Base()
  {
    std::cout<<"Base Dtr";
  }
};

struct Derived : Base
{
  Derived()
  {
    std::cout<<"Derived Ctr";
  }

  ~Base()
  {
    std::cout<<"Derived Dtr";
  }
};

int main()
{
  Base* b = new Derived;
  delete b;
}

给我以下输出:

Base Ctr
Derived Ctr
Base Dtr

解决方案是使基础析构函数成为虚拟的.

但是,当我使用没有虚拟基础析构函数的boost智能指针时.我得到了不同的输出.

int main()
{
  boost::shared_ptr<Base> b = boost::make_shared<Derived>();
}

输出是

 Base Ctr
 Derived Ctr
 Derived Dtr
 Base Dtr

boost shared_ptr如何在不影响(我假设)Base和Derived类的情况下实现此目的.
它如何根据多级继承进行扩展,即基于dervderv的基点,其中dervderv是从derv继承的.

编辑:

大多数答案告诉我,"魔法"发生在make_shared中.但是,我对以下代码获得了相同的行为

boost::shared_ptr<Base> ptr(new Derived);  

Answer 1

使用普通函数指针实现的解决方案：

#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <typeinfo>

using namespace std;

struct Base{

  Base(){
    cout<<"Base ctor."<<endl;
  }

  ~Base(){
    cout<<"Base dtor."<<endl;
  }

};

struct Derv: Base{

  Derv():Base(){
    cout<<"Derv ctor."<<endl;
  }

  ~Derv(){
    cout<<"Derv dtor."<<endl;
  }

};

typedef void (*DEL)(void*);

template<typename U>
void deleter(void* ptr)
{
  delete static_cast<U*>(ptr);
}

template<typename T>
struct SmartPtr{

  T* memPtr;

  DEL func;

  template<typename U>
    SmartPtr(U* p):
      memPtr(p)
  {
    func = deleter<U>;
  }

  ~SmartPtr(){

      func(memPtr);
  }
};
int main()
{
  //case 1
  SmartPtr<Base> ptrSmart1(new Derv());

  //case 2
  SmartPtr<Base> ptrSmart2(new Base());

  //case 3
  SmartPtr<Derv> ptrSmart3(new Derv());

  return 0;
}