如何找出std :: vector中是否存在项目？

Question

我要做的就是检查矢量中是否存在一个元素，以便我可以处理每种情况。

if ( item_present )
   do_this();
else
   do_that();

Answer 1

您可以使用 std :: find >＆lt;算法＆gt; ：

#include <algorithm>
#include <vector>
vector<int> vec; 
//can have other data types instead of int but must same datatype as item 
std::find(vec.begin(), vec.end(), item) != vec.end()

这将返回到第一个元素。如果不存在，它会将迭代器返回到持久的一半。与您的示例：

#include <algorithm>
#include <vector>

if ( std::find(vec.begin(), vec.end(), item) != vec.end() )
   do_this();
else
   do_that();

Answer 2

正如其他人所说，使用stl find_if functions。但是，如果您要在非常大的向量中搜索并影响性能，则可能需要对矢量进行分类，然后使用 binary_search ， 或算法。

Answer 3

如果未订购您的向量，请使用MSN建议的方法：

if(std::find(vector.begin(), vector.end(), item)!=vector.end()){
      // Found the item
}

如果您的向量是订购的，请使用binary_search方法Brian Neal建议：

if(binary_search(vector.begin(), vector.end(), item)){
     // Found the item
}

二进制搜索产生O（log n）最差的性能，这比第一个方法更有效。为了使用二进制搜索，您可以使用Qsort首先对矢量进行排序，以确保其订购。

Answer 4

使用从Stl的算法标题中查找。我已经说明了其与int类型的使用。只要您可以比较平等（如果您需要为自定义类）进行比较，则可以使用任何喜欢的类型。

#include <algorithm>
#include <vector>

using namespace std;
int main()
{   
    typedef vector<int> IntContainer;
    typedef IntContainer::iterator IntIterator;

    IntContainer vw;

    //...

    // find 5
    IntIterator i = find(vw.begin(), vw.end(), 5);

    if (i != vw.end()) {
        // found it
    } else {
        // doesn't exist
    }

    return 0;
}

Answer 5

在C ++ 11中，您可以使用 any_of 。例如，如果是 vector＆lt; string＆gt; v; 然后：

if (any_of(v.begin(), v.end(), bind(equal_to<string>(), _1, item)))
   do_this();
else
   do_that();

或者使用lambda：

if (any_of(v.begin(), v.end(), [&](const std::string& elem) { return elem == item; }))
   do_this();
else
   do_that();

Answer 6

在C ++ 23中，我们终于有一个体面的解决方案：

if (std::ranges::contains(vec, item))
   do_this();
else
   do_that();

Answer 7

我使用这样的东西...

#include <algorithm>


template <typename T> 
const bool Contains( std::vector<T>& Vec, const T& Element ) 
{
    if (std::find(Vec.begin(), Vec.end(), Element) != Vec.end())
        return true;

    return false;
}

if (Contains(vector,item))
   blah
else
   blah

...这样它实际上清晰可读。
（显然，您可以在多个位置重复使用模板）。

Answer 8

从C ++ 20，使用范围（ #include＆lt; ranges＆gt; ）

    //SAMPLE DATA
    std::vector<int> vecOfElements = { 2,4,6,8 };

    //DO SOMETHING IF 8 IN VECTOR
    if (std::ranges::find(vecOfElements, 8) != vecOfElements.end())
    {
        std::cout << "DO SOMETHING" << std::endl;
    }

Answer 9

这是一个适用于任何容器的函数：

template <class Container> 
const bool contains(const Container& container, const typename Container::value_type& element) 
{
    return std::find(container.begin(), container.end(), element) != container.end();
}

请注意，您可以使用1个模板参数逃脱，因为您可以从容器中提取 value_type 。您需要 typename 因为容器:: value_type 是依赖性名称。

Answer 10

请记住，如果您要进行很多查找，那么有一些STL容器会更好。我不知道您的应用程序是什么，但是像STD :: MAP这样的关联容器可能值得考虑。

std :: vector是选择的容器，除非您有另一个原因，而按值进行查找可能就是这样的原因。

Answer 11

使用Boost，您可以使用 any_of_equal ：

#include <boost/algorithm/cxx11/any_of.hpp>

bool item_present = boost::algorithm::any_of_equal(vector, element);

Answer 12

使用stl 查找函数。

请记住，还有一个 find_if 函数，如果您可以使用，如果您可以使用它们搜索更为复杂，即如果您不仅在寻找元素，例如，是否要查看是否有一个元素满足特定条件，例如，以“ ABC”开头的字符串。 （ find_if 将为您提供指向第一个此类元素的迭代器）。

Answer 13

您可以尝试此代码：

