ఈ కథనం C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో అస్పష్టమైన ఎర్రర్‌ల గురించి ఆందోళన చెందుతుంది. కంపైలర్ వివిధ పనులలో ఉపయోగించాల్సిన పద్ధతులు లేదా ఆపరేటర్లను గుర్తించలేనప్పుడు అస్పష్టమైన పరిస్థితి కనిపిస్తుంది. కొన్నిసార్లు, మేము ఒకే నేమ్‌స్పేస్‌తో ఒకే పారామీటర్ ఫంక్షన్‌ని ఉపయోగిస్తాము, ఆపై రెండు సందర్భాల్లోనూ కౌట్ నిర్వచించబడుతుంది. మేము ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, కంపైలర్ కౌట్ అస్పష్టమైన లోపాన్ని సృష్టిస్తుంది ఎందుకంటే ఈ కోడ్ ఏ అర్థాన్ని చూపుతుందో కంపైలర్‌కు అర్థం కాలేదు. ప్రోగ్రామ్‌లోని నిర్వచించిన నేమ్‌స్పేస్‌లు లేదా ఫంక్షన్‌ల యొక్క బహుళ డిక్లరేషన్‌ల మధ్య వైరుధ్యం ఏర్పడినప్పుడు కౌట్ అస్పష్టత ఏర్పడుతుంది.
ఉదాహరణ 1:
C++ ప్రోగ్రామింగ్‌లో ఎక్కువగా సంభవించే కౌట్ సందిగ్ధ దోషానికి ఇది ఒక ఉదాహరణ. ఇక్కడ, మనం బహుళ నేమ్‌స్పేస్‌లను ఉపయోగించినప్పుడు కంపైలర్ కౌట్‌లో అస్పష్టమైన లోపాలను ఎలా సృష్టిస్తుందో చూద్దాం. ఈ ఉదాహరణ యొక్క కోడ్ స్నిప్పెట్ కింది వాటిలో పేర్కొనబడింది:
#
నేమ్‌స్పేస్ ల్యాప్టాప్ {
శూన్యం ప్రదర్శన ( ) {
std :: కోట్ << 'ఇది ల్యాప్టాప్ నేమ్‌స్పేస్' << std :: endl ;
}
}
నేమ్‌స్పేస్ మొబైల్ {
శూన్యం ప్రదర్శన ( ) {
std :: కోట్ << 'ఇది మొబైల్ నేమ్‌స్పేస్' << std :: endl ;
}
}
int ప్రధాన ( ) {
ఉపయోగించి నేమ్‌స్పేస్ ల్యాప్టాప్ ;
ఉపయోగించి నేమ్‌స్పేస్ మొబైల్ ;
ప్రదర్శన ( ) ;
తిరిగి 0 ;
}
ఇక్కడ, మన అవసరానికి అనుగుణంగా నిర్వచించబడిన రెండు నేమ్‌స్పేస్‌లతో ప్రోగ్రామ్‌ని తీసుకున్నాము. మేము స్క్రీన్‌పై స్ట్రింగ్‌లను ప్రదర్శించాలనుకుంటున్నాము. ఈ కోడ్ యొక్క అవుట్‌పుట్ కింది వాటిలో జోడించబడింది:
కోడ్ అమలులో, అస్పష్టమైన పరిస్థితి గురించి లోపం ఏర్పడుతుంది. కంపైలర్ కోడ్‌ను చదివినప్పుడు, కంపైలర్ వినియోగదారు ముగింపు నుండి స్పష్టమైన ఇన్‌పుట్‌ను పొందనందున లోపం ఏర్పడింది. మేము మా కోడ్‌లో బహుళ నేమ్‌స్పేస్ డిక్లరేషన్‌లను ఉపయోగించాము. మొత్తం కోడ్‌లో, మేము స్క్రీన్‌పై అవుట్‌పుట్‌ను ప్రదర్శించడానికి మాత్రమే “డిస్‌ప్లే” పద్ధతిని ఉపయోగించాము. ఏ డిస్‌ప్లే మెథడ్ ఏ నేమ్‌స్పేస్‌కు సంబంధించినదో కంపైలర్‌కు తెలియదు. మేము కోడ్‌ను సరళంగా మరియు స్పష్టంగా ఉంచాలి, తద్వారా కోడ్‌ను సందిగ్ధం చేయకుండా కంపైలర్ దశలను సులభంగా అర్థం చేసుకోవచ్చు.
కంపైలర్‌కు మరింత అవగాహన కోసం మెయిన్ ఫంక్షన్‌లో సంబంధిత నేమ్‌స్పేస్‌తో పద్ధతిని పిలవడం ఈ లోపానికి పరిష్కారం. మేము మా ప్రధాన ఎగ్జిక్యూషన్ పోర్షన్‌లో నేమ్‌స్పేస్ యొక్క ఏ పద్ధతిని కాల్ చేయాలనుకుంటున్నామో స్పష్టంగా పేర్కొంటాము.
#నేమ్‌స్పేస్ ల్యాప్టాప్ {
శూన్యం ప్రదర్శన ( ) {
std :: కోట్ << 'ఇది ల్యాప్టాప్ నేమ్‌స్పేస్' << std :: endl ;
}
}
నేమ్‌స్పేస్ మొబైల్ {
శూన్యం ప్రదర్శన ( ) {
std :: కోట్ << 'ఇది మొబైల్ నేమ్‌స్పేస్' << std :: endl ;
}
}
int ప్రధాన ( ) {
ఉపయోగించి నేమ్‌స్పేస్ ల్యాప్టాప్ ;
ఉపయోగించి నేమ్‌స్పేస్ మొబైల్ ;
ల్యాప్టాప్ :: ప్రదర్శన ( ) ;
తిరిగి 0 ;
}
ఇక్కడ, మేము మునుపటి స్క్రీన్‌షాట్‌లో చూసినట్లుగా ప్రధాన ఫంక్షన్‌లోని “ల్యాప్టాప్” నేమ్‌స్పేస్‌తో డిస్‌ప్లే() పద్ధతిని లింక్ చేయవచ్చు. ఇప్పుడు, ప్రోగ్రామ్‌ను అమలు చేయండి. అవుట్‌పుట్ కన్సోల్ విండోలో ప్రదర్శించబడుతుంది.
ఉదాహరణ 2:
ఈ దృశ్యం C++లోని కౌట్ సందిగ్ధ దోషానికి సంబంధించినది. కంపైలర్ ఎగ్జిక్యూషన్ ఫ్లోను అర్థం చేసుకోనప్పుడు లోపాన్ని చూపుతుంది. ఈ ఉదాహరణ యొక్క కోడ్ స్నిప్పెట్ కింది వాటిలో జోడించబడింది:
#నేమ్‌స్పేస్ భాష {
శూన్యం ముద్రణ ( int i ) {
std :: కోట్ << 'సి భాష యొక్క నేమ్‌స్పేస్:' << i << std :: endl ;
}
}
నేమ్‌స్పేస్ జావా {
శూన్యం ముద్రణ ( int జె ) {
std :: కోట్ << 'జావా భాష యొక్క నేమ్‌స్పేస్:' << జె << std :: endl ;
}
}
ఉపయోగించి నేమ్‌స్పేస్ భాష ;
ఉపయోగించి నేమ్‌స్పేస్ జావా ;
int ప్రధాన ( ) {
ముద్రణ ( 5 ) ;
తిరిగి 0 ;
}
ఈ కోడ్‌లో, మేము అవసరమైన అన్ని లైబ్రరీ హెడర్‌లను నిర్వచించాము. మేము వేర్వేరు ప్రయోజనాల కోసం రెండు నేమ్‌స్పేస్‌లను సృష్టిస్తాము. “క్లాంగ్వేజ్” నేమ్‌స్పేస్‌లో, వినియోగదారు నుండి పూర్ణాంక విలువను తీసుకునే “ముద్రణ” పద్ధతిని మేము నిర్వచించాము. “ప్రింట్” ఫంక్షన్‌లో, కన్సోల్ స్క్రీన్‌పై వినియోగదారు పాస్ చేసిన విలువను మేము చూపాలనుకుంటున్నాము. మేము మా కోడ్‌లోని “కౌట్” స్ట్రీమ్‌ని ఉపయోగించి అవసరమైన అవుట్‌పుట్‌ను ప్రదర్శిస్తాము. ఆ తర్వాత, 'జావా' అనే పేరు ఉన్న మరొక నేమ్‌స్పేస్‌ని మేము నిర్వచించాము.
ఈ “జావా” నేమ్‌స్పేస్‌లో, “కౌట్” ఉపయోగించి వినియోగదారు పాస్ చేసే విలువను ప్రదర్శించడానికి మేము మళ్లీ “ప్రింట్” పద్ధతిని ఉపయోగిస్తాము. C++లో కన్సోల్ విండోలో కావలసిన అవుట్‌పుట్‌ను పొందడానికి మా ప్రధాన ఫంక్షన్‌లో ఉపయోగించడం కోసం మేము రెండు నేమ్‌స్పేస్‌లను పిలుస్తాము. “ప్రధాన” ఫంక్షన్‌లో, కన్సోల్ స్క్రీన్‌పై పాస్ చేసిన విలువను చూపించడానికి మేము “ప్రింట్()”ఓవర్‌లోడెడ్ ఫంక్షన్‌ని పిలుస్తాము.
ప్రధాన మెను నుండి 'ఎగ్జిక్యూట్' ఎంపికపై క్లిక్ చేసి, 'కంపైల్ & రన్' ఎంపికను ఎంచుకోండి. ఈ కోడ్ అమలులో అస్పష్టత గురించిన లోపం ఏర్పడింది. లోపం స్క్రీన్ షాట్ క్రింది విధంగా జోడించబడింది:
కంపైలర్ అని పిలువబడే ఓవర్‌లోడ్ చేయబడిన ప్రింట్() ఫంక్షన్ గురించి గందరగోళంగా ఉందని ఈ లోపం సూచిస్తుంది. ఈ ఎర్రర్ లైన్ 19, “ప్రింట్ (5)”లో ఉంది. ఈ ఓవర్‌లోడెడ్ ఫంక్షన్‌కు సంబంధించిన నేమ్‌స్పేస్ గురించి కంపైలర్ గందరగోళంగా ఉంది. ప్రారంభకులు ఎల్లప్పుడూ ఈ రకమైన లోపాలలో ఎక్కువ సమయం చిక్కుకుంటారు.
వాస్తవానికి సంక్లిష్టంగా లేని ఈ లోపాన్ని పరిష్కరిద్దాం. అస్పష్టమైన లోపాలు సులభంగా పరిష్కరించబడతాయి. కంపైలర్ విజిబిలిటీ మరియు అవగాహన కోసం “మెయిన్” ఫంక్షన్‌లో ఓవర్‌లోడ్ చేసిన ఫంక్షన్‌తో పాటు నేమ్‌స్పేస్‌ను తప్పనిసరిగా పేర్కొనాలి. ఈ ప్రోగ్రామ్‌లో వలె, ఈ క్రింది వాటిలో పేర్కొన్న విధంగా మేము ఇప్పటికే ఉన్న మా కోడ్‌లో ఈ “java::print(5)”ని జోడిస్తాము:
#నేమ్‌స్పేస్ భాష {
శూన్యం ముద్రణ ( int i ) {
std :: కోట్ << 'సి భాష యొక్క నేమ్‌స్పేస్:' << i << std :: endl ;
}
}
నేమ్‌స్పేస్ జావా {
శూన్యం ముద్రణ ( int జె ) {
std :: కోట్ << 'జావా భాష యొక్క నేమ్‌స్పేస్:' << జె << std :: endl ;
}
}
ఉపయోగించి నేమ్‌స్పేస్ భాష ;
ఉపయోగించి నేమ్‌స్పేస్ జావా ;
int ప్రధాన ( ) {
జావా :: ముద్రణ ( 5 ) ;
తిరిగి 0 ;
}
ఇప్పుడు, ప్రోగ్రామ్ ఎటువంటి అస్పష్టమైన లోపం లేకుండా సంపూర్ణంగా అమలు చేయబడుతుంది మరియు కన్సోల్ స్క్రీన్‌పై అవుట్‌పుట్‌ను ప్రదర్శిస్తుంది. ఈ ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ క్రింది వాటిలో జోడించబడింది:
ఉదాహరణ 3:
ఇది అస్పష్టమైన సమస్య కారణంగా ఉత్పన్నమయ్యే లోపానికి సంబంధించిన చివరి మరియు చివరి ఉదాహరణ. కంపైలర్ సరైన ఫలితాన్ని పొందలేకపోయింది. ఈ ఉదాహరణ యొక్క కోడ్ స్నిప్పెట్ వినియోగదారు యొక్క మంచి అవగాహన కోసం కింది వాటిలో జోడించబడింది:
ఇక్కడ, మేము అవసరమైన లైబ్రరీలను నిర్వచించాము. ఆ తర్వాత, కన్సోల్ విండోలో స్ట్రింగ్‌ని ప్రదర్శించదలిచిన క్లాస్‌ని కలిగి ఉన్న నేమ్‌స్పేస్‌ను మేము నిర్వచించాము. మేము ఈ నిర్వచించిన నేమ్‌స్పేస్‌ని “ప్రధాన” ఫంక్షన్‌లో “c” వేరియబుల్‌తో పిలుస్తాము. ఆ తర్వాత, మేము నేమ్‌స్పేస్ ఆబ్జెక్ట్‌ని ఉపయోగించి ప్రింట్() పద్ధతిని పిలుస్తాము. మెథడ్ కాల్ తర్వాత మేము స్ట్రింగ్‌ను కన్సోల్ స్క్రీన్‌పై మళ్లీ ప్రదర్శిస్తాము. అవుట్‌పుట్ తప్పనిసరిగా రెండు స్ట్రింగ్‌లుగా ఉండాలి మరియు కన్సోల్ స్క్రీన్‌పై ప్రదర్శించబడుతుంది. మేము ఈ కోడ్‌ని అమలు చేసినప్పుడు, కింది వాటిలో చూపిన విధంగా లోపం సంభవిస్తుంది:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
నేమ్‌స్పేస్ myNamspace {
తరగతి కోట్ {
ప్రజా :
శూన్యం ముద్రణ ( ) {
కోట్ << 'కస్టమ్ కౌట్' << std :: endl ;
}
} ;
}
int ప్రధాన ( ) {
myNamspace :: కోట్ సి ;
సి. ముద్రణ ( ) ;
కోట్ << 'హలో, వరల్డ్!' << std :: endl ;
తిరిగి 0 ;
}
కంపైలర్ కన్సోల్ స్క్రీన్‌పై డేటాను ప్రదర్శించే కౌట్ స్టేట్‌మెంట్‌ను ఎంచుకోలేదు. కంపైలర్ కౌట్ స్టేట్‌మెంట్‌కు చెందిన నేమ్‌స్పేస్‌ను అర్థం చేసుకోలేరు మరియు లోపాన్ని సృష్టిస్తుంది. కంపైలర్ రీడబిలిటీ మరియు అవగాహన కోసం కౌట్ స్టేట్‌మెంట్‌తో నేమ్‌స్పేస్ ఆబ్జెక్ట్‌ను జోడించడం ఈ లోపానికి పరిష్కారం. కౌట్ స్టేట్‌మెంట్‌తో పాటు “std::”ని జోడించి, కోడ్‌ని అమలు చేయండి. కింది అవుట్‌పుట్ కన్సోల్ స్క్రీన్‌పై ప్రదర్శించబడుతుంది:
ముగింపు
ఇక్కడ, కన్సోల్ స్క్రీన్‌పై అవుట్‌పుట్‌ను ప్రదర్శించడం వలన సింటాక్స్ లోపం లేదా తార్కిక లోపం లేని లోపాన్ని కూడా ఉత్పత్తి చేస్తుందని మనం చెప్పగలం. ఎక్కువ సమయం, వినియోగదారు కోడ్ యొక్క మంచి భావాన్ని వ్రాస్తారు, కానీ అది కంపైలర్‌కు అర్థం కాలేదు. కంపైలర్ ఇన్‌పుట్ గురించి అస్పష్టంగా ఉంది. కాబట్టి, C++ ప్రోగ్రామింగ్ భాషలో లోపాలను నివారించడానికి సరైన నేమ్‌స్పేసింగ్ మరియు సింటాక్స్‌తో ప్రతి కోడ్ దశను స్పష్టం చేయండి. ఈ సమస్యను పరిష్కరించడంలో పాల్గొనే దశలు స్పష్టమైన క్వాలిఫైయర్‌లను ఉపయోగించడం, నేమ్‌స్పేస్ ఘర్షణలను నిరోధించడం మరియు ఉద్దేశించిన విధులు లేదా వస్తువులు ఈ సమస్యను పరిష్కరించడంలో ఉన్న దశలను గుర్తించాయని నిర్ధారించడం.