C++ Méthode d'utilisation et exemple de set erase()

C++ Set (ensemble) STL

C ++ set erase()La fonction est utilisée pour supprimer un seul élément ou une plage d'éléments (de [first, last)) associés à une clé donnée dans le conteneur set. Par conséquent, la taille sera réduite par le nombre d'éléments supprimés.

Syntaxe

void erase(iterator position);　　　　　　　　　　　　　　　　　　　　　　　	　　//C++　11　avant
size_type erase(const value_type& val);　　　　		　　//C++　11　avant
void erase(iterator first, iterator last);　　		　　//C++　11　avant
iterator erase(const_iterator position);		　　//C++　11De
size_type erase(const value_type& val);		　　//C++　11De	
iterator erase(const_iterator first, const_iterator last);　//C++　11De

Paramètres

position：Itérateur, pointant sur l'élément unique à supprimer de l'ensemble.

val：La valeur à supprimer de l'ensemble.

first：Le point de départ de la plage à effacer.

last：Le point final de la plage à effacer.

Valeur de retour

Il retourne un itérateur pointant sur l'élément suivant de l'élément supprimé, ou retourne le nombre d'éléments supprimés.

Complexité

erase(position) : constante amortie.

erase (val) : logarithme de la taille du conteneur.

erase(first, last)：La distance entre le premier et le dernier est linéaire.

Validité de l'itérateur

Les itérateurs, les références et les pointeurs vers l'élément supprimé deviennent invalides.

Tous les autres itérateurs, pointeurs et références conservent leur validité.

Concurrence des données

Le conteneur a été modifié.

L'élément supprimé sera modifié. Bien que l'accès simultané à d'autres éléments soit sécurisé, l'itération sur la plage du conteneur n'est pas sécurisée.

Sécurité des exceptions

Cette fonction ne lève pas d'exception.

Si une plage ou une position invalide est spécifiée, cela peut entraîner un comportement non défini.

exemple1

Laissons-nous voir un exemple simple où l'élément est effacé par l'itérateur.

exemple

#include <iostream>
#include <set>
using namespace std;
int main () {
　　　　set<int> myset;
　　　　iterator set<int> it;
　　　　myset = {
　　　　　　　　10,20,30
　　　　}
　　　　;
　　　　cout << "Avant de supprimer l'élément:\n";
　　　　for (it = myset.begin(); it != myset.end();　++it)
　　　　　　　　cout <<　*it << '\n';
　　　　it = myset.find('b');
　　　　myset.erase (*it);
　　　　//　Effacer par itérateur
　　　　cout << '
' << "Effacer l'élément après : 
";
　　　　for (it = myset.begin(); it != myset.end();　++it)
　　　　　　　　cout <<　*it << '\n';
　　　　return 0;
}

Sortie :

Avant de supprimer l'élément :　
10
20
30
Après avoir supprimé l'élément :　
10
20
30

Dans cet exemple, l'élément est supprimé par l'itérateur.

exemple2

Laissons-nous voir un exemple simple pour effacer des éléments dans un ensemble en utilisant une clé donnée :

exemple

#include <iostream>
#include <set>
using namespace std;
int main ()
{
　　set<int> myset;
　　iterator set<int> it;
　　myset = {10,　20,　30,　40});
　　
　　cout << "Avant de supprimer l'élément:\n";
　　　for (it = myset.begin(); it != myset.end();　++it){
　　　　　cout <<　*it << '
';
　　　}
　　
　　　myset.erase (30);//Effacer la valeur spécifiée
　　cout << "\nAprès avoir supprimé l'élément:\n";
　　for (it = myset.begin(); it != myset.end();　++it){
　　　　　　cout <<　*it << '
';
　　}
　　　　
　　return 0;
}

Sortie :

Avant de supprimer l'élément :　
10
20
30
40
Après avoir supprimé l'élément :　
10
20
40

Dans cet exemple, la fonction erase (value) utilise la valeur dans le ensemble30.

exemple3

Laissons-nous voir un exemple simple pour effacer des éléments dans une plage donnée :

exemple

#include <iostream>
#include <set>
using namespace std;
int main () {
　　　　set<int> myset;
　　　　iterator set<int> it;
　　　　myset = {
　　　　　　　　10,　20,　30
　　　　};
　　　　cout << "Avant de supprimer l'élément:\n";
　　　　cout << "La taille est: " << myset.size() << '\n';
　　　　for (it = myset.begin(); it != myset.end();　++it){
　　　　　　　cout <<　*it << '\n';
　　　　}
　　　　　　
　　　　myset.erase(myset.begin(), myset.end());
　　　　//　Effacer une plage spécifiée
　　　　cout << "\nAprès avoir supprimé l'élément:\n";
　　　　cout << "La taille est: " << myset.size();
　　　　for (it = myset.begin(); it != myset.end();　++it){
　　　　　　　cout <<　*it << '\n';
　　　　}　
　　　　return 0;
}

Sortie :

Avant de supprimer l'élément :　
La taille est:　3
10
20
30
Après avoir supprimé l'élément :　
La taille est: 0

Dans l'exemple précédent, la fonction Erase(first, last) a été utilisée pour supprimer les éléments dans une plage donnée (c'est-à-dire de la première à la dernière).

