Storage Classes in C++ – Lifetime and Visibility

Storage Classes in C++: ये Class “C++” की Class नहीं है। ये “C” Language से लिया गया एक Concept है जिसमें ये तय किया जाता है कि कौनसा Data किस प्रकार से Store हो रहा है और किस प्रकार से Use हो रहा है। Storage Class के Concept को Use करके हम ये तय करते हैं कि हमें किस प्रकार के Variable की हमारे Program में जरूरत है और हम किस प्रकार के मान को Memory में Store करने के लिए किस प्रकार का Variable Create करते हैं। इससे पहले कि हम Storage Classes को समझें हमें दो शब्दों (Declaration व Definitions) को अच्छी तरह से समझना होगा।

Declarations and Definitions

जब हम किसी Variable या Function को कोई नाम देते हैं और उसका Data Type तय करते हैं, तो इस प्रक्रिया को Declaration कहा जाता है। यानी Declaration में हम किसी चीज का नाम व Data Type तय करते हैं। Declaration Compiler के लिए एक Information होती है। Compiler किसी Declaration पर कोई Action नहीं लेता है।

जबकि Definition का मतलब होता है कि Compiler Variable के लिए Memory में कोई Space Allocate करे। इन दोनों के बीच के अन्तर को हमने Functions को समझाते समय कई जगह पर Note करने की कोशिश की है। इसे सामान्‍य तरीके से हम निम्नानुसार लिख सकते हैं:

void function();    // function declaration

void function()     // function definition
{
   // statements									
}

Declaration केवल एक जानकारी होती है जबकि Definition वास्तविक चीज होती है। Definition Memory में स्थान लेता है जबकि Declaration Memory में कोई स्थान नहीं लेता। Declaration भी दो तरह के होते हैं। एक Declaration वह होता है जिसमें Declaration के समय Memory Allocate होती है जबकि दूसरे Declaration में Memory Allocate नहीं होती है।

जबकि Definition में हमेंशा Memory Allocate होती है। हम जब भी कोई Basic Data Type का Variable Declare करते हैं तो वह Variable वास्तव में Declare भी हो रहा होता है और Define भी। लेकिन कुछ स्थितियों में किसी Variable का Definition उसी समय नहीं होता जब उसे Declare किया जाता है।

Storage Classes in C++ : Lifetime and Visibility

किसी भी Variable की दो Characteristics होती है जिससे ;ह तय होता है कि कोई Variable किस Storage Class का है। पहली Characteristics है Visibility या Scope, जिसका मतलब ये होता है कि किसी Program के किसी हिस्से तक कोई Variable Accessible रहेगा। दूसरी विशेषता है lifetime, जो कि ये बताता है कि कोई Variable Memory में कितने समय तक Useable रहेगा और कब उस Variable का अन्त हो जाएगा।

कोई Variable किसी Function, Class, File में Visible रह सकता है और किसी Variable की Lifetime किसी Function, Object या Entire Program के Termination तक हो सकती है। यानी कोई Variable तब तक उपयोगी हो सकता है जब तक कि Program Terminate नहीं हो जाता।

हर Storage Class अलग तरीके का Lifetime व Visibility प्रदान करता है। हमने पिछले विभिन्न Programs में अलग-अलग तरीके के Storage Class को Use किया है। मुख्‍य रूप से दो तरह की Class के Variables हो सकते हैं।

Automatic Variables

जो Variables किसी Block के अन्दर Declare किए जाते useable हैं, वे Automatic Variables होते हैं। जैसे:

void anyfunc()
{
   int ivar;    	// automatic variables
   float fvar;
}

इन Variables को Automatic इसलिए कहा जाता है क्योंकि जब भी हम किसी Function को Call करते हैं तो उस Function में Declare किए गए सभी Variables Automatically Create हो जाते हैं और जब Program Control उस Function से बाहर निकलता है तो ये Variables Automatically समाप्त भी हो जाते हैं।

यदि तकनीकी रूप से इस बात को कहें तो जब किसी Function को Call किया जाता है, तब Automatic Variables Stack में Push होते हैं और जब Function Terminate होता है, तब Automatic Variables Stack से Pop हो जाते हैं। Automatic Variables की Lifetime उतनी ही होती है, जितनी देर Function के अन्दर Program Control रहता है। जैसे ही Program Control Function से Calling Program Return होता है, उस Function के सभी Automatic Variables की Life समाप्त हो जाती है।

