C++ for Scientists - Technische Universität Dresden

110 CHAPTER 4. GENERIC PROGRAMMING
};
T data[Size] ;
If you compare this implementation with the implementation in Section 4.3 on page 95 you
realize that there not so many differences.
The essential difference is that the size is now part of the type and that the compiler knows it.
Let us start with the latter. The compiler can use its knowlegde for optimization. For instance,
if we create a variable
fsize vector v(w);
the compiler can decide that the generated code for the copy constructor is not performed in a
loop but as a sequence of independent operations like:
fsize vector( const self& that )
{
data[0]= that.data[0];
data[1]= that.data[1];
data[2]= that.data[2];
}
This saves the incrementation of the counter and the test for the loop end. In some sense,
this test is already performed at compile time. As a rule of thumb, the more is known during
compilation the more potential for optimization exist. We will come back to this in more detail
in Section 8.2 and Chapter ??.
Which optimization is induced by additional compile-time information is of course compilerdependent.
One can only find out which transformation is actually done by reading the generated
assembler code — what is not that easy, especially with high optimization and with low
optimization the effect will probably not be there — or indirectly by observing performance and
comparing it with other implementations. In the example above, the compiler will probably
unroll the loop as shown for small sizes like 3 and keep the loop for larger sizes say 100. You
see, why this compile-time sizes are particularly interesting for small matrices and vectors, e.g.
three-dimensional coordinates or rotations.
Another benefit of knowning the size at compile time is that we can store the values in an array
and even inside the class. Then the values of temporary objects are stored on the stack and not
on the heap. 19 The creation and destruction is much less expensive because only the change of
the program counter at function begin and end needs to adapted to the objects size compared
to dynamic memory allocation on the heap that involves the management of lists to keep track
of allocated and free memory blocks. 20 To make a long story short, keeping the data in small
arrays is much less expensive than dynamic allocation.
We said that the size becomes part of the type. The careful reader might have realized that we
omitted the checks whether the vectors have the same size. We do not need them anymore. If
an argument has the class type, it implicitly has the same size. Consider the following program
snippet:
fsize vector v;
fsize vector w;
19 TODO: Picture.
20 TODO: Need easier or longer explication. or citation.