यहां हम देखेंगे कि यदि C++ में डिस्ट्रक्टर्स प्राइवेट हैं तो क्या होगा। आइए कुछ उदाहरण कोड देखें ताकि विचार मिल सके।
केस 1: प्राइवेट डिस्ट्रक्टर, कोई ऑब्जेक्ट नहीं बनाया गया
इस कोड में प्राइवेट डिस्ट्रक्टर है, लेकिन यह कोई त्रुटि उत्पन्न नहीं करेगा क्योंकि कोई ऑब्जेक्ट नहीं बनाया गया।
#include <iostream>
using namespace std;
class my_class {
private:
~my_class() {
// प्राइवेट डिस्ट्रक्टर
}
};
int main() {
// कोई ऑब्जेक्ट नहीं बनाया
return 0;
}
केस 2: स्टैक पर ऑब्जेक्ट बनाना (त्रुटि)
इस प्रोग्राम में, यह कंपाइलेशन त्रुटि उत्पन्न करेगा, क्योंकि हम एक ऑब्जेक्ट बनाने का प्रयास कर रहे हैं, लेकिन कंपाइलर देख सकता है कि डिस्ट्रक्टर एक्सेसिबल नहीं है। इसलिए स्कोप समाप्त होने पर इसे नष्ट नहीं किया जा सकता।
#include <iostream>
using namespace std;
class my_class {
private:
~my_class() {
// प्राइवेट डिस्ट्रक्टर
}
};
int main() {
my_class obj; // त्रुटि: डिस्ट्रक्टर प्राइवेट है
return 0;
}
आउटपुट
[Error] 'my_class::~my_class()' is private
केस 3: पॉइंटर बनाना (कोई त्रुटि नहीं)
अब यदि हम उस क्लास के लिए एक पॉइंटर बनाते हैं, तो यह त्रुटि उत्पन्न नहीं करेगा क्योंकि कोई वास्तविक ऑब्जेक्ट नहीं बनाया गया।
#include <iostream>
using namespace std;
class my_class {
private:
~my_class() {
// प्राइवेट डिस्ट्रक्टर
}
};
int main() {
my_class *obj; // केवल पॉइंटर, कोई ऑब्जेक्ट नहीं
return 0;
}
केस 4: new के साथ ऑब्जेक्ट बनाना (कोई त्रुटि नहीं)
यदि new ऑपरेटर का उपयोग करके एक ऑब्जेक्ट बनाया जाता है, तो भी कोई त्रुटि उत्पन्न नहीं होगी। कंपाइलर मानता है कि यह प्रोग्रामर की जिम्मेदारी है कि वह ऑब्जेक्ट को मेमोरी से डिलीट करे।
#include <iostream>
using namespace std;
class my_class {
private:
~my_class() {
// प्राइवेट डिस्ट्रक्टर
}
};
int main() {
my_class *obj = new my_class; // OK
// delete obj; // यदि यह अनकमेंट किया गया तो त्रुटि होगी
return 0;
}
केस 5: delete के साथ डिलीट करना (त्रुटि)
अब यदि हम ऑब्जेक्ट को डिलीट करने के लिए delete स्टेटमेंट जोड़ते हैं, तो यह प्राइवेट डिस्ट्रक्टर के लिए त्रुटि उत्पन्न करेगा।
#include <iostream>
using namespace std;
class my_class {
private:
~my_class() {
// प्राइवेट डिस्ट्रक्टर
}
};
int main() {
my_class *obj = new my_class;
delete obj; // त्रुटि: डिस्ट्रक्टर प्राइवेट है
return 0;
}
आउटपुट
[Error] 'my_class::~my_class()' is private
प्राइवेट डिस्ट्रक्टर के उपयोग के मामले
प्राइवेट डिस्ट्रक्टर उपयोगी होते हैं जब:
- सिंगलटन पैटर्न: केवल एक इंस्टेंस सुनिश्चित करना, और इसे केवल स्टैटिक फ़ैक्टरी मेथड के माध्यम से बनाया/नष्ट किया जा सकता है।
- हीप-ओनली ऑब्जेक्ट्स: ऑब्जेक्ट्स को केवल हीप पर बनाने के लिए बाध्य करना (स्टैक पर नहीं)।
- रेफरेंस काउंटिंग/स्मार्ट पॉइंटर्स: कस्टम डिलीशन लॉजिक लागू करना।
सिंगलटन उदाहरण
class Singleton {
private:
static Singleton* instance;
Singleton() {} // प्राइवेट कंस्ट्रक्टर
~Singleton() {} // प्राइवेट डिस्ट्रक्टर
public:
static Singleton* getInstance() {
if (!instance) instance = new Singleton();
return instance;
}
static void destroy() {
delete instance;
instance = nullptr;
}
// कॉपी/मूव रोकें
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
};
Singleton* Singleton::instance = nullptr;
इस पैटर्न में, केवल getInstance() और destroy() ही ऑब्जेक्ट के जीवनचक्र को नियंत्रित कर सकते हैं।
