Comment vérifier qu'un élément est dans un std :: set?
Question
Comment vérifier qu'un élément est dans un ensemble?
Y at-il un équivalent plus simple du code suivant:
myset.find(x) != myset.end()
La solution
La façon typique de vérifier l'existence dans de nombreux conteneurs STL est:
const bool is_in = container.find(element) != container.end();
Autres conseils
Une autre façon de dire simplement si un élément existe est de vérifier la count()
if (myset.count(x)) {
// x is in the set, count is 1
} else {
// count zero, i.e. x not in the set
}
La plupart du temps, cependant, je me trouve besoin d'accéder à l'élément où je vérifie son existence.
Alors je dois trouver l'itérateur de toute façon. Ensuite, bien sûr, il vaut mieux se contenter de comparer à end
aussi.
set< X >::iterator it = myset.find(x);
if (it != myset.end()) {
// do something with *it
}
C 20 ++
Dans 20 ensemble C de obtient une fonction contains
, de sorte que le suivant devient possible
if (myset.contains(x)) {
// x is in the set
} else {
// no x
}
Juste pour clarifier les choses, la raison pour laquelle il n'y a aucun membre comme contains()
dans ces types de conteneurs est parce qu'il vous ouvrir à l'écriture de code inefficace. Une telle méthode serait probablement juste faire une this->find(key) != this->end()
interne, mais considérez ce que vous faites lorsque la clé est bien présent; dans la plupart des cas, vous aurez envie alors d'obtenir l'élément et faire quelque chose avec elle. Cela signifie que vous auriez à faire une deuxième find()
, ce qui est inefficace. Il est préférable d'utiliser directement trouver, de sorte que vous pouvez mettre en cache le résultat, comme suit:
Container::const_iterator it = myContainer.find(key);
if (it != myContainer.end())
{
// Do something with it, no more lookup needed.
}
else
{
// Key was not present.
}
Bien sûr, si vous ne se soucient pas de l'efficacité, vous pouvez toujours rouler votre propre, mais dans ce cas, vous ne devriez probablement pas en C ++ ...;)
Si vous allez ajouter une fonction contains
, il pourrait ressembler à ceci:
#include <algorithm>
#include <iterator>
template<class TInputIterator, class T> inline
bool contains(TInputIterator first, TInputIterator last, const T& value)
{
return std::find(first, last, value) != last;
}
template<class TContainer, class T> inline
bool contains(const TContainer& container, const T& value)
{
// This works with more containers but requires std::begin and std::end
// from C++0x, which you can get either:
// 1. By using a C++0x compiler or
// 2. Including the utility functions below.
return contains(std::begin(container), std::end(container), value);
// This works pre-C++0x (and without the utility functions below, but doesn't
// work for fixed-length arrays.
//return contains(container.begin(), container.end(), value);
}
template<class T> inline
bool contains(const std::set<T>& container, const T& value)
{
return container.find(value) != container.end();
}
Cela fonctionne avec std::set
, d'autres conteneurs STL, et même les tableaux de longueur fixe:
void test()
{
std::set<int> set;
set.insert(1);
set.insert(4);
assert(!contains(set, 3));
int set2[] = { 1, 2, 3 };
assert(contains(set2, 3));
}
Edit:
Comme indiqué dans les commentaires, je involontairement une fonction nouvelle à C ++ 0x (std::begin
et std::end
). Voici la mise en œuvre quasi-triviale de VS2010:
namespace std {
template<class _Container> inline
typename _Container::iterator begin(_Container& _Cont)
{ // get beginning of sequence
return (_Cont.begin());
}
template<class _Container> inline
typename _Container::const_iterator begin(const _Container& _Cont)
{ // get beginning of sequence
return (_Cont.begin());
}
template<class _Container> inline
typename _Container::iterator end(_Container& _Cont)
{ // get end of sequence
return (_Cont.end());
}
template<class _Container> inline
typename _Container::const_iterator end(const _Container& _Cont)
{ // get end of sequence
return (_Cont.end());
}
template<class _Ty,
size_t _Size> inline
_Ty *begin(_Ty (&_Array)[_Size])
{ // get beginning of array
return (&_Array[0]);
}
template<class _Ty,
size_t _Size> inline
_Ty *end(_Ty (&_Array)[_Size])
{ // get end of array
return (&_Array[0] + _Size);
}
}
C ++ 20 nous obtenons finalement méthode std::set::contains
.
#include <iostream>
#include <string>
#include <set>
int main()
{
std::set<std::string> example = {"Do", "not", "panic", "!!!"};
if(example.contains("panic")) {
std::cout << "Found\n";
} else {
std::cout << "Not found\n";
}
}
Vous pouvez également vérifier si un élément est en jeu ou non lors de l'insertion de l'élément. La version à un seul élément d'une paire de retour, avec sa paire d'élément :: first fixé à un itérateur pointant vers soit l'élément nouvellement inséré ou de l'élément équivalent déjà dans l'ensemble. La paire :: deuxième élément de la paire est définie sur true si un nouvel élément a été inséré ou faux si un élément équivalent existait déjà.
Par exemple:. Supposons que l'ensemble a déjà 20 comme un élément
std::set<int> myset;
std::set<int>::iterator it;
std::pair<std::set<int>::iterator,bool> ret;
ret=myset.insert(20);
if(ret.second==false)
{
//do nothing
}
else
{
//do something
}
it=ret.first //points to element 20 already in set.
Si l'élément est inséré récemment que deux :: premier pointera vers la position de nouvel élément dans le jeu.
Écrivez votre propre:
template<class T>
bool checkElementIsInSet(const T& elem, const std::set<T>& container)
{
return container.find(elem) != container.end();
}
J'utilise
if(!my_set.count(that_element)) //Element is present...
;
Mais il est pas aussi efficace que
if(my_set.find(that_element)!=my_set.end()) ....;
Ma version enregistre uniquement mon temps par écrit le code. Je préfère cette façon pour le codage concurrentiel.
Je suis capable d'écrire une fonction contains
générale pour std::list
et std::vector
,
template<typename T>
bool contains( const list<T>& container, const T& elt )
{
return find( container.begin(), container.end(), elt ) != container.end() ;
}
template<typename T>
bool contains( const vector<T>& container, const T& elt )
{
return find( container.begin(), container.end(), elt ) != container.end() ;
}
// use:
if( contains( yourList, itemInList ) ) // then do something
nettoie la syntaxe un peu.
Mais je ne pouvais pas utiliser le paramètre template modèle magie pour faire ce travail conteneurs stl arbitraires.
// NOT WORKING:
template<template<class> class STLContainer, class T>
bool contains( STLContainer<T> container, T elt )
{
return find( container.begin(), container.end(), elt ) != container.end() ;
}
Les commentaires au sujet de l'amélioration de la dernière réponse serait bien.
// Syntaxe générale
set<int>::iterator ii = find(set1.begin(),set1.end(),"element to be searched");
/ * en dessous de code que je suis en train de trouver l'élément 4 et int mis si elle est présente ou non * /
set<int>::iterator ii = find(set1.begin(),set1.end(),4);
if(ii!=set1.end())
{
cout<<"element found";
set1.erase(ii);// in case you want to erase that element from set.
}