मानचित्र कुंजी के डुप्लिकेट स्टोरेज से बचें

Question

मान लें कि मेरे पास std::map<std::string, T> (या unordered_map) है और मैं सामग्री पर एक पुनरावर्तक/संदर्भ/सूचक से कुंजी का उपयोग करना चाहता हूं।

क्या std::string कुंजी (मानचित्र द्वारा स्वामित्व वाला एक, सामग्री ऑब्जेक्ट के अंदर एक) के दो प्रतियों के बिना ऐसा करने का कोई तरीका है? क्या कोई दूसरे का संदर्भ हो सकता है?

Answer 1

दोनों एक ही मूल्य का संदर्भ हो सकते हैं। उदाहरण के लिए:

#include <stdio.h> 
#include <string> 
#include <map> 

struct xx { std::string mykey; int value; }; 

int main (int argc, char **argv) 
{ 
    std::string      key1("the-key"); 
    std::map<std::string, xx>  map; 

    map[key1].mykey = key1; 
    map[key1].value = 13; 

    std::string &lookup_key = map[key1].mykey; 

    printf("%d\n", map[lookup_key].value); 
} 

Answer 2

क्यों आप दो वस्तुओं बना सकता हूँ नहीं:

std::set<std::string> wordSet; 
std::map<std::string*, T> yourMap; 

टी एसटीडी सूचक शामिल होना चाहिए :: स्ट्रिंग, और yourMap कस्टम तुलनित्र की जरूरत है। इसके अतिरिक्त आप इन सभी को कुछ कक्षा में लपेट सकते हैं।

Answer 3

क्या आप boost :: bimap का उपयोग करने पर विचार करेंगे? नीचे एक साधारण उदाहरण है:

#include <boost/bimap.hpp> 
#include <string> 
struct Person 
{ 
    Person() 
    {} 
    Person(const std::string& f, const std::string& l, int a) : first(f), last(l), age(a) 
    {} 
    std::string first; 
    std::string last; 
    int age; 
}; 

bool operator <(const Person& lhs, const Person& rhs) 
{ 
    if(lhs.last < rhs.last) 
     return true; 
    return false; 
} 

std::ostream& operator << (std::ostream& os, const Person& p) 
{ 
    os << "First Name: " << p.first << " Last Name: " << p.last << " Age: " << p.age; 
    return os; 
} 

int main() 
{ 
    typedef boost::bimap<std::string, Person> people; 
    typedef people::value_type value; 

    people m; 
    m.insert(value("12345",Person("fred", "rabbit", 10))); 
    m.insert(value("67890",Person("benjamin", "bunny", 12))); 

    Person p = m.left.at("12345"); 
    std::cout << "Person with serial no. 12345 is: " << p << "\n"; 
    std::cout << "Serial number of " << p << " is: " << m.right.at(p) << "\n"; 

} 

Answer 4

कारण यह कठिन बना क्योंकि यह खतरनाक है। आपको गारंटी है कि std::string सदस्यों में से कोई भी कुंजी बंद नहीं होगा, कभी भी मूल्य नहीं बदलेगा, या पूरा नक्शा अवैध हो जाएगा। दिलचस्प, दिमाग में आने वाला पहला समाधान बेहद हैकिश दिखाई देता है, और यूबी की तरह दिखता है, लेकिन मेरा मानना ​​है कि मैं बहुत सावधानी से यूबी को स्कर्ट करता हूं।

struct key_type { 
    mutable const char* ptr;  
}; 
bool operator<(const key_type& lhs, const key_type& rhs) 
{return strcmp(lhs.ptr, rhs.ptr)<0;} 

struct person { 
    std::string name; 
    int age; 
}; 
person& people_map_get(std::map<key_type, person>& map, const char* name) { 
    auto it = map.insert(name, person{name}).first; //grab, possibly insert 
    if->first.ptr = it->second.name.c_str(); //in case of insert, fix ptr 
    return it->second; 
} 
person& people_map_assign(std::map<key_type, person>& map, person p) { 
    auto pair = map.insert(name, p); //grab, possibly insert 
    auto it = pair.first;  
    if (pair.second == false) 
     it->second = std::move(p); 
    if->first.ptr = it->second.name.c_str(); //ptr probably invalidated, so update it 
    return it->second; 
} 

int main() { 
    std::map<key_type, person> people; 
    people_map_assign(people, person{"ted"}); 
    person frank = people_map_get(people, "frank"); 
} 

मुझे आशा है कि के रूप में स्पष्ट है, इस पागल यूबी के करीब है, और बहुत ज्यादा की सलाह नहीं दी। असल में, एक डालने/खोजने के दौरान, आपके अस्थायी ऑब्जेक्ट या इनपुट स्ट्रिंग पर मुख्य बिंदु, और जैसे ही ऑब्जेक्ट डाला/पाया जाता है, कुंजी स्ट्रिंग सदस्य में निहित मान पर इंगित होती है, और जब तक आप कभी भी ऐसा कुछ भी नहीं करते हैं जो किसी भी person ऑब्जेक्ट पर .c_str() के वापसी मूल्य को अमान्य कर देगा, सबकुछ बस मुश्किल से काम करता है। मुझे लगता है।