ఈ ఆర్టికల్లో, మేము ఈ రకమైన అన్ని రకాల కన్స్ట్రక్టర్ల గురించి ఉదాహరణలతో చర్చించాము.
ఉదాహరణ 1
ఇది డిఫాల్ట్ కన్స్ట్రక్టర్ యొక్క దృష్టాంతం. మేము ఒక తరగతి వస్తువును సృష్టించినప్పుడు నిర్మాతలు ఆటోమేటిక్‌గా సృష్టించబడతాయని మనకు తెలుసు. దీనిని అవ్యక్త సృష్టి అంటారు. కన్స్ట్రక్టర్లు క్లాస్ పేరు అదే పేరుతో ఉంటారు. తరగతికి ప్రైవేట్ మరియు పబ్లిక్ అనే రెండు ఆప్షన్‌లు ఉన్నాయని మాకు తెలిసినందున కన్స్ట్రక్టర్ యొక్క c ++ కోడ్ ఉన్న ఫైల్‌ని పరిగణించండి. ప్రైవేట్ భాగం డేటా వేరియబుల్స్ కలిగి ఉంటుంది, అయితే పబ్లిక్ భాగం ఏదైనా వస్తువు ద్వారా తిరిగి పొందిన ఫంక్షన్ల కోసం. కాబట్టి కన్స్ట్రక్టర్ పబ్లిక్ భాగంలో కూడా నిర్వచించబడింది.
పూర్ణ సంఖ్య()
{
x=యాభై;
మరియు=ఇరవై;
};
ఈ కన్స్ట్రక్టర్‌లో, వేరియబుల్స్‌కు విలువలు కేటాయించబడతాయి. మేము విలువలను అవుట్‌పుట్‌గా పొందాలనుకుంటే, మేము వాటిని ప్రధాన ప్రోగ్రామ్‌లో ముద్రించాలి.
కన్స్ట్రక్టర్‌ను నిర్వచించిన తరువాత, తరగతి మూసివేయబడుతుంది. ప్రధాన ప్రోగ్రామ్‌లోకి ప్రవేశించేటప్పుడు, మేము ఒక వస్తువును ఉపయోగించి విలువల ముద్రణను తీసుకుంటాము. ఆబ్జెక్ట్ ఎల్లప్పుడూ కన్స్ట్రక్టర్లను యాక్సెస్ చేస్తుంది, ఎందుకంటే ఇవి క్లాస్ యొక్క భాగాలు. వస్తువు సృష్టి చాలా సులభం. ఇది తరగతి పేరుతో పరిచయం చేయడం ద్వారా చేయబడుతుంది. అది ఈ ఉదాహరణలోని పూర్ణాంకం. డాట్ పద్ధతి ద్వారా విలువ పొందబడుతుంది. అనగా, a.x.
మేము ఉబుంటులోని టెర్మినల్ నుండి సోర్స్ కోడ్ యొక్క అవుట్‌పుట్‌ను చూడవచ్చు. అవుట్‌పుట్ పొందడానికి ఉపయోగించే విధానం చాలా సులభం. ముందుగా కోడ్ కంపైల్ చేయబడింది, ఆపై అది అమలు చేయబడుతుంది. మేము సంకలనం ప్రక్రియ కోసం G ++ కంపైలర్‌ని ఉపయోగిస్తాము. C విషయంలో వలె, మేము GCC ని ఉపయోగిస్తాము.
$ G++ -లేదా ఫైల్క్ ఫైల్.c
./ఫైల్
-O ఫైల్‌లో అవుట్‌పుట్‌ను సేవ్ చేయడానికి ఉపయోగించబడుతుంది.
ఉదాహరణ 2
ఈ దృష్టాంతంలో, మేము పారామీటరైజ్డ్ కన్స్ట్రక్టర్లను వివరించబోతున్నాం. మునుపటి ఉదాహరణకి భిన్నంగా, ప్రధాన ప్రోగ్రామ్ నుండి మేము వాదనలను కన్స్ట్రక్టర్లకు కూడా పంపవచ్చు. వస్తువు ఉత్పత్తి చేయబడినప్పుడు, ఈ విలువలు స్వయంచాలకంగా విలువను స్వీకరించడానికి కన్స్ట్రక్టర్‌లో ఉన్న వేరియబుల్స్‌కు పంపబడతాయి. పారామీటరైజ్డ్ కన్స్ట్రక్టర్ల యొక్క కొన్ని ఉపయోగాలు.
- ఇది ప్రారంభించినప్పుడు కన్స్ట్రక్టర్ల లోపల వివిధ విలువలతో విభిన్న వేరియబుల్స్ ప్రారంభించడానికి ఉపయోగించబడుతుంది.
- ఇది కన్స్ట్రక్టర్ ఓవర్‌లోడింగ్‌లో ఉపయోగించబడుతుంది. ఇది తరువాత వ్యాసంలో నిర్వచించబడింది.
ఇప్పుడు ఈ భావనను వివరించడానికి మేము వివరించిన దృష్టాంతాన్ని పరిశీలిద్దాం. తరగతికి పూర్ణాంకం అనే పేరు ఉంది, కాబట్టి ఖచ్చితంగా, కన్స్ట్రక్టర్ పేరు కూడా అలాగే ఉంటుంది. కన్స్ట్రక్టర్ యొక్క పారామితులలో, రెండు పూర్ణాంకాల రకం విలువలు ఉన్నాయి. ప్రధాన ప్రోగ్రామ్ నుండి ఫంక్షన్ కాల్‌గా పంపబడే విలువలను అంగీకరించడానికి ఇవి ప్రారంభించబడ్డాయి.
పూర్ణ సంఖ్య( intx,intమరియు){
కు=x;
బి=మరియు;
};
మునుపటి ఉదాహరణలో, కన్స్ట్రక్టర్ లోపల వేరియబుల్స్ విలువలు ఇవ్వబడ్డాయి. ఈ కన్స్ట్రక్టర్‌లో, వేరియబుల్స్ విలువ కలిగిన వేరియబుల్స్‌తో కేటాయించబడతాయి.
మేము డిస్‌ప్లే తీసుకోవాలనుకుంటే, ఆ ప్రారంభించిన వేరియబుల్‌ను కన్స్ట్రక్టర్ నుండి నేరుగా యాక్సెస్ చేయడం సాధ్యం కానందున మేము విలువను తిరిగి ఇచ్చే ఫంక్షన్‌ను నిర్వచించాలి.
intgetX(){
తిరిగికు;
};
ఇప్పుడు మనం ప్రోగ్రామ్ యొక్క ప్రధాన భాగాన్ని చూస్తాము. ఇక్కడ వస్తువు సృష్టించబడినప్పుడు, మీరు పారామీటర్ విభాగంలో విలువలను చూడవచ్చు.
పూర్ణాంకం v(70,55); {అవ్యక్త}పూర్ణాంకం v=పూర్ణ సంఖ్య(10,పదిహేను); {స్పష్టమైన}
మరియు ఫలితాన్ని ప్రదర్శించడానికి, క్లాస్ లోపల సృష్టించబడిన ఫంక్షన్‌లను ఆబ్జెక్ట్ ఉపయోగించి కాల్ చేస్తాము. అంటే v.getx ().
రికార్డ్ పొందడం యొక్క పద్ధతి ఇంతకు ముందు ప్రవేశపెట్టిన విధంగానే ఉంటుంది.
ఉదాహరణ 3
ఈ ఉదాహరణ ఒక తరగతి కన్స్ట్రక్టర్ యొక్క కాపీని సూచిస్తుంది. కాపీ చేయబడిన కన్స్ట్రక్టర్ వస్తువును ఇదే తరగతిలో ఉన్న మరొక వస్తువుతో ప్రారంభించడానికి ఉపయోగిస్తారు. ఈ కన్స్ట్రక్టర్ ఒక వస్తువులోని డేటాను మరొక వస్తువుకు కాపీ చేస్తుంది. ఈ కన్స్ట్రక్టర్ యొక్క పారామితులు తరగతి వస్తువు యొక్క చిరునామాను కలిగి ఉంటాయి. ఇచ్చిన ఉదాహరణలను పరిగణించండి, దీనిలో మేము ఒకే డేటా రకానికి చెందిన రెండు వేరియబుల్స్‌ను ప్రవేశపెట్టాము, తద్వారా ఇవి క్లాస్ లోపల ఏదైనా ఫంక్షన్ ద్వారా యాక్సెస్ చేయగలవు. కన్స్ట్రక్టర్ వేరియబుల్ ద్వారా విలువలను అందుకుంటారు. అదే సమయంలో, కాపీ చేయబడిన కన్స్ట్రక్టర్ వస్తువును మాత్రమే అందుకుంటారు. మరియు ఈ వస్తువు సహాయంతో, విలువలు పొందబడతాయి.
గోడ(గోడ&ఆబ్జెక్ట్){
పొడవు=ఆబ్జెక్ట్పొడవు;
ఎత్తు=ఆబ్జెక్ట్ఎత్తు;
}
మేము ప్రాంతాన్ని లెక్కించాలి, కాబట్టి ఈ గణన కోసం ఫంక్షన్ ఇక్కడ నిర్వచించబడింది. కాల్ చేసినప్పుడు ఇది ప్రధాన ఫంక్షన్‌కు విలువను అందిస్తుంది. ఇప్పుడు మేము కోడ్ యొక్క ప్రధాన ప్రోగ్రామ్‌ని గమనిస్తాము
కాపీ చేయబడిన కన్స్ట్రక్టర్ యొక్క ఫంక్షన్ కాల్ ఇలా ఉంటుంది.
గోడ గోడ 2=గోడ 1;వస్తువు కాపీ చేయబడిన కన్స్ట్రక్టర్‌ను పిలుస్తుంది మరియు మొదటి వస్తువు ద్వారా డేటా దాని ద్వారా కాపీ చేయబడుతుంది. ఇంకా, మేము రెండు వస్తువుల ద్వారా ప్రాంతాన్ని లెక్కించడానికి ఫంక్షన్‌ను పిలుస్తాము.
అవుట్‌పుట్ నుండి, రెండు కన్స్ట్రక్టర్ల నుండి వచ్చిన ఫలితం ఒకేలా ఉందని మీరు చూడవచ్చు. దీని అర్థం మొత్తం డేటా విజయవంతంగా వస్తువు ద్వారా కాపీ చేయబడింది.
ఉదాహరణ 4
ఇది కన్స్ట్రక్టర్ ఓవర్‌లోడింగ్ యొక్క దృష్టాంతం. మేము తరగతి లోపల ఒకే ఫంక్షన్ కంటే ఎక్కువ ఉపయోగించాల్సి వచ్చినప్పుడు ఇది జరుగుతుంది. కన్స్ట్రక్టర్ ఓవర్‌లోడింగ్ పారామీటరైజ్డ్ కన్స్ట్రక్టర్ల సూచనలను అనుసరిస్తుంది. క్లాస్‌లోని అన్ని కన్స్ట్రక్టర్లు క్లాస్‌కు సమానమైన పేరును కలిగి ఉంటారు. కానీ ప్రతి నిర్మాతకు వేర్వేరు పారామితులు కేటాయించబడతాయి. మేము వస్తువును సృష్టించినప్పుడు ప్రతి నిర్మాతను వాదన ప్రకారం పిలుస్తారు.
ఇచ్చిన ఉదాహరణను పరిగణించండి, దీనిలో మేము మూడు కన్స్ట్రక్టర్లను ఉపయోగించాము. ఒకటి ఎలాంటి వాదన లేకుండా ఉంది. రెండవది ఒకే వాదనతో, మూడవది రెండు వాదనలతో ఉంటుంది. ఈ దృష్టాంతం మునుపటి మాదిరిగానే ఉంటుంది. మేము తరగతి లోపల వివరించిన ప్రత్యేక ఫంక్షన్‌లో ప్రాంతాన్ని లెక్కించినప్పుడు.
// రెండు వాదనలతో కన్స్ట్రక్టర్ఆకారం(intx,intమరియు)
{
కు=x;
బి=మరియు;
};
ఇప్పుడు, ప్రధాన ప్రోగ్రామ్ వైపు కదులుతున్నప్పుడు, మనం క్లాస్ ఆబ్జెక్ట్‌ను ప్రారంభించినప్పుడు, ఎలాంటి ఆర్గ్యుమెంట్ లేని కన్స్ట్రక్టర్ డిఫాల్ట్‌గా పిలువబడేలా చూడవచ్చు. ఇప్పుడు మేము విభిన్న వాదనలు కలిగి ఉన్న విభిన్న వస్తువులతో ఇతర నిర్మాణదారులను పిలవాలి.
ఆకారాలు;ఆకారం s2(8);
ఆకారం s3(4,2);
సృష్టించిన అదే వస్తువు ద్వారా మనం విలువను ప్రదర్శించగల ఫంక్షన్ అంటారు.
అవుట్‌పుట్‌ను వీక్షించడానికి, ఫైల్‌లో ఉన్న కోడ్‌ను కంపైల్ చేయడం మరియు అమలు చేయడం ద్వారా మేము అదే కమాండ్ టెర్మినల్ పద్ధతిని ఉపయోగిస్తాము.
అవుట్‌పుట్ నుండి, ప్రతి కన్స్ట్రక్టర్‌కు సమాధానం ఒకేలా ఉంటుందని మనం చూడవచ్చు.
ముగింపు
ఈ ట్యుటోరియల్‌లో, కన్స్ట్రక్టర్ల ప్రాథమికాలను మరియు వాటి కార్యాచరణలను, వాటిని ఎలా ఓవర్‌లోడ్ చేయాలో సహా చూశాము. కన్స్ట్రక్టర్లు విలువలతో వేరియబుల్స్ ప్రారంభించడానికి ఉపయోగించబడతాయి.