Chapter 1

6.4 C and T Classes
We've already seen that the naming convention for classes has been chosen to indicate
their main cleanup properties. So far, I've described the cleanup-related properties of C
classes. I'll briefly review them, and then reintroduce T classes, which are quite similar.
C classes are derived from CBase and allocated on the heap. They must, therefore, be
cleaned up when they are no longer needed. Most C classes have a destructor.
C classes are referred to by a pointer – a member variable of some class that owns it, a
member variable of a class that uses it, or an automatic variable.
If a C class is referred to only by a single automatic, in a function that might leave, then the
pointer should be pushed to the cleanup stack.
CBase offers just two things to any C class:
� Zero initialization, so that all member pointers and handles are initially zero, which is
cleanup safe.
� A virtual destructor, so that CBase-derived objects can be properly destroyed from the
cleanup stack.
By contrast, T types are defined as classes or built-in types that don't need a destructor.
They don't need one because they own no data. Examples of T types are as follows:
� Any built-in type: these are given typedefs such as TInt for an unsigned integer.
� Any enumerated type, such as TAmPm, which indicates whether a formatted time of day
is am or pm. All enumerations are Ts, though enumerated constants such as EAm or
EPm begin with E.
� Class types that do not need a destructor, such as TBuf (a buffer for a maximum
of 40 characters) or TPtrC (a pointer to a string of any number of characters). TPtrC
contains a pointer, but it only uses (rather than has) the characters it points to, and so it
does not need a destructor.
Important T classes do not own any data, so they don't need a destructor.
However, they may have pointers, provided that these are uses-a
pointers rather than has-a pointers, like TPtrC's string data
pointer.
T types are normally allocated as automatics, or as member variables of any other kind of
class.
It's possible (but rare) to allocate T class objects explicitly on the heap. If so, you need to
ensure that the heap cell is freed. You can push a T to the cleanup stack using code like
this:
TDes* name = new(ELeave) TBuf; // TDes is a base of TBuf
CleanupStack::PushL(name);
DoSomethingL();
CleanupStack::PopAndDestroy(name)
This invokes CleanupStack::PushL(TAny*). When something pushed as a TAny* is
popped and destroyed, its memory is deallocated, but no destructor is called.
Important
If you forget to derive a C class from CBase, it will be pushed as a