Page Title

usududhdhdhduudhdhd hdhdhdhdhdhdh

hello! i'm a side content of 'introduction'.

PREMISE

Template metaprogramming (TMP) is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. [Wikipedia]

Good start..
Seems like this TMP thing is quite obscure.
What is meant by generate temporary source code?(source code is essentially the code we write)
Does the compiler write code for us.. really? That would be great!
Although we may not appreciate that it's temporary (we cannot see what code was generated) we must admit TMP is a powerful tool that is worth knowing.

The definition provided doesn't tell too much, it just says we use templates to achieve TMP.

What is a template? We need some documentation..

A template is a C++ entity that defines one of the following:
● a family of classes (class template), which may be nested classes
● a family of functions (function template), which may be member functions
● an alias to a family of types (alias template) (since C++11)
● a family of variables (variable template) (since C++14)
● a concept (constraints and concepts) (since C++20)

Templates are parametrized by one or more template parameters, of three kinds: type template parameters, non-type template parameters, and template template parameters.
[cppreference]

Whaaaat ?? Ok it's complicated. Keep calm..
A C++ entity is a basic concept, it is essentially everything we declare.

The entities of a C++ program are values, objects, references, structured bindings (since C++17), functions, enumerators, types, class members, templates, template specializations, namespaces, and parameter packs. Preprocessor macros are not C++ entities.
[cppreference]

Templates are something we declare, just like a function for example.

Next we have a list of what a template defines..
A template defines FAMILIES of related classes,function, variables but also aliases.
This is what we can do whit templates.

To make things more complicated we may say that templates are entities which makes entities, that's really abstract and obscure.
What i like is the FAMILY thing.. in short we declare ONE template and the compiler generates many classes, functions, and many other things!

The definition ends with Templates are parametrized, looks very similar to a function. We have a way to control the template job!
Finally we have three kinds of template parameters:
● type template parameters (int, char..)
● non-type template parameters (22, 'a'..)
● template template parameters (...)

These three are really important because our use of templates relies on them most of the time. Put very simply types are classes, non-type are values and the last.. well is an entity @,@

The introduction suggests that templates are not easy but we should have realized that templates relies on a very basic concept: they are entities, we need imagination to work with.
Too much theory, in the next sections we'll see how templates works with practical examples!

INTRODUCTION

TMP is not something we can describe so easily, it's time to add more practical definitions.

TMP can be seen as a language embedded inside the C++ language and it is interpreted by the compiler. That's why it is also described as compile time or even better functional programming. in fact it is immutable and stateless.

Functional: programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.
[Wikipedia]

Put simply, everytimes we call a function with the same arguments the output is always the same.
The function doesn't change the state of our program nor is affected by it.
There are no states, no variables, we cannot change values, only constants.

Why is it considered a language?
Because TMP is turing complete since it has the basic elements to perform every computation :
● values
● branches on conditions (if statements)
● loops
● return from functions

Now that we have a global overview is time to see real examples compared to normal runtume versions.
The equivalent of runtime variables in TMP are compile time values and types such as const variables, literals, constexpr, types, functions and templates.

int x = 1; // normal variable

const int num = 0; // constant 
const char name[] = "TMP"; // string literal
typedef unsigned int UInt; // type

The equivalent of functions concept in TMP are classes and structs where parameters are templates parameters and the return statement is a public value often called value or result by convention.
This is technically correct because technically a function maps input values to an output value.

We will use structs most of the times for simplicity, they have default public access policy.

// runtime function
int sum(int x,int y){
 return x + y;
}

int a=10, b=90;
int ab = sum(a,b);

// TMP function
template<int X,int Y>struct Sum{
 static const int result = X + Y;
};

const int A = 2, B = 8;
const int AB = Sum<a,b>::result;

The equivalent of the function body is one or more expressions inside the struct, it is evaluated at compile time and it must be const. Since this value belongs to a class, and not to an object, it is static and we access it trough :: scope resolution.

Another example of a typical TMP operation is a type conversion, we pass a type as argument and we return a different type.

template<typename T>struct ToPtr{
 typedef T* result;
};

typedef ToPtr<char>::result p_char;
const p_char name = "TMP";

MODERN TMP

