C++ for Scientists - Technische Universität Dresden

212 CHAPTER 7. EFFECTIVE PROGRAMMING: THE POLYMORPHIC WAY
7.5 From Monomorphic to Polymorphic Behavior
As presented in the last sections, each programming techique (or paradigm) offers different key
benefits regarding effective programming. The imperative programming, the related procedural
paradigm, and the object-related programming are simple and require that all calls to an object
or function have exactly the same typing as the signature. So type checks and type constraints
can be derived directly from the program text. But the effectivness (genericity and applicability)
is greatly reduced for real world problems. This is in contrast to polymorphic code that freely
operates only on abstract concept types. Polymorphic behavior enables the use of algorithms
and data structures with several different types. The object-oriented, generic, and functional
programming offer an additional mechanism which delays the actual type instantiation to a
later evaluation point. Compared to the simple monomorphic way, the polymorphic mechanism
is composed of a complex set of inference rules, because there is propagation of type information
between the object and function signature and the call signature in both directions.
In object-oriented programming, libraries typically specify that the types supplied to the library
must be derived from a common abstract base class, providing implementa- tions for a collection
of pure virtual functions. The library knows only about the abstract base class interface,
but can be extendedto work with new user types derived from the abstract interface. That is,
variability is achieved through differing implementations of the virtual functions in the derived
classes. This is how object-oriented programming supports modules that are closed for modification,
yet remain open for extension. One strength of this paradigm is its support for varying
the types supplied to a module at runtime. Composability of modules is limited, however,
since independently produced modules generally do not agree on common abstract interfaces
from which supplied types must inherit. The paradigm of generic programming, pioneered by
Stepanov, Musser and their collaborators, is based on the principle of decomposing software into
efficient components which make only minimal assumptions about other components, allowing
maximum flexibility in composition. C++ libraries developed following the generic programming
paradigm typically rely on templates for the parametric and ad- hoc polymorphism they
offer. Composability is enhanced as use of a library does not require inheriting from a particular
abstract interface. Interfaces of library components are specified using concept collections of
requirements analogous to, say, Haskell type classes. The key difference to abstract base classes
and inheritance is that a type can be made to satisfy the constraints of a concept retroactively,
independently of the definition of the type. Also, generic programming strives to make algorithms
fully generic, while remaining as efficient as non-generic hand-written algorithms. Such
an approach is not possible when the cost of any customization is a virtual function call.
The strength of polymorphism is that the same piece of code can operate on different types,
even types that are not known at the time the code was written. Such applicability is the
cornerstone of polymorphism because it amplifies the usefulness and reusability of code. If
the types of poymorphism are analysed in more detail, then two different main types can be
observed:
• Ad-hoc polymorphism
• Universal polymorphism
Only the second type, universal polymorphism, is actually important for effective programming,
where the first type, ad-hoc polymorphism, is rather convenience.