Automatic Variables केवल उसी Function में उपयोगी होते हैं जिसमें उन्हें Declare किया जाता है। किसी Function के किसी Variable के मान का प्रयोग हम उस Variable के नाम का प्रयोग करके Calling Function में नहीं कर सकते हैं। यानी किसी अन्‍य Function में लिखे Statement किसी Calling Function में Declare किए गए Variable के मान को Use नहीं कर सकता है।

यदि दो अलग-अलग Function में x नाम के दो Variables हों,  तो ये दोनों Variables एक दूसरे से बिल्कुल अलग होते हैं। यदि हम किसी Variable को Automatic Class का Declare करना चाहें तो हम auto Keyword का प्रयोग करके निम्नानुसार किसी Variable को Automatic Class का Declare कर सकते हैं:

auto int Total;

लेकिन जो Variables किसी Function के Statement Block में Declare किए जाते हैं वे Variables By Default Automatic Class के होते हैं। Automatic Variables By Default Initialize नहीं होते हैं, इसलिए जब भी कोई Variable Automatic Class का होता है तो उसमें By Default Garbage मान होता है।

Register Variables

Register Variable एक विशेष तरह का Automatic Variable होता है। जब हम किसी Variable को register Class का Declare करना चाहते हैं, तब हमें register Keyword का प्रयोग करना पडता है। यानी हम निम्नानुसार किसी Variable को Register Class का Declare कर सकते हैं:

register int Total;

Register Variable के Declaration का Idea ये है कि जब हम किसी Variable को register Class का Declare करते हैं तब Variable Memory में Create ना होकर के सीधे ही CPU Register में Create होता है।

चूंकि registers के मान Memory की तुलना में काफी अधिक तेजी से Process होते हैं, ये Variable Program की Speed को काफी अधिक कर देते हैं। किसी Nested Loop में जो Inner Most Loop होता है उस Loop में स्थित Variable हमेंशा Register Class में Store होता है।

हम किसी एक Function में केवल एक या दो Variables को ही Register Class में Declare कर सकते हैं। जब हम किसी ऐसे Program को develop कर रहे हों जिसमें काफी Loops Use हो रहे हैं तो हमें चाहिए कि Loop के Variable को Register Class का Declare करें।

ये जरूरी नहीं है कि हम केवल किसी Function में ही Automatic Variables Create कर सकते हैं या केवल किसी Function में Created Variable ही Automatic Class का होता है। वास्तव में हम किसी भी Block के अन्दर Automatic Variables Create कर सकते हैं।

यदि हम हमारे Program में चाहते हैं कि कोई ऐसा Variable Create हो जो केवल कुछ Statement तक ही जीवित रहे तो हमें वे Statements व उस Variables दोनों को ही एक Block में Declare करना चाहिए। किसी Block के अन्दर Create होने वाला Variable हमेंशा Automatic Storage Class का Variable होता है।

External Variables

ऐसे Variables जो किसी Function या Class से बाहर Declare किए जाते हैं, External Storage Class के Variable कहलाते हैं। इन्हें Global Variables भी कहते हैं। उदाहरण के लिए हमने पिछले Program में MAX_LENGTH नाम का एक Variable declare किया है। ये एक Global या External Variable है। Global Variable को कोई भी Function Use कर सकता है और इन Variables की Lifetime Program के Termination तक होती है। यानी ऐसे Variables तभी समाप्त होते हैं जब Program Terminate होता है। कोई भी External Variable Create या Declare होते ही उसमें 0 Initialize हो जाता है।

External Variables को हम Multi File Program में भी Use कर सकते हैं। यानी एक External Variable के मान को हम किसी अन्‍य File में भी Use कर सकते हैं। लेकिन जब हम किसी External Variable को किसी Multi File Program में Access करना चाहते हैं तब हमें External Variable को extern Keyword के साथ Declare करना होता है। यदि हम किसी External Variable को extern Keyword के साथ निम्नानुसार Declare करें, तो हम उस External Variable को किसी भी अन्‍य File में Access कर सकते हैं। इस तरह के Variables Multi File Programs में काफी उपयोगी होते हैं।

// file #1
int ivar;          	// definition
			// ivar is known in this file
			// end of file #1

// file #2
extern int ivar;   	// declaration
			// ivar is also known in this file
			// end of file #2

// file #3
			// ivar is not known in this file
			// end of file #3

यहां ivar Variable को file 1 व file 2 में Define किया गया है, लेकिन File 3 में Declare नहीं किया गया है। इस तरीके के कारण ivar Variable File1 व File 2 में Visible है लेकिन File 3 में इस Variable को Use नहीं किया जा सकता है।

किसी भी Program में एक Variable केवल एक ही बार Define होता है और Memory में केवल एक ही बार जगह लेता है। फिर भी एक Variable को कई बार कई जगहों पर Declare किया जा सकता है।

