std::ranges::iter_swap

Intercambia valores denotados por dos iteradores.

Una llamada a ranges::iter_swap es equivalente en expresión a:

1. (void)iter_swap(std::forward<I1>(i1), std::forward<I2>(i2)), si std::remove_cvref_t<I1> o std::remove_cvref_t<I2> es una clase o un tipo enumeración y la expresión está bien formada en un contexto no evaluado, donde la resolución de sobrecarga se lleva a cabo con los siguientes candidatos:
   • void iter_swap(auto, auto) = delete;
   • cualquier declaración de iter_swap encontrada por la búsqueda dependiente de argumento.

   Si la sobrecarga seleccionada no intercambia el valor denotado por i1 e i2, el programa está mal formado, no se requiere diagnóstico.

2. de lo contrario, ranges::swap(*std::forward<I1>(i1), *std::forward<I2>(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)(*std::forward<I1>(i1) = /*iter_exchange_move*/(std::forward<I2>(i2), std::forward<I1>(i1))), si I1 e I2 modelan std::indirectly_move_storable<I1, I2> y std::indirectly_move_storable<I2, I1>, donde iter_exchange_move es una plantilla de función de solo exposición descrita posteriormente.

En todos los otros casos, una llamada a ranges::iter_swap está mal formada, lo que puede resultar en falla en la sustitución cuando ranges::iter_swap(e1, e2) aparece en el contexto inmediato de una instanciación de plantilla.

La plantilla de función de solo exposición iter_exchange_move está definida equivalentemente como:

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::move(x)) &&
             noexcept(*x = std::ranges::iter_move(y))))
{
    std::iter_value_t<X> old(std::ranges::iter_move(x));
    *x = std::ranges::iter_move(y);
    return old;
}

[editar] Equivalente en expresión

La expresión e es equivalente-en-expresión a la expresión f, si e y f tienen los mismos efectos, ambas potencialmente lanzan o ambas potencialmente no lanzan (es decir, noexcept (e) == noexcept(f)), y ambas son subexpresiones constantes o ambas no son subexpresiones constantes.

[editar] 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 const de un tipo clase literal semiregular (denotado, a efectos de exposición, como iter_swap_ftor). Todos los ejemplares de iter_swap_ftor son iguales. Por lo tanto, ranges::iter_swap puede copiarse libremente y sus copias pueden usarse indistintamente.

Dado un conjunto de tipos Args..., si std::declval<Args>()... cumple con los requerimientos para los argumentos de ranges::iter_swap mencionado anteriormente, iter_swap_ftor satisfará a std::invocable<const iter_swap_ftor&, Args...>. De lo contrario, ningún operador de llamada a función de iter_swap_ftor participa en la resolución de sobrecarga.

[editar] Véase también