postconstructor_invoker<T> postconstructor_invoker<T> const A1 & postconstructor_invoker<T> const A1 & const A2 & postconstructor_invoker<T> const A1 & const A2 & ... const AN & Create a shared_ptr with support for post-constructors and pre-destructors. 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. If your compiler supports the C++11 features of rvalue references and variadic templates, then deconstruct will perform perfect forwarding of arguments to the T constructor, using a prototype of: 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 deconstruct overloads access to your class' private and protected constructors by declaring deconstruct_access a friend. Using private constructors in conjunction with deconstruct_access can be useful to ensure your objects are only created by deconstruct, and thus their postconstructors or predestructors will always be called. A postconstructor_invoker<T> owning a newly allocated object of type T. Gives deconstruct access to private/protected constructors. Declaring deconstruct_access a friend to your class will give the deconstruct factory function access to your class' private and protected constructors. Using private constructors in conjunction with deconstruct_access can be useful to ensure postconstructible or predestructible objects are always created properly using deconstruct. const shared_ptr<T> & The conversion operator has the same effect as explicitly calling the postconstruct method with no arguments. const shared_ptr<T> & const shared_ptr<T> & A1 const shared_ptr<T> & A1 A1 const shared_ptr<T> & A1 A1 ... A1 The postconstruct methods make an unqualified call to adl_postconstruct() and then return the shared_ptr which was wrapped inside the postconstructor_invoker object by deconstruct(). The first two arguments passed to the adl_postconstruct() call are always the shared_ptr owning the object created by deconstruct(), followed by a ordinary pointer to the same object. As a convenience, the ordinary pointer will always be cast to point to a non-const type before being passed to adl_postconstruct. The remaining arguments passed to adl_postconstruct are whatever arguments the user may have passed to the postconstruct method. Pass arguments to and run postconstructors for objects created with deconstruct(). Objects of type postconstructor_invoker are returned by calls to the deconstruct() factory function. These objects are intended to either be immediately assigned to a shared_ptr (in which case the class' conversion operator will perform the conversion by calling the postconstruct with no arguments), or to be converted to shared_ptr explicitly by the user calling one of the postconstruct methods.