在许多STL容器中检查是否存在的典型方法，如std::map， std::set，…是:

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

写你自己的:

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

另一种简单地判断元素是否存在的方法是检查count()

if (myset.count(x)) {
// x is in the set, count is 1
} else {
// count zero, i.e. x not in the set
}

然而，大多数时候，我发现自己需要访问元素，无论我在哪里检查它的存在。

所以我还是要找到迭代器。然后，当然，最好也将它与end进行比较。

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

C + + 20

在c++ 20中，set得到一个contains函数，因此如下所述成为可能

if (myset.contains(x)) {
// x is in the set
} else {
// no x
}

澄清一下，在这些容器类型中没有contains()这样的成员的原因是因为它会让你编写低效的代码。这样的方法可能只是在内部做this->find(key) != this->end()，但是考虑一下当键确实存在时你做了什么;在大多数情况下，您将希望获取元素并对其做一些事情。这意味着你必须执行第二次find()，这是低效的。最好直接使用find，这样你就可以缓存你的结果，像这样:

auto it = myContainer.find(key);
if (it != myContainer.end())
{
// Do something with it, no more lookup needed.
}
else
{
// Key was not present.
}

当然，如果你不关心效率，你总是可以自己滚动，但在这种情况下，你可能不应该使用c++…；）

如果你要添加一个contains函数，它可能看起来像这样:

#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();
}

这适用于std::set，其他STL容器，甚至是定长数组:

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));
}

编辑:

正如评论中指出的，我无意中使用了c++ 0x的新函数(std::begin和std::end)。下面是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);
}


}

我能够为std::list和std::vector编写一个通用的contains函数，

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

这样可以稍微清理一下语法。

但我不能使用模板模板参数魔术使此工作任意stl容器。

// 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() ;
}

任何关于改进上一个答案的评论都是很好的。

例如:假设集合中已经有20作为元素。

 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.

如果元素是新插入的，则than pair::first将指向新元素在set中的位置。

/ /通用语法

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

/*在下面的代码中，我试图找到元素4和int集，如果它存在与否*/

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

我使用

if(!my_set.count(that_element)) //Element is present...
;

但它的效率不如

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

我的版本只是节省了我写代码的时间。对于竞争性编码，我更喜欢这种方式。

在C + + 20中，我们将最终得到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";
}
}

就是这个，一英里。

bool once(uintptr_t val) {
return visited.emplace(val).second;
}

怎么会不是这样呢?

https://godbolt.org/z/9zP77jqMc

func5(unsigned long):
sub     rsp, 24
mov     QWORD PTR [rsp+8], rdi
lea     rsi, [rsp+8]
mov     edi, OFFSET FLAT:visited2
call    std::pair<std::_Rb_tree_iterator<unsigned long>, bool> std::_Rb_tree<unsigned long, unsigned long, std::_Identity<unsigned long>, std::less<unsigned long>, std::allocator<unsigned long> >::_M_emplace_unique<unsigned long&>(unsigned long&)
add     rsp, 24
mov     eax, edx
ret