విషయము

• పోలిక చార్ట్:
• కన్స్ట్రక్టర్ యొక్క నిర్వచనం:
• కన్స్ట్రక్టర్ల రకాలు
• కన్స్ట్రక్టర్ అమలు:
• డిస్ట్రక్టర్ యొక్క నిర్వచనం:
• డిస్ట్రక్టర్ అమలు:
• డిస్ట్రక్టర్ అవసరం
• ముగింపు:

కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ వారి తరగతికి సమానమైన పేరుతో సభ్యుల విధులు. మునుపటి రకం తయారీదారు వస్తువును ప్రారంభించడంలో సహాయపడుతుంది. దీనికి విరుద్ధంగా, a డిస్ట్రాక్టర్ సృష్టించిన కన్స్ట్రక్టర్ ఉపయోగం లేనప్పుడు తొలగించే కన్స్ట్రక్టర్ నుండి భిన్నంగా ఉంటుంది.

కొన్నిసార్లు వస్తువు యొక్క కొంత భాగాన్ని ఉపయోగించుకునే ముందు దాన్ని ప్రారంభించాల్సిన అవసరం ఉంది. ఉదాహరణకు, మేము స్టాక్‌పై పనిచేస్తున్నాము, మేము ఏదైనా చర్య తీసుకునే ముందు, స్టాక్ పైభాగం ఎల్లప్పుడూ సున్నాకి సెట్ చేయాలి. ఆటోమేటిక్ ప్రారంభించడం యొక్క ఈ లక్షణం ‘కన్స్ట్రక్టర్’ ద్వారా జరుగుతుంది. ఒక వస్తువు నాశనం కావడానికి ముందే కొన్ని కోడ్‌ను అమలు చేయవలసి వస్తే. ఉదాహరణకు, ఒక వస్తువు దాని నాశనానికి ముందు, తెరిచిన ఫైల్‌ను మూసివేయాల్సిన అవసరం ఉంటే. దీన్ని ‘డిస్ట్రక్టర్’ సహాయంతో చేయవచ్చు.

పోలిక చార్ట్ సహాయంతో కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ మధ్య కొన్ని ప్రాథమిక తేడాలను అవలోకనం చేద్దాం

1. పోలిక చార్ట్
2. నిర్వచనం
3. కీ తేడాలు
4. ముగింపు

పోలిక చార్ట్:

పోలిక కోసం ఆధారం	నమూనా రచయిత	డిస్ట్రాక్టర్
పర్పస్	ఇది ఒక వస్తువుకు మెమరీని కేటాయిస్తుంది.	ఇది ఒక వస్తువు యొక్క జ్ఞాపకశక్తిని తొలగిస్తుంది.
ప్రకటన	class_name (వాదనలు ఉంటే) {};	~ class_name (వాదనలు లేవు) {};
వాదనలు	కన్స్ట్రక్టర్ వాదనను అంగీకరిస్తాడు	డిస్ట్రక్టర్ ఏ వాదనను అంగీకరించడు.
కాలింగ్	కన్స్ట్రక్టర్ స్వయంచాలకంగా పిలువబడుతుంది, అయితే వస్తువు సృష్టించబడుతుంది.	బ్లాక్ నిష్క్రమించినప్పుడు లేదా ప్రోగ్రామ్ ముగుస్తున్నందున డిస్ట్రక్టర్ స్వయంచాలకంగా పిలువబడుతుంది.
వర్కింగ్	కన్స్ట్రక్టర్ ఒక వస్తువును దాని విలువలో కొంత ముందు ప్రారంభించడానికి అనుమతిస్తుంది, అది ఉపయోగించబడుతుంది.	డిస్ట్రక్టర్ ఒక వస్తువును నాశనం చేసే సమయంలో కొన్ని కోడ్‌ను అమలు చేయడానికి అనుమతిస్తుంది.
అమలు యొక్క ఆర్డర్	కన్స్ట్రక్టర్‌ను వరుస క్రమంలో పిలుస్తారు.	కన్స్ట్రక్టర్ యొక్క రివర్స్ ఆర్డర్లో డిస్ట్రక్టర్ అంటారు.
సంఖ్యలలో	ఒక తరగతిలో బహుళ కన్స్ట్రక్టర్లు ఉండవచ్చు.	తరగతిలో ఎప్పుడూ ఒకే డిస్ట్రక్టర్ ఉంటుంది.
కన్స్ట్రక్టర్‌ను కాపీ చేయండి	కాపీ కన్స్ట్రక్టర్ ఒక కన్స్ట్రక్టర్ మరొక వస్తువు నుండి ఒక వస్తువును ప్రకటించడానికి మరియు ప్రారంభించడానికి అనుమతిస్తుంది.	అలాంటి కాన్సెప్ట్ లేదు.
ఓవర్ లోడింగ్	కన్స్ట్రక్టర్లను ఓవర్లోడ్ చేయవచ్చు.	డిస్ట్రక్టర్ ఓవర్లోడ్ చేయబడదు.

