What is template for in C++26

If you’re exploring the latest features of C++26, you’ve probably come across the term template for. It’s a new and exciting addition to the C++ programming language, designed to make compile-time programming easier and more powerful. But what exactly is template for in C++26, and how can you use it in your code?

Why C++26 Matters

C++ is a powerful, high-performance programming language used for everything from game development to operating systems. Every few years, the C++ standard evolves, introducing new features to make coding faster, safer, and more flexible. C++26, the next major release after C++23, is set to bring exciting changes, including improved reflection and the template for construct.

C++26 builds on the Standard Template Library (STL), generic programming, and compile-time features introduced in earlier standards like C++11, C++17, and C++20. The template for feature is particularly tied to reflection, a new capability that lets programs inspect their own structure at compile time. Let’s dive into what template for is and why it’s a game-changer.

What is `template for` in C++26?

The template for construct is a new type of loop introduced in C++26 for compile-time iteration. Unlike regular for loops, which run at runtime, template for loops are executed entirely at compile time. This means the compiler “unrolls” the loop, generating code for each iteration during compilation, not when the program runs.

Think of template for as a way to repeat a block of code at compile time, substituting different values or types for each iteration. It’s especially useful for tasks like reflection, where you need to process metadata (e.g., class members or enum values) during compilation.

Key Features of `template for`

Compile-Time Execution: The loop runs during compilation, producing static code.
Reflection Integration: Often used with C++26’s reflection features to iterate over metadata.
Type Safety: Works with C++’s strong typing system for safe, generic code.
Flexible Iteration: Supports iterating over packs, ranges, and tuples.

template for was proposed in the C++26 reflection paper (P2996R0) and is designed to simplify metaprogramming tasks that were previously complex or verbose.

How Does `template for` Differ from Other Loops?

To understand template for, let’s compare it to other C++ loops:

Regular for Loop: Runs at runtime, iterating over data like arrays or vectors. Example:for (int i = 0; i < 5; ++i) { std::cout << i << "\n"; }
Range-Based for Loop: Also runtime, iterates over containers like std::vector. Example:for (auto x : {1, 2, 3}) { std::cout << x << "\n"; }
Template Metaprogramming (Pre-C++26): Uses recursive templates or std::tuple to achieve compile-time iteration, but it’s verbose and hard to read.
template for: Runs at compile time, generating code for each iteration. It’s cleaner and more intuitive than older metaprogramming techniques.

The key difference is that template for is a compile-time expansion statement. Instead of executing the loop N times at runtime, the compiler “stamps out” N copies of the loop body during compilation, each with different values or types.

Syntax of `template for`

The syntax of template for is similar to a range-based for loop but with the template keyword to indicate compile-time behavior. Here’s the basic structure:

template for (constexpr auto variable : range) {
    // Code to be expanded at compile time
}

template: Signals that this is a compile-time construct.
constexpr auto variable: Declares a compile-time constant variable for each iteration.
range: A compile-time range, pack, or tuple to iterate over.
{}: The body of the loop, which is unrolled for each element in the range.

The constexpr keyword ensures the variable is evaluated at compile time, making it usable in contexts like template arguments or reflection splices.

Use Cases for `template for` in C++26

The template for construct shines in scenarios where you need to process data at compile time, especially with C++26’s reflection features. Here are some common use cases:

1. Enum-to-String Conversion

One of the most cited examples for template for is converting an enum value to its string representation. In C++26, reflection allows you to access an enum’s enumerators (values) at compile time. template for makes it easy to iterate over them.

Here’s an example:

#include <string>
#include <meta>

enum class Color { Red, Green, Blue };

template <typename E>
requires std::is_enum_v<E>
constexpr std::string enum_to_string(E value) {
    template for (constexpr auto e : std::meta::enumerators_of(^^E)) {
        if (value == [:e:]) {
            return std::string(std::meta::identifier_of(e));
        }
    }
    return "<unknown>";
}

^^E: A reflection operator to get metadata about the enum type E.
std::meta::enumerators_of: Returns a compile-time range of enum values.
[:e:]: A splice to access the enum value at compile time.
template for: Iterates over each enumerator, checking if it matches value.

This code generates a function that converts Color::Red to "Red", Color::Green to "Green", etc., all at compile time.

2. Iterating Over Class Members

Another powerful use case is iterating over a class’s non-static data members for tasks like serialization or printing. Here’s an example:

#include <meta>
#include <string>

struct Person {
    std::string name;
    int age;
};

template <class T>
void print_members(const T& obj) {
    std::print("{");
    bool first = true;
    constexpr auto ctx = std::meta::access_context::unchecked();
    template for (constexpr auto mem : define_static_array(std::meta::nonstatic_data_members_of(^^T, ctx))) {
        if (!first) {
            std::print(", ");
        }
        first = false;
        std::print(".{}={}", std::meta::identifier_of(mem), obj.[:mem:]);
    }
    std::print("}");
}

This code prints a Person object like {name=Alice, age=30}. The template for loop iterates over the class’s members, accessing their names and values at compile time.

3. Iterating Over Parameter Packs

template for can also iterate over parameter packs, simplifying variadic template code. Example:

template <class... Ts>
void print_all(Ts... ts) {
    template for (auto t : {ts...}) {
        std::println("{}", t);
    }
}

This function prints each argument in the pack ts. The template for loop unrolls the pack at compile time, generating a std::println call for each argument.

4. Tuple Iteration

You can use template for to iterate over a std::tuple, checking types at compile time. Example:

#include <tuple>

void process_tuple() {
    int x = 1;
    template for (auto p : std::tuple(x, &x)) {
        if constexpr (std::is_pointer_v<decltype(p)>) {
            std::println("{}", *p);
        }
    }
}

