De exemplu, sa zicem ca vrem sa facem o asertie la timpul compilarii. Avem o expresie statica (care poate fi calculata la compilare) si vrem sa primim o eroare daca aceasta expresie nu se evalueaza la true. Putem sa folosim aceasta idee de template specialization:

==code(c) |

template<bool> struct CompileTimeError {};
template<> struct CompileTimeError<true> { enum { Cool = 1 }; };

==

Am definit un tip CompileTimeError care in general este gol. Insa daca parametrul bool se intampla sa fie true, compilatorul foloseste definitia specializata a tipului. Daca avem o expresie expr, sa ne gandim la urmatoarea expresie:

==code(c) |

CompileTimeError<expr>::Cool

==

Daca expr = true, s-ar evalua la 1. Insa daca este false, vom avea o eroare de compilare - definitia generala nu include identificatorul Cool. Am reusit sa facem compilatorul sa evalueze doua lucruri diferite in functie de o expresie - un "if" daca vreti.

Pentru ca tipurile sunt prin definitie imuabile, nu vom putea sa facem compilatorul sa ruleze algoritmi iterativi - nu avem cum sa il facem sa mentina o stare. Va trebui sa convertim orice lucru iterativ in ceva recursiv, cum am face la un limbaj functional (in stil lisp). Cum determinam daca un numar este prim fara sa mentinem stare? Putem sa definim o "functie" HasDivisors cu doi parametri, N si K. HasDivisors returneaza true daca vreun numar intre 2 si K il divide pe N. Astfel, un numar este prim daca HasDivisors este true pentru parametrii N si N-1. Putem implementa aceasta idee cu template-uri:

== code(c) |

template <int N, int K>
struct HasDivisors
{

{
    enum { Result = !HasDivisors<N, N-1>::Result };
};

==

Observam recursivitatea din HasDivisors; conditia de oprire este implementata prin specializarea partiala HasDivisors<N, 1>
Putem combina acestea cu definitiile de mai sus pentru a genera erori pentru numerele prime:

== code(c) |

template <int N>
struct PrimeErrors
{

{
    enum { Result = 0 };
};

==

Prima parte a expresiei din PrimeErrors este doar o asertie la timpul compilarii. Operatia de adunare e folosita doar pentru recursivitate. Din nou, specializarea ne da voie sa definim conditia de oprire a recursivitatii. In final nu mai avem nevoie decat de o instructiune care sa faca compilatorul sa evalueze PrimeErrors:

== code(c) |

PrimeErrors<100>::Result x;

==

Daca compilam acest program, vom primi erori ca mai jos (am taiat din liniile repetitive):

== code(c) |

templates.cpp: In instantiation of 'PrimeErrors<2>':
templates.cpp:25:   instantiated from 'PrimeErrors<3>'
templates.cpp:25:   instantiated from 'PrimeErrors<4>'

...
templates.cpp:34:   instantiated from here
templates.cpp:25: error: 'Cool' is not a member of 'CompileTimeError<false>'

==

Daca filtram doar liniile cu In instantiation of ..., vedem frumos rezultatul dorit:

== code(c) |

root@slack ~# gcc templates.cpp 2>&1 | grep "In in"
templates.cpp: In instantiation of 'PrimeErrors<2>':
templates.cpp: In instantiation of 'PrimeErrors<3>':

templates.cpp: In instantiation of 'PrimeErrors<83>':
templates.cpp: In instantiation of 'PrimeErrors<89>':
templates.cpp: In instantiation of 'PrimeErrors<97>':

==

Dragut, nu?