ఉదాహరణ 1: C++లో కాన్స్ట్ మెంబర్ ఫంక్షన్ యొక్క ప్రోగ్రామ్
ఇక్కడ, మేము కాన్స్ట్ మెంబర్ ఫంక్షన్ యొక్క సాధారణ ప్రోగ్రామ్‌ను కలిగి ఉన్నాము:
#includeఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి నా తరగతి {
int ఒకదానిపై ;
ప్రజా :
నా తరగతి ( int n = 0 ) {
ఒకదానిపై = n ;
}
int విలువ పొందండి ( ) స్థిరంగా {
తిరిగి ఒకదానిపై ;
}
} ;
int ప్రధాన ( ) {
స్థిరంగా మైక్లాస్ సి ( 30 ) ;
MyClass c1 ( 5 ) ;
కోట్ << 'ఆబ్జెక్ట్ సి ఉపయోగించి సంఖ్య : ' << సి. విలువ పొందండి ( ) ;
కోట్ << ' \n ఆబ్జెక్ట్ c1ని ఉపయోగించే సంఖ్య : ' << c1. విలువ పొందండి ( ) ;
తిరిగి 0 ;
}
ప్రారంభంలో, ప్రోగ్రామ్ ఇన్‌పుట్/అవుట్‌పుట్ స్ట్రీమ్‌లను ప్రారంభించే హెడర్ ఫైల్‌ను మేము నిర్వచించాము. అప్పుడు, మేము 'MyClass' తరగతిని సెట్ చేస్తాము, ఇక్కడ మేము 'num' వేరియబుల్ మరియు MyClass() ఫంక్షన్ మరియు getVal() ఫంక్షన్ యొక్క సభ్యుల ఫంక్షన్లను ప్రకటిస్తాము. MyClass() ఫంక్షన్ లోపల, మేము 'n' పరామితిని '0' విలువతో సెట్ చేస్తాము. అప్పుడు, “n” ఆర్గ్యుమెంట్ “num” వేరియబుల్‌కు కేటాయించబడుతుంది. తరువాత, మేము 'const' కీవర్డ్‌తో getVal() ఫంక్షన్‌ని పిలుస్తాము, ఇది ఫంక్షన్ కాల్‌లో ఆబ్జెక్ట్ యొక్క ప్రస్తుత స్థితిని సవరించబడదని సూచిస్తుంది. getVal() ఫంక్షన్ “సంఖ్య” మెంబర్ వేరియబుల్‌ని అందిస్తుంది.
చివరగా, మేము ప్రధాన () ఫంక్షన్‌కు చేరుకుంటాము. ఇక్కడ, మేము MyClass() ఫంక్షన్ యొక్క “c” మరియు “c1” ఆబ్జెక్ట్‌లను నిర్వచించాము మరియు ఈ ఆబ్జెక్ట్‌లకు విలువలను కూడా పాస్ చేస్తాము. “c” ఆబ్జెక్ట్ “const” కీవర్డ్‌తో సెట్ చేయబడింది, ఈ ఆబ్జెక్ట్‌కు కేటాయించిన విలువను సవరించడం సాధ్యం కాదని సూచిస్తుంది.
ఆబ్జెక్ట్ ద్వారా పిలువబడే కాన్స్ట్ మెంబర్ ఫంక్షన్ యొక్క అవుట్‌పుట్ క్రింది వాటిలో చూపబడింది. ఈ విధంగా, మనం మెంబర్ ఫంక్షన్ మరియు ఆబ్జెక్ట్‌తో “const” కీవర్డ్‌ని ఉపయోగించవచ్చు:
ఉదాహరణ 2: C++లో క్లాస్ వెలుపల కాన్స్ట్ మెంబర్ ఫంక్షన్ యొక్క ప్రోగ్రామ్
ఇప్పుడు, మేము కాన్స్ట్ మెంబర్ ఫంక్షన్ క్లాస్ డెఫినిషన్ వెలుపల నిర్వచించబడిన మరొక అమలును కలిగి ఉన్నాము మరియు కాన్స్ట్ మెంబర్ ఫంక్షన్‌ని ఉపయోగించి ప్రైవేట్ మెంబర్ వేరియబుల్ విలువను సెట్ చేసి తిరిగి పొందుతాము.
#ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి న్యూక్లాస్ {
int i ;
ప్రజా :
శూన్యం సెట్_రికార్డ్ ( int ) ;
int పొందండి_రికార్డు ( ) స్థిరంగా ;
} ;
శూన్యం న్యూక్లాస్ :: సెట్_రికార్డ్ ( int x ) { i = x ; }
int న్యూక్లాస్ :: పొందండి_రికార్డు ( ) స్థిరంగా { తిరిగి i ; }
int ప్రధాన ( )
{
న్యూక్లాస్ సి ;
సి. సెట్_రికార్డ్ ( 10 ) ;
కోట్ << సి. పొందండి_రికార్డు ( ) ;
తిరిగి 0 ;
}
ఇక్కడ, మేము మొదట 'న్యూక్లాస్' అనే క్లాస్‌ను ఏర్పాటు చేస్తాము, ఇక్కడ మనం ప్రైవేట్‌గా ఉంచబడిన 'i' వేరియబుల్‌ని ప్రారంభిస్తాము. ఆ తర్వాత, set_record() మరియు get_record() మెంబర్ ఫంక్షన్‌లు నిర్వచించబడే పబ్లిక్ కీవర్డ్ మాకు ఉంది. 'i' వేరియబుల్ విలువను సెట్ చేయడానికి set_record() మెంబర్ ఫంక్షన్ ఉపయోగించబడుతుంది మరియు 'i' వేరియబుల్ విలువను తిరిగి ఇవ్వడానికి get_record() ఫంక్షన్ ఇక్కడ ఉపయోగించబడుతుంది. మేము get_record() మెంబర్ ఫంక్షన్‌తో “const” కీవర్డ్‌ని ఉపయోగిస్తామని గమనించండి, అది const Member ఫంక్షన్‌గా సూచిస్తుంది మరియు ఆబ్జెక్ట్ స్థితిని సవరించడం సాధ్యం కాదు. ఆ తర్వాత, “i” వేరియబుల్ విలువను సెట్ చేయడానికి మనకు set_record() ఫంక్షన్ డెఫినిషన్ ఉంటుంది.
అదేవిధంగా, “i” వేరియబుల్ విలువను తిరిగి పొందడానికి మనకు get_record() ఫంక్షన్ డెఫినిషన్ ఉంది. అప్పుడు, మేము 'న్యూక్లాస్' క్లాస్ యొక్క 'సి' ఆబ్జెక్ట్ యొక్క డిక్లరేషన్ ఉన్న ప్రధాన() ఫంక్షన్‌ను సెట్ చేస్తాము. అప్పుడు, “z” వేరియబుల్‌కు విలువను కేటాయించడానికి “set_record”, నాన్-కాన్స్ట్ మెంబర్ ఫంక్షన్ అంటారు. కొనసాగుతూనే, “i” విలువను ప్రింట్ చేయడానికి మనం get_record() const Member ఫంక్షన్‌ని పిలుస్తాము.
ప్రైవేట్ మెంబర్ వేరియబుల్ విలువ కాన్స్ట్ మెంబర్ ఫంక్షన్ ద్వారా పిలువబడుతుంది మరియు కింది ప్రాంప్ట్‌లో చూపబడుతుంది:
ఉదాహరణ 3: కాన్స్ట్ మెంబర్ ఫంక్షన్ యొక్క ప్రోగ్రామ్ క్లాస్ వెలుపల ఒక స్వతంత్ర ఫంక్షన్‌గా నిర్వచించబడింది
అయినప్పటికీ, 'const' కీవర్డ్‌తో మెంబర్ ఫంక్షన్‌ని క్లాస్ వెలుపల స్వతంత్ర ఫంక్షన్‌గా పిలవబడే కాన్స్ట్ మెంబర్ ఫంక్షన్ యొక్క మరొక సందర్భాన్ని మేము అమలు చేస్తాము.
#includeఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి సమీకరణం {
int n1,n2 ;
ప్రజా :
శూన్యం సెట్_సమీకరణం ( int x, int మరియు )
{
n1 = x ;
n2 = మరియు ;
}
శూన్యం షో_సమీకరణం ( )
{
కోట్ << 'సమీకరణం:' << n1 << '+' << n2 << 'బి' << endl ;
}
స్నేహితుడు శూన్యం ఇది సరదాగా ఉంది ( స్థిరంగా సమీకరణం ) ;
} ;
శూన్యం ఇది సరదాగా ఉంది ( స్థిరంగా సమీకరణం obj )
{
కోట్ << 'ఫంక్షన్ ఉపయోగించి సమీకరణం:' << obj n1 << '+' << obj n2 << 'బి' << endl ;
}
int ప్రధాన ( )
{
సమీకరణం obj ;
obj సెట్_సమీకరణం ( 5 , 8 ) ;
obj షో_సమీకరణం ( ) ;
ఇది సరదాగా ఉంది ( obj ) ;
}
ఇక్కడ, మేము “సమీకరణం()” తరగతిని సృష్టించి, ఆపై “n1” మరియు “n2” వేరియబుల్‌లను ప్రకటిస్తాము. ఇక్కడ, “n1” మరియు “n2” వేరియబుల్స్ విలువలను సెట్ చేయడానికి మేము set_Equation() మెంబర్ ఫంక్షన్‌ని కూడా జోడిస్తాము. show_Equation() ఫంక్షన్ ఈ వేరియబుల్స్ ఉపయోగించి ఉత్పత్తి చేయబడిన సమీకరణాన్ని చూపుతుంది.
దీని తర్వాత, 'స్నేహితుడు' కీవర్డ్‌ని ఉపయోగించి నిర్వచించబడిన funIs() యొక్క ఫంక్షన్ డిక్లరేషన్‌ని మేము కలిగి ఉన్నాము. ఈ “స్నేహితుడు” కీవర్డ్ “ఈక్వేషన్” క్లాస్‌లోని ప్రైవేట్ మెంబర్‌ని యాక్సెస్ చేయడానికి మమ్మల్ని అనుమతిస్తుంది. తరువాత, మేము తరగతి వెలుపల ఉన్న “funIs()” ఫ్రెండ్ ఫంక్షన్‌ని పిలుస్తాము మరియు “సమీకరణం” తరగతిలోని “obj” పరామితిని constగా ఇన్‌పుట్ చేస్తాము. ముగింపులో, మేము 'సమీకరణం' తరగతి యొక్క ఆబ్జెక్ట్‌ను ప్రకటించే ప్రధాన() ఫంక్షన్‌ని కలిగి ఉన్నాము. అప్పుడు, మేము set_Equation() ఫంక్షన్‌ని ఉపయోగించి “n1” మరియు “n2” వేరియబుల్స్ విలువలను సెట్ చేస్తాము. show_Equation() ఫంక్షన్‌ని ఉపయోగించి వాటి విలువలను ప్రదర్శించడానికి “n1” మరియు “n2” వేరియబుల్స్ ఉపయోగించబడతాయి. చివరగా, సమీకరణాన్ని ప్రదర్శించడానికి 'ఈక్వేషన్' క్లాస్ యొక్క 'funIs' ఫ్రెండ్ ఫంక్షన్ అని పిలుస్తాము.
కాన్స్ట్ ఫ్రెండ్ ఫంక్షన్‌ని ఉపయోగించి సమీకరణం మరియు సమీకరణం ప్రాంప్ట్‌లో ప్రదర్శించబడతాయి:
ఉదాహరణ 4: C++లో విలువను నవీకరించడానికి కాన్స్ట్ మెంబర్ ఫంక్షన్ యొక్క ప్రోగ్రామ్ (చెత్త సందర్భం)
ప్రోగ్రామ్ కాన్స్ట్ మెంబర్ ఫంక్షన్ యొక్క చెత్త దృష్టాంతాన్ని ప్రదర్శిస్తుంది, ఇక్కడ మేము 'కాన్స్ట్ మెంబర్ ఫంక్షన్ లోపల' అని పిలువబడే వేరియబుల్ విలువను సవరించడానికి ప్రయత్నిస్తాము.
#ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి సమాచారం {
int లో ;
ప్రజా :
శూన్యం సెట్ విలువ ( int i ) { లో = i ; }
int విలువ పొందండి ( ) స్థిరంగా
{
++ లో ;
తిరిగి లో ;
}
} ;
int ప్రధాన ( )
{
డేటా డి ;
డి. సెట్ విలువ ( ఇరవై ) ;
కోట్ << endl << డి. విలువ పొందండి ( ) ;
తిరిగి 0 ;
}
ఇక్కడ, మేము మొదట “డేటా” క్లాస్‌ని నిర్మిస్తాము మరియు క్లాస్‌లో “v” వేరియబుల్‌ను ప్రకటిస్తాము. దీని తర్వాత, మేము 'పబ్లిక్' కీవర్డ్‌ని సెట్ చేసి, ఆపై 'setValue()' యొక్క క్లాస్ మెంబర్ ఫంక్షన్లను ప్రకటిస్తాము, ఇది క్లాస్ యొక్క కన్స్ట్రక్టర్‌ను సూచిస్తుంది మరియు తరగతి యొక్క గెటర్ మెంబర్ ఫంక్షన్‌ను సూచించే getValue()ని సూచిస్తుంది. setValue() ఫంక్షన్ “i” వేరియబుల్‌ను పారామీటర్‌గా తీసుకుంటుంది. ఈ “i” వేరియబుల్ “v” మెంబర్ వేరియబుల్‌కు కేటాయించబడింది.
దీని తరువాత, మనకు getValue() ఫంక్షన్ డెఫినిషన్ ఉంటుంది, ఇక్కడ మనం “v” వేరియబుల్ విలువను తిరిగి పొందుతాము. getValue() ఫంక్షన్ “const” కీవర్డ్‌తో ప్రకటించబడినందున, “v” వేరియబుల్ విలువ ఏ సందర్భంలోనైనా నవీకరించబడదని సూచిస్తుంది. అయితే, మేము ఉద్దేశపూర్వకంగా దాని విలువను మార్చడానికి “v” వేరియబుల్‌ని పెంచడానికి ప్రయత్నిస్తాము. ప్రోగ్రామ్ ఈ దశకు చేరుకున్నప్పుడు, ఒక లోపం విసిరివేయబడుతుంది. చివరగా, మేము 'డేటా' క్లాస్ యొక్క 'd' ఆబ్జెక్ట్‌ను నిర్వచించే ప్రధాన() ఫంక్షన్ కాల్‌ని కలిగి ఉన్నాము మరియు ఈ 'd' ఆబ్జెక్ట్ కోసం '20' విలువను సెట్ చేస్తాము. ఆ తర్వాత, వస్తువు యొక్క “d” విలువను పొందడానికి మేము getValue() ఫంక్షన్‌ని పిలుస్తాము.
ప్రాంప్ట్ మునుపటి అమలు ఫలితాలను ఉత్పత్తి చేస్తుంది, ఇక్కడ అది “++v”పై ఎర్రర్‌ను ఇస్తుంది ఎందుకంటే కాన్స్ట్ మెంబర్ ఫంక్షన్ ఆబ్జెక్ట్‌ల విలువను సవరించడానికి మాకు అనుమతి లేదు:
ముగింపు
ముగింపులో, ప్రోగ్రామ్ విలువలో ప్రమాదవశాత్తూ మార్పులను నివారించడానికి ఉపయోగించే C++ యొక్క కాన్స్ట్ ఫంక్షన్‌లోకి మేము ప్రవేశిస్తాము. C++లోని కాన్స్ట్ మెంబర్ ఫంక్షన్‌లు చదవడానికి-మాత్రమే ఫంక్షన్‌లు, వీటిని పిలిచే వస్తువులను సవరించడం అనుమతించబడదు. మేము C++లో దాని కార్యాచరణను ప్రదర్శించడానికి కాన్స్ట్ ఫంక్షన్ యొక్క వివిధ దృశ్యాలను కూడా అమలు చేసాము.