C++లో, మనం ఒక తరగతిని నిర్వచించినప్పుడు, ఆ తరగతి లోపల కొన్ని వేరియబుల్స్‌ని ప్రారంభిస్తాము. ఈ వేరియబుల్స్ క్లాస్ యొక్క 'మెంబర్ వేరియబుల్'. C++ ప్రోగ్రామింగ్‌లో కన్స్ట్రక్టర్ పద్ధతిని ఉపయోగించడం ద్వారా మనం 'సభ్యుల వేరియబుల్'ని ప్రారంభించవచ్చు. నిర్దిష్ట క్లాస్ ఆబ్జెక్ట్‌కి లింక్ చేయబడిన మరియు దాని అన్ని పద్ధతులు లేదా ఫంక్షన్‌లకు యాక్సెస్ చేయగల వేరియబుల్‌ను C++లో “సభ్య వేరియబుల్”గా సూచిస్తారు. ఈ వ్యాసంలో, మేము ఈ “సభ్యుల వేరియబుల్స్”ని C++ కోడ్‌లో ప్రకటిస్తాము మరియు “సభ్యుల వేరియబుల్స్” గురించి ఇక్కడ వివరంగా వివరిస్తాము.
ఉదాహరణ 1:
ఈ కోడ్ సమయంలో మనకు అవసరమైన “హెడర్ ఫైల్”ని చేర్చడం ద్వారా ఇక్కడ కొంత కోడ్‌ను ప్రారంభిద్దాం. “iostream” అనేది ఈ కోడ్‌లో మనం ఇన్సర్ట్ చేసే హెడర్ ఫైల్. ఈ హెడర్ ఫైల్ ఈ కోడ్‌లో మనకు అవసరమైన వీలైనన్ని విధులను కలిగి ఉంటుంది మరియు దానిలో ప్రకటించబడుతుంది. అప్పుడు, మనం తప్పనిసరిగా “std” అయిన నేమ్‌స్పేస్‌ను చేర్చాలి, కాబట్టి “namespace std”తో “using” కీవర్డ్‌ని ఉంచడం ద్వారా దాన్ని ఇక్కడ జోడిస్తాము.
మేము ఈ “std”ని ఫంక్షన్‌లతో విడిగా జోడించాల్సిన అవసరం లేదు. అప్పుడు, మేము 'SampleClass' అనే తరగతిని నిర్వచించాము మరియు 'పబ్లిక్' కన్స్ట్రక్టర్ని ఉపయోగిస్తాము. ఈ “పబ్లిక్” కన్‌స్ట్రక్టర్‌లో, మేము కొన్ని మెంబర్ వేరియబుల్‌లను ప్రకటిస్తాము, వీటిని మేము తర్వాత మా మెంబర్ ఫంక్షన్‌లలో యాక్సెస్ చేస్తాము. మేము ఇక్కడ ప్రకటించే సభ్య వేరియబుల్స్ “int” డేటా రకం యొక్క “mVar1” మరియు “mVar2”.
అప్పుడు, మేము దీని క్రింద 'setValues()' అనే ఫంక్షన్‌ను ప్రకటిస్తాము. ఈ “setValues()” ఫంక్షన్‌లో, రెండు విలువలను ఇన్‌పుట్ చేయమని వినియోగదారుని సూచించే సందేశాన్ని ప్రింట్ చేయడానికి మేము “cout”ని ఉంచుతాము. వినియోగదారు నమోదు చేసే రెండు విలువలు “mVar1” మరియు “mVar2” వేరియబుల్స్‌లో సేవ్ చేయబడతాయి. మేము 'సిన్' పద్ధతి సహాయంతో ఈ విలువలను పొందుతాము. రెండు విలువలను పొంది, వాటిని “mVar1” మరియు “mVar2”లో సేవ్ చేసిన తర్వాత, మేము దీని క్రింద మరొక ఫంక్షన్‌ని నిర్వచించాము. ఆ ఫంక్షన్ పేరు 'getValues' ఇక్కడ మేము 'కౌట్' స్టేట్‌మెంట్‌లను ఉపయోగిస్తాము.
ఇక్కడ, మేము మునుపటి వినియోగదారు నుండి పొందిన రెండు విలువలను ప్రదర్శించడానికి 'mVar1' మరియు 'mVar2'ని మళ్లీ 'cout'లో ఉంచుతాము. దీని కింద, క్లాస్ ఆబ్జెక్ట్ ఉత్పత్తి చేయబడిన “ప్రధాన()” పద్ధతిని మేము పిలుస్తాము. తరగతి వస్తువు పేరు “sc1”. అప్పుడు, మనం ఇక్కడ 'sc1' ఆబ్జెక్ట్‌తో నిర్వచించే మొదటి ఫంక్షన్‌ని “setValues” అని పిలుస్తాము.
దీని తర్వాత, మేము ఆబ్జెక్ట్ పేరును మళ్లీ ఉంచాము మరియు 'sc1' ఆబ్జెక్ట్ పేరుతో 'getValues()' అని ఉన్న రెండవ ఫంక్షన్‌ని పిలుస్తాము. ఇప్పుడు, ఇది మొదట విలువలను పొందుతుంది మరియు ఈ కోడ్‌లో మెంబర్ వేరియబుల్ యాక్సెస్ చేయబడిన క్లాస్ ఆబ్జెక్ట్‌తో మేము రెండు పద్ధతులను పిలిచినప్పుడు వాటిని కన్సోల్‌లో ప్రదర్శిస్తుంది.
కోడ్ 1:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
తరగతి నమూనా తరగతి {
ప్రజా:
int mVar1, mVar2;
శూన్యమైన సెట్ విలువలు ( ) {
కోట్ <> mVar1 >> mVar2;
}
విలువలు చెల్లవు ( ) {
కోట్ << 'మొదటి మెంబర్ వేరియబుల్ విలువ =' << mVar1 << endl ;
కోట్ << 'రెండవ మెమెబర్ వేరియబుల్ విలువ =' << mVar2 << endl;
}
} ;
పూర్ణాంక ప్రధాన ( )
{
నమూనా క్లాస్ sc1;
sc1.setValues ( ) ;
sc1.getValues ( ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇది మొదట సందేశాన్ని ముద్రిస్తుంది. అప్పుడు, మేము కోడ్‌లో ప్రకటించిన మెంబర్ వేరియబుల్స్‌లో నిల్వ చేయబడిన ఇన్‌పుట్ విలువలుగా “12” మరియు “456” నమోదు చేస్తాము. ఆ తర్వాత, మెంబర్ ఫంక్షన్‌ని ఉపయోగించి మనం వాటిని యాక్సెస్ చేస్తున్నప్పుడు ఇది రెండు వేరియబుల్స్ విలువలను ప్రదర్శిస్తుంది.
ఉదాహరణ 2:
ఇప్పుడు, మేము 'iostream' హెడర్ ఫైల్ మరియు 'std' నేమ్‌స్పేస్‌ని జోడించిన తర్వాత 'ProductClass' అనే తరగతిని నిర్వచించాము. ఈ “ప్రొడక్ట్‌క్లాస్”లో, మేము “పబ్లిక్” కన్స్ట్రక్టర్ని ఉపయోగిస్తాము, దీనిలో మేము “int” డేటా రకం యొక్క రెండు వేరియబుల్‌లను ప్రకటిస్తాము. ఇవి సభ్యుల వేరియబుల్స్ అయిన “విలువ” మరియు “గుణకం”.
అప్పుడు, రెండు వేరియబుల్స్‌ను యాక్సెస్ చేయడానికి “calProductOfTwo()” ఫంక్షన్ పేరుతో ఇక్కడ ఒక ఫంక్షన్‌ని నిర్వచించాము. ఇది ఇక్కడ మెంబర్ ఫంక్షన్ మరియు మేము ఈ ఫంక్షన్‌లోని మెంబర్ వేరియబుల్స్‌ని యాక్సెస్ చేస్తాము. మేము దీని క్రింద 'రిటర్న్' కీవర్డ్‌ని ఉపయోగిస్తాము మరియు ఈ రెండు వేరియబుల్స్ యొక్క ఉత్పత్తిని అందించే 'విలువ * గుణకం'ని ఉంచుతాము.
అప్పుడు, మేము 'p_obj' పేరుతో 'ProductClass' యొక్క ఆబ్జెక్ట్‌ని సృష్టించే 'main()' ఫంక్షన్‌ని అమలు చేస్తాము మరియు ఆపై మేము గతంలో ప్రకటించిన మెంబర్ వేరియబుల్స్‌కు విలువలను కేటాయిస్తాము. మేము 'తరగతి' ఆబ్జెక్ట్ సహాయంతో ఈ వేరియబుల్స్ ప్రారంభించాము. మేము మొదట ఆబ్జెక్ట్ పేరును ఉంచుతాము, ఆపై సభ్యుని వేరియబుల్ పేరు “p_obj.value” మరియు “విలువ” వేరియబుల్‌కు “33”ని కేటాయిస్తాము.
అప్పుడు, మేము “మల్టిప్లైయర్” వేరియబుల్‌ని ప్రారంభించాము మరియు ఈ వేరియబుల్‌కు “98” ని కేటాయిస్తాము. ఇప్పుడు, మేము రెండు సభ్యుల వేరియబుల్స్ యొక్క ఉత్పత్తిని ప్రదర్శించే 'p_obj' తరగతి యొక్క ఆబ్జెక్ట్‌తో 'cout'లో 'calProductOfTwo()' ఫంక్షన్‌ని పిలుస్తాము.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
తరగతి ఉత్పత్తి తరగతి {
ప్రజా:
పూర్ణాంక విలువ;
పూర్ణాంక గుణకం;
Int calProductOfTwo ( ) {
తిరిగి విలువ * గుణకం;
}
} ;
పూర్ణాంక ప్రధాన ( ) {
ProductClass p_obj;
p_obj.value = 33 ;
p_obj.multiplier = 98 ;
కోట్ << 'రెండు విలువల ఉత్పత్తి = ' << p_obj.calProductOfTwo ( ) << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
'సభ్యుడు' వేరియబుల్స్ యొక్క విలువల ఉత్పత్తి ఇక్కడ ప్రదర్శించబడుతుంది. “సభ్యుడు” ఫంక్షన్‌లోని “సభ్యుడు” వేరియబుల్స్‌ని యాక్సెస్ చేసి, “క్లాస్” ఆబ్జెక్ట్‌ని సృష్టించి, మా కోడ్‌లోని “సభ్యుడు” ఫంక్షన్‌కి కాల్ చేసిన తర్వాత వాటిని ప్రారంభించడాన్ని మనం చూడవచ్చు. రెండు సభ్యుల వేరియబుల్స్ యొక్క విలువల ఉత్పత్తి క్రింది వాటిలో ఇవ్వబడింది:
ఉదాహరణ 3:
ఈ కోడ్‌లో “సమ్‌క్లాస్” ఇక్కడ నిర్వచించబడింది. తర్వాత, “పబ్లిక్”లో, మేము “s_val_1”, “s_val_2” మరియు “s_val_3” పేర్లతో ముగ్గురు సభ్యుల వేరియబుల్‌లను ప్రకటిస్తాము మరియు అన్ని వేరియబుల్స్ యొక్క డేటా రకం “int”. అప్పుడు, మేము “సభ్యుడు” ఫంక్షన్ అయిన “calSumOfTwo()” ఫంక్షన్‌ని నిర్వచిస్తాము మరియు మేము ఈ ఫంక్షన్‌లోని వేరియబుల్స్‌ను యాక్సెస్ చేస్తాము. “calSumOfTwo()”లో, మేము “రిటర్న్” కీవర్డ్‌ని ఉపయోగిస్తాము. ఇక్కడ, మేము 's_val_1 + s_val_2'ని ఉంచుతాము.
ఇప్పుడు, ఇది ఈ రెండు వేరియబుల్స్ మొత్తాన్ని ఇస్తుంది. దీని కింద, మేము 'calSumOfThree()' అనే మరో ఫంక్షన్‌ని నిర్వచించాము. ఈ ఫంక్షన్‌లో, మేము మూడు వేరియబుల్స్‌ను వాటి మొత్తాన్ని కనుగొని, వాటి ఫలితాన్ని ఇక్కడ అందించడానికి యాక్సెస్ చేస్తాము. అప్పుడు, మేము 'ప్రధాన ()' పద్ధతిని పిలుస్తాము. ఇక్కడ ఉత్పత్తి చేయబడిన “తరగతి” ఆబ్జెక్ట్ “sObj1”.
దీని తర్వాత, మేము ఇక్కడ 'క్లాస్' ఆబ్జెక్ట్ సహాయంతో మూడు సభ్యుల వేరియబుల్స్‌ను ప్రారంభించాము మరియు '33', '98' మరియు '195'లను వరుసగా 's_val_1', 's_val_2' మరియు 's_val_3'కి కేటాయిస్తాము. అప్పుడు, మేము 'కౌట్'లో 'సభ్యుడు' ఫంక్షన్లను పిలుస్తాము, దీనిలో 'calSumOfTwo()' మొదటి రెండు వేరియబుల్స్ మొత్తాన్ని ప్రదర్శిస్తుంది మరియు 'calSumOfThree()' మొత్తం మూడు సభ్యుల వేరియబుల్స్ మొత్తాన్ని ప్రదర్శిస్తుంది.
కోడ్ 3:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
తరగతి సమ్‌క్లాస్ {
ప్రజా:
int s_val_1;
int s_val_2;
int s_val_3;
int calSumOfTwo ( ) {
తిరిగి s_val_1 + s_val_2;
}
int calSumOfThree ( ) {
తిరిగి s_val_1 + s_val_2 + s_val_3;
}
} ;
పూర్ణాంక ప్రధాన ( ) {
సమ్ క్లాస్ sObj1;
sObj1.s_val_1 = 33 ;
sObj1.s_val_2 = 98 ;
sObj1.s_val_3 = 195 ;
కోట్ << 'రెండు విలువల మొత్తం = ' << sObj1.calSumOfTwo ( ) << endl;
కోట్ << 'మూడు విలువల మొత్తం = ' << sObj1.calSumOfThree ( ) << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
మొదటి రెండు సభ్యుల వేరియబుల్స్ మొత్తం “131”, ఇది మొదటి “సభ్యుడు” ఫంక్షన్‌ని పిలవడం ద్వారా మనం ఇక్కడ పొందుతాము. మొత్తం మూడు సభ్యుల వేరియబుల్స్ మొత్తం “326″, ఇది మన కోడ్‌లోని రెండవ “సభ్యుడు” ఫంక్షన్‌ని కాల్ చేయడం ద్వారా పొందుతుంది.
ముగింపు
C++ ప్రోగ్రామింగ్‌లోని “సభ్యుల వేరియబుల్స్” ఈ వ్యాసంలో లోతుగా అన్వేషించబడ్డాయి. తరగతిని నిర్వచించిన తర్వాత 'సభ్యుల వేరియబుల్స్' ప్రకటించబడతాయని మేము వివరించాము. 'క్లాస్' ఆబ్జెక్ట్‌ని సృష్టించిన తర్వాత కోడ్‌లోని ప్రతిచోటా ఈ వేరియబుల్స్ యాక్సెస్ చేయబడతాయి. మనం ఈ మెంబర్ వేరియబుల్స్‌ని “సభ్యుడు” ఫంక్షన్‌లలో కూడా యాక్సెస్ చేయవచ్చు. 'క్లాస్' ఆబ్జెక్ట్‌ని సృష్టించిన తర్వాత మేము ఈ వేరియబుల్‌లను ప్రారంభించాము. ఇక్కడ, మేము మా C++ కోడ్‌లోని “సభ్యుల వేరియబుల్స్”ని ప్రకటించాము, ప్రారంభించాము మరియు యాక్సెస్ చేసాము.