Modern template metaprogramming basics

May 23, 2024

Template metaprogramming essentially allows you to write Python-like dynamic code at compile time, while still maintaining the performance of a statically typed language at runtime. (You can even call a template function “dynamically” through template argument deduction.) C++ template programming uses template instantiation to perform computation at compile time: that is, there is no run time cost. It is likely Turing complete, meaning that you can write any program using it. This is a very powerful tool that can be used to write more efficient code, but it can also be very difficult to understand and debug.

Introduction

Specializations don’t participate in overload resolution

The compiler seeks to instantiate the template with the most specialized type. It’s wrong to use function template specialization to provide a “better match” for a particular type. The reason is that function template specializations don’t participate in overload resolution. The compiler will always choose the most specialized function template, not the most specialized function template specialization. If there are multiple function template specializations that are equally specialized, the compiler will throw an error because it can’t decide which specialization to use.

Dimov and Abrahams provide a good explanation of this behavior. Base template (b) is more specialized than (a) because it is more specific. The compiler will choose the more specialized template. If (c) is a speicialization of (b), the compiler will choose (c) over (b) because it is more specialized.

template<class T> // (a) a base template
void f( T );

template<class T> // (b) a second base template, overloads (a)
void f( T* );     //     (function templates can't be partially
                  //     specialized; they overload instead)

template<>        // (c) explicit specialization of (b)
void f<>(int*);

// ...

int *p;
f( p );           // calls (c)

template<class T> // (a) same old base template as before
void f( T );

template<>        // (c) explicit specialization, this time of (a)
void f<>(int*);

template<class T> // (b) a second base template, overloads (a)
void f( T* );

// ...

int *p;
f( p );           // calls (b)! overload resolution ignores
                  // specializations and operates on the base
                  // function templates only

Avoid specializing function templates. Instead, prefer to write a single function template that should never be specialized or overloaded, and then implement the function template entirely as a simple handoff to a class template containing a static function with the same signature. Everyone can specialize that – both fully and partially, and without affecting the results of overload resolution.

Nontemplate functions are first-class citizens. A plain old nontemplate function that matches the parameter types as well as any function template will be selected over an otherwise-just-as-good function template.

If there are no first-class citizens to choose from that are at least as good, then function base templates as the second-class citizens get consulted next. Which function base template gets selected depends on which matches best and is the “most specialized” (important note: this use of “specialized” oddly enough has nothing to do with template specializations; it’s just an unfortunate colloquialism) according to a set of fairly arcane rules:

• If it’s clear that there’s one “most specialized” function base template, that one gets used. If that base template happens to be specialized for the types being used, the specialization will get used, otherwise the base template instantiated with the correct types will be used.
• Else if there’s a tie for the “most specialized” function base template, the call is ambiguous because the compiler can’t decide which is a better match. The programmer will have to do something to qualify the call and say which one is wanted.
• Else if there’s no function base template that can be made to match, the call is bad and the programmer will have to fix the code.

The rationale for why specializations don’t participate in overloading is simple, once explained, because the surprise factor is exactly the reverse: The standards committee felt it would be surprising that, just because you happened to write a specialization for a particular template, that it would in any way change which template gets used. Under that rationale, and since we already have a way of making sure our version gets used if that’s what we want (we just make it a function, not a specialization), we can understand more clearly why specializations don’t affect which template gets selected.

Moral #1: If you want to customize a function base template and want that customization to participate in overload resolution (or, to always be used in the case of exact match), make it a plain old function, not a specialization. And, if you do provide overloads, avoid also providing specializations.

But what if you’re the one who’s writing, not just using, a function template? Can you do better and avoid this (and other) problem(s) up front, for yourself and for your users? Indeed you can:

Moral #2: If you’re writing a function base template, prefer to write it as a single function template that should never be specialized or overloaded, and then implement the function template entirely as a simple handoff to a class template containing a static function with the same signature. Everyone can specialize that – both fully and partially, and without affecting the results of overload resolution.

Dependent Names

A dependent name is a name that depends on a template parameter. The compiler doesn’t know what the name is until the template is instantiated. Dan Saks provides a good example of a dependent name in his CppCon talk:

