Re: Making a smart pointer which works with incomplete types
Alf P. Steinbach wrote:
If you make it a mandatory template parameter that's very
inconvenient for the user because he would have to write an explicit
deleter for each single type he uses the smart pointer with. If the
template parameter is optional, it would require a default value. What
would be this default value (and how would it be different from what I
posted)?
A templated function.
And how do you call this templated function from the destructor of the
smart pointer class without requiring for the object type to be complete?
boost::shared_ptr is a horrendously inefficient memory hog. For
example, in a typical 32-bit linux system each instance of
boost::shared_ptr (which doesn't share the allocated object) consumes 56
bytes of memory,
It may be that 56 bytes won't matter where there is a need for this
pointer.
Then by all means use boost::shared_ptr. You'll get many advantages
from it (such as it being thread-safe).
However, there may be other situations where boost::shared_ptr takes
too much memory. Thus boost::shared_ptr is not good for *all* possible
situations.
and all of its operations are slow (for example because
it allocates dynamically the payload data, and all of its operations are
thread-safe, even if no multithreading is done).
Cache.
A cache read is slower than no cache read at all.
[snip]
(In fact, I can't understand why boost::shared_ptr stores a deleter
function pointer in the payload it creates. I see absolutely no reason
why a static function pointer wouldn't work equally well. It would save
4/8 bytes per instance. Not much, but it's free and has no negative
consequences.)
It's just the functionality chosen, having per-pointer deleter, which
allows having two or more shared_ptr<T> with different destruction
behavior.
The problem is that shared_ptr always uses the exact same deleter
function for all the instances of shared_ptr<T>. I can't see any reason
why the pointer to the deleter function must be stored in each instance.