निम्नलिखित बिल्कुल बिल्कुल सटीक नहीं है। जब आप इसे पढ़ते हैं तो इसे नमक के दाने के साथ लें :)
खैर, आप जिन तीन चीजों का उल्लेख करते हैं , वे स्वचालित, स्थिर और गतिशील भंडारण अवधि हैं , जिनका कुछ करना है कि वस्तुएं कितनी देर तक रहती हैं और कब जीवन शुरू करती हैं।
स्वचालित भंडारण अवधि
आप अल्पकालिक और छोटे डेटा के लिए स्वचालित भंडारण अवधि का उपयोग करते हैं , जो केवल कुछ ब्लॉक के भीतर स्थानीय स्तर पर आवश्यक है :
if(some condition) {
int a[3]; // array a has automatic storage duration
fill_it(a);
print_it(a);
}
जैसे ही हम ब्लॉक से बाहर निकलते हैं, जीवनकाल समाप्त हो जाता है, और जैसे ही ऑब्जेक्ट परिभाषित होता है, वैसे ही यह शुरू हो जाता है। वे सबसे सरल प्रकार की भंडारण अवधि हैं, और विशेष गतिशील भंडारण अवधि की तुलना में तेज़ हैं।
स्थिर भंडारण अवधि
आप मुफ्त चर के लिए स्थिर भंडारण अवधि का उपयोग करते हैं, जो किसी भी कोड द्वारा हर समय पहुँचा जा सकता है, यदि उनका दायरा ऐसे उपयोग (नेमस्पेस स्कोप) की अनुमति देता है, और स्थानीय चर के लिए जिन्हें अपने दायरे (स्थानीय दायरे) से बाहर निकलने के लिए अपने जीवनकाल का विस्तार करने की आवश्यकता होती है, और सदस्य चरों के लिए जिन्हें उनके वर्ग (वर्ग दायरे) की सभी वस्तुओं द्वारा साझा किए जाने की आवश्यकता है। उनका जीवनकाल उस दायरे पर निर्भर करता है जिसमें वे हैं। उनके पास नाम स्थान और स्थानीय गुंजाइश और वर्ग गुंजाइश हो सकती है । उन दोनों के बारे में क्या सच है, एक बार उनका जीवन शुरू हो जाता है, जीवनकाल कार्यक्रम के अंत में समाप्त होता है । यहाँ दो उदाहरण हैं:
// static storage duration. in global namespace scope
string globalA;
int main() {
foo();
foo();
}
void foo() {
// static storage duration. in local scope
static string localA;
localA += "ab"
cout << localA;
}
प्रोग्राम प्रिंट करता है ababab, क्योंकि localAइसके ब्लॉक से बाहर निकलने पर नष्ट नहीं होता है। आप कह सकते हैं कि जिन वस्तुओं पर स्थानीय गुंजाइश होती है, वे जीवनकाल शुरू करते हैं जब नियंत्रण उनकी परिभाषा तक पहुंचता है । इसके लिए localA, यह तब होता है जब फ़ंक्शन के शरीर में प्रवेश किया जाता है। नेमस्पेस स्कोप में वस्तुओं के लिए, प्रोग्राम स्टार्टअप पर जीवनकाल शुरू होता है । वर्ग गुंजाइश की स्थिर वस्तुओं के लिए भी यही सच है:
class A {
static string classScopeA;
};
string A::classScopeA;
A a, b; &a.classScopeA == &b.classScopeA == &A::classScopeA;
जैसा कि आप देख रहे हैं, classScopeAअपने वर्ग की विशेष वस्तुओं के लिए बाध्य नहीं है, बल्कि कक्षा के लिए ही है। उपरोक्त तीनों नामों का पता एक ही है, और सभी एक ही वस्तु को दर्शाते हैं। स्थैतिक वस्तुओं को कब और कैसे शुरू किया जाता है, इस बारे में विशेष नियम हैं, लेकिन अब इसके बारे में चिंता न करें। यह शब्द स्टैटिक इनिशियलाइज़ेशन ऑर्डर फियास्को द्वारा लिया गया है ।
गतिशील भंडारण अवधि
अंतिम भंडारण अवधि गतिशील है। यदि आप ऑब्जेक्ट्स को किसी अन्य आइल पर जीना चाहते हैं, तो आप इसका उपयोग करते हैं, और आप उस संदर्भ के आसपास पॉइंटर्स रखना चाहते हैं। यदि आपकी वस्तुएँ बड़ी हैं , और यदि आप केवल रनटाइम पर ज्ञात आकार की सरणियाँ बनाना चाहते हैं, तो आप उनका उपयोग भी करते हैं । इस लचीलेपन के कारण, गतिशील भंडारण अवधि वाले ऑब्जेक्ट जटिल और धीमी गति से प्रबंधित होते हैं। जब एक उपयुक्त नया ऑपरेटर आह्वान होता है तो उस गतिशील अवधि का जीवनकाल शुरू होता है:
int main() {
// the object that s points to has dynamic storage
// duration
string *s = new string;
// pass a pointer pointing to the object around.
// the object itself isn't touched
foo(s);
delete s;
}
void foo(string *s) {
cout << s->size();
}
इसका जीवनकाल तभी समाप्त होता है जब आप उनके लिए डिलीट कहते हैं। यदि आप यह भूल जाते हैं, कि वे वस्तुएँ जीवनकाल कभी समाप्त नहीं होती हैं। और क्लास ऑब्जेक्ट जो एक उपयोगकर्ता घोषित कंस्ट्रक्टर को परिभाषित करते हैं, उनके विध्वंसक नहीं होंगे। गतिशील भंडारण अवधि वाले ऑब्जेक्ट को अपने जीवनकाल और संबंधित मेमोरी संसाधन की मैन्युअल हैंडलिंग की आवश्यकता होती है। उनके उपयोग में आसानी के लिए पुस्तकालय मौजूद हैं। एक स्मार्ट पॉइंटर का उपयोग करके विशेष वस्तुओं के लिए स्पष्ट कचरा संग्रह स्थापित किया जा सकता है:
int main() {
shared_ptr<string> s(new string);
foo(s);
}
void foo(shared_ptr<string> s) {
cout << s->size();
}
आपको कॉल डिलीट करने की परवाह नहीं है: साझा किया गया ptr आपके लिए ऐसा करता है, अगर ऑब्जेक्ट को रेफर करने वाला आखिरी पॉइंटर गुंजाइश से बाहर हो जाता है। साझा ptr में ही स्वचालित संग्रहण अवधि होती है। इसलिए इसका जीवनकाल स्वचालित रूप से प्रबंधित हो जाता है, जिससे यह जांचने की अनुमति मिलती है कि क्या इसे अपने विध्वंसक में इंगित गतिशील वस्तु को हटाना चाहिए या नहीं। Share_ptr संदर्भ के लिए, बढ़ावा देने वाले दस्तावेज़ देखें: http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/sared_ptr.htm