पॉइंटर्स की एक एसटीएल सूची/वेक्टर की सफाई

Question

सी ++ का सबसे छोटा हिस्सा क्या है जो आप वेक्टर या पॉइंटर्स की सूची को सुरक्षित रूप से साफ करने के लिए आ सकते हैं? (यह मानते हुए आप कॉल करने के लिए संकेत पर हटाना चाहते हैं?)

list<Foo*> foo_list; 

मैं नहीं बल्कि बूस्ट का उपयोग या स्मार्ट संकेत के साथ अपने संकेत रैप नहीं चाहते हैं।

Answer 1

के बाद से हम यहाँ चुनौती नीचे फेंक रहे हैं ... "सी की सबसे छोटा हिस्सा ++"

static bool deleteAll(Foo * theElement) { delete theElement; return true; } 

foo_list . remove_if (deleteAll); 

मुझे लगता है कि हम लोग कुशल एल्गोरिदम के लिए एसटीएल के साथ आया था भरोसा कर सकते हैं। पहिया को फिर से क्यों शुरू करें?

Answer 2

template< typename T > 
struct delete_ptr : public std::unary_function<T,bool> 
{ 
    bool operator()(T*pT) const { delete pT; return true; } 
}; 

std::for_each(foo_list.begin(), foo_list.end(), delete_ptr<Foo>()); 

Answer 3

for(list<Foo*>::const_iterator it = foo_list.begin(); it != foo_list.end(); ++it) 
{ 
    delete *it; 
} 
foo_list.clear(); 

Answer 4

मुझे यकीन है कि functor दृष्टिकोण यहाँ संक्षिप्तता के लिए जीत नहीं हूँ।

for(list<Foo*>::iterator i = foo_list.begin(); i != foo_list.end(); ++i) 
    delete *i; 

मैं आमतौर पर इसके खिलाफ सलाह देता हूं, हालांकि। स्मार्ट पॉइंटर्स में पॉइंटर्स को लपेटना या एक विशेषज्ञ सूचक कंटेनर का उपयोग करना, सामान्य रूप से, अधिक मजबूत होने जा रहा है। सूची से वस्तुओं को हटाया जा सकता है (erase, clear के विभिन्न स्वाद, सूची का विनाश, सूची में एक पुनरावर्तक के माध्यम से असाइनमेंट इत्यादि)। क्या आप उन्हें पकड़ने की गारंटी दे सकते हैं?

Answer 5

for (list<Foo*>::const_iterator i = foo_list.begin(), e = foo_list.end(); i != e; ++i) 
    delete *i; 
foo_list.clear(); 

Answer 6

std::list<T*> उपयोग के लिए:

while(!foo.empty()) delete foo.front(), foo.pop_front(); 

std::vector<T*> उपयोग के लिए:

while(!bar.empty()) delete bar.back(), bar.pop_back(); 

सुनिश्चित नहीं हैं कि मैं क्यों ऊपर std::list के लिए front बजाय back ले लिया। मुझे लगता है कि यह महसूस कर रहा है कि यह तेज़ है। लेकिन वास्तव में दोनों स्थिर समय हैं :)। वैसे भी एक समारोह में लपेट और मजा:

template<typename Container> 
void delete_them(Container& c) { while(!c.empty()) delete c.back(), c.pop_back(); } 

Answer 7

यह वास्तव में कंटेनर के बाहर कोड पर भरोसा करने के लिए अपने संकेत से हटाने के लिए खतरनाक है। क्या होता है जब एक अपवाद के कारण कंटेनर नष्ट हो जाता है, उदाहरण के लिए?

मुझे पता है कि आपने कहा था कि आपको बढ़ावा पसंद नहीं है, लेकिन कृपया boost pointer containers पर विचार करें।

Answer 8

कम से कम एक सूची के लिए, पुनरावृत्त और हटाना, फिर अंत में स्पष्ट कॉल करना थोड़ा अनावश्यक है क्योंकि इसमें सूची को दो बार घुमाने में शामिल है, जब आपको वास्तव में केवल एक बार ऐसा करना होता है। यहाँ थोड़ा बेहतर तरीका है:

for (list<Foo*>::iterator i = foo_list.begin(), e = foo_list.end(); i != e;) 
{ 
    list<Foo*>::iterator tmp(i++); 
    delete *tmp; 
    foo_list.erase(tmp); 
} 

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

Answer 9

दरअसल, मेरा मानना ​​है कि एसटीडी पुस्तकालय allocator class

के रूप में स्मृति प्रबंध आप स्वचालित रूप से किसी भी कंटेनर के सदस्यों को हटाने के लिए बुनियादी संभाजक के पुनःआवंटन() विधि विस्तार कर सकते हैं का एक सीधा तरीका प्रदान करता है।

मैं/सोचता हूं/यह उस चीज का प्रकार है जिसका उद्देश्य यह है।

Answer 10

निम्नलिखित हैक पॉइंटर्स को हटा देता है जब आपकी सूची RAII का उपयोग करके दायरे से बाहर हो जाती है या यदि आप सूची :: clear() कहते हैं।

template <typename T> 
class Deleter { 
public: 
    Deleter(T* pointer) : pointer_(pointer) { } 
    Deleter(const Deleter& deleter) { 
    Deleter* d = const_cast<Deleter*>(&deleter); 
    pointer_ = d->pointer_; 
    d->pointer_ = 0; 
    } 
    ~Deleter() { delete pointer_; } 
    T* pointer_; 
}; 

उदाहरण:

std::list<Deleter<Foo> > foo_list; 
foo_list.push_back(new Foo()); 
foo_list.clear(); 

Answer 11

void remove(Foo* foo) { delete foo; } 
.... 
for_each(foo_list.begin(), foo_list.end(), remove); 

Answer 12

आप सी ++ 11 के लिए अनुमति देते हैं, तो आप डगलस Leeder के जवाब का एक बहुत ही लघु संस्करण कर सकते हैं:

for(auto &it:foo_list) delete it; foo_list.clear(); 

Answer 13

for(list<Foo*>::const_iterator it = foo_list.begin(); it != foo_list.end(); it++) 
{ 
    delete *it; 
} 
foo_list.clear(); 

नहीं है एक छोटा कारण यह है कि आप ऐसा क्यों नहीं करना चाहते हैं - आप प्रभावी ढंग से फिर से चल रहे हैं सूची दो बार।

std :: सूची <> :: स्पष्टता जटिलता में रैखिक है; यह एक लूप के भीतर एक समय में एक तत्व को हटा देता है और नष्ट कर देता है।

विचार सरलतम में ऊपर ले रहा है मेरी राय में समाधान को पढ़ने के लिए है:

while(!foo_list.empty()) 
{ 
    delete foo_list.front(); 
    foo_list.pop_front(); 
} 

Answer 14

के बाद से सी ++ 11:

std::vector<Type*> v; 
... 
std::for_each(v.begin(), v.end(), std::default_delete<Type>()); 

या, यदि आप टेम्प्लेटेड कोड लिखने और करना चाहते हैं एक ठोस प्रकार को निर्दिष्ट से बचने:

std::for_each(v.begin(), v.end(), 
    std::default_delete<std::remove_pointer<decltype(v)::value_type>::type>()); 

कौन सा (के बाद से सी ++ 14) के रूप में छोटा किया जा सकता:

std::for_each(v.begin(), v.end(), 
    std::default_delete<std::remove_pointer_t<decltype(v)::value_type>>());