c++ - यह कैसे पता चलेगा कि सी ++ std :: नक्शा में दी गई कुंजी मौजूद है


मैं यह जांचने की कोशिश कर रहा हूं कि क्या दी गई कुंजी मैप में है और कुछ ऐसा नहीं कर सकती है:

typedef map<string,string>::iterator mi;
map<string, string> m;
m.insert(make_pair("f","++--"));
pair<mi,mi> p = m.equal_range("f");//I'm not sure if equal_range does what I want
cout << p.first;//I'm getting error here

तो मैं कैसे पी में है मुद्रित कर सकते हैं?



Answers



map::find प्रयोग map::find

if ( m.find("f") == m.end() ) {
  // not found
} else {
  // found
}



यह देखने के लिए कि क्या मानचित्र में कोई विशेष कुंजी मौजूद है, count सदस्य फ़ंक्शन का निम्नलिखित तरीकों में से एक में उपयोग करें:

m.count(key) > 0
m.count(key) == 1
m.count(key) != 0

map::find दस्तावेज के लिए दस्तावेज कहते हैं: "किसी अन्य सदस्य फ़ंक्शन, map::count इस्तेमाल सिर्फ जांच कर सकते हैं कि कोई विशेष कुंजी मौजूद है या नहीं।"

map::count दस्तावेज के लिए प्रलेखन कहते हैं: "क्योंकि नक्शा कंटेनर के सभी तत्व अद्वितीय हैं, यह फ़ंक्शन केवल 1 (यदि तत्व मिल गया है) या शून्य (अन्यथा) लौटा सकता है।"

किसी कुंजी के माध्यम से मान से प्राप्त करने के लिए जो आप मौजूद हैं, मैप का प्रयोग करें: at :

value = m.at(key)

मैप के विपरीत : ऑपरेटर [] , map::at एक नई कुंजी नहीं बनाई जाएगी यदि निर्दिष्ट कुंजी मौजूद नहीं है।




आप। .find() उपयोग कर सकते हैं:

map<string,string>::iterator i = m.find("f");

if (i == m.end()) { /* Not found */ }
else { /* Found, i->first is f, i->second is ++-- */ }



m.find == m.end() // not found 

यदि आप अन्य एपीआई का उपयोग करना चाहते हैं, तो m.count(c)>0

 if (m.count("f")>0)
      cout << " is an element of m.\n";
    else 
      cout << " is not an element of m.\n";



मुझे लगता है कि आप map::find चाहते हैं map::find यदि m.find("f") m.end() बराबर है, तो कुंजी नहीं मिली थी। अन्यथा, पाया तत्व पर इंगित एक इरेटरेटर रिटर्न मिलता है।

त्रुटि इसलिए है क्योंकि p.first एक इटरेटर है, जो स्ट्रीम प्रविष्टि के लिए काम नहीं करता है। अपनी अंतिम पंक्ति को cout << (p.first)->first;p iterators की एक जोड़ी है, p.first एक iterator है, p.first->first कुंजी स्ट्रिंग है

किसी नक्शा में केवल एक दिए गए कुंजी के लिए एक तत्व हो equal_range है, इसलिए equal_range बहुत उपयोगी नहीं है। इसे मानचित्र के लिए परिभाषित किया गया है, क्योंकि यह सभी एसोसिएटिव कंटेनरों के लिए परिभाषित है, लेकिन multimap के लिए यह बहुत दिलचस्प है।




नक्शे 'एम' की तरह समाप्त होने वाले परिणामों की तुलना करने में सावधान रहें क्योंकि सभी उत्तर मैप के ऊपर किया है: iterator i = m.find ("f");

 if (i == m.end())
 {
 }
 else
 {
 }  

आप किसी भी ऑपरेशन की कोशिश नहीं करनी चाहिए जैसे कि कुंजी या मूल्य को इटरेटर I के साथ छपाई करना, अगर इसकी m.end () के बराबर होता है और इससे विभाजन की गलती हो जाएगी




map<string, string> m;

जाँच कुंजी मौजूद है या नहीं, और वापसी की संख्या होती है (0/1 मानचित्र में):

int num = m.count("f");  
if (num>0) {    
    //found   
} else {  
    // not found  
}

चेक कुंजी मौजूद है या नहीं, और इटरेटर लौट रहा है:

map<string,string>::iterator mi = m.find("f");  
if(mi != m.end()) {  
    //found  
    //do something to mi.  
} else {  
    // not found  
}  

आपके प्रश्न में, खराब operator<< अधिभार के कारण हुई त्रुटि, क्योंकि p.first का map<string, string> , आप इसे प्रिंट नहीं कर सकते। इसे इस्तेमाल करे:

if(p.first != p.second) {
    cout << p.first->first << " " << p.first->second << endl;
}



template <typename T, typename Key>
bool key_exists(const T& container, const Key& key)
{
    return (container.find(key) != std::end(container));
}

बेशक, यदि आप चाहते हैं कि आप एक फंतासी प्राप्त करना चाहते हैं, तो आप फ़ंक्शन को हमेशा टेम्प्लेट कर सकते हैं, जो किसी फ़ंक्शन को भी मिला और फ़ंक्शन नहीं मिला, ऐसा कुछ:

template <typename T, typename Key, typename FoundFunction, typename NotFoundFunction>
void find_and_execute(const T& container, const Key& key, FoundFunction found_function, NotFoundFunction not_found_function)
{
    auto& it = container.find(key);
    if (it != std::end(container))
    {
        found_function(key, it->second);
    }
    else
    {
        not_found_function(key);
    }
}

और इसे इस तरह प्रयोग करें:

    std::map<int, int> some_map;
    find_and_execute(some_map, 1,
        [](int key, int value){ std::cout << "key " << key << " found, value: " << value << std::endl; },
        [](int key){ std::cout << "key " << key << " not found" << std::endl; });

इसका नकारात्मक पक्ष एक अच्छा नाम के साथ आ रहा है, "find_and_execute" अजीब है और मैं अपने सिर के शीर्ष से बेहतर कुछ भी नहीं कर सकता ...




Std :: map :: find and std :: map :: count का कोड की तुलना करना, मैं कह सकता हूँ कि पहले कुछ प्रदर्शन लाभ प्राप्त कर सकता है:

const_iterator find(const key_type& _Keyval) const
    {   // find an element in nonmutable sequence that matches _Keyval
    const_iterator _Where = lower_bound(_Keyval); // Here one looks only for lower bound
    return (_Where == end()
        || _DEBUG_LT_PRED(this->_Getcomp(),
            _Keyval, this->_Key(_Where._Mynode()))
                ? end() : _Where);
    }

size_type count(const key_type& _Keyval) const
    {   // count all elements that match _Keyval
    _Paircc _Ans = equal_range(_Keyval); // Here both lower and upper bounds are to be found, which is presumably slower.
    size_type _Num = 0;
    _Distance(_Ans.first, _Ans.second, _Num);
    return (_Num);
    }



यदि आप मानचित्र की जोड़ी की तुलना करना चाहते हैं तो आप इस विधि का उपयोग कर सकते हैं:

typedef map<double, double> TestMap;
TestMap testMap;
pair<map<double,double>::iterator,bool> controlMapValues;

controlMapValues= testMap.insert(std::pair<double,double>(x,y));
if (controlMapValues.second == false )
{
    TestMap::iterator it;
    it = testMap.find(x);

    if (it->second == y)
    {
        cout<<"Given value is already exist in Map"<<endl;
    }
}

यह एक उपयोगी तकनीक है