Smart
pointer programming techniquesSmart
pointer programming techniques
Using incomplete classes for implementation hiding
The "Pimpl" idiom
Using abstract classes for implementation hiding
Preventing delete px.get()
Using a shared_ptr to hold a pointer to an array
Encapsulating allocation details, wrapping factory
functions
Using a shared_ptr to hold a pointer to a statically allocated
object
Using a shared_ptr to hold a pointer to a COM object
Using a shared_ptr to hold a pointer to an object with an
embedded reference count
Using a shared_ptr to hold another shared ownership smart
pointer
Obtaining a shared_ptr from a raw pointer
Obtaining a shared_ptr (weak_ptr) to this in a
constructor
Obtaining a shared_ptr to this
Using shared_ptr as a smart counted handle
Using shared_ptr to execute code on block exit
Using shared_ptr<void> to hold an arbitrary object
Associating arbitrary data with heterogeneous shared_ptr
instances
Post-constructors and pre-destructors
Using shared_ptr as a CopyConstructible mutex lock
Using shared_ptr to wrap member function calls
Delayed deallocation
Weak pointers to objects not managed by a shared_ptr
[Old, proven technique; can be used in C]
class FILE; FILE * fopen(char const * name, char const * mode); void fread(FILE * f, void * data, size_t size); void fclose(FILE * f);
[Compare with]
class FILE; shared_ptr<FILE> fopen(char const * name, char const * mode); void fread(shared_ptr<FILE> f, void * data, size_t size);
Note that there is no fclose function; shared_ptr's ability to execute a custom deleter makes it unnecessary.
[shared_ptr<X> can be copied and destroyed when X is incomplete.]
[...]
// file.hpp:
class file
{
private:
class impl;
shared_ptr<impl> pimpl_;
public:
file(char const * name, char const * mode);
// compiler generated members are fine and useful
void read(void * data, size_t size);
};
// file.cpp:
#include "file.hpp"
class file::impl
{
private:
impl(impl const &);
impl & operator=(impl const &);
// private data
public:
impl(char const * name, char const * mode) { ... }
~impl() { ... }
void read(void * data, size_t size) { ... }
};
file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
{
}
void file::read(void * data, size_t size)
{
pimpl_->read(data, size);
}
[file is CopyConstructible and Assignable.]
[Interface based programming]
// X.hpp:
class X
{
public:
virtual void f() = 0;
virtual void g() = 0;
protected:
~X() {}
};
shared_ptr<X> createX();
-- X.cpp:
class X_impl: public X
{
private:
X_impl(X_impl const &);
X_impl & operator=(X_impl const &);
public:
virtual void f()
{
// ...
}
virtual void g()
{
// ...
}
};
shared_ptr<X> createX()
{
shared_ptr<X> px(new X_impl);
return px;
}
[Note protected and nonvirtual destructor; client cannot delete X; shared_ptr correctly calls ~X_impl even when nonvirtual.]
delete px.get()[Alternative 1, use the above.]
[Alternative 2, use a private deleter:]
class X
{
private:
~X();
class deleter;
friend class deleter;
class deleter
{
public:
void operator()(X * p) { delete p; }
};
public:
static shared_ptr<X> create()
{
shared_ptr<X> px(new X, X::deleter());
return px;
}
};
shared_ptr to hold a pointer to an array[...]
shared_ptr<X> px(new X[1], checked_array_deleter<X>());
[shared_array is preferable, has a better interface; shared_ptr has *, ->, derived to base conversions.]
[Existing interface, possibly allocates X from its own heap, ~X is private, or X is incomplete.]
X * CreateX(); void DestroyX(X *);
[Wrapper:]
shared_ptr<X> createX()
{
shared_ptr<X> px(CreateX(), DestroyX);
}
[Client remains blissfully oblivious of allocation details; doesn't need to remember to call destroyX.]
shared_ptr to hold a pointer to a statically allocated
object[...]
shared_ptr<X> createX();
[Sometimes needs to return a pointer to a statically allocated X instance.]
struct null_deleter
{
void operator()(void const *) const
{
}
};
static X x;
shared_ptr<X> createX()
{
shared_ptr<X> px(&x, null_deleter());
return px;
}
[The same technique works for any object known to outlive the pointer.]
shared_ptr to hold a pointer to a COM Object[COM objects have an embedded reference count, AddRef() and Release(), Release() self-destroys when reference count drops to zero.]
shared_ptr<IWhatever> make_shared_from_COM(IWhatever * p)
{
p->AddRef();
shared_ptr<IWhatever> pw(p, mem_fn(&IWhatever::Release));
return pw;
}
[All pw copies will share a single reference.]
shared_ptr to hold a pointer to an object with an
embedded reference count[A generalization of the above. Example assumes intrusive_ptr-compatible object.]
template<class T> struct intrusive_deleter
{
void operator()(T * p)
{
if(p) intrusive_ptr_release(p);
}
};
shared_ptr<X> make_shared_from_intrusive(X * p)
{
if(p) intrusive_ptr_add_ref(p);
shared_ptr<X> px(p, intrusive_deleter<X>());
return px;
}
shared_ptr to hold another shared ownership smart
pointer[...]
template<class P> class smart_pointer_deleter
{
private:
P p_;
public:
smart_pointer_deleter(P const & p): p_(p)
{
}
void operator()(void const *)
{
p_.reset();
}
};
shared_ptr<X> make_shared_from_another(another_ptr<X> qx)
{
shared_ptr<X> px(qx.get(), smart_pointer_deleter< another_ptr<X> >(qx));
return px;
}
[If p_.reset() can throw - wrap in try {} catch(...) {} block, will release p_ when all weak pointers are eliminated.]
shared_ptr from a raw pointer[...]
void f(X * p)
{
shared_ptr<X> px(???);
}
[Not possible in general, either switch to]
void f(shared_ptr<X> px);
[This transformation can be used for nonvirtual member functions, too; before:]
void X::f(int m);
[after]
void f(shared_ptr<X> this_, int m);
[If f cannot be changed, use knowledge about p's lifetime and allocation details and apply one of the above.]
shared_ptr (weak_ptr) to this in a
constructor[...]
class X
{
public:
X()
{
shared_ptr<X> this_(???);
}
};
[Not possible in general. If X can have automatic or static storage, and this_ doesn't need to keep the object alive,
use a null_deleter. If X is supposed to always live on the heap, and be managed by a shared_ptr, use:]
class X
{
private:
X() { ... }
public:
static shared_ptr<X> create()
{
shared_ptr<X> px(new X);
// use px as 'this_'
return px;
}
};
shared_ptr to this[Sometimes it is needed to obtain a shared_ptr from this in a virtual member function.]
[The transformations from above cannot be applied.]
class X
{
public:
virtual void f() = 0;
protected:
~X() {}
};
class Y
{
public:
virtual shared_ptr<X> getX() = 0;
protected:
~Y() {}
};
// --
class impl: public X, public Y
{
public:
impl() { ... }
virtual void f() { ... }
virtual shared_ptr<X> getX()
{
shared_ptr<X> px(???);
return px;
}
};
[Solution:]
class impl: public X, public Y
{
private:
weak_ptr<impl> weak_this;
impl(impl const &);
impl & operator=(impl const &);
impl() { ... }
public:
static shared_ptr<impl> create()
{
shared_ptr<impl> pi(new impl);
pi->weak_this = pi;
return pi;
}
virtual void f() { ... }
virtual shared_ptr<X> getX()
{
shared_ptr<X> px = get_shared_ptr(weak_this);
return px;
}
};
[Future support planned, impl: public enable_shared_from_this<impl>.]
shared_ptr as a smart counted handle[Win32 API allusion]
typedef void * HANDLE; HANDLE CreateProcess(); void CloseHandle(HANDLE);
[Quick wrapper]
typedef shared_ptr<void> handle;
handle createProcess()
{
shared_ptr<void> pv(CreateProcess(), CloseHandle);
return pv;
}
[Better, typesafe:]
class handle
{
private:
shared_ptr<void> pv_;
public:
explicit handle(HANDLE h): pv_(h, CloseHandle) {}
HANDLE get() { return pv_.get(); }
};
shared_ptr to execute code on block exit[1. Executing f(p), where p is a pointer:]
shared_ptr<void> guard(p, f);
[2. Executing arbitrary code: f(x, y):]
shared_ptr<void> guard(static_cast<void*>(0), bind(f, x, y));
shared_ptr<void> to hold an arbitrary object[...]
shared_ptr<void> pv(new X);
[Will correctly call ~X.]
[Can be used to strip type information: shared_ptr<X> -> (shared_ptr<void>, typeid(X))]
shared_ptr
instances[...]
typedef int Data; std::map< shared_ptr<void>, Data > userData; // or std::map< weak_ptr<void>, Data > userData; to not affect the lifetime shared_ptr<X> px(new X); shared_ptr<int> pi(new int(3)); userData[px] = 42; userData[pi] = 91;
[...]
class X
{
public:
X();
virtual void postconstructor();
virtual void predestructor() throw();
~X() throw();
struct deleter
{
void operator()(X * p)
{
p->predestructor();
delete p;
}
}
static shared_ptr<X> create()
{
shared_ptr<X> px(new X, X::deleter());
px->postconstructor(); // can throw
return px;
}
};
shared_ptr as a CopyConstructible mutex lock[Sometimes it's necessary to return a mutex lock from a function. A noncopyable lock cannot be used.]
class mutex
{
public:
void lock();
void unlock();
};
shared_ptr<mutex> lock(mutex & m)
{
m.lock();
return shared_ptr<mutex>(&m, mem_fn(&mutex::unlock));
}
[Or to encapsulate it in a dedicated class:]
class shared_lock
{
private:
shared_ptr<void> pv;
public:
template<class Mutex> explicit shared_lock(Mutex & m): pv((m.lock(), &m), mem_fn(&Mutex::unlock)) {}
};
[Usage:]
shared_lock lock(m);
[Note that shared_lock is not templated on the mutex type, thanks to shared_ptr<void>'s ability to hide type information.]
shared_ptr to wrap member function calls[http://www.research.att.com/~bs/wrapper.pdf]
template<class T> class pointer
{
private:
T * p_;
public:
explicit pointer(T * p): p_(p)
{
}
shared_ptr<T> operator->() const
{
p_->prefix();
return shared_ptr<T>(p_, mem_fn(&T::suffix));
}
};
class X
{
private:
void prefix();
void suffix();
friend class pointer<X>;
public:
void f();
void g();
};
int main()
{
X x;
pointer<X> px(&x);
px->f();
px->g();
}
[In some situations, a single px.reset() can trigger an expensive deallocation in a performance-critical region.]
class X; // ~X is expensive
class Y
{
shared_ptr<X> px;
public:
void f()
{
px.reset();
}
};
[Solution 1]
vector< shared_ptr<void> > free_list;
class Y
{
shared_ptr<X> px;
public:
void f()
{
free_list.push_back(px);
px.reset();
}
};
// periodically invoke free_list.clear() when convenient
[Solution 2, as above, but use a delayed deleter]
struct delayed_deleter
{
template<class T> void operator()(T * p)
{
try
{
shared_ptr<void> pv(p);
free_list.push_back(pv);
}
catch(...)
{
}
}
};
shared_ptrMake the object hold a shared_ptr to itself, using a null_deleter:
class X
{
private:
shared_ptr<X> this_;
int i_;
public:
explicit X(int i): this_(this, null_deleter()), i_(i)
{
}
// repeat in all constructors (including the copy constructor!)
X(X const & rhs): this_(this, null_deleter()), i_(rhs.i_)
{
}
// do not forget to not assign this_ in the copy assignment
X & operator=(X const & rhs)
{
i_ = rhs.i_;
}
weak_ptr<X> get_weak_ptr() const { return this_; }
};
When the object's lifetime ends, X::this_ will be destroyed, and all weak pointers will automatically expire.
$Date$
Copyright © 2003 Peter Dimov. Permission to copy, use, modify, sell and distribute this document is granted provided this copyright notice appears in all copies. This document is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.