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




vector (12)

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

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

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

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

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

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

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

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

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


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

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


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

#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

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


यदि आप वेक्टर में स्ट्रिंग ढूंढना चाहते हैं:

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

यहां एक ऐसा फ़ंक्शन है जो किसी भी कंटेनर के लिए काम करेगा:

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 की आवश्यकता है क्योंकि Container::value_type एक आश्रित नाम है


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

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

न्यूटन सी ++ का उपयोग करना आसान है, स्वयं-दस्तावेज और 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();

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




std