Search⌘ K
AI Features
Home
Courses
Master Modern C++

Concepts and Constraints

Explore the role of concepts and constraints in C++20 to write safer and more readable templates. Understand how to define and use concepts, apply standard library constraints, and leverage abbreviated syntax to catch type errors early and formalize template contracts.

We'll cover the following...

One of the biggest frustrations in C++ development has historically been debugging template errors. We have all experienced it: we pass the wrong type to a function, and the compiler spits out hundreds of cryptic error messages pointing deep into a library we didn't write. This happens because standard templates are unrestricted; they accept anything and only fail when they try to use an operation that doesn't exist on that type. C++20 changed this landscape permanently with concepts. Concepts allow us to specify exactly what types a template accepts before the compiler even looks at the function body. By constraining our templates, we make our code robust, readable, and much easier to debug.

The problem with unconstrained templates (before C++20)

Before C++20, templates relied on "duck typing": if it walks like a duck and quacks like a duck, it's a duck. If we wrote a template that adds two numbers, the compiler would accept any type we passed in, as long as that type had a + operator.

If we pass a type that doesn't support addition, the compilation fails, but not where we expect. It fails inside the function logic, often exposing internal details that the caller shouldn't need to understand.

C++ 17
#include <iostream>
#include <vector>
// Unconstrained template (pre-C++20 style)
template <typename T>
T add(T a, T b) {
    return a + b;  // Assumes T supports +
}
int main() {
    std::cout << add(5, 10) << "\n";  // Works
    // Uncommenting the following lines causes a confusing error:
    // std::vector<int> v1, v2;
    // add(v1, v2);  // Fails deep inside template instantiation
}

Let’s understand the issue:

  • The template accepts any type T.

  • The requirement that T must support operator+ is implicit.

  • If we pass a type that does not satisfy this requirement, the compiler fails inside the function body.

  • The error messages often point deep into template internals instead of clearly stating what ...