C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లోని వేరియబుల్స్ C++ ప్రోగ్రామ్‌లోని వేరియబుల్స్‌ను మార్చడంలో ముఖ్యమైన పాత్రను పోషించే డేటాను నిర్వహించడానికి మరియు నిర్వహించడానికి ప్రాథమిక బిల్డింగ్ బ్లాక్‌లుగా పనిచేస్తాయి. C++ ప్రోగ్రామింగ్ లాంగ్వేజ్ స్టాటిక్ గ్లోబల్ వేరియబుల్స్‌ని ఉపయోగించి వివిధ స్కోప్‌లు మరియు కంపైలేషన్ యూనిట్‌లలో వేరియబుల్ విజిబిలిటీని నిర్వహించడానికి బలమైన మార్గాన్ని అందిస్తుంది. గ్లోబల్ స్కోప్ వద్ద ప్రకటించబడిన స్టాటిక్ గ్లోబల్ వేరియబుల్ 'స్టాటిక్' స్పెసిఫైయర్ కారణంగా నిర్వచించబడిన ఫైల్‌కు పరిమితం చేయబడింది. 'స్టాటిక్' కీవర్డ్ ఆ ఫైల్‌లోని ఫంక్షన్ కాల్‌ల అంతటా వేరియబుల్ దాని విలువను కలిగి ఉందని నిర్ధారిస్తుంది, అయితే ఇతర ఫైల్‌లకు ప్రాప్యత చేయలేని మరియు కనిపించకుండా ఉంటుంది. ప్రోగ్రామ్ స్థితిని నిర్వహించడంలో C++లోని స్టాటిక్ గ్లోబల్ వేరియబుల్స్ కీలకం. ఈ కథనం స్టాటిక్ గ్లోబల్ వేరియబుల్స్ యొక్క చిక్కులను విశ్లేషిస్తుంది, వాటి లక్షణాలు, వినియోగ సందర్భాలు మరియు సంభావ్య సవాళ్లను హైలైట్ చేస్తుంది.
C++లో స్టాటిక్ వేరియబుల్స్
C++లో, గ్లోబల్, లోకల్, నేమ్‌స్పేస్ లేదా క్లాస్‌లతో సహా వివిధ స్కోప్‌లలో స్టాటిక్ వేరియబుల్ ఇన్‌స్టాంటియేట్ చేయబడుతుంది. దాని ఉనికి మొత్తం ప్రోగ్రామ్ రన్‌టైమ్ ప్రారంభం నుండి ముగింపు వరకు విస్తరించి ఉంటుంది, దాని కేటాయింపు అంతటా నిర్వహించబడుతుందని నిర్ధారిస్తుంది. సరళంగా చెప్పాలంటే, ప్రోగ్రామ్ ప్రారంభంలో మెమరీ ఈ వేరియబుల్స్‌కు కేటాయించబడుతుంది మరియు ప్రోగ్రామ్ ఎగ్జిక్యూషన్ ముగిసినప్పుడు డీలోకేట్ చేయబడుతుంది. స్టాటిక్‌ను వేరియబుల్‌తో ఉపయోగించినప్పుడు, ఇది అనుసంధానం పరంగా వేరియబుల్ యొక్క దృశ్యమానతను పరిమితం చేస్తుంది మరియు అది ప్రకటించబడిన ప్రోగ్రామ్‌కు మాత్రమే అందుబాటులో ఉంటుంది.
C++లో స్టాటిక్ వేరియబుల్స్ అప్లికేషన్స్
స్టాటిక్ గ్లోబల్ వేరియబుల్ నిర్వచించే ఫైల్‌కు మాత్రమే సంబంధించిన స్థితి లేదా కాన్ఫిగరేషన్‌ను నిర్వహించడానికి నియంత్రిత యంత్రాంగాన్ని అందిస్తుంది. స్టాటిక్ గ్లోబల్ వేరియబుల్స్ ద్వారా విధించబడిన ఫైల్ స్కోప్ భావన బాహ్య అనుసంధానం నుండి అవాంఛిత దుష్ప్రభావాలను నిరోధించడం ద్వారా క్లీనర్ మాడ్యులర్ ప్రోగ్రామింగ్‌ను సులభతరం చేస్తుంది, తద్వారా మరింత నిర్వహించదగిన మరియు దోష-నిరోధక కోడ్‌కి దారి తీస్తుంది. స్టాటిక్ వేరియబుల్ వివిధ దృశ్యాలలో ఉపయోగించబడుతుంది మరియు అవి క్రింది వాటిలో జాబితా చేయబడ్డాయి:
దృశ్యం 1: బహుళ ఫంక్షన్లలో కౌంటర్
ఒక ఫంక్షన్ లోపల స్టాటిక్ కీవర్డ్‌తో వేరియబుల్ డిక్లేర్ చేయబడినప్పుడు, అదే ఫంక్షన్‌కు బహుళ కాల్‌లలో దాని స్థితిని భద్రపరుస్తుంది. వేరియబుల్ యొక్క స్థితిని నిర్వహించగల ఈ సామర్థ్యం నిర్దిష్ట పరిస్థితులలో ప్రయోజనకరంగా ఉంటుంది. C++ స్టాటిక్ గ్లోబల్ వేరియబుల్‌ని ఉపయోగించి బహుళ ఫంక్షన్లలో కౌంటర్‌ని అర్థం చేసుకోవడానికి ఒక ఉదాహరణను చూద్దాం. ఉదాహరణ కోడ్ క్రింది విధంగా ఇవ్వబడింది:
#
తరగతి కౌంటర్ {
ప్రైవేట్:
స్టాటిక్ పూర్ణాంక గ్లోబల్ కౌంటర్;
ప్రజా:
శూన్యమైన ఇంక్రిమెంట్ కౌంటర్ ( ) {
++గ్లోబల్ కౌంటర్;
}
int getCounterValue ( ) స్థిరంగా {
తిరిగి గ్లోబల్ కౌంటర్;
}
} ;
int కౌంటర్ ::globalCounter = 0 ;
పూర్ణాంక ప్రధాన ( ) {
కౌంటర్ కౌంటర్;
కోసం ( int i = 0 ; i < 5 ; ++i ) {
కౌంటర్.incrementCounter ( ) ;
}
int counterValue = counter.getCounterValue ( ) ;
std::cout << 'కౌంటర్ విలువ:' << ప్రతివిలువ << std::endl;
తిరిగి 0 ;
}
ఈ కోడ్ రెండు ఫంక్షన్‌లతో కూడిన సాధారణ “కౌంటర్” క్లాస్‌ని నిర్వచిస్తుంది: “ఇంక్రిమెంట్‌కౌంటర్” ఇది గ్లోబల్ కౌంటర్‌ను 1కి పెంచుతుంది మరియు గ్లోబల్ కౌంటర్ యొక్క ప్రస్తుత విలువను అందించే “getCounterValue”. 'కౌంటర్' తరగతిని ఎలా ఉపయోగించాలో వివరించే ప్రధాన విధిని కూడా కోడ్ కలిగి ఉంటుంది. ఇది 'కౌంటర్' ఆబ్జెక్ట్‌ను సృష్టిస్తుంది, కౌంటర్‌ను ఐదుసార్లు పెంచుతుంది, దాని విలువను తిరిగి పొందుతుంది మరియు దానిని కన్సోల్‌కు ప్రింట్ చేస్తుంది. ఈ అమలు అన్ని 'కౌంటర్' ఆబ్జెక్ట్‌ల ద్వారా భాగస్వామ్యం చేయబడిన ఒకే గ్లోబల్ కౌంటర్‌ను ఉపయోగిస్తుంది. ఇది సరళమైనది మరియు అర్థం చేసుకోవడం సులభం, కానీ మీకు బహుళ స్వతంత్ర కౌంటర్లు అవసరమయ్యే పరిస్థితులకు ఇది సరిపోకపోవచ్చు. ప్రోగ్రామ్ యొక్క క్రింది అవుట్‌పుట్‌ను చూడండి:
ఈ ఉదాహరణలో, 'గ్లోబల్‌కౌంటర్' స్టాటిక్ వేరియబుల్ 'ఇంక్రిమెంట్‌కౌంటర్' మరియు 'గెట్‌కౌంటర్‌వాల్యూ' వంటి ఫంక్షన్‌లకు కాల్‌ల మధ్య తన స్థితిని కలిగి ఉందని మీరు గమనించవచ్చు, ఇది ఒకే ఫైల్‌లోని బహుళ ఫంక్షన్లలో నిరంతర కౌంటర్‌గా పనిచేస్తుంది.
దృష్టాంతం 2: యుటిలిటీ ఫంక్షన్ ఇన్‌స్టాన్స్‌లలో షేర్ చేయబడింది
క్లాస్‌లోని మెంబర్ ఫంక్షన్ స్టాటిక్‌గా నిర్వచించబడినప్పుడు, అది అన్ని క్లాస్ ఇన్‌స్టాన్స్‌లకు అందుబాటులో ఉంటుంది. అయినప్పటికీ, దానికి పాయింటర్ లేనందున ఇది ఒక ఉదాహరణ సభ్యుని యాక్సెస్ చేయదు. ఈ దృష్టాంతాన్ని బాగా అర్థం చేసుకోవడానికి కింది సంబంధిత ఉదాహరణను పరిశీలిద్దాం:
#తరగతి యుటిలిటీ క్లాస్ {
ప్రజా:
స్టాటిక్ శూన్యం యుటిలిటీ ఫంక్షన్ ( ) {
std::cout << 'యుటిలిటీ ఫంక్షన్ అంటారు.' << std::endl;
}
} ;
తరగతి MyClass {
ప్రజా:
కాల్ యుటిలిటీ ఫంక్షన్ శూన్యం ( ) {
యుటిలిటీ క్లాస్:: యుటిలిటీ ఫంక్షన్ ( ) ;
}
} ;
పూర్ణాంక ప్రధాన ( ) {
MyClass వస్తువు;
obj.callUtilityFunction ( ) ;
తిరిగి 0 ;
}
ఈ కోడ్ రెండు తరగతులను నిర్వచిస్తుంది: 'యుటిలిటీ క్లాస్' మరియు 'మైక్లాస్'. “యుటిలిటీక్లాస్” “యుటిలిటీ ఫంక్షన్” అనే పబ్లిక్ స్టాటిక్ ఫంక్షన్‌ను కలిగి ఉంది, అది కన్సోల్‌కు 'యుటిలిటీ ఫంక్షన్ అంటారు' అని ప్రింట్ చేస్తుంది. 'MyClass'కి 'callUtilityFunction' అనే పబ్లిక్ ఫంక్షన్ ఉంది, అది 'UtilityClass' యొక్క 'utilityFunction' ఫంక్షన్‌ని పిలుస్తుంది.
ప్రధాన విధి 'obj' అని పిలువబడే 'MyClass' యొక్క వస్తువును సృష్టిస్తుంది. ఇది 'obj' ఆబ్జెక్ట్ యొక్క 'callUtilityFunction' ఫంక్షన్‌ని పిలుస్తుంది. ఇది 'యుటిలిటీ క్లాస్' యొక్క 'యుటిలిటీ ఫంక్షన్' ఫంక్షన్‌ని పిలుస్తుంది, ఇది కన్సోల్‌కు 'యుటిలిటీ ఫంక్షన్ ఈజ్ కాల్' అని ప్రింట్ చేస్తుంది. కోడ్ యొక్క క్రింది అవుట్‌పుట్‌ను చూడండి:
ఈ విధానం ప్రత్యేక వస్తువుల అవసరాన్ని తొలగిస్తుంది మరియు కోడ్ నిర్మాణాన్ని సులభతరం చేస్తుంది. 'యుటిలిటీఫంక్షన్'ని యాక్సెస్ చేయడానికి తరగతి రెండు మార్గాలను అందిస్తుంది. ఒక మార్గం నేరుగా యుటిలిటీ క్లాస్ :: యుటిలిటీఫంక్షన్ () సింటాక్స్‌ని ఉపయోగించడం, ఇది వస్తువును సృష్టించకుండానే యాక్సెస్ చేయగలదు. ఇతర మార్గం obj.callUtilityFunction() మెంబర్ ఫంక్షన్‌ని ఉపయోగించే వస్తువు ద్వారా, ఇది తరగతిలో మరింత సందర్భం మరియు సంభావ్య అదనపు కార్యాచరణను అనుమతిస్తుంది. యుటిలిటీ ఫంక్షన్ కోసం మీరు కోరుకున్న వినియోగ నమూనాపై ఆధారపడి ఈ విధానం సరళత మరియు వశ్యతను సమతుల్యం చేస్తుంది.
దృశ్యం 3: స్టాటిక్ గ్లోబల్ వేరియబుల్‌లో క్లాస్ స్కోప్
తరగతి ఉదంతాల సంఖ్యతో సంబంధం లేకుండా, తరగతిలో స్టాటిక్‌గా ప్రకటించబడిన సభ్యుడు ఒక కాపీలో మాత్రమే ఉంటాడు. ఇది డేటా సభ్యులు (వేరియబుల్స్) మరియు మెంబర్ ఫంక్షన్‌లు రెండింటికీ వర్తిస్తుంది. ముఖ్యంగా, స్టాటిక్ డేటా మెంబర్ యొక్క నిర్వచనం తప్పనిసరిగా క్లాస్ డిక్లరేషన్ వెలుపల జరగాలి, సాధారణంగా ఫైల్ స్కోప్ వద్ద.
C++లో డేటా మెంబర్ మరియు మెంబర్ ఫంక్షన్ రెండింటికీ వర్తించే స్టాటిక్ ఉదాహరణ ఇక్కడ ఉంది:
#తరగతి కౌంటర్ {
ప్రజా:
స్టాటిక్ int గ్లోబల్‌కౌంట్;
కౌంటర్ ( ) {
++గ్లోబల్ కౌంట్;
}
స్టాటిక్ శూన్య ప్రింట్ గ్లోబల్ కౌంట్ ( ) {
std::cout << 'గ్లోబల్ కౌంట్:' << ప్రపంచ గణన << std::endl;
}
} ;
int కౌంటర్ ::globalCount = 0 ;
పూర్ణాంక ప్రధాన ( ) {
కౌంటర్ కౌంటర్ 1;
కౌంటర్ కౌంటర్2;
కౌంటర్::printGlobalCount ( ) ;
తిరిగి 0 ;
}
కోడ్ “గ్లోబల్‌కౌంట్” అనే ప్రైవేట్ స్టాటిక్ మెంబర్ వేరియబుల్ మరియు ఇద్దరు పబ్లిక్ మెంబర్ ఫంక్షన్‌లతో “కౌంటర్” అనే క్లాస్‌ని నిర్వచిస్తుంది. ఒకటి కౌంటర్() ఇది “గ్లోబల్‌కౌంట్” వేరియబుల్‌ను పెంచే కన్‌స్ట్రక్టర్ ఫంక్షన్. మరొకటి 'printGlobalCount', ఇది 'globalCount' వేరియబుల్ యొక్క ప్రస్తుత విలువను అందిస్తుంది. కోడ్ ఒక ప్రధాన విధిని కూడా కలిగి ఉంటుంది. ఈ ఫంక్షన్ 'కౌంటర్' క్లాస్ యొక్క రెండు ఆబ్జెక్ట్‌లను సృష్టిస్తుంది, అవి 'కౌంటర్1' మరియు 'కౌంటర్2' పేర్లతో గుర్తించబడతాయి. వేరియబుల్ డిక్లరేషన్ తర్వాత, ఇది 'Counter::printGlobalCount' ఫంక్షన్‌ని పిలుస్తుంది, ఇది బహుశా 'globalCount' వేరియబుల్ యొక్క ప్రస్తుత విలువను ప్రింట్ చేస్తుంది. కింది అవుట్‌పుట్ స్నిప్పెట్‌ని చూడండి:
ఈ ఉదాహరణలో, 'కౌంటర్' క్లాస్ లోపల 'గ్లోబల్ కౌంట్' వేరియబుల్ స్టాటిక్ డేటా మెంబర్‌గా ప్రకటించబడింది. ఎన్ని 'కౌంటర్' ఆబ్జెక్ట్‌లు సృష్టించబడినా, ఈ వేరియబుల్ యొక్క ఒక కాపీ మాత్రమే ఉందని దీని అర్థం. కౌంటర్()కన్‌స్ట్రక్టర్ ప్రతి సందర్భానికి 'గ్లోబల్ కౌంట్'ని పెంచుతుంది, వస్తువులు అంతటా దాని భాగస్వామ్య స్వభావాన్ని ప్రదర్శిస్తుంది. 'printGlobalCount' అనేది స్టాటిక్ మెంబర్ ఫంక్షన్. గుర్తుంచుకోండి, ఇది నేరుగా తరగతి పేరును ఉపయోగించి చేయబడుతుంది (కౌంటర్::printGlobalCount). 'కౌంటర్' క్లాస్ యొక్క అన్ని సందర్భాలలో భాగస్వామ్య స్థితిని ప్రతిబింబిస్తూ, ఊహించిన విధంగా 'గ్లోబల్ కౌంట్' పెరిగినట్లు అవుట్‌పుట్ చూపిస్తుంది.
ముగింపు
ముగింపులో, C++లోని స్టాటిక్ గ్లోబల్ వేరియబుల్స్ ఫంక్షన్‌లు మరియు ఫైల్‌లలో స్థితిని నిర్వహించడానికి ఒక బహుముఖ సాధనంగా ఉద్భవించాయి. వారి అంతర్గత అనుసంధానం, నిరంతర స్వభావం మరియు నియంత్రిత సమాచార భాగస్వామ్యం కొన్ని ప్రోగ్రామింగ్ దృశ్యాలలో వాటిని విలువైన ఆస్తులుగా చేస్తాయి. వారి లక్షణాలను అర్థం చేసుకోవడం ద్వారా, విభిన్న వినియోగ సందర్భాలను అన్వేషించడం మరియు సంభావ్య ఆపదలను గుర్తించడం ద్వారా, డెవలపర్‌లు స్టాటిక్ గ్లోబల్ వేరియబుల్స్‌ను సమర్థవంతంగా ఉపయోగించగలరు, కోడ్ మాడ్యులారిటీని మెరుగుపరుస్తారు మరియు వారి ప్రాజెక్ట్‌లలోని వివిధ భాగాల మధ్య కమ్యూనికేషన్‌ను సులభతరం చేయవచ్చు. ఆలోచనాత్మక పరిశీలన మరియు ఉత్తమ అభ్యాసాలకు కట్టుబడి ఉండటం ద్వారా, C++ ప్రోగ్రామ్‌ల రూపకల్పన మరియు కార్యాచరణకు సానుకూలంగా సహకరించడానికి స్టాటిక్ గ్లోబల్ వేరియబుల్స్ ఉపయోగించబడతాయి.