मैं एसटीएल मानचित्र में प्रत्येक मान को हटाने के लिए for_each का उपयोग कैसे करूं?

Question

मान लीजिए मेरे पास एक एसटीएल मानचित्र है जहां मान पॉइंटर्स हैं, और मैं उन्हें सभी को हटाना चाहता हूं। मैं निम्नलिखित कोड का प्रतिनिधित्व कैसे करूं, लेकिन std :: for_each का उपयोग कर रहा हूं? बूस्ट का उपयोग करने के लिए समाधान के लिए मैं खुश हूं।

for(stdext::hash_map<int, Foo *>::iterator ir = myMap.begin(); 
    ir != myMap.end(); 
    ++ir) 
{ 
    delete ir->second; // delete all the (Foo *) values. 
} 

(मैं बूस्ट के checked_delete पाया है, लेकिन मुझे यकीन है कि कैसे pair<int, Foo *> कि इटरेटर का प्रतिनिधित्व करता है कि लागू करने के लिए नहीं कर रहा हूँ)।

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

नोट: मैंने बाद में एक पंक्ति का उत्तर पाया और सूचीबद्ध किया है ... लेकिन कोड बहुत भयानक है इसलिए मैंने जीएमएन के स्वीयर जवाब को स्वीकार कर लिया है।

struct second_deleter 
{ 
    template <typename T> 
    void operator()(const T& pX) const 
    { 
     delete pX.second; 
    } 
}; 

std::for_each(myMap.begin(), myMap.end(), second_deleter()); 

आप को बढ़ावा देने का उपयोग कर रहे हैं, तो आप भी लैम्ब्डा पुस्तकालय इस्तेमाल कर सकते हैं:

Answer 1

आप एक समारोह वस्तु बनाना है

namespace bl = boost::lambda; 
std::for_each(myMap.begin(), myMap.end(), second_deleter(), 
       bl::bind(bl::delete_ptr(), 
       bl::bind(std::select2nd<myMap::value_type>(), _1)); 

लेकिन आप pointer containers पुस्तकालय की कोशिश हो सकता है यह स्वचालित रूप से करता है।

ध्यान दें कि आप मानचित्र का उपयोग नहीं कर रहे हैं, लेकिन hash_map। मैं आपको बूस्ट unordered_map पर स्विच करने की सलाह देता हूं, जो अधिक वर्तमान है। हालांकि, ptr_unordered_map प्रतीत नहीं होता है।

सुरक्षा के लिए, आपको यह चीज़ लपेटनी चाहिए। उदाहरण के लिए:

template <typename T, typename Deleter> 
struct wrapped_container 
{ 
    typedef T container_type; 
    typedef Deleter deleter_type; 

    wrapped_container(const T& pContainer) : 
    container(pContainer) 
    {} 

    ~wrapped_container(void) 
    { 
     std::for_each(container.begin(), container.end(), deleter_type()); 
    } 

    T container; 
}; 

और का उपयोग यह पसंद:

typedef wrapped_container< 
      boost::unordered_map<int, Foo*>, second_deleter> my_container; 

my_container.container./* ... */ 

यह कोई बात नहीं क्या, अपने कंटेनर एक Deleter साथ के माध्यम से दोहराया हो जाएगा सुनिश्चित करता है। (। अपवाद, उदाहरण के लिए के लिए)

की तुलना करें:

std::vector<int*> v; 
v.push_back(new int); 

throw "leaks!"; // nothing in vector is deleted 

wrapped_container<std::vector<int*> > v; 
v.container.push_back(new int); 

throw "no leaks!"; // wrapped_container destructs, deletes elements 

Answer 2

तो यह संभव है, यही कारण है कि आप स्मार्ट संकेत दिए गए अपने नक्शे में उपयोग नहीं करते हैं?

Answer 3

क्या आपने BOOST_FOREACH का उपयोग करने का प्रयास किया है? इससे आपको अपना खुद का मज़ेदार बनाये बिना लाइन में ऐसा करने की अनुमति मिलनी चाहिए।

मैं (यदि वास्तव में नहीं) निम्नलिखित कोड का परीक्षण किया है, लेकिन यह कुछ इस तरह दिखना चाहिए:

typedef stdext::hash_map<int, Foo *> MyMapType; //see comment. 
BOOST_FOREACH(MyMapType::value_type& p, myMap) 
{ 
    delete p.second; 
} 

खैर 1 से अधिक लाइन thats, typedef :) ठीक की वजह से

Answer 4

, मैंने पाया कि इसे एक पंक्ति में कैसे करना है ... लेकिन मुझे नहीं लगता कि मैं वास्तव में असली कोड में निम्नलिखित करता हूं!

std::for_each(mayMap.begin() 
      , myMap.end() 
      , boost::bind(&boost::checked_delete<Foo> 
          , boost::bind(&stdext::hash_map<int, Foo *>::value_type::second, _1))); 

हालांकि मैं क्योंकि मैं एक लिपटे कंटेनर के अपने विचार हैं, और मेरे जवाब की तरह, के रूप में अनुरोध एक लाइन होने के बावजूद GMAN के जवाब को स्वीकार करने के लिए जा रहा हूँ, बस सादा बुरा है।