#include <algorithm>
#include <vector>

// You can use class, struct or primitive data type for Item
struct Item {
    //Some fields
};
typedef std::vector<Item> ItemVector;
typedef ItemVector::iterator ItemIterator;
//...
ItemVector vtItem;
//... (init data for vtItem)
Item itemToFind;
//...

ItemIterator itemItr;
itemItr = std::find(vtItem.begin(), vtItem.end(), itemToFind);
if (itemItr != vtItem.end()) {
    // Item found
    // doThis()
}
else {
    // Item not found
    // doThat()
}

Answer 14

您可以使用 查找 代码> std 名称空间，即 std ::查找。您通过 std :: find 函数开始和 end 从您要搜索的向量以及您正在查找的元素中读取器因为并将结果迭代器与向量的末端进行比较，以查看它们是否匹配。

std::find(vector.begin(), vector.end(), item) != vector.end()

您还能够像其他任何迭代器一样放弃迭代器并正常使用它。

Answer 15

您也可以使用计数。
它将返回向量中存在的项目数。

int t=count(vec.begin(),vec.end(),item);

Answer 16

我亲自使用了最近的模板来一次处理多种类型的容器，而不仅仅是处理矢量。我在网上找到了一个类似的例子（不记得在哪里），所以无论我从中窃取了这一点，都将获得信用。这种特殊的模式似乎也处理了原始阵列。

template <typename Container, typename T = typename std::decay<decltype(*std::begin(std::declval<Container>()))>::type>
bool contains(Container && c, T v)
{
    return std::find(std::begin(c), std::end(c), v) != std::end(c);
}

Answer 17

template <typename T> bool IsInVector(const T & what, const std::vector<T> & vec)
{
    return std::find(vec.begin(),vec.end(),what)!=vec.end();
}

Answer 18

（C ++ 17及以上）：

可以使用 std :: search

这也可用于搜索元素序列。

#include <algorithm>
#include <iostream>
#include <vector>

template <typename Container>
bool search_vector(const Container& vec, const Container& searchvec)
{
    return std::search(vec.begin(), vec.end(), searchvec.begin(), searchvec.end()) != vec.end();
}

int main()
{
     std::vector<int> v = {2,4,6,8};

     //THIS WORKS. SEARCHING ONLY ONE ELEMENT.
     std::vector<int> searchVector1 = {2};
     if(search_vector(v,searchVector1))
         std::cout<<"searchVector1 found"<<std::endl;
     else
         std::cout<<"searchVector1 not found"<<std::endl;

     //THIS WORKS, AS THE ELEMENTS ARE SEQUENTIAL.
     std::vector<int> searchVector2 = {6,8};
     if(search_vector(v,searchVector2))
         std::cout<<"searchVector2 found"<<std::endl;
     else
         std::cout<<"searchVector2 not found"<<std::endl;

     //THIS WILL NOT WORK, AS THE ELEMENTS ARE NOT SEQUENTIAL.
     std::vector<int> searchVector3 = {8,6};
     if(search_vector(v,searchVector3))
         std::cout<<"searchVector3 found"<<std::endl;
     else
         std::cout<<"searchVector3 not found"<<std::endl;
}

同样，通过一些搜索算法也有灵活性。请参阅此处。

https://en.cppreference.com/w/cpp/algorithm/algorithm/searchm/search

Answer 19

如果您想在向量中找到字符串：

struct isEqual
{
    isEqual(const std::string& s): m_s(s)
    {}

    bool operator()(OIDV* l)
    {
        return l->oid == m_s;
    }

    std::string m_s;
};

struct OIDV
{
    string oid;
//else
};

VecOidv::iterator itFind = find_if(vecOidv.begin(), vecOidv.end(), isEqual(szTmp));

Answer 20

另一种方法是使用 std :: count 。

示例代码：

#include <algorithm>
#include <vector>

void run_vector_contains_example() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int item_to_find = 3;

    int count = std::count(vec.begin(), vec.end(), item_to_find);

    if (count > 0) {
        // item found in vector
    } else {
        // item not found in vector
    }
}

诚然，此方法可能比 std ::与大型矢量打交道时。

Answer 21

怎么样？

   #include <iostream>
   #include <vector>
   #include <algorithm>

int main() {
std::vector<int> vec = {1, 2, 3, 4, 5};

// Find element 3 in the vector
auto it = std::find(vec.begin(), vec.end(), 3);

// Check if element is found
if (it != vec.end()) {
    // Calculate index of the found element
    int index = std::distance(vec.begin(), it);
    std::cout << "Element 3 found at index: " << index << std::endl;
} else {
    std::cout << "Element 3 not found" << std::endl;
}

return 0;
}