C++ OOP Design

Extensibility
With play( )defined as virtual in the base class, you can add as 
many new types as you want without changing the tune( )
function. In a well-designed OOP program, most or all of your 
functions will follow the model of tune( )and communicate only 
with the base-class interface. Such a program is extensible because 
you can add new functionality by inheriting new data types from 
the common base class. The functions that manipulate the base class interface will not need to be changed at all to accommodate 

the new classes. 

You’ve seen in this chapter that it’s impossible to understand, or 
even create, an example of polymorphism without using data 
abstraction and inheritance. Polymorphism is a feature that cannot 
be viewed in isolation (like constor a switchstatement, for 
example), but instead works only in concert, as part of a “big 
picture” of class relationships. People are often confused by other, 
non-object-oriented features of C++, like overloading and default 
arguments, which are sometimes presented as object-oriented. 
Don’t be fooled; if it isn’t late binding, it isn’t polymorphism. 

Choosing composition vs. inheritance
Both composition and inheritance place subobjects inside your new 
class. Both use the constructor initializer list to construct these 
subobjects. You may now be wondering what the difference is 
between the two, and when to choose one over the other. 
Composition is generally used when you want the features of an 
existing class inside your new class, but not its interface. That is, 
you embed an object to implement features of your new class, but 
the user of your new class sees the interface you’ve defined rather 
than the interface from the original class. To do this, you follow the 
typical path of embedding private objects of existing classes inside 
your new class. 
Occasionally, however, it makes sense to allow the class user to 
directly access the composition of your new class, that is, to make 
the member objects public. The member objects use access control 
themselves, so this is a safe thing to do and when the user knows 
you’re assembling a bunch of parts, it makes the interface easier to 
understand.

From<thinking in C++>