సి ++ లో స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ను ఉత్తమంగా ఎలా ఉపయోగించాలి?

పేరు సూచించినట్లుగా, వేరియబుల్ స్కోప్‌ల కారణంగా దాచిన పేర్లను పొందడానికి స్కోప్ రిజల్యూషన్ ఆపరేటర్ ఉపయోగించబడుతుంది, తద్వారా మీరు వాటిని ఇప్పటికీ ఉపయోగించవచ్చు. ఈ వ్యాసంలో సి ++ లో స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ను ఎలా ఉపయోగించాలో అర్థం చేసుకుంటాము & a నుండి దాని విభిన్న ప్రయోజనాలు ఏమిటి .

C ++ లో, స్కోప్ రిజల్యూషన్ ఆపరేటర్ ::. C ++ లోని స్కోప్ రిజల్యూషన్ ఆపరేటర్ వీటిని ఉపయోగించవచ్చు:

• అదే పేరుతో లోకల్ వేరియబుల్ ఉన్నప్పుడు గ్లోబల్ వేరియబుల్ యాక్సెస్
• తరగతి వెలుపల ఒక ఫంక్షన్‌ను నిర్వచించడం
• తరగతి స్టాటిక్ వేరియబుల్స్ యాక్సెస్
• మరొక తరగతి లోపల ఒక తరగతిని సూచిస్తుంది
• బహుళ వారసత్వం విషయంలో
• నేమ్‌స్పేస్

ఇప్పుడు ఉదాహరణల సహాయంతో ప్రతి ప్రయోజనాన్ని ఒక్కొక్కటిగా అర్థం చేసుకుందాం.

స్థానిక వేరియబుల్ ఉన్నప్పుడు గ్లోబల్ వేరియబుల్ యాక్సెస్ అదే పేరు

మీకు అదే పేరుతో లోకల్ వేరియబుల్ ఉంటే గ్లోబల్ వేరియబుల్ యాక్సెస్ చేయడానికి మీరు స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ని ఉపయోగించవచ్చు. దిగువ ఉదాహరణలో మనకు గ్లోబల్ & లోకల్ స్కోప్‌తో పేరు వేరియబుల్ అనే రెండు వేరియబుల్స్ ఉన్నాయి. కాబట్టి, ప్రధాన తరగతిలో గ్లోబల్ నమ్ వేరియబుల్‌ను యాక్సెస్ చేయడానికి మీరు స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ను ఉపయోగించాలి (అనగా :: సంఖ్య).

ఉదాహరణ

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int num = 30 // గ్లోబల్ వేరియబుల్‌ను ప్రారంభించడం num int main () {int num = 10 // స్థానిక వేరియబుల్ num cout ను ప్రారంభించడం<< 'Value of global num is ' << ::num cout << 'nValue of local num is ' << num return 0 } 

అవుట్పుట్

సి ++ లో స్కోప్ రిజల్యూషన్ ఆపరేటర్‌పై ఈ కథనంతో కదులుతోంది

తరగతి వెలుపల ఒక ఫంక్షన్‌ను నిర్వచించడం

మీరు ఒక తరగతిలో ఒక ఫంక్షన్‌ను ప్రకటించి, తరువాత దానిని తరగతి వెలుపల నిర్వచించాలనుకుంటే, మీరు స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ను ఉపయోగించి దీన్ని చేయవచ్చు. దిగువ ఉదాహరణలో, మేము క్లాస్ బైక్‌లో ఫంక్షన్ స్పీడ్‌ను ప్రకటిస్తున్నాము. తరువాత మేము స్కోప్ రిజల్యూషన్ ఆపరేటర్ ఉపయోగించి ప్రధాన తరగతిలో ఫంక్షన్‌ను నిర్వచిస్తున్నాము.

ఉదాహరణ