కన్స్ట్రక్టర్ యొక్క నిర్వచనం:

ఒక తయారీదారు ప్రాథమికంగా తరగతి యొక్క సభ్యుల ఫంక్షన్, ఇది వస్తువును ప్రారంభిస్తుంది మరియు దానికి మెమరీని కేటాయిస్తుంది. కన్స్ట్రక్టర్లను తరగతి పేరుతోనే డిక్లేర్ చేసి నిర్వచించినందున వాటిని సులభంగా గుర్తించవచ్చు. కన్స్ట్రక్టర్‌కు తిరిగి వచ్చే రకం లేదు; కాబట్టి, వారు దేనినీ తిరిగి ఇవ్వరు, ‘శూన్యమైనది’ కూడా కాదు. ఒక కన్స్ట్రక్టర్ ఎల్లప్పుడూ తరగతి యొక్క పబ్లిక్ విభాగంలో నిర్వచించబడుతుంది.

ఒక తరగతిలో బహుళ కన్స్ట్రక్టర్లు ఉండవచ్చు; ఆమోదించిన వాదనల సంఖ్య మరియు రకం ఆధారంగా వాటిని వేరు చేయవచ్చు. ఒక తరగతిలో బహుళ కన్స్ట్రక్టర్లు ఉంటే; అవ్యక్త కన్స్ట్రక్టర్ (డూ-నథింగ్ కన్స్ట్రక్టర్) వారితో పాటు నిర్వచించబడాలి; ఇది ఏమీ చేయదు, కంపైలర్ను సంతృప్తిపరుస్తుంది.

కన్స్ట్రక్టర్లను డిఫాల్ట్ ఆర్గ్యుమెంట్లతో కూడా నిర్వచించవచ్చు. అయితే, వారు “డైనమిక్‌గా” వస్తువును కూడా ప్రారంభిస్తారు. కన్స్ట్రక్టర్లను వారసత్వంగా పొందలేము, లేదా అది వర్చువల్ కావచ్చు కానీ, వాటిని ఓవర్‌లోడ్ చేయవచ్చు. వారిని వారి చిరునామాకు సూచించలేరు.

కన్స్ట్రక్టర్ల రకాలు

ప్రాథమికంగా మూడు రకాల కన్స్ట్రక్టర్లు ఉన్నాయి- డిఫాల్ట్, పారామీటరైజ్డ్ మరియు కాపీ కన్స్ట్రక్టర్స్.

• డిఫాల్ట్ కన్స్ట్రక్టర్: ఇది కన్స్ట్రక్టర్, ఇక్కడ కన్స్ట్రక్టర్కు ఎటువంటి వాదన ఇవ్వబడదు. డిఫాల్ట్ కన్స్ట్రక్టర్‌కు పరామితి లేదు, కానీ డిఫాల్ట్ కన్స్ట్రక్టర్‌కు విలువలు అప్రమేయంగా (డైనమిక్‌గా) పంపబడతాయి.
• పారామీటర్ చేయబడిన కన్స్ట్రక్టర్: ఈ రకమైన కన్స్ట్రక్టర్ వాదనలు తీసుకుంటారు; మేము డేటా సభ్యులకు వేర్వేరు విలువలను వాదనలుగా పంపవచ్చు.
• కన్స్ట్రక్టర్‌ను కాపీ చేయండి: కాపీ కన్స్ట్రక్టర్ ఇతర రకాల కన్స్ట్రక్టర్ల నుండి భిన్నంగా ఉంటుంది ఎందుకంటే ఇది ఇతర వస్తువు యొక్క చిరునామాను వాదనగా అంగీకరిస్తుంది.

కన్స్ట్రక్టర్ అమలు:

తరగతి కాన్స్టాంట్ a, బి; పబ్లిక్: పరామితి లేని const () // కన్స్ట్రక్టర్ {a = 0; బి = 0; } Const (int c, int d) a // పరామితి a = c తో కన్స్ట్రక్టర్; c = d; }}; int main () {Const C1; C2 (10,20); // ఈ ప్రకటన కన్స్ట్రక్టర్‌ను పిలుస్తుంది}