template <typename T>
T::size_type munge(T const& a) {
    T::size_type * i(T::npos);
}

• If T::size_type is a type and T::npos is a type, the code above is a function declaration.
• If T::size_type is a type and T::npos is a constant, objection, or function, the code above is an object definition.
• If T::size_type is not a type and T::npos is not a type, the code above is a multiplication.

The solution is to use the typename keyword to tell the compiler that T::size_type is a type and let the compiler know that T::npos is not a type.

template <typename T>
typename T::size_type munge(T const& a) {
    typename T::size_type * i(T::npos);
}

Partial Specialization

Partial specialization is a way to specialize a template for a subset of types. It is used to provide a more specialized implementation for a subset of types. For example, you can specialize a template for a pointer type. The syntax for partial specialization is as follows:

template <typename T>
class A {
    // general implementation
};

template <typename T>
class A<T*> {
    // specialized implementation for pointer types
};

You can’t partially specialize a function template. You can only partially specialize a class template. If you need to specialize a function template, you can use function overloading.

template <typename T>
void f(T t) {
    // general implementation
}

// ERROR: you can't partially specialize a function template
template <typename T>
void f<T*>(T* t) {
    // specialized implementation for pointer types
}

// Use function overloading instead
template <typename T>
void f(T* t) {
    // specialized implementation for pointer types
}

// Full specialization of a function template
// This is allowed but not recommended
template <>
void f<int>(int t) {
    // specialized implementation for int types
}

// Also a full specialization of a function template
// This is allowed but not recommended
template <>
void f(double* t) {
    // specialized implementation for int pointer types
}

Traits

Traits are a way to provide information about a type. They are used to provide compile-time information about a type. For example, you can use traits to determine if a type is a pointer type. The syntax for traits is as follows:

template <typename T>
struct is_pointer {
    static const bool value = false;
};

template <typename T>
struct is_pointer<T*> {
    static const bool value = true;
};

Standard library provides a set of traits in the <type_traits> header. For example, you can use std::is_pointer to determine if a type is a pointer type. The syntax for using std::is_pointer is as follows:

#include <type_traits>
#include <fmt/core.h>

int main() {
    fmt::print("{}\n", std::is_pointer<int>::value); // 0
    fmt::print("{}\n", std::is_pointer<int*>::value); // 1
}

Trait type and value members are used to provide information about a type. The type member is used to provide information about the type of a type. The value member is used to provide information about the value of a type. For example, you can use the type member to determine the type of a type. The syntax for using the type member is as follows:

#include <type_traits>
#include <fmt/core.h>

int main() {
    fmt::print("{}\n", std::is_pointer<int>::type);  // std::false_type
    fmt::print("{}\n", std::is_pointer<int*>::type); // std::true_type


    fmt::print("{}\n", std::is_pointer_v<int>);  // 0
    fmt::print("{}\n", std::is_pointer_v<int*>); // 1

    fmt::print("{}\n", std::is_pointer_t<int>);  //std::false_type
    fmt::print("{}\n", std::is_pointer_t<int*>); //std::true_type
}

Variadic Templates

Variadic templates are a way to write templates that can take a variable number of arguments. They are used to write templates that can take a variable number of arguments. For example, you can use variadic templates to write a function that takes a variable number of arguments. The syntax for variadic templates is as follows:

template <typename... Args>
void f(Args... args) {
    // implementation for variadic templates
}

Constexpr

Constexpr is a way to write functions that can be evaluated at compile time. In C++, both const and constexpr are used to define constant values, but they have different purposes and characteristics. const values can be determined at runtime, while constexpr values must be determined at compile time. constexpr usually requires less instantiation overhead template metaprogramming. In case memorization is needed however template metaprogramming would reuse the same instantiation or constexpr might recompute and require longer compile time.

#include <iostream>
#include <type_traits>

template <typename T>
void print_type_info(T) {
    if (std::is_pointer<T>::value) {
        std::cout << "Pointer to ";
        print_type_info(typename std::remove_pointer<T>::type());
    } else {
        std::cout << typeid(T).name() << std::endl;
    }
}

