How To Use C++ Templates If You Are A Programmer?

Template metaprogramming can initially look baffling, but researching its connection to operational programming will help shed a little light on matters.


Computing is sometimes quite a very profound field occasionally.

I discover that the further I know about this, the more I am struck by how many similarities there are between different regions of the niche.

I was going through Andrei Alexandrescu’s fascinating publication Modern C++ Design recently after I learn about an association that I thought was worth discussing.

As I guess the majority of you’ll be aware, C++ may be utilized for something called template metaprogramming, making usage of C++’s template mechanics to calculate matters at compile time.

If you look at a template metaprogram, but you are going to discover that it looks like a normal’ app.

In reality, such a thing but the simplest metaprogram is able to begin to appear quite intimidating to anyone who’s not familiar with the idioms involved.

This makes meta-programming seem hard and may put off people until they have even begun.

Surprisingly, the secret to template metaprogramming proves to be operational programming.

Conventional apps are written in an imperative manner: that the developer tells the computer to accomplish things in a specific sequence, and it moves off also implements them.

Functional programming, in comparison, involves enlarging definitions of purposes before the final result is readily calculated.

Developers that have studied computer engineering officially at university are most very likely to have previously come across some type of operational programming, but perhaps in a language such as Haskell, however for a lot of self-taught developers, the idioms of operational programming will likely probably soon be quite new.

Within the following guide, I expect to provide a glimpse of just functional programming works, and also how it connects right to meta-programming in C++.

Anybody who is enthusiastic about template metaprogramming generally could also want to look at this Boost MPL library [ Boost].

Finally, to get a far deeper look at performing operational programming at C++, readers will look in [ McNamara].

Compile Time lists

As a real example, I wish to think about a very simple list execution. For people that are not familiar together, Haskell lists have been constructed recursively.

Alist is defined as the empty list, [], or an element (of the right type) pre-fixed, with the: operator, directly to a present list.

Working just with lists of integers (Integers at Haskell) for clarity Right Now, we could specify the following purposes to Choose the tail and head of a listing:

The mind work requires a set of integers and returns an integer (namely, the very first element in the list).

The tail function yields the set of integers staying after the mind is removed.

Up to now, therefore dull (at the very least if you are a normal working developer ).

Now for the fun bit. As it happens you can do the exact identical task from C++, with templates.

(This might or might not force you to imagine a ha!’, based upon your character) The concept (à la Alexandrescu) will be to save the list for being a type.

  • struct NullType;

A vital thing here is that neither of the structs will be instantiated (which is the reason why they are only announced in the place of the need to be defined):

Posts have been represented as types rather than items.

Considering that the aforementioned mentioned declarations, we can execute our thoughts and tail acts as shown in List 1.

Already some vital ideas are appearing. To begin with, if we discount the simple fact the C++ variation of this code is a lot more verbose compared to its Haskell counterpart (chiefly because we’re using C++ templates to get an objective for which these were not meant), the 2 apps are unusually similar.

Integers are increasingly now being defined with enum lists and s are all defined with typedef, therefore (remember yet more which lists are represented as types).

