LCleanedupArray Class Reference

The default cleanup strategy is to deallocate the managed array using arrray delete (delete[]), assuming that the array is heap-allocated. An alternative cleanup strategy can be selected by specifying a cleanup strategy template class as the optional second template argument (corresponding to the CleanupStrategy template parameter).

The constructors of this class may leave.

As a convenience, the elements of the managed array may be accessed via "[]" notation directly on the management object.

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
	{
	LCleanedupArray<TValue> arrayp(new(ELeave) TValue[KArraySize]);
	arrayp[0].DoSomethingL(); // leave-safe
	if (arrayp[0].Finished())
		return; //	the array is deleted automatically when exiting from scope
	arrayp[1].DoSomethingElseL(); // leave-safe
	//	the array 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).

See also: LManagedArray which has the same interface, but does not use the cleanup stack and is suitable for protecting the data members of classes