Skip to content

Search topics & cppreference

Search all study topics, concept maps, and 6,587 C++ and C reference pages.

Concepts library (since C++20)

Move beyond SFINAE enable_if hacks to algebraic atomic constraints, concept subsumption lattices, and readable diagnostics.

NotebookLM
[temp.constr][temp.constr.order][expr.prim.req][temp.res]

Only named concepts participate in atomic constraint subsumption—writing identical raw requires expressions twice produces two distinct atoms and an ambiguous overload!

CppCon angle
Visualize overload selection as a DAG lattice: std::contiguous_iterator subsumes random_access_iterator, which subsumes bidirectional_iterator, letting std::ranges pick the fastest algorithm cleanly.
Common audience trap
Writing requires requires(...) — the first keyword introduces a constraint clause, the second starts a boolean requires-expression.
Stage takeaway
If two constrained overloads ever tie with 'ambiguous call', check whether you wrote an ad-hoc boolean expression instead of composing named concepts.

Named concepts & atomic constraint identity

[temp.constr.atomic] & [temp.constr.order]

During overload resolution, the compiler converts constrained templates into Disjunctive/Conjunctive Normal Form of atomic constraints—each tied to its exact source-code token position and parameter mapping.

If overload A writes template<class T> requires (std::integral<T> && sizeof(T) >= 4) and overload B writes template<class T> requires (std::integral<T> && sizeof(T) >= 4 && alignof(T) >= 4), the sizeof(T) >= 4 expression in A and B came from TWO separate source locations, so neither subsumes the other! Wrapping sizeof(T) >= 4 in a named concept Wide<T> shares one atomic identity.

Subsumption works ONLY through shared named concepts
template <class T>
concept SignedInt = std::integral<T> && std::is_signed_v<T>;

void dispatch(std::integral auto x); // Q: atomic(std::integral)
void dispatch(SignedInt auto x);     // P: atomic(std::integral) && atomic(is_signed)

dispatch(42); // P subsumes Q -> unambiguously calls SignedInt overload!

Key rule: Always factor reusable predicates into named concept declarations if you want overloads to partially order by specificity.

The requires requires idiom decoded

[temp.constr.decl] & [expr.prim.req]

The first requires introduces a requires-clause (expecting a constant boolean expression). The second requires opens a requires-expression—an unevaluated compile-time check returning true if every nested expression compiles.

For real libraries, prefer defining a named concept above the function rather than embedding anonymous requires requires directly on every signature.

Clean named concept vs. inline requires-requires
template <class R>
concept Reservable = requires(R& r, std::size_t n) {
    r.reserve(n);       // simple requirement: must compile (not evaluated)
    { r.capacity() } -> std::convertible_to<std::size_t>; // compound requirement
};

Key rule: Inside a requires-expression, expressions are unevaluated operands—side effects never run, and compound requirements validate return type concepts.

Across revisions (C++17 → C++20 → C++23)

C++17

Added if constexpr to discard untaken compile-time branches, reducing SFINAE tag-dispatch boilerplate.

C++20

Added concepts, requires-clauses, requires-expressions, abbreviated function templates (auto parameters), and standard <concepts> / <iterator> hierarchies.

Full 1:1 cppreference specification

Original specification mirrored from cppreference.com with restyled declaration panels and code windows.

The concepts library provides definitions of fundamental library concepts that can be used to perform compile-time validation of template arguments and perform function dispatch based on properties of types. These concepts provide a foundation for equational reasoning in programs.

Most concepts in the standard library impose both syntactic and semantic requirements. It is said that a standard concept is satisfied if its syntactic requirements are met, and is modeled if it is satisfied and its semantic requirements (if any) are also met.

In general, only the syntactic requirements can be checked by the compiler. If the validity or meaning of a program depends whether a sequence of template arguments models a concept, and the concept is satisfied but not modeled, or if a semantic requirement is not met at the point of use, the program is ill-formed, no diagnostic required.

Equality preservation

An expression is equality-preserving if it results in equal outputs given equal inputs, where

  • the inputs consist of its operands (not neccessarily making the expression semantically valid), and
  • the outputs consist of its result and all modifications to the operands by the expression, if any

where, for convenience of wording, its "operands" refer to its largest sub-expressions that consist of an id-expression or invocations of std::move, std::forward, and std::declval.

The cv-qualification and value category of each operand is determined by assuming that each template type parameter in its type denotes a cv-unqualified complete non-array object type.

Every expression required to be equality preserving is further required to be stable, that is, two evaluations of it with the same input objects must have equal outputs without any explicit intervening modification of those input objects.

