Comment vérifier qu'un élément est dans un std::set?

Question

Comment vérifiez-vous qu'un élément est dans un ensemble?

Y a-t-il un équivalent plus simple du code suivant:

myset.find(x) != myset.end()

Answer 1

À partir de C++20, vous pouvez utiliser contains pour vérifier l'existence dans de nombreux conteneurs STL tels que std::map, std::set, ... :

const bool is_in = container.contains(element);

Avant C++20, la façon typique était :

const bool is_in = container.find(element) != container.end();

Answer 2

Une autre façon de simplement vérifier si un élément existe est de vérifier le count()

if (myset.count(x)) {
   // x est dans l'ensemble, le compte est de 1
} else {
   // compte nul, c'est-à-dire x n'est pas dans l'ensemble
}

La plupart du temps, cependant, je me retrouve à avoir besoin d'accéder à l'élément partout où je vérifie son existence.

Donc je devrais trouver l'itérateur de toute façon. Ensuite, bien sûr, il vaut mieux simplement le comparer à end aussi.

set< X >::iterator it = myset.find(x);
if (it != myset.end()) {
   // faire quelque chose avec *it
}

C++ 20

En C++20, set obtient une fonction contains, donc ce qui suit devient possible comme mentionné à : https://stackoverflow.com/a/54197839/895245

if (myset.contains(x)) {
  // x est dans l'ensemble
} else {
  // pas de x 
}

Answer 3

Juste pour clarifier, la raison pour laquelle il n'y a pas de membre comme contains() dans ces types de conteneurs est parce que cela ouvrirait la porte à l'écriture de code inefficace. Une telle méthode ferait probablement simplement un this->find(key) != this->end() en interne, mais réfléchissez à 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. Cela signifie que vous devriez faire un second find(), ce qui est inefficace. Il vaut mieux utiliser directement find, afin de pouvoir mettre en cache votre résultat, de la manière suivante :

auto it = myContainer.find(key);
if (it != myContainer.end())
{
    // Faire quelque chose avec, plus besoin de recherche.
}
else
{
    // La clé n'était pas présente.
}

Évidemment, si vous ne vous souciez pas de l'efficacité, vous pouvez toujours créer votre propre méthode, mais dans ce cas, vous ne devriez probablement pas utiliser C++... ;)

Answer 4

Si vous deviez ajouter une fonction contains, elle pourrait ressembler à ceci :

#include 
#include 

template inline
bool contains(TInputIterator first, TInputIterator last, const T& value)
{
    return std::find(first, last, value) != last;
}

template inline
bool contains(const TContainer& container, const T& value)
{
    // Cela fonctionne avec plus de conteneurs mais nécessite std::begin et std::end
    // de C++0x, que vous pouvez obtenir de deux manières :
    //  1. En utilisant un compilateur C++0x ou
    //  2. En incluant les fonctions utilitaires ci-dessous.
    return contains(std::begin(container), std::end(container), value);

    // Cela fonctionne avant C++0x (et sans les fonctions utilitaires ci-dessous, mais ne fonctionne pas
    // pour les tableaux de longueur fixe.
    //return contains(container.begin(), container.end(), value);
}

template inline
bool contains(const std::set& container, const T& value)
{
    return container.find(value) != container.end();
}

Ceci fonctionne avec std::set, d'autres conteneurs STL, et même des tableaux de longueur fixe :

void test()
{
    std::set 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 l'implémentation presque triviale de VS2010 :

namespace std {

template inline
    typename _Container::iterator begin(_Container& _Cont)
    { // obtenir le début de la séquence
    return (_Cont.begin());
    }

template inline
    typename _Container::const_iterator begin(const _Container& _Cont)
    { // obtenir le début de la séquence
    return (_Cont.begin());
    }

template inline
    typename _Container::iterator end(_Container& _Cont)
    { // obtenir la fin de la séquence
    return (_Cont.end());
    }

template inline
    typename _Container::const_iterator end(const _Container& _Cont)
    { // obtenir la fin de la séquence
    return (_Cont.end());
    }

template inline
    _Ty *begin(_Ty (&_Array)[_Size])
    { // obtenir le début du tableau
    return (&_Array[0]);
    }

template inline
    _Ty *end(_Ty (&_Array)[_Size])
    { // obtenir la fin du tableau
    return (&_Array[0] + _Size);
    }

}

Answer 5

Écrivez le vôtre :

template
bool checkElementIsInSet(const T& elem, const std::set& container)
{
  return container.find(elem) != container.end();
}