Re: Making a smart pointer which works with incomplete types
* Juha Nieminen:
Alf P. Steinbach wrote:
* Juha Nieminen:
Alf P. Steinbach wrote:
<code file="x.cpp">
#include "sp.h"
class X;
X* newX();
void deleteX( X* );
int main()
{
SmartPtr<X, deleteX> p( newX() );
}
</code>
Here you require a "deleteX" function to be implemented by the user
alongside the X class,
No.
Yes you do. Your deleter template parameter is not optional.
It is: that's what the "=" syntax does.
and you require this "deleteX" function to be
given as template parameter to the smart pointer.
No. Well, yes, for this example code. But that's how example code goes,
it sort of needs to be concrete if it is to be any good to those who
don't understand.
Then show us
Hm, "us"... :-) Is that the royal "we"? He he (u get as good as u give).
the code which:
a) Doesn't require the user to explicitly define a deleter function for
each type.
Provide a default. TR1's OK. Sort of. But also see below.
b) Is able to properly delete the object based on an incomplete type.
(The smart pointer can require for the type to be complete at construction.)
I think I didn't grok what you meant here earlier.
For if you can arrange for complete type at construction, then it's difficult
for me to see how you can not just as easily arrange for complete type at
destruction, e.g., for PIMPL idiom, just give that outer type a user defined
destructor -- just an empty one.
And voil? (if not for darned formal requirements this technique can be used to
use std::auto_ptr for PIMPL, and some say also in *spite* of formal
requirements! ;-) ).
Of course that works like that, but it's burdensome for the user to
have to do that for every single type he uses with the smart pointer.
The smart pointer ought to create such a function automatically to ease
the user's task, which is the whole point.
To shave off one line of user code per class, for a relative rare case, you
think that approach with static pointer is a good idea?
It might of course be complexity of that single line you're reacting to, that it
would be more difficult to understand than subtlety of smart pointer class.
Then how about this line, always the same, no complexity, just copy n' paste:
#include "sp.hpp"
in the file where you have the "type to be complete at construction"?
<code file="sp.h" comment="as before, just *removed* a few things! :-)">
#ifndef SP_H
#define SP_H
template< typename T >
void destroy( T* );
template< typename T >
class SmartPtr
{
private:
T* myReferent;
SmartPtr( SmartPtr const& );
SmartPtr& operator=( SmartPtr const& );
public:
SmartPtr( T* p );
~SmartPtr() { destroy( myReferent ); }
};
#endif
</code>
<code file="sp.hpp">
#ifndef SP_HPP
#define SP_HPP
#include "sp.h"
template< typename T >
void destroy( T* p ) { delete p; }
template< typename T >
SmartPtr<T>::SmartPtr( T* p ): myReferent( p )
{
destroy<T>( 0 );
}
#endif
</code>
And usage e.g. like this:
<code file="foo.h">
#ifndef FOO_H
#define FOO_H
#include "sp.h"
class Foo
{
public:
class Impl;
Foo();
//~Foo();
private:
SmartPtr<Impl> myImpl;
};
#endif
</code>
<code file="foo.cpp">
#include "foo.h"
#include "sp.hpp"
#include <iostream>
using namespace std;
class Foo::Impl
{
public:
Impl() { cout << "Impl::<init>" << endl; }
~Impl() { cout << "Impl::<destroy>" << endl; }
};
Foo::Foo(): myImpl( new Impl ) {}
//Foo::~Foo() {}
</code>
If the smart pointer can do that then AFAICS you're content to assume a
trivial destructor for the incomplete type, in which case you don't need
any special smart pointer type -- any will do.
I showed how to do it in my original post, and you don't need to
restrict yourself to trivial destructors.
Cheers & hth.,
- Alf
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?