
int factorial(int n) { if (n == 1) return 1; else return n * factorial(n  1); } //factorial(4) == (4*3*2*1) == 24
Factorial with template metaprogramming
template <int N> struct Factorial { enum { value = N * Factorial<N  1>::value }; }; template <> struct Factorial<1> { enum { value = 1 }; }; //Factorial<4>::value == 24
The template metaprogramming solution uses template specialization to provide the ending condition for the recursion.
Now here's the catch: The factorial in the latter case (Factorial<4>::value) is computed at compile time, i.e. when compiling your code. This has the natural consequence that Factorial<x>::value can only be used for x that are known at compile time, e.g. constant numbers or the value returned by sizeof().
Template metaprogramming does have its practical uses even though its syntax looks clumsy. It may be used to create ndimensional vector classes where n is known at compile time. The benefit over a more traditional ndimensional vector is that the loops can be unrolled, resulting in very optimized code.
Consider this example of the addition operator: Traditional ndimensional vector class approach
Vector& operator+=(const Vector& rhs) { for (int i=0; i<dimension; ++i) { value[i] += rhs.value[i]; } return *this; }With template metaprogramming, the loop can be unrolled at compiletime, resulting in code similar to this: Template metaprogramming enhanced ndimensional vector class
Vector<2>& operator+=(const Vector<2>& rhs) { value[0] += rhs.value[0]; value[1] += rhs.value[1]; return *this; }Note that it results in code like that, but is not programmed like that. But it demonstrates that the loop is gone and so is the loop's overhead. For a real implementation of this technique, see this post on flipcode.com (http://www.flipcode.com/cgibin/msg.cgi?showThread=TipUnrollingLoopsMeta&forum=totd&id=1).
Also worth noting is that the programming paradigm used in template metaprogramming is functional and that template metaprogramming in C++ is a Turingcomplete technique. The former means that you should be very familiar with recursion if you plan to do template metaprogramming. The latter means that any algorithm can be implemented with template metaprogramming. The only implication is that the algorithm's input values must be known while the code is compiled.
Search Encyclopedia

Featured Article
