వాక్యనిర్మాణం
మా లోపం యొక్క దోష సందేశం క్రింది విధంగా ఉంది:
లోపం : వేరియబుల్ ‘ ’ ని వియుక్త రకంగా ప్రకటించలేముఖాళీ కుండలీకరణంలో, వేరియబుల్ మరియు అబ్‌స్ట్రాక్ట్ క్లాస్ పేర్లు ఉంటాయని గమనించండి.
లోపం C2259 : 'రాష్ట్రం' : నైరూప్య తరగతిని తక్షణం చేయలేము
అటువంటి లోపాన్ని ఎదుర్కొన్నప్పుడు కంపైలర్ నుండి మనకు వచ్చే మరొక సందేశం ఇది.
ఉదాహరణ # 01:
ఈ లోపాన్ని అర్థమయ్యేలా చేయడానికి, మేము ఒక ఉదాహరణను ప్రదర్శిస్తాము, దీనిలో మనకు లోపం వచ్చే విధంగా మా కోడ్‌ను వ్రాస్తాము. ఆ ప్రయోజనం కోసం, మేము 'ShapeClass' పేరుతో ఒక తరగతిని ప్రారంభించాము. ఈ తరగతిని వియుక్తంగా చేయడానికి, మేము దానిలో “getArea” పేరుతో వర్చువల్ ఫంక్షన్‌ని ప్రకటించాము. మేము వరుసగా 'setWidth' మరియు 'setHeight' పేర్లతో మరో రెండు ఫంక్షన్లను ప్రకటించాము. ఇక్కడ మనం చేయాలనుకుంటున్నది ఏమిటంటే, ఎత్తును పారామీటర్‌గా మరియు వెడల్పును ఇన్‌పుట్ పారామీటర్‌గా పొందాలనుకుంటున్నాము. మేము మా ఇన్‌పుట్ పారామితుల సహాయంతో ప్రాంతాన్ని లెక్కిస్తాము. మేము ప్రధాన పద్ధతిలో మా తరగతికి సంబంధించిన ఒక ఉదాహరణను సృష్టించాము. ఆ వస్తువు సహాయంతో, మేము పద్ధతులను పిలిచాము మరియు మేము ఆ పద్ధతుల ద్వారా ఇన్‌పుట్ పారామితులను పాస్ చేస్తాము. ఆ తర్వాత, ఫలితాలను తనిఖీ చేయడానికి మేము మా అవుట్‌పుట్‌ను ముద్రించాము.
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
తరగతి ShapeClass
{
ప్రజా :
వర్చువల్ int గెటారియా ( ) = 0 ;
శూన్యం సెట్ వెడల్పు ( int లో )
{
వెడల్పు = లో ;
}
శూన్యం ఎత్తు ( int h )
{
ఎత్తు = h ;
}
రక్షించబడింది :
int వెడల్పు ;
int ఎత్తు ;
} ;
int ప్రధాన ( శూన్యం )
{
ShapeClasssh ;
sh. సెట్ వెడల్పు ( 1 ) ;
sh. ఎత్తు ( రెండు ) ;
కోట్ << 'మొత్తం దీర్ఘచతురస్ర ప్రాంతం:' << sh. గెటారియా ( ) << endl ;
తిరిగి 0 ;
}
మా కోడ్ అమలు చేసిన తర్వాత సిస్టమ్ మాకు లోపం ఇచ్చింది. వేరియబుల్ ‘sh’ని మనం అబ్‌స్ట్రాక్ట్ టైప్ ‘షేప్‌క్లాస్’గా ప్రకటించలేమని ఎర్రర్ మెసేజ్ చెబుతోంది. ఇప్పుడు, కంపైలర్ 'ShapeClass' ఒక వియుక్త రకం మరియు మేము దాని వేరియబుల్‌ను ప్రకటించలేమని తెలియజేయడానికి ప్రయత్నిస్తోంది. కాబట్టి, సందేశంతో, కంపైలర్ మన అబ్‌స్ట్రాక్ట్ క్లాస్‌ని ఇన్‌స్టాంటియేట్ చేయనివ్వడం లేదని, అందుకే సిస్టమ్ మనకు లోపాన్ని ఇస్తోందని మనం స్పష్టంగా అర్థం చేసుకోవచ్చు.
లోపాన్ని పరిష్కరించడానికి, మేము మరొక తరగతి 'దీర్ఘచతురస్రం'ని ప్రకటించాము. ఈ తరగతి మా వియుక్త తరగతి యొక్క చైల్డ్ క్లాస్ అవుతుంది మరియు మేము ఈ తరగతిలో మా వర్చువల్ ఫంక్షన్ యొక్క బాడీని ప్రకటిస్తాము. ఆ తరువాత, మేము దాని వస్తువును ప్రధాన పద్ధతిలో సృష్టిస్తాము మరియు దాని వస్తువు సహాయంతో, మేము ఫంక్షన్లను పిలుస్తాము.
సవరణల తర్వాత, మేము మా కోడ్‌ని తయారు చేసాము మరియు ఇప్పుడు మా కోడ్‌ని అమలు చేయడంలో మేము విజయం సాధించాము. సిస్టమ్ లోపాలు లేకుండా మా కోడ్‌ని అమలు చేసింది. సిస్టమ్ దీర్ఘచతురస్రం యొక్క వైశాల్యాన్ని లెక్కించి అవుట్‌పుట్‌ను ముద్రించినట్లు అవుట్‌పుట్‌లో మనం చూడవచ్చు. మా నైరూప్య తరగతి యొక్క వస్తువును మేము నేరుగా పిలవడం మా తప్పు అని మేము తెలుసుకున్నాము, ఇది తప్పు విధానం. మేము దాని చైల్డ్ క్లాస్ యొక్క ఆబ్జెక్ట్‌ని పిలిచినప్పుడు మా కోడ్ బాగా పని చేయడం ప్రారంభించింది.
ఉదాహరణ # 02:
ఈ ఉదాహరణలో, మేము ఎటువంటి గణిత గణనలను చేయము. ఈ ఉదాహరణ వియుక్త తరగతులను అర్థం చేసుకోవడానికి మరియు కోడ్‌ను అమలు చేస్తున్నప్పుడు పద్ధతులు మరియు తరగతుల మధ్య కంపైలర్ ఎలా నడుస్తుందో అర్థం చేసుకోవడానికి మాకు సహాయపడే సాధారణ ఉదాహరణ. ఈ తరగతిలో, మేము ఒక వియుక్త తరగతిని సృష్టించాము మరియు దానికి “AbsClass” అని పేరు పెట్టాము. మేము మరొక తరగతిని “చైల్డ్‌క్లాస్”గా ప్రకటించాము, కానీ ఇది వియుక్త తరగతి కాదు. ఈ తరగతి మా నైరూప్య తరగతి నుండి తీసుకోబడింది.
మేము అబ్‌స్ట్రాక్ట్ క్లాస్‌లో డిక్లేర్డ్ చేసిన పద్ధతిలో “ఆబ్జెక్ట్‌ని ఉపయోగించి పాస్ చేసిన విలువ” అని ప్రింట్ చేసాము. ఫంక్షన్ పేరు 'valueFunc'. మేము చర్చించినట్లుగా, వర్చువల్ ఫంక్షన్ యొక్క శరీరం చైల్డ్ క్లాస్‌లో ప్రకటించబడింది. మా పిల్లల తరగతిలో, మేము మా వర్చువల్ ఫంక్షన్ బాడీలో “వర్చువల్ ఫంక్షన్‌లో” అని ముద్రించాము. ఇప్పుడు, మన విలువ ఫంక్షన్‌కు విలువను పాస్ చేస్తాము మరియు చేరుకున్న విలువ సరైనదేనా అని చూస్తాము. మా ప్రధాన పద్ధతిలో, మేము మా వియుక్త తరగతి యొక్క ఉదాహరణను సృష్టించాము మరియు ఉదాహరణ సహాయంతో, మేము మా వర్చువల్ మరియు ఇతర ఫంక్షన్లను పిలుస్తాము. ఇప్పుడు, మేము మా కోడ్‌ను అమలు చేస్తాము.
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
తరగతి AbsClass
{
ప్రజా :
వర్చువల్ int VirtFunc ( ) = 0 ;
శూన్యం విలువ ఫంక్ ( int లో )
{
వెడల్పు = లో ;
కోట్ << 'ఆబ్జెక్ట్ ఉపయోగించి విలువ ఆమోదించబడింది' << లో << endl ;
}
రక్షించబడింది :
int వెడల్పు ;
} ;
తరగతి చైల్డ్ క్లాస్ :
పబ్లిక్ అబ్స్ క్లాస్
{
ప్రజా :
int VirtFunc ( ) {
కోట్ << 'వర్చువల్ ఫంక్షన్‌లో' << endl ;
}
} ;
int ప్రధాన ( శూన్యం )
{
చైల్డ్‌క్లాస్ సిసి ;
cc. విలువ ఫంక్ ( 5 ) ;
కోట్ << cc. VirtFunc ( ) << endl ;
తిరిగి 0 ;
}
మా కోడ్ అమలు చేసిన తర్వాత, మనకు లోపం వస్తుంది. ఈ లోపం ప్రాథమికంగా మేము మా ప్రధాన పద్ధతిలో ఇక్కడ చేయడానికి ప్రయత్నిస్తున్న ఒక వియుక్త తరగతిని తక్షణమే చేయలేము. ఇక్కడ గమనించాల్సిన విషయం ఏమిటంటే, మన సందేశంలో వేరియబుల్ మరియు అబ్‌స్ట్రాక్ట్ టైప్ మార్చబడ్డాయి.
ఇప్పుడు, మేము మా లోపాన్ని తొలగించి, మా కోడ్‌ని అమలు చేయడానికి ప్రయత్నిస్తాము. ఆ ప్రయోజనం కోసం, మేము మా పిల్లల తరగతి యొక్క వస్తువును సృష్టిస్తాము మరియు దాని ఉదాహరణను చేస్తాము. ఆ ఉదాహరణ సహాయంతో, మేము మా వియుక్త తరగతిలో వర్చువల్ మరియు మరొక పద్ధతి రెండింటినీ పిలుస్తాము. చైల్డ్ క్లాస్‌ని ఉపయోగించి మనం వర్చువల్ ఫంక్షన్‌ని యాక్సెస్ చేయగలమా లేదా అనేది కూడా గమనించబడుతుంది. అలా చేయడంలో మనం విజయవంతమైతే, దాని ఉత్పన్నమైన క్లాస్‌ని ఉపయోగించి మనం అబ్‌స్ట్రాక్ట్ క్లాస్‌ని యాక్సెస్ చేసామని చెప్పవచ్చు.
మా కోడ్‌ను అమలు చేసిన తర్వాత, కంపైలర్ ఈసారి ఎటువంటి లోపాన్ని విసిరివేయలేదు. బదులుగా, సిస్టమ్ మా కోడ్‌ను విజయవంతంగా కంపైల్ చేసి మాకు అవుట్‌పుట్ ఇచ్చింది. ఇప్పుడు, అవుట్‌పుట్‌ను చూద్దాం. సిస్టమ్ దానికి వ్యతిరేకంగా “ఆబ్జెక్ట్ ఉపయోగించి ఆమోదించిన విలువ” మరియు “5” అని ముద్రించింది. ఎందుకంటే మేము ప్రధాన పద్ధతిలో మా ఉదాహరణను ఉపయోగించి 5ని పాస్ చేసాము. ఆ తర్వాత, అది మన వర్చువల్ ఫంక్షన్‌లో మనం అడిగిన పంక్తిని ప్రింట్ చేసింది.
ముగింపు
ఈ గైడ్‌లో, ఆబ్జెక్ట్-ఓరియెంటెడ్ కాన్సెప్ట్‌లను కోడింగ్ చేసేటప్పుడు మరియు ప్రాక్టీస్ చేస్తున్నప్పుడు ప్రోగ్రామర్లు ఎదుర్కొనే క్లిష్టమైన లోపాలను మేము చర్చించాము. ప్రోగ్రామర్ వియుక్త తరగతులతో వ్యవహరిస్తున్నప్పుడు ఈ రకమైన లోపాలు తరచుగా జరుగుతాయి. నైరూప్య తరగతులను తక్షణం చేయడం సాధ్యం కాదని మొత్తం కథనం సారాంశం, మరియు మేము వారి వస్తువులను దానిలోని పద్ధతులను పిలవలేము. మేము లోపాలను సృష్టించడానికి వివిధ ఉదాహరణలను కూడా ప్రయత్నించాము మరియు మా కోడ్‌లోని లోపాలను పరిష్కరించాము.