Practical C++ Metaprogramming

Chapter 3. C++ Metaprogramming and Application Design

Chapter 2 gave you a taste of how powerful type manipulation can be and how it can make code more compact, generic, and elegant, and less error prone.

As in all automation systems, metaprogramming requires some tools to avoid rewriting the same code over and over. This chapter will go over the basic components of such a toolbox. We also will try to extract axioms (small, self-contained elements of knowledge) to apply in our everyday jobs as metaprogram developers.

Compile-Time Versus Runtime Paradigms

C++ runtime code is based on the fact that users can define functions that will operate on values represented by some data type (either native or user defined) to produce new values or side effects. A C++ program is then the orchestration of said function calls to advance the application’s goal at runtime.

If those notions of functions, values, and types defined by runtime behavior are pretty straightforward, things become blurry when speaking about their compile-time equivalents.

Values at Compile Time

Compile-time computations need to operate on values defined as valid at compile time. Here’s what this notion of compile-time values covers:

• Types, which are entities defined at compile time
• Integral constants, defined by using the constexpr keyword or passed to the template class as template parameters.

Unfortunately, types and integral constants are two completely different beasts in C++. Moreover, there is currently no way ...