On Nov 29, 2006, at 12:50 PM, Andrew Holden wrote:
I have put together an option based on Andrei Alexandrescu's policy
based design. It may take a little time to read, as I modified a copy
of scoped_ptr.hpp. What I did was add a second template parameter
(called deleter) and inherited scoped_ptr from this.
If instead of inheriting from D, you contain a compressed_pair, you'll get the same size savings and be able to support function
pointers as deleters. With a little more work (in your constructors
mainly) you can support D& types as a deleter.
D& types are really handy for transferring pointer ownership from one
object to another when there is a custom deleter of unknown type. Of
course since you're working with scoped_ptr, perhaps you're not
interested in this use case. But just in case you are:
template
class A
{
...
void foo(T* p);
private:
T* p_;
D deleter_;
...
};
// A::foo establishes ownership of p, but
// must acquire other resources to do so. A local
// unique_ptr is used as an aid to hold on to p while
// those other resources are acquired.
template
void
A::foo(T* p)
{
// Establish preliminary ownership without requiring
// a copy of the deleter D
std::unique_ptr hold(p, deleter_); // no throw
// acquire resources // if throws,
// ... // deleter_(p)
executed
// transfer ownership to A
p_ = hold.release(); // no throw
}
-Howard
