What are the core concepts covered in Compile-Time Metaprogramming: Concepts & consteval?

The evolution from SFINAE (`std::enable_if_t`) to C++20 Concepts and `requires` clauses; Defining custom Concepts (`template concept Numeric = ...`); Immediate functions with `consteval` (guaranteed compile-time calculation with zero binary footprint); Compile-time type introspection using type traits and `if constexpr`

Advanced 24 min readModule: Module 14: Template Metaprogramming: Concepts, Constraints & `consteval`

Compile-Time Metaprogramming: Concepts & consteval

Replace cryptic SFINAE templates with modern C++20 Concepts and Constraints, compile-time function evaluation with `consteval` and `constexpr`, and variadic Fold Expressions.

What You Will Learn in This Lesson

The evolution from SFINAE (`std::enable_if_t`) to C++20 Concepts and `requires` clauses
Defining custom Concepts (`template<typename T> concept Numeric = ...`)
Immediate functions with `consteval` (guaranteed compile-time calculation with zero binary footprint)
Compile-time type introspection using type traits and `if constexpr`

Introduction & Core Concept

Template Metaprogramming in legacy C++ relied on SFINAE (Substitution Failure Is Not An Error), leading to unreadable template code and multi-page compiler error messages. C++20 Concepts and Constraints provide first-class language support for specifying requirements on generic types, while 'consteval' guarantees that complex algorithms execute purely during compilation.

WHY DOES THIS MATTER IN THE REAL WORLD?

Compile-time computation produces zero runtime CPU cost. Calculations like lookup tables, cryptographic hashing, and serialization schemas can be pre-calculated entirely during compilation.

Syntax & Structure

cpp

template<typename T>
concept Serializable = requires(T a) {
  { a.serialize() } -> std::same_as<std::string>;
};
 
consteval int square(int n) { return n * n; }

Type Constraints with C++20 Concepts and consteval Lookups

cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// C++20 Concepts & Compile-Time consteval Evaluation
#include <iostream>
#include <concepts>
#include <array>
 
// 1. Define C++20 Concept for Numerical Calculations
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;
 
template<typename T>
concept PrintableRecord = requires(T item) {
    { item.print() } -> std::same_as<void>;
};
 
// 2. Constrained Function using Concepts
template<Numeric T>
T calculate_compound_interest(T principal, T rate, int years) {
    T result = principal;
    for (int i = 0; i < years; ++i) {
        result *= (1 + rate);
    }
    return result;
}
 
// 3. consteval Immediate Function: MUST execute during compilation!
consteval std::array<int, 5> generate_lookup_table() {
    std::array<int, 5> table{};
    for (int i = 0; i < 5; ++i) {
        table[i] = (i + 1) * (i + 1) * 10; // Pre-calculated square table
    }
    return table;
}
 
int main() {
    std::cout << "=== C++20 Concepts & consteval Metaprogramming ===" << std::endl;
 
    // Guaranteed compile-time table baked directly into the binary's read-only data segment!
    constexpr auto lookup = generate_lookup_table();
    std::cout << "Precomputed Compile-Time Value #3: " << lookup[2] << std::endl;
 
    double balance = calculate_compound_interest(1000.0, 0.05, 3);
    std::cout << "Calculated Compound Balance: $" << balance << std::endl;
 
    // Passing a non-numeric type triggers a clean 1-line compiler error!
    // calculate_compound_interest(std::string("invalid"), ...); // Rejected by concept!
    return 0;
}

Line-by-Line Technical Breakdown

1Fold Expressions: Variadic templates in C++17/20 can be expanded using binary operators: `template<typename... Args> auto sum(Args... args) { return (... + args); }`. This folds all arguments into a single left-associative addition expression at compile time.

Try It Yourself (Interactive Editor)

Modify the code in real-time and click Run to test live browser output and console logs.

Intelligent Code Runner & Live Sandbox[CPP]

CPP SOURCE EDITOR

Interactive Live Code

// C++20 Concepts & Compile-Time consteval Evaluation
#include <iostream>
#include <concepts>
#include <array>

// 1. Define C++20 Concept for Numerical Calculations
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template<typename T>
concept PrintableRecord = requires(T item) {
    { item.print() } -> std::same_as<void>;
};

// 2. Constrained Function using Concepts
template<Numeric T>
T calculate_compound_interest(T principal, T rate, int years) {
    T result = principal;
    for (int i = 0; i < years; ++i) {
        result *= (1 + rate);
    }
    return result;
}

// 3. consteval Immediate Function: MUST execute during compilation!
consteval std::array<int, 5> generate_lookup_table() {
    std::array<int, 5> table{};
    for (int i = 0; i < 5; ++i) {
        table[i] = (i + 1) * (i + 1) * 10; // Pre-calculated square table
    }
    return table;
}

int main() {
    std::cout << "=== C++20 Concepts & consteval Metaprogramming ===" << std::endl;

// Guaranteed compile-time table baked directly into the binary's read-only data segment!
    constexpr auto lookup = generate_lookup_table();
    std::cout << "Precomputed Compile-Time Value #3: " << lookup[2] << std::endl;

double balance = calculate_compound_interest(1000.0, 0.05, 3);
    std::cout << "Calculated Compound Balance: $" << balance << std::endl;

// Passing a non-numeric type triggers a clean 1-line compiler error!
    // calculate_compound_interest(std::string("invalid"), ...); // Rejected by concept!
    return 0;
}

>g++ -std=c++20 -O3 -Wall -Wextra main.cpp -o main

>Build succeeded: 0 errors, 0 warnings.

>=== C++20 Concepts & consteval Metaprogramming ===

>Precomputed Compile-Time Value #3: lookup[2]

>Calculated Compound Balance: $balance

Common Mistakes & How to Avoid Them

#1: Using `constexpr` when `consteval` is required: `constexpr` functions can still fall back to runtime execution if arguments are not constant.

`consteval` enforces strictly compile-time execution. If the compiler cannot evaluate it at build time, it raises a compile-time error.

Incorrect / Antipattern

constexpr int calc(int x) { ... } // May run at runtime if x is not constexpr

Correct / Professional Solution

consteval int calc(int x) { ... } // Compiler ERROR if not evaluated at compile-time

Industry Best Practices & Professional Standards

Use C++20 Concepts to constrain all template parameters for clean compiler diagnostics.
Use `if constexpr` inside templates to eliminate dead conditional branches at compile time.
Use `consteval` for lookup tables, compile-time string hashing, and mathematical constants.

Lesson Summary & Core Takeaways

C++20 Concepts replace legacy SFINAE with clean, expressive type constraints.
`consteval` guarantees function execution during compilation with zero runtime cost.
`if constexpr` branches types conditionally at compile time without runtime overhead.