Compile-Time Programming

C++ has the ability to evaluate expressions at compile time, meaning that values are already calculated when the program executes. Even though metaprogramming has been possible since C++98, it was initially very complicated due to its complex template-based syntax. With the introduction of constexpr, if constexpr, and recently, C++ concepts, metaprogramming has become much more similar to writing regular code.

This chapter will give you a brief introduction to compile-time expression evaluations in C++ and how they can be used for optimization.

We will cover the following topics:

• Metaprogramming using C++ templates and how to write abbreviated function templates in C++20
• Inspecting and manipulating types at compile time using type traits
• Constant expressions that are evaluated by the compiler
• C++20 concepts and how to use them to add constraints to our template parameters
• Some real-world examples of metaprogramming...

Introduction to template metaprogramming

When writing regular C++ code, it is eventually transformed into machine code. Metaprogramming, on the other hand, allows us to write code that transforms itself into regular C++ code. In a more general sense, metaprogramming is a technique where we write code that transforms or generates some other code. By using metaprogramming, we can avoid duplicating code that only differs slightly based on the data types we use, or we can minimize runtime costs by precomputing values that can be known before the final program executes. There is nothing that stops us from generating C++ code by using other languages. We could, for example, do metaprogramming by using preprocessor macros extensively or writing a Python script that generates or modifies C++ files for us:

Figure 8.1: A metaprogram generates regular C++ code that will later be compiled into machine code

Even though we could use any language to produce regular code, with C++, we...

Type traits

When doing template metaprogramming, you may often find yourself in situations where you need information about the types you are dealing with at compile time. When writing regular (non-generic) C++ code, we work with concrete types that we have complete knowledge about, but this is not the case when writing a template; the concrete types are not determined until a template is being instantiated by the compiler. Type traits let us extract information about the types our templates are dealing with in order to generate efficient and correct C++ code.

In order to extract information about template types, the standard library provides a type traits library, which is available in the <type_traits> header. All type traits are evaluated at compile time.

Type trait categories

There are two categories of type traits:

• Type traits that return information about a type as a boolean or an integer value.
• Type traits that return a new type. These type...

Programming with constant expressions

An expression prefixed with the constexpr keyword tells the compiler that the expression should be evaluated at compile time:

constexpr auto v = 43 + 12; // Constant expression

The constexpr keyword can also be used with functions. In that case, it tells the compiler that a certain function is intended to be evaluated at compile time if all the conditions allowing for compile-time evaluation are fulfilled. Otherwise, it will execute at runtime, like a regular function.

A constexpr function has a few restrictions; it is not allowed to do the following:

• Handle local static variables
• Handle thread_local variables
• Call any function, which, in itself, is not a constexpr function

With the constexpr keyword, writing a compile-time evaluated function is as easy as writing a regular function since its parameters are regular parameters instead of template parameters.

Consider the following constexpr function...

Constraints and concepts

So far, we have covered quite a few important techniques for writing C++ metaprograms. You have seen how templates can generate concrete classes and functions for us with excellent support from the type traits library. Furthermore, you have seen how the use of constexpr, consteval, and if constexpr can help us move computations from runtime to compile time. In that way, we can detect programming errors at compile time and write programs with lower runtime costs. This is great, but there is still plenty of room for improvement when it comes to writing and consuming generic code in C++. Some of the issues that we haven't addressed yet include:

1. Interfaces are too generic. When using a template with some arbitrary type, it's hard to know what the requirements of that type are. This makes the templates hard to use if we only inspect the template interface. Instead, we have to rely on documentation or dig deep into the implementation of a template...

Real-world examples of metaprogramming

Advanced metaprogramming can appear to be very academic, so in order to demonstrate its usefulness, let's look at some examples that not only demonstrate the syntax of metaprogramming, but how it can be used in practice.

Example 1: creating a generic safe cast function

When casting between data types in C++, there is a multitude of different ways things can go wrong:

• You might lose a value if casting to an integer type of a lower bit length.
• You might lose a value if casting a negative value to an unsigned integer.
• If casting from a pointer to any other integer than uintptr_t, the correct address might become incorrect. This is because C++ only guarantees that uintptr_t is the only integer type that can withhold an address.
• If casting from double to float, the result might be int if the double value is too large for float to withhold.
• If casting between pointers with a static_cast(), we might get...

Summary

In this chapter, you have learned how to use metaprogramming to generate functions and values at compile time instead of runtime. You also discovered how to do this in a modern C++ way by using templates, the constexpr, static_assert(), and if constexpr, type traits, and concepts. Moreover, with constant string hashing, you saw how to use compile-time evaluation in a practical context.

In the next chapter, you will learn how to further expand your C++ toolbox so that you can create libraries by constructing hidden proxy objects.