లోపాలు అంటే ఏదైనా కోడ్ యొక్క అసాధారణ పని ఫలితంగా సంభవించే కార్యకలాపాలు. మేము కోడ్ను అమలు చేసే వరకు లేదా అది కంపైల్ చేయబడే వరకు వ్రాసే సమయంలో లోపం కనుగొనబడదు. కొన్ని లోపాలు తొలగించబడే వరకు కోడ్‌ని అమలు చేయకుండా నిషేధిస్తాయి. ఈ రోజు, ప్రోగ్రామ్ కంపైల్ చేయబడినప్పుడు కూడా సంభవించే ఒక లోపాన్ని కూడా చర్చిస్తాము, అంటే 'ఎర్రర్: 'ఆపరేటర్='కి సరిపోలడం లేదు'. ఈ లోపం వంటి కారణాల వల్ల సంభవించవచ్చు: మేము స్ట్రింగ్ పాస్ చేయవలసిన పాయింటర్‌ను పాస్ చేసినట్లయితే, స్థిరమైన వేరియబుల్‌ని సవరించడం మొదలైనవి. 'నో ఆచరణీయమైన ఓవర్‌లోడ్' లోపాన్ని తొలగించడం కష్టం కాదు కానీ ప్రధాన పని ఏమిటంటే లోపాన్ని అర్థం చేసుకోండి ఎందుకంటే ఇది లోపం యొక్క వివరణ లేకుండా లోపాన్ని చూపుతుంది.
వాక్యనిర్మాణం
ఇది కోడ్ లేదా అవుట్‌పుట్‌లో భాగం కానందున ఈ ఎర్రర్‌కు అటువంటి ముందే నిర్వచించబడిన సింటాక్స్ ఏదీ లేదు ఎందుకంటే ఇది తప్పు కోడ్ కారణంగా సంభవించే అస్పష్టత మాత్రమే. మనం చూడగలిగినట్లుగా, లోపం ఎలా ఉంటుందో దిగువ ఉదాహరణ.
లోపం : పోలిక లేదు కోసం 'ఆపరేటర్ = ’
ఉదాహరణ # 01:
ఈ లోపం గురించి మరియు దీనిని పరిష్కరించే పద్ధతి గురించి మాకు ఒక ఆలోచన చేద్దాం. దీన్ని బాగా అర్థం చేసుకోవడానికి, మేము ఆబ్జెక్ట్‌లను ఉపయోగించి పేర్లను ఫంక్షన్‌కు పాస్ చేయబోతున్న ఉదాహరణను ప్రదర్శిస్తాము మరియు అది వాటిని ప్రదర్శిస్తుంది. మేము మొదట హెడర్ ఫైల్ iostreamను చేర్చుతాము. ఆ తర్వాత, మేము 'my_object' పేరుతో ఒక తరగతిని ప్రకటిస్తాము. దాని లోపల, మేము 'F_name' మరియు 'L_name' అనే రెండు స్ట్రింగ్ వేరియబుల్‌లను ప్రకటించాము, 'L_name' వ్యక్తి యొక్క చివరి పేరును సూచించే వ్యక్తి యొక్క మొదటి పేరును సూచించే 'F_name'.
తర్వాత, మేము “my_object()” పేరుతో పబ్లిక్ కన్స్ట్రక్టర్ని ప్రకటించాము, దీనిలో మేము “F_name” మరియు “L_name” వేరియబుల్స్ రెండింటికీ శూన్య విలువలను కేటాయించాము. ఆ తరువాత, మేము స్ట్రింగ్ టైప్ వేరియబుల్స్ “fn” మరియు “ln”ని పాస్ చేసిన మరొక ఫంక్షన్‌ను ప్రకటించాము. దాని లోపల, మేము name_set() పద్ధతిని పిలిచాము. అప్పుడు, మేము ఇద్దరు సభ్యుల ఫంక్షన్‌లను “show()” మరియు “name_set()” ప్రకటించాము. “షో() ఫంక్షన్‌ని పిలిచినప్పుడు, అది మొదటి పేర్లు మరియు చివరి పేర్లను కలిపి ప్రదర్శిస్తుంది. అయితే, “set_name()” మెంబర్ ఫంక్షన్‌లో, మేము స్ట్రింగ్ టైప్ “fn” మరియు “ln” యొక్క రెండు స్ట్రింగ్ వేరియబుల్స్‌ను పాస్ చేసాము, వీటిని మనం రెండవ కన్స్ట్రక్టర్‌కి కూడా పంపాము.
ఇప్పుడు, క్లాస్ my_object యొక్క కాపీ అసైన్‌మెంట్ ఆపరేటర్‌ని ఉపయోగించి, మేము 'my_object' రకం యొక్క ఒక పరామితిని తీసుకుంటాము. కంపైలర్ ఎల్లప్పుడూ దానిని ఏదైనా తరగతికి చెందిన ఇన్‌లైన్ పబ్లిక్ మెంబర్‌గా ప్రకటిస్తుంది. ఈ సభ్యుని లోపల, మేము 'F_name' మరియు 'L_name' కాపీని కలిగి ఉన్న 'F_name'కి src.F_name మరియు 'L_name'కి src.L_nameని కేటాయించాము. ఇది my_object తరగతి సభ్యులకు పంపబడుతుంది. ఇప్పుడు, మేము 'name1' అనే క్లాస్ my_cobject యొక్క ఆబ్జెక్ట్‌ను ప్రకటించాము, దానికి మేము 'అన్నా' మరియు 'స్మిత్' అనే రెండు స్ట్రింగ్‌లను ఆర్గ్యుమెంట్‌గా పాస్ చేసాము. ఇది కన్స్ట్రక్టర్ని పిలుస్తుంది మరియు చివరి పేరుతో పాటు మొదటి పేరును ప్రదర్శిస్తుంది.
ఆ తర్వాత, మేము మరొక వస్తువు 'name2'ని సృష్టించాము మరియు ఆ వస్తువుకు పేరును విడిగా కేటాయించాము. రెండు ఆబ్జెక్ట్‌ల కోసం కన్స్ట్రక్టర్కు విలువలను పాస్ చేసిన తర్వాత, మేము షో() పద్ధతి అని పిలుస్తాము, అది “nam1” మరియు “name2” రెండింటికీ పేర్లను ప్రదర్శిస్తుంది. కోడ్ చివరిలో, మేము శూన్య విలువను అందించాము మరియు మా కోడ్‌ని అమలు చేసాము.
చేర్చండితరగతి నా_వస్తువు {
ప్రైవేట్ :
std :: స్ట్రింగ్ F_name, L_name ;
ప్రజా :
నా_వస్తువు ( ) { F_పేరు = '' ; L_పేరు = '' ; }
నా_వస్తువు ( std :: స్ట్రింగ్ fn, std :: స్ట్రింగ్ ln ) {
పేరు_సెట్ ( fn, ln ) ;
}
శూన్యం చూపించు ( ) { std :: కోట్ << 'పేరు' << F_పేరు << '' << L_పేరు << '. \n ' ; }
శూన్యం పేరు_సెట్ ( std :: స్ట్రింగ్ fn, std :: స్ట్రింగ్ ln ) { F_పేరు = fn ; L_పేరు = ln ; }
నా_వస్తువు & ఆపరేటర్ = ( స్థిరంగా నా_వస్తువు & src ) {
F_పేరు = src F_పేరు ;
L_పేరు = src L_పేరు ;
తిరిగి * ఇది ;
}
} ;
int ప్రధాన ( int argc, చార్ ** argv ) {
నా_వస్తువు పేరు1 ( 'అన్నా' , 'స్మిత్' ) ;
నా_వస్తువు పేరు2 ;
పేరు2 = ( 'అన్నా' , 'స్మిత్' ) ;
పేరు1. చూపించు ( ) ;
పేరు2. చూపించు ( ) ;
తిరిగి 0 ;
}
మా కోడ్‌ని అమలు చేసిన తర్వాత, మేము ఈ ఎర్రర్‌ను కలిగి ఉన్నాము, ఇది మేము లైన్ 24లో తప్పు కోడ్ను వ్రాసినట్లు ప్రదర్శిస్తుంది, ఇది 'ఎర్రర్: 'ఆపరేటర్='కి సరిపోలడం లేదు'. ఇప్పుడు, మేము ఈ లోపాన్ని పరిష్కరించడానికి ప్రయత్నిస్తాము.
ఈ లోపాన్ని పరిష్కరించడానికి, ఏదైనా తరగతి యొక్క కన్స్ట్రక్టర్కు విలువలను పంపడానికి మాకు అనేక మార్గాలు ఉన్నాయి. మొదటి పద్ధతిలో, మేము కేవలం 'name1' ఆబ్జెక్ట్‌ను 'name2'కి కేటాయిస్తాము ఎందుకంటే మేము రెండు వస్తువులకు ఒకే విలువలను పాస్ చేసాము కాబట్టి వాటిని విడిగా పాస్ చేయవలసిన అవసరం లేదు. ఇప్పుడు మేము కోడ్ను అమలు చేస్తాము.
int ప్రధాన ( int argc, చార్ ** argv ) {నా_వస్తువు పేరు1 ( 'అన్నా' , 'స్మిత్' ) ;
నా_వస్తువు పేరు2 ;
పేరు2 = పేరు1 ;
పేరు1. చూపించు ( ) ;
పేరు2. చూపించు ( ) ;
పైన చూపిన విధంగా కోడ్‌లో మార్పులు చేసిన తర్వాత, మేము దిగువ స్నిప్పెట్‌లో ఇచ్చిన ఫలితాన్ని కలిగి ఉన్నాము. మేము కన్స్ట్రక్టర్కు పంపిన పేరును ప్రదర్శించాము, ఎటువంటి లోపం లేకుండా విజయవంతంగా ప్రదర్శించబడుతుంది.
ఈ లోపాన్ని పరిష్కరించడానికి రెండవ పద్ధతి ఏమిటంటే, మనం రెండు వస్తువులకు వేర్వేరు విలువలను పాస్ చేయాల్సి ఉంటుంది. మేము ఒక వాదనగా కన్స్ట్రక్టర్కు పంపవలసిన విలువలతో పాటు తరగతి పేరును ఉపయోగిస్తాము. మేము మొదటి పేరు 'జోన్' మరియు రెండవ పేరు 'స్మిత్'ని ఆమోదించాము. అప్పుడు, మేము కోడ్ను అమలు చేసాము.
int ప్రధాన ( int argc, చార్ ** argv ) {నా_వస్తువు పేరు1 ( 'అన్నా' , 'స్మిత్' ) ;
నా_వస్తువు పేరు2 ;
పేరు2 = నా_వస్తువు ( 'జాన్', 'స్మిత్' ) ;
పేరు1. చూపించు ( ) ;
పేరు2. చూపించు ( ) ;
పైన జోడించిన కోడ్‌ని అమలు చేసిన తర్వాత, క్రింద చూపిన విధంగా మనకు అవుట్‌పుట్ ఉంటుంది. ఆబ్జెక్ట్ “name1” కోసం, ఇది “అన్నా స్మిత్” అనే పేరును ప్రదర్శిస్తుంది మరియు రెండవ వస్తువు “name2” కోసం ఇది “Jhone Smith”ని ప్రదర్శిస్తుంది. కానీ ఈసారి మా కోడ్‌లో ఎలాంటి లోపాలు లేకుండా సరిగ్గా పనిచేసింది.
ఇప్పుడు, మేము మా కోడ్‌ని విజయవంతంగా అమలు చేయడానికి మరొక పద్ధతిని ప్రయత్నిస్తాము. పై సందర్భాలలో వలె, మేము అసైన్‌మెంట్ ఆపరేటర్‌ని ఉపయోగించి ఆబ్జెక్ట్‌లకు విలువలను కేటాయించడానికి ప్రయత్నించాము. కానీ ఈసారి, మేము వస్తువు యొక్క ప్రకటన సమయంలో విలువలను పాస్ చేస్తాము. దిగువ స్నిప్పెట్‌లో మనం చూడగలిగినట్లుగా, ఆబ్జెక్ట్ “name1” డిక్లరేషన్ సమయంలో, “name2” కోసం అదే దశను పునరావృతం చేసే వస్తువుకు ఆర్గ్యుమెంట్‌గా విలువలను పంపాము. ఇప్పుడు, మేము మరోసారి కోడ్ను అమలు చేస్తాము.
int ప్రధాన ( int argc, చార్ ** argv ) {నా_వస్తువు పేరు1 ( 'అన్నా' , 'స్మిత్' ) ;
నా_వస్తువు పేరు2 ( 'జాన్', 'స్మిత్' ) ;
పేరు1. చూపించు ( ) ;
పేరు2. చూపించు ( ) ;
ఈ సారి కూడా కోడ్ అమలు చేయబడిన తర్వాత, మేము ఎటువంటి ఎర్రర్‌ను ఎదుర్కోలేదు అంటే ఇది ఎటువంటి ఎర్రర్‌లను కలిగి ఉండకుండా చేస్తుంది.
ముగింపు
తరగతుల నుండి యాక్సెస్ చేయబడిన ఫంక్షన్‌లపై పని చేస్తున్నప్పుడు మనం ఎదుర్కొనే లోపాన్ని మేము క్లుప్తంగా చర్చించాము. మేము 'నో ఆచరణీయమైన ఓవర్‌లోడ్' లోపాన్ని పరిష్కరించడానికి కారణాలు మరియు పద్ధతులను కూడా అధ్యయనం చేసాము. ఎక్కువగా ఈ లోపం కొత్త ప్రోగ్రామర్‌లకు అర్థం చేసుకోవడం కష్టం కాబట్టి ఉదాహరణలను అమలు చేయడం ద్వారా మరియు దాని వివరణతో కూడా దీన్ని సులభంగా వదిలించుకోవడానికి మేము వారి కోసం ప్రయత్నించాము.