Set de détecter l'insertion d'échec

Est-il un moyen simple de détecter quand un jeu insertion ne se fait pas parce que l'élément inséré existe déjà dans le jeu? Par exemple, je voudrais afficher un message à l'utilisateur qui montre l'insertion de l'échec, de sorte qu'ils peuvent trouver et supprimer les doublons dans les données plus facilement. Voici un pseudo-code pour démontrer ce que j'aimerais faire:

try
{
   items.insert(item)
}

catch insert_failed_item_already_in_set
{
   //show user the failed item
}

cplusplus.com/reference/stl/set/insert
Quelque chose de mal avec votre C++ standard de référence de la bibliothèque? Vous n'avez même pas regarder le type de retour des fonctions que vous utilisez?
Désolé pour la question. Je n'ai pas utilisé des ensembles beaucoup. Je sais que la structure de données bien, tout simplement pas comment C++ détecté d'insertion à l'échec. Je ne vais pas poser ces questions ici plus longtemps. Merci à tous ceux qui ont pris le temps de répondre.

InformationsquelleAutor 01100110 | 2012-03-06

c++set stdset

9

Il y a cette insert signature dans std::set

pair<iterator,bool> insert ( const value_type& x );

Test de la second de retour de la paire, doit être défini à true si elle est insérée correctement.
- Merci!!!! Je n'ai pas utilisé des ensembles beaucoup. J'apprécie la référence. Qui fonctionne.
InformationsquelleAutor Nim
15

Une signature pour set::insert est:
```
pair<iterator,bool> insert ( const value_type& x );
```
Donc, votre code devrait ressembler à:
```
if( !items.insert(item).second )
{   
    show user the failed item
}
```
- Correction; un signature pour set::insert
- Vous avez raison, bien sûr.
InformationsquelleAutor Robᵩ
4

de cplusplus:

se référant à insérer(const T& valeur)

La première version renvoie une paire, avec ses membres de la paire::première série à un itérateur pointant vers le nouvellement inséré l'élément ou de l'élément qui avaient déjà sa même valeur dans le jeu. La paire::deuxième élément de la paire est définie sur true si un élément nouveau a été inséré ou false si un élément avec la même valeur existé.

InformationsquelleAutor andrea.marangoni
4

Comme indiqué insérer un retour de la paire, vous pouvez vérifier l'état du deuxième élément de la paire à l'aide de get<1> qui est le Booléen , si votre insertion est réalisée ou non .
```
if (get<1>(set.insert(x)) == false){
 //Your error log.
}
```
InformationsquelleAutor Parth
2

STL set<>.insert(elem) retourne pair<iterator,bool> où la deuxième valeur de la paire est true si l'élément a été inséré avec succès, false sinon.

InformationsquelleAutor malenkiy_scot
1

Une opération d'insertion sur un ensemble renvoie une paire, avec ses membres first ensemble pour un itérateur pointant vers le nouvellement inséré l'élément ou de l'élément équivalent déjà dans le jeu. Le second élément de la paire est mis à true si un nouvel élément est inséré ou false si un élément équivalent existait déjà. Ainsi, vous pouvez utiliser le second élément afin de déterminer si elle a été ajoutée.

Par exemple:
```
#include <iostream>
#include <set>
using namespace std;
int main ()
{
 std::set<int> myset;
 std::set<int>::iterator it;
 std::pair<std::set<int>::iterator,bool> ret;


 for (int i=1; i<=5; ++i) myset.insert(i*10);    //set: 10 20 30 40 50

 ret = myset.insert(20);               //no new element inserted

 if (ret.second==false)
     cout<<"Element already present";

}
```
InformationsquelleAutor Prashant Shubham
0

Parce que l'ensemble des contenants ne permettant pas de doublons, l'insertion de l'opération vérifie pour chaque élément inséré si un autre élément existe déjà dans le récipient avec la même valeur, le cas échéant, l'élément n'est pas insérée et -si la fonction renvoie la valeur d'un itérateur, il est renvoyé.

vous pouvez trouver un exemple ici:
http://www.cplusplus.com/reference/stl/set/insert/

InformationsquelleAutor Stefan Birladeanu
0

Il est assez facile de vérifier si un élément est déjà dans un ensemble. Si c'est la seule chose que vous cherchez n'est pas nécessaire pour le try/catch.
```
if ( items.find(item) == items.end() )
{
    //Item was not in the set, so put it in the set
    items.insert(item)
}
else
{
    //Item was already in the set
}
```
Ou vous pouvez vérifier l'insertion de la valeur de retour, qui est une paire qui est second de la moitié de la paire est de savoir si l'insertion a été un succès:
```
if ( false == items.insert(item).second )
{
    //Item was already in the set
}
```
Des deux méthodes, la deuxième méthode est plus compact et plus efficace, comme la première méthode nécessite deux recherches, l'une pendant .find, et une autre en cours de .insert.

InformationsquelleAutor Nic Foster

Vous devez vous connecter pour publier un commentaire.