Unless noted otherwise, every expression used in a requires expression of the standard library concepts is required to be equality preserving, and the evaluation of the expression may modify only its non-constant operands. Operands that are constant must not be modified.

In the standard library, the following concepts are allowed to have non equality-preserving requires expressions:

Implicit expression variations

A requires expression that uses an expression that is non-modifying for some constant lvalue operand also implicitly requires additional variations of that expression that accept a non-constant lvalue or (possibly constant) rvalue for the given operand unless such an expression variation is explicitly required with differing semantics.

These implicit expression variations must meet the same semantic requirements of the declared expression. The extent to which an implementation validates the syntax of the variations is unspecified.

snippet.cpp
template<class T>
concept C = requires(T a, T b, const T c, const T d)
{
    c == d;           // expression #1: does not modify the operands
    a = std::move(b); // expression #2: modifies both operands
    a = c;            // expression #3: modifies the left operand `a`
};
 
// Expression #1 implicitly requires additional expression variations that
// meet the requirements for c == d (including non-modification),
// as if the following expressions had been declared as well:
 
// ------ const == const ------- ------ const == non-const ---
//                                         c  ==           b;
//            c == std::move(d);           c  == std::move(b);
// std::move(c) ==           d;  std::move(c) ==           b;
// std::move(c) == std::move(d); std::move(c) == std::move(b);
 
// -- non-const == const ------- -- non-const == non-const ---
//           a  ==           d;            a  ==           b;
//           a  == std::move(d);           a  == std::move(b);
// std::move(a) ==           d;  std::move(a) ==           b;
// std::move(a) == std::move(d); std::move(a) == std::move(b);
 
// Expression #3 implicitly requires additional expression variations that
// meet the requirements for a = c
// (including non-modification of the second operand),
// as if the expressions a = b (non-constant lvalue variation)
// and a = std::move(c) (const rvalue variation) had been declared.
 
// Note: Since expression #2 already requires the non-constant rvalue variation
// (a == std::move(b)) explicitly, expression #3 does not implicitly require it anymore.
 
// The type T meets the explicitly stated syntactic requirements of
// concept C above, but does not meet the additional implicit requirements
// (i.e., T satisfies but does not model C):
// a program requires C<T> is ill-formed (no diagnostic required).
struct T
{
    bool operator==(const T&) const { return true; }
    bool operator==(T&) = delete;
};

Standard library concepts

Defined in namespace std
Core language concepts
Defined in header <concepts>
(C++20)
specifies that a type is the same as another type
(concept)
specifies that a type is derived from another type
(concept)
specifies that a type is implicitly convertible to another type
(concept)
specifies that two types share a common reference type
(concept)
specifies that two types share a common type
(concept)
(C++20)
specifies that a type is an integral type
(concept)
specifies that a type is an integral type that is signed
(concept)
specifies that a type is an integral type that is unsigned
(concept)
specifies that a type is a floating-point type
(concept)
specifies that a type is assignable from another type
(concept)
specifies that a type can be swapped or that two types can be swapped with each other
(concept)
specifies that an object of the type can be destroyed
(concept)
specifies that a variable of the type can be constructed from or bound to a set of argument types
(concept)
specifies that an object of a type can be default constructed
(concept)
specifies that an object of a type can be move constructed
(concept)
specifies that an object of a type can be copy constructed and move constructed
(concept)
Comparison concepts
Defined in header <concepts>
 (C++20)
specifies that a type can be used in Boolean contexts
(exposition-only concept*)
specifies that operator == is an equivalence relation
(concept)
specifies that the comparison operators on the type yield a total order
(concept)
Defined in header <compare>
specifies that operator <=> produces consistent result on given types
(concept)
Object concepts
Defined in header <concepts>
(C++20)
specifies that an object of a type can be moved and swapped
(concept)
(C++20)
specifies that an object of a type can be copied, moved, and swapped
(concept)
specifies that an object of a type can be copied, moved, swapped, and default constructed
(concept)
(C++20)
specifies that a type is regular, that is, it is both semiregular and equality_comparable
(concept)
Callable concepts
Defined in header <concepts>
specifies that a callable type can be invoked with a given set of argument types
(concept)
(C++20)
specifies that a callable type is a Boolean predicate
(concept)
(C++20)
specifies that a callable type is a binary relation
(concept)
specifies that a relation imposes an equivalence relation
(concept)
specifies that a relation imposes a strict weak ordering
(concept)

Additional concepts can be found in the iterators library, the algorithms library, and the ranges library.

See also

Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.