C++లోని ఇంటర్‌ఫేస్‌లు వియుక్త తరగతులను ఉపయోగించి వర్తింపజేయబడతాయి. మరోవైపు, క్లాస్‌లోని కనీసం ఒక ఫంక్షన్‌ను స్వచ్ఛమైన వర్చువల్ ఫంక్షన్‌గా ప్రకటించినట్లయితే ఒక క్లాస్‌ను అబ్‌స్ట్రాక్ట్ క్లాస్ అంటారు.
ప్యూర్ వర్చువల్ ఫంక్షన్ అంటే ఏమిటి
ది స్వచ్ఛమైన వర్చువల్ ఫంక్షన్ అంటే వినియోగదారులు కేవలం ఫంక్షన్‌ను ప్రకటిస్తారు మరియు దాని నిర్వచనం కాదు. డెరైవ్డ్ క్లాస్‌లో స్వచ్ఛమైన వర్చువల్ పద్ధతులను అమలు చేయడానికి పద్ధతి/ఫంక్షన్ ఓవర్‌రైడింగ్ ఉపయోగించబడుతుంది. క్రింద ఇచ్చిన విధంగా తరగతి లోపల వివరించబడినట్లయితే, ఒక ఫంక్షన్ స్వచ్ఛమైన వర్చువల్‌గా పరిగణించబడుతుంది:
ఇక్కడ a యొక్క వాక్యనిర్మాణం ఉంది స్వచ్ఛమైన వర్చువల్ ఫంక్షన్ తరగతి గది.
తరగతి గది {
ప్రజా :
// స్వచ్ఛమైన వర్చువల్ ఫంక్షన్
వర్చువల్ రెట్టింపు గెటారియా ( ) = 0 ;
ప్రైవేట్ :
రెట్టింపు పొడవు ; // గది పొడవు
రెట్టింపు వెడల్పు ; // గది వెడల్పు
} ;
వియుక్త తరగతి అంటే ఏమిటి
బేస్ క్లాస్‌గా పనిచేయడం కోసం ప్రత్యేకంగా సృష్టించబడిన ఒక తరగతి పేరు ఒక నైరూప్య తరగతి . వియుక్త తరగతిలో కనీసం ఒక స్వచ్ఛమైన వర్చువల్ ఫంక్షన్ తప్పనిసరిగా ఉండాలి. ఇది వేరియబుల్స్ మరియు స్టాండర్డ్ ఫంక్షన్‌లను కలిగి ఉండవచ్చు. వియుక్త తరగతి కలిగి ఉన్న ఉత్పన్నమైన తరగతులు, బేస్ క్లాస్ యొక్క స్వచ్ఛమైన వర్చువల్ ఫంక్షన్‌ను అమలు చేయాలి, లేకుంటే అవి వియుక్తంగా మారతాయి.
కింది ఉదాహరణను పరిగణించండి, దీనిలో పేరెంట్ క్లాస్ బేస్ క్లాస్‌కి ఇంటర్‌ఫేస్‌ని ఇస్తుంది, ఇది బేస్ క్లాస్‌ని అప్లై చేయడానికి స్వచ్ఛమైన వర్చువల్ ఫంక్షన్ అని పిలువబడుతుంది getArea() . రెండు వేర్వేరు తరగతులు ఒకే విధంగా ఉపయోగిస్తాయి getArea() ఫంక్షన్, కానీ రెండు సందర్భాలలో అవుట్‌పుట్ భిన్నంగా ఉంటుంది.
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి ఆకారం
{
ప్రజా :
వర్చువల్ int గెటారియా ( ) = 0 ;
శూన్యం సెట్ వెడల్పు ( int wth )
{
వెడల్పు = wth ;
}
శూన్యం పొడవు ( int lవ )
{
పొడవు = lవ ;
}
రక్షించబడింది :
int వెడల్పు ;
int పొడవు ;
} ;
తరగతి దీర్ఘ చతురస్రం : ప్రజా ఆకారం
{
ప్రజా : int గెటారియా ( )
{
తిరిగి ( వెడల్పు * పొడవు ) ;
}
} ;
తరగతి త్రిభుజం : ప్రజా ఆకారం
{
ప్రజా : int గెటారియా ( )
{
తిరిగి ( వెడల్పు * పొడవు ) / 2 ;
}
} ;
int ప్రధాన ( శూన్యం )
{
దీర్ఘచతురస్రం R ;
ట్రయాంగిల్ T ;
ఆర్. సెట్ వెడల్పు ( 9 ) ;
ఆర్. పొడవు ( 5 ) ;
కోట్ << 'దీర్ఘచతురస్రం యొక్క ప్రాంతం:' << ఆర్. గెటారియా ( ) << endl ;
టి. సెట్ వెడల్పు ( 9 ) ;
టి. పొడవు ( 5 ) ;
కోట్ << 'త్రిభుజం ప్రాంతం:' << టి. గెటారియా ( ) << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్
ఇంటర్‌ఫేస్‌ల ప్రాముఖ్యత
స్వచ్ఛమైన అబ్‌స్ట్రాక్ట్ క్లాస్ (ఇంటర్ఫేస్) నుండి తీసుకోబడిన ఏదైనా తరగతి ఎల్లప్పుడూ బేస్ క్లాస్ యొక్క ప్రతి పద్ధతులను అమలు చేయాలి, అంటే ఇంటర్ఫేస్. ఇంటర్ఫేస్ పాయింటర్‌లను ఫంక్షన్‌లు మరియు తరగతులకు పంపవచ్చు, తద్వారా ఉత్పన్నమైన తరగతి యొక్క ఫంక్షన్‌లను అక్కడ నుండే కాల్ చేయవచ్చు.
ఇంటర్‌ఫేస్‌లను ఉపయోగించడం కోసం నియమాలు ఏమిటి
C++లో ఇంటర్‌ఫేస్‌లను ఉపయోగించడానికి వినియోగదారులు అనుసరించాల్సిన క్రింది నియమాలు ఉన్నాయి:
- స్వచ్ఛమైన వర్చువల్ ఫంక్షన్‌లను మాత్రమే ప్రకటించండి.
- స్వచ్ఛమైన వర్చువల్ ఫంక్షన్‌లకు 0 మాత్రమే కేటాయించబడింది.
- తరగతుల ఇంటర్‌ఫేస్‌ని సృష్టించవద్దు.
- బేస్ నైరూప్య తరగతికి సూచనను ఉపయోగించి, మేము ఉత్పన్నమైన తరగతి యొక్క ఉదాహరణకి పాయింటర్‌ను సృష్టించవచ్చు.
కింది కోడ్‌లో, ఒక ఇంటర్ఫేస్ linuxhint , స్వచ్ఛమైన వర్చువల్ పద్ధతిని ఉపయోగించి ఒక వియుక్త తరగతి సృష్టించబడినట్లుగా, అలాగే దాని ఫంక్షన్ చైల్డ్ క్లాస్‌లో వర్తించబడుతుంది మరియు మేము రిటర్న్ స్ట్రింగ్() ఇంటర్ఫేస్ నియమాలను అనుసరించడం ద్వారా ప్రధాన విధిలో పద్ధతి.
##
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి linuxhint
{
ప్రజా :
వర్చువల్ స్ట్రింగ్ రిటర్న్ స్ట్రింగ్ ( ) = 0 ;
} ;
తరగతి బిడ్డ : ప్రజా linuxhint
{
ప్రజా :
స్ట్రింగ్ రిటర్న్ స్ట్రింగ్ ( )
{
తిరిగి 'హలో Linuxhint' ;
}
} ;
int ప్రధాన ( )
{
పిల్లల బిడ్డ_వస్తువు ;
linuxhint * pntr ;
pntr = & పిల్లల_వస్తువు ;
కోట్ < రిటర్న్ స్ట్రింగ్ ( ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్
ముగింపు
ఇంటర్‌ఫేస్‌లు అనేది C++లో అవసరమైన తరగతిని అమలు చేయడానికి అవసరమైన తరగతి ప్రవర్తనను వివరించే వియుక్త తరగతులు. ఇంటర్‌ఫేస్‌లతో పని చేయడం ద్వారా వారి C++ ప్రోగ్రామింగ్ నైపుణ్యాలను మెరుగుపరచుకోవడానికి పైన పేర్కొన్న మార్గదర్శకాలు ఒక అనుభవశూన్యుడు చాలా కీలకం. C++లో ఇంటర్‌ఫేస్‌ల అమలును నేర్చుకోవడంలో మీకు సహాయపడే కొన్ని ఉదాహరణలను మీరు కనుగొంటారు.