Mastering C++ Concepts: Simplify Template Constraints and Boost Compile‑Time Safety

Introduction

Templates have been a crucial line in the evolution of C++, and concepts represent the most significant recent feature. This article explains C++ concepts in depth.

Historical background of templates

Templates were first envisioned in 1982 and formally introduced at the 1998 USENIX C++ Conference. They were created to provide generic containers such as vector and list before the standard library existed. By 1998 templates were already Turing‑complete, allowing recursion, specialization, and partial specialization to implement loops and branches at compile time.

Example of a compile‑time Fibonacci using templates:

template<int N>
int fibonacci() {
    return fibonacci<N-1>() + fibonacci<N-2>();
}
template<> int fibonacci<1>() { return 1; }
template<> int fibonacci<0>() { return 0; }

SFINAE guarantees the recursion termination, and with C++17 if constexpr the same logic becomes clearer:

template<int N>
constexpr int fibonacci() {
    if constexpr (N <= 1) return N;
    else return fibonacci<N-1>() + fibonacci<N-2>();
}
auto val = fibonacci<5>();

What is a concept?

A concept is a set of constraints on a template parameter T. For example, an Integral concept can be defined as:

template<typename T>
concept Integral = std::is_integral_v<T>;

template<Integral T>
bool equal(const T& a, const T& b) {
    return a == b;
}

Attempting to instantiate equal with floating‑point types results in a compile‑time error, ensuring the function is used only with integral types.

Why use concepts?

Improved readability compared with std::enable_if or SFINAE.

Reduced code duplication.

Clearer and more direct error messages when a constraint is not satisfied.

Four ways to constrain T

template<my_concept T> void func(T t);
void func(my_concept t);
template<typename T> requires my_concept<T> void func(T t);
template<typename T> void func(T t) requires my_concept<T>;

Using requires clauses allows combination of multiple concepts, e.g.:

template<typename T> requires concept_a<T> && concept_b<T> || sizeof(T) == 4
void func(T t);

Built‑in concepts

The header <concept> provides a rich set of standard concepts covering core language, comparison, object, callable, iterator, and range categories.

Defining your own concept

A user‑defined concept follows the pattern:

template<typename T>
concept MyConcept = /* constraint expression */;

Concept definitions cannot be recursive and cannot be constrained by other concepts.

Requires expressions

The requires keyword can also introduce a requires‑expression that lists arbitrary compile‑time checks, such as simple expressions, type requirements, compound requirements, and nested requirements.

Conclusion

Concepts are a mechanism for expressing constraints; the constraints themselves are the goal. They bring template programming closer to natural language, making generic code safer and easier to understand.