Chapter 16: Metaprogramming

In C++ Metaprogramming refers to the use of macros or templates to generate code at compile-time.

In general, macros are frowned upon in this role and templates are preferred, although they are not as generic.

Template metaprogramming often makes use of compile-time computations, whether via templates or constexpr functions, to achieve its goals of generating code, however compile-time computations are not metaprogramming per se.

Section 16.1: Calculating Factorials

Factorials can be computed at compile-time using template metaprogramming techniques.

factorial is a struct, but in template metaprogramming it is treated as a template metafunction. By convention, template metafunctions are evaluated by checking a particular member, either ::type for metafunctions that result in types, or ::value for metafunctions that generate values.

In the above code, we evaluate the factorial metafunction by instantiating the template with the parameters we want to pass, and using ::value to get the result of the evaluation.

The metafunction itself relies on recursively instantiating the same metafunction with smaller values. The factorial<0> specialization represents the terminating condition. Template metaprogramming has most of the restrictions of a functional programming language, so recursion is the primary "looping" construct.

Since template metafunctions execute at compile time, their results can be used in contexts that require compiletime values. For example:

int my_array[factorial<5>::value];

Automatic arrays must have a compile-time defined size. And the result of a metafunction is a compile-time constant, so it can be used here.

Limitation: Most of the compilers won't allow recursion depth beyond a limit. For example, g++ compiler by default

for (int i = 1; i <= n; ++i) { result *= i;

}

return result;

}

Version ≥ C++17

Since c++17 one can use fold expression to calculate factorial:

#include <iostream> #include <utility>

template <class T, T N, class I = std::make_integer_sequence<T, N>> struct factorial;

template <class T, T N, T... Is>

struct factorial<T,N,std::index_sequence<T, Is...>> {

static constexpr T value = (static_cast<T>(1) * ... * (Is + 1));

};

int main() {

std::cout << factorial<int, 5>::value << std::endl;

}

Section 16.2: Iterating over a parameter pack

Often, we need to perform an operation over every element in a variadic template parameter pack. There are many ways to do this, and the solutions get easier to read and write with C++17. Suppose we simply want to print every element in a pack. The simplest solution is to recurse:

Version ≥ C++11

void print_all(std::ostream& os) { // base case

}

template <class T, class... Ts>

void print_all(std::ostream& os, T const& first, Ts const&... rest) { os << first;

print_all(os, rest...);

}

We could instead use the expander trick, to perform all the streaming in a single function. This has the advantage of not needing a second overload, but has the disadvantage of less than stellar readability:

Version ≥ C++11

template <class... Ts>

void print_all(std::ostream& os, Ts const&... args) { using expander = int[];

(void)expander{0,

(void(os << args), 0)...

};

}

For an explanation of how this works, see T.C's excellent answer.

Version ≥ C++17

With C++17, we get two powerful new tools in our arsenal for solving this problem. The first is a fold-expression: