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
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class T, class Proj = std::identity > requires std::indirectly_copyable<I, O> && std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T*> constexpr remove_copy_result<I, O> remove_copy( I first, S last, O result, const T& value, Proj proj = {} );	(1)	(depuis C++20) (jusqu'à C++26)
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 remove_copy_result<I, O> remove_copy( I first, S last, O result, const T& value, Proj proj = {} );	(1)		(depuis C++26)
template< ranges::input_range R, std::weakly_incrementable O, class T, class Proj = std::identity > 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 remove_copy_result<ranges::borrowed_iterator_t<R>, O> remove_copy( R&& r, O result, const T& value, Proj proj = {} );	(2)	(depuis C++20) (jusqu'à C++26)
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 remove_copy_result<ranges::borrowed_iterator_t<R>, O> remove_copy( R&& r, O result, const T& value, Proj proj = {} );	(2)		(depuis C++26)
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 remove_copy_if_result<I, O> remove_copy_if( I first, S last, O result, Pred pred, Proj proj = {} );	(3)	(depuis C++20)
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 remove_copy_if_result<ranges::borrowed_iterator_t<R>, O> remove_copy_if( R&& r, O result, Pred pred, Proj proj = {} );	(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.

1) Ignore tous les éléments qui sont égaux à value.

3) Ignore tous les éléments pour lesquels le prédicat pred retourne true.

2,4) Identique à (1,3), mais utilise r comme plage source, comme si ranges::begin(r) était utilisé 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 template ne peuvent pas être spécifiées lors de l'appel à l'une d'elles.
Aucune d'entre elles n'est visible par la recherche dépendante des arguments.
Quand l'une d'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.

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

Exécuter ce code

#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

ranges::remove ranges::remove_if (C++20) (C++20)	supprime les éléments satisfaisant des critères spécifiques (objet fonction d'algorithme)
ranges::copy ranges::copy_if (C++20) (C++20)	copie une plage d'éléments vers un nouvel emplacement (objet fonction d'algorithme)
ranges::copy_n (C++20)	copie un nombre d'éléments vers un nouvel emplacement (objet fonction d'algorithme)
ranges::copy_backward (C++20)	copie une plage d'éléments dans l'ordre inverse (objet fonction d'algorithme)
ranges::replace_copy ranges::replace_copy_if (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)
ranges::reverse_copy (C++20)	crée une copie d'une plage qui est inversée (objet fonction d'algorithme)
ranges::rotate_copy (C++20)	copie et fait pivoter une plage d'éléments (objet fonction d'algorithme)
ranges::unique_copy (C++20)	crée une copie d'une plage d'éléments qui ne contient pas de doublons consécutifs (objet fonction d'algorithme)
remove_copy remove_copy_if	copie une plage d'éléments en omettant ceux qui satisfont des critères spécifiques (modèle de fonction)

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque des concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque des plages (C++20)
Bibliothèque des algorithmes
Bibliothèque des chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque du système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants