అత్యంత విస్తృతంగా ఉపయోగించే ఉన్నత-స్థాయి భాషలలో ఒకటి C++, ఇది వివిధ కార్యకలాపాలు మరియు విధుల్లో మాకు సహాయపడుతుంది. అదనంగా, ఇది ఫంక్షన్ డిక్లరేషన్‌లను కలిగి ఉన్న అనేక హెడర్ ఫైల్‌లను అందిస్తుంది మరియు మేము C++ కోడ్‌లలో తరగతులను సృష్టించవచ్చు. ఈ లక్షణాలు మా ఉద్యోగాన్ని మరింత సౌకర్యవంతంగా చేస్తాయి. ఎన్‌క్యాప్సులేషన్ సూత్రం యొక్క ప్రధాన అంశం గెట్టర్స్ మరియు సెట్టర్‌లు. పొందేవారు ప్రైవేట్ డేటాను ప్రజలకు చేరువయ్యేలా చేస్తారు. వారు తిరిగి వచ్చే ఫలితాన్ని కూడా కొంతవరకు మార్చవచ్చు. సెట్టర్‌లు ప్రైవేట్ వేరియబుల్‌ని మార్చడాన్ని సాధ్యం చేస్తాయి. అవి కీలకమైనవి ఎందుకంటే అవి విలువను సెట్ చేసే ముందు నిర్ధారణను అందించవచ్చు. ఇక్కడ మన C++ కోడ్‌లలో ఈ గెట్టర్‌లు మరియు సెట్టర్‌లను వర్తింపజేద్దాం.
ఉదాహరణ 1:
C++ డెవలప్‌మెంట్ కోసం అందుబాటులో ఉన్నందున మా కోడ్‌ను ప్రారంభించడానికి మేము ఇక్కడ హెడర్ ఫైల్‌లను ఉపయోగిస్తాము. ప్రారంభించడానికి ఈ కోడ్‌ని అమలు చేయడానికి అవసరమైన హెడర్ ఫైల్‌లను మేము లోడ్ చేస్తాము. 'స్ట్రింగ్' మరియు 'iostream' హెడర్ ఫైల్‌లు ఈ కోడ్‌లో చేర్చబడ్డాయి. మేము ఆ తర్వాత 'నేమ్‌స్పేస్ std'ని చేర్చుతాము.
అప్పుడు, మేము ఇక్కడ “టేబుల్” క్లాస్‌ని సృష్టించి, “int” డేటా రకంతో “count” అనే ప్రైవేట్ వేరియబుల్‌ని ప్రారంభించాము మరియు దాని విలువగా “15”ని నిల్వ చేస్తాము. దీని తరువాత, మేము 'పబ్లిక్' కీవర్డ్‌ని ఇన్సర్ట్ చేస్తాము. అప్పుడు, మేము 'getCount()' పేరుతో ఒక ఫంక్షన్‌ను సృష్టిస్తాము. దీని డేటా రకం 'int'. ఇది ఇక్కడ గెట్టర్ ఫంక్షన్. “రిటర్న్” కీవర్డ్‌ని ఉపయోగించడం ద్వారా మేము ఈ ఫంక్షన్‌లో ఈ “కౌంట్”ని తిరిగి ఇస్తాము. అప్పుడు, మేము 'T_obj' పేరుతో మునుపటి తరగతి యొక్క ఆబ్జెక్ట్‌ను సృష్టించే క్రింది 'ప్రధాన()' ఫంక్షన్‌ను అమలు చేస్తాము. అప్పుడు, కౌంట్ విలువను పొందడానికి మరియు ఫలితాన్ని ఇక్కడ ప్రింట్ చేయడానికి “cout” స్టేట్‌మెంట్‌లోని ఈ క్లాస్ ఆబ్జెక్ట్‌తో “getCount()” ఫంక్షన్‌ని పిలుస్తాము.
కోడ్ 1:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి పట్టిక
{
ప్రైవేట్ :
int లెక్కించండి = పదిహేను ;
ప్రజా :
int getCount ( )
{
తిరిగి లెక్కించండి ;
}
} ;
int ప్రధాన ( )
{
టేబుల్ T_obj ;
కోట్ << 'మేము ఇక్కడ పట్టిక సంఖ్యలను పొందుతాము: ' << T_obj. getCount ( ) ;
}
అవుట్‌పుట్:
ఈ కోడ్ యొక్క పూర్తి మరియు విజయవంతమైన సంకలనం తర్వాత, మేము ఈ కావలసిన అవుట్‌పుట్‌ను పొందుతాము, దీనిలో ఇది కౌంట్ విలువను పొందుతుందని మరియు దానిని ఇక్కడ ప్రదర్శించడం “15” అని చూడవచ్చు. ఇది 'ప్రైవేట్' తరగతి లోపల ప్రారంభించబడింది.
ఉదాహరణ 2:
ఈ కోడ్‌కు అవసరమైన “స్ట్రింగ్” మరియు “iostream” హెడర్ ఫైల్‌లు ఇక్కడ చేర్చబడ్డాయి. 'namespace std' ఆ తర్వాత చేర్చబడుతుంది. తరువాత, మేము 'MySquareClass' తరగతికి కొత్త ఉదాహరణను తయారు చేస్తాము, 'int' డేటా రకంతో 'squareSide' అనే ప్రైవేట్ వేరియబుల్‌ని ప్రారంభించి, దాని విలువను '5'కి సెట్ చేస్తాము. అప్పుడు “పబ్లిక్” కీవర్డ్ జోడించబడుతుంది మరియు “int” డేటా రకంతో “getSquareSide()” అనే ఫంక్షన్ అభివృద్ధి చేయబడింది.
ఇక్కడ, దీనిని 'గెటర్' ఫంక్షన్‌గా సూచిస్తారు. దీని లోపల, మేము 'స్క్వేర్ సైడ్' ను 'తిరిగి' చేస్తాము. కాబట్టి, మేము ఈ ఫంక్షన్‌ని పిలిచినప్పుడు, అది “స్క్వేర్‌సైడ్” విలువను ఇస్తుంది. దీని తరువాత, మేము 'getSquarePerimeter()' అనే మరొక ఫంక్షన్‌ను ఉంచుతాము. ఇక్కడ, మేము చుట్టుకొలతను కనుగొనడానికి సూత్రాన్ని ఉంచుతాము, కనుక ఇది చతురస్రం యొక్క వైపు విలువను పొందిన తర్వాత మరియు దానిని '4'తో గుణించిన తర్వాత స్క్వేర్ చుట్టుకొలతను తిరిగి ఇస్తుంది. మేము చతురస్రం యొక్క వైశాల్యాన్ని కూడా కనుగొనాలి. ఈ ప్రయోజనం కోసం, మేము 'getSquareArea()' పేరుతో మరో ఫంక్షన్‌ని అభివృద్ధి చేస్తాము మరియు స్క్వేర్ వైపులా గుణించే ఫార్ములా సహాయంతో స్క్వేర్ వైశాల్యాన్ని గణిస్తాము. ఇది మనం కాల్ చేసినప్పుడు స్క్వేర్ వైశాల్యాన్ని అందిస్తుంది మరియు మునుపటి “స్క్వేర్‌సైడ్” వేరియబుల్ నుండి స్క్వేర్ వైపు విలువను పొందుతుంది.
ఇప్పుడు, మనం ఈ ఫంక్షన్లను కాల్ చేయాలి. మేము “main()”ని అమలు చేసి, ఆపై “sq_obj1” పేరుతో “MySquareClass” యొక్క ఆబ్జెక్ట్‌ను సృష్టిస్తాము. దీని తరువాత, మేము ఈ క్లాస్ ఆబ్జెక్ట్‌తో మూడు ఫంక్షన్లను విడిగా కాల్ చేసి ప్రింట్ చేస్తాము.
కోడ్ 2:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి MySquareClass
{
ప్రైవేట్ :
int చతురస్రం వైపు = 5 ;
ప్రజా :
int getSquareSide ( )
{
తిరిగి చతురస్రం వైపు ;
}
int getSquarePerimeter ( )
{
తిరిగి చతురస్రం వైపు * 4 ;
}
int getSquareArea ( )
{
తిరిగి చతురస్రం వైపు * చతురస్రం వైపు ;
}
} ;
int ప్రధాన ( )
{
MySquareClass sq_obj1 ;
కోట్ << 'చదరపు వైపు =' <<
sq_obj1. getSquareSide ( ) << endl ;
కోట్ << 'చదరపు చుట్టుకొలత =' <<
sq_obj1. getSquarePerimeter ( ) << endl ;
కోట్ << 'చదరపు ప్రాంతం =' <<
sq_obj1. getSquareArea ( ) << endl ;
}
అవుట్‌పుట్:
మొదట, ఇది 'getSquareSide()' ఫంక్షన్ సహాయంతో '5' అయిన స్క్వేర్ వైపు ప్రదర్శిస్తుంది. అప్పుడు, ఇది 'getSquarePerimeter()' ఫంక్షన్‌ని మరియు 'getSquareArea()' ఫంక్షన్‌ని ఉపయోగించి స్క్వేర్ యొక్క వైశాల్యాన్ని ఉపయోగించడం ద్వారా స్క్వేర్ చుట్టుకొలతను ప్రింట్ చేస్తుంది.
ఉదాహరణ 3:
ఇక్కడ, మేము 'డ్రైవర్' తరగతిని కలిగి ఉన్నాము, దీనిలో మేము 'ప్రైవేట్' కీవర్డ్‌ని ఉంచాము మరియు 'int' డేటా రకంతో ప్రైవేట్ మెంబర్‌గా 'driverSalary'ని ప్రకటిస్తాము. దీని తర్వాత, మనకు “పబ్లిక్” ఉంది, ఇక్కడ మనం “setDriverSalary” ఫంక్షన్‌ని సృష్టించి, “int d_s”ని ఈ ఫంక్షన్ యొక్క పారామీటర్‌గా పాస్ చేస్తాము. ఈ కోడ్‌లో ఇది సెట్టర్ ఫంక్షన్. ఇప్పుడు, మేము ఈ ఫంక్షన్‌లోని “డ్రైవర్‌సాలరీ” వేరియబుల్‌కు “d_s”ని కేటాయిస్తాము.
దీని తర్వాత, మేము 'getDriverSalary' అనే గెటర్ ఫంక్షన్‌ని రూపొందించాము మరియు డ్రైవర్ జీతం తిరిగి ఇస్తాము. ఇప్పుడు, “main()”ని ప్రారంభించిన తర్వాత, మేము “driverObj_1” అనే క్లాస్ యొక్క ఆబ్జెక్ట్‌ను సృష్టిస్తాము మరియు “setDriverSalary()” ఫంక్షన్‌కి కాల్ చేసి, “30000”ని దాని పారామీటర్‌గా పాస్ చేయడం ద్వారా డ్రైవర్ జీతం యొక్క విలువను సెట్ చేస్తాము. డ్రైవర్ జీతం. అప్పుడు, మేము 'getDriverSalary()' ఫంక్షన్‌కి కాల్ చేయడం ద్వారా ఈ జీతం ప్రింట్ చేస్తాము.
కోడ్ 3:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి డ్రైవర్ {
ప్రైవేట్ :
int డ్రైవర్ జీతం ;
ప్రజా :
శూన్యం సెట్డ్రైవర్ జీతం ( int d_s ) {
డ్రైవర్ జీతం = d_s ;
}
int డ్రైవర్ జీతం పొందండి ( ) {
తిరిగి డ్రైవర్ జీతం ;
}
} ;
int ప్రధాన ( ) {
డ్రైవర్ డ్రైవర్Obj_1 ;
డ్రైవర్Obj_1. సెట్డ్రైవర్ జీతం ( 30000 ) ;
కోట్ << 'డ్రైవర్ జీతం:' << డ్రైవర్Obj_1. డ్రైవర్ జీతం పొందండి ( ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, మేము డ్రైవర్ జీతం సెట్ చేస్తాము మరియు దానిని సెట్ చేసి అవుట్‌పుట్ స్క్రీన్‌పై ప్రదర్శించిన తర్వాత దాని జీతం పొందుతాము.
ఉదాహరణ 4:
“వ్యక్తి” తరగతి ఈ కోడ్‌లో రూపొందించబడింది, ఇక్కడ మేము “స్ట్రింగ్” డేటా రకంతో “P_name”, “P_city” మరియు “P_language” అనే మూడు “ప్రైవేట్” వేరియబుల్‌లను ప్రకటిస్తాము. దీని తరువాత, మేము 'పబ్లిక్' కన్స్ట్రక్టర్ను తయారు చేస్తాము. ఇక్కడ, మేము “setPersonName()” ఫంక్షన్‌ని ఉంచుతాము మరియు ఫంక్షన్ యొక్క పారామీటర్‌గా “string newName”ని ఉంచాము. దీని తర్వాత, మేము ఈ “కొత్త పేరు”ని “P_name” వేరియబుల్‌కు కేటాయిస్తాము. అప్పుడు, మేము “getPersonCity()” ఫంక్షన్‌ని సృష్టించి, “P_city”ని తిరిగి ఇస్తాము. అదే పద్ధతిలో, మేము “setPersonCity()”పేరుతో మరొక ఫంక్షన్‌ని సృష్టిస్తాము. అప్పుడు, మేము 'స్ట్రింగ్ సిటీ'ని పరామితిగా పాస్ చేస్తాము.
'నగరం' వేరియబుల్ ఇప్పుడు 'P_city' వేరియబుల్‌కు కేటాయించబడింది. ”getPersonLanguage()” అనేది ఇక్కడ తదుపరి ఫంక్షన్, ఇది “P_language”ని కూడా అందిస్తుంది. అంతేకాకుండా, మేము “setPersonLanguage()” ఫంక్షన్‌ని కూడా నిర్వచించాము మరియు దాని పారామీటర్‌గా “lang” స్ట్రింగ్‌ను పాస్ చేస్తాము. 'lang' అప్పుడు 'P_language' వేరియబుల్‌కు కేటాయించబడుతుంది. దీని తర్వాత, మనకు “లైవ్స్()” మరియు “స్పీక్()” అనే మరో రెండు ఫంక్షన్‌లు ఉన్నాయి, ఇక్కడ మేము “కౌట్()” స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము.
“main()” పద్ధతిని అమలు చేసిన తర్వాత, మేము ఇప్పుడు “p_obj1” అనే క్లాస్ యొక్క ఆబ్జెక్ట్‌ను రూపొందిస్తాము. ఇక్కడ, మేము 'setPersonName()' ఫంక్షన్‌ని అమలు చేయడం ద్వారా వ్యక్తి పేరును సెట్ చేస్తాము మరియు దాని పరామితిగా 'Samuel' అనే వ్యక్తి పేరును అందించాము. దీని తర్వాత, మేము 'setPersonCity()' ఫంక్షన్‌కి కాల్ చేయడం ద్వారా మరియు 'లండన్'ని పారామీటర్‌గా పాస్ చేయడం ద్వారా వ్యక్తి యొక్క నగరాన్ని సెట్ చేస్తాము. అప్పుడు, మేము 'setPersonLanguage()' ఫంక్షన్‌ని ఉపయోగించి వ్యక్తి యొక్క భాషను కూడా సెట్ చేస్తాము మరియు దాని పరామితిగా 'ఇంగ్లీష్'ని పాస్ చేస్తాము. ఇప్పుడు, మేము 'p_obj1' తరగతి యొక్క ఆబ్జెక్ట్‌తో విడిగా 'లైవ్స్()' మరియు 'స్పీక్()' ఫంక్షన్లను పిలుస్తాము.
కోడ్ 4:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి వ్యక్తి
{
ప్రైవేట్ :
స్ట్రింగ్ P_పేరు ;
స్ట్రింగ్ P_city ;
స్ట్రింగ్ P_language ;
ప్రజా :
శూన్యం సెట్ పర్సన్ పేరు ( స్ట్రింగ్ కొత్త పేరు ) {
P_name = కొత్తపేరు ;
}
స్ట్రింగ్ getPersonCity ( ) {
తిరిగి P_city ;
}
శూన్యం సెట్ పర్సన్ సిటీ ( స్ట్రింగ్ సిటీ ) {
P_city = నగరం ;
}
స్ట్రింగ్ getPersonLanguage ( ) {
తిరిగి P_language ;
}
శూన్యం సెట్ పర్సన్ లాంగ్వేజ్ ( స్ట్రింగ్ లాంగ్ ) {
P_language = కేవలం ;
}
శూన్యం జీవితాలు ( )
{
కోట్ << P_name << ' నివసిస్తున్నాడు ' << P_city << endl ;
}
శూన్యం మాట్లాడతారు ( )
{
కోట్ << P_name << 'మాట్లాడుతుంది' << P_language << endl ;
}
} ;
int ప్రధాన ( ) {
వ్యక్తి p_obj1 ;
p_obj1. సెట్ పర్సన్ పేరు ( 'శామ్యూల్' ) ;
p_obj1. సెట్ పర్సన్ సిటీ ( 'లండన్' ) ;
p_obj1. సెట్ పర్సన్ లాంగ్వేజ్ ( 'ఆంగ్ల' ) ;
p_obj1. జీవితాలు ( ) ;
p_obj1. మాట్లాడతారు ( ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, ఫలితంగా మన కోడ్‌లో మనం సెట్ చేసిన అన్ని విలువలను ఇది చూపుతుంది. మేము సృష్టించిన ఫంక్షన్‌కు కాల్ చేయడం ద్వారా ఈ ఫలితాన్ని పొందుతాము.
ముగింపు
మేము ఈ గైడ్‌లో C++ ప్రోగ్రామింగ్‌లోని గెట్టర్‌లు మరియు సెట్టర్‌లను అన్వేషించాము. 'గెట్టర్' మరియు 'సెట్టర్' పద్ధతులు తరగతి యొక్క అంతర్గత కార్యకలాపాల యొక్క మెరుగైన సంగ్రహణ మరియు ఎన్‌క్యాప్సులేషన్‌ను అందజేస్తాయని మేము వివరించాము. అదనంగా, మేము డేటా సభ్యుని రక్షించడానికి డేటా చెల్లుబాటు కార్యాచరణను అలాగే ఉంచినట్లు అన్వేషించాము, బాహ్య కోడ్‌పై ప్రభావం చూపకుండా తరగతి దాని కోడ్‌ను మార్చడానికి అనుమతిస్తుంది. మేము ఈ గెట్టర్‌లు మరియు సెట్టర్‌లను ఉపయోగించడం ద్వారా C++ కోడ్‌లతో దీన్ని చేసాము.