C++ for Scientists - Technische Universität Dresden

100 CHAPTER 4. GENERIC PROGRAMMING
a new compilation for each combination of types. As a consequence, the sources must reside in
header files and cannot be stored to libraries. 7
Executable size: As mentioned before, generic functions need multiple compilations and
as a result of this, the generated executable contains code for each instatiation. A function
programmed against an abstract interface exist only once. On the other hand, the virtual
functions introduce some additional memory need to store the virtual function tables. Except
for some pathological examples, one can expect that this additional space is less than the extra
space needed for having separate machine code for every instantiation of a generic function. In
extreme cases, a very large executable size can negatively impact the performance due to waste
of cache memory.
Performance: The higher compilation efforts for generic programming has a double performance
benefit. Functions within the multi-functional computations do not need to be called
indirectly via expensive function pointers but can be called directly. Whenever appropriate they
can be even inlined saving the function call overhead entirely. We once measured the impact
of the approaches to the performance of an accumulate function (a more general approach than
in § 4.2.1) [?]. The generic version was in our case about 40 times faster than the inheritancebased
implementation. This value varies from platform to platform but for small functions
one can expect that an inlined template function is 10–100 times faster than virtual functions.
Conversely, for long calculations like solving a large linear system the performance difference is
unperceivable.
Concept refinement: that is adding (syntactic) requirements is feasible with the inheritance
approach but it is very tedious and obfuscates the program source, details in [?].
Intrusiveness: The genericity emulation by inheritance can induce a deep class hierarchy [?],
more critical for the universal applicability is that the technology is intrusive. A type cannot
be used as argument of an OOP implementation if it is not derived from the according class
even if the provides the correct interface! Thus, we have to add additional base class(es) to the
type. This is particularly problematic if we use types from third-party libraries or intrinsic types
because we cannot add base classes their. Generic functions have not such rigid constraints. We
can even adapt a third-party or intrinsic type to meet a generic function’s syntactic requirements
without modifying third-party programs.
Time of selection: At least one advantage of the OOP-style polymorphism we should mention
at the end. The argument type of generic function call must be known at compile time so that
the compiler can instantiate the template function. The type of an OOP function argument can
be chosen during the execution of the program and therefore depend on preceeding calculations
or input data. For instance, one can define in a file which linear solver is used in an application.
Résumé: It is not our goal to compare object-oriented and generic programming in general.
The two approaches complete each other in many respects and this is beyond the scope of this
discussion. However, when only considering the aspect of maximal applicability with optimal
performance the generic approach is undoubtly superior. Especially if functions of a library are
used with types defined outside this library, possibly necessary interface adaption is quite easy
without modifying the type definition while the addition of extra base classes forces changing
the type definition what is not always possible (or desirable). In contexts where functions are
used with limited numbers of types and they are defined in the same library, derivation can be
7 Libraries in the classical sense that are linked with separately compiled sources as opposed to template
libraries.