exemple4

Laissez-nous voir un exemple simple pour supprimer tous les nombres impairs d'un ensemble :

exemple

#include <set>
#include <iostream>
using namespace std;
int main()
{
　　　　set<int> m = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
　　　　　　　　　　　　　　　　　　　　　　　　　　
　　　　//　Supprimer tous les nombres impairs de m
　　　　cout << "Après avoir supprimé les nombres impairs, les éléments sont:\n	";
　　　　for (auto it = m.begin(); it != m.end();){
　　　　　　　　if (*it %　2　==　1)
　　　　　　　　　　　　it = m.erase(it);
　　　　　　　　} else {
　　　　　　　　　　　　++it;
　　　　　　　　}
　　　　　}
　　　　for (auto& p : m) {
　　　　　　　cout << p << ", ";
　　　　　}
}

Sortie :

Après avoir supprimé les nombres impairs, les éléments sont :
　2,　4,　6,　8,　10,　12,　14,

Dans l'exemple précédent, tous les nombres impairs ont été supprimés et les nombres pairs affichés.

exemple5

Laissez-nous voir un autre exemple :

exemple

#include <set>　　
#include <string>　　
#include <iostream>　　
#include <iterator>　//　fonction d'aide next() et prev()　
　　
using namespace std;　　
　　
using myset = set<string>;　　
　　
void printset(const myset& s) {　　
　　　　for (const auto& iter : s) {　　
　　　　　　　　cout << " [" << iter << "]";　　
　　　　}　　
　　　　cout << endl << "size() == " << s.size() << endl << endl;　　
}　　
　　
int main()　　
{　　
　　　　myset s1;　　
　　
　　　　//　Insérer des données pour le test, un à la fois
　　　　s1.insert("Bob");　　
　　　　s1.insert("Robert");　　
　　　　s1.insert("Bert");　　
　　　　s1.insert("Rob");　　
　　　　s1.insert("Bobby");　　
　　
　　　　cout << "Le ensemble s1Les données initiales sont : " << endl;　　
　　　　printset(s1);　　
　　　　//　La première fonction membre supprime l'élément à la position donnée　　
　　　　s1.erase(next(s1.begin()));　　
　　　　cout << "Supprimer le "2après avoir ajouté1est : " << endl;　　
　　　　printset(s1);　　
　　
　　　　//　Utiliser une liste d'initialisation pour insérer un élément de test à la fois
　　　　myset s2{ "meow", "hiss", "purr", "growl", "yowl" };　　
　　
　　　　cout << "Le ensemble s2Les données initiales sont : " << endl;　　
　　　　printset(s2);　　
　　　　//　La deuxième fonction membre supprime l'élément　
　　　　//　la plage [First, Last)　　
　　　　s2.erase(next(s2.begin()), prev(s2.end()));　　
　　　　cout << "Supprimer l'élément intermédiaire après, le ensemble s2est : " << endl;　　
　　　　printset(s2);　　
　　
　　　　myset s3;　　
　　
　　　　//　Utiliser emplace pour insérer un élément de test à la fois　
　　　　s3.emplace("C");　　
　　　　s3.emplace("C#");　　
　　　　s3.emplace("D");　　
　　　　s3.emplace("D#");　　
　　　　s3.emplace("E");　　
　　　　s3.emplace("E#");　　
　　　　s3.emplace("F");　　
　　　　s3.emplace("F#");　　
　　　　s3.emplace("G");　　
　　　　s3.emplace("G#");　　
　　　　s3.emplace("A");　　
　　　　s3.emplace("A#");　　
　　　　s3.emplace("B");　　
　　
　　　　cout << "Le ensemble s3Les données initiales sont : " << endl;　　
　　　　printset(s3);　　
　　　　//　La troisième fonction membre supprime l'élément avec la clé donnée　
　　　　myset::size_type count = s3.erase("E#");　　
　　　　//　La troisième fonction membre retourne également le nombre d'éléments supprimés
　　　　cout << "Supprimer l'élément à partir de s3Le nombre d'éléments supprimés est : " << count << "." << endl;　　
　　　　cout << "Supprimer l'élément clé "E#" après, le ensemble s3est : " << endl;　　
　　　　printset(s3);　　
}

Sortie :

La collection s1Les données initiales sont :
　[Bert] [Bob] [Bobby] [Rob] [Robert]
size() ==　5
supprimer le2après avoir ajouté1Pour:
　[Bert] [Bobby] [Rob] [Robert]
size() ==　4
La collection s2Les données initiales sont :
　[growl] [hiss] [meow] [purr] [yowl]
size() ==　5
Après la suppression de l'élément central, la collection s2Pour:
　[growl] [yowl]
size() ==　2
La collection s3Les données de début sont:
　[A] [A#] [B] [C] [C#] [D] [D#] [E] [E#] [F] [F#] [G] [G#]
size() ==　13
de3Le nombre d'éléments supprimés dans la collection s　1.
Après la suppression de l'élément avec la clé "E#", le nombre d'éléments supprimés dans la collection s3Pour:
　[A] [A#] [B] [C] [C#] [D] [D#] [E] [E#] [F] [F#] [G] [G#]
size() ==　12

C++ Set (ensemble) STL