నిర్మాణం మరియు తరగతి మధ్య వ్యత్యాసం
విషయము
ఒక నిర్మాణం మరియు తరగతి రెండూ అనుకూలీకరించిన డేటా రకాన్ని సృష్టించడానికి ఒక మార్గాన్ని అందిస్తుంది, ఇది ఉదాహరణలను సృష్టించడానికి మరింత ఉపయోగించబడుతుంది. C ++ ఒక తరగతిని సృష్టించడానికి నిర్మాణం యొక్క పాత్రను విస్తరిస్తుంది. నిర్మాణం మరియు తరగతి రెండూ, ఒక తేడా మినహా అన్ని విధాలుగా సమానంగా ఉంటాయి, అప్రమేయంగా నిర్మాణం దాని సభ్యులందరినీ “పబ్లిక్” గా కలిగి ఉంటుంది మరియు అప్రమేయంగా తరగతి దాని సభ్యులందరినీ “ప్రైవేట్” గా కలిగి ఉంటుంది. పోలిక చార్ట్ ఉపయోగించి నిర్మాణం మరియు తరగతి మధ్య వ్యత్యాసాన్ని అధ్యయనం చేద్దాం.
- పోలిక చార్ట్
- నిర్వచనం
- కీ తేడాలు
- సారూప్యతలు
- ముగింపు
పోలిక చార్ట్
| పోలిక కోసం ఆధారం | నిర్మాణం | క్లాస్ |
|---|---|---|
| ప్రాథమిక | యాక్సెస్ స్పెసిఫైయర్ ప్రకటించకపోతే, అప్రమేయంగా సభ్యులందరూ పబ్లిక్. | యాక్సెస్ స్పెసిఫైయర్ ప్రకటించకపోతే, అప్రమేయంగా సభ్యులందరూ ప్రైవేట్. |
| ప్రకటన | struct structure_name { struct_element 1 అని టైప్ చేయండి; struct_element 2 అని టైప్ చేయండి; struct_element 3; . . . }; | తరగతి తరగతి_పేరు { డేటా సభ్యుడు; సభ్యుల ఫంక్షన్; }; |
| ఇన్స్టాన్స్ | నిర్మాణం యొక్క ఉదాహరణను స్ట్రక్చర్ వేరియబుల్ అంటారు. | తరగతి యొక్క ఉదాహరణను వస్తువు అంటారు. |
నిర్మాణం యొక్క నిర్వచనం
ఒక నిర్మాణం అనేది అసమాన డేటా రకాల వేరియబుల్స్ యొక్క సమాహారం, అన్నీ ఒకే పేరుతో సూచించబడతాయి. ఒక నిర్మాణ ప్రకటన నిర్మాణం యొక్క ఉదాహరణను సృష్టించడానికి ఉపయోగించే ఒక టెంప్లేట్‌ను రూపొందిస్తుంది. నిర్మాణం ఫాలోగా ప్రకటించబడింది.
struct sname {type struct_element1; struct_element2 అని టైప్ చేయండి; struct_element3 అని టైప్ చేయండి; . . . } వేరియబుల్ 1, వేరియబుల్ 2 ,. . .;
‘Struct’ అనే కీవర్డ్ కంపైలర్కు ఒక నిర్మాణం ప్రకటించబడుతుందని నిర్వచిస్తుంది. ‘స్నేమ్’ నిర్మాణానికి ఇచ్చిన పేరును సూచిస్తుంది. నిర్మాణ ప్రకటన ఎల్లప్పుడూ సెమికోలన్ చేత ముగించబడుతుంది, ఎందుకంటే ఇది ఒక ప్రకటనగా పరిగణించబడుతుంది. నిర్మాణం యొక్క ముగింపును పైన పేర్కొన్న కోడ్ (వేరియబుల్ 1, వేరియబుల్ 2) లో చేసినట్లుగా మీరు ప్రకటించవచ్చు లేదా నిర్మాణం యొక్క పేరును ముందుగా () పేరుతో వ్రాయడం ద్వారా నిర్మాణం యొక్క ఉదాహరణను ప్రధాన () లో ప్రకటించవచ్చు.
// ఉదాహరణ. ప్రధాన () {స్నేమ్ ఎస్ 1, ఎస్ 2; }
ఇక్కడ S1 మరియు S2 నిర్మాణం యొక్క ఉదాహరణలు. నిర్మాణం యొక్క ఉదాహరణలను “స్ట్రక్చర్ వేరియబుల్” అంటారు. బాడీ ఆఫ్ స్ట్రక్చర్ లోపల డిక్లేర్డ్ ఎలిమెంట్‌ను డాట్ (.) ఆపరేటర్ వాడకం ద్వారా స్ట్రక్చర్ వేరియబుల్స్ ద్వారా యాక్సెస్ చేయవచ్చు.
// ఉదాహరణ ఎస్ 1. struct_element1;
- నిర్మాణం యొక్క శ్రేణిని కూడా సృష్టించవచ్చు, దీని కోసం, మీరు మొదట ఒక నిర్మాణాన్ని ప్రకటించాలి, ఆపై, ఆ రకమైన శ్రేణిని ప్రకటించాలి.
// నమూనా స్ట్రక్ట్ స్నేమ్ సర్రే;
పై స్టేట్మెంట్ పది వేరియబుల్ కలిగి ఉన్న ‘సారే’ పేరుతో ఒక శ్రేణిని సృష్టిస్తుంది మరియు ప్రతి వేరియబుల్ ‘స్నేమ్’ లో నిర్వచించిన విధంగా నిర్వహించబడుతుంది.
- మీరు ఒక ఫంక్షన్ సభ్యునికి ఒక ఫంక్షన్‌కు పంపవచ్చు మరియు మీరు మొత్తం నిర్మాణాన్ని ఒక ఫంక్షన్‌కు పంపవచ్చు.
- స్ట్రక్చర్ వేరియబుల్స్ పేరు ముందు ‘*’ ఉంచడం ద్వారా పూర్ణాంక పాయింటర్, అర్రే పాయింటర్ వంటి స్ట్రక్చర్ పాయింటర్‌ను కూడా ప్రకటించవచ్చు.
// నమూనా స్ట్రక్ట్ స్నేమ్ * ఎస్ 1;
గమనిక:
‘స్ట్రక్చర్’ ఎలిమెంట్స్ ఒక పరస్పర మెమరీ స్థానంలో నిల్వ చేయబడతాయి.
తరగతి నిర్వచనం
OOP లోని క్లాస్ క్రొత్త రకాన్ని నిర్వచిస్తుంది, ఇది డేటా సభ్యులు మరియు సభ్యుల పనితీరును కలిగి ఉంటుంది, అవి తరగతి యొక్క డేటా సభ్యులను యాక్సెస్ చేయడానికి ఉపయోగించబడతాయి. తరగతుల ఉదంతాలను "వస్తువులు" అని పిలుస్తారు, వీటిలో ప్రతి ఒక్కటి తరగతికి సమానమైన సంస్థను కలిగి ఉంటాయి. తరగతి ఒక తార్కిక సంగ్రహణ, అయితే, ఒక వస్తువుకు భౌతిక ఉనికి ఉంది. తరగతి నిర్మాణానికి సమానంగా ఉంటుంది. తరగతిని ఫాలోగా ప్రకటించవచ్చు.
తరగతి తరగతి_పేరు {ప్రైవేట్ డేటా సభ్యులు మరియు సభ్యుల విధులు. యాక్సెస్_స్పెసిఫైయర్ రకం డేటా_మెంబర్; mem_funct (పారామితి జాబితా) type అని టైప్ చేయండి. . }} వస్తువు జాబితా;
ఇక్కడ, క్లాస్ అనేది ఒక క్లాస్ అని ప్రకటించబడిన కంపైలర్కు ప్రకటించే కీవర్డ్. OOP యొక్క ప్రధాన లక్షణం డేటా దాచడం, ఇది "పబ్లిక్", "ప్రైవేట్", "రక్షిత" అనే మూడు యాక్సెస్ స్పెసిఫైయర్లను అందించడం ద్వారా సాధించబడుతుంది. డేటా సభ్యులు లేదా సభ్యుల విధులను ప్రకటించేటప్పుడు మీరు తరగతిలో ఏదైనా యాక్సెస్ స్పెసిఫైయర్ను పేర్కొనకపోతే, అప్రమేయంగా అన్నీ ప్రైవేట్‌గా పరిగణించబడతాయి. పబ్లిక్ యాక్సెస్ స్పెసిఫైయర్ మీ ప్రోగ్రామ్ యొక్క ఇతర భాగాల ద్వారా యాక్సెస్ చేయడానికి, ఫంక్షన్లు లేదా డేటాను అనుమతిస్తుంది. తరగతి యొక్క ప్రైవేట్ సభ్యులను ఆ తరగతి సభ్యుడు మాత్రమే యాక్సెస్ చేయవచ్చు. రక్షిత యాక్సెస్ స్పెసిఫైయర్ వారసత్వ సమయంలో వర్తించబడుతుంది. మీరు యాక్సెస్ స్పెసిఫైయర్ను ప్రకటించిన తర్వాత, అది ప్రోగ్రామ్ అంతటా మార్చబడదు.
వస్తువులు తరగతుల ఉదాహరణ తప్ప మరొకటి కాదు. తరగతి సభ్యులను డాట్ (.) ఆపరేటర్ ఉపయోగించి ఒకే తరగతి వస్తువు ద్వారా యాక్సెస్ చేస్తారు.
//object.mem_funct (వాదనలు);
- వస్తువును ఒక ఫంక్షన్‌కు వాదనగా కూడా పంపవచ్చు.
- ఒక వస్తువుకు పాయింటర్ కూడా సృష్టించవచ్చు.
- నిర్మాణాలు మరియు తరగతుల మధ్య ప్రధాన వ్యత్యాసం ఏమిటంటే, అప్రమేయంగా నిర్మాణంలోని సభ్యులందరూ పబ్లిక్ అయితే, అప్రమేయంగా తరగతి సభ్యులందరూ ప్రైవేట్‌గా ఉంటారు.
సారూప్యతలు:
- C ++ లో నిర్మాణం మరియు తరగతి రెండూ వాక్యనిర్మాణంగా సమానం.
- నిర్మాణం మరియు తరగతి రెండూ వారి సభ్యులలో కొంతమందిని ప్రైవేట్‌గా ప్రకటించగలవు.
- నిర్మాణం లేదా తరగతి పేరును స్టాండ్-ఒంటరిగా రకంగా ఉపయోగించవచ్చు.
- నిర్మాణం మరియు తరగతి రెండూ వారసత్వ యంత్రాంగానికి మద్దతు ఇస్తాయి.
ముగింపు:
సిలోని నిర్మాణానికి కొంత పరిమితి ఉంది, ఎందుకంటే నిర్మాణం డేటాను దాచడానికి నిర్మాణం అనుమతించదు, ‘స్ట్రక్ట్’ డేటాటైప్‌ను అంతర్నిర్మిత రకాలుగా పరిగణించలేము, నిర్మాణాలు వారసత్వానికి మద్దతు ఇవ్వవు. C ++ లోని నిర్మాణం ఈ పరిమితులను అధిగమించింది. C ++ లో, తరగతులు నిర్మాణం యొక్క విస్తరించిన సంస్కరణ. ప్రోగ్రామర్ డేటాను పట్టుకోవటానికి తరగతిని ఉపయోగించడం సులభం మరియు రెండింటినీ పని చేయడం మరియు డేటాను పట్టుకోవటానికి మాత్రమే నిర్మాణం.
