std::ranges::copy_backward, std::ranges::copy_backward_result
De fr.cppreference.net
| Défini dans l'en-tête <algorithm>
|
||
| Signature d'appel |
||
template< std::bidirectional_iterator I1, std::sentinel_for<I1> S1,
std::bidirectional_iterator I2 >
requires std::indirectly_copyable<I1, I2>
constexpr copy_backward_result<I1, I2>
copy_backward( I1 first, S1 last, I2 d_last );
|
(1) | (depuis C++20) |
template< ranges::bidirectional_range R, std::bidirectional_iterator I >
requires std::indirectly_copyable<ranges::iterator_t<R>, I>
constexpr copy_backward_result<ranges::borrowed_iterator_t<R>, I>
copy_backward( R&& r, I d_last );
|
(2) | (depuis C++20) |
| Types auxiliaires |
||
template< class I1, class I2 >
using copy_backward_result = ranges::in_out_result<I1, I2>;
|
(3) | (depuis C++20) |
1) Copie les éléments de la plage, définie par
[first, last), vers une autre plage [d_last - N, d_last), où N = ranges::distance(first, last). Les éléments sont copiés dans l'ordre inverse (le dernier élément est copié en premier), mais leur ordre relatif est préservé. Le comportement est indéfini si d_last est à l'intérieur de (first, last]. Dans ce cas, std::ranges::copy peut être utilisé à la place.2) Identique à (1), mais utilise
r comme plage source, comme si vous utilisiez ranges::begin(r) comme first, et ranges::end(r) comme last.Les entités de type fonction décrites sur cette page sont des objets fonctions d'algorithme (informellement appelés niebloïdes), c'est-à-dire :
- Les listes explicites d'arguments de modèle ne peuvent pas être spécifiées lors de l'appel de l'un d'entre eux.
- Aucun d'entre eux n'est visible par la recherche dépendante des arguments.
- Lorsque l'un d'entre eux est trouvé par une recherche non qualifiée normale en tant que nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.
Paramètres
| first, last | - | la paire itérateur-sentinelle définissant la plage d'éléments à copier |
| r | - | la plage des éléments à copier |
| d_last | - | la fin de la plage de destination |
Valeur de retour
{last, d_last - N}
Complexité
Exactement N affectations.
Remarques
Lors de la copie de plages qui se chevauchent, ranges::copy est approprié lors de la copie vers la gauche (le début de la plage de destination est en dehors de la plage source) tandis que ranges::copy_backward est approprié lors de la copie vers la droite (la fin de la plage de destination est en dehors de la plage source).
Implémentation possible
struct copy_backward_fn
{
template<std::bidirectional_iterator I1, std::sentinel_for<I1> S1,
std::bidirectional_iterator I2>
requires std::indirectly_copyable<I1, I2>
constexpr ranges::copy_backward_result<I1, I2>
operator()(I1 first, S1 last, I2 d_last) const
{
I1 last1 {ranges::next(first, std::move(last))};
for (I1 i {last1}; i != first;)
*--d_last = *--i;
return {std::move(last1), std::move(d_last)};
}
template<ranges::bidirectional_range R, std::bidirectional_iterator I>
requires std::indirectly_copyable<ranges::iterator_t<R>, I>
constexpr ranges::copy_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 copy_backward_fn copy_backward{};
|
Exemple
Exécuter ce code
#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
void print(std::string_view rem, std::ranges::forward_range auto const& r)
{
for (std::cout << rem << ": "; auto const& elem : r)
std::cout << elem << ' ';
std::cout << '\n';
}
int main()
{
const auto src = {1, 2, 3, 4};
print("src", src);
std::vector<int> dst(src.size() + 2);
std::ranges::copy_backward(src, dst.end());
print("dst", dst);
std::ranges::fill(dst, 0);
const auto [in, out] =
std::ranges::copy_backward(src.begin(), src.end() - 2, dst.end());
print("dst", dst);
std::cout
<< "(in - src.begin) == " << std::distance(src.begin(), in) << '\n'
<< "(out - dst.begin) == " << std::distance(dst.begin(), out) << '\n';
}
Sortie :
src: 1 2 3 4
dst: 0 0 1 2 3 4
dst: 0 0 0 0 1 2
(in - src.begin) == 2
(out - dst.begin) == 4
Voir aussi
(C++20)(C++20) |
copie une plage d'éléments vers un nouvel emplacement (objet fonction d'algorithme) |
(C++20) |
copie un certain nombre d'éléments vers un nouvel emplacement (objet fonction d'algorithme) |
(C++20)(C++20) |
copie une plage d'éléments en omettant ceux qui satisfont des critères spécifiques (objet fonction d'algorithme) |
(C++20)(C++20) |
copie une plage en remplaçant les éléments satisfaisant des critères spécifiques par une autre valeur (objet fonction d'algorithme) |
(C++20) |
crée une copie inversée d'une plage (objet fonction d'algorithme) |
(C++20) |
copie et fait pivoter une plage d'éléments (objet fonction d'algorithme) |
(C++20) |
crée une copie d'une plage d'éléments sans doublons consécutifs (objet fonction d'algorithme) |
(C++20) |
déplace une plage d'éléments vers un nouvel emplacement (objet fonction d'algorithme) |
(C++20) |
déplace une plage d'éléments vers un nouvel emplacement dans l'ordre inverse (objet fonction d'algorithme) |
| copie une plage d'éléments dans l'ordre inverse (modèle de fonction) |