This is the second article in series C++ Metaprogramming series, you can find the first article here C++ Metaprogramming: Variadic Templates & Fold Expressions. This article will unveil the practical usage of templates and constexpr for compile-time code execution. C++ Metaprogramming: Variadic Templates & Fold Expressions constexpr Introduction Compile-time calculations in C++ allow some operations to be performed during compilation instead of at runtime. This provides a number of advantages: validating data and logic before running the program, reducing overall execution time, and enhancing code safety and reliability. At the same time, of course, there is an additional cost: compilation time could increase significantly, and the code itself may become more difficult to read. In this article we will explore: Compilation mechanisms for computations available in C++ (templates and constexpr)
Examples of non-trivial use of template metaprogramming
Modern capabilities of constexpr (including objects, loops, and algorithms)
Useful features and techniques, which make developer’s life easier.
Potential pitfalls and tips on how to avoid them. Compilation mechanisms for computations available in C++ (templates and constexpr) constexpr Examples of non-trivial use of template metaprogramming Modern capabilities of constexpr (including objects, loops, and algorithms) constexpr Useful features and techniques, which make developer’s life easier. Potential pitfalls and tips on how to avoid them. Templates Metaprogramming - the foundation of compile-time calculations Historically in C++ metaprogramming emerged thanks to templates. They originally were intended for generating generic functions and classes, but over time it was discovered, that recursive templates could be used to preform quite complex computations. Classical examples Example 1: Factorial using template recursion #include <cstdio>

template <int N>
struct Factorial {
    static constexpr int value = N * Factorial<N - 1>::value;
};

template <>
struct Factorial<0> {
    static constexpr int value = 1;
};

int main() {
  printf("%d\n", Factorial<5>::value);
  return 0;
} #include <cstdio>

template <int N>
struct Factorial {
    static constexpr int value = N * Factorial<N - 1>::value;
};

template <>
struct Factorial<0> {
    static constexpr int value = 1;
};

int main() {
  printf("%d\n", Factorial<5>::value);
  return 0;
} Here, the computation of Factorial<5>::value takes place at compile time. However, this approach is difficult to read, requires specializations and overloads the compiler. Factorial<5>::value Example 2: Fibonacci Numbers #include <cstdio>

template <int N>
struct Fibonacci {
    static constexpr int value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value;
};

template <>
struct Fibonacci<0> {
    static constexpr int value = 0;
};

template <>
struct Fibonacci<1> {
    static constexpr int value = 1;
};

int main() {
  printf("%d\n", Fibonacci<10>::value);
  return 0;
} #include <cstdio>

template <int N>
struct Fibonacci {
    static constexpr int value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value;
};

template <>
struct Fibonacci<0> {
    static constexpr int value = 0;
};

template <>
struct Fibonacci<1> {
    static constexpr int value = 1;
};

int main() {
  printf("%d\n", Fibonacci<10>::value);
  return 0;
} Recursive templates are good for demonstrating ideas, but in real enterprise code they quickly become cumbersome. Drawbacks and limitations Debugging complexity: when errors occur in metacode, compiler messages can be extremely confusing.
Increased compilation time: recursive calculations generate numerous instances of templates.
Template limitations: difficulties with condition constructs and local variables. Debugging complexity: when errors occur in metacode, compiler messages can be extremely confusing. Increased compilation time: recursive calculations generate numerous instances of templates. Template limitations: difficulties with condition constructs and local variables. Nevertheless, templates metaprogramming is still successfully used today, including in the modern libraries, though more often for working with types than for purely mathematical operations. Modern approach: constexpr constexpr With the introduction of the constexpr specifier in C++11, template hacks began to take a back seat. The keyword constexpr informs the compiler that a function or an object can (and should, if possible) be evaluated at compile time. constexpr constexpr Basics of constexpr constexpr constexpr functions: They’re regular functions that can be evaluated at compile time if all arguments are known at the compile stage.
constexpr variables: Variables that are initialized by the constant expression.
Limitations:  in constexpr functions, operations that require runtime evaluation - such as a memory allocation with new or calling virtual functions - cannot be used. constexpr functions: They’re regular functions that can be evaluated at compile time if all arguments are known at the compile stage. constexpr constexpr variables: Variables that are initialized by the constant expression. constexpr Limitations:  in constexpr functions, operations that require runtime evaluation - such as a memory allocation with new or calling virtual functions - cannot be used. constexpr new Example 3: Factorial using constexpr constexpr #include <cstdio>

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