Before we go trough the various basic constructs it's good to see some new features added to the language to to help and improve TMP.
At the very beginning TMP was discovered accidentally during the process of standardizing the C++ language, it was found that template system happens to be capable of compute everything is computable making it turing complete.
It was presented a small TMP program to compiute a sequence of prime numbers, the program didn't compile but inside the error message appeared a list of the first prime numbers!
TMP has since advanced considerably, c++ 11 and latter version added features to make these TMP techniques first class features of the C++ language.

C++ 11 introduced alias templates allowing instantation of alias families, an alias is a replacement for typedef, a synonimus of a type.
With this syntax our ToPtr function is now more concise.

template<typename T>
using ToPtr = T*;

using p_char = ToPtr<char>

C++ 11 also added constant expressions (constexpr), they can be variables and functions and give us a normal c++ way to perform computations at compile time.
They also allow us to use float and double values in TMP since they form compile time constant values, we will see this later. For now let's see a simple example involving our Sum function.

constexpr int Sum(const int X, const int Y){
 return X + Y;
}

constexpr int a = 1, b = 2;

constexpr int ab = Sum(a,b);

And finally C++ 11 added Template Parameter Pack.

A template parameter pack is a template parameter that accepts zero or more template arguments (non-types, types, or templates). A function parameter pack is a function parameter that accepts zero or more function arguments.

A template with at least one parameter pack is called a variadic template. [cppreference]

template<int a=0,int... args>struct Sum{
 static const int result = a + Sum<args...>::result ;
};
template<int a>struct Sum<a>{
 static const int result = a;
};

Another useful feature related to TMP added since C++ 11 is the decltype specifier.

decltype inspects the declared type of an entity or the type and value category of an expression. [cppreference]

template<typename T,typename U>
auto sum(T x,U y)->decltype(x+y){
 return x+y;
}

C++ 14 added variable template allowing instantation of variables with templates.
Our Sum function now becomes..

template<int X,int Y>
int Sum = X + Y;

const int XY = Sum<2,3>

TMP FLOW CONTROL

LOOP
We have seen how the c++ language evolved in favor of compile time computing with the new features added, it's time to resume the overview of the basic components of TMP.
Things gets more interesting, we are about to enter real TMP, loops are one of the biggest bricks of algorithms.
In TMP loops are achieved with recursion because of the constant nature of compile time computations.
We will see now the most basic example, a program to compiute the factorial of a number, the TMP "Hello world!" program.

The factorial of a number N is the product of all the positive integers less than or equal to N, the factorial of 0 is 1.

To solve this algorythm with TMP we define a template struct calling itself in a recursive way, and we define an end condition ( for n = 0 ) trough template specialization.
Specialization looks very similar to function overloading, and we can perform a different operation for a particular type or value.

template<int N>struct Factorial{
 static const int result = N * Factorial<N-1>::result;
};

template<>struct Factorial<0>{
 static const int result = 1;
};

const int fac_5 = Factorial<5>::result;

The <0> specialized template doesn't call itself like the normal version, this is how recursion ends.
It's like putting a .. if ( value == 0 ) break; inside a infinite loop.

BRANCHES
Branches (if statements) are achieved in the same way, trough template specialization, as an example here we have a code to check if a type is const.

template<typename T>struct If_const{
 static const bool result = false ;
};

template<typename T>struct If_const<const T>{
 static const bool result = true ;
};

using A = char;
using B = const char;


const bool testA = If_const<A>::result ;
const bool testB = If_const<B>::result ;

On the next sections we'll see some examples with some techniques and improvements.
TMP is hard to master due to its criptic syntax and awful error messages making it difficult to read, debug and to maintain, sometimes it leads to big compilaton times, anyway it may improve dramatically performance at runtime.
Although sometimes not recommended it is a powerful tool that has changed the way we make programs in modern C++ programming.

RATIONAL TYPE

Let's do some practice, too much theory until now, we will make a simple template device modeling rational numbers with some basic operations on them.

#include <iostream>
template<int n,int d>struct Rational{
 static const int numerator   = n;
 static const int denominator = d;
 
 static std::ostream& print(std::ostream& out) {
  out << numerator << "/" << denominator ;
  return out; 
 }
};

template<typename R,int n>struct Scale{
 using result = Rational<R::numerator * n,R::denominator * n>;
};

using a = Rational<3,2>;
using b = Scale<a,3>::result ;

int main() {
 std::cout << a::print << " * 3 = " << b::print ;
    return 0;
}

