सी ++ पॉइंटर्स का ऐरे: हटाएं या हटाएं []?

Question

निम्नलिखित कोड कोसाइडर करें:

class Foo 
{ 
    Monster* monsters[6]; 

    Foo() 
    { 
     for (int i = 0; i < 6; i++) 
     { 
      monsters[i] = new Monster(); 
     } 
    } 

    virtual ~Foo(); 
} 

सही विनाशक क्या है?

यह:

Foo::~Foo() 
{ 
    delete [] monsters; 
} 

या यह:

Foo::~Foo() 
{ 
    for (int i = 0; i < 6; i++) 
    { 
     delete monsters[i]; 
    } 
} 

वर्तमान में मेरे पास सबसे ऊपर का कन्स्ट्रक्टर है और सबकुछ ओकी काम कर रहा है, लेकिन निश्चित रूप से मैं नहीं देख सकता कि यह लीक होने वाला होता है ...

व्यक्तिगत रूप से, मुझे लगता है कि दूसरा संस्करण जो कुछ भी कर रहा हूं, उसके बारे में अधिक तर्कसंगत है। वैसे भी, ऐसा करने के लिए "उचित" तरीका क्या है?

Answer 1

delete[] monsters;

गलत है, यह है संकेत की एक सरणी। वर्ग के उदाहरण के रूप में जब कक्षा का उदाहरण नष्ट हो जाता है तो यह स्वचालित रूप से नष्ट हो जाएगा।

आपका अन्य कार्यान्वयन सही है क्योंकि सरणी में पॉइंटर्स गतिशील रूप से आवंटित Monster ऑब्जेक्ट्स को इंगित करते हैं।

ध्यान दें कि आपकी वर्तमान मेमोरी आवंटन रणनीति के साथ आप शायद अपनी खुद की प्रतिलिपि कन्स्ट्रक्टर और कॉपी-असाइनमेंट ऑपरेटर घोषित करना चाहते हैं ताकि अनजाने प्रतिलिपि डबल डिलीट न हो। (यदि आप प्रतिलिपि को रोकना चाहते हैं तो आप उन्हें निजी घोषित कर सकते हैं और वास्तव में उन्हें लागू नहीं कर सकते हैं।)

Answer 2

आपका दूसरा उदाहरण सही है; आपको monsters सरणी को ही हटाने की आवश्यकता नहीं है, केवल आपके द्वारा बनाई गई व्यक्तिगत वस्तुएं।

Answer 3

new के लिए आपको delete का उपयोग करना चाहिए। new[] के लिए delete[] का उपयोग करें। आपका दूसरा संस्करण सही है।

Answer 4

दूसरा परिस्थितियों में ठीक है (ठीक है, कम से कम गलत, वैसे भी)।

संपादित करें: "कम से कम गलत", मूल कोड में के रूप में पहली जगह में new या delete उपयोग करने के लिए कोई अच्छा कारण पता चलता है, तो आप शायद सिर्फ उपयोग करना चाहिए:

std::vector<Monster> monsters; 

परिणाम सरल हो जाएगा जिम्मेदारियों के कोड और क्लीनर अलगाव।

Answer 5

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

Answer 6

delete[] monsters निश्चित रूप से गलत है। मेरे ढेर डिबगर निम्नलिखित उत्पादन पता चलता है:

allocated non-array memory at 0x3e38f0 (20 bytes) 
allocated non-array memory at 0x3e3920 (20 bytes) 
allocated non-array memory at 0x3e3950 (20 bytes) 
allocated non-array memory at 0x3e3980 (20 bytes) 
allocated non-array memory at 0x3e39b0 (20 bytes) 
allocated non-array memory at 0x3e39e0 (20 bytes) 
releasing  array memory at 0x22ff38 

आप देख सकते हैं, आप हटाना (गैर सरणी बनाम सरणी) का गलत फार्म के साथ रिलीज करने के लिए कोशिश कर रहे हैं, और सूचक है 0x22ff38 कभी नहीं एक से लौटा दिया गया नए को बुलाओवैसे भी

[allocations omitted for brevity] 
releasing non-array memory at 0x3e38f0 
releasing non-array memory at 0x3e3920 
releasing non-array memory at 0x3e3950 
releasing non-array memory at 0x3e3980 
releasing non-array memory at 0x3e39b0 
releasing non-array memory at 0x3e39e0 

, मैं एक डिजाइन जहां मैन्युअल नाशक को लागू करने के साथ शुरू करने के लिए आवश्यक नहीं है पसंद करते हैं: दूसरे संस्करण सही उत्पादन को दर्शाता है।

#include <array> 
#include <memory> 

class Foo 
{ 
    std::array<std::shared_ptr<Monster>, 6> monsters; 

    Foo() 
    { 
     for (int i = 0; i < 6; ++i) 
     { 
      monsters[i].reset(new Monster()); 
     } 
    } 

    virtual ~Foo() 
    { 
     // nothing to do manually 
    } 
}; 

Answer 7

यह Sens होगा अगर अपने कोड इस तरह था:

#include <iostream> 

using namespace std; 

class Monster 
{ 
public: 
     Monster() { cout << "Monster!" << endl; } 
     virtual ~Monster() { cout << "Monster Died" << endl; } 
}; 

int main(int argc, const char* argv[]) 
{ 
     Monster *mon = new Monster[6]; 

     delete [] mon; 

     return 0; 
} 

Answer 8

आसान बनाने के लिए answare के निम्नलिखित कोड पर नजर डालते हैं:

#include "stdafx.h" 
#include <iostream> 
using namespace std; 

class A 
{ 
private: 
    int m_id; 
    static int count; 
public: 
    A() {count++; m_id = count;} 
    A(int id) { m_id = id; } 
    ~A() {cout<< "Destructor A " <<m_id<<endl; } 
}; 

int A::count = 0; 

void f1() 
{ 
    A* arr = new A[10]; 
    //delete operate only one constructor, and crash! 
    delete arr; 
    //delete[] arr; 
} 

int main() 
{ 
    f1(); 
    system("PAUSE"); 
    return 0; 
} 

उत्पादन होता है: नाशक एक 1 और फिर यह क्रैश हो रहा है (अभिव्यक्ति: _BLOCK_TYPE_IS_VALID (phead-nBlockUse))।

हमें उपयोग करने की आवश्यकता है: हटाएं [] arr; क्योंकि यह पूरी सरणी को हटा देता है और सिर्फ एक सेल नहीं!

हटाएं [] arr का उपयोग करने का प्रयास करें; उत्पादन होता है: नाशक एक 10 नाशक एक 9 नाशक एक 8 नाशक एक 7 नाशक एक 6 नाशक एक 5 नाशक एक 4 नाशक एक 3 नाशक एक 2 नाशक एक 1

ही सिद्धांत पॉइंटर्स की एक सरणी के लिए है:

void f2() 
{ 
    A** arr = new A*[10]; 
    for(int i = 0; i < 10; i++) 
    { 
     arr[i] = new A(i); 
    } 
    for(int i = 0; i < 10; i++) 
    { 
     delete arr[i];//delete the A object allocations. 
    } 

    delete[] arr;//delete the array of pointers 
} 

अगर हम हटाए जाने के बजाय हटाए गए एआर का उपयोग करेंगे [] arr। यह सरणी => पॉइंटर ऑब्जेक्ट्स की स्मृति रिसाव में पूरे पॉइंटर्स को मिटा नहीं देगा!