I’ve finally had a little time to advance with reading Alexandrescu’s book on Modern C++ design, and I’m absolutely blown away by the sheer awesomeness of its ideas. I highly recommend getting this book!

I would like to show just a little bit of what we can do with template specialization when it comes down to meta programming.

Suppose we wanted to know how many levels of indirection does our type actually have. What I mean in “levels of indirection” is basically how many times do we need to de-reference the type in order to get to the real underlying type. Here’s how it’s possible to achieve just that, in compile time, using template specializations:

template <typename T>
struct LevelOfIndirection {
    enum { result = 0 };
    typedef T pointedToType;
};

template <typename T>
struct LevelOfIndirection<T*> {
    enum { result = LevelOfIndirection<T>::result + 1 };
    typedef typename LevelOfIndirection<T>::pointedToType pointedToType;
};

#include <iostream>

int main () {
    std::cout <<
        "int**: " << LevelOfIndirection<int**>::result <<
        ", int: " << LevelOfIndirection<int>::result <<
        std::endl;
    // LevelOfIndirection<int**>::pointedToType is int!
}

The second specialization matches pointer types better and therefore gets selected by the compiler as long as T represents a pointer type. So by using it, we’re able to make all the calculations we’re interested in.

This is just something I came up with to demonstrate the power in yielding template specializations for meta programming. There are many other interesting techniques I plan to introduce in the near future.