1.4c — Local scope पर एक नज़र

1.4c — Local scope पर एक नज़र

Lesson 1.3 -- Variables, initialization, और assignment पर एक नज़र में आपने पहले ही देखा है की जब CPU कोई statement जैसे int x; को execute करता है, तब define किया गया variable instantiate हो जाता है, अर्थात इसके लिए memory में जगह बना ली जाती है ।

तो ज़ाहिर सा सवाल है की, “यदि ऐसा है, तो instantiated (created) variable नष्ट (destroy) कब होता है?”

किसी variable का scope ये निर्धारित करता है की variable के instantiate होने के बाद उसे कौन देख सकता है या उसका इस्तेमाल कौन कर सकता है । Function parameters और varibles जो function के अन्दर define किये जाते हैं, उनका local scope होता है । अर्थात वे केवल उसी function में देखे या इस्तेमाल किये जा सकते हैं जिसमे इन्हें define किया गया हो । Local variables function के शुरू होते ही बना लिए जाते हैं और इसके (function के) ख़त्म होने पर नष्ट हो जाते हैं ।

इस program पर नज़र डालें:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#include <iostream> int add(int x, int y) // x और y यहाँ बनाए गए {     // x औए y केवल इसी function में देखे और इस्तेमाल किये जा सकते हैं     return x + y; } // x और y यहाँ नष्ट (destroy) हो गयें int main() // a और b यहाँ बनाये गए {     int a = 5; // a को यहाँ initialize किया गया     int b = 6; // b को यहाँ initialize किया गया     // a और b केवल इसी function में देखे और इस्तेमाल किये जा सकते हैं     std::cout << add(a, b) << std::endl; // Function add() को call किया गया जहाँ x=a और y=b है     return 0; } // a और b यहाँ नष्ट (destroy) हो गयें

Function add() में, parameters x और y function के call होते ही बना लिए जाते हैं । इन्हें केवल function add() के अन्दर ही देखा/ इस्तेमाल किया जा सकता है और जैसे ही add() ख़त्म होता है, ये variables नष्ट हो जाते है ।
Variables a और b main() में बनाये जाते हैं । इन्हें केवल function main() के अन्दर ही देखा/ इस्तेमाल किया जा सकता है और जैसे ही main() ख़त्म होता है, ये variables भी नष्ट हो जाते है ।

और अच्छी तरह से समझने के लिए, आइये इस program को ज़रा नज़दीक से देखते हैं । यहाँ, एक-एक करके ये सारी चीजें हो रही हैं:

• main() का execution शुरू हुआ
• main में variable a बनाया गया और इसे value 5 assign किया गया
• main में variable b बनाया गया और इसे value 6 assign किया गया
• Function add() को parameters 5 और 6 के साथ call किया गया
• add में variable x बनाया गया और इसे value 5 assign किया गया
• add में variable y बनाया गया और इसे value 6 assign किया गया
• operator + की सहायता से 5 और 6 को जोड़ा गया, इन्हे जोड़ने पर value 11 प्राप्त हुआ
• add ने caller (main) को value (11) return किया
• add के x और y नष्ट हो गएँ
• main function ने आगे execute होते हुए console पर 11 print किया
• main ने operating system को value 0 return किया
• main के a और b नष्ट हो गएँ

और इस तरह हमारा program ख़त्म हुआ ।

ध्यान दे की यदि function add() को दो बार call किया जाता तो parameters x और y भी दो बार बनाये और नष्ट किये जाते -- हर call के लिए एक-एक बार । बहुत सारे functions से बने programs में variables कई बार बनाये और नष्ट किये जाते हैं ।

Local scope naming collision से बचाता है

Naming collision या Naming conflict: जब दो या दो से अधिक variables, classes, structs, enums आदि को एक ही नाम के साथ एक ही scope में define किया जाता है, तो इस घटना को naming collision या naming conflict कहा जाता है । ध्यान दे की naming collision या naming conflict किसी function के definition में भी संभव है, पर function overloading (जिसके बारे आगे के एक chapter में चर्चा की जाएगी) की सहायता से आप एक ही नाम के दो functions एक ही scope में आसानी से define कर सकते हैं । Naming conflicts या naming collision के case में compiler हमे error देता है ।

ऊपर दिए गए example में, आसानी से पता चल रहा है की variables a और b, variables x और y से अलग हैं ।

अब ज़रा इसपर नज़र डाले:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <iostream> int add(int x, int y) // add का x यहाँ बनाया गया {     return x + y; } // add का x यहाँ नष्ट हुआ int main() // main का x यहाँ बनाया गया {     int x = 5;     int y = 6;     std::cout << add(x, y) << std::endl; // main के x का value add के x में कॉपी किया गया     return 0; } // main का x यहाँ नष्ट हुआ

इस example में, हमने बस main में declare किये गए variables का नाम a और b से बदलकर x और y कर दिया है । ये program अब भी बिना किसी परेशानी के compile हो जायेगा, जबकि इसमें add() और main(), दोनों के variables के नाम बिलकुल एक जैसे हैं (x और y) । अब ज़रा सोचिये, यहाँ कोई naming collision क्यूँ नहीं हुआ? क्यूंकि main के x और y local scope में आते है, add() इन्हें (main के x और y को) नहीं देख सकता । उसी तरह add() के x और y का भी local scope है, जहां main() इन्हें नहीं देख सकता । बेहतर तरीके से समझाया जाये, तो main() और add() में से किसी को भी नहीं पता की किसी दुसरे function में variables के नाम, उनके variables के नाम से मिलते-जुलते हैं!

ये हमें naming conflicts से बचाता है, क्यूंकि किसी function को इस बात की चिंता करने की ज़रूरत नहीं की दुसरे functions में किन नामो का प्रयोग किया गया है । ये किसी दुसरे function के variables के value को गलती से या सोच-समझकर बदले जाने से भी बचाता है ।

हम chapter 4 में local scope और दुसरे तरह के scopes के बारे में और अधिक चर्चा करेंगे

Rule: वे नाम जिनका इस्तेमाल function के अंदर या function के parameter के रूप में किया गया हो, वे केवल उसी function तक सीमित होते हैं । वे किसी दुसरे function पर कोई प्रभाव नहीं डाल सकते ।

Quiz

1) ये program क्या print करेगा?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include <iostream> void doIt(int x) {     x = 3;     int y = 4;     std::cout << "doIt: x = " << x << " y = " << y << std::endl; } int main() {     int x = 1;     int y = 2;     std::cout << "main: x = " << x << " y = " << y << std::endl;     doIt(x);     std::cout << "main: x = " << x << " y = " << y << std::endl;     return 0; }