Como descobrir se um item está presente em um std::vector?

Como outros já disseram, use o STL find ou find_if funções. Mas se você procura muito grande de vetores e isso afeta o desempenho, poderá ordenar o seu vetor e, em seguida, usar o binary_search, lower_bound, ou upper_bound algoritmos.

Usar O find a partir do cabeçalho do algoritmo de stl.Ilustrei o seu uso com o tipo int. Você pode usar qualquer tipo que você gosta, desde que você possa comparar para a igualdade (sobrecarga == se você precisar para a sua classe personalizada).

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

Se o seu vector não for ordenado, use a abordagem MSN sugerida:

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

Se o seu vector for ordenado, use o método binary_search Brian Neal sugerido:

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

A busca binária produz um desempenho de O (log n) no pior caso, o que é muito mais eficiente do que a primeira abordagem. A fim de usar a pesquisa binária, você pode usar o qsort para classificar o vetor primeiro para garantir que ele é ordenado.

#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

Em C++11 pode usar any_of. Por exemplo, se for um vector<string> v; Então:

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

Em alternativa, utilize um lambda:

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

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

Lembre-se que pode escapar com o parâmetro 1 modelo porque pode extrair o value_type do contentor. Você precisa do typename Porque Container::value_type é um Nome dependente .

Std:: vector é o recipiente de escolha, a menos que tenha uma razão para outro, e as pesquisas pelo valor podem ser essa razão.

Utilize a função STL find.

, tenha em mente que há também um find_if função, que você pode usar se a pesquisa é mais complexo, i.e. se você não está apenas procurando por um elemento, mas, por exemplo, quer ver se há um elemento que cumpre uma determinada condição, por exemplo, uma seqüência de caracteres que começa com "abc". ({[[0]} dar-lhe-ia um iterador que apontasse para o primeiro desses elementos).

Com impulso pode usar any_of_equal:

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

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

Pode tentar este código:

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

Podes usar o find função, encontrada no espaço de nomes std, ie std::find. Você passa a função std::find a begin e end iterador do vector que deseja procurar, juntamente com o elemento que procura e compara o iterador resultante com o fim do vector para ver se correspondem ou não.

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

Também podes usar a contagem. Ele retornará o número de itens presentes em um vetor.

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

Se quiseres encontrar uma corda num vector:

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

(C++17 e superior):

Também

Isto também é útil para pesquisar sequência de elementos.

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

Também há flexibilidade de passar alguns algoritmos de busca. Veja aqui.

Https://en.cppreference.com/w/cpp/algorithm/search

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

Eu usei pessoalmente modelos de tarde para lidar com vários tipos de contentores ao mesmo tempo, em vez de lidar apenas com Vectores. Encontrei um exemplo similar online (não me lembro de onde), então o crédito vai para quem eu roubou isso. Este padrão em particular parece lidar com arrays raw também.

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

Usando Newton C++ é mais fácil, auto-documentado e mais rápido do que com std::encontrar por causa do retorno de um bool directamente.

bool exists_linear( INPUT_ITERATOR first, INPUT_ITERATOR last, const T& value )

bool exists_binary( INPUT_ITERATOR first, INPUT_ITERATOR last, const T& value )

include <newton/algorithm/algorithm.hpp>

if ( newton::exists_linear(first, last, value) )
   do_this();
else
   do_that();