C++ మాకు తరగతి వస్తువును సృష్టించే సదుపాయాన్ని అందిస్తుంది. మన కోడ్‌లో తరగతిని ప్రకటించినప్పుడు మాత్రమే మేము ఆబ్జెక్ట్‌ను సృష్టిస్తాము. C++ క్లాస్‌లో, డేటా మరియు డేటా మానిప్యులేషన్ పద్ధతులు ఒక ఎంటిటీగా మిళితం చేయబడతాయి. తరగతి అనేది సంబంధిత అంశాల సమాహారం. అంతేకాకుండా, తరగతులు వస్తువు యొక్క రూపాన్ని నిర్వచించాయి. ఆబ్జెక్ట్ అనేది రన్‌టైమ్‌లో సంభవించే సృష్టి. ఇది ఒక తరగతి ఉదాహరణ. ఆబ్జెక్ట్ సహాయంతో, తరగతి సభ్యులందరూ యాక్సెస్ చేయగలరు. ఇక్కడ, మేము తరగతి యొక్క ఆబ్జెక్ట్‌ను సృష్టిస్తాము మరియు ఈ గైడ్‌లోని దాని ఆబ్జెక్ట్ ద్వారా దాని సభ్యులను యాక్సెస్ చేస్తాము.
ఉదాహరణ 1:
మేము 'iostream' హెడర్ ఫైల్ యొక్క ఫంక్షన్‌లను వాటిని ఉపయోగించుకోవడానికి మా కోడ్‌లో చేర్చాము. దీని తర్వాత, మేము ఈ కోడ్‌లోని “స్ట్రింగ్”తో పని చేయాల్సి ఉన్నందున మేము “స్ట్రింగ్” హెడర్ ఫైల్‌ను జోడిస్తాము. మేము 'std' నేమ్‌స్పేస్‌ని కాల్ చేయకుండానే దాని తరగతులను యాక్సెస్ చేయడానికి ఉపయోగిస్తాము. దీని తర్వాత, మేము 'MyFirstClass' తరగతిని సృష్టించి, దానితో 'తరగతి' కీవర్డ్‌ని ఉంచుతాము.
దీని క్రింద, మేము ఇక్కడ యాక్సెస్ స్పెసిఫైయర్ అయిన “పబ్లిక్”ని ఉంచుతాము మరియు ఈ క్లాస్ యొక్క “a” మరియు “str_a” లక్షణాలను ప్రకటిస్తాము. “a” యొక్క డేటా రకం “int” మరియు “str_a” యొక్క డేటా రకం “string”. అప్పుడు మేము 'ప్రధాన ()' అని పిలుస్తాము. ఈ “మెయిన్()” కింద, మేము “myFirstObj” పేరుతో “MyFirstClass” యొక్క ఆబ్జెక్ట్‌ని సృష్టిస్తాము.
తరువాత, తదుపరి పంక్తిలో, మేము తరగతి ఆబ్జెక్ట్ సహాయంతో తరగతి లక్షణాలను యాక్సెస్ చేస్తాము మరియు వాటిని విలువలతో కేటాయిస్తాము. మేము ఆబ్జెక్ట్ పేరును ఉంచాము, చుక్కను ఉంచాము, ఆపై విలువను కేటాయించడానికి లక్షణం పేరును టైప్ చేస్తాము. మేము “myFirstObj.a” అని టైప్ చేసి, ఈ “a” లక్షణానికి “40”ని కేటాయిస్తాము. అదే విధంగా, మేము స్ట్రింగ్ డేటాను “str_a” లక్షణానికి కేటాయిస్తాము. ఈ వేరియబుల్‌కు మనం కేటాయించే స్ట్రింగ్ “ది స్ట్రింగ్ ఇక్కడ ఉంది”.
దీని తర్వాత, మేము 'కౌట్'ని ఉపయోగిస్తాము మరియు వాటి మధ్య చుక్కను ఉంచడం ద్వారా తరగతి వస్తువుతో పాటు ఈ లక్షణాలను జోడిస్తాము. ఇప్పుడు, రెండు గుణాలు, వాటి విలువలతో పాటు, రెండర్ చేయబడతాయి.
కోడ్ 1:
#
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
తరగతి MyFirstClass {
ప్రజా:
int a;
స్ట్రింగ్ str_a;
} ;
పూర్ణాంక ప్రధాన ( ) {
MyFirstClass myFirstObj;
myFirstObj.a = 40 ;
myFirstObj.str_a = 'తీగ ఇక్కడ ఉంది' ;
కోట్ << 'పూర్ణాంకం సంఖ్య' << myFirstObj.a << endl;
కోట్ << myFirstObj.str_a;
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము ఆబ్జెక్ట్ క్లాస్ సహాయంతో రెండు తరగతి లక్షణాలను యాక్సెస్ చేస్తాము. లక్షణాలు, వాటి విలువలతో పాటు, కింది వాటిలో ప్రదర్శించబడతాయి:
ఉదాహరణ 2:
మేము ఇక్కడ సృష్టించే తరగతి 'డాక్టర్' తరగతి. అప్పుడు, మేము 'పబ్లిక్' కీవర్డ్‌ని ఉంచడం ద్వారా కొన్ని పబ్లిక్ వేరియబుల్స్‌ను ప్రకటిస్తాము. ఈ “డాక్టర్” తరగతి యొక్క లక్షణాలు వరుసగా “int” మరియు “string” డేటా రకాలైన “dr_id” మరియు “dr_name”.
ఇప్పుడు, మేము 'ప్రధాన ()' ఫంక్షన్‌ను అమలు చేస్తాము. అప్పుడు, మేము 'డాక్టర్' తరగతి యొక్క వస్తువును సృష్టిస్తాము. తరగతి వస్తువు పేరు “d1”. దీని తరువాత, మేము 'd1' ఆబ్జెక్ట్ సహాయంతో ఈ లక్షణాలకు విలువలను కేటాయిస్తాము. మేము 'd1' ఆబ్జెక్ట్‌ను ఈ లక్షణం పేరుతో ఉంచడం ద్వారా 'dr_id'కి '123'ని కేటాయిస్తాము. దీని తర్వాత, మేము 'd1' ఆబ్జెక్ట్‌ను దీనితో ఉంచడం ద్వారా 'dr_name' లక్షణానికి 'Peter Samuel'ని కేటాయిస్తాము.
ఇప్పుడు, మేము 'కౌట్' మరియు 'd1.dr_id' మరియు 'd1.dr_name'ని చొప్పించడం ద్వారా మేము గతంలో కేటాయించిన విలువలతో పాటు రెండు లక్షణాలను రెండర్ చేస్తాము.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
తరగతి డాక్టర్ {
ప్రజా:
int dr_id;
స్ట్రింగ్ dr_name;
} ;
పూర్ణాంక ప్రధాన ( ) {
డాక్టర్ d1;
d1.dr_id = 123 ;
d1.dr_name = 'పీటర్ శామ్యూల్' ;
కోట్ << 'డాక్టర్ ఐడి' << d1.dr_id << endl;
కోట్ << 'డాక్టర్ పేరు' << d1.dr_name << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
డాక్టర్ యొక్క 'పేరు' మరియు 'ID' ఇప్పుడు ఇక్కడ ప్రదర్శించబడతాయి. మేము ఆబ్జెక్ట్‌ని సృష్టించి, క్లాస్ ఆబ్జెక్ట్ సహాయంతో విలువను కేటాయించిన తర్వాత ఈ “పేరు” మరియు “ఐడి”ని కూడా కేటాయిస్తాము.
ఉదాహరణ 3:
'క్లయింట్' తరగతి మేము ఇక్కడ నిర్మించాము. మేము 'పబ్లిక్' కీవర్డ్‌ని ఉపయోగించి కొన్ని పబ్లిక్ వేరియబుల్‌లను ప్రకటించాము. “int” మరియు “string” డేటా రకాలకు చెందిన “clientId” మరియు “clientName” వరుసగా ఇక్కడ “క్లయింట్” తరగతి యొక్క గుణాలుగా ప్రకటించబడ్డాయి.
దీని తర్వాత, మేము “insert()” ఫంక్షన్‌ని ఉంచుతాము మరియు “c_id” మరియు “c_name” అనే రెండు పారామీటర్‌లను వాటి డేటా రకాలైన “int” మరియు “string”తో పాస్ చేస్తాము. అప్పుడు, మేము “c_id”ని “clientId”కి మరియు “c_name”ని “clientName” లక్షణానికి కేటాయిస్తాము. దీని క్రింద, మేము 'display()' పేరుతో మరొక ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు 'clientId' మరియు 'clientName'ని ప్రదర్శించడంలో సహాయపడే 'cout'ని ఉపయోగిస్తాము. ఇక్కడ, మేము 'ప్రధాన()' ఫంక్షన్‌ని పిలుస్తాము మరియు 'క్లయింట్' తరగతి వస్తువును రూపొందిస్తాము. తరగతి వస్తువులను 'c1', 'c2' మరియు 'c3' అని పిలుస్తారు. మేము ఇక్కడ సృష్టించాలనుకుంటున్న ఆబ్జెక్ట్ పేరుతో తరగతి పేరును ఉంచడం ద్వారా తరగతి వస్తువులు సృష్టించబడతాయి.
ఇప్పుడు, “c1”, “c2” మరియు “c3” అనే ఆబ్జెక్ట్ పేర్లతో “insert()” ఫంక్షన్‌ని ఉపయోగించడం ద్వారా మేము ఈ లక్షణాలలో విలువలను ఇన్సర్ట్ చేస్తాము. మేము మూడు ఆబ్జెక్ట్ విలువలను ప్రదర్శించాలనుకుంటున్నాము, కాబట్టి మేము ఈ అన్ని క్లాస్ ఆబ్జెక్ట్‌లతో “డిస్‌ప్లే()” ఫంక్షన్‌ను ఉంచుతాము.
కోడ్ 3:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
తరగతి క్లయింట్ {
ప్రజా:
int clientId;
స్ట్రింగ్ క్లయింట్ పేరు;
శూన్య చొప్పించు ( int c_id, స్ట్రింగ్ c_name )
{
clientId = c_id;
క్లయింట్ పేరు = c_name;
}
శూన్య ప్రదర్శన ( )
{
కోట్ << క్లయింట్ ఐడి << '' << క్లయింట్ పేరు << endl;
}
} ;
పూర్ణాంక ప్రధాన ( శూన్యం ) {
క్లయింట్ c1;
క్లయింట్ c2;
క్లయింట్ c3;
c1.insert ( 111 , 'జేమ్స్' ) ;
c2.insert ( 112 , 'మేరీ' ) ;
c3.insert ( 113 , 'జార్జ్' ) ;
c1.display ( ) ;
c2.display ( ) ;
c3.display ( ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము మునుపటి కోడ్‌లో మూడు వస్తువులను సృష్టించాము మరియు ఈ వస్తువులను ఉపయోగించడం ద్వారా విలువలను జోడించాము. మేము అన్ని విలువలను కూడా అందించాము.
ఉదాహరణ 4:
మేము 'స్టూడెంట్ క్లాస్'ని సృష్టించి, ఆపై 'పబ్లిక్' లక్షణాలను ప్రకటిస్తాము. మేము ఈ “స్టూడెంట్ క్లాస్” యొక్క నాలుగు లక్షణాలను ప్రకటిస్తాము, అవి “s_name”, “s_class”, “s_rollNo” మరియు “s_subject”. “s_name” కోసం “string”, “s_class” కోసం “int”, “s_rollNo” కోసం “int” మరియు “s_subject” కోసం “string” వంటి ఈ లక్షణాల డేటా రకాలు ఇక్కడ ఉంచబడ్డాయి. ఇప్పుడు, మేము 'మెయిన్()'ని పిలుస్తాము మరియు 'స్టూడెంట్ క్లాస్' యొక్క వస్తువు సృష్టించబడుతుంది. “స్టూడెంట్ క్లాస్” యొక్క ఆబ్జెక్ట్ “stdObj1”. ఇది క్లాస్ పేరు మరియు ఆబ్జెక్ట్ పేరును 'ప్రధాన()' తర్వాత ఉంచడం ద్వారా సృష్టించబడుతుంది.
దీని తర్వాత, ఆబ్జెక్ట్ పేరు మరియు లక్షణం పేరును ఇక్కడ ఉంచడం ద్వారా మేము ఈ అన్ని లక్షణాలకు విలువలను కేటాయిస్తాము. మొదట, మేము 'stdObj1.s_name'ని ఉంచాము మరియు 'జాన్'ని కేటాయించాము. అప్పుడు, మేము 'stdObj1.s_s_class'ని ఉంచాము మరియు ఈ లక్షణానికి '9'ని కేటాయిస్తాము. దీని క్రింద, మేము ఆబ్జెక్ట్ పేరును డాట్‌తో ఉంచిన తర్వాత “s_rollNo” లక్షణానికి “143”ని కేటాయిస్తాము. అప్పుడు, మేము ఆబ్జెక్ట్ పేరును మళ్లీ డాట్‌తో ఉంచాము మరియు “s_subject” లక్షణానికి “కంప్యూటర్”ని కేటాయించాము.
అదే విధంగా, మేము 'విలియం', '8', '211' మరియు 'కెమిస్ట్రీ' అనే నాలుగు లక్షణాలకు ఆబ్జెక్ట్ పేరును లక్షణ పేర్లతో ఉంచడం ద్వారా కేటాయిస్తాము. దీని తర్వాత, మేము 'కౌట్'లో వాటిని ఉంచడం ద్వారా ఈ లక్షణాల యొక్క అన్ని విలువలను అందిస్తాము. రెండరింగ్ కోసం, మేము ఈ అన్ని లక్షణాలతో లక్షణం మరియు ఆబ్జెక్ట్ పేర్లను కూడా ఉంచుతాము.
కోడ్ 4:
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
తరగతి విద్యార్థి తరగతి {
ప్రజా:
స్ట్రింగ్ s_name;
int s_class;
int s_rollNo;
స్ట్రింగ్ s_subject;
} ;
పూర్ణాంక ప్రధాన ( ) {
స్టూడెంట్ క్లాస్ stdObj1;
stdObj1.s_name = 'జాన్' ;
stdObj1.s_class = 9 ;
stdObj1.s_rollNo = 143 ;
stdObj1.s_subject = 'కంప్యూటర్' ;
స్టూడెంట్ క్లాస్ stdObj2;
stdObj2.s_name = 'విలియం' ;
stdObj2.s_class = 8 ;
stdObj2.s_rollNo = 211 ;
stdObj2.s_subject = 'రసాయన శాస్త్రం' ;
కోట్ << stdObj1.s_name << '' << stdObj1.s_class << '' << stdObj1.s_rollNo << '' << stdObj1.s_subject << endl ;
కోట్ << stdObj2.s_name << '' << stdObj2.s_class << '' << stdObj2.s_rollNo << '' << stdObj2.s_subject << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
క్లాస్ ఆబ్జెక్ట్‌ని సృష్టించిన తర్వాత క్లాస్ అట్రిబ్యూట్‌లకు మనం కేటాయించే అన్ని విలువలు ఈ అవుట్‌పుట్‌లో రెండర్ చేయబడతాయి.
ముగింపు
మేము ఈ గైడ్‌లో C++లో ఒక వస్తువును ఎలా సృష్టించాలో వివరంగా అధ్యయనం చేసాము. మేము మా కోడ్‌లో తరగతికి చెందిన ఒక వస్తువు మరియు బహుళ ఆబ్జెక్ట్‌లను సృష్టించాము. మేము తరగతి వస్తువులతో తరగతి లక్షణాలకు విలువలను కూడా కేటాయించాము. అన్ని ఉదాహరణలు ఇక్కడ వివరించబడ్డాయి మరియు అవుట్‌పుట్‌లు కూడా ఈ గైడ్‌లో ప్రదర్శించబడతాయి.