सी ++: नाशक से पहले यह क्षेत्र से बाहर जाना चाहिए बुलाया जा रहा है?

Question

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

#include <iostream> 
using namespace std; 

class Foo { 
private: 

    double *array; 

public: 

Foo(int N) { 
    array = new double[N]; 
    for (int i=0; i<N; i++) { 
     array[i]=0; 
    } 
} 

~Foo() { 
    delete[] array; 
} 
}; 

void subroutine(Foo x) { 
    cout << "Hello!" << endl; 
} 

int main() { 
    Foo bar(10); 
    subroutine(bar); 
    subroutine(bar); 
} 

अब वस्तु बार यहाँ पहली सबरूटीन के बाद कहा जाता हो जाता है के लिए नाशक खत्म भले ही यह गुंजाइश की पूरी होना चाहिए:

यहाँ कि मेरी समस्या को प्रदर्शित करता है कोड मैं सबसे छोटी टुकड़ा है मुख्य कार्य? इसका मतलब यह है कि जब मैं दूसरा सबराउटिन कहता हूं तो विनाशक को फिर से बुलाया जाता है और मुझे स्मृति रिसाव मिलती है।

मैं पाया है मैं सबरूटीन में संदर्भ द्वारा फोन करके इसे ठीक कर सकते हैं, लेकिन मैं इसे ठीक से बहुत संतुष्ट के बाद मुझे समझ में क्यों यह पहली जगह में काम नहीं किया न नहीं कर रहा हूँ। क्या कोई इस पर मेरे लिए कुछ प्रकाश डाल सकता है?

धन्यवाद।

Answer 1

आप subroutine कार्य करने के लिए मूल्य द्वारा एक Foo गुजर रहे हैं। इसका मतलब है कि इसकी अपनी प्रति है, जो इसके दायरे से बाहर निकलने पर नष्ट हो जाती है।

void subroutine(Foo x) { 
    // x is a new Foo here. It will get destroyed on exiting scope, 
    // resulting in a destructor call 
} 

आपका मुख्य समस्या यह है कि यहाँ आप एक प्रति निर्माता लागू नहीं किया है, तो गतिशील रूप से आवंटित सरणी कॉपी नहीं है (केवल सूचक है कि यह है की ओर इशारा करता है)। इसलिए, जब आप Foo वस्तुओं कॉपी, आप प्रत्येक प्रतिलिपि एक ही सरणी की चर्चा करते हुए की है। और प्रत्येक प्रति इसे नष्ट करने की कोशिश करेगी।

आपको rule of three का पालन करना चाहिए और एक असाइनमेंट ऑपरेटर और एक कॉपी कन्स्ट्रक्टर लागू करना है जो सरणी की "गहरी प्रति" बनाता है, जैसे प्रत्येक Foo ऑब्जेक्ट का अपना सरणी है।

Answer 2

आपको हो रही समस्या

है कि आप मूल्य के आधार पर आपके वस्तु गुजर रहे हैं:

void subroutine(Foo x) { 

यह एक अस्थायी वस्तु बनाने और प्रतिलिपि निर्माता/हर बार जब आप इसे कहते आपके वस्तु का नाशक लागू कर रहा है।

Answer 3

जब आप void subroutine(Foo x) { पर कॉल करते हैं तो आपकी ऑब्जेक्ट bar कॉपी की जाती है (इस प्रकार कार्यकर्ता को फ़ंक्शन समाप्त होने के बाद बुलाया जाता है)।

उपयोग करने का प्रयास करें: void subroutine(Foo &x) {, यह ठीक काम करना चाहिए।

Answer 4

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

void subroutine(Foo& x) 
{ 
    cout << "Hello!" << endl; 
} 

आप प्रतिलिपि निर्माता की घोषणा के द्वारा अपने वर्ग के आकस्मिक प्रतियां रोकने के लिए और कॉपी इस तरह असाइनमेंट ऑपरेटर निजी कर सकते हैं:

class Foo { 
private: 

    double *array; 

    Foo(const Foo&); 
    Foo& operator=(const foo&); 

public: 
    ... 
}; 

तो फिर तुम एक संकलन मिल इसके बजाय त्रुटि। क्या तुम सच में अपने वर्ग की एक प्रतिलिपि बनाने के लिए सक्षम होने की जरूरत है, तो आप वास्तव में इन कार्यों को लागू करने के लिए एक "गहरी प्रतिलिपि" प्रदर्शन करने के लिए (या बेहतर अभी तक std::vector<float> का उपयोग करें और है कि सुरक्षित नकल सहित आप के लिए स्मृति का प्रबंधन करते हैं) की आवश्यकता होगी।