Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      Standard library header <concepts> (C++20)

      From cppreference.com
      <cpp‎ |header
       
       
      Standard library headers
       

      This header is part of theconcepts library.

      Contents

      Concepts

      Core language concepts
      (C++20)
      specifies that a type is the same as another type
      (concept)[edit]
      specifies that a type is derived from another type
      (concept)[edit]
      specifies that a type is implicitly convertible to another type
      (concept)[edit]
      specifies that two types share a common reference type
      (concept)[edit]
      specifies that two types share a common type
      (concept)[edit]
      (C++20)
      specifies that a type is an integral type
      (concept)[edit]
      specifies that a type is an integral type that is signed
      (concept)[edit]
      specifies that a type is an integral type that is unsigned
      (concept)[edit]
      specifies that a type is a floating-point type
      (concept)[edit]
      specifies that a type is assignable from another type
      (concept)[edit]
      specifies that a type can be swapped or that two types can be swapped with each other
      (concept)[edit]
      specifies that an object of the type can be destroyed
      (concept)[edit]
      specifies that a variable of the type can be constructed from or bound to a set of argument types
      (concept)[edit]
      specifies that an object of a type can be default constructed
      (concept)[edit]
      specifies that an object of a type can be move constructed
      (concept)[edit]
      specifies that an object of a type can be copy constructed and move constructed
      (concept)[edit]
      Comparison concepts
      specifies that operator== is an equivalence relation
      (concept)[edit]
      specifies that the comparison operators on the type yield a total order
      (concept)[edit]
      Object concepts
      (C++20)
      specifies that an object of a type can be moved and swapped
      (concept)[edit]
      (C++20)
      specifies that an object of a type can be copied, moved, and swapped
      (concept)[edit]
      specifies that an object of a type can be copied, moved, swapped, and default constructed
      (concept)[edit]
      (C++20)
      specifies that a type is regular, that is, it is bothsemiregular andequality_comparable
      (concept)[edit]
      Callable concepts
      specifies that a callable type can be invoked with a given set of argument types
      (concept)[edit]
      (C++20)
      specifies that a callable type is a Boolean predicate
      (concept)[edit]
      (C++20)
      specifies that a callable type is a binary relation
      (concept)[edit]
      specifies that arelation imposes an equivalence relation
      (concept)[edit]
      specifies that arelation imposes a strict weak ordering
      (concept)[edit]

      Customization point objects

      swaps the values of two objects
      (customization point object)[edit]

      [edit]Synopsis

      // all freestandingnamespace std{// language-related concepts// concept same_astemplate<class T,class U>  concept same_as=/* see description */; // concept derived_fromtemplate<class Derived,class Base>  concept derived_from=/* see description */; // concept convertible_totemplate<class From,class To>  concept convertible_to=/* see description */; // concept common_reference_withtemplate<class T,class U>  concept common_reference_with=/* see description */; // concept common_withtemplate<class T,class U>  concept common_with=/* see description */; // arithmetic conceptstemplate<class T>  concept integral=/* see description */;template<class T>  concept signed_integral=/* see description */;template<class T>  concept unsigned_integral=/* see description */;template<class T>  concept floating_point=/* see description */; // concept assignable_fromtemplate<class LHS,class RHS>  concept assignable_from=/* see description */; // concept swappablenamespace ranges{inlinenamespace/* unspecified */{inlineconstexpr/* unspecified */ swap=/* unspecified */;}}template<class T>  concept swappable=/* see description */;template<class T,class U>  concept swappable_with=/* see description */; // concept destructibletemplate<class T>  concept destructible=/* see description */; // concept constructible_fromtemplate<class T,class...Args>  concept constructible_from=/* see description */; // concept default_initializabletemplate<class T>  concept default_initializable=/* see description */; // concept move_constructibletemplate<class T>  concept move_constructible=/* see description */; // concept copy_constructibletemplate<class T>  concept copy_constructible=/* see description */; // comparison concepts// concept equality_comparabletemplate<class T>  concept equality_comparable=/* see description */;template<class T,class U>  concept equality_comparable_with=/* see description */; // concept totally_orderedtemplate<class T>  concept totally_ordered=/* see description */;template<class T,class U>  concept totally_ordered_with=/* see description */; // object conceptstemplate<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// concept invocabletemplate<class F,class...Args>  concept invocable=/* see description */; // concept regular_invocabletemplate<class F,class...Args>  concept regular_invocable=/* see description */; // concept predicatetemplate<class F,class...Args>  concept predicate=/* see description */; // concept relationtemplate<class R,class T,class U>  concept relation=/* see description */; // concept equivalence_relationtemplate<class R,class T,class U>  concept equivalence_relation=/* see description */; // concept strict_weak_ordertemplate<class R,class T,class U>  concept strict_weak_order=/* see description */;}

      [edit]Helper conceptboolean-testable

      template<class T>concept/*boolean-testable-impl*/= convertible_to<T,bool>;// exposition only; template<class T>conceptboolean-testable=// exposition only/*boolean-testable-impl*/<T>&& requires(T&& t){{!std::forward<T>(t)}->/*boolean-testable-impl*/;};

      [edit]Conceptsame_as

      template<class T,class U>concept/*same-as-impl*/= is_same_v<T, U>;// exposition only template<class T,class U>concept same_as=/*same-as-impl*/<T, U>&&/*same-as-impl*/<U, T>;

      [edit]Conceptderived_from

      template<class Derived,class Base>concept derived_from= is_base_of_v<Base, Derived>&&                       is_convertible_v<constvolatile Derived*,constvolatile Base*>;

      [edit]Conceptconvertible_to

      template<class From,class To>concept convertible_to=  is_convertible_v<From, To>&& requires{static_cast<To>(declval<From>());};

      [edit]Conceptcommon_reference_with

      template<class T,class U>concept common_reference_with=  same_as<common_reference_t<T, U>, common_reference_t<U, T>>&&  convertible_to<T, common_reference_t<T, U>>&&  convertible_to<U, common_reference_t<T, U>>;

      [edit]Conceptcommon_with

      template<class T,class U>concept common_with=  same_as<common_type_t<T, U>, common_type_t<U, T>>&&  requires{static_cast<common_type_t<T, U>>(declval<T>());static_cast<common_type_t<T, U>>(declval<U>());}&&  common_reference_with<add_lvalue_reference_t<const T>,                        add_lvalue_reference_t<const U>>&&  common_reference_with<    add_lvalue_reference_t<common_type_t<T, U>>,    common_reference_t<add_lvalue_reference_t<const T>, add_lvalue_reference_t<const U>>>;

      [edit]Conceptintegral

      template<class T>concept integral= is_integral_v<T>;

      [edit]Conceptsigned_integral

      template<class T>concept signed_integral= integral<T>&& is_signed_v<T>;

      [edit]Conceptunsigned_integral

      template<class T>concept unsigned_integral= integral<T>&&!signed_integral<T>;

      [edit]Conceptfloating_point

      template<class T>concept floating_point= is_floating_point_v<T>;

      [edit]Conceptassignable_from

      template<class LHS,class RHS>concept assignable_from=  is_lvalue_reference_v<LHS>&&  common_reference_with<const remove_reference_t<LHS>&,const remove_reference_t<RHS>&>&&  requires(LHS lhs, RHS&& rhs){{      lhs=std::forward<RHS>(rhs)}-> same_as<LHS>;};

      [edit]Conceptswappable

      template<class T>concept swappable= requires(T& a, T& b){ranges::swap(a, b);};

      [edit]Conceptswappable_with

      template<class T,class U>concept swappable_with= common_reference_with<T, U>&& requires(T&& t, U&& u){ranges::swap(std::forward<T>(t),std::forward<T>(t));ranges::swap(std::forward<U>(u),std::forward<U>(u));ranges::swap(std::forward<T>(t),std::forward<U>(u));ranges::swap(std::forward<U>(u),std::forward<T>(t));};

      [edit]Conceptdestructible

      template<class T>concept destructible= is_nothrow_destructible_v<T>;

      [edit]Conceptconstructible_from

      template<class T,class...Args>concept constructible_from= destructible<T>&& is_constructible_v<T, Args...>;

      [edit]Conceptdefault_initializable

      template<class T>constexprbool/*is-default-initializable*/=/* see description */;// exposition only template<class T>concept default_initializable=  constructible_from<T>&& requires{ T{};}&&/*is-default-initializable*/<T>;

      [edit]Conceptmove_constructible

      template<class T>concept move_constructible= constructible_from<T, T>&& convertible_to<T, T>;

      [edit]Conceptcopy_constructible

      template<class T>concept copy_constructible=  move_constructible<T>&& constructible_from<T, T&>&& convertible_to<T&, T>&&  constructible_from<T,const T&>&& convertible_to<const T&, T>&&  constructible_from<T,const T>&& convertible_to<const T, T>;

      [edit]Conceptequality_comparable

      template<class T,class U>concept/*weakly-equality-comparable-with*/=// exposition only  requires(const remove_reference_t<T>& t,const remove_reference_t<U>& u){{ t== u}->boolean-testable;{ t!= u}->boolean-testable;{ u== t}->boolean-testable;{ u!= t}->boolean-testable;}; template<class T>concept equality_comparable=/*weakly-equality-comparable-with*/<T, T>;

      [edit]Conceptequality_comparable_with

      template<class T,class U,class C= common_reference_t<const T&,const U&>>concept/*comparison-common-type-with-impl*/=// exposition only  same_as<common_reference_t<const T&,const U&>,          common_reference_t<const U&,const T&>>&&  requires{    requires convertible_to<const T&,const C&>|| convertible_to<T,const C&>;    requires convertible_to<const U&,const C&>|| convertible_to<U,const C&>;}; template<class T,class U>concept/*comparison-common-type-with*/=// exposition only/*comparison-common-type-with-impl*/<remove_cvref_t<T>, remove_cvref_t<U>>; template<class T,class U>concept equality_comparable_with=  equality_comparable<T>&& equality_comparable<U>&&/*comparison-common-type-with*/<T, U>&&  equality_comparable<    common_reference_t<const remove_reference_t<T>&,const remove_reference_t<U>&>>&&/*weakly-equality-comparable-with*/<T, U>;

      [edit]Helper conceptpartially-ordered-with

      Defined in header<compare>

      template<class T,class U>concept/*partially-ordered-with*/=// exposition only  requires(const remove_reference_t<T>& t,const remove_reference_t<U>& u){{ t<  u}->boolean-testable;{ t>  u}->boolean-testable;{ t<= u}->boolean-testable;{ t>= u}->boolean-testable;{ u<  t}->boolean-testable;{ u>  t}->boolean-testable;{ u<= t}->boolean-testable;{ u>= t}->boolean-testable;};

      [edit]Concepttotally_ordered

      template<class T>concept totally_ordered= equality_comparable<T>&&/*partially-ordered-with*/<T, T>;

      [edit]Concepttotally_ordered_with

      template<class T,class U>concept totally_ordered_with=  totally_ordered<T>&& totally_ordered<U>&& equality_comparable_with<T, U>&&  totally_ordered<    common_reference_t<const remove_reference_t<T>&,const remove_reference_t<U>&>>&&/*partially-ordered-with*/<T, U>;

      [edit]Conceptmovable

      template<class T>concept movable=  is_object_v<T>&& move_constructible<T>&& assignable_from<T&, T>&& swappable<T>;

      [edit]Conceptcopyable

      template<class T>concept copyable= copy_constructible<T>&& movable<T>&& assignable_from<T&, T&>&&                   assignable_from<T&,const T&>&& assignable_from<T&,const T>;

      [edit]Conceptsemiregular

      template<class T>concept semiregular= copyable<T>&& default_initializable<T>;

      [edit]Conceptregular

      template<class T>concept regular= semiregular<T>&& equality_comparable<T>;

      [edit]Conceptinvocable

      template<class F,class...Args>concept invocable= requires(F&& f, Args&&...args){  invoke(std::forward<F>(f),std::forward<Args>(args)...);// not required to be equality-preserving};

      [edit]Conceptregular_invocable

      template<class F,class...Args>  concept regular_invocable= invocable<F, Args...>;

      [edit]Conceptpredicate

      template<class F,class...Args>concept predicate=  regular_invocable<F, Args...>&&boolean-testable<invoke_result_t<F, Args...>>;

      [edit]Conceptrelation

      template<class R,class T,class U>concept relation=  predicate<R, T, T>&& predicate<R, U, U>&& predicate<R, T, U>&& predicate<R, U, T>;

      [edit]Conceptequivalence_relation

      template<class R,class T,class U>concept equivalence_relation= relation<R, T, U>;

      [edit]Conceptstrict_weak_order

      template<class R,class T,class U>concept strict_weak_order= relation<R, T, U>;
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/concepts&oldid=163949"

      [8]ページ先頭

      ©2009-2025 Movatter.jp