మీరు డేటాబేస్ కనెక్షన్, లాగర్ లేదా కాన్ఫిగరేషన్ మేనేజర్ వంటి ప్రపంచవ్యాప్తంగా యాక్సెస్ చేయవలసిన ఏకైక, భాగస్వామ్య వనరును కలిగి ఉండవలసి వచ్చినప్పుడు సింగిల్టన్ నమూనా సాధారణంగా ఉపయోగించబడుతుంది. ఒకే ఉదాహరణను అమలు చేయడం ద్వారా, ఇది ప్రోగ్రామ్‌లోని బహుళ భాగాలను ఒకే వస్తువును యాక్సెస్ చేయడానికి మరియు సవరించడానికి అనుమతిస్తుంది, డేటా స్థిరత్వాన్ని ప్రోత్సహిస్తుంది మరియు గ్లోబల్ వేరియబుల్స్ అవసరాన్ని తగ్గిస్తుంది. సింగిల్‌టన్‌ను ఆబ్జెక్ట్ కాష్‌గా ఉపయోగించవచ్చు, ఇక్కడ తరచుగా ఉపయోగించే లేదా ఖరీదైన-సృష్టించే వస్తువులు అప్లికేషన్ అంతటా నిల్వ చేయబడతాయి మరియు తిరిగి ఉపయోగించబడతాయి. ఈ విధానం అనవసరమైన ఆబ్జెక్ట్ సృష్టి మరియు ప్రారంభాన్ని నివారించడం ద్వారా పనితీరును మెరుగుపరచడంలో సహాయపడుతుంది.
ఈ కథనంలో, మేము సింగిల్టన్ యొక్క సృష్టిని వివరిస్తాము మరియు C++ ప్రోగ్రామ్‌లో సింగిల్‌టన్‌ను స్టైలైజ్ చేసే ఉదాహరణను ప్రదర్శిస్తాము.
ఉదాహరణ 1: ఈగర్ ఇనిషియలైజేషన్‌తో సింపుల్ సింగిల్‌టన్‌ని క్రియేట్ చేయడం
ప్రారంభ ప్రారంభతతో కూడిన ఒక సాధారణ సింగిల్టన్ అనేది తరగతి యొక్క ఒక ఉదాహరణ మాత్రమే సృష్టించబడిందని నిర్ధారిస్తుంది మరియు ఇది స్టాటిక్ ఇనిషియలైజేషన్ సమయంలో ఆసక్తిగా సృష్టించబడుతుంది.
మేము ఆసక్తితో ప్రారంభించడంతోపాటు సాధారణ సింగిల్‌టన్‌ని సృష్టించడం కోసం ప్రాథమిక కోడ్ స్నిప్పెట్‌ను ప్రదర్శిస్తాము. ప్రోగ్రామ్‌తో ప్రారంభిద్దాం:
#
తరగతి సింగిల్టన్ {
ప్రైవేట్ :
స్థిరమైన సింగిల్టన్ * ఉదాహరణ ;
సింగిల్టన్ ( ) { }
ప్రజా :
స్థిరమైన సింగిల్టన్ * getInstance ( ) {
తిరిగి ఉదాహరణ ;
}
} ;
సింగిల్టన్ * సింగిల్టన్ :: ఉదాహరణ = కొత్త సింగిల్టన్ ( ) ;
int ప్రధాన ( ) {
సింగిల్టన్ * సింగిల్టన్ఇన్‌స్టాన్స్1 = సింగిల్టన్ :: getInstance ( ) ;
సింగిల్టన్ * singletonInstance2 = సింగిల్టన్ :: getInstance ( ) ;
std :: కోట్ << 'singletonletonInstance1:' << సింగిల్టన్ఇన్‌స్టాన్స్1 << std :: endl ;
std :: కోట్ << 'singletonletonInstance2:' << singletonInstance2 << std :: endl ;
తిరిగి 0 ;
}
కోడ్
హెడర్ ఫైల్‌ని చేర్చిన తర్వాత, సింగిల్టన్ నమూనా అమలును సూచించే 'సింగిల్టన్' క్లాస్‌ని మేము నిర్వచించాము. ఇది ఒక ప్రైవేట్ కన్స్ట్రక్టర్ మరియు 'ఇన్‌స్టాన్స్' అనే ప్రైవేట్ స్టాటిక్ మెంబర్ వేరియబుల్‌ను కలిగి ఉంది.
అప్పుడు, getInstance() ఫంక్షన్ 'Singleton' క్లాస్ యొక్క పబ్లిక్ స్టాటిక్ మెంబర్ ఫంక్షన్‌గా అమలు చేయబడుతుంది. ఇది స్టాటిక్ మెంబర్ వేరియబుల్ ఇన్‌స్టాన్స్‌లో నిల్వ చేయబడిన సింగిల్టన్ ఉదాహరణను అందిస్తుంది. 'Singleton* Singleton::instance = new Singleton();'తో స్టాటిక్ మెంబర్ వేరియబుల్ ఇన్‌స్టాన్స్ నిర్వచించబడింది మరియు క్లాస్ వెలుపల ప్రారంభించబడింది. ఈ పంక్తి స్టాటిక్ ఇనిషియలైజేషన్ సమయంలో 'సింగిల్టన్' క్లాస్ యొక్క ఉదాహరణను ఆసక్తిగా ప్రారంభిస్తుంది.
ప్రధాన() ఫంక్షన్‌లో, మేము “singletonInstance1” మరియు “singletonInstance2” అనే రెండు పాయింటర్‌లను ప్రకటిస్తాము మరియు Singleton ::getInstance()కి కాల్ చేయడం ద్వారా తిరిగి వచ్చే విలువను కేటాయిస్తాము. ఉదాహరణ ఆత్రంగా ప్రారంభించబడినందున, రెండు పాయింటర్‌లు ఒకే ఉదాహరణను సూచిస్తాయి. “std::cout” స్టేట్‌మెంట్‌లు “singletonInstance1” మరియు “singletonInstance2” యొక్క మెమరీ చిరునామాలను “<<” ఆపరేటర్ మరియు “std::endl” ఉపయోగించి కన్సోల్‌కు ప్రింట్ చేస్తాయి.
కోడ్ విజయవంతమైన ప్రోగ్రామ్ అమలును సూచించే 'రిటర్న్ 0'తో ముగుస్తుంది.
మీరు ఈ కోడ్‌ని అమలు చేసినప్పుడు, అవుట్‌పుట్ ఇలా ఉంటుంది:
అవుట్‌పుట్ 'singletonInstance1' మరియు 'singletonInstance2' యొక్క మెమరీ చిరునామాలను ప్రదర్శిస్తుంది. Singleton ::getInstance() నుండి పొందిన ఒకే ఉదాహరణతో రెండు పాయింటర్‌లు కేటాయించబడినందున, వాటికి ఒకే మెమరీ చిరునామా ఉంటుంది. సింగిల్టన్ నమూనా తరగతికి ఒకే ఉదాహరణ ఉందని మరియు getInstance()కి భవిష్యత్తులో చేసే కాల్‌లు ఎల్లప్పుడూ అదే సందర్భంలో ఫలితాన్ని ఇస్తాయని ఇది చూపిస్తుంది.
ఉదాహరణ 2: లేజీ ఇనిషియలైజేషన్‌తో సింగిల్టన్ ప్యాటర్న్ ఇంప్లిమెంటేషన్
ఈ ప్రదర్శన సోమరి ప్రారంభతతో సింగిల్టన్ నమూనా అమలును వివరిస్తుంది మరియు ప్రధాన() ఫంక్షన్‌లో దాని వినియోగాన్ని చూపుతుంది. కోడ్ స్నిప్పెట్ యొక్క దశల వారీ వివరణ ఈ ప్రోగ్రామ్ తర్వాత అందించబడుతుంది:
#includeతరగతి సింగిల్టన్ {
ప్రైవేట్ :
స్థిరమైన సింగిల్టన్ * ఉదాహరణ ;
సింగిల్టన్ ( ) {
std :: కోట్ << 'సింగిల్టన్ ఉదాహరణ సృష్టించబడింది.' << std :: endl ;
}
ప్రజా :
స్థిరమైన సింగిల్టన్ * getInstance ( ) {
ఉంటే ( ఉదాహరణ == nullptr ) {
ఉదాహరణ = కొత్త సింగిల్టన్ ( ) ;
}
తిరిగి ఉదాహరణ ;
}
శూన్యం సందేశాన్ని చూపు ( ) {
std :: కోట్ << 'సింగిల్టన్ నుండి హలో!' << std :: endl ;
}
~ సింగిల్టన్ ( ) {
std :: కోట్ << 'సింగిల్టన్ ఉదాహరణ నాశనం చేయబడింది.' << std :: endl ;
}
} ;
సింగిల్టన్ * సింగిల్టన్ :: ఉదాహరణ = nullptr ;
int ప్రధాన ( ) {
సింగిల్టన్ * సింగిల్టన్ఇన్‌స్టాన్స్1 = సింగిల్టన్ :: getInstance ( ) ;
సింగిల్టన్ఇన్‌స్టాన్స్1 -> సందేశాన్ని చూపు ( ) ;
సింగిల్టన్ * singletonInstance2 = సింగిల్టన్ :: getInstance ( ) ;
singletonInstance2 -> సందేశాన్ని చూపు ( ) ;
తిరిగి 0 ;
}
ఇన్‌పుట్/అవుట్‌పుట్ టాస్క్‌లను నిర్వహించడానికి
'సింగిల్టన్' క్లాస్ యొక్క కన్‌స్ట్రక్టర్‌ని పిలిచినప్పుడల్లా, అది 'సింగిల్టన్' క్లాస్ యొక్క ఉదాహరణను ఉత్పత్తి చేస్తుంది. ఇది “std::cout << … << std::endl;”ని ఉపయోగించి కన్సోల్‌కు “Singleton instance Created” సందేశాన్ని అవుట్‌పుట్ చేస్తుంది. ఇది డిఫాల్ట్ కన్స్ట్రక్టర్ అయినందున కన్‌స్ట్రక్టర్‌కు ఎలాంటి పారామీటర్‌లు లేవు. ఇది ఎటువంటి వాదనలు లేకుండా సింగిల్టన్()గా నిర్వచించబడింది. మేము దానిని ప్రైవేట్‌గా ప్రకటిస్తాము అంటే ఇది తరగతి లోపల నుండి మాత్రమే ప్రారంభించబడుతుంది. ఇది 'సింగిల్టన్' క్లాస్ యొక్క ప్రత్యక్ష ఇన్‌స్టంటేషన్‌ను నిరోధిస్తుంది మరియు ఒక ఉదాహరణను పొందేందుకు ఏకైక మార్గం getInstance() ఫంక్షన్ ద్వారా మాత్రమే అని నిర్ధారిస్తుంది.
'Singleton' తరగతి getInstance() పద్ధతి పబ్లిక్ స్టాటిక్ మెంబర్ ఫంక్షన్‌గా ప్రకటించబడింది. ఇది సింగిల్టన్ ఉదాహరణకి యాక్సెసిబిలిటీని స్థాపించడం మరియు మంజూరు చేయడం పాత్రలో ఉంది. getInstance() లోపల, ఇది ఉదాహరణ “nullptr” కాదా అని తనిఖీ చేస్తుంది. ఒకవేళ, ఆ సందర్భం ఇప్పటికే లేదని సూచిస్తూ, “సింగిల్టన్” క్లాస్‌లోని కొత్త వస్తువును ఇన్‌స్టాంటియేట్ చేయడానికి ప్రైవేట్ కన్‌స్ట్రక్టర్‌ని ఉపయోగిస్తుంది.
ShowMessage() ఫంక్షన్ అనేది 'హలో ఫ్రమ్ సింగిల్టన్!'ని ప్రదర్శించే ఒక సాధారణ మెంబర్ ఫంక్షన్. సందేశం. సింగిల్టన్ యొక్క డిస్ట్రక్టర్ నిర్వచించబడింది. ప్రోగ్రామ్ ముగించబడినప్పుడు మరియు 'సింగిల్టన్ ఇన్‌స్టాన్స్ నాశనం' అని ప్రింట్ చేసినప్పుడు ఇది పరోక్షంగా పిలువబడుతుంది. సింగిల్టన్ ఉదాహరణ నాశనం చేయబడిందని సూచించే సందేశం. స్టాటిక్ మెంబర్ వేరియబుల్ ఇన్‌స్టాన్స్ మొదట్లో “nullptr”గా నిర్వచించబడింది.
Int main() ప్రధాన() ఫంక్షన్ యొక్క నిర్వచనాన్ని ప్రారంభిస్తుంది. తర్వాత, “Singleton* singletonInstance1 = Singleton::getInstance();” సింగిల్టన్ ఉదాహరణకి పాయింటర్‌ని పొందేందుకు 'సింగిల్టన్' క్లాస్ యొక్క getInstance() ఫంక్షన్‌ని పిలుస్తుంది. ఇది ఈ పాయింటర్‌ను “singletonInstance1” వేరియబుల్‌కు కేటాయిస్తుంది.
ఆ తర్వాత, “singletonInstance1->showMessage();” 'singletonInstance1' పాయింటర్‌లో showMessage() ఫంక్షన్‌ని కాల్ చేయడానికి బాణం ఆపరేటర్ (->)ని ఉపయోగిస్తుంది. ఈ ఫంక్షన్ కన్సోల్‌లో పేర్కొన్న సందేశాన్ని ప్రదర్శిస్తుంది. తర్వాత, “Singleton* singletonInstance2 = Singleton::getInstance();” గెట్‌ఇన్‌స్టాన్స్() ఫంక్షన్‌ని మళ్లీ పిలుస్తుంది, సింగిల్టన్ ఇన్‌స్టాన్స్‌కు మరొక పాయింటర్‌ను పొందుతుంది. ఈసారి, ఇది “singletonInstance2” వేరియబుల్‌కు పాయింటర్‌ను కేటాయిస్తుంది. “singletonInstance2->showMessage();” 'singletonInstance2' పాయింటర్‌పై showMessage() ఫంక్షన్‌ని పిలుస్తుంది. ఈ ఫంక్షన్ 'సింగిల్టన్ నుండి హలో!' కన్సోల్‌కు మళ్లీ సందేశం పంపండి.
చివరగా, 'రిటర్న్ 0;' మెయిన్() ఫంక్షన్ ముగింపును సూచిస్తుంది మరియు ప్రోగ్రామ్ విజయవంతమైన ప్రోగ్రామ్ ఎగ్జిక్యూషన్‌ను సూచించే 0 విలువను అందిస్తుంది.
మునుపు వివరించిన కోడ్ స్నిప్పెట్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది:
ఈ ఫలితం 'సింగిల్టన్' క్లాస్ కేవలం ఒక ఉదాహరణ యొక్క సృష్టికి హామీ ఇస్తుందని మరియు getInstance() ఫంక్షన్‌కి తదుపరి కాల్‌లు అదే ఉదాహరణను విశ్వసనీయంగా అందజేస్తాయని నిర్ధారిస్తుంది.
ముగింపు
C++లో సింగిల్‌టన్‌ని సృష్టించడం చాలా ఉపయోగకరమైన భావన. ఈ పోస్ట్‌లో, మేము మొదట సింగిల్టన్ పరిచయ విభాగాన్ని కవర్ చేసాము. ఇంకా, C++లో సింగిల్‌టన్‌ను అమలు చేయడానికి రెండు ఉదాహరణలు రూపొందించబడ్డాయి. మొదటి దృష్టాంతం ఆసక్తిగల సింగిల్టన్ ఇనిషియలైజేషన్ అమలును చూపుతుంది. అయితే సింగిల్టన్ నమూనా యొక్క సోమరి ప్రారంభ అమలు ఈ కథనం యొక్క రెండవ ఉదాహరణలో అందించబడింది. అంతేకాకుండా, ఉత్పత్తి చేయబడిన అవుట్‌పుట్ యొక్క స్నాప్‌షాట్‌లు సంబంధిత ప్రోగ్రామ్‌ల కోసం కూడా ప్రదర్శించబడతాయి.