C++ for Scientists - Technische Universität Dresden

7.2. GENERIC PROGRAMMING 203
7.2 Generic Programming
Generic programming may be viewed as having been developed in order to further facilitate
the goals of code reusability and extensibility. From a general view the generic programming
paradigm is about generalizing software components so that they can be directly reused easily
in a wide variety of situations. While these are among the goals, which lead to the development
of object oriented programming, it may vary quite profoundly in the realization. A major
distinction from object oriented programming, which is focused on data structures and their
states, is that it especially allows for a very abstract and orthogonal description of algorithms.
To achieve this kind of generalization a separation of the basic tools of programming are important:
algorithms, containers (data structures), and a glue between them (so called iterators
or more generally traversors). As introduced as an important part for effective programming,
the minimization of glue code, iterators and traversal objects operate as a minimal but fully
abstract interface between data structures and algorithms.
While the desired functionality is often implemented using static polymorphism mechanisms,
such as templates in C++, generic programming should not be equated with simply programming
with templates. However, when generic programming is realized using purely compile
time facilities such as static polymorphism, not only is implementation effort reduced but the
resulting run time performance optimized.
In the following, the process of generic programming is given by elevating a procedural code to
a generic one simultanioulsy fullfilling the important topics of effective programming (efficiency,
type-safety, code reuse):
• Algorithm: Generic algorithms are generic in two ways. First the data type which they
are operating on is arbitrary and second, the type of container within which the elements
are held is arbitrary.
To get in touch with the generic approach, a generalization of the memcpy() function of the
C standard library is discussed. An implementation of memcpy() might look somewhat
like the following:
void∗ memcpy(void∗ region1, const void∗ region2, size t n)
{
const char∗ first = (const char∗)region2;
const char∗ last = ((const char∗)region2) + n;
char∗ result = (char∗)region1;
while (first != last)
∗result++ = ∗first++;
return result;
}
The memcpy() function is already generalized to some extent by the use of void∗ so that
the function can be used to copy arrays of different kinds of data.
Looking at the body of memcpy(), the function’s minimal requirements are that it needs to
traverse the sequence using some sort of pointer, access the elements pointed to, copy the
elements to the destination, and compare pointers to know when to stop. The memcpy()
function can then be written in a generic manner:
template
OutputIterator