std::ranges:: remove_copy, std::ranges:: remove_copy_if, std::ranges:: remove_copy_result, std::ranges:: remove_copy_if_result
|
Défini dans l'en-tête
<algorithm>
|
||
|
Signature d'appel
|
||
| (1) | ||
|
template
<
std::
input_iterator
I,
std::
sentinel_for
<
I
>
S,
std::
weakly_incrementable
O,
class
T,
class
Proj
=
std::
identity
>
|
(depuis C++20)
(jusqu'à C++26) |
|
|
template
<
std::
input_iterator
I,
std::
sentinel_for
<
I
>
S,
std::
weakly_incrementable
O,
class
Proj
=
std::
identity
,
|
(depuis C++26) | |
| (2) | ||
|
template
<
ranges::
input_range
R,
std::
weakly_incrementable
O,
class
T,
class
Proj
=
std::
identity
>
|
(depuis C++20)
(jusqu'à C++26) |
|
|
template
<
ranges::
input_range
R,
std::
weakly_incrementable
O,
class
Proj
=
std::
identity
,
|
(depuis C++26) | |
|
template
<
std::
input_iterator
I,
std::
sentinel_for
<
I
>
S,
std::
weakly_incrementable
O,
class
Proj
=
std::
identity
,
|
(3) | (depuis C++20) |
|
template
<
ranges::
input_range
R,
std::
weakly_incrementable
O,
class
Proj
=
std::
identity
,
|
(4) | (depuis C++20) |
|
Types auxiliaires
|
||
|
template
<
class
I,
class
O
>
using remove_copy_result = ranges:: in_out_result < I, O > ; |
(5) | (depuis C++20) |
|
template
<
class
I,
class
O
>
using remove_copy_if_result = ranges:: in_out_result < I, O > ; |
(6) | (depuis C++20) |
Copie les éléments de la plage source
[
first
,
last
)
, vers la plage de destination commençant à
result
, en omettant les éléments qui (après projection par
proj
) satisfont des critères spécifiques. Le comportement est indéfini si les plages source et destination se chevauchent.
Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithme (informellement appelés 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'une d'entre elles.
- Aucune d'entre elles n'est visible pour la recherche dépendante des arguments .
- Lorsque l'une d'entre elles est trouvée par la recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.
Table des matières |
Paramètres
| first, last | - | la paire itérateur-sentinelle définissant la plage source des éléments à traiter |
| r | - | la plage source des éléments |
| result | - | le début de la plage de destination |
| value | - | la valeur des éléments non à copier |
| comp | - | le prédicat binaire pour comparer les éléments projetés |
| proj | - | la projection à appliquer aux éléments |
Valeur de retour
{ last, result + N } , où N est le nombre d'éléments copiés.
Complexité
Exactement ranges:: distance ( first, last ) applications du prédicat correspondant comp et de toute projection proj .
Notes
L'algorithme est stable, c'est-à-dire qu'il préserve l'ordre relatif des éléments copiés.
| Macro de test de fonctionnalité | Valeur | Std | Fonctionnalité |
|---|---|---|---|
__cpp_lib_algorithm_default_value_type
|
202403
|
(C++26) | Initialisation par liste pour les algorithmes ( 1,2 ) |
Implémentation possible
| remove_copy (1,2) |
|---|
struct remove_copy_fn { template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class Proj = std::identity, class T = std::projected_value_t<I, Proj>> requires std::indirectly_copyable<I, O> && std::indirect_binary_predicate<ranges::equal_to, std::projected<I, Proj>, const T*> constexpr ranges::remove_copy_result<I, O> operator()(I first, S last, O result, const T& value, Proj proj = {}) const { for (; !(first == last); ++first) if (value != std::invoke(proj, *first)) { *result = *first; ++result; } return {std::move(first), std::move(result)}; } template<ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj>> requires std::indirectly_copyable<ranges::iterator_t<R>, O> && std::indirect_binary_predicate<ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr ranges::remove_copy_result<ranges::borrowed_iterator_t<R>, O> operator()(R&& r, O result, const T& value, Proj proj = {}) const { return (*this)(ranges::begin(r), ranges::end(r), std::move(result), value, std::move(proj)); } }; inline constexpr remove_copy_fn remove_copy {}; |
| remove_copy_if (3,4) |
struct remove_copy_if_fn { template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred> requires std::indirectly_copyable<I, O> constexpr ranges::remove_copy_if_result<I, O> operator()(I first, S last, O result, Pred pred, Proj proj = {}) const { for (; first != last; ++first) if (false == std::invoke(pred, std::invoke(proj, *first))) { *result = *first; ++result; } return {std::move(first), std::move(result)}; } template<ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>, Proj>> Pred> requires std::indirectly_copyable<ranges::iterator_t<R>, O> constexpr ranges::remove_copy_if_result<ranges::borrowed_iterator_t<R>, O> operator()(R&& r, O result, Pred pred, Proj proj = {}) const { return (*this)(ranges::begin(r), ranges::end(r), std::move(result), std::move(pred), std::move(proj)); } }; inline constexpr remove_copy_if_fn remove_copy_if {}; |
Exemple
#include <algorithm> #include <array> #include <complex> #include <iomanip> #include <iostream> #include <iterator> #include <string_view> #include <vector> void println(const auto rem, const auto& v) { std::cout << rem << ' '; for (const auto& e : v) std::cout << e << ' '; std::cout << '\n'; } int main() { // Filtrer le symbole dièse de la chaîne donnée. const std::string_view str{"#Small #Buffer #Optimization"}; std::cout << "before: " << std::quoted(str) << '\n'; std::cout << "after: \""; std::ranges::remove_copy(str.begin(), str.end(), std::ostream_iterator<char>(std::cout), '#'); std::cout << "\"\n"; // Copier uniquement les nombres complexes avec une partie imaginaire positive. using Ci = std::complex<int>; constexpr std::array<Ci, 5> source { Ci{1, 0}, Ci{0, 1}, Ci{2, -1}, Ci{3, 2}, Ci{4, -3} }; std::vector<std::complex<int>> target; std::ranges::remove_copy_if ( source, std::back_inserter(target), [](int imag) { return imag <= 0; }, [](Ci z) { return z.imag(); } ); println("source:", source); println("target:", target); std::vector<std::complex<float>> nums{{2, 2}, {1, 3}, {4, 8}, {1, 3}}; std::vector<std::complex<double>> outs; #ifdef __cpp_lib_algorithm_default_value_type std::remove_copy(nums.cbegin(), nums.cend(), std::back_inserter(outs), {1, 3}); // T est déduit comme std::complex<float> #else std::remove_copy(nums.cbegin(), nums.cend(), std::back_inserter(outs), std::complex<float>{1, 3}); #endif println("nums: ", nums); println("outs: ", outs); }
Sortie :
before: "#Small #Buffer #Optimization" after: "Small Buffer Optimization" source: (1,0) (0,1) (2,-1) (3,2) (4,-3) target: (0,1) (3,2) nums: (2,2) (1,3) (4,8) (1,3) outs: (2,2) (4,8)
Voir aussi
|
(C++20)
(C++20)
|
supprime les éléments satisfaisant des critères spécifiques
(objet fonction d'algorithme) |
|
(C++20)
(C++20)
|
copie une plage d'éléments vers un nouvel emplacement
(objet fonction d'algorithme) |
|
(C++20)
|
copie un nombre d'éléments vers un nouvel emplacement
(objet fonction d'algorithme) |
|
(C++20)
|
copie une plage d'éléments dans l'ordre inverse
(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 d'une plage qui est inversée
(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 qui ne contient pas de doublons consécutifs
(objet fonction d'algorithme) |
|
copie une plage d'éléments en omettant ceux qui satisfont des critères spécifiques
(modèle de fonction) |