std::ranges::move, std::ranges::move_result

template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O >
requires std::indirectly_movable<I, O>
constexpr move_result<I, O>
    move( I first, S last, O result );

template< ranges::input_range R, std::weakly_incrementable O >
requires std::indirectly_movable<ranges::iterator_t<R>, O>
constexpr move_result<ranges::borrowed_iterator_t<R>, O>
    move( R&& r, O result );

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

Les éléments de la gamme déplacés contiendront toujours des valeurs valides du type approprié, mais pas nécessairement les mêmes valeurs qu'avant le déplacement.

Les entités de type fonction décrites sur cette page sont des objets de fonction d'algorithme (informellement connus sous le nom de niebloids), c'est-à-dire :

• Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'un d'eux.
• Aucun d'eux n'est visible par la recherche dépendante des arguments.
• Lorsque l'un d'eux est trouvé par la recherche non qualifiée normale comme le nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Paramètres

Valeur de retour

{ last, result + N } , où

Complexité

Exactement N affectations de déplacement.

Notes

Lors du déplacement de plages qui se chevauchent, ranges::move est approprié lors d'un déplacement vers la gauche (le début de la plage de destination est en dehors de la plage source) tandis que ranges::move_backward est approprié lors d'un déplacement vers la droite (la fin de la plage de destination est en dehors de la plage source).

Implémentation possible

struct move_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O>
    requires std::indirectly_movable<I, O>
    constexpr ranges::move_result<I, O>
        operator()(I first, S last, O result) const
    {
        for (; first != last; ++first, ++result)
            *result = ranges::iter_move(first);
        return {std::move(first), std::move(result)};
    }
    template<ranges::input_range R, std::weakly_incrementable O>
    requires std::indirectly_movable<ranges::iterator_t<R>, O>
    constexpr ranges::move_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result));
    }
};
inline constexpr move_fn move {};

Exemple

#include <algorithm>
#include <chrono>
#include <iostream>
#include <iterator>
#include <list>
#include <thread>
#include <vector>
using namespace std::literals::chrono_literals;
void f(std::chrono::milliseconds n)
{
    std::this_thread::sleep_for(n);
    std::cout << "thread with n=" << n.count() << "ms ended" << std::endl;
}
int main()
{
    std::vector<std::jthread> v;
    v.emplace_back(f, 400ms);
    v.emplace_back(f, 600ms);
    v.emplace_back(f, 800ms);
    std::list<std::jthread> l;
    // std::ranges::copy() would not compile, because std::jthread is non-copyable
    std::ranges::move(v, std::back_inserter(l));
}

thread with n=400ms ended
thread with n=600ms ended
thread with n=800ms ended

Voir aussi