उपर बता, गए उदाहरण में ivar Variable को हम जितनी चाहें उतनी Files में extern Keyword का प्रयोग करके Declare कर सकते हैं। हम किसी External Variable को अन्‍य File में Visible होने से रोक भी सकते हैं, चाहे दूसरी File उस External Variable को extern Keyword का प्रयोग करके Access कर रहा हो। ऐसा करने के लिए हमें static Keyword का प्रयोग करना होता है। इसे समझने के लिए निम्न Code Segments देखिए:

// file #1
static int ivar;          	// definition
				// ivar can be known ONLY in this file
				// end of file #1

// file #2
extern int ivar;          	// useless declaration
				// end of file #2

यहां Compile ये सोंचता है कि ivar एक ऐसा Variable है जिसे अभी तक Define नहीं किया गया है। जब Program Linker से Link होता है, तब Error Message देता है कि ivar Function को अभी तक Define नहीं किया गया है।

External Variables के साथ कुछ समस्याऐं भी हैं। चूंकि एक External Variable Global होता है इसलिए उसे किसी भी Function द्वारा Access किया जा सकता है और उसके मान में परिवर्तन किया जा सकता है। दूसरी समस्या ये है कि हम एक Program में एक नाम का केवल एक ही External Variable Create कर सकते हैं क्योंकि एक External Variable By Default Global प्रक`ति का होता है। इस स्थिति को Handle करने के लिए “C++” में Local Static Variables का Concept Add किया गया है।

Local Static Variables

कई बार हम चाहते हैं कि किसी Function को Call करने पर जब वापस उस Function को Call किया जाए, तो उसके किसी Variable का मान Damaged ना हो और उस मान को दूसरी बार Function में Use किया जा सके। उदाहरण के लिए हम एक ऐसा Function चाहते हैं जिसे जितनी बार भी Call किया जाए, वह हर Call पर मानों की Running Total का Average Return करे, जिसमें पिछले Call के भी सभी मान हों और वर्तमान Call के भी मान हों।

इस तरह के Function में हमें Total व जितनी बार Function को Call किया गया है, उसकी Counting को Store करके रखना जरूरी होता है ताकि Function नई Average को Calculate कर सके। हम जानते हैं कि किसी Function में Declare होने वाला Variable केवल Function के Block तक ही जीवित रहता है। जैसे ही Program Control Function के Block से बाहर आता है, Function के सभी Automatic Variables नष्‍ट हो जाते हैं।

यदि हम चाहते हैं कि Function के अन्दर किसी Variable के मान में जो परिवर्तन होता है, वह Program Control के Function से बाहर आने के बाद भी स्थिर रहे] तो हमें Variable को Static Declare करना पडता है। static “C++” का एक Keyword है। निम्न Function को देखिए:

float average(float item)
{
   static int n = 0;          // number of times we've been called
   static float total = 0.0;  // running total
   total += item;             // add argument to running total
   return total/n++;          // find average, increment count
}

Local Static Variable का Lifetime पूरे Program तक होता है। यानी यदि हम किसी Local Variable को Static Declare करते हैं, तो वह Variable तब तक जीवित रहता है जब तक हमारा Program Running होता है। ये Variable तब Destroy होते हैं जब हम हमारे Program का Termination करते हैं। इसलिए Static Local Variables के अन्दर जो मान होते हैं, वे मान भी पूरे Program में रहते हैं। ये हमेंशा Declare करते ही 0.0 से Initialized हो जाते हैं।

Local Static Variables का प्रयोग “C++” में उतना नहीं किया जाता जितना “C” में किया जाता था। “C++” में Local Static Variables को Use करने के लिए Member Functions Use किए जाते हैं, इसलिए Objects ने Functions के Local Variables को Use करने का काम स्वयं ले लिया है। Objects व Functions दोनों में Data स्थिर रहते हैं चाहे Function Execute हो रहा हो या नहीं।

चूंकि, Objects अधिक शक्तिशाली व बहुमुखी हैं इसलिए “C++” में Functions व Static Variables Create करने के बजाय Class Create की जाती है। यदि हम हमारी आवश्‍यकतानुसार Static Variables व Non – Member Function Create करना चाहें तो हम ऐसा कर सकते हैं।

लेकिन यदि ऐसी कोई जरूरत हो तो हमें Static Variables व Non – Member Function Create करने के बजाय Class Create करनी चाहिए जिसमें Static Data Members हों। हम विभिन्न प्रकार के Storage Class व Scope आदि को निम्न Table द्वारा सारांश रूप में देख सकते हैं: (Storage Classes in C++ – StackOverflow)