c++ एक std:: वेक्टर में कोई आइटम मौजूद है या नहीं?




vector (14)

बढ़ावा के साथ आप any_of_equal उपयोग कर सकते हैं:

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

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

मैं बस यह देखना चाहता हूं कि वेक्टर में कोई तत्व मौजूद है या नहीं, इसलिए मैं प्रत्येक मामले से निपट सकता हूं।

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

सी ++ ऑपरेटरों का उपयोग कर एक और नमूना।

#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!");
  }
}

मैं इस तरह कुछ उपयोग करता हूँ ...

#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

... इस तरह यह वास्तव में स्पष्ट और पठनीय है। (जाहिर है आप टेम्पलेट को कई स्थानों पर पुन: उपयोग कर सकते हैं)।


आप <algorithm> से std::find उपयोग कर सकते हैं:

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

यह एक बूल देता है (यदि मौजूद true तो true , अन्यथा false )। आपके उदाहरण के साथ:

#include <algorithm>

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

ध्यान रखें कि, यदि आप बहुत सारे लुकअप करने जा रहे हैं, तो एसटीएल कंटेनर हैं जो इसके लिए बेहतर हैं। मुझे नहीं पता कि आपका आवेदन क्या है, लेकिन एसडीडी :: मानचित्र जैसे सहयोगी कंटेनर विचार करने लायक हो सकते हैं।

std :: वेक्टर पसंद का कंटेनर है जब तक कि आपके पास कोई अन्य कारण न हो, और मूल्य के आधार पर लुकअप ऐसा कारण हो सकता है।


जैसा कि अन्य ने कहा है, एसटीएल std::find या std::find कार्यों का उपयोग करें। लेकिन यदि आप बहुत बड़े वैक्टर में खोज रहे हैं और यह प्रदर्शन को प्रभावित करता है, तो आप अपने वेक्टर को सॉर्ट करना चाहेंगे और फिर binary_search , lower_bound , या lower_bound एल्गोरिदम का उपयोग कर सकते हैं।


एसटीएल find समारोह का प्रयोग करें।

ध्यान रखें कि एक find_if फ़ंक्शन भी है, जिसका उपयोग आप कर सकते हैं यदि आपकी खोज अधिक जटिल है, यानी यदि आप केवल तत्व की तलाश नहीं कर रहे हैं, लेकिन, उदाहरण के लिए, देखना चाहते हैं कि कोई तत्व है जो निश्चित करता है शर्त, उदाहरण के लिए, एक स्ट्रिंग जो "एबीसी" से शुरू होती है। ( find_if आपको एक find_if देगा जो पहले ऐसे तत्व को इंगित करता है)।


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

न्यूटन सी ++ का उपयोग करना आसान है, स्वयं-दस्तावेज और std :: के मुकाबले तेज है, क्योंकि सीधे एक बूल लौटाता है।

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

आप इस कोड को आजमा सकते हैं:

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

सी ++ 11 में आप any_of उपयोग कर सकते हैं। उदाहरण के लिए यदि यह एक vector<string> v; फिर:

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

आप std namespace, यानी std::find में पाए गए find फ़ंक्शन का उपयोग कर सकते std::find । आप std::find फ़ंक्शन को उस वेक्टर से begin और end इटरेटर को पास करते हैं, जिसे आप खोजना चाहते हैं, जिस तत्व को आप ढूंढ रहे हैं उसके साथ वे परिणामस्वरूप इटरेटर को वेक्टर के अंत तक तुलना करें ताकि वे यह देख सकें कि वे मेल खाते हैं या नहीं।

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

आप इसे पुनरावर्तक करने में भी सक्षम हैं और इसे किसी अन्य इटरेटर की तरह सामान्य के रूप में उपयोग करते हैं।


आप भी गिनती का उपयोग कर सकते हैं। यह एक वेक्टर में मौजूद वस्तुओं की संख्या वापस कर देगा।

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




std