int main() {
  printf("%d\n", factorial(5));
  return 0;
} #include <cstdio>

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

int main() {
  printf("%d\n", factorial(5));
  return 0;
} This core is simpler than the template-based version and easier to read. Moreover, if factorial(5) is called with a constant, the result will be computed at compile time. factorial(5) Advanced aspects of constexpr constexpr Conditional operators (if, switch) inside constexpr functions have been available since C++14, which simplifies writing complex logic.


Loops (for, while) have also been allowed inside constexpr since C++14, which makes it easier to create initializer lists, arrays and lookup tables.


constexpr classes: you can declare class constructors and methods as constexpr, which allows creating objects at compile time and invoke their methods.
Example 4:  constexprand loops Conditional operators (if, switch) inside constexpr functions have been available since C++14, which simplifies writing complex logic. Conditional operators (if, switch) inside constexpr functions have been available since C++14, which simplifies writing complex logic. constexpr Loops (for, while) have also been allowed inside constexpr since C++14, which makes it easier to create initializer lists, arrays and lookup tables. Loops (for, while) have also been allowed inside constexpr since C++14, which makes it easier to create initializer lists, arrays and lookup tables. constexpr constexpr classes: you can declare class constructors and methods as constexpr, which allows creating objects at compile time and invoke their methods.
Example 4:  constexprand loops constexpr classes: you can declare class constructors and methods as constexpr, which allows creating objects at compile time and invoke their methods. constexpr constexpr Example 4:  constexprand loops constexpr #include <cstdio>

constexpr int sum_to_n(int n) {
    int sum = 0;
    for (int i = 1; i <= n; ++i) {
        sum += i;
    }
    return sum;
}

int main() {
  printf("%d\n", sum_to_n(15));
  return 0;
} #include <cstdio>

constexpr int sum_to_n(int n) {
    int sum = 0;
    for (int i = 1; i <= n; ++i) {
        sum += i;
    }
    return sum;
}

int main() {
  printf("%d\n", sum_to_n(15));
  return 0;
} Example 5:  constexpr and classes constexpr #include <cstdio>
#include <cmath>

struct Point {
    int x, y;

    constexpr Point(int x, int y) : x(x), y(y) {}
    constexpr float len() const { return sqrt(x * x + y * y); }
};

constexpr Point p(3, 4);

int main() {
  printf("%f\n", p.len());
  return 0;
} #include <cstdio>
#include <cmath>

struct Point {
    int x, y;

    constexpr Point(int x, int y) : x(x), y(y) {}
    constexpr float len() const { return sqrt(x * x + y * y); }
};

constexpr Point p(3, 4);

int main() {
  printf("%f\n", p.len());
  return 0;
} Useful features for compile-time computations static_assert : allows performing checks at compile-time
static_assert(sizeof(void*) == 8, "64-bit platform expected");

or using Example 4
static_assert(sum_to_n(15) == 120, "Something went wrong");



if constexpr (C++17): simplified form of conditional operators in templates
#include <iostream>

template <typename T>
void print_type_info(const T& val) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "Integer: " << val << std::endl;
    } else {
        std::cout << "Not an integer" << std::endl;
    }
}

int main() {
  print_type_info(15);
  return 0;
}

Here, the brunch that doesn’t satisfy the condition won’t be compiled at all if the check occurs at compile time.


Compile-time array and table generation: convenient for precomputing values
constexpr int squares[] = {
    1*1, 2*2, 3*3, 4*4, 5*5
};



Creating complex structures: you can declare an entire object as constexpr if all of its initialization methods are also constexpr. static_assert : allows performing checks at compile-time
static_assert(sizeof(void*) == 8, "64-bit platform expected");

or using Example 4
static_assert(sum_to_n(15) == 120, "Something went wrong"); static_assert : allows performing checks at compile-time static_assert static_assert(sizeof(void*) == 8, "64-bit platform expected"); static_assert(sizeof(void*) == 8, "64-bit platform expected"); or using Example 4 static_assert(sum_to_n(15) == 120, "Something went wrong"); static_assert(sum_to_n(15) == 120, "Something went wrong"); if constexpr (C++17): simplified form of conditional operators in templates
#include <iostream>

template <typename T>
void print_type_info(const T& val) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "Integer: " << val << std::endl;
    } else {
        std::cout << "Not an integer" << std::endl;
    }
}

int main() {
  print_type_info(15);
  return 0;
}

Here, the brunch that doesn’t satisfy the condition won’t be compiled at all if the check occurs at compile time. if constexpr (C++17): simplified form of conditional operators in templates if constexpr #include <iostream>

