Standard library header <concepts>

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Standard Library headers

Language Support
<cstddef> <limits> <climits> <contract>	<cfloat> <cstdint> <new> <version>	<typeinfo> <exception> <initializer_list>	<csignal> <csetjmp> <cstdarg>
Concepts
<concepts>
Diagnostics
<stdexcept>	<cassert>	<cerrno>	<system_error>
General utilities
<utility> <memory> <memory_resource> <scoped_allocator>     <compare>	<bitset> <tuple> <optional> <any> <variant>	<type_traits> <ratio> <chrono> <typeindex> <functional>	<ctime> <cstdlib>
Strings
<string> <string_view>	<cctype> <cwctype>	<cwchar> <cuchar>	<cstring> <charconv>
Localization
<locale>	<codecvt>	<clocale>
Containers
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
Iterators
<iterator>
Ranges
<ranges>
Algorithms
<algorithm>	<execution>
Numerics
<complex> <random>	<valarray> <numeric>	<cfenv> <cmath>	<bit>
Input/Output
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
Regular expressions
<regex>
Filesystem support
<filesystem>
Thread support
<thread> <atomic>	<mutex> <shared_mutex>	<condition_variable> <future>
C compatibility
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath>

 

This header is part of the concepts library.

Concepts
Core language concepts
Same (C++20)	specifies that a type is the same as another type (concept)
DerivedFrom (C++20)	specifies that a type is derived from another type (concept)
ConvertibleTo (C++20)	specifies that a type is implicitly convertible to another type (concept)
CommonReference (C++20)	specifies that two types share a common reference type (concept)
Common (C++20)	specifies that two types share a common type (concept)
Integral (C++20)	specifies that a type is an integral type (concept)
SignedIntegral (C++20)	specifies that a type is an integral type that is signed (concept)
UnsignedIntegral (C++20)	specifies that a type is an integral type that is unsigned (concept)
Assignable (C++20)	specifies that a type is assignable from another type (concept)
SwappableSwappableWith (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 (C++20)	specifies that a variable of the type can be constructed from or bound to a set of argument types (concept)
DefaultConstructible (C++20)	specifies that an object of a type can be default constructed (concept)
MoveConstructible (C++20)	specifies that an object of a type can be move constructed (concept)
CopyConstructible (C++20)	specifies that an object of a type can be copy constructed and move constructed (concept)
Comparison concepts
Boolean (C++20)	specifies that a type can be used in Boolean contexts (concept)
EqualityComparableEqualityComparableWith (C++20)	specifies that operator == is an equivalence relation (concept)
StrictTotallyOrderedStrictTotallyOrderedWith (C++20)	specifies that the comparison operators on the type yield a total order (concept)
Object 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 EqualityComparable (concept)
Callable concepts
InvocableRegularInvocable (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)
StrictWeakOrder (C++20)	specifies that a Relation imposes a strict weak ordering (concept)

Synopsis

namespace std { 
 
    // Core language concepts
 
    template <class T, class U>
    concept Same = /* see description */;
 
    template <class Derived, class Base>
    concept DerivedFrom = /* see description */;
 
    template <class From, class To>
    concept ConvertibleTo = /* see description */;
 
    template <class T, class U>
    concept CommonReference = /* see description */;
 
    template <class T, class U>
    concept Common = /* see description */;
 
    template <class T>
    concept Integral = /* see description */;
 
    template <class T>
    concept SignedIntegral = /* see description */;
 
    template <class T>
    concept UnsignedIntegral = /* see description */;
 
    template <class LHS, class RHS>
    concept Assignable = /* see description */;
 
    template <class T>
    concept Swappable = /* see description */;
 
    template <class T, class U>
    concept SwappableWith = /* see description */;
 
    template <class T>
    concept Destructible = /* see description */;
 
    template <class T, class... Args>
    concept Constructible = /* see description */;
 
    template <class T>
    concept DefaultConstructible = /* see description */;
 
    template <class T>
    concept MoveConstructible = /* see description */;
 
    template <class T>
    concept CopyConstructible = /* see description */;
 
    // Comparison concepts
 
    template <class B>
    concept Boolean = /* see description */;
 
    template <class T>
    concept EqualityComparable = /* see description */;
    template <class T, class U>
    concept EqualityComparableWith = /* see description */;
 
    template <class T>
    concept StrictTotallyOrdered = /* see description */;
    template <class T, class U>
    concept StrictTotallyOrderedWith = /* see description */;
 
    // Object concepts
 
    template <class T>
    concept Movable = /* see description */;
 
    template <class T>
    concept Copyable = /* see description */;
 
    template <class T>
    concept Semiregular = /* see description */;
 
    template <class T>
    concept Regular = /* see description */;
 
    // Callable concepts
 
    template <class F, class... Args>
    concept Invocable = /* see description */;
 
    template <class F, class... Args>
    concept RegularInvocable = /* see description */;
 
    template <class F, class... Args>
    concept Predicate = /* see description */;
 
    template <class R, class T, class U>
    concept Relation = /* see description */;
 
    template <class R, class T, class U>
    concept StrictWeakOrder = /* see description */;
}