Namespaces
Variants

std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: erase

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (C++17)
iterator erase ( iterator pos ) ;
(1) (depuis C++11)
(constexpr depuis C++26)
iterator erase ( const_iterator pos ) ;
(2) (depuis C++11)
(constexpr depuis C++26)
iterator erase ( const_iterator first, const_iterator last ) ;
(3) (depuis C++11)
(constexpr depuis C++26)
size_type erase ( const Key & key ) ;
(4) (depuis C++11)
(constexpr depuis C++26)
template < class K >
size_type erase ( K && x ) ;
(5) (depuis C++23)
(constexpr depuis C++26)

Supprime les éléments spécifiés du conteneur. L'ordre des éléments restants est préservé. (Cela permet de supprimer des éléments individuels lors de l'itération à travers le conteneur.)

1,2) Supprime l'élément à la position pos .
3) Supprime les éléments dans l'intervalle [ first , last ) , qui doit être un intervalle valide dans * this .
4) Supprime l'élément (s'il existe) avec la clé équivalente à key .
5) Supprime tous les éléments dont la clé est équivalente à la valeur x .
Cette surcharge participe à la résolution de surcharge seulement si Hash et KeyEqual sont tous deux transparents , et que ni iterator ni const_iterator ne sont implicitement convertibles depuis K . Cela suppose qu'un tel Hash peut être appelé avec à la fois le type K et le type Key , et que le KeyEqual est transparent, ce qui, ensemble, permet d'appeler cette fonction sans construire une instance de Key .

Les références et itérateurs vers les éléments effacés sont invalidés. Les autres itérateurs et références ne sont pas invalidés.

L'itérateur pos doit être déréférençable. Par conséquent, l'itérateur end() (qui est valide, mais n'est pas déréférençable) ne peut pas être utilisé comme valeur pour pos .

Table des matières

Paramètres

pos - itérateur vers l'élément à supprimer
first, last - la paire d'itérateurs définissant la plage des éléments à supprimer
key - valeur clé des éléments à supprimer
x - une valeur de tout type pouvant être comparée de manière transparente avec une clé désignant les éléments à supprimer

Valeur de retour

1-3) Itérateur suivant le dernier élément supprimé.
4) Nombre d'éléments supprimés (0 ou 1).
5) Nombre d'éléments supprimés.

Exceptions

1-3) Ne lance rien.
4,5) Toute exception levée par les objets Hash et KeyEqual .

Complexité

Étant donné une instance c de unordered_map :

1,2) Cas moyen : constant, cas le plus défavorable : c. size ( ) .
3) Cas moyen : std:: distance ( first, last ) , cas le plus défavorable : c. size ( ) .
4) Cas moyen : c. count ( key ) , cas le plus défavorable : c. size ( ) .
5) Cas moyen : c. count ( x ) , cas le plus défavorable : c. size ( ) .

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_associative_heterogeneous_erasure 202110L (C++23) Effacement hétérogène dans les conteneurs associatifs et les conteneurs associatifs non ordonnés ; surcharge ( 5 )

Exemple

Exécuter ce code 
#include <unordered_map>
#include <iostream>
int main()
{
    std::unordered_map<int, std::string> c =
    {
        {1, "one"}, {2, "two"}, {3, "three"},
        {4, "four"}, {5, "five"}, {6, "six"}
    };
    // supprimer tous les nombres impairs de c
    for (auto it = c.begin(); it != c.end();)
    {
        if (it->first % 2 != 0)
            it = c.erase(it);
        else
            ++it;
    }
    for (auto& p : c)
        std::cout << p.second << ' ';
    std::cout << '\n';
}

Sortie possible : 

two four six

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 2059 C++11 il y avait une ambiguïté pour la surcharge ( 2 ) surcharge ajoutée ( 1 )
LWG 2356 C++11 l'ordre des éléments non équivalents qui ne sont
pas effacés n'était pas garanti d'être préservé 		doit être préservé

Voir aussi

efface le contenu
(fonction membre publique)