template <typename T>
void print_type_info(const T& val) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "Integer: " << val << std::endl;
    } else {
        std::cout << "Not an integer" << std::endl;
    }
}

int main() {
  print_type_info(15);
  return 0;
} #include <iostream>

template <typename T>
void print_type_info(const T& val) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "Integer: " << val << std::endl;
    } else {
        std::cout << "Not an integer" << std::endl;
    }
}

int main() {
  print_type_info(15);
  return 0;
} Here, the brunch that doesn’t satisfy the condition won’t be compiled at all if the check occurs at compile time. Compile-time array and table generation: convenient for precomputing values
constexpr int squares[] = {
    1*1, 2*2, 3*3, 4*4, 5*5
}; Compile-time array and table generation: convenient for precomputing values constexpr int squares[] = {
    1*1, 2*2, 3*3, 4*4, 5*5
}; constexpr int squares[] = {
    1*1, 2*2, 3*3, 4*4, 5*5
}; Creating complex structures: you can declare an entire object as constexpr if all of its initialization methods are also constexpr. Creating complex structures: you can declare an entire object as constexpr if all of its initialization methods are also constexpr. constexpr constexpr Combining Templates and constexpr constexpr Although constexpr often simplifies the task, there are situations in which templates remain necessary: constexpr Need to determine type characteristics, for example determine if a type is an array, a pointer, etc.
Need to store a compile-time list of types (using std::tuple or custom structures) Need to determine type characteristics, for example determine if a type is an array, a pointer, etc. Need to store a compile-time list of types (using std::tuple or custom structures) std::tuple Often it is more efficient and clear to perform all calculations using constexpr, and to use templates only where metaprogramming on types is truly needed. This approach strikes a balance between flexibility and ease of debugging. constexpr Pitfalls Compilation Time: Extensive use of metaprogramming and constexpr can significantly increase build times.
Expression Limitations: Not all operations are allowed in constexpr functions requiring full runtime support are prohibited.
Potential Hidden Copies: When using complex objects in constexpr functions, unexpected copies may occur if methods aren’t declared as constexpr or aren't properly optimized.
Debugging Complexity: If an error occurs inside a constexpr function, it’s not always easy to pinpoint the exact location. Compilation Time: Extensive use of metaprogramming and constexpr can significantly increase build times. constexpr Expression Limitations: Not all operations are allowed in constexpr functions requiring full runtime support are prohibited. constexpr Potential Hidden Copies: When using complex objects in constexpr functions, unexpected copies may occur if methods aren’t declared as constexpr or aren't properly optimized. constexpr constexpr Debugging Complexity: If an error occurs inside a constexpr function, it’s not always easy to pinpoint the exact location. constexpr Conclusion Conclusion Modern C++ offers developers a wide range of tools for organizing compile-time computations - from classic template-based metaprogramming to the more intuitive and flexible constexpr. When used wisely, these tools can significantly improve code performance and safety by catching entire classes of errors early. constexpr At the same time, it's important to weigh the trade-offs: will your code turn into an unreadable monolith, or will compilation times become unreasonably long? Within reasonable limits, metaprogramming and constexpr can make your project more efficient and reliable, offering tangible benefits when developing large-scale systems. constexpr Try It Yourself on GitHub If you want to explore these examples hands-on, feel free to visit my GitHub repository where you’ll find all the source files for the code in this article. You can clone the repository, open the code in your favorite IDE or build system, and experiment with constexpr to see how the compiler works with it. Enjoy playing around with the examples! GitHub repository constexpr Follow me Follow me LinkedIn LinkedIn Github Github

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

GitHub

Accelerating Neural Networks: The Power of Quantization

C++ Metaprogramming: Variadic Templates & Fold Expressions—Now with 100% Less Headaches

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

C++ Metaprogramming: Compilation of Calculations, from Basic Techniques to Advanced Methods

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

A Practical Guide to Machine Learning for Business

The Noonification: What is the InfiniteNature-Zero AI Model? (11/19/2022)

10 Most Popular Programming Languages | 2022

14 Big Ideas for 2023: Why Crypto is Here to Stay

The Noonification: Love is in the Air (2/14/2023)

A Practical Guide to Machine Learning for Business

The Noonification: What is the InfiniteNature-Zero AI Model? (11/19/2022)

10 Most Popular Programming Languages | 2022

14 Big Ideas for 2023: Why Crypto is Here to Stay

The Noonification: Love is in the Air (2/14/2023)

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps