std::remove, std::remove_if

template< class ForwardIt, class T >
ForwardIt remove( ForwardIt first, ForwardIt last, const T& value );

template< class ForwardIt, class T = typename std::iterator_traits
                                         <ForwardIt>::value_type >
constexpr ForwardIt remove( ForwardIt first, ForwardIt last,
                            const T& value );

template< class ExecutionPolicy, class ForwardIt, class T >
ForwardIt remove( ExecutionPolicy&& policy,
                  ForwardIt first, ForwardIt last, const T& value );

template< class ExecutionPolicy, class ForwardIt,
          class T = typename std::iterator_traits
                        <ForwardIt>::value_type >
ForwardIt remove( ExecutionPolicy&& policy,
                  ForwardIt first, ForwardIt last, const T& value );

template< class ForwardIt, class UnaryPred >
ForwardIt remove_if( ForwardIt first, ForwardIt last, UnaryPred p );

template< class ExecutionPolicy, class ForwardIt, class UnaryPred >
ForwardIt remove_if( ExecutionPolicy&& policy,
                     ForwardIt first, ForwardIt last, UnaryPred p );

Supprime tous les éléments répondant à des critères spécifiques de la plage [first, last) et renvoie un itérateur pointant après la fin pour la nouvelle fin de la plage.

Explication

La suppression s'effectue en décalant les éléments de la plage de telle manière que les éléments à ne pas supprimer apparaissent au début de la plage.

• Le décalage est effectué par copy assignment (until C++11) move assignment (since C++11) .
• L'opération de suppression est stable : l'ordre relatif des éléments non supprimés reste inchangé.
• La séquence sous-jacente de [ first , last ) n'est pas raccourcie par l'opération de suppression. En prenant result comme itérateur retourné :

• Tous les itérateurs dans [ result , last ) restent déréférençables .

Paramètres

Valeur de retour

Itérateur après la fin pour la nouvelle plage de valeurs (si ce n'est pas end , alors il pointe vers une valeur non spécifiée, et il en va de même pour les itérateurs vers toutes les valeurs entre cet itérateur et end ).

Complexité

Étant donné \(\scriptsize N\) N comme std:: distance ( first, last ) :

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

• Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelé. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
• Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levée.

Implémentation possible

template<class ForwardIt, class T = typename std::iterator_traits<ForwardIt>::value_type>
ForwardIt remove(ForwardIt first, ForwardIt last, const T& value)
{
    first = std::find(first, last, value);
    if (first != last)
        for (ForwardIt i = first; ++i != last;)
            if (!(*i == value))
                *first++ = std::move(*i);
    return first;
}

template<class ForwardIt, class UnaryPred>
ForwardIt remove_if(ForwardIt first, ForwardIt last, UnaryPred p)
{
    first = std::find_if(first, last, p);
    if (first != last)
        for (ForwardIt i = first; ++i != last;)
            if (!p(*i))
                *first++ = std::move(*i);
    return first;
}

Notes

Un appel à remove est généralement suivi d'un appel à la fonction membre erase d'un conteneur pour supprimer effectivement les éléments du conteneur. Ces deux invocations ensemble constituent ce qu'on appelle l'idiome erase-remove .

Les fonctions membres de conteneur portant des noms similaires member functions list::remove , list::remove_if , forward_list::remove , et forward_list::remove_if suppriment les éléments retirés.

Ces algorithmes ne peuvent pas être utilisés avec des conteneurs associatifs tels que std::set et std::map car leurs types d'itérateurs ne déréférencent pas vers des types MoveAssignable (les clés dans ces conteneurs ne sont pas modifiables).

La bibliothèque standard définit également une surcharge de std::remove dans <cstdio> , qui prend un const char * et est utilisée pour supprimer des fichiers.

Parce que std::remove prend la value par référence, il peut avoir un comportement inattendu s'il s'agit d'une référence à un élément de la plage [ first , last ) .

Exemple

#include <algorithm>
#include <cassert>
#include <cctype>
#include <complex>
#include <iomanip>
#include <iostream>
#include <string>
#include <string_view>
#include <vector>
int main()
{
    std::string str1{"Quick  Red  Dog"};
    std::cout << "1) " << std::quoted(str1) << '\n';
    const auto noSpaceEnd = std::remove(str1.begin(), str1.end(), ' ');
    std::cout << "2) " << std::quoted(str1) << '\n';
    // Les espaces sont supprimés de la chaîne uniquement logiquement.
    // Notez que nous utilisons une vue, la chaîne originale n'est toujours pas réduite :
    std::cout << "3) " << std::quoted(std::string_view(str1.begin(), noSpaceEnd))
              << ", taille : " << str1.size() << '\n';
    str1.erase(noSpaceEnd, str1.end());
    // Les espaces sont supprimés physiquement de la chaîne.
    std::cout << "4) " << std::quoted(str1) << ", taille : " << str1.size() << '\n';
    std::string str2 = "Jumped\n Over\tA\vLazy \t  Fox\r\n";
    str2.erase(std::remove_if(str2.begin(), 
                              str2.end(),
                              [](unsigned char x) { return std::isspace(x); }),
               str2.end());
    std::cout << "5) " << std::quoted(str2) << '\n';
    std::vector<std::complex<double>> nums{{2, 2}, {1, 3}, {4, 8}};
    #ifdef __cpp_lib_algorithm_default_value_type
        nums.erase(std::remove(nums.begin(), nums.end(), {1, 3}), nums.end());
    #else
        nums.erase(std::remove(nums.begin(), nums.end(), std::complex<double>{1, 3}),
                   nums.end());
    #endif
    assert((nums == std::vector<std::complex<double>>{{2, 2}, {4, 8}}));
}

1) "Quick  Red  Dog"
2) "QuickRedDog Dog"
3) "QuickRedDog", size: 15
4) "QuickRedDog", size: 11
5) "JumpedOverALazyFox"

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi