Espacios de nombres
Variantes
Acciones

Archivo de encabezado de la biblioteca estándar <concepts>

De cppreference.com
< cpp‎ | header
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Archivos de encabezado de la biblioteca estándar
 

Este archivo de encabezado es parte de la biblioteca de conceptos.

Contenido

Conceptos

Conceptos del lenguaje centrales
(C++20)
 Especifica que un tipo es el mismo que otro tipo.
(concepto) [editar]
(C++20)
 Especifica que un tipo se deriva de otro tipo.
(concepto) [editar]
(C++20)
 Especifica que un tipo es implícitamente convertible a otro tipo.
(concepto) [editar]
(C++20)
 Especifica que dos tipos comparte un tipo de referencia común.
(concepto) [editar]
(C++20)
 Especifica que dos tipos comparten un tipo común.
(concepto) [editar]
(C++20)
 Especifica que un tipo es un tipo entero.
(concepto) [editar]
(C++20)
 Especifica que un tipo es un tipo entero con signo.
(concepto) [editar]
(C++20)
 Especifica que un tipo es un tipo entero que no tiene signo.
(concepto) [editar]
(C++20)
 Especifica que un tipo es un tipo de punto flotante.
(concepto) [editar]
(C++20)
 Especifica que un tipo es asignable desde otro tipo.
(concepto) [editar]
(C++20)
 Especifica que un tipo puede ser intercambiado o que dos tipos pueden ser intercambiados uno con el otro.
(concepto) [editar]
(C++20)
 Especifica que un objeto del tipo puede ser destruido.
(concepto) [editar]
(C++20)
 Especifica que una variable del tipo puede ser construida desde un conjunto de argumentos o vinculada a un conjunto de argumentos.
(concepto) [editar]
(C++20)
 Especifica que un objeto de un tipo puede ser construido por defecto.
(concepto) [editar]
(C++20)
 Especifica que el objeto de un tipo puede construirse usando el constructor de movimiento.
(concepto) [editar]
(C++20)
 Especifica que un objeto de un tipo puede construirse con el constructor de copia y el constructor de movimiento.
(concepto) [editar]
Conceptos de comparación
(C++20)
 Especifica que el operador == es una relación de equivalencia.
(concepto) [editar]
(C++20)
 Especifica que los operadores de comparación sobre el tipo producen un orden total.
(concepto) [editar]
Conceptos de objetos
(C++20)
 Especifica que un objeto de un tipo puede ser movido e intercambiado.
(concepto) [editar]
(C++20)
 Especifica que un objeto de un tipo puede ser copiado, movido, e intercambiado.
(concepto) [editar]
(C++20)
 Especifca que un objeto de un tipo puede ser copiado, movido, intercambiado y construido usando el constructor por defecto.
(concepto) [editar]
(C++20)
 Especifica que un tipo es regular. Es decir, es tanto semiregular como comparable en igualdad (equality_comparable).
(concepto) [editar]
Conceptos que pueden ser llamados
(C++20)
 Especifica que un tipo invocable puede invocarse con un conjunto dado de tipos de argumento.
(concepto) [editar]
(C++20)
 Especifica que un tipo invocable es un predicado Booleano.
(concepto) [editar]
(C++20)
 Especifica que un tipo invocable es una relación binaria.
(concepto) [editar]
(C++20)
 Especifica que una relación (relation) impone una relación de equivalencia.
(concepto) [editar]
(C++20)
 Especifica que una relación (relation) impone un ordenamiento estricto débil.
(concepto) [editar]

Objetos de punto de personalización

(C++20)
 Intercambia los valores de dos objetos.
(objeto punto de personalización) [editar]


[editar] Sinopsis

namespace std {
  // conceptos relacionados con el lenguaje
  // concepto same_as
  template<class T, class U>
    concept same_as = /* véase descripción */;
 
  // concepto derived_from
  template<class Derived, class Base>
    concept derived_from = /* véase descripción */;
 
  // concepto convertible_to
  template<class From, class To>
    concept convertible_to = /* véase descripción */;
 
  // concepto common_reference_with
  template<class T, class U>
    concept common_reference_with = /* véase descripción */;
 
  // concepto common_with
  template<class T, class U>
    concept common_with = /* véase descripción */;
 
  // conceptos aritméticos
  template<class T>
    concept integral = /* véase descripción */;
  template<class T>
    concept signed_integral = /* véase descripción */;
  template<class T>
    concept unsigned_integral = /* véase descripción */;
  template<class T>
    concept floating_point = /* véase descripción */;
 
  // concepto assignable_from
  template<class LHS, class RHS>
    concept assignable_from = /* véase descripción */;
 
  // concepto swappable
  namespace ranges {
    inline namespace /* unspecified */ {
      inline constexpr /* unspecified */ swap = /* unspecified */;
    }
  }
  template<class T>
    concept swappable = /* véase descripción */;
  template<class T, class U>
    concept swappable_with = /* véase descripción */;
 
  // concepto destructible
  template<class T>
    concept destructible = /* véase descripción */;
 
