Come scoprire se un elemento è presente in un vettore std ::?

Tutto quello che voglio fare è verificare se un elemento esiste nel vettore o meno, così posso occuparmi di ogni caso.

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

Puoi usare std::find da :

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

Questo restituisce un bool ( true se presente, false altrimenti). Con il tuo esempio:

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

Come altri hanno già detto, usa le funzioni STL find o find_if . Ma se stai cercando in vettori di grandi dimensioni e questo ha un impatto sulle prestazioni, potresti voler ordinare il vettore e quindi utilizzare gli binary_search , lower_bound o upper_bound .

Usa find dall’intestazione dell’algoritmo di stl.ho illustrato il suo uso con il tipo int. Puoi utilizzare qualsiasi tipo che ti piace purché sia ​​ansible confrontare per uguaglianza (sovraccarico == se è necessario per la tua class personalizzata).

 #include  #include  using namespace std; int main() { typedef vector 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 il tuo vettore non è ordinato, usa l’approccio suggerito da MSN:

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

Se il tuo vettore è ordinato, usa il metodo binary_search suggerito da Brian Neal:

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

la ricerca binaria produce prestazioni O (log n) nel peggiore dei casi, il che è molto più efficiente del primo approccio. Per utilizzare la ricerca binaria, è ansible utilizzare qsort per ordinare prima il vettore per garantire che sia ordinato.

Io uso qualcosa come questo …

 #include  template  const bool Contains( std::vector& 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 

… in questo modo è in realtà chiaro e leggibile. (Ovviamente puoi riutilizzare il modello in più posti).

Tieni presente che, se hai intenzione di fare molte ricerche, ci sono contenitori STL che sono migliori per questo. Non so quale sia la vostra applicazione, ma i contenitori associativi come std :: map possono valere la pena di essere presi in considerazione.

std :: vector è il contenitore di scelta a meno che tu non abbia una ragione per un’altra, e le ricerche in base al valore possono essere una tale ragione.

In C ++ 11 puoi usare any_of . Ad esempio se è un vector v; poi:

 if (any_of(v.begin(), v.end(), bind2nd(equal_to(), item))) do_this(); else do_that(); 

Usa la funzione di ricerca STL.

Tieni presente che esiste anche una funzione find_if , che puoi utilizzare se la ricerca è più complessa, ad esempio se non stai solo cercando un elemento, ma, ad esempio, vuoi vedere se c’è un elemento che soddisfa un certo condizione, ad esempio, una stringa che inizia con “abc”. ( find_if ti darebbe un iteratore che punta al primo di tali elementi).

Puoi provare questo codice:

 #include  #include  // You can use class, struct or primitive data type for Item struct Item { //Some fields }; typedef std::vector 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() } 

Ecco una funzione che funzionerà per qualsiasi contenitore:

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

Tieni presente che puoi utilizzare 1 parametro del modello perché puoi estrarre il value_type dal contenitore. È necessario il nome di tipo perché Container::value_type è un nome dipendente .

Con boost puoi usare any_of_equal :

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

È ansible utilizzare la funzione di find , trovata nello spazio dei nomi std , ovvero std::find . Si passa alla funzione std::find l’ begin e la end dell’iteratore dal vettore che si desidera cercare, insieme all’elemento che si sta cercando e confrontare l’iteratore risultante alla fine del vettore per vedere se corrispondono o meno.

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

Puoi anche dereferenziare l’iteratore e usarlo normalmente, come qualsiasi altro iteratore.

Puoi usare anche il conteggio. Restituirà il numero di elementi presenti in un vettore.

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

Se vuoi trovare una stringa in un vettore:

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

Un altro esempio che utilizza operatori C ++.

 #include  #include  #include  template inline static bool operator ==(const std::vector& v, const T& elem) { return (std::find(v.begin(), v.end(), elem) != v.end()); } template inline static bool operator !=(const std::vector& v, const T& elem) { return (std::find(v.begin(), v.end(), elem) == v.end()); } enum CODEC_ID { CODEC_ID_AAC, CODEC_ID_AC3, CODEC_ID_H262, CODEC_ID_H263, CODEC_ID_H264, CODEC_ID_H265, CODEC_ID_MAX }; void main() { CODEC_ID codec = CODEC_ID_H264; std::vector codec_list; codec_list.reserve(CODEC_ID_MAX); codec_list.push_back(CODEC_ID_AAC); codec_list.push_back(CODEC_ID_AC3); codec_list.push_back(CODEC_ID_H262); codec_list.push_back(CODEC_ID_H263); codec_list.push_back(CODEC_ID_H264); codec_list.push_back(CODEC_ID_H265); if (codec_list != codec) { throw std::runtime_error("codec not found!"); } if (codec_list == codec) { throw std::logic_error("codec has been found!"); } } 
 template  bool IsInVector(T what, std::vector * vec) { if(std::find(vec->begin(),vec->end(),what)!=vec->end()) return true; return false; } 

Usare Newton C ++ è più facile, autodocumentato e più veloce di con std :: find perché restituisce direttamente un bool.

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

Penso che sia ovvio cosa fanno le funzioni.

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