Chapter 1

delete iObject6;
}
We didn't use the cleanup stack here because iObject6 is a member variable. The
important thing about the code above is that nothing can leave between the
CleanupStack::Pop(), and the assignment of the CZ* to iObject6.
If we want to refer to the new CZ from an automatic variable, then we need the cleanup stack
throughout the lifetime of the CZ. We could use the NewL() above and then push the object
to the cleanup stack on return, but that would be wasteful. Instead, we use a static
NewLC()function that operates like NewL() but doesn't pop the object from the cleanup
stack before returning:
CZ* CZ::NewLC()
{
CZ* self = new(ELeave) CZ;
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
This allocates the new CZ and, if all goes well, leaves it on the cleanup stack – that's what
the C in NewLC() stands for. If anything fails, the function leaves and everything is cleaned
up.
This is used from Use 7, whose handler is
case EMagicCmdUse7:
{
CZ* z = CZ::NewLC();
z->iX->UseL();
CleanupStack::PopAndDestroy(z);
}
This is very convenient, but it's not necessary to use NewL() and NewLC() in every class. If
your class is a one-off class, designed for use only in your application, then it's a waste to
code NewL()-type functions, and it's easy enough to code new followed by ConstructL()
in the one place where your application constructs an instance of this class. For classes
designed for frequent reuse, the case for encapsulating construction in NewL()-type
functions is more compelling.
For classes with more than one C++ constructor such as application documents that may
construct either a blank document, or a document loaded in from file, there is a very strong
case to wrap up the various construction sequences in distinct NewL()-type functions.
During development, you sometimes change your mind about things like this and equip a
class with NewL()-type functions, or occasionally even remove them. The presence or
absence of these convenience functions is not a fundamental property of a class, which is
probably why it's not reflected in a naming convention.