  // concepto constructible_from
  template<class T, class... Args>
    concept constructible_from = /* véase descripción */;
 
  // concepto default_initializable
  template<class T>
    concept default_initializable = /* véase descripción */;
 
  // concepto move_constructible
  template<class T>
    concept move_constructible = /* véase descripción */;
 
  // concepto copy_constructible
  template<class T>
    concept copy_constructible = /* véase descripción */;
 
  // conceptos de comparación
  // concepto equality_comparable
  template<class T>
    concept equality_comparable = /* véase descripción */;
  template<class T, class U>
    concept equality_comparable_with = /* véase descripción */;
 
  // concepto totally_ordered
  template<class T>
    concept totally_ordered = /* véase descripción */;
  template<class T, class U>
    concept totally_ordered_with = /* véase descripción */;
 
  // conceptos de objetos
  template<class T>
    concept movable = /* véase descripción */;
  template<class T>
    concept copyable = /* véase descripción */;
  template<class T>
    concept semiregular = /* véase descripción */;
  template<class T>
    concept regular = /* véase descripción */;
 
  // conceptos que pueden ser llamados
  // concepto invocable
  template<class F, class... Args>
    concept invocable = /* véase descripción */;
 
  // concepto regular_invocable
  template<class F, class... Args>
    concept regular_invocable = /* véase descripción */;
 
  // concepto predicate
  template<class F, class... Args>
    concept predicate = /* véase descripción */;
 
  // concepto relation
  template<class R, class T, class U>
    concept relation = /* véase descripción */;
 
  // concepto equivalence_relation
  template<class R, class T, class U>
    concept equivalence_relation = /* véase descripción */;
 
  // concepto strict_weak_order
  template<class R, class T, class U>
    concept strict_weak_order = /* véase descripción */;
}

[editar] Concepto same_as

template<class T, class U>
  concept __SameImpl = is_same_v<T, U>;  // exposition only
 
template<class T, class U>
  concept same_as = __SameImpl<T, U> && __SameImpl<U, T>;

[editar] Concepto derived_from

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

[editar] Concepto convertible_to

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

[editar] Concepto common_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>>;

[editar] Concepto common_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>>>;

[editar] Concepto integral

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

[editar] Concepto signed_integral

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

[editar] Concepto unsigned_integral

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

[editar] Concepto floating_point

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

[editar] Concepto assignable_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>;

[editar] Concepto swappable

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

[editar] Concepto swappable_with

template<class T, class U>
  concept swappable_with =
    common_reference_with<const remove_reference_t<T>&, const remove_reference_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));
    };

[editar] Concepto destructible

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

[editar] Concepto constructible_from

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

[editar] Concepto default_initializable

template<class T>
  inline constexpr bool __is_default_initializable =
    /* véase descripción */;  // exposition only
 
template<class T>
  concept default_initializable = constructible_from<T> &&
                                  requires{ T{}; } &&
                                  __is_default_initializable<T>;

[editar] Concepto move_constructible

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

[editar] Concepto copy_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>;

[editar] Concepto equality_comparable

template<class T, class U>
  concept __WeaklyEqualityComparableWith = // 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 = __WeaklyEqualityComparableWith<T, T>;

[editar] Concepto equality_comparable_with

template<class T, class U>
  concept equality_comparable_with =
    equality_comparable<T> && equality_comparable<U> &&
    common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
    equality_comparable<
      common_reference_t<
        const remove_reference_t<T>&,
        const remove_reference_t<U>&>> &&
    __WeaklyEqualityComparableWith<T, U>;

[editar] Concepto totally_ordered

template<class T>
  concept totally_ordered =
    equality_comparable<T> &&
    requires(const remove_reference_t<T>& a,
             const remove_reference_t<T>& b) {
      { a <  b } -> boolean-testable;
      { a >  b } -> boolean-testable;
      { a <= b } -> boolean-testable;
      { a >= b } -> boolean-testable;
    };

[editar] Concepto totally_ordered_with

template<class T, class U>
  concept totally_ordered_with =
    totally_ordered<T> && totally_ordered<U> &&
    common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
    totally_ordered<
      common_reference_t<
        const remove_reference_t<T>&,
        const remove_reference_t<U>&>> &&
    equality_comparable_with<T, U> &&
    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;
    };

[editar] Concepto movable

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

[editar] Concepto copyable

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

[editar] Concepto semiregular

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

[editar] Concepto regular

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

[editar] Concepto invocable

template<class F, class... Args>
  concept invocable = requires(F&& f, Args&&... args) {
    invoke(std::forward<F>(f), std::forward<Args>(args)...);
      // no se requiere que sea preservador de igualdad
  };

[editar] Concepto regular_invocable

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

[editar] Concepto predicate

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

[editar] Concepto relation

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>;

[editar] Concepto equivalence_relation

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

[editar] Concepto strict_weak_order

template<class R, class T, class U>
  concept strict_weak_order = relation<R, T, U>;
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/header/concepts&oldid=43299»