...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
boost::signals2::deconstruct — Create a shared_ptr
with support for post-constructors and pre-destructors.
// In header: <boost/signals2/deconstruct.hpp> template<typename T> postconstructor_invoker<T> deconstruct(); template<typename T, typename A1> postconstructor_invoker<T> deconstruct(const A1 & arg1); template<typename T, typename A1, typename A2> postconstructor_invoker<T> deconstruct(const A1 & arg1, const A2 & arg2); template<typename T, typename A1, typename A2, ..., typename AN> postconstructor_invoker<T> deconstruct(const A1 & arg1, const A2 & arg2, ..., const AN & argN);
Creates an object and its owning shared_ptr<T>
(wrapped inside a postconstructor_invoker
)
using only a single allocation,
in a manner similar
to that of boost::make_shared()
. In addition, deconstruct
supports postconstructors and predestructors. The returned
shared_ptr
is wrapped inside a postconstructor_invoker
in order to provide the user with an opportunity to pass arguments to a postconstructor,
while insuring the postconstructor is run before the wrapped
shared_ptr
is accessible.
In order to use deconstruct
you must define a postconstructor for your class.
More specifically, you must define
an adl_postconstruct
function which can be found via argument-dependent
lookup. Typically, this means defining an adl_postconstruct
function
in the same namespace as its associated class. See the reference for
postconstructor_invoker
for a specification of what arguments are passed to the adl_postconstruct
call.
Optionally, you may define a predestructor for your class. This is done by
defining an adl_predestruct
function which may be found
by argument-dependent lookup. The deleter of the shared_ptr
created by deconstruct
will make an unqualified call to
adl_predestruct
with a single
argument: a pointer to the object which is about to be deleted.
As a convenience, the pointer will always be cast to point to a non-const type
before being passed to adl_predestruct
.
If no user-defined adl_predestruct
function is found via
argument-dependent lookup, a default function (which does nothing) will
be used. After adl_predestruct
is called, the deleter
will delete the object with
checked_delete
.
Any arguments passed to a
deconstruct()
call are forwarded to the matching constructor of the
template type
T
. Arguments may also be passed to the class' associated
adl_postconstruct
function by using the
postconstructor_invoker::postconstruct()
methods.
Notes: |
If your compiler supports the C++0x features of rvalue references
and variadic templates, then template< typename T, typename... Args > postconstructor_invoker< T > deconstruct( Args && ... args ); Otherwise, argument forwarding is performed via const references, as specified in the synopsis. In order to pass non-const references to a constructor, you will need to wrap them in reference wrappers using boost::ref. You may give all the |
Returns: |
A |