స్నాప్‌షాట్ నుండి ec2 ఉదాహరణను సృష్టించండి

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి బైక్ {పబ్లిక్: // జస్ట్ ఫంక్షన్ డిక్లరేషన్ శూన్య వేగం ()} // బైక్ క్లాస్ వెలుపల స్పీడ్ ఫంక్షన్‌ను నిర్వచించడం :: శూన్య బైక్ :: స్పీడ్ () out కౌట్<< 'Speed of Bike is 90 KMPH' } int main() { Bike bike bike.Speed() return 0 } 

అవుట్పుట్

సి ++ లో స్కోప్ రిజల్యూషన్ ఆపరేటర్‌పై ఈ కథనంతో కదులుతోంది

తరగతి స్టాటిక్‌ను యాక్సెస్ చేస్తోంది వేరియబుల్స్

మీరు క్లాస్ నేమ్ & స్కోప్ రిజల్యూషన్ ఆపరేటర్ (అనగా క్లాస్_ నేమ్ :: స్టాటిక్_విరియబుల్) ఉపయోగించి క్లాస్ స్టాటిక్ వేరియబుల్ యాక్సెస్ చేయవచ్చు. మీరు ఈ క్రింది ఉదాహరణలో చూడవచ్చు, మేము తరగతిలో స్టాటిక్ వేరియబుల్ అని ప్రకటిస్తున్నాము. మేము స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ను ఉపయోగించి తరగతి వెలుపల వేరియబుల్‌ను నిర్వచిస్తున్నాము. అప్పుడు మేము క్లాస్ నేమ్ & స్కోప్ రిజల్యూషన్ ఆపరేటర్ ఉపయోగించి దీన్ని యాక్సెస్ చేస్తున్నాము.

ఉదాహరణ

# నేమ్‌స్పేస్‌ను ఉపయోగించి చేర్చండి std class ప్రయత్నించండి {static int num1 public: static int num2 // స్థానిక పారామితి తరగతి సభ్యుడిని దాచిపెడుతుంది // తరగతి సభ్యుడిని దీన్ని ఉపయోగించి యాక్సెస్ చేయవచ్చు :: void function (int num1) {// num1 స్టాటిక్ వేరియబుల్ ఉపయోగించి యాక్సెస్ చేయవచ్చు :: // లోకల్ వేరియబుల్ num1 cout యొక్క ప్రేరణ<< 'Static num1: ' << Try::num1 cout << 'nLocal num1: ' << num1 } } // Defining a static members explicitly using :: int Try::num1 = 10 int Try::num2 = 15 int main() { Try o int num1 = 20 o.function(num1) cout << 'nTry::num2 = ' << Try::num2 return 0 } 

అవుట్పుట్

సి ++ లో స్కోప్ రిజల్యూషన్ ఆపరేటర్‌పై ఈ కథనంతో కదులుతోంది

మరొక తరగతి లోపల ఒక తరగతిని సూచిస్తుంది

మీరు రెండు తరగతులలో ఒకే వేరియబుల్ పేర్లతో సమూహ తరగతిని సృష్టించవచ్చు. స్కోప్ రిజల్యూషన్ ఆపరేటర్ ఉపయోగించి మీరు రెండు వేరియబుల్స్ యాక్సెస్ చేయవచ్చు. అంతర్గత తరగతి వేరియబుల్ కోసం, మీరు ఉపయోగించాలి Uter టర్_క్లాస్ :: ఇన్నర్_క్లాస్ :: వేరియబుల్.

ఉదాహరణ

# నేమ్‌స్పేస్‌ను ఉపయోగించి చేర్చండి std class uts ట్సైడ్_క్లాస్ {పబ్లిక్: int num class Inside_class {public: int num static int x}} int Outside_class :: Inside_class :: x = 5 int main () {వెలుపల_క్లాస్ వెలుపల_క్లాస్ :: లోపల_క్లాస్ B}

సి ++ లో స్కోప్ రిజల్యూషన్ ఆపరేటర్‌పై ఈ కథనంతో కదులుతోంది

బహుళ వారసత్వం విషయంలో

మీకు ఒకే వేరియబుల్ పేర్లతో రెండు పేరెంట్ క్లాసులు ఉంటే మరియు మీరు రెండింటినీ చైల్డ్ క్లాస్‌లో వారసత్వంగా పొందుతుంటే, అప్పుడు మీరు వ్యక్తిగత వేరియబుల్స్‌ను యాక్సెస్ చేయడానికి క్లాస్ పేరుతో స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ను ఉపయోగించవచ్చు.

దిగువ ఉదాహరణలో, మేము రెండు పేరెంట్ క్లాస్ పేరెంట్ 1 & పేరెంట్ 2 ను సృష్టిస్తున్నాము మరియు రెండింటిలో వేరియబుల్ నం ఉంది. మేము చైల్డ్ క్లాస్‌లో ఈ రెండింటినీ వారసత్వంగా పొందినప్పుడు, క్లాస్ నేమ్ & స్కోప్ రిజల్యూషన్ ఆపరేటర్ ఉపయోగించి నమ్ వేరియబుల్స్ రెండింటినీ యాక్సెస్ చేయవచ్చు.

ఉదాహరణ

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి పేరెంట్ 1 {రక్షిత: పూర్ణాంకం పబ్లిక్: పేరెంట్ 1 () {సంఖ్య = 100}} తరగతి పేరెంట్ 2 {రక్షిత: పూర్ణాంక సంఖ్య పబ్లిక్: పేరెంట్ 2 () {సంఖ్య = 200}} తరగతి పిల్లవాడు: పబ్లిక్ పేరెంట్ 1, పబ్లిక్ పేరెంట్ 2 { పబ్లిక్: శూన్య ఫంక్షన్ () {కౌట్<< 'Parent1's num is ' << Parent1::num cout << 'nParent2's num is ' << Parent2::num } } int main() { Child obj obj.function() return 0 } 

అవుట్పుట్

సి ++ లో స్కోప్ రిజల్యూషన్ ఆపరేటర్‌పై ఈ కథనంతో కదులుతోంది

నేమ్‌స్పేస్

మనకు రెండు నేమ్‌స్పేస్‌లు ఉన్నాయని అనుకుందాం & రెండూ ఒకే పేరుతో క్లాస్ కలిగి ఉంటాయి. కాబట్టి ఏదైనా సంఘర్షణను నివారించడానికి మేము స్కోప్ రిజల్యూషన్ ఆపరేటర్‌తో నేమ్‌స్పేస్ పేరును ఉపయోగించవచ్చు. దిగువ ఉదాహరణలో మేము ఉపయోగిస్తున్నాము std :: cout .

ఉదాహరణ

# int main () {std :: cout ను చేర్చండి<< 'Hello' << std::endl } 

అవుట్పుట్

ఇప్పుడు పై ప్రోగ్రామ్‌ల ద్వారా వెళ్ళిన తరువాత మీరు C ++ లోని స్కోప్ రిజల్యూషన్ ఆపరేటర్ గురించి ప్రతిదీ అర్థం చేసుకున్నారు. ఈ బ్లాగ్ మీకు సమాచారం మరియు అదనపు విలువను ఇస్తుందని నేను ఆశిస్తున్నాను.

ఇప్పుడు పై ప్రోగ్రామ్‌ను అమలు చేసిన తర్వాత మీరు C ++ లో స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ను అర్థం చేసుకుంటారు. ఈ విధంగా మేము ‘జావాలోని క్విక్‌సోర్ట్’ పై ఈ వ్యాసం చివరకి వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత జావా శిక్షణను చూడండి. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.