This code checks each tuple element’s type and only dereferences pointers. The template for loop ensures the logic is expanded at compile time.

How `template for` Works Under the Hood

To appreciate template for, it’s helpful to understand what happens during compilation. When the compiler encounters a template for loop, it:

Evaluates the Range: The range (e.g., std::meta::enumerators_of or a tuple) must be a compile-time constant expression.
Unrolls the Loop: For each element in the range, the compiler generates a copy of the loop body, substituting the loop variable (e in the enum example).
Generates Code: The result is a sequence of statements, as if you wrote them manually. For example:template for (constexpr auto e : {1, 2, 3}) { std::println("{}", e); } Expands to:std::println("{}", 1); std::println("{}", 2); std::println("{}", 3);

This process, called expansion, ensures no runtime overhead. The generated code is as efficient as handwritten code.

Requirements for the Range in `template for`

The right-hand side of a template for loop (the range) must meet specific requirements:

Compile-Time Evaluatable: The range must be a constexpr expression, like a std::vector<std::meta::info> or a tuple.
Random-Access Range: For now, C++26 requires random-access ranges (e.g., arrays or vectors), not just forward ranges.
Static Elements: Each element must be usable as a constexpr value, especially for reflection splices like [:e:].

For reflection, functions like std::meta::enumerators_of return a std::vector<std::meta::info>, but since std::vector allocates memory, you often need a workaround like define_static_array to ensure static storage.

Comparison: `template for` vs. Other Compile-Time Techniques

Before template for, C++ programmers used other methods for compile-time iteration. Let’s compare them:

Recursive Templates

Older C++ code used recursive template functions to iterate over types or values. Example:

template <size_t I = 0, typename... Ts>
void print_tuple(const std::tuple<Ts...>& t) {
    if constexpr (I < sizeof...(Ts)) {
        std::cout << std::get<I>(t) << "\n";
        print_tuple<I + 1>(t);
    }
}

This is verbose and error-prone. template for is much cleaner.

`std::apply` with Lambdas

C++17 introduced std::apply to process tuples, but it’s still runtime-focused:

std::apply([](auto... args) {
    (std::cout << ... << args);
}, std::tuple(1, 2, 3));

template for is more flexible for compile-time tasks.

Table: `template for` vs. Alternatives

Feature	`template for`	Recursive Templates	`std::apply`
Compile-Time	Yes	Yes	Partial
Readability	High	Low	Medium
Reflection Support	Excellent	Poor	None
Break/Continue Support	Yes	No	No

template for is a clear winner for modern C++ metaprogramming.

Advantages of `template for`

Why should you use template for in your C++26 projects? Here are the benefits:

Simpler Code: Replaces complex recursive templates with a familiar loop syntax.
Better Debugging: Compile-time errors are easier to understand than template recursion errors.
Reflection Power: Makes it easy to work with C++26’s reflection API.
Efficiency: No runtime overhead, as all work is done at compile time.
Flexibility: Supports packs, ranges, tuples, and reflection metadata.

Challenges and Limitations

While template for is powerful, it has some limitations:

Compiler Support: As of July 2025, C++26 is still in development, and not all compilers fully support template for.
Learning Curve: If you’re new to compile-time programming or reflection, the syntax may feel unfamiliar.
Range Restrictions: Requires random-access ranges, which may limit some use cases.
Memory Constraints: Reflection ranges like std::vector<std::meta::info> need static storage workarounds.

Despite these challenges, template for is a significant step forward for C++ metaprogramming.

Getting Started with `template for`

Ready to try template for? Here’s how to get started:

Use a C++26 Compiler: Ensure your compiler (e.g., GCC, Clang, or MSVC) supports C++26 features. Check for experimental flags like -std=c++26.
Include Reflection Headers: Use <meta> for reflection functions like std::meta::enumerators_of.
Experiment with Examples: Start with the enum-to-string example above.
Read the Standard: The C++26 reflection paper (P2996R0) provides detailed insights.
Join Communities: Discuss template for on platforms like Stack Overflow or the C++ subreddit.

FAQs About `template for` in C++26

What is the difference between `template for` and a regular `for` loop?

A regular for loop runs at runtime, while template for runs at compile time, generating code for each iteration.

Is `template for` only for reflection?

No, it’s versatile and can iterate over packs, tuples, or ranges, but it’s most powerful with reflection.

Can I use `template for` with runtime data?

No, template for is strictly compile-time. Use regular loops for runtime iteration.

Does `template for` support `break` and `continue`?

Yes, it supports break and continue with standard loop semantics.

Conclusion: Embrace `template for` in C++26

The template for construct in C++26 is a powerful tool for compile-time iteration, making metaprogramming and reflection more accessible. Whether you’re converting enums to strings, processing class members, or iterating over parameter packs, template for simplifies complex tasks with a clean, intuitive syntax.

As C++26 rolls out, template for will become a staple for developers working on generic, type-safe, and efficient code. Start experimenting with it today, and you’ll be ahead of the curve in C++ template programming.

Have questions about template for C++26? Share them in the comments below!

Resource: For more details, read the C++26 Reflection Proposal (P2996R0).

Why C++26 Matters

What is template for in C++26?

Key Features of template for

How Does template for Differ from Other Loops?

Syntax of template for

Use Cases for template for in C++26

1. Enum-to-String Conversion

2. Iterating Over Class Members

3. Iterating Over Parameter Packs

4. Tuple Iteration

How template for Works Under the Hood

Requirements for the Range in template for

Comparison: template for vs. Other Compile-Time Techniques

Recursive Templates

std::apply with Lambdas

Table: template for vs. Alternatives

Advantages of template for