Here we have defined a template struct containing the components of a rational number (numerator and denominator).
We have also added a manipulation of stream object to make the type easily printable inside the standard output stream (cout << ..).
It is not possible to overload ostream for a type ( well it is, and we'll see a template overload of ostream later ) because we have to refer to an instance of a type, but passing just te type like we do in TMP is not possible, we need a trick..
The trick is very simple: the ostream << operator is designed in a way that makes it concatenable, in short the << operator takes an ostream object and returns it, that's exactly what we usually do when we use cout with many values chained, for example:
cout << "message" << var << endl;
The static print() method(callable from the class) takes an ostream object and returns it allowing insertion in the stream chain.

We ave also defined a Scale struct (TMP function) taking a Rational type and returning a new one with both parameters multiplied.

Let's add some operations like multiplication and sum..
3/2 * 5/4 = (3*5) / (2*4)

template<typename A,typename B>struct Multiply{
 using result = Rational<
  A::numerator*B::numerator,
  A::denominator*B::denominator
 >;
};

The formulae for the sum is :
a/b + c/d = ad + cb / bd [ Wikipedia]

template<typename A,typename B>struct Add{
 using result = Rational< 
  A::numerator*B::denominator +
  B::numerator*A::denominator ,
  A::denominator*B::denominator
 >;
};

Every rational number may be expressed in a unique way as an irreducible fraction a/b, where a and b are coprime integers, and b > 0. [Wikipedia]

To reduce a Rational we have to scale it by the Great Common Divisor MCD, first let's make a Mcd struct using Euclidean Algorithm, then we will use it in a Reduce struct.

constexpr int Mcd(int x,int y){
 return y ? Mcd( y , x%y ) : x;
}


template<typename R>struct Reduce{
 static const int mcd = Mcd(R::numerator,R::denominator);
 using result = Rational<R::numerator/mcd,R::denominator/mcd>;
};

We have played a little with our Rational and we have seen how we can do every kind of computations in TMP, let's proceed to more interesting (and more complicated) things.

LIST DEVICE

We have learned the basics and strengthened them making a Rational devce, anyway this was not a real TMP as it is intended, now we will make a real one.
In fact TMP is also known as programming with types, this means we operate more on types and templates instead of values in general, we have approached it a little but now we need to improve our skills. Let's make a data structure, a List.
A list is usually implemented as linked list, this means we have a sequence of elements containing data (Head) and a pointer to the next element (Tail). Our data is obviously a type while the next element will be a list.
This kind of structure apply well to a recursive stile, hence to TMP, we can iterate trough the list easily but we need something to detect the end of the list, we will create an End type and use it as default template argument for the Tail.

struct End{
 typedef End Head;
 typedef End Tail;
};

template<typename H,typename T=End>struct List{
 typedef H Head;
 typedef T Tail;
};

typedef List<char,List<int,List<Foo>>> myList;

TEMPLATE PARAMETER PACK

Look at the List creation, what an ugly syntax! Suppose we have a list of ten or more elements, it would be hard to declare a List correctly..
typedef List< a, List< int, List< char, List< double, List< Fruit, List< const unsigned, list< long int > > >..> > myList;
Well it's normal to see things like this in TMP but there is something we can do to make our list creation more readable and intuitive, C++ 11 came to rescue us with Parameter Pack.

A template parameter pack is a template parameter that accepts zero or more template arguments (non-types, types, or templates).
A function parameter pack is a function parameter that accepts zero or more function arguments.

A template with at least one parameter pack is called a variadic template.
[cppreference]

The syntax is simple : ( ... ) tree dots called ellipsis, they are variable argument lists.
Let's make a struct returning a List with this new feature.

template<typename Arg=End,typename... Args>struct MakeList{
 typedef List<Arg,typename MakeList<Args...>::result> result;
};

template<>struct MakeList<End>{
 typedef End result ;
};


template<typename L>struct Len{
 static const int result = 1 + Len<typename L::Tail>::result ;
};
template<>struct Len<End>{
 static const int result = 0;
};

It works this way : when we 'call' our template with one or more arguments the first goes to Arg and the rest goes to Args...
When the pack is empty Arg becomes the default parameter (End) and it fires the template specialization template<>struct Len<End>{.. resulting in End as Tail.
Attention.. a parameter pack must be the last parameter in the declaration, it's obvious due to its variadic size, isn't it?

We have also declared a Len struct to compute the length of a list, there's nothing to explain I hope.

Different approach.
We probably would like to avoid another function (MakeList) and just build our list directly trough List, altough it was probably the best approach we can also use a different one(to avoid MakeList<>), but this time we need some extra snippets..

template<typename Arg=End,typename... Args>struct List{
 typedef Arg Head ;
 typedef List<Args...> Tail ;
};

template<>struct List<End>{
 typedef End Head ;
 typedef End Tail ;
};


// check if an entity is of type End
template<typename T>
constexpr bool isEnd = false ;

template<>
constexpr bool isEnd<End> = true ;


template<typename L>struct Len{
 static const int result = 
  !isEnd<typename L::Head> +
  Len<typename L::Tail>::result ;
};

template<>struct Len<End>{
 static const int result = 0;
};

Here the main issue is that the last element has not End as a Tail but a List (made of End as both Head and Tail), this is counterintuitive and that's why i don't like this approach..
Look at our Len struct, we had to add some extra workarond to make it work, we have to inspect Head everytime because our Tail doesn't tell us if it is End or what else.

It's better to continue with the first approach and this is a rule we should strive in TMP : make each operation in a different template when possible, eg: Make operation and List element are two different things!

ASSERT

Element At
One common List operation is getting an element at a position N.
To do it we iterate the List recursively until N becomes 0 and return the Head.

template<typename L,std::size_t N>struct At{
 typedef At<typename L::Tail,N-1>::result result ;
};

template<typename L>struct At<L,0>{
 typedef L::Head result ;
};

We are gonna make many operations and primitives types aren't too much meaningful, let's add a special type containing some data for the purpose of showing something on the output and check our operations.

#include <iostream>
template<typename T,T val>struct Entry{
 static const T value = val ;
 static void print(){
  std::cout << val;
 }
};

typedef Entry<int,1> e1;
typedef Entry<char,'$'> e2;
typedef MakeList<e1,e2,Entry<int,2>::result list1;

typedef At<list1,2>::result myChoice;

int main(){
 myChoice::print();
}

Now what happens if we try to access an index outside the list, for example calling At<5> when our list has only three elements?
TMP is famous for its strange errors hard to spot, this one is a simple example, At<list1,5> doesn't give any error, is the call to print() that makes an error later but nothing tell us we tried to access an element which doesn't exist, well in this case we have an hint, the error sais there is not a print() function inside End, but we will encounter errors extremely hard or even impossible to read during our TMP journey.
The problem is that the compiler isn't often able to produce meaningful errors messages when we write TMP code, we need to find a way to help it produce nice messages.

Assert is a technique to make the compiler fail when a specific condition is not met and let it produce a meaningful message.
We make an empty class and its name will be the assertion, it will be the error message.
Then we create an Assert struct that will fail to compile if the condition is false.

template<bool cond,class Assertion>struct Assert{
 typedef typename Assertion::failed ERROR; 
}; 

template<class Assertion>struct Assert<true,Assertion>{
 typedef void ERROR; 
};

The template parameter Assertion represent the error message, so we create an empty class named ERROR___input_exceed_list_length___, this class doesn't have a ::failed member so it will fail to compile if we try to use it. The true specialization instead will compile fine.
Let's try it..

class ERROR___input_exceed_list_length___{};
template<typename L,std::size_t N>struct At{
 typedef typename Assert< (N < Len<L>::result),ERROR___input_exceed_list_length___>::ERROR test;
 typedef typename At<typename L::Tail,N-1>::result result ; 
};

template<typename L>struct At<L,0>{
 typedef typename L::Head result ; 
};

If we run this code we'll see now a clear ERROR___input_exceed_list_length___ in the error being generated, and also the line the error comes from, good, we have the informations we need to fix the error!

As said in a previous section the language evolved in favor of TMP, C++ 11 added static_assert standardizing this technique and making it part of the language.

static_assert
Performs compile-time assertion checking
static_assert ( bool_constexpr , message )

If bool_constexpr returns true, this declaration has no effect. Otherwise a compile-time error is issued, and the text of message, if any, is included in the diagnostic message.
[cppreference]

We have a condition and a message, the good thing is that the message is a string literal so we don't have to declare a class for every assertion!
Note : A template cannot have a string literal as argument, but static_assert can.

template<typename L,std::size_t N>struct At{
 static_assert(N < Len<L>::result," ==> 'std::size_t N' argument in struct At<list, N>  exceed list length ! \n        *  *  *  *  *  *  *  *  * \n ");
 typedef typename At<typename L::Tail,N-1>::result result ; 
};

error: static assertion failed: ==> 'std::size_t N' argument in struct At<list, N>  exceed list length ! 
        *  *  *  *  *  *  *  *  *

The string literal let us display better error messages allowing the use of the complete character set, including spaces and returns!

FACADES

There are some big issues in our previous code, first the At<L,0> specialization doesn't have an Assert, we can add it easily just with a copy-paste but this doesn't seems to be a good solution, copy-paste.. not for real programners!
In fact the real issue is that we make an assertion on every iteration of At(N times), which also "calls" Len. This code is not well optimized!
We should make our check and then perform At separately, seems like we have two operations to solve our task.
We will use the Facade pattern to accomplish it.

Facade : unified - simplified interface to a complex subsystem or set of interfaces

In short we have a At struct as interface and a At_facade struct which do the job.
The real facade is At but we reserve the simple name to the client and call At_facade the subsystem indicating it works for At.

template<typename L,std::size_t N>struct At_facade{
 typedef typename At_facade<typename L::Tail,N-1>::result result ;  
};

template<typename L>struct At_facade<L,0>{
 typedef typename L::Head result ; 
};


class ERROR___input_exceed_list_length___{};
template<typename L,std::size_t N>struct At{
 typedef typename Assert< (N < Len<L>::result),ERROR___input_exceed_list_length___>::ERROR test;
 typedef typename At_facade<L,N>::result result ; 
};

We will use a lot facades in TMP, this style suits very well for this language, below we'll add a functionality to our list device using both Facade and Assert.

Find Position of an Element
Another common operation on List is find the position of an element inside it, it may happen that the element is not inside the List and in this case we need an Assert again, here is the code.

template<typename L,typename E>struct Pos_facade{
 static const std::size_t result =
  sameType<typename L::Head,E> ?
   0 :
   1 + Pos_facade<typename L::Tail,E>::result ; 
};

template<typename L,typename E>struct Pos{
 static_assert(Includes<L,E>::result," ==> Element not in List ! \n        *  *  *  *  *  *  *  *  * \n ");
 static const std::size_t result = Pos_facade<L,E>::result;
};

We have defined sameType somewhere before, it was like this.

template<typename T1,typename T2>
constexpr bool sameType = false;

template<typename T>
constexpr bool sameType<T,T> = true;

But we haven't defined Includes yet..

template<typename L,typename E>struct Includes{
 static const bool result = sameType<typename L::Head,E> || Includes<typename L::Tail,E>::result;
};

template<typename E>struct Includes<End,E>{
 static const bool result = false;
};

LIST COMPLETED

It's time to finish our List and declare various operations like adding/removing elements, adding list and so on..

Append / Prepend
To append an element E to a list L we iterate trough it until we reach End and sobstitute End with E.

template<typename L,typename E>struct Append{
 typedef typename L::Head Head;
 typedef Append<typename L::Tail,E> Tail;
};

template<typename E>struct Append<END,E>{
 typedef E Head;
 typedef END Tail;
};

Prepend is simple, we make a new list with the element as Head and the old List as Tail.

template<typename L=END,typename E>struct Prepend{
 typedef E Head;
 typedef L Tail;
};

Concat
Same as Append but we append a List.

template<typename A,typename B>struct Concat{
 typedef typename A::Head Head;
 typedef Concat<typename A::Tail,B> Tail;
};

template<typename B>struct Concat<END,B>{
 typedef typename B::Head Head;
 typedef typename B::Tail Tail;
};

These three operations have one common thing.. seems like the result isn't a List no more, when we Append for example we make an Append<..parameters> entity and not a list but it works, even when we call printList<..>() on Append type.
This is a demonstration of how TMP is behavioural and generic, in short we pass an entity telling.. "it works this way" and not.. "it is this thing".

Insert
Insert an element is a bit more complex but the strategy is the same: template specialization.

template<typename L,typename E,std::size_t N>struct Insert{
 typedef typename L::Head Head;
 typedef Insert<typename L::Tail,E,N-1> Tail;
};

template<typename L,typename E>struct Insert<L,E,0>{
 typedef E Head;
 typedef L Tail;
};

template<typename E,std::size_t N>struct Insert<End,E,N>{
 typedef E Head;
 typedef End Tail; 
};

Operations with keys: Pop
Let's have fun.. we'll make a Pop operation with two Keys : Back and Front.
We could create a popBack and popFront but it will be boring so we'll make something like Pop<...,Back> and Pop<...,Front>

class Back{};
class Front{};


template<typename L,typename Key>struct Pop{};

template<typename Key>struct Pop<End,Key>{
 typedef End result ;
};

We have defined two Keys in the form of empty classes : Back and Front. We are programming with types after all.
Then we have defined a Primary template and a specialization for empty lists.

Now Pop<..,Front> is easy, we return the Tail.

template<typename L>struct Pop<L,Front>{
 typedef typename L::Tail result;
};

For the Pop<..,Back> we need a bit of extra work.. Less talk and more code.

template<typename L,std::size_t Z>struct PopBack_Facade{
 typedef  List<typename  L::Head,typename  PopBack_Facade<typename L::Tail,Z-1>::result > result ;
};

template<typename L>struct PopBack_Facade<L,1>{
 typedef List < typename  L::Head , End> result;
};

template<typename L>struct PopBack_Facade<L,0>{
 typedef End result ;
};
 
template<typename L>struct Pop<L,Back>{
 typedef typename  PopBack_Facade<L,Len<L>::result-1>::result  result ;
};

RemoveAt

template<typename H,typename T,std::size_t P>struct RemoveAt_Facade{
 typedef List<H,typename RemoveAt_Facade<typename T::Head,typename T::Tail,P-1>::result> result ;
};

template<typename H,typename T>struct RemoveAt_Facade<H,T,0>{
 typedef T result ;
};

template<typename H>struct RemoveAt_Facade<H,End,0>{
 typedef End result ;
};

template<typename L,std::size_t pos>struct RemoveAt{
 static_assert(pos < Len<L>::result," ==> Index out of List bounds ! \n * * * * * * * * * \n ");
 typedef typename RemoveAt_Facade<typename L::Head,typename L::Tail,pos>::result result;
};

Remove Entry
To remove an element E we may find its position and then use RemoveAt.
It would be nice to add a remove all option and here we'll use keys again, a Default key that will be also default parameter so that we don't have to specify it, and a remove All key to remove all same copies of E.

class Default{};
class All{};

template<typename L,typename E,typename Key=Default>struct RemoveElement{
 static_assert(Includes<L,E>::result," ==> Element E not in List ! \n        *  *  *  *  *  *  *  *  * \n ");
 typedef typename  RemoveAt<L,Pos<L,E>::result>::result result ;
};

The primary template is the default case, we remove just one Entry, for the All key we make a specialization and we use a facade.

template<typename L,typename E,bool included>struct RemoveElement_All_Facade{
 typedef typename RemoveElement<L,E>::result Step;
 typedef typename RemoveElement_All_Facade::result >::result result;
};

template<typename L,typename E>struct RemoveElement_All_Facade<L,E,false>{
 typedef L result;
};

template<typename L,typename E>struct RemoveElement<L,E,All>{
 static_assert(Includes<L,E>::result," ==> Element E not in List ! \n        *  *  *  *  *  *  *  *  * \n ");
 typedef typename RemoveElement_All_Facade<L,E,true>::result result;
};

Unique
Let's remove all duplicates from our list making an unique list.

template<typename E,typename X>struct Unique_Facade{
 typedef E Head;
 typedef Unique_Facade<typename X::Head,typename RemoveElement<X,typename X::Head,All>::result> Tail;
};

template<typename E>struct Unique_Facade<E,End>{
 typedef E Head ;
 typedef End Tail ;
};


template<typename L>struct Unique{
 typedef Unique_Facade<typename L::Head,typename RemoveElement<L,typename L::Head,All>::result> result;
};

We have played a lot with our List device and we have acquired a good control of the TMP basics. But how can we use this tecnique in real program?
We need to use these compile time stuffs we have created at runtime, we have already created a printList template function but it was for the only purpose of displaying something to the output, to see if our stuffs worked.

From now we'll see more compile time <==> runtime facilities to reach real effective TMP, things may become really complicated.

It's mandatory to have fully understood everything we have seen so far.

DATABASE

As an example close to real use of TMP we can use our List to make a Database system, there probably are better and simplier solution and there are still libraries available but this is a good example to make a further step in our TMP experience.

To start off let't see the main features of a DB

Data definition – Creation, modification and removal of definitions that define the organization of the data.

Update – Insertion, modification, and deletion of the actual data.
[Wikipedia]

Well.. our List device may serve for the data definition while we need to define runtime facilities for the update part.

EXAMPLES

Let's finish to design our TMP List, there's a lot of operations we can perform on a list.

Template Meta Programming