C++ for Scientists - Technische Universität Dresden

4.5. INHERITANCE OR GENERICS? 99
For illustration purpose we like to show the conceptualized implementation of a generic sorting
function as used in the library of the concept compiler:
template
requires LessThanComparable
&& CopyAssignable
&& Swappable
&& CopyConstructible
inline void sort(Iter first, Iter last);
If the function is called erroneously, the compiler will detect this directly in the function call
not deep inside its implementation.
4.5 Inheritance or Generics?
In this section we will discuss the commonalities and difference of/between object-oriented
programming (OOP) and generic programming. People that do not know OOP so far will not
learn it in this section. The purpose of this section is to motivate why we pay more attention
to generic than to object-oriented programming in this book. The short answer is performance
and applicability. If this answer is good enough for you, you can skip this section and continue
with the next one. Programmers that are used to OOP and think they can implement the
functionality with inheritance instead of templates should take the time and read this section.
Inheritance and generic programming are similar in the sense that most programming problems
that can be solved by inheritance have a generic alternative solution and vice versa. The
following table summarizes the basic components of inheritance and the corresponding building
blocks of generic programming:
Inheritance Generic Programming
base class concept
derived class model
In the remainder of this section we will discuss the differences between generic programming
and inheritance.
We will focus on functions, but similar arguments hold for templated classes. The advantage
of using a base class reference or pointer as argument type of a function is that we are sure
that all derived classes can be used as argument too, see § ??. 6 Inheritance in C ++ and other
OOP languages is designed in a fashion that a function in a derived class can substitute (hide)
the one in the base class with the identic signature. Thus calling the function for a base class
argument will either use the base class’s implementation or those of the derived class (if the
function is virtual). In both cases we can rely on the existance. We will explain OOP in more
detail in Section ??. Here, we only name advantages and disadvantages of the two approaches
regarding different aspects of programming.
Compile time: With the OOP approach, function is only compiled once. The distinction
between the different calculations is realized at run-time. The generic implementation requires
6 TODO: OOP section is still not written yet.