Concepts library (C++20)

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Concepts library

Core language concepts same_as derived_from convertible_to common_reference_with common_with integral signed_integral unsigned_integral floating_point swappableswappable_with destructible constructible_from default_initializable move_constructible copy_constructible assignable_from

Comparison concepts equality_comparableequality_comparable_with totally_orderedtotally_ordered_with Object concepts movable copyable semiregular regular Callable concepts invocableregular_invocable predicate relation equivalence_relation strict_weak_order

 

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.

Defined in namespace std
Core language concepts
Defined in header <concepts>
same_as (C++20)	specifies that a type is the same as another type (concept)
derived_from (C++20)	specifies that a type is derived from another type (concept)
convertible_to (C++20)	specifies that a type is implicitly convertible to another type (concept)
common_reference_with (C++20)	specifies that two types share a common reference type (concept)
common_with (C++20)	specifies that two types share a common type (concept)
integral (C++20)	specifies that a type is an integral type (concept)
signed_integral (C++20)	specifies that a type is an integral type that is signed (concept)
unsigned_integral (C++20)	specifies that a type is an integral type that is unsigned (concept)
floating_point (C++20)	specifies that a type is a floating-point type (concept)
assignable_from (C++20)	specifies that a type is assignable from another type (concept)
swappableswappable_with (C++20)	specifies that a type can be swapped or that two types can be swapped with each other (concept)
destructible (C++20)	specifies that an object of the type can be destroyed (concept)
constructible_from (C++20)	specifies that a variable of the type can be constructed from or bound to a set of argument types (concept)
default_initializable (C++20)	specifies that an object of a type can be default constructed (concept)
move_constructible (C++20)	specifies that an object of a type can be move constructed (concept)
copy_constructible (C++20)	specifies that an object of a type can be copy constructed and move constructed (concept)
Comparison concepts
Defined in header <concepts>
boolean-testable (C++20)	specifies that a type can be used in Boolean contexts (exposition-only concept)
equality_comparableequality_comparable_with (C++20)	specifies that operator == is an equivalence relation (concept)
totally_orderedtotally_ordered_with (C++20)	specifies that the comparison operators on the type yield a total order (concept)
Defined in header <compare>
three_way_comparablethree_way_comparable_with (C++20)	specifies that operator <=> produces consistent result on given types (concept)
Object concepts
Defined in header <concepts>
movable (C++20)	specifies that an object of a type can be moved and swapped (concept)
copyable (C++20)	specifies that an object of a type can be copied, moved, and swapped (concept)
semiregular (C++20)	specifies that an object of a type can be copied, moved, swapped, and default constructed (concept)
regular (C++20)	specifies that a type is regular, that is, it is both semiregular and equality_comparable (concept)
Callable concepts
Defined in header <concepts>
invocableregular_invocable (C++20)	specifies that a callable type can be invoked with a given set of argument types (concept)
predicate (C++20)	specifies that a callable type is a Boolean predicate (concept)
relation (C++20)	specifies that a callable type is a binary relation (concept)
equivalence_relation (C++20)	specifies that a relation imposes an equivalence relation (concept)
strict_weak_order (C++20)	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.