A class template that provides CleanupStack-based local-scope automatic management of pointers.

By default, the cleanup action is to delete the managed pointer using non-array delete. An alternative cleanup strategy may be selected by specifying a cleanup strategy template class in the optional second template parameter position. The most common alternative cleanup strategies are predefined.

The constructors of this class may leave.

As a convenience, the methods of the managed pointer may be accessed via "->" notation directly on the management object, while "." notation is used to access the interface of the management object itself. Using "*" to dereference the management object yields a T&, and is often useful when passing the managed object as an argument.

Automatic cleanup may be disabled at any time by calling Unmanage(), while cleanup may be forced at any time by calling ReleaseResource().

	// block scope example
	{
	LCleanedupPtr<CDynamic> autop(new(ELeave) CDynamic);
	autop->DoSomethingL(); // leave-safe
	if (autop->Finished())
		return; //	the pointer is deleted automatically when exiting from scope
	autop->DoSomethingElseL(); // leave-safe
	//	the pointer is deleted automatically when exiting from scope
	}

Behind the scenes, this class template is implemented in terms of the thread-local CleanupStack, restricting its use to locals on the stack. This use of the CleanupStack ensures a consistent cleanup order between functions that call one another, even if they use different cleanup idioms.

This class template together with the cleanup strategy class templates provide a template-based implementation of the Strategy design pattern (See also: Policy-based design).

TPointerDelete which implements the default deleting cleanup strategy TPointerFree which implements the alternative User::Free() cleanup strategy LManagedPtr which has the same interface, but does not use the cleanup stack and is suitable for protecting the data members of classes