Namespaces
Variants

std::ranges:: iter_swap

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
Definido en el encabezado <iterator>
namespace ranges {

inline namespace /* no especificado */ {
inline constexpr /* no especificado */
iter_swap = /* no especificado */ ;
}

}
(desde C++20)
(objeto de punto de personalización)
Firma de llamada
template < class I1, class I2 >
constexpr void iter_swap ( I1 && i1, I2 && i2 ) noexcept ( /* ver más abajo */ ) ;
(desde C++20)
Función auxiliar
template < class X, class Y >

constexpr std:: iter_value_t < X >
iter - exchange - move ( X && x, Y && y )
noexcept ( noexcept ( std:: iter_value_t < X > ( std :: ranges:: iter_move ( x ) ) ) &&

noexcept ( * x = std :: ranges:: iter_move ( y ) ) ) ;
( solo para exposición* )

Intercambia los valores denotados por dos iteradores.

El efecto de la función auxiliar de solo exposición iter-exchange-move es equivalente a 

std::iter_value_t<X> old(std::ranges::iter_move(x));
*x = std::ranges::iter_move(y);
return old;

ranges :: iter_swap ( i1, i2 ) es equivalente-expresión a:

  1. ( void ) iter_swap ( i1, i2 ) , si i1 o i2 tiene un tipo de clase o enumeración y la expresión está bien formada, donde la resolución de sobrecarga de iter_swap se realiza con el candidato adicional void iter_swap ( auto , auto ) = delete ; [1] , excluyendo al propio std::ranges::iter_swap .
    • Si la sobrecarga seleccionada no intercambia el valor denotado por i1 y i2 , el programa está mal formado, sin requerir diagnóstico.
  2. De lo contrario, ranges:: swap ( * i1, * i2 ) si tanto I1 como I2 modelan indirectly_readable y si std:: iter_reference_t < I1 > y std:: iter_reference_t < I2 > modelan swappable_with .
  3. De lo contrario, ( void ) ( * i1 = iter-exchange-move ( i2, i1 ) ) , si std:: indirectly_movable_storable < I1, I2 > y std:: indirectly_movable_storable < I2, I1 > están ambos modelados, excepto que i1 solo se evalúa una vez.
  4. De lo contrario, ranges :: iter_swap ( i1, i2 ) está mal formado, lo que puede resultar en fallo de sustitución cuando ranges :: iter_swap ( i1, i2 ) aparece en el contexto inmediato de una instanciación de plantilla.
  1. ↑ Esto impide llamar a la función no restringida std::iter_swap .

Objetos de punto de personalización

El nombre ranges::iter_swap denota un objeto de punto de personalización , que es un objeto función constante de tipo clase literal semiregular . Consulte CustomizationPointObject para más detalles.

Ejemplo

Esta sección está incompleta
Razón: sin ejemplo

Véase también

(C++20)
intercambia los objetos apuntados por dos iteradores subyacentes ajustados
(plantilla de función)
(C++20)
intercambia los objetos apuntados por dos iteradores subyacentes
(plantilla de función)
intercambia los elementos apuntados por dos iteradores
(plantilla de función)