लेख सामग्री
- घोषणात्मक क्षेत्र और दायरा
- वैश्विक कार्यक्षेत्र
- ब्लॉक स्कोप
- फंक्शन स्कोप
- गणना का दायरा
- कक्षा का दायरा
- टेम्पलेट पैरामीटर स्कोप
- नाम छुपाना
- उसी दायरे में घोषणा को दोहराने की संभावना
- नेमस्पेस स्कोप
- विभिन्न भागों में दायरा
- निष्कर्ष
घोषणात्मक क्षेत्र और दायरा
एक घोषणात्मक क्षेत्र एक प्रोग्राम टेक्स्ट का सबसे बड़ा हिस्सा होता है जिसमें एक इकाई का नाम मान्य होता है। यह वह क्षेत्र है जिसमें एक ही इकाई को संदर्भित करने के लिए अयोग्य नाम का उपयोग (देखा) किया जा सकता है। निम्नलिखित संक्षिप्त कार्यक्रम पर विचार करें:
#शामिल
का उपयोग करते हुए नाम स्थानघंटे;
शून्यएफएन()
{
NSकहां= 3;
अगर (1==1)
{
लागत<<कहां<<'एन';
}
}
NSमुख्य()
{
एफएन();
वापसी 0;
}
फ़ंक्शन fn () में दो ब्लॉक होते हैं: if-condition के लिए एक आंतरिक ब्लॉक और फ़ंक्शन बॉडी के लिए एक बाहरी ब्लॉक। पहचानकर्ता, var, को बाहरी ब्लॉक में पेश और देखा जाता है। इसे कोउट स्टेटमेंट के साथ इनर ब्लॉक में भी देखा जाता है। बाहरी और आंतरिक ब्लॉक दोनों नाम, var के दायरे हैं।
हालांकि, नाम, var, अभी भी एक अलग इकाई घोषित करने के लिए उपयोग किया जा सकता है जैसे कि आंतरिक ब्लॉक में एक फ्लोट। निम्नलिखित कोड इसे दिखाता है:
#शामिल
का उपयोग करते हुए नाम स्थानघंटे;
शून्यएफएन()
{
NSकहां= 3;
अगर (1==1)
{
पानी पर तैरनाकहां= 7.5;
लागत<<कहां<<'एन';
}
}
NSमुख्य()
{
एफएन();
वापसी 0;
}
आउटपुट 7.5 है। इस मामले में, नाम, var, का उपयोग अब आंतरिक ब्लॉक में मूल्य 3 के पूर्णांक को संदर्भित करने के लिए नहीं किया जा सकता है, जिसे बाहरी ब्लॉक में पेश (घोषित) किया गया था। ऐसे आंतरिक ब्लॉकों को बाहरी ब्लॉक में घोषित संस्थाओं के लिए संभावित दायरे के रूप में संदर्भित किया जाता है।
नोट: बाहरी ब्लॉक की तरह एक ही प्रकार की एक इकाई को अभी भी आंतरिक ब्लॉक में घोषित किया जा सकता है। हालांकि, इस मामले में, आंतरिक ब्लॉक में जो मान्य है वह नई घोषणा और उसका अर्थ है, जबकि पुरानी घोषणा और आंतरिक ब्लॉक के बाहर इसका अर्थ बाहरी ब्लॉक में मान्य रहता है।
एक आंतरिक ब्लॉक में एक ही नाम की घोषणा आम तौर पर उस आंतरिक ब्लॉक के बाहर उसी नाम की घोषणा को ओवरराइड करती है। आंतरिक ब्लॉक अन्य आंतरिक ब्लॉकों को घोंसला बना सकते हैं।
वैश्विक कार्यक्षेत्र
जब कोई प्रोग्रामर सिर्फ एक फाइल टाइप करना शुरू करता है, तो वह वैश्विक दायरा होता है। निम्नलिखित लघु कार्यक्रम इसे दर्शाता है:
#शामिलका उपयोग करते हुए नाम स्थानघंटे;
पानी पर तैरनाकहां= 9.4;
NSमुख्य()
{
लागत <<कहां<<'एन';
लागत <<::कहां<<'एन';
वापसी 0;
}
आउटपुट है:
9.4
9.4
इस मामले में, var के लिए घोषणात्मक क्षेत्र या दायरा var के लिए घोषणा के बिंदु से शुरू होता है, फ़ाइल (अनुवाद इकाई) के अंत तक नीचे की ओर जारी रहता है।
मुख्य () फ़ंक्शन का ब्लॉक एक अलग दायरा है; यह वैश्विक दायरे के लिए नेस्टेड स्कोप है। वैश्विक दायरे की एक इकाई तक पहुँचने के लिए, एक अलग दायरे से, पहचानकर्ता का उपयोग सीधे या पहले स्कोप रिज़ॉल्यूशन ऑपरेटर द्वारा किया जाता है, :: ।
नोट: इकाई, मुख्य (), को भी वैश्विक दायरे में घोषित किया गया है।
ब्लॉक स्कोप
if, जबकि, do, for, या switch स्टेटमेंट प्रत्येक एक ब्लॉक को परिभाषित कर सकता है। ऐसा कथन एक यौगिक कथन है। किसी ब्लॉक में घोषित चर के नाम में एक ब्लॉक का दायरा होता है। इसका दायरा इसके घोषणा के बिंदु से शुरू होता है और इसके ब्लॉक के अंत में समाप्त होता है। निम्नलिखित लघु कार्यक्रम इसे चर, पहचान के लिए दिखाता है:
#शामिलका उपयोग करते हुए नाम स्थानघंटे;
NSमुख्य()
{
अगर (1==1)
{
/*कुछ बयान*/
NSअध्यक्ष= 5;
लागत<<अध्यक्ष<<'एन';
/*कुछ बयान*/
}
वापसी 0;
}
एक चर, जैसे कि पहचान, जिसे ब्लॉक स्कोप पर घोषित किया गया है, एक स्थानीय चर है।
ब्लॉक स्कोप के बाहर और उसके ऊपर घोषित एक वैरिएबल को ब्लॉक के हेडर में देखा जा सकता है (जैसे, if-block के लिए कंडीशन) और ब्लॉक के भीतर भी। निम्नलिखित लघु कार्यक्रम इसे चर, पहचान के लिए दिखाता है:
#शामिलका उपयोग करते हुए नाम स्थानघंटे;
NSमुख्य()
{
NSपहचान= 8;
अगर (पहचान== 8)
{
लागत<<पहचान<<'एन';
}
वापसी 0;
}
आउटपुट 8 है। यहां दो ब्लॉक स्कोप हैं: मुख्य () फ़ंक्शन के लिए ब्लॉक और नेस्टेड इफ-कंपाउंड स्टेटमेंट। नेस्टेड ब्लॉक मुख्य () फ़ंक्शन ब्लॉक का संभावित दायरा है।
ब्लॉक के दायरे में शुरू की गई घोषणा को ब्लॉक के बाहर नहीं देखा जा सकता है। निम्नलिखित लघु कार्यक्रम, जो संकलित नहीं करता है, इसे चर, चर के साथ दिखाता है:
#शामिलका उपयोग करते हुए नाम स्थानघंटे;
NSमुख्य()
{
अगर (1 == 1)
{
NSचरबी= पंद्रह;
}
लागत<<चरबी<<'एन'; // त्रुटि: इसके दायरे से बाहर पहुँचा।
वापसी 0;
}
संकलक variab के लिए एक त्रुटि संदेश उत्पन्न करता है।
एक कंपाउंड फ़ंक्शन के हेडर में घोषित एक इकाई को कंपाउंड स्टेटमेंट के बाहर (नीचे) नहीं देखा जा सकता है। निम्नलिखित फॉर-लूप कोड संकलित नहीं होगा, जिसके परिणामस्वरूप एक त्रुटि संदेश होगा:
#शामिलका उपयोग करते हुए नाम स्थानघंटे;
NSमुख्य()
{
के लिये (NSमैं=0;मैं<4; ++मैं)
{
लागत<<मैं<<'';
}
लागत<<मैं<<'';
वापसी 0;
}
पुनरावृत्ति चर, i, फॉर-लूप ब्लॉक के अंदर देखा जाता है, लेकिन फॉर-लूप ब्लॉक के बाहर नहीं।
फंक्शन स्कोप
फ़ंक्शन ब्लॉक में एक फ़ंक्शन पैरामीटर देखा जाता है। फ़ंक्शन ब्लॉक में घोषित एक इकाई को घोषणा के बिंदु से फ़ंक्शन ब्लॉक के अंत तक देखा जाता है। निम्नलिखित लघु कार्यक्रम इसे दर्शाता है:
#शामिल#शामिल
का उपयोग करते हुए नाम स्थानघंटे;
स्ट्रिंग fn(स्ट्रिंग str)
{
charकाटें[] = 'केले';
/*अन्य कथन*/
स्ट्रिंग टोटलStr=पी+काटें;
वापसीटोटलस्ट्र;
}
NSमुख्य()
{
स्ट्रिंग टोटस्ट्रा=एफएन('खाना');
लागत<<टोटस्ट्रा<<'एन';
वापसी 0;
}
आउटपुट है:
केला खाना
नोट: फ़ंक्शन के बाहर घोषित एक इकाई (इसके ऊपर) को फ़ंक्शन पैरामीटर सूची में और फ़ंक्शन ब्लॉक में भी देखा जा सकता है।
लेबल
एक लेबल का दायरा वह कार्य है जिसमें वह दिखाई देता है। निम्नलिखित कोड इसे दिखाता है:
#शामिलका उपयोग करते हुए नाम स्थानघंटे;
शून्यएफएन()
{
के लिए जाओप्रयोगशाला;
/*अन्य कथन*/
प्रयोगशाला: NSनहीं= 2;
लागत<<नहीं<<'एन';
}
NSमुख्य()
{
एफएन();
वापसी 0;
}
आउटपुट 2 है।
गणना का दायरा
अनस्कोप्ड एन्यूमरेशन
निम्नलिखित पर विचार करें यदि-ब्लॉक:
{
एन्यूम {ए, बी, सी=बी+2};
लागत<<प्रति<<''<<बी<<''<<सी<<'एन';
}
आउटपुट 0 1 3 है।
ब्लॉक में पहली पंक्ति एक एन्यूमरेशन है, ए, बी, और सी इसके एन्यूमरेटर हैं। एन्यूमरेटर का दायरा घोषणा के बिंदु से शुरू होकर एन्यूमरेशन के संलग्न ब्लॉक के अंत तक होता है।
निम्नलिखित कथन संकलित नहीं होगा क्योंकि c की घोषणा का बिंदु उसके बाद है:
एन्यूम {प्रति=सी+2, बी, सी};निम्नलिखित कोड खंड संकलित नहीं होगा क्योंकि एन्यूमरेटर्स को एन्यूमरेशन के संलग्न ब्लॉक के बाद एक्सेस किया जाता है:
अगर (1==1){
एन्यूम {ए, बी, सी=बी+2};
}
लागत<<प्रति<<''<<बी<<''<<सी<<'एन'; // त्रुटि: दायरे से बाहर
उपरोक्त एन्यूमरेशन को एक अनस्कोप्ड एन्यूमरेशन के रूप में वर्णित किया गया है, और इसके एन्यूमरेटर्स को अनस्कोप्ड एन्यूमरेटर्स के रूप में वर्णित किया गया है। ऐसा इसलिए है क्योंकि यह केवल आरक्षित-शब्द, एनम से शुरू होता है। एन्यूमरेशन जो एनम क्लास या एनम स्ट्रक्चर से शुरू होते हैं, उन्हें स्कोप्ड एन्यूमरेशन के रूप में वर्णित किया जाता है। उनके एन्यूमरेटर्स को स्कोप्ड एन्यूमरेटर्स के रूप में वर्णित किया गया है।
स्कोप्ड एन्यूमरेशन
निम्नलिखित कथन ठीक है:
यह एक स्कोप्ड एन्यूमरेशन का एक उदाहरण है। वर्ग का नाम नाम है। यहां, एन्यूमरेटर का दायरा घोषणा के बिंदु से शुरू होकर एन्यूमरेशन डेफिनिशन के अंत तक होता है, न कि एन्यूमरेशन के लिए संलग्न ब्लॉक के अंत तक। निम्नलिखित कोड संकलित नहीं होगा:
अगर (1==1){
एन्यूम कक्षानर{ए, बी, सी=बी+2};
लागत<<प्रति<<''<<बी<<''<<सी<<'एन'; // त्रुटि: एनम क्लास या एनम स्ट्रक्चर के दायरे से बाहर
}
कक्षा का दायरा
सामान्य दायरे के साथ, घोषणात्मक क्षेत्र एक बिंदु से शुरू होता है, फिर जारी रहता है और एक अलग बिंदु पर रुक जाता है। दायरा एक सतत क्षेत्र में मौजूद है। वर्ग के साथ, एक इकाई का दायरा अलग-अलग क्षेत्रों में हो सकता है जो एक साथ शामिल नहीं होते हैं। नेस्टेड ब्लॉक के नियम अभी भी लागू होते हैं। निम्नलिखित कार्यक्रम इसे दर्शाता है:
#शामिलका उपयोग करते हुए नाम स्थानघंटे;
// बेस क्लास
कक्षाक्लास
{
निजी:
NSमेमप= 5;
संरक्षित:
NSमेमप्रो= 9;
सह लोक:
शून्यएफएन()
{
लागत<<मेमप<<'एन';
}
};
// व्युत्पन्न वर्ग
कक्षाडेरक्ला: सह लोकक्लास
{
सह लोक:
NSडरमेम=मेमप्रो;
};
NSमुख्य()
{
क्ला ओब्जो;
ओबीजेएफएन();
डेरक्ला डेरऑब्ज;
लागत<<derObj.डरमेम<<'एन';
वापसी 0;
}
आउटपुट है:
5
9
कक्षा क्ला में, चर memP, घोषणा के बिंदु पर देखा जाता है। उसके बाद, संरक्षित का छोटा हिस्सा छोड़ दिया जाता है, फिर कक्षा सदस्य फ़ंक्शन ब्लॉक में फिर से देखा जाता है। व्युत्पन्न वर्ग को छोड़ दिया जाता है, फिर मुख्य () फ़ंक्शन स्कोप (ब्लॉक) पर फिर से देखा जाता है।
कक्षा क्ला में, चर memPro, घोषणा के बिंदु पर देखा जाता है। सार्वजनिक फ़ंक्शन fn () का हिस्सा छोड़ दिया जाता है, फिर व्युत्पन्न वर्ग विवरण ब्लॉक में देखा जाता है। इसे मुख्य () फ़ंक्शन में फिर से नीचे देखा जाता है।
स्कोप रिजॉल्यूशन ऑपरेटर
C++ में स्कोप रेजोल्यूशन ऑपरेटर :: है। इसका उपयोग कक्षा के स्थिर सदस्य तक पहुँचने के लिए किया जाता है। निम्नलिखित कार्यक्रम इसे दर्शाता है:
का उपयोग करते हुए नाम स्थानघंटे;
कक्षाक्लास
{
सह लोक:
स्थिर NS स्थिरांकमेम= 5;
सह लोक:
स्थिर शून्यएफएन()
{
लागत<<मेम<<'एन';
}
};
NSमुख्य()
{
लागत<<क्लास::मेम<<'एन';
क्लास::एफएन();
वापसी 0;
}
आउटपुट है:
5
5
स्थैतिक सदस्यों को मुख्य () फ़ंक्शन ब्लॉक में देखा जाता है, जिसे स्कोप रिज़ॉल्यूशन ऑपरेटर का उपयोग करके एक्सेस किया जाता है।
टेम्पलेट पैरामीटर स्कोप
टेम्प्लेट पैरामीटर नाम का सामान्य दायरा घोषणा के बिंदु से उसके ब्लॉक के अंत तक शुरू होता है, जैसा कि निम्नलिखित कोड में है:
टेम्पलेट<नाम लिखोटी,नाम लिखोयू> structयुग{
टी जॉन= ग्यारह;
आप पीटर= 12.3;
टी मेरी= १३;
यू जॉय= 14.6;
};
यू और टी ब्लॉक के भीतर देखे जाते हैं।
टेम्प्लेट फ़ंक्शन प्रोटोटाइप के लिए, स्कोप घोषणा के बिंदु से शुरू होकर फ़ंक्शन पैरामीटर सूची के अंत तक होता है, जैसा कि निम्नलिखित कथन में है:
टेम्पलेट<नाम लिखोटी,नाम लिखोयू> शून्यसमारोह(तुम नहीं, तुम चा,स्थिरांक char *पी);हालाँकि, जब वर्ग विवरण (परिभाषा) की बात आती है, तो दायरा भी विभिन्न भागों का हो सकता है जैसा कि निम्नलिखित कोड में है:
#शामिलका उपयोग करते हुए नाम स्थानघंटे;
टेम्पलेट<कक्षाटी,कक्षायू> कक्षाद क्लास
{
सह लोक:
टी संख्या;
स्थिरयू चो;
शून्यसमारोह(आप पिता,स्थिरांक char *पी)
{
लागत << 'वहां ' <<एक पर<< 'मूल्यवान पुस्तकें' <<नहीं<<पी<< ' दुकान में।' << 'एन';
}
स्थिर शून्यमज़ा(यू चो)
{
अगर (चौधरी== 'प्रति')
लागत << 'आधिकारिक स्थिर सदस्य समारोह' << 'एन';
}
};
NSमुख्य()
{
द क्लास<NS,char>ओब्जो;
ओबीजेएक पर = 12;
ओबीजेसमारोह('$','500');
वापसी 0;
}
नाम छुपाना
नाम छिपाने का एक उदाहरण तब होता है जब एक ही ऑब्जेक्ट प्रकार का नाम नेस्टेड ब्लॉक में फिर से घोषित किया जाता है। निम्नलिखित कार्यक्रम इसे दर्शाता है:
#शामिलका उपयोग करते हुए नाम स्थानघंटे;
शून्यएफएन()
{
NSकहां= 3;
अगर (1==1)
{
NSकहां= 4;
लागत<<कहां<<'एन';
}
लागत<<कहां<<'एन';
}
NSमुख्य()
{
एफएन();
वापसी 0;
}
आउटपुट है:
4
3
ऐसा इसलिए है क्योंकि नेस्टेड ब्लॉक में var बाहरी ब्लॉक में var को छुपाता है।
उसी दायरे में घोषणा को दोहराने की संभावना
घोषणा का बिंदु वह जगह है जहां नाम को इसके दायरे में (पहली बार) पेश किया जाता है।
फंक्शन प्रोटोटाइप
विभिन्न संस्थाओं, यहां तक कि विभिन्न प्रकार के, को सामान्य रूप से एक ही दायरे में घोषित नहीं किया जा सकता है। हालाँकि, एक फ़ंक्शन प्रोटोटाइप को एक ही दायरे में एक से अधिक बार घोषित किया जा सकता है। दो फ़ंक्शन प्रोटोटाइप और संबंधित फ़ंक्शन परिभाषा के साथ निम्न प्रोग्राम इसे दिखाता है:
का उपयोग करते हुए नाम स्थानघंटे;
शून्यएफएन(NSएक पर);
शून्यएफएन(NSएक पर);
शून्यएफएन(NSएक पर)
{
लागत<<एक पर<<'एन';
}
NSमुख्य()
{
एफएन(5);
वापसी 0;
}
कार्यक्रम काम करता है।
अतिभारित कार्य
ओवरलोडेड फ़ंक्शन एक ही नाम के साथ फ़ंक्शन होते हैं लेकिन विभिन्न फ़ंक्शन हस्ताक्षर होते हैं। एक अन्य अपवाद के रूप में, समान नाम वाले अतिभारित कार्यों को समान दायरे में परिभाषित किया जा सकता है। निम्नलिखित कार्यक्रम इसे दर्शाता है:
का उपयोग करते हुए नाम स्थानघंटे;
शून्यएफएन(NSएक पर)
{
लागत<<एक पर<<'एन';
}
शून्यएफएन(पानी पर तैरनानहीं)
{
लागत<<नहीं<<'एन';
}
NSमुख्य()
{
एफएन(5);
पानी पर तैरनाफ्लाइट= 8.7;
एफएन(फ्लाइट);
वापसी 0;
}
आउटपुट है:
5
8.7
अतिभारित कार्यों को वैश्विक दायरे में परिभाषित किया गया है।
नेमस्पेस स्कोप
नेमस्पेस स्कोप अपने लेख के योग्य है। उक्त लेख इस वेबसाइट linuxhint.com के लिए लिखा गया है। बस इस साइट (पेज) के सर्च बॉक्स में सर्च शब्द नेमस्पेस स्कोप टाइप करें और ओके पर क्लिक करें, और आपको लेख मिल जाएगा।
विभिन्न भागों में दायरा
वर्ग ही एकमात्र ऐसी योजना नहीं है जिसका दायरा विभिन्न भागों में हो सकता है। मित्र विनिर्देशक, विस्तृत-प्रकार-विनिर्देशक के कुछ उपयोग, और उपयोग-निर्देश अन्य योजनाएं हैं जहां गुंजाइश अलग-अलग जगहों पर है - विवरण के लिए, बाद में देखें।
निष्कर्ष
एक दायरा एक घोषणात्मक क्षेत्र है। एक घोषणात्मक क्षेत्र एक प्रोग्राम टेक्स्ट का सबसे बड़ा हिस्सा होता है जिसमें एक इकाई का नाम मान्य होता है। इसे कुछ प्रोग्रामिंग योजनाओं के अनुसार एक से अधिक भागों में विभाजित किया जा सकता है, जैसे नेस्टेड ब्लॉक। जिन भागों में घोषणा बिंदु नहीं है, वे संभावित दायरे का निर्माण करते हैं। संभावित दायरे में घोषणा हो भी सकती है और नहीं भी।