Because characteristics shared by different classes are factored into shared base classes, one of the benefits of classes is code reuse through inheritance. Each class that derives from the base class inherits the parent's structure and behavior. Derived classes represent increasingly specialized entities founded on more abstract or general base classes.

The ability to derive new classes from existing classes makes it possible to extend the capabilities of any part of Taligent's system software. If a CommonPoint class does exactly what an application requires for a particular purpose, the programmer can use it as is. If it does some but not all of what's needed, the programmer can derive a new class from the existing one and add new data structures and actions to extend its capabilities.

For example, suppose you want to create a scrolling window. You can derive a new class called TScrollingWindow from the TWindow class, a process called subclassing. Figure 9 shows how this works.

The new TScrollingWindow class inherits all the characteristics of TWindow. This means you start with (reuse) all the same data members and member functions and just add the new ones you need or replace the ones whose behavior you want to change. Inheritance relationships like this allow many different classes to share common characteristics. Two new data members, scrollX and scrollY, represent the horizontal and vertical scroll positions, which indicate what part of the content should be drawn inside the window. A new member function called DrawScrollbars draws the scroll bars, including the position of each scroll bar's "thumb" (the small box that moves up and down or left and right inside a scroll bar), which depends on the values of scrollX and scrollY. Finally, you need to replace the original TWindow DrawSelf member function with a new DrawSelf function that draws a scrolling window.

The new DrawSelf function calls DrawFrame as before to draw the basic window, then calls the new DrawScrollbars member function to add the scroll bars, then calls the original DrawContents, but with slightly different arguments. The new arguments reflect both the reduced content area due to making room for the scroll bars and the shift in the contents indicated by the current values of scrollX and scrollY.

In the programming language C++, the class from which a new class is derived by subclassing is called a base class, and the new class derived from a base class is called a derived class.

In C++, a function that can be overridden as shown in Figure 10 is called a virtual function, because it can (but need not) be replaced. If a base class provides no default implementation for a function, it is called a pure virtual function, because it's really just a "stub" or placeholder that can't be used as is and must therefore be overridden with an implementation provided by the programmer.

Figure 11 shows how OOP addresses this kind of situation, which requires a form of inheritance called multiple inheritance.

TScrollingDrawingWindow inherits characteristics of TScrollingWindow, which in turn inherits characteristics of TWindow. These three classes represent the main branch of the inheritance hierarchy for TScrollingDrawingWindow. But TScrollingDrawingWindow also "mixes in" the characteristics of the class MMouseTracker with the characteristics it inherits from TScrollingWindow, thus providing its own hybrid capabilities. Classes such as MMouseTracker that are designed for this purpose are called mixin classes.

TScrollingDrawingWindow uses the capabilities inherited from MMouseTracker to keep track of the location of the mouse and overrides the DrawContents member function inherited from TScrollingWindow (which was in turn inherited from TWindow) to draw lines when the mouse button is down. TScrollingDrawingWindow inherits all the other scrolling and drawing capabilities of TScrollingWindow without changing them.