Answers:
典型的检查方法存在许多STL容器,例如std::map
,std::set
...是:
const bool is_in = container.find(element) != container.end();
std::find(container.begin(), container.end(), element) != container.end()
; O(N)问题仍然存在……
if(container.find(foo) == container.end())
需要进行树查找以首先找到元素-如果未找到,则需要进行第二次树查找以找到正确的插入位置。原始变体if(container.insert(foo).second) {...}
的魅力在于,只需一个树即可查找...
set.contains(x)
会在C ++ 20标准中返回布尔值。我不知道为什么要到2020
简单判断一个元素是否存在的另一种方法是检查 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
函数,因此,如以下提到的,以下内容变为可能:https : //stackoverflow.com/a/54197839/895245
if (myset.contains(x)) {
// x is in the set
} else {
// no x
}
count()
代替find()
永远不会更好,但可能会更糟。这是因为find()
将在第一个匹配项之后返回,count()
并将始终遍历所有元素。
multiset
,multimap
我想吗?仍然
set
包含一个匹配的成员,所以在这种情况下,是否会像在Pieter指出的那样,在定位第一个元素之后停止该函数的实现?无论如何都有用的答案!
count()
从未比现在快find()
)仍然成立,但第二部分确实不适用于std::set
。但是,我猜想可以提出另一个论点find()
:它更具表现力,即强调您要查找元素而不是计算出现次数。
为了明确起见,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 ++ ...;)
list::remove
,remove(makes_sense_only_for_vector, iterators)
...)
在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";
}
}
如果要添加一个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::set
,并记住只有在您唯一需要知道的是存在的情况下才适用。
您还可以在插入元素时检查元素是否在集合中。单个元素版本返回一对,其成员pair :: first设置为一个迭代器,该迭代器指向新插入的元素或集合中已经存在的等效元素。如果插入了新元素,则对中的pair :: second元素设置为true,如果已经存在等效元素,则设置为false。
例如:假设集合已经有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.
如果新插入的元素比对:: first将指向set中新元素的位置。
自己写:
template<class T>
bool checkElementIsInSet(const T& elem, const std::set<T>& container)
{
return container.find(elem) != container.end();
}
我能写一般的contains
功能std::list
和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
这样可以稍微清理一下语法。
但是我无法使用模板模板参数魔术来使此工作成为任意的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() ;
}
关于改善最后答案的任何评论都很好。
template<typename CONTAINER, typename CONTAINEE> bool contains(const CONTAINER& container, const CONTAINEE& needle) { return find(container.begin(), container.end(), needle) != container.end();
//一般语法
set<int>::iterator ii = find(set1.begin(),set1.end(),"element to be searched");
/ *在下面的代码中,我试图在元素4中找到元素4并设置它是否存在* /
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.
}