11 Template metaprogramming

This chapter shows how C++ templates enable programs that run at compile time to manipulate types and guide code generation, yielding faster and safer generic libraries. It motivates metaprogramming as a way to tailor algorithms to type capabilities and highlights modern C++17 features that make this style practical: compile-time branching with constexpr if, rich type traits, and SFINAE-based introspection. Alongside type-centric techniques, the chapter also emphasizes uniformly invoking arbitrary callables and illustrates how these tools support higher-level abstractions, from generic utilities to small domain-specific languages.

It begins with deducing and transforming types: using decltype and std::declval to infer element types, then normalizing results with remove_cv and remove_reference. The chapter demonstrates verifying deductions via static_assert and building core traits by partial specialization (for example, custom is_same and remove_reference). It then advocates relying on container-provided value_type when available, and shows how to detect such metainformation and other properties (like iterability) with void_t and SFINAE. Combined with constexpr if, these checks let code select the right implementation while compiling only valid branches, preventing hard-to-read overload sets and eliminating invalid code paths.

Next, the text develops a generic currying wrapper that stores a callable and captured arguments, decides at compile time (with is_invocable) whether enough arguments are present, and either invokes or returns a new curried object. To support every kind of callable—including member pointers—it uses std::invoke, and pairs it with std::apply to expand argument tuples; reference wrappers avoid unnecessary copies. Finally, it builds a compact DSL for transactional record updates by modeling an AST (field, update, transaction), overloading operators to compose updates, applying them atomically via copy-and-swap, and distinguishing setters that return bool from those that return void using is_invocable_r. Together, these patterns showcase how template metaprogramming and C++17 features enable expressive, type-safe APIs with zero runtime overhead.

When you provide different arguments to is_same, only the first definition that returns false_type will be a match. If you pass the same type as both parameters, both definitions will be a match, and the more specialized match will win—the one returning true_type.

The void_t metafunction is strange: it ignores all its parameters and always returns void. It’s useful because it can be evaluated only if the types you pass as its arguments are valid. If they aren’t, void_t triggers a substitution failure, and the compiler will ignore the definition that used it.

The abstract syntax tree you want to model contains three levels: the object you’re updating, a list of updates that need to be performed (if each update contains two items, the field that should be updated), and the new value the field should have.

• Templates give you a Turing-complete programming language that is executed during program compilation. This was discovered accidentally by Erwin Unruh, who created a C++ program that prints the first 10 prime numbers during compilation—as compilation errors.
• TMP is not only a Turing-complete language; it’s also a pure functional language. All variables are immutable, and there’s no mutable state in any form.
• The type_traits header contains many useful metafunctions for type manipulation.
• From time to time, because of limitations or missing features in the core programming language, workarounds are added to the standard library. For example, std::invoke allows you to call all function-like objects, even those that don’t support the regular function-call syntax.
• DSLs are tedious to write but let you significantly simplify the main program logic. Ranges are also DSLs, in a sense; they define an AST for defining range transformations using the pipe syntax.

FAQ