Utilizing these constructs is quite clumsy. An app outputting the mind of this listing [7,8], as an example, now resembles:

  • #include
  • {Int main() undefined

To boost this sorry situation, we will utilize macros (this really is some of these times once the huge advantages of with them outweigh the downsides).

In a way similar to that employed for ‘typelists’ at Modern C++ Design we specify that the macros in List 2 to help with list production.

We also specify macros for tail and head:

The progress from the readability and brevity of this code above is more striking:

From today on, we’ll assume that if we specify a new construct, we’ll even specify a corresponding macro to create it a lot simpler to make utilize of.

Outputting a listing

Before implementing a number more interesting list calculations, it’s worth mentioning just how to output alist.

It should really come as no real surprise that the kind of the output differs from the different code within this short informative essay:

Effect signal will be obviously performed at run time, whereas our additional list manipulations are complete in compile time.


Computing the tail and head of an inventory assembled at a mind: tail shape might appear a relatively trivial case.

Our alternative is to decide to test implementing something a little more interesting: sorting.

Perhaps surprisingly, that really isn’t actually that difficult. The analogy between programming in Haskell and also compile-time programming in C++ is excessively profound, to the degree you may transform Haskell code into C++ template code nearly automatically.

With this particular article, we will consider two implementations of sorting, and selection sort and insertion sort (it’d be equally as achievable, and also never just really an excellent bit tougher, to execute something more effective, such as quicksort:

I will leave that as an exercise to the reader).

I have restricted my execution for ordering elements using operator but it may be much more generic with hardly any additional work.

An easy selection sort operates by locating the minimum element in an inventory, moving it into the mind of this list, and recursing on the rest of the We’re going to want the next:

  • a method of locating the minimum element in an inventory,
  • a method of removing the very first matching part from an inventory and also a sorting execution to unite the 2.
  • List 4 shows exactly how we’d get it done in Haskell.
  • We can alter to C++ as shown in List 5.

The main factors to note here would be that all function from the Haskell code corresponds with a C++ template statement, also each pattern-matched instance from the Haskell code corresponds to a specialty of a few of those C++ templates.

Implementing an insertion form is quite intriguing. The gist of the algorithm will be always to add the elements one at the same time right in an organized record, maintaining the sorted nature of this list within an invariant.

An easy Haskell execution of them goes as follows:

Translating the added role to C++ isn’t entirely insignificant. The predicament is that individuals will need to build among two distinct types based upon the significance of a boolean state, that will be non-obvious.

You will find (at least) two methods for this: we are able to rewrite the Haskell work to avert the circumstance, or you also are able to write a unique C++ template to pick among 2 typedefs, therefore, predicated on a boolean condition.

Rewriting the Haskell code can be performed as follows:

This simplifies the issue (generating 1 of 2 unique values based upon the worth of a boolean state is straightforward), however at the price of a less effective function.

The template variant (with the Select template offered right from Andrei’s publication) does a much better job:


This lets us straightforwardly alter the efficient kind of this Haskell code into C++ (List 6).

It ends up in C++ this is still not as efficient as it might possibly be.

To blame is at the 2nd specialty of Insert – by specifying the earlier and after typedef, so at the specialty itself, we induce them to be instantiated despite the fact that only 1 is in fact needed.

The remedy is to present an additional level of indirection (List 7).

This simplifies the situation because today the preferred IntList template simply gets instantiated when it’s in fact needed.

Maps and filters

Certainly one of the greatest reasons for writing in an operational language has traditionally been the skill of expressing complicated manipulations in a very simple fashion.

As an instance, to apply the exact identical function f to every element of a list xs from Haskell is equally really as easy as writing map xs. A definition of those roles in Haskell is simple enough:

Achieving exactly the exact task in C++ initially sounds simple, but is clearly marginally subtle. The issue is the way exactly to specify f and de.

It ends up that exactly what we want below would be template parameters.

Both f and p have been template types that give a unique result for every value of these template debate.

For Example, a purpose’ to multiply two can be described as:

And also a predicate which merely takes numbers can possibly be understood to be

The Map and Filter templates are able to be thought of as in List 8.

Be aware that we make use of this Select template to select from both different result type s in Filter.


Thus far, we’ve just seen how to execute integer lists. There is a fantastic reason behind this – matters such as pops, as an instance, can not be template parameters.

All is not totally lost, nevertheless. It works out that individuals may create lists of whatever which may be represented by integers in compile time! The code looks something similar to List 9.

The key change is in the way we treat the mind of this list – today we write typename x where we’d int x and utilize the type’s value field to receive its true value if we are in need of it.

The remaining part of the code might also be altered to benefit generic lists at a very similar trend.

There is something to be said about the way we handle fixing, however, that is clearly an issue for the future article!


Within the following piece, we’ve discovered how template metaprogramming is related to operational programming in languages such as Haskell and executed compile-time lists with C++ templates.

In the next moment, I will reveal 1 of the ways of executing orders in forums that are generic, and consider just how to execute compile-time binary search trees.

Therefore which will be the applications of writing code such as this? 1 direct utilization of compile time BSTs is to employ a table that’s sorted at market time.

This may prove to be extremely helpful, especially in embedded code.

Additionally, there are indirect benefits of TL Templates based on learning about template metaprogramming generally.

Writing code such as this is sometimes regarded as a good stepping stone to understanding matters just as the type lists clarified in Andrei’s publication.

The capacities these provide are very amazing and may give us real advantages to this brevity and architecture of the code.

Leave a Reply