C1 సృష్టించబడినప్పుడు, పారామితి లేని కన్స్ట్రక్టర్ అమలు చేయబడదు, ఎందుకంటే C1 ఏ పరామితిని దాటదు. అయితే, C2 సృష్టించబడినప్పుడు పారామితితో ఒక కన్స్ట్రక్టర్ అమలు అవుతుంది, ఎందుకంటే ఇది రెండు పూర్ణాంకాలను కన్స్ట్రక్టర్‌కు పంపుతుంది.

డిస్ట్రక్టర్ యొక్క నిర్వచనం:

ఒక డిస్ట్రాక్టర్ ఒక తరగతి యొక్క సభ్యుల ఫంక్షన్, ఇది ఒక వస్తువుకు కేటాయించిన మెమరీని తొలగిస్తుంది. ఇది ఒక తరగతి పేరుతో నిర్వచించబడింది, ముందు a టిల్డ్ (~) చిహ్నం. కన్స్ట్రక్టర్ల రివర్స్ క్రమంలో డిస్ట్రక్టర్లను ఎల్లప్పుడూ పిలుస్తారు.

ఒక తరగతిలో ఒకే డిస్ట్రక్టర్ ఎల్లప్పుడూ ఉంటుంది, ఎందుకంటే ఇది ఎటువంటి వాదనలను అంగీకరించదు. అమలు యొక్క నియంత్రణ బ్లాక్ను విడిచిపెట్టిన వెంటనే స్థానిక వస్తువులు నాశనం అవుతాయి; మరోవైపు, మొత్తం ప్రోగ్రామ్ ముగిసినప్పుడు ప్రపంచ వస్తువులు నాశనం అవుతాయి. ఒక డిస్ట్రక్టర్‌ను కంపైలర్ చేత పరోక్షంగా పిలుస్తారు. తరగతులు వారసత్వంగా పొందినట్లయితే, మరియు ఒక తరగతి మాతృ తరగతి నుండి ఉద్భవించినట్లయితే, మరియు పిల్లల తరగతి మరియు తల్లిదండ్రుల తరగతి రెండింటిలోనూ డిస్ట్రక్టర్లు ఉంటే; అప్పుడు, ఉత్పన్నమైన తరగతి యొక్క డిస్ట్రక్టర్‌ను మొదట పిలుస్తారు, తరువాత మాతృ తరగతి యొక్క డిస్ట్రక్టర్.

డిస్ట్రక్టర్ అమలు:

తరగతి కాన్స్టాంట్ a, బి; పబ్లిక్: పరామితితో const (int c, int d) // కన్స్ట్రక్టర్. {a = సి; c = d; cout << "a మరియు b యొక్క విలువ" <<>

C1 ఆబ్జెక్ట్ సృష్టించబడినప్పుడు, పూర్ణాంక రకం యొక్క రెండు పారామితులతో ఒక కన్స్ట్రక్టర్ ప్రారంభించబడుతుంది మరియు సభ్యుడు “a, b” ప్రారంభించబడుతుంది మరియు “a, b” యొక్క విలువ సంకలనం చేయబడుతుంది. ఆ డిస్ట్రక్టర్ ఆరంభించిన తరువాత మరియు “ఆబ్జెక్ట్ సి 1 నాశనం అవుతుంది”.

డిస్ట్రక్టర్ అవసరం

కన్స్ట్రక్టర్ యొక్క సృష్టి కొంత మొత్తంలో మెమరీ స్థలాన్ని వినియోగిస్తుంది, ఎందుకంటే ఇది చివరికి వస్తువులకు మెమరీని కేటాయిస్తుంది. ఇతర పనుల కోసం వనరులను విడిపించేందుకు వస్తువులను నాశనం చేయడానికి ముందు ఈ కేటాయించిన మెమరీని డీలోకేట్ చేయాలి. ఉద్దేశించిన ప్రయోజనం కోసం డిస్ట్రక్టర్లు చాలా ఉపయోగకరంగా ఉంటాయి, ఇది వస్తువులను సమర్థవంతంగా నాశనం చేస్తుంది మరియు మెమరీని విడుదల చేయడానికి శుభ్రపరిచే పనులను నిర్వహిస్తుంది.

