Namespaces
Variants

std:: erase, std:: erase_if (std::list)

From cppreference.net

C++
Containers library
std::list
Member functions
Non-member functions
(C++20)
erase (std::list) erase_if (std::list)
(C++20) (C++20)
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
Défini dans l'en-tête <list>
(1)
template < class T, class Alloc, class U >

typename std:: list < T, Alloc > :: size_type

erase ( std:: list < T, Alloc > & c, const U & value ) ;
(depuis C++20)
(jusqu'à C++26)
template < class T, class Alloc, class U = T >

constexpr typename std:: list < T, Alloc > :: size_type

erase ( std:: list < T, Alloc > & c, const U & value ) ;
(depuis C++26)
template < class T, class Alloc, class Pred >

typename std:: list < T, Alloc > :: size_type

erase_if ( std:: list < T, Alloc > & c, Pred pred ) ;
(2) (depuis C++20)
(constexpr depuis C++26)
1) Supprime tous les éléments égaux à value du conteneur c . Équivalent à return c. remove_if ( [ & ] ( const auto & elem ) - > bool { return elem == value ; } ) ; .
2) Supprime tous les éléments qui satisfont le prédicat pred du conteneur c . Équivalent à return c. remove_if ( pred ) ; .

Table des matières

Paramètres

c - conteneur duquel effacer
value - valeur à supprimer
pred - prédicat unaire qui retourne ​ true si l'élément doit être effacé.

L'expression pred ( v ) doit être convertible en bool pour chaque argument v de type (éventuellement const) T , indépendamment de la catégorie de valeur , et ne doit pas modifier v . Ainsi, un type de paramètre T & n'est pas autorisé , pas plus que T sauf si pour T un déplacement est équivalent à une copie (depuis C++11) . ​

Valeur de retour

Le nombre d'éléments effacés.

Complexité

Linéaire.

Notes

Contrairement à std::list::remove , erase accepte des types hétérogènes et ne force pas une conversion vers le type de valeur du conteneur avant d'invoquer l'opérateur == .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_algorithm_default_value_type 202403 (C++26) Initialisation par liste pour std::erase

Exemple

Exécuter ce code 
#include <complex>
#include <iostream>
#include <numeric>
#include <string_view>
#include <list>
void println(std::string_view comment, const auto& c)
{
    std::cout << comment << '[';
    bool first{true};
    for (const auto& x : c)
        std::cout << (first ? first = false, "" : ", ") << x;
    std::cout << "]\n";
}
int main()
{
    std::list<char> cnt(10);
    std::iota(cnt.begin(), cnt.end(), '0');
    println("Initialement, cnt = ", cnt);
    std::erase(cnt, '3');
    println("Après effacement de '3', cnt = ", cnt);
    auto erased = std::erase_if(cnt, [](char x) { return (x - '0') % 2 == 0; });
    println("Après effacement de tous les nombres pairs, cnt = ", cnt);
    std::cout << "Nombres pairs effacés : " << erased << '\n';
    std::list<std::complex<double>> nums{{2, 2}, {4, 2}, {4, 8}, {4, 2}};
    #ifdef __cpp_lib_algorithm_default_value_type
        std::erase(nums, {4, 2});
    #else
        std::erase(nums, std::complex<double>{4, 2});
    #endif
    println("Après effacement de {4, 2}, nums = ", nums);
}

Sortie : 

Initialement, cnt = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Après effacement de '3', cnt = [0, 1, 2, 4, 5, 6, 7, 8, 9]
Après effacement de tous les nombres pairs, cnt = [1, 5, 7, 9]
Nombres pairs effacés : 5
Après effacement de {4, 2}, nums = [(2,2), (4,8)]

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.

DR Appliqué à Comportement publié Comportement corrigé
LWG 4135 C++20 le type de retour du prédicat lambda utilisé
était déduit des arguments du prédicat 		le type de retour est
explicitement spécifié comme bool

Voir aussi

supprime les éléments satisfaisant des critères spécifiques
(modèle de fonction)
(C++20) (C++20)
supprime les éléments satisfaisant des critères spécifiques
(objet fonction algorithme)
supprime les éléments satisfaisant des critères spécifiques
(fonction membre publique)