template <typename T> struct add_pointer {
    using type = T*;
};

int main() {
    using int_ptr = add_pointer<int>::type; // int_ptr is int*
    int value = 42;
    int_ptr ptr = &value;

    print_type_info(value); // Outputs: int
    print_type_info(ptr); // Outputs: Pointer to int

    return 0;
}

Template metaprogramming is more expressive with return type deduction.

#include <iostream>
#include <type_traits>

template <typename T>
constexpr auto add_pointer() {
    return typename std::add_pointer<T>::type{};
}

int main() {
    int value = 42;
    auto ptr = add_pointer<int>(); // ptr is of type int*

    if constexpr (std::is_pointer_v<decltype(ptr)>) {
        std::cout << "ptr is a pointer to int" << std::endl;
    } else {
        std::cout << "ptr is not a pointer" << std::endl;
    }

    return 0;
}

Concepts

Substitution Failure Is Not An Error (SFINAE) is a C++ template metaprogramming technique that allows you to write code that will not compile if a certain condition is not met. It is used to enable or disable a template based on a condition. For example, you can use SFINAE to enable a template if a type has a certain member function. The syntax for SFINAE is as follows:

template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
f(T t) {
    // implementation for integral types
}

With C++20, you can use concepts to enable or disable a template based on a condition. Concepts are a way to define requirements for a template. For example, you can use concepts to require that a type has a certain member function. The syntax for a simple concept is as follows:

include <type_traits>
#include <iostream>

// Define a concept for integral types
template <class T>
concept integral = std::is_integral_v<T>;

// A function that requires its parameter type to be integral
template<integral T>
void printIntegral(T value) {
    std::cout << value << std::endl;
}

int main() {
    int x = 5;
    printIntegral(x); // Works fine, int is an integral type

    // double y = 5.5;
    // printIntegral(y); 
    // Error, double is not an integral type
}

requires keyword

requires keyword in C++20 is one of the most powerful tools introduced with concepts, and it comes in two forms: the requires clause and the requires expression. Each serves different purposes in specifying constraints for template parameters. Let’s explore both forms: requires clause and requires expression.

The requires clause is used to specify constraints directly on template parameters. It is placed after the template parameter list and before the function body or type definition.

#include <iostream>
#include <type_traits>

// A function template with a requires clause
template<typename T>
requires std::is_integral_v<T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(3, 4) << std::endl; // Works fine, int is integral
    // std::cout << add(3.5, 4.5) << std::endl; // Error, double is not integral
}

The requires expression is used to define more complex constraints. It can be used within the definition of concepts to specify a set of requirements that must be met for a type to satisfy the concept. This form allows checking for the validity of specific expressions, the presence of member functions, operator overloads, etc.

#include <concepts>
#include <type_traits>
#include <iostream>

// Define a concept for a type that supports addition and is integral
template<typename T>
concept AddableAndIntegral = requires(T a, T b) {
    { a + b } -> std::same_as<T>; 
    // The expression 'a + b' must be valid and return type must be T
} && std::is_integral_v<T>; // The type must be integral

// A function that requires its parameter type to be AddableAndIntegral
template<AddableAndIntegral T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(3, 4) << std::endl; // Works fine, int supports addition and is integral

    // std::cout << add(3.5, 4.5) << std::endl; 
    // Error, double is not an integral type
    
    // std::cout << add("Hello, ", "World!") << std::endl; 
    // Error, std::string does not support addition and is not integral
}

#include <numeric>
#include <vector>
#include <iostream>
#include <concepts>

template <typename T> 
requires std::integral<T> || std::floating_point<T>
constexpr double Average(std::vector<T> const &vec) {
    const double sum = std::accumulate(vec.begin(), vec.end(), 0.0);        
    return sum / vec.size();
}

int main() {
    std::vector ints { 1, 2, 3, 4, 5};
    st
    std::cout << Average(ints) << std::endl; // 3
}

Some of the most common concepts are defined in the <concepts> header. Here are some of the most common concepts: