मानचित्र सामग्री कैसे प्रदर्शित करें?

Question

मैं एक नक्शा है

map < string , list <string> > mapex ; list<string> li; 

कैसे कंसोल पर ऊपर नक्शा आइटम प्रदर्शित करने के लिए।

Answer 1

खैर यह आप उन्हें कैसे प्रदर्शित करना चाहते हैं पर निर्भर करता है, लेकिन आप हमेशा उन्हें आसानी से पुनरावृति कर सकते हैं:

typedef map<string, list<string>>::const_iterator MapIterator; 
for (MapIterator iter = mapex.begin(); iter != mapex.end(); iter++) 
{ 
    cout << "Key: " << iter->first << endl << "Values:" << endl; 
    typedef list<string>::const_iterator ListIterator; 
    for (ListIterator list_iter = iter->second.begin(); list_iter != iter->second.end(); list_iter++) 
     cout << " " << *list_iter << endl; 
} 

Answer 2

मैं कोशिश करता हूँ निम्नलिखित

void dump_list(const std::list<string>& l) { 
    for (std::list<string>::const_iterator it = l.begin(); l != l.end(); l++) { 
    cout << *l << endl; 
    } 
} 

void dump_map(const std::map<string, std::list<string>>& map) { 
    for (std::map<string,std::list<string>>::const_iterator it = map.begin(); it != map.end(); it++) { 
    cout << "Key: " << it->first << endl; 
    cout << "Values" << endl; 
    dump_list(it->second); 
} 

Answer 3

मैं एक छोटे से बंद विषय हूँ यहां ...

मुझे लगता है कि आप डिबगिंग के लिए मानचित्र सामग्री को डंप करना चाहते हैं। मुझे यह उल्लेख करना है कि अगली जीडीबी रिलीज (संस्करण 7.0) में पाइथन दुभाषिया में बनाया गया होगा जिसका उपयोग एसटीएल सुंदर प्रिंटर प्रदान करने के लिए जीसीसी libstdC++ द्वारा किया जाएगा। यहाँ अपने मामले

#include <map> 
    #include <map> 
    #include <list> 
    #include <string> 

    using namespace std; 

    int main() 
    { 
    typedef map<string, list<string> > map_type; 
    map_type mymap; 

    list<string> mylist; 
    mylist.push_back("item 1"); 
    mylist.push_back("item 2"); 
    mymap["foo"] = mylist; 
    mymap["bar"] = mylist; 

    return 0; // stopped here 
    } 

जो

(gdb) print mymap 
$1 = std::map with 2 elements = { 
    ["bar"] = std::list = { 
    [0] = "item 1", 
    [1] = "item 2" 
    }, 
    ["foo"] = std::list = { 
    [0] = "item 1", 
    [1] = "item 2" 
    } 
} 

Yay में जो परिणाम के लिए एक उदाहरण है!

Answer 4

दूसरा रूप, <algorithm> का उपयोग कर:

void printPair(const pair<string, list<string> > &p) 
{ 
    cout << "Key: " << p.first << endl; 
    copy(p.second.begin(), p.second.end(), ostream_iterator<string>(cout, "\n")); 
}  
for_each(mapex.begin(), mapex.end(), printPair); 

टेस्ट कार्यक्रम:

#include <iostream> 
#include <map> 
#include <list> 
#include <iterator> 
#include <algorithm> 
using namespace std; 

void printPair(const pair<string, list<string> > &p) 
{ 
    cout << "Key: " << p.first << endl; 
    copy(p.second.begin(), p.second.end(), ostream_iterator<string>(cout, "\n")); 
} 

int main() 
{ 
    map<string, list<string> > mapex; 

    list<string> mylist1; 
    mylist1.push_back("item 1"); 
    mylist1.push_back("item 2"); 
    mapex["foo"] = mylist1; 
    list<string> mylist2; 
    mylist2.push_back("item 3"); 
    mylist2.push_back("item 4"); 
    mylist2.push_back("item 5"); 
    mapex["bar"] = mylist2; 

    for_each(mapex.begin(), mapex.end(), printPair); 
} 

Answer 5

अद्यतन (भविष्य पर वापस): के साथ सी ++ 11 रेंज आधारित छोरों के लिए -

std::map<Key, Value> m { ... /* initialize it */ ... }; 

for (const auto &p : m) { 
    std::cout << "m[" << p.first << "] = " << p.second << '\n'; 
} 

Answer 6

आप एक सामान्य जेनेरिक ओवरलोडेड फ़ंक्शन लिख सकते हैं, जो दो उद्देश्यों के लिए अच्छा है:

1. यह किसी भी map के साथ काम करता है।
2. यह << का उपयोग करने की अनुमति देता है।

समारोह

template<class key_t, class value_t> 
ostream& operator<<(ostream& os, const map<key_t, value_t>& m) { 
    for (typename map<key_t, value_t>::const_iterator it = m.begin(); 
      it != m.end(); it++) { 
     os << "Key: " << it->first << ", Value: " << it->second; 
    } 
    return os; 
} 

cout << किसी भी map जिसके लिए << के लिए typename रों key_t और value_t परिभाषित किया गया है के साथ काम करेंगे है। आपके मामले में, यह value_t (= list<string>) के लिए परिभाषित नहीं है, इसलिए आपको इसे परिभाषित करना होगा। एक ऐसी ही भावना में, आप

template<class T> 
ostream& operator<<(ostream& os, const list<T>& l) { 
    for (typename list<T>::const_iterator it = l.begin(); it != l.end(); it++) { 
     os << "\"" << *it << "\", "; 
    } 
    return os; 
} 

तो उपयोग कर सकते हैं, आप कर सकते हैं:

1. इन दोनों कार्यों जोड़ें।
2. जहां आवश्यक हो प्रोटोटाइप जोड़ें।
3. using namespace std; का उपयोग करें (या आवश्यकतानुसार std:: जोड़ें)।
4. उपयोग करें, उदा।,
   cout << mapex << endl;
cout << li << endl;

याद रखें कि अगर वहाँ << रों सिर्फ परिभाषित के लिए किसी अन्य व्यवहार्य उम्मीदवार है (जो मैं ले वहाँ नहीं है, अन्यथा आप की संभावना यह सवाल पूछते नहीं होगा), यह पूर्वता समय लग सकता है वर्तमान में।