boost共享指针构造函数析构函数
boost共享指针构造函数析构函数
提问于 2015-06-04 09:15:48
以下代码
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 Dtrboost shared_ptr如何能够在不影响(我假设)基本类和派生类的情况下实现这一点。
它如何为多级继承(即从dervderv继承dervderv的基本点)扩展它。
编辑：
大多数答案告诉我，“魔法”发生在make_shared。但是，对于下面的代码，我得到了相同的行为
boost::shared_ptr<Base> ptr(new Derived); 回答 3
Stack Overflow用户
回答已采纳
发布于 2015-06-04 11:16:46
使用普通函数指针实现的解决方案：
#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;
}Stack Overflow用户
发布于 2015-06-04 09:40:23
简而言之，boost::smart_ptr包含指向对象、引用计数和删除函数的指针，在析构函数中调用该函数，当调用boost::make_shared<Derived>()时，它将创建类Derived的默认构造对象，删除器将指向Derived的析构函数。这对于任何长度的继承链都是有效的，但是在基类中使用虚拟析构函数是必须的。
考虑下一个简化的此类技术的简单示例实现：
#include <iostream>
#include <functional>
using namespace std;
struct Base
{
public:
Base()
{
std::cout<<"Base Ctr ";
}
~Base()
{
std::cout<<"Base Dtr ";
}
};
struct Derived : Base
{
Derived()
{
std::cout<<"Derived Ctr ";
}
Derived(const Derived& d)
{
std::cout<<"Derived copy Ctr ";
}
~Derived()
{
std::cout<<"Derived Dtr ";
}
};
template <typename T>
void default_deleter(T* p) {
delete p;
}
template <typename T>
struct pointer {
pointer(T* p, std::function<void ()> d) : p_(p), deleter_(d) {}
template <typename U>
pointer(pointer<U> other) : p_(new U(*other.p_)),
deleter_(std::bind(&default_deleter<U>, (U*)p_)) {}
template <typename Y>
explicit pointer(Y* p) : p_(p), deleter_(std::bind(&default_deleter<Y>, p)) {}
~pointer() {
deleter_();
}
T* p_;
std::function<void ()> deleter_;
};
template <typename T>
pointer<T> make_pointer() {
T* p = new T;
return pointer<T>(p, std::bind(&default_deleter<T>, p));
}
int main() {
pointer<Base> b = make_pointer<Derived>();
pointer<Base> b2(new Derived);
return 0;
}产出如下：
Base Ctr Derived Ctr Base Ctr Derived copy Ctr Derived Dtr Base Dtr Derived Dtr Base Dtr派生类的析构函数被调用两次，因为指针有两个实例:一个是用make_pointer函数创建的，另一个是主函数。
Stack Overflow用户
发布于 2015-06-04 09:39:43
Boost通过有一个删除函子来实现这一点。默认实现对使用delete创建的类型调用make_shared。
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：
https://stackoverflow.com/questions/30639786
复制相关文章
相似问题
腾讯云开发者
