std :: vector에 항목이 있는지 확인하는 방법?

내가하고 싶은 것은 요소가 벡터에 존재하는지 여부를 확인하는 것이므로 각 경우를 처리 할 수 ​​있습니다.

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

다음 std::find에서 사용할 수 있습니다 <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()

부울을 반환합니다 (있는 true경우 false). 예를 들면 다음과 같습니다.

#include <algorithm>
#include <vector>

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

다른 사람들이 말했듯이 STL find또는 find_if기능을 사용하십시오 . 매우 큰 벡터에서 검색이 성능에 영향을하는 경우에, 당신은 당신의 벡터를 정렬 할 후 사용할 수 있습니다 binary_search, lower_bound또는 upper_bound알고리즘을.

stl의 알고리즘 헤더에서 find를 사용하십시오 .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;
}

벡터를 주문하지 않은 경우 MSN이 제안한 방법을 사용하십시오.

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

벡터가 주문 된 경우 Brian Neal이 제안한 binary_search 메소드를 사용하십시오.

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

이진 검색은 O (log n) 최악의 성능을 제공하며 이는 첫 번째 방법보다 훨씬 효율적입니다. 이진 검색을 사용하려면 qsort를 사용하여 벡터가 정렬되도록 벡터를 먼저 정렬 할 수 있습니다.

나는 이런 것을 사용합니다 ...

#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

... 그런 식으로 실제로 명확하고 읽을 수 있습니다. (여러분은 여러 곳에서 템플릿을 재사용 할 수 있습니다).

C ++ 11에서는을 사용할 수 있습니다 any_of. 예를 들어 다음과 같은 경우 vector<string> v;:

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

또는 람다를 사용하십시오.

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

value_type컨테이너에서를 추출 할 수 있기 때문에 1 개의 템플릿 매개 변수를 사용하여 벗어날 수 있습니다 . 당신은 필요 typename하기 때문에이 Container::value_typeA는 따라 이름 .

많은 조회를 수행하려는 경우 더 나은 STL 컨테이너가 있음을 명심하십시오. 귀하의 응용 프로그램이 무엇인지 모르지만 std :: map과 같은 연관 컨테이너를 고려해 볼 가치가 있습니다.

std :: vector는 다른 이유가없는 한 선택한 컨테이너이며 값별 조회가 그러한 이유 일 수 있습니다.

STL 찾기 기능을 사용하십시오 .

find_if 함수 도 있습니다. 검색이 더 복잡한 경우, 즉 요소를 찾는 것이 아니라 특정 요소를 충족시키는 요소가 있는지 확인하려는 경우 사용할 수 있습니다. 조건 (예 : "abc"로 시작하는 문자열) ( find_if첫 번째 요소를 가리키는 반복자를 제공합니다).

부스트를 사용하면 다음을 사용할 수 있습니다 any_of_equal.

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

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

이 코드를 시도해 볼 수 있습니다.

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

네임 스페이스 find에 있는 함수 를 사용할 수 있습니다 ( std예 :) std::find. 찾고자하는 요소와 함께 std::find함수 begin및 end반복자를 전달하고 결과 반복자를 벡터의 끝과 비교하여 일치하는지 여부를 확인합니다.

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

또한 이터레이터를 역 참조하여 다른 이터레이터와 마찬가지로 정상적으로 사용할 수 있습니다.

count도 사용할 수 있습니다. 벡터에있는 항목 수를 반환합니다.

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

벡터에서 문자열을 찾으려면 다음을 수행하십시오.

    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 ++ 연산자를 사용하는 다른 샘플.

#include <vector>
#include <algorithm>
#include <stdexcept>

template<typename T>
inline static bool operator ==(const std::vector<T>& v, const T& elem)
{
  return (std::find(v.begin(), v.end(), elem) != v.end());
}

template<typename T>
inline static bool operator !=(const std::vector<T>& 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_ID> 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 <typename T> bool IsInVector(T what, std::vector<T> * vec)
{
    if(std::find(vec->begin(),vec->end(),what)!=vec->end())
        return true;
    return false;
}

(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/search

나는 벡터 만 다루지 않고 여러 유형의 컨테이너를 한 번에 처리하기 위해 개인적으로 늦은 템플릿을 사용했습니다. 나는 온라인에서 비슷한 예를 찾았습니다 (어디를 기억하지 못합니까). 크레딧은 내가 이것을 인용 한 사람에게갑니다. 이 특정 패턴은 원시 배열도 처리하는 것으로 보입니다.

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

Newton C ++를 사용하면 직접 bool을 반환하기 때문에 std :: find보다 쉽고 자체 문서화되며 빠릅니다.

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