une autre façon de dire simplement si un élément existe est de vérifier le 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, j'ai besoin d'accéder à l'élément partout où je vérifie son existence.

donc je dois trouver l'itérateur de toute façon. Alors, bien sûr, il est préférable de simplement comparer à end .

set< X >::iterator it = myset.find(x);
if (it != myset.end()) {
   // do something with *it
}

juste pour clarifier, la raison pour laquelle il n'y a aucun membre comme contains() dans ces types de conteneurs est parce qu'il vous ouvrirait à l'écriture de code inefficace. Une telle méthode ne ferait probablement qu'un this->find(key) != this->end() en interne, mais considérez ce que vous faites lorsque la clé est effectivement présente; dans la plupart des cas, vous voudrez alors obtenir l'élément et faire quelque chose avec lui. Cela signifie que vous devez faire un second find() , ce qui est inefficace. Il est préférable d'utiliser find directement, de sorte que vous pouvez résultat, comme ceci:

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 vous souciez pas de l'efficacité, vous pouvez toujours lancer le vôtre, mais dans ce cas, vous ne devriez probablement pas utiliser C++... ;)

si vous deviez ajouter une fonction contains , elle 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 des réseaux 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, j'ai utilisé involontairement une fonction nouvelle à C++0x ( std::begin et std::end ). Voici la mise en œuvre presque insignifiante 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);
    }

}

vous pouvez également vérifier si un élément est en jeu ou non lors de l'insertion de l'élément. La version single element renvoie une paire, avec sa paire de membres:: d'abord définie à un itérateur pointant soit vers l'élément nouvellement inséré, soit vers l'élément équivalent déjà dans l'ensemble. La paire:: second élément de la paire est définie à true si un nouvel élément a été inséré ou false 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 nouvellement inséré que pair::first pointera à la position du nouvel élément dans set.

écrivez les vôtres:

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 n'est pas aussi efficace que

if(my_set.find(that_element)!=my_set.end()) ....;

ma version ne fait que gagner du temps à écrire le code. Je préfère cette façon concurrentielle pour le codage.

j'ai pu écrire une fonction générale contains 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

ceci nettoie un peu la syntaxe.

mais je ne pouvais pas utiliser paramètre Modèle magic pour rendre ce travail des 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() ;
}

tout commentaire sur l'amélioration de la dernière réponse serait agréable.

//syntaxe générale

       set<int>::iterator ii = find(set1.begin(),set1.end(),"element to be searched");

/* dans le code ci-dessous je suis en train d'essayer de trouver l'élément 4 et int set s'il est présent ou pas*/

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.
 }