std::ranges::move_backward, std::ranges::move_backward_result

template< std::bidirectional_iterator I1, std::sentinel_for<I1> S1,
          std::bidirectional_iterator I2 >
requires std::indirectly_movable<I1, I2>
constexpr move_backward_result<I1, I2>
    move_backward( I1 first, S1 last, I2 d_last );

template< ranges::bidirectional_range R, std::bidirectional_iterator I >
requires std::indirectly_movable<ranges::iterator_t<R>, I>
constexpr move_backward_result<ranges::borrowed_iterator_t<R>, I>
    move_backward( R&& r, I d_last );

template< class I, class O >
using move_backward_result = ranges::in_out_result<I, O>;

Los elementos en el rango desde el cual se movió seguirán conteniendo valores válidos del tipo apropiado, pero no necesariamente los mismos valores que antes del movimiento, como si se usara *(d_last - n) = ranges::iter_move(last - n) para cada entero n, donde 0 ≤ n < N.

Las entidades similares a funciones descritas en esta página son objetos de función de algoritmo (conocidos informalmente como niebloids), es decir:

• No se pueden especificar listas explícitas de argumentos de plantilla al llamar a ninguna de ellas.
• Ninguna de ellas es visible mediante búsqueda dependiente de argumentos.
• Cuando alguna de ellas se encuentra mediante búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, la búsqueda dependiente de argumentos se inhibe.

Parámetros

Valor de retorno

{ last, d_last - N } .

Complejidad

Notas

Al mover rangos superpuestos, ranges::move es apropiado al mover hacia la izquierda (el inicio del rango de destino está fuera del rango fuente) mientras que ranges::move_backward es apropiado al mover hacia la derecha (el final del rango de destino está fuera del rango fuente).

Implementación posible

struct move_backward_fn
{
    template<std::bidirectional_iterator I1, std::sentinel_for<I1> S1,
             std::bidirectional_iterator I2>
    requires std::indirectly_movable<I1, I2>
    constexpr ranges::move_backward_result<I1, I2>
        operator()(I1 first, S1 last, I2 d_last) const
    {
        auto i {last};
        for (; i != first; *--d_last = ranges::iter_move(--i))
        {}
        return {std::move(last), std::move(d_last)};
    }
    template<ranges::bidirectional_range R, std::bidirectional_iterator I>
    requires std::indirectly_movable<ranges::iterator_t<R>, I>
    constexpr ranges::move_backward_result<ranges::borrowed_iterator_t<R>, I>
        operator()(R&& r, I d_last) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(d_last));
    }
};
inline constexpr move_backward_fn move_backward {};

Ejemplo

#include <algorithm>
#include <iostream>
#include <string>
#include <string_view>
#include <vector>
using Vec = std::vector<std::string>;
void print(std::string_view rem, Vec const& vec)
{
    std::cout << rem << "[" << vec.size() << "]: ";
    for (const std::string& s : vec)
        std::cout << (s.size() ? s : std::string{"·"}) << ' ';
    std::cout << '\n';
}
int main()
{
    Vec a{"▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"};
    Vec b(a.size());
    print("Before move:\n" "a", a);
    print("b", b);
    std::ranges::move_backward(a, b.end());
    print("\n" "Move a >> b:\n" "a", a);
    print("b", b);
    std::ranges::move_backward(b.begin(), b.end(), a.end());
    print("\n" "Move b >> a:\n" "a", a);
    print("b", b);
    std::ranges::move_backward(a.begin(), a.begin()+3, a.end());
    print("\n" "Overlapping move a[0, 3) >> a[5, 8):\n" "a", a);
}

Before move:
a[8]: ▁ ▂ ▃ ▄ ▅ ▆ ▇ █
b[8]: · · · · · · · ·
Move a >> b:
a[8]: · · · · · · · ·
b[8]: ▁ ▂ ▃ ▄ ▅ ▆ ▇ █
Move b >> a:
a[8]: ▁ ▂ ▃ ▄ ▅ ▆ ▇ █
b[8]: · · · · · · · ·
Overlapping move a[0, 3) >> a[5, 8):
a[8]: · · · ▄ ▅ ▁ ▂ ▃

Véase también