Re: Making a smart pointer which works with incomplete types
On Sep 7, 11:45 am, Juha Nieminen <nos...@thanks.invalid> wrote:
Lance Diduck wrote:
Most shared_ptr implementations will use ECBO for the deleter. i.e.
template<class T,class D>
In this case the user would have to always provide a deleter for the
smart pointer because it has no default value. This can be burdensome
and a nuisance. It should be made optional.
struct shared_ptr_imp:D{
T* data;
unsigned refcount;
void decrementReferenceCount()
{
if(data)
{
// decrement reference count and then:
if(<refcount == 0>)
{
this->D::operator()(data);//exapanded t=
o see whats
really happening
If D is a template class, that line instantiates the D::operator()
function. If that function calls the destructor of 'data', it will
require for T to be a complete type.
}
}
}
};
In the vast majority of cases, D is something like
template<class T>
struct DeleteMe{
void operator()(T* d){delete d;}
Which is exactly the problem: DeleteMe::operator() cannot properly
destroy 'd' if T is an incomplete type (it cannot call its destructor).
That's exactly what the deleter function pointer trick solves: Rather
than performing a 'delete' in the destructor of the smart pointer, what
it does is that it simply calls the deleter function through the
pointer.
There has been a long standing feature in C++ called "virtual
desstructor" that exacly solves this problem in this same way.i.e.
struct Incomplete{
virtual void foo()=0;
virtual ~Incomplete(){}
};
struct Complete:Incomplete{
void foo(){}
};
Incomplete * i=new Complete;
delete i;//does not require Complete type
That last line is resolved at runtime to be:
i->~Complete();
Complete::operator delete(dynamic_cast<void*>( i));
So I am unclear on why you may want to do this manually in a smart
pointer?