Aussie AI
Next level templating
-
Book Excerpt from "Generative AI in C++"
-
by David Spuler, Ph.D.
Next level templating
C++ templates are a very powerful programming mechanism. In fact, you can define entire projects as templates inside header files. To get the most out of template optimizations at compile-time, consider these methods:
- Type traits
- Variadic templates
- SFINAE
- Template Meta-Programming (TMP)
Type traits are a generic feature of C++ (since C++11) that you can use
to interrogate the type of a variable.
They are declared in the <type_traits> header file
and there are numerous ways that you can test the type
of a variable.
The above example std::is_same_v is one example.
As another example, there is std::is_signed and std::is_unsigned
to test whether it's a signed or unsigned type.
There's also std::is_pointer and std::is_array and various others.
Combining type traits with “if constexpr” gives a powerful way
to ensure templated code gets evaluated at compile-time,
and to specialize blocks of code for particular types.
Variadic templates are another way to level up your code
and have been supported since C++11.
These are variable-argument templates
via the use of the ellipsis “...” operator in a template declaration.
This allows templates to accept a variable number of parameters for instantiation.
SFINAE.
Another optimization for advanced templating is to rely on SFINAE semantics.
This refers to “Substitution Failure Is Not An Error”
and means that template instantiation that fails should not itself trigger
a compilation error that prevents execution.
More specifically, if the compiler tries and fails to instantiate a template,
but there's another way to run it, such as a different overloaded function
available, then the code should execute via the non-templated method.
Relying on this capability in C++ not only avoids
having compilation errors that block some advanced template usages,
but can also be used to ensure compile-time calculations.
However, although there are some good uses cases in making templates faster,
SFINAE is an obscure programming technique
that isn't widely used in everyday C++ programming.
Template Meta-Programming.
Further optimization of templated code at compile-time is
possible via the technique called “Template Meta-Programming” (TMP).
Note that this refers to an unusual usage of templates in C++,
where the idea goes beyond just using templates of code for different types
(i.e. normal templating of classes).
TMP is an advanced coding method
that uses (misuses, perhaps) instantiation semantics of templates as a way of
generating compile-time code,
even for some conditional branches.
However, this is an obscure method
that is rarely needed,
because most of the effects can be achieved
via preprocessor macros, function inlining, and using “constexpr” in modern C++.
|
• Next: • Up: Table of Contents |
|
The new AI programming book by Aussie AI co-founders:
Get your copy from Amazon: Generative AI in C++ |