1. కన్స్ట్రక్టర్ యొక్క ప్రాధమిక ఉద్దేశ్యం వస్తువులు సృష్టించబడినప్పుడు వాటికి మెమరీని కేటాయించడం. దీనికి విరుద్ధంగా, డిస్ట్రక్టర్ యొక్క ముఖ్య ఉద్దేశ్యం వస్తువు నాశనం అయినప్పుడు దాని జ్ఞాపకశక్తిని విడదీయడం.
2. తరగతి యొక్క డేటా సభ్యులను ప్రారంభించడానికి వాదనలు ఉపయోగించబడుతున్నందున వాదనలను అంగీకరించడానికి ఒక కన్స్ట్రక్టర్ అనుమతించబడతాడు. మరోవైపు, ఒక డిస్ట్రక్టర్ ఎటువంటి వాదనలను అంగీకరించడు ఎందుకంటే దాని యొక్క ఏకైక పని వస్తువు యొక్క జ్ఞాపకశక్తిని విడదీయడం.
3. ఒక వస్తువు సృష్టించబడినప్పుడు కన్స్ట్రక్టర్ అంటారు. దీనికి విరుద్ధంగా, ఒక ప్రోగ్రామ్ ముగిసినప్పుడు లేదా ప్రోగ్రామ్ ఒక వస్తువు సృష్టించబడిన బ్లాక్ నుండి నిష్క్రమించినప్పుడు డిస్ట్రక్టర్ అంటారు.
4. తరగతి యొక్క డేటా సభ్యులను ప్రారంభించడానికి సాధారణంగా ఒక కన్స్ట్రక్టర్ ఉపయోగించబడుతుంది, అయితే వస్తువు నాశనం కావడానికి ముందే కొంత చర్యను చేయటానికి ఒక డిస్ట్రక్టర్ ఉపయోగించబడుతుంది.
5. కన్స్ట్రక్టర్లు వరుస క్రమంలో అమలు చేయబడతారు, అంటే బేస్ క్లాస్‌ను వారసత్వంగా పొందిన ఉత్పన్న తరగతి ఉంటే మరియు ఉత్పన్నమైన తరగతి యొక్క వస్తువు సృష్టించబడితే అది మొదట బేస్ క్లాస్ యొక్క కన్స్ట్రక్టర్‌ను మరియు తరువాత ఉత్పన్నమైన క్లాస్ యొక్క కన్స్ట్రక్టర్ అని పిలుస్తుంది. దీనికి విరుద్ధంగా, ఉత్పన్నమైన తరగతి యొక్క డిస్ట్రక్టర్‌ను మొదట అంటారు మరియు తరువాత బేస్ క్లాస్ అంటే కన్స్ట్రక్టర్ యొక్క రివర్స్ ఆర్డర్‌లో ఒక డిస్ట్రక్టర్ అమలు చేయబడుతుంది.
6. తరగతిలో, బహుళ కన్స్ట్రక్టర్లు ఉండవచ్చు, అవి ఆమోదించిన సంఖ్య వాదనలు ద్వారా గుర్తించబడతాయి, అయితే దీనికి ఒకే ఒక డిస్ట్రక్టర్ మాత్రమే ఉంటుంది.
7. కాపీ కన్స్ట్రక్టర్ యొక్క భావన ఉంది, ఇది ఒక వస్తువును మరొక వస్తువు నుండి ప్రారంభించటానికి అనుమతిస్తుంది, అయితే డిస్ట్రక్టర్‌కు అలాంటి భావన లేదు.
8. ఒకే కన్స్ట్రక్టర్ పేరుతో విభిన్న చర్యలను చేయడానికి కన్స్ట్రక్టర్లను ఓవర్లోడ్ చేయవచ్చు. దీనికి విరుద్ధంగా, డిస్ట్రక్టర్లను ఓవర్లోడ్ చేయలేరు.

ముగింపు:

సారూప్యతతో పాటు, ఆ కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ ఒక తరగతి యొక్క ప్రత్యేక సభ్యుల ఫంక్షన్ మరియు ఒకే పేరును కలిగి ఉంటారు, ఈ రెండింటిలో ముఖ్యమైన వ్యత్యాసం ఏమిటంటే, 'కన్స్ట్రక్టర్' ను మెమరీ కేటాయింపు సమయంలో పిలుస్తారు మరియు 'డిస్ట్రక్టర్' అని పిలుస్తారు వస్తువుల మెమరీ తొలగింపు సమయం. కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ రెండింటినీ తరగతిలో నిర్వచించనప్పటికీ కంపైలర్ చేత పరోక్షంగా పిలుస్తారు.