Chapter 1

used in preference to old style C casting, as by doing this you get the benefit of C++ cast
checking. Previous versions of the SDK defined macros that expanded to these keywords,
for compatibility with older versions of GCC that did not support C++ casting. These are now
deprecated – current compilers can use the standard C++ definitions.
3.7 Classes
As you'd expect, classes are used to represent objects, abstractions, and interfaces.
Relationships between classes are used to represent relationships between objects or
abstractions. The most important relationships between classes are the following:
� uses-a: if class A uses-a class B, then A has a member of type B, B&, const B&, B*,
or const B*, or a function that can easily return a B in one of these guises. A can then
use B's member functions and data.
� has-a: has-a is like uses-a, except that A takes responsibility for constructing and
destroying the B as well as using it during its lifetime.
� is-a: if class A is-a class B, then B should be an abstraction of A. is-a relationships are
usually represented in C++ using public derivation.
� implements: if class A implements an interface M, then it implements all M's pure virtual
functions. Interface implementation is the only time multiple inheritance is used in
Symbian OS.
Sometimes, abstract/concrete notions are blurred. CEikDialog is concrete as far as its
implementation of CCoeControl is concerned, but in fact CEikDialog is an essentially
abstract base class for user-specified dialogs or Uikon standard dialogs such as a
CEikInfoDialog. Some classes (such as both CCoeControl and CEikDialog) contain
no pure virtual functions, but are still intended to be derived from. They provide fall-back
functionality for general cases, but it is likely that one or two functions will need to be
overridden to provide a useful class.
3.7.1 Interfaces
Symbian OS makes quite extensive use of interface classes (originally called mixins). An
interface is an abstract base class with no data and only pure virtual functions.
APIs that have both library and framework aspects often define their library aspect by means
of a concrete class and their framework by means of an interface class. To use such an API,
you need to use the concrete class and implement the interface.
The Symbian OS PRINT API provides an example. In addition to library classes to start the
print job, there are framework classes for printing part of a page, and for notifying the
progress of the job to an application. MPrintProcessObserver is the interface for
notifying progress:
class MPrintProcessObserver
{
public:
virtual void NotifyPrintStarted(
TPrintParameters aPrintParams) = 0;
virtual void NotifyBandPrinted(
TInt aPercentageOfPagePrinted,