डुप्लिकेट जोड़े से कैसे बचें/मल्टीमैप में एक जोड़ी ढूंढें?

Question

मेरे पास कुछ (काम करने वाला) कोड है जो multimap<string,string> का उपयोग करता है। मैं इसे एक ही कुंजी पर डुप्लिकेट मानों को अस्वीकार करने के लिए बदलना चाहता हूं (स्पष्ट रूप से एक ही कुंजी पर अलग-अलग मान ठीक हैं, अन्यथा मैं एक मल्टीमैप का उपयोग नहीं करता)।

आश्चर्यजनक रूप से प्रकार seem नहीं है ताकि डुप्लीकेट से बचने के लिए अंतर्निहित तरीका न हो और न ही एक कुंजी-मूल्य जोड़ी (केवल एक कुंजी ढूंढने के लिए)। लेकिन मुझे लगता है कि एसओ पर किसी को तैयार किए गए कामकाज के लिए होना चाहिए। किसी को?

Answer 1

यहाँ मैं के साथ आया है।)

Answer 2

मेरा सुझाव आपको कक्षा में अपने मल्टीमैप को लपेटना होगा और उस विधि में सत्यापन करना होगा जहां आप मानचित्र में कुछ जोड़ते हैं। शेष कार्य बस मल्टीमैप के तरीकों से गुज़रेंगे। यह बहुत सारे बॉयलर प्लेट कोड बनाता है लेकिन यदि आपको कभी भी अन्य प्रकार की सत्यापन करने की आवश्यकता है तो यह इस तरह से आसान होगा।

Answer 3

ऐसा लगता है कि

 std::set<std::pair<std::string,std::string>>> 

बिल्कुल गुण आप देख रहे हैं होगा।

हालांकि यह नक्शा और न ही मल्टीमैप है। आप मल्टीमैप और कुंजी, वैल्यू जोड़े दोनों सेट रख सकते हैं या केवल स्थिरता की जांच के लिए इस सेट को बना सकते हैं।

मैं इस सेट का उपयोग करता हूं और इंटरफ़ेस को मल्टीमैप करने के लिए इसे एडाप्टर बना देता हूं। शायद यह लागू करने का सबसे आसान समाधान नहीं है, लेकिन सर्वोत्तम प्रदर्शन दक्षता के साथ।

संदर्भों के लिए "एडाप्टर डिज़ाइन पैटर्न" प्रश्न देखें।

---

[अद्यतन]

देखें मेरी working example एक प्रारंभ बिंदु के रूप।

उदा। कुंजी के लिए सभी मूल्यों पर पुनरावृति करने के लिए कैसे - देखें:

typedef std::set<std::pair<std::string, std::string> > ssset; 

ssset::iterator get_key(ssset& s, std::string key) 
{ 
    ssset::iterator it = s.lower_bound(std::make_pair(key, "")); 
    if (it != s.end() && it->first == key) return it; 
    return s.end(); 
} 

for (ssset::iterator it = get_key(s, "abc"); it != s.end() && it->first == "abc"; ++it) 
    std::cout << it->first << "->" << it->second << std::endl; 

Answer 4

std::map<std::string, std::set<std::string>> के लिए exactamondo गुण आप के लिए (हालांकि अवर जटिलता unordered_map करने और unordered_set) देख रहे हैं प्रदर्शित होगी। (यह कुशल है जब वहाँ एक एकल कुंजी से जुड़ी मूल्यों की एक बड़ी संख्या है नहीं है, लेकिन मेरे मामले में प्रत्येक कुंजी पर बहुत कुछ मान देखते हैं

template<class K, class V> 
typename multimap<K, V>::const_iterator find_pair(const multimap<K, V>& map, const pair<K, V>& pair) 
{ 
    typedef multimap<K, V>::const_iterator it; 
    std::pair<it,it> range = map.equal_range(pair.first); 
    for (it p = range.first; p != range.second; ++p) 
     if (p->second == pair.second) 
      return p; 
    return map.end(); 
} 
template<class K, class V> 
bool insert_if_not_present(multimap<K, V>& map, const pair<K, V>& pair) 
{ 
    if (find_pair(map, pair) == map.end()) { 
     map.insert(pair); 
     return true; 
    } 
    return false; 
} 

: