Chapter 1

When a subsequent PopAndDestroy() happens, this function can only call the destructor
of a CBase-derived object. We have already noted that CBase::operator new() zero
initializes all member variables; now we meet CBase's second important property:
Important
CBase's destructor is a virtual function.
This means that any object derived from CBase can be pushed to the cleanup stack and,
when it is popped and destroyed, its destructor is called (as you would expect).
Important
The cleanup stack and C++ destructors make it very easy for a
programmer to handle cleanup. Use the cleanup stack for objects
pointed to only by C++ automatics. Use the destructor for objects
pointed to by member variables. It just works. You very rarely need to
use TRAP(). The resulting code is easy to write, compact, and efficient.
6.2.7 Two-phase Construction
The cleanup stack is used to hold pointers to heap-based objects so that they can be
cleaned up if a leave occurs. This means that you must have the opportunity to push objects
to the cleanup stack. One key situation in which this would not be possible when using
normal C++ conventions is in between the allocation performed by new, and the invocation
of a C++ constructor that follows the allocation.
This problem requires us to invent a new rule that C++ constructors cannot leave. We also
need a work-around: two-phase construction.
C++ constructors must not leave
Let's see what happens if we allow C++ constructors to leave. memorymagic has a class
called CY that contains a member variable that points to a CX. Using conventional C++
techniques, we allocate the CX from the constructor
class CY : public CBase
{
public:
CY();
public:
~CY();
CX* iX;
};
CY::CY() {
iX = new(ELeave) CX;
}
CY::~CY()
{
delete iX;
}
memorymagic's Use 4 menu item calls cleanup-friendly code, as follows: