Skip to content

GitLab

H
Hindi-Telugu-Data
Commit 956c0d4e authored by Vandan Mujadia's avatar Vandan Mujadia
Browse files
Options

update

parent 43fe9c4f
Show whitespace changes
Inline Side-by-side
Showing with 7442 additions and 7455 deletions
inhouse/NPTEL/PreFinal/c++/Telugu/04. ProgramminginCplusplus_Template (Function Template) Part II (Lecture 55)-MNoPTVrsXZs.txt
View file @ 956c0d4e
 1.  ప్రోగ్రామింగ్ C ++ లో మాడ్యూల్ 39 కు స్వాగతం.
2. మేము టెంప్లేట్లు(templates) లేదా జెనరిక్(generic) ప్రోగ్రామింగ్, C ++ లో మెటా ప్రోగ్రామింగ్ గురించి చర్చించాము, ఇక్కడ మేము కొన్ని విధులు, టెంప్లేట్ చేయబడిన ఫంక్షన్లు, ఒకటి లేదా అంతకంటే ఎక్కువ రకం వేరియబుల్స్తో(variables) పారామీటర్డ్(parameterized) ఫంక్షన్లను వ్రాయవచ్చు.
3. తదనుగుణంగా వివిధ పారామిరైజ్డ్ రకాలను ఎక్ష్ప్లిసిట్(explicit) లేదా ఇంప్లిసిట్ వేర్వేరు ఫంక్షన్ పొందవచ్చు ఓవర్లోడ్(overload) గా ఉత్పత్తి మరియు పొందవచ్చు.
4. మేము మునుపటి మాడ్యూల్‌లో లోతును చూశాము.
  ప్రోగ్రామింగ్ C ++ లో మాడ్యూల్ 39 కు స్వాగతం.
మేము టెంప్లేట్లు(templates) లేదా జెనరిక్(generic) ప్రోగ్రామింగ్, C ++ లో మెటా ప్రోగ్రామింగ్ గురించి చర్చించాము, ఇక్కడ మేము కొన్ని విధులు, టెంప్లేట్ చేయబడిన ఫంక్షన్లు, ఒకటి లేదా అంతకంటే ఎక్కువ రకం వేరియబుల్స్తో(variables) పారామీటర్డ్(parameterized) ఫంక్షన్లను వ్రాయవచ్చు.
తదనుగుణంగా వివిధ పారామిరైజ్డ్ రకాలను ఎక్ష్ప్లిసిట్(explicit) లేదా ఇంప్లిసిట్ వేర్వేరు ఫంక్షన్ పొందవచ్చు ఓవర్లోడ్(overload) గా ఉత్పత్తి మరియు పొందవచ్చు.
మేము మునుపటి మాడ్యూల్‌లో లోతును చూశాము.
5. మేము ఇంతకుముందు టెంప్లేట్ చేసిన రూపంలో వ్రాసిన మాక్స్ ఫంక్షన్ (ఫంక్షన్) యొక్క ఉదాహరణను లోతుగా చూశాము, దానిని పూర్ణాంకం మరియు డబుల్ కోసం ఉపయోగించాము మరియు తరువాత మేము దానిని సి తీగలకు ప్రత్యేకత చేసాము మరియు తరువాత ఈ వినియోగదారు కోసం కూడా నిర్వచించమని చూపించాము కాంప్లెక్స్ వంటి రకాలు.
మేము ఇంతకుముందు టెంప్లేట్ చేసిన రూపంలో వ్రాసిన మాక్స్ ఫంక్షన్ (ఫంక్షన్) యొక్క ఉదాహరణను లోతుగా చూశాము, దానిని పూర్ణాంకం మరియు డబుల్ కోసం ఉపయోగించాము మరియు తరువాత మేము దానిని సి తీగలకు ప్రత్యేకత చేసాము మరియు తరువాత ఈ వినియోగదారు కోసం కూడా నిర్వచించమని చూపించాము కాంప్లెక్స్ వంటి రకాలు.
6. ప్రస్తుత మాడ్యూల్‌లో, మేము దానిపై కొనసాగుతాము మరియు మా దృష్టి C ++ లోని ఇతర రకాల టెంప్లేట్‌లపై ఉంటుంది, వీటిని క్లాస్ టెంప్లేట్లు అంటారు.
ప్రస్తుత మాడ్యూల్‌లో, మేము దానిపై కొనసాగుతాము మరియు మా దృష్టి C ++ లోని ఇతర రకాల టెంప్లేట్‌లపై ఉంటుంది, వీటిని క్లాస్ టెంప్లేట్లు అంటారు.
7. ఇది రూపురేఖలు మరియు మేము చర్చించే నీలం విభాగం మీ స్క్రీన్ యొక్క ఎడమ వైపున అందుబాటులో ఉంటుంది.
ఇది రూపురేఖలు మరియు మేము చర్చించే నీలం విభాగం మీ స్క్రీన్ యొక్క ఎడమ వైపున అందుబాటులో ఉంటుంది.
8. ఇది శీఘ్ర పునరావృతం కోసం మాత్రమే, ఒక టెంప్లేట్ అంటే ఏమిటో మనం చూస్తాము మరియు దానిలో కొంత భాగాన్ని చూశాము.
ఇది శీఘ్ర పునరావృతం కోసం మాత్రమే, ఒక టెంప్లేట్ అంటే ఏమిటో మనం చూస్తాము మరియు దానిలో కొంత భాగాన్ని చూశాము.
9. మరియు ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ సందర్భంలో, ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ (టెంప్లేట్) ప్రాథమికంగా అల్గోరిథంలో కోడ్ పునర్వినియోగం అని మేము చూశాము.
మరియు ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ సందర్భంలో, ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ (టెంప్లేట్) ప్రాథమికంగా అల్గోరిథంలో కోడ్ పునర్వినియోగం అని మేము చూశాము.
10. కాబట్టి, మీకు సెర్చ్ అల్గోరిథం ఉంది, మాకు సార్టింగ్ అల్గోరిథం ఉంది, మాకు కనీస అల్గోరిథం ఉంది, మాకు సగటు అల్గోరిథం ఉంది.
కాబట్టి, మీకు సెర్చ్ అల్గోరిథం ఉంది, మాకు సార్టింగ్ అల్గోరిథం ఉంది, మాకు కనీస అల్గోరిథం ఉంది, మాకు సగటు అల్గోరిథం ఉంది.
11. C ++ లో, దీని కోసం కోడ్ ప్రత్యేకంగా మూలకం రకం ఆధారంగా తిరిగి ఇవ్వబడుతుంది.
C ++ లో, దీని కోసం కోడ్ ప్రత్యేకంగా మూలకం రకం ఆధారంగా తిరిగి ఇవ్వబడుతుంది.
12. ఏదేమైనా, సాధారణంగా అల్గోరిథం మూలకం రకాలను బట్టి మారదు, కాబట్టి టెంప్లేట్‌ను ఉపయోగించడం ద్వారా, ఈ ఫంక్షన్ (ఫంక్షన్) కోడ్ (కోడ్), శోధనలు, కనిష్ట, సగటును క్రమబద్ధీకరించే ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ (టెంప్లేట్) ను వ్రాయవచ్చు.  వాటన్నింటినీ సాధారణ రూపంలో వ్రాయవచ్చు మరియు వెంటనే ఆ రకాన్ని బట్టి ఉంటుంది.
ఏదేమైనా, సాధారణంగా అల్గోరిథం మూలకం రకాలను బట్టి మారదు, కాబట్టి టెంప్లేట్‌ను ఉపయోగించడం ద్వారా, ఈ ఫంక్షన్ (ఫంక్షన్) కోడ్ (కోడ్), శోధనలు, కనిష్ట, సగటును క్రమబద్ధీకరించే ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ (టెంప్లేట్) ను వ్రాయవచ్చు.  వాటన్నింటినీ సాధారణ రూపంలో వ్రాయవచ్చు మరియు వెంటనే ఆ రకాన్ని బట్టి ఉంటుంది.
13. ఇప్పుడు, డేటా స్ట్రక్చర్ పరంగా కోడ్ పునర్వినియోగాన్ని పరిశీలిస్తే మనం ఎక్కువ చేయవచ్చు.
ఇప్పుడు, డేటా స్ట్రక్చర్ పరంగా కోడ్ పునర్వినియోగాన్ని పరిశీలిస్తే మనం ఎక్కువ చేయవచ్చు.
14. ఉదాహరణకు, ఒక స్టాక్‌ను పరిగణించండి, మొదటిది చివరిది.
ఉదాహరణకు, ఒక స్టాక్‌ను పరిగణించండి, మొదటిది చివరిది.
15. ఉదాహరణకు మీరు పేర్చే అనేక సమస్యలు ఉన్నాయి, శీర్షాన్ని బ్యాక్‌ట్రాక్ చేయడానికి అక్షరాల స్టాక్ అవసరం.
ఉదాహరణకు మీరు పేర్చే అనేక సమస్యలు ఉన్నాయి, శీర్షాన్ని బ్యాక్‌ట్రాక్ చేయడానికి అక్షరాల స్టాక్ అవసరం.
16. పోస్ట్‌ఫిక్స్‌లోని వ్యక్తీకరణ మరియు ఇన్ఫిక్స్ వ్యక్తీకరణకు మళ్ళీ అక్షరాల స్టాక్ అవసరం.
పోస్ట్‌ఫిక్స్‌లోని వ్యక్తీకరణ మరియు ఇన్ఫిక్స్ వ్యక్తీకరణకు మళ్ళీ అక్షరాల స్టాక్ అవసరం.
17. ఉపసర్గ వ్యక్తీకరణల మూల్యాంకనానికి మనం అంచనా వేయదలిచిన పూర్ణాంక, డబుల్, సంక్లిష్టమైన వివిధ రకాల రకాలు అవసరం.
ఉపసర్గ వ్యక్తీకరణల మూల్యాంకనానికి మనం అంచనా వేయదలిచిన పూర్ణాంక, డబుల్, సంక్లిష్టమైన వివిధ రకాల రకాలు అవసరం.
18. మూడు లోతుకు మొదటి మూడు నోడ్‌ల యొక్క నోడ్ పాయింటర్ (రకం) స్టాక్ అవసరం.
మూడు లోతుకు మొదటి మూడు నోడ్‌ల యొక్క నోడ్ పాయింటర్ (రకం) స్టాక్ అవసరం.
19. అనేక సమస్యలు ఉండవచ్చు, దీనికి ఒక నిర్దిష్ట సమస్య పరిష్కారం కోసం వివిధ రకాల స్టాక్‌లు అవసరం.
అనేక సమస్యలు ఉండవచ్చు, దీనికి ఒక నిర్దిష్ట సమస్య పరిష్కారం కోసం వివిధ రకాల స్టాక్‌లు అవసరం.
20. ఇప్పుడు, మనకు అవసరమైనప్పుడు ఈ రకానికి ఒక స్టాక్ క్లాస్ రాయడం ఒక ఎంపిక, కాని మనం చూస్తున్నది కోడ్ యొక్క స్టాక్, దీనిని ఉదారంగా పిలుస్తారు, మనకు కావలసిన నిర్దిష్ట రకాన్ని వెంటనే ఇవ్వవచ్చు, ఎందుకంటే, పుష్, పాప్, టాప్, ఖాళీ మరియు మొదలైన ఇంటర్‌ఫేస్‌ల సమితితో స్టాక్ రూపంలో ఒక భావన మొదటిది., స్టాక్ ఉపయోగిస్తున్న నిర్దిష్ట మూలకం రకాన్ని బట్టి ఇది మారదు.
21. మీరు మరింత చూస్తే క్యూలో అదే సారూప్యతను మీరు కనుగొంటారు. ప్రాసెస్ షెడ్యూలింగ్ ఉపయోగించి టాస్క్ షెడ్యూలింగ్. క్యూ యూజర్కు చాలా సమస్యలు అవసరం, దీనికి స్టాక్ (స్టాక్) క్యూ అమలు చేయడం వంటి జాబితా అవసరం, అప్పుడు ఏదైనా వస్తువుల సేకరణలు మరియు మొదలైనవి.
ఇప్పుడు, మనకు అవసరమైనప్పుడు ఈ రకానికి ఒక స్టాక్ క్లాస్ రాయడం ఒక ఎంపిక, కాని మనం చూస్తున్నది కోడ్ యొక్క స్టాక్, దీనిని ఉదారంగా పిలుస్తారు, మనకు కావలసిన నిర్దిష్ట రకాన్ని వెంటనే ఇవ్వవచ్చు, ఎందుకంటే, పుష్, పాప్, టాప్, ఖాళీ మరియు మొదలైన ఇంటర్‌ఫేస్‌ల సమితితో స్టాక్ రూపంలో ఒక భావన మొదటిది., స్టాక్ ఉపయోగిస్తున్న నిర్దిష్ట మూలకం రకాన్ని బట్టి ఇది మారదు.
మీరు మరింత చూస్తే క్యూలో అదే సారూప్యతను మీరు కనుగొంటారు. ప్రాసెస్ షెడ్యూలింగ్ ఉపయోగించి టాస్క్ షెడ్యూలింగ్. క్యూ యూజర్కు చాలా సమస్యలు అవసరం, దీనికి స్టాక్ (స్టాక్) క్యూ అమలు చేయడం వంటి జాబితా అవసరం, అప్పుడు ఏదైనా వస్తువుల సేకరణలు మరియు మొదలైనవి.
22. క్లాస్ టెంప్లేట్లు కోడ్ పునర్వినియోగానికి ఒక పరిష్కారం, ఇక్కడ మీకు ఒకే ఇంటర్ఫేస్ మరియు అదే లేదా చాలా దగ్గరి అల్గోరిథంలు, సారూప్య అల్గోరిథంలు ఉన్న డేటా స్ట్రక్చర్ యొక్క సాధారణ భాగాన్ని మేము గుర్తిస్తాము, కాని మూలకం రకాలు కారణంగా అమలు భిన్నంగా ఉండాలి, వాటిని కలపడం సాధారణ సాధారణ తరగతి టెంప్లేట్ యొక్క సందర్భం.
క్లాస్ టెంప్లేట్లు కోడ్ పునర్వినియోగానికి ఒక పరిష్కారం, ఇక్కడ మీకు ఒకే ఇంటర్ఫేస్ మరియు అదే లేదా చాలా దగ్గరి అల్గోరిథంలు, సారూప్య అల్గోరిథంలు ఉన్న డేటా స్ట్రక్చర్ యొక్క సాధారణ భాగాన్ని మేము గుర్తిస్తాము, కాని మూలకం రకాలు కారణంగా అమలు భిన్నంగా ఉండాలి, వాటిని కలపడం సాధారణ సాధారణ తరగతి టెంప్లేట్ యొక్క సందర్భం.
23. కాబట్టి, స్పష్టంగా చెప్పాలంటే, ఇది ఎడమ మరియు కుడి, మీరు ఇక్కడ చూస్తే అది అక్షరాల స్టాక్, ఇది పాత్ర.
24. ఇవి ప్రత్యేకమైన కోడ్ పంక్తుల ఉల్లేఖనాలుగా చూపించబడతాయి, ఇవి రకం పరిజ్ఞానం అవసరం మరియు పూర్ణాంకాల స్టాక్, కాబట్టి ఇవి మీకు అవసరమైన పంక్తులు.
25. కాబట్టి మీరు ఇక్కడ పూర్ణాంకం, ఇక్కడ నాలుగు, మీరు ఇక్కడ నాలుగు, మీరు ఇక్కడ నాలుగు, మరియు ఇక్కడ పూర్ణాంకం.
26. ఇది కాకుండా, మిగిలిన కోడ్ కూడా ఒక ఫంక్షన్ (ఫంక్షన్) విషయంలో మాదిరిగానే టైప్ వేరియబుల్‌తో భర్తీ చేయకపోతే అదే విధంగా ఉంటుంది.
27. ఇది తరగతి టెంప్లేట్‌ను రకంతో ప్రామాణీకరించిన మరియు సభ్యుల విధులను కలిగి ఉంటుంది.
కాబట్టి, స్పష్టంగా చెప్పాలంటే, ఇది ఎడమ మరియు కుడి, మీరు ఇక్కడ చూస్తే అది అక్షరాల స్టాక్, ఇది పాత్ర.
ఇవి ప్రత్యేకమైన కోడ్ పంక్తుల ఉల్లేఖనాలుగా చూపించబడతాయి, ఇవి రకం పరిజ్ఞానం అవసరం మరియు పూర్ణాంకాల స్టాక్, కాబట్టి ఇవి మీకు అవసరమైన పంక్తులు.
కాబట్టి మీరు ఇక్కడ పూర్ణాంకం, ఇక్కడ నాలుగు, మీరు ఇక్కడ నాలుగు, మీరు ఇక్కడ నాలుగు, మరియు ఇక్కడ పూర్ణాంకం.
ఇది కాకుండా, మిగిలిన కోడ్ కూడా ఒక ఫంక్షన్ (ఫంక్షన్) విషయంలో మాదిరిగానే టైప్ వేరియబుల్‌తో భర్తీ చేయకపోతే అదే విధంగా ఉంటుంది.
ఇది తరగతి టెంప్లేట్‌ను రకంతో ప్రామాణీకరించిన మరియు సభ్యుల విధులను కలిగి ఉంటుంది.
28. మిగిలిన నిర్వచనం వివరాల కోసం మరియు ఉదాహరణను పరిశీలిస్తుంది.
మిగిలిన నిర్వచనం వివరాల కోసం మరియు ఉదాహరణను పరిశీలిస్తుంది.
29. కాబట్టి మనం చేసే స్టాక్ కోసం, మేము ఈ రకమైన మూలకం రకాన్ని T గా పారామితి చేస్తాము.
కాబట్టి మనం చేసే స్టాక్ కోసం, మేము ఈ రకమైన మూలకం రకాన్ని T గా పారామితి చేస్తాము.
30. మీరు చేసేటప్పుడు మీకు అవసరమైన స్థలాలను మీరు చూడవచ్చు కాబట్టి నేను టి అని ఎలిమెంట్ రకాన్ని తెలుసుకోవాలి. నేను అగ్రస్థానంలో ఉన్నప్పుడు ఎలిమెంట్ రకాన్ని తెలుసుకోవాలి, పాప్ చేయండి. తెలుసుకోవలసిన అవసరం లేదు, ఖలీ అవసరం లేదు తెలుసు.
మీరు చేసేటప్పుడు మీకు అవసరమైన స్థలాలను మీరు చూడవచ్చు కాబట్టి నేను టి అని ఎలిమెంట్ రకాన్ని తెలుసుకోవాలి. నేను అగ్రస్థానంలో ఉన్నప్పుడు ఎలిమెంట్ రకాన్ని తెలుసుకోవాలి, పాప్ చేయండి. తెలుసుకోవలసిన అవసరం లేదు, ఖలీ అవసరం లేదు తెలుసు.
31. ఇది T రకం కాబట్టి, నేను దానిని ప్రామాణీకరించాను మరియు ఒక ఫంక్షన్ (ఫంక్షన్) విషయంలో నేను చేసినట్లుగానే, టెంప్లేట్ క్లాస్ T సందర్భంలో ఇది ఒక టెంప్లేట్ (టెంప్లేట్) అని చెప్పాను.  ఒక వేరియబుల్.
ఇది T రకం కాబట్టి, నేను దానిని ప్రామాణీకరించాను మరియు ఒక ఫంక్షన్ (ఫంక్షన్) విషయంలో నేను చేసినట్లుగానే, టెంప్లేట్ క్లాస్ T సందర్భంలో ఇది ఒక టెంప్లేట్ (టెంప్లేట్) అని చెప్పాను.  ఒక వేరియబుల్.
32. మరియు ఈ సభ్యుల విధులను సూచించడానికి ఆ టెంప్లేట్ వేరియబుల్ ఉపయోగించబడుతుంది.
మరియు ఈ సభ్యుల విధులను సూచించడానికి ఆ టెంప్లేట్ వేరియబుల్ ఉపయోగించబడుతుంది.
33. కాబట్టి, ఇది టెంప్లేట్ చేయబడిన స్టాక్‌ను చేస్తుంది, ఇది దేనికైనా వెంటనే చేయవచ్చు.
కాబట్టి, ఇది టెంప్లేట్ చేయబడిన స్టాక్‌ను చేస్తుంది, ఇది దేనికైనా వెంటనే చేయవచ్చు.
34. వాస్తవానికి, ఈ స్టాక్ టెంప్లేట్ పని చేయడానికి, మనకు కొన్ని లక్షణాలను సంతృప్తి పరచడానికి టైప్ టి, టైప్ వేరియబుల్ టి అవసరం.
వాస్తవానికి, ఈ స్టాక్ టెంప్లేట్ పని చేయడానికి, మనకు కొన్ని లక్షణాలను సంతృప్తి పరచడానికి టైప్ టి, టైప్ వేరియబుల్ టి అవసరం.
35. ఉదాహరణకు, అంశం T రకం మరియు డేటా I రకం T మరియు డేటా మూలకం.
ఉదాహరణకు, అంశం T రకం మరియు డేటా I రకం T మరియు డేటా మూలకం.
36. అందువల్ల ఇక్కడ ఒక నియామకం సాధ్యమేనని మేము చూస్తాము.
అందువల్ల ఇక్కడ ఒక నియామకం సాధ్యమేనని మేము చూస్తాము.
37. కాపీ అసైన్‌మెంట్ ఆపరేటర్ ఈ ప్రదేశంలో సాధ్యమవుతుంది, అది లేకుండా మీరు వెంటనే ఒక నిర్దిష్ట రకం స్టాక్‌ను పంపలేరు.
కాపీ అసైన్‌మెంట్ ఆపరేటర్ ఈ ప్రదేశంలో సాధ్యమవుతుంది, అది లేకుండా మీరు వెంటనే ఒక నిర్దిష్ట రకం స్టాక్‌ను పంపలేరు.
38. ఇది స్టాక్ డాట్ హెడర్‌లోకి వెళుతుందని uming హిస్తూ, దీన్ని ఉపయోగించడం మనం చూస్తే, మనం ఫంక్షన్ (ఫంక్షన్) ను వేగవంతం చేసే విధంగానే నాకు వెంటనే ఇష్టం. మేము దానిని పాత్ర కోసం పిలుస్తాము.
ఇది స్టాక్ డాట్ హెడర్‌లోకి వెళుతుందని uming హిస్తూ, దీన్ని ఉపయోగించడం మనం చూస్తే, మనం ఫంక్షన్ (ఫంక్షన్) ను వేగవంతం చేసే విధంగానే నాకు వెంటనే ఇష్టం. మేము దానిని పాత్ర కోసం పిలుస్తాము.
39. ఇది ఇప్పుడు నేను ఉపయోగించగల అక్షరాల స్టాక్‌ను ఇస్తుంది.
ఇది ఇప్పుడు నేను ఉపయోగించగల అక్షరాల స్టాక్‌ను ఇస్తుంది.
40. నేను ఈ కోడ్‌ను వివరించడానికి వెళ్ళను. మేము ఈ కోడ్‌ను చాలాసార్లు చూశాము, ఒత్తిడిని తిప్పికొట్టడానికి మేము ఆ స్టాక్‌ను ఉపయోగించవచ్చు.
నేను ఈ కోడ్‌ను వివరించడానికి వెళ్ళను. మేము ఈ కోడ్‌ను చాలాసార్లు చూశాము, ఒత్తిడిని తిప్పికొట్టడానికి మేము ఆ స్టాక్‌ను ఉపయోగించవచ్చు.
41. అదే శీర్షికతో డాట్ h ని స్టాక్ చేయండి.
అదే శీర్షికతో డాట్ h ని స్టాక్ చేయండి.
42. ఇప్పుడు నేను ప్రత్యేక అప్లికేషన్ రాయగలను.
ఇప్పుడు నేను ప్రత్యేక అప్లికేషన్ రాయగలను.
43. కాబట్టి, పోస్ట్‌ఫిక్స్ వ్యక్తీకరణలను అంచనా వేయడానికి నేను వేరే అప్లికేషన్‌ను వ్రాయగలిగే అదే టెంప్లేట్ చేయబడిన స్టాక్ కోడ్ వలె ఇదే శీర్షిక.
కాబట్టి, పోస్ట్‌ఫిక్స్ వ్యక్తీకరణలను అంచనా వేయడానికి నేను వేరే అప్లికేషన్‌ను వ్రాయగలిగే అదే టెంప్లేట్ చేయబడిన స్టాక్ కోడ్ వలె ఇదే శీర్షిక.
44. ఇక్కడ వ్యక్తీకరణలు పూర్ణాంకాలు కాబట్టి, నాకు పూర్ణాంకం యొక్క వ్యక్తీకరణ విలువను కలిగి ఉండే స్టాక్ అవసరం, కనుక ఇది విలీనం చేయబడింది.
ఇక్కడ వ్యక్తీకరణలు పూర్ణాంకాలు కాబట్టి, నాకు పూర్ణాంకం యొక్క వ్యక్తీకరణ విలువను కలిగి ఉండే స్టాక్ అవసరం, కనుక ఇది విలీనం చేయబడింది.
45. నేను సి తో చేస్తే, నాకు రెండు వేర్వేరు స్టాక్ ఇంప్లిమెంటేషన్లు, రివర్స్ స్ట్రింగ్ కోసం నాలుగు బేస్ ఇంప్లిమెంటేషన్లు మరియు ఈ ప్రత్యేకమైన పోస్ట్ ఫిక్స్ మూల్యాంకన సమస్య కోసం ఒక ఇంటెంట్ రివర్స్ రివర్స్ ఇంప్లిమెంటేషన్ అవసరం, కానీ నేను అదే టెంప్లేట్ (స్టాక్) ని నిర్వచించాను రెండు వేర్వేరు రకాలతో త్వరగా.
నేను సి తో చేస్తే, నాకు రెండు వేర్వేరు స్టాక్ ఇంప్లిమెంటేషన్లు, రివర్స్ స్ట్రింగ్ కోసం నాలుగు బేస్ ఇంప్లిమెంటేషన్లు మరియు ఈ ప్రత్యేకమైన పోస్ట్ ఫిక్స్ మూల్యాంకన సమస్య కోసం ఒక ఇంటెంట్ రివర్స్ రివర్స్ ఇంప్లిమెంటేషన్ అవసరం, కానీ నేను అదే టెంప్లేట్ (స్టాక్) ని నిర్వచించాను రెండు వేర్వేరు రకాలతో త్వరగా.
46. ఇది తరగతి టెంప్లేట్ యొక్క ప్రధాన బలం మరియు ఇది డేటా స్ట్రక్చర్ల పరంగా ప్రత్యేకంగా మరియు వేర్వేరు యుటిలిటీ క్లాసులలో మాకు చాలా సాధారణీకరణను ఇస్తుంది.
ఇది తరగతి టెంప్లేట్ యొక్క ప్రధాన బలం మరియు ఇది డేటా స్ట్రక్చర్ల పరంగా ప్రత్యేకంగా మరియు వేర్వేరు యుటిలిటీ క్లాసులలో మాకు చాలా సాధారణీకరణను ఇస్తుంది.
47. ఇప్పుడు, సహజంగా నేను ఈ ఆవశ్యకత చేసినప్పుడు నేను చెప్పినట్లు.
ఇప్పుడు, సహజంగా నేను ఈ ఆవశ్యకత చేసినప్పుడు నేను చెప్పినట్లు.
48. ఇంతకుముందు మేము దీనిని ఫంక్షన్ టెంప్లేట్ల కోసం చూశాము, ఇప్పుడు మీరు దీన్ని క్లాస్ టెంప్లేట్ కోసం చూస్తున్నారు, పరామితి రకం టెంప్లేట్‌లో ఉపయోగించబడిందని మేము నిర్ధారించుకోవాలి, అవి ఏ రకమైనవి అయినా కొన్ని లక్షణాలను సంతృప్తిపరుస్తాయి.
ఇంతకుముందు మేము దీనిని ఫంక్షన్ టెంప్లేట్ల కోసం చూశాము, ఇప్పుడు మీరు దీన్ని క్లాస్ టెంప్లేట్ కోసం చూస్తున్నారు, పరామితి రకం టెంప్లేట్‌లో ఉపయోగించబడిందని మేము నిర్ధారించుకోవాలి, అవి ఏ రకమైనవి అయినా కొన్ని లక్షణాలను సంతృప్తిపరుస్తాయి.
49. ఇతర పారామీటర్ చేయబడిన రకాలు కూడా ఉండవచ్చు, అవి సొంతంగా టైప్ చేయవచ్చు, కాని తరగతి అమలు యొక్క ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ (టెంప్లేట్) అమలుకు అవసరమైన పద్ధతులకు అవి మద్దతు ఇవ్వడం ముఖ్యం.
ఇతర పారామీటర్ చేయబడిన రకాలు కూడా ఉండవచ్చు, అవి సొంతంగా టైప్ చేయవచ్చు, కాని తరగతి అమలు యొక్క ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ (టెంప్లేట్) అమలుకు అవసరమైన పద్ధతులకు అవి మద్దతు ఇవ్వడం ముఖ్యం.
50. కాబట్టి, లక్షణాలు ఉన్నందున, వారు కన్స్ట్రక్టర్కు మద్దతు ఇవ్వవలసి ఉంటుంది, వారు వేర్వేరు ఆపరేటర్లకు మద్దతు ఇవ్వవలసి ఉంటుంది మరియు మేము దాని ఉదాహరణలను చూశాము.
51. అవి ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ (టెంప్లేట్) అలాగే క్లాస్ టెంప్లేట్ (టెంప్లేట్) రెండింటినీ అనుసరించాల్సిన ప్రాథమిక రకం లక్షణాలు.
52. కాబట్టి, ఫంక్షన్ టెంప్లేట్ విషయంలో మీరు చూసినది ఇదే, ఇది మీ రీక్యాప్ కోసం మాత్రమే.
53. తరగతి టెంప్లేట్ సందర్భంలో, ఆవశ్యకతను సాధారణంగా స్పష్టంగా తీర్చాల్సిన అవసరం ఉంది మరియు ఇది ఒక తరగతి కనుక, తరగతిని వాస్తవంగా అందించకుండానే ఫార్వార్డ్ చేయడం చాలా సాధ్యమే. వాస్తవానికి నేను పిలువబడేదాన్ని వ్రాయగలను అసంపూర్ణ స్టాక్ రకం.
54. టైప్ టి ద్వారా ప్రామాణికమైన స్టాక్ అని పిలువబడే తరగతి ఉందని వ్యవస్థకు చెప్పడం మరింత ప్రకటన అని ఇది చెప్పింది, అయితే ఇది పద్ధతులు ఏమిటో చెప్పలేదు మరియు మొదలైనవి.
కాబట్టి, లక్షణాలు ఉన్నందున, వారు కన్స్ట్రక్టర్కు మద్దతు ఇవ్వవలసి ఉంటుంది, వారు వేర్వేరు ఆపరేటర్లకు మద్దతు ఇవ్వవలసి ఉంటుంది మరియు మేము దాని ఉదాహరణలను చూశాము.
అవి ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్ (టెంప్లేట్) అలాగే క్లాస్ టెంప్లేట్ (టెంప్లేట్) రెండింటినీ అనుసరించాల్సిన ప్రాథమిక రకం లక్షణాలు.
కాబట్టి, ఫంక్షన్ టెంప్లేట్ విషయంలో మీరు చూసినది ఇదే, ఇది మీ రీక్యాప్ కోసం మాత్రమే.
తరగతి టెంప్లేట్ సందర్భంలో, ఆవశ్యకతను సాధారణంగా స్పష్టంగా తీర్చాల్సిన అవసరం ఉంది మరియు ఇది ఒక తరగతి కనుక, తరగతిని వాస్తవంగా అందించకుండానే ఫార్వార్డ్ చేయడం చాలా సాధ్యమే. వాస్తవానికి నేను పిలువబడేదాన్ని వ్రాయగలను అసంపూర్ణ స్టాక్ రకం.
టైప్ టి ద్వారా ప్రామాణికమైన స్టాక్ అని పిలువబడే తరగతి ఉందని వ్యవస్థకు చెప్పడం మరింత ప్రకటన అని ఇది చెప్పింది, అయితే ఇది పద్ధతులు ఏమిటో చెప్పలేదు మరియు మొదలైనవి.
55. కాబట్టి, దానితో.
56. నేను వస్తువును తక్షణం చేయడానికి ప్రయత్నిస్తే, నేను లోపం పొందుతాను, ఎందుకంటే కన్స్ట్రక్టర్, డిస్ట్రాయర్, ఇతర ఆపరేటర్లు మరియు సభ్యులను నాకు తెలియకపోతే ఆ వస్తువును తక్షణం చేయలేము.
కాబట్టి, దానితో.
నేను వస్తువును తక్షణం చేయడానికి ప్రయత్నిస్తే, నేను లోపం పొందుతాను, ఎందుకంటే కన్స్ట్రక్టర్, డిస్ట్రాయర్, ఇతర ఆపరేటర్లు మరియు సభ్యులను నాకు తెలియకపోతే ఆ వస్తువును తక్షణం చేయలేము.
57. కానీ నేను ఇప్పటికీ ఈ రకానికి పాయింటర్‌ను నిర్వచించగలను; నేను ఈ రకమైన సూచనను నిర్వచించగలను. కాబట్టి రివర్స్ స్ట్రింగ్ ఫంక్షన్ (ఫంక్షన్) ను నేను నిర్వచించగలను,
కానీ నేను ఇప్పటికీ ఈ రకానికి పాయింటర్‌ను నిర్వచించగలను; నేను ఈ రకమైన సూచనను నిర్వచించగలను. కాబట్టి రివర్స్ స్ట్రింగ్ ఫంక్షన్ (ఫంక్షన్) ను నేను నిర్వచించగలను,
58. అది నిజంగా ఏమిటో నాకు తెలియనప్పుడు ఈ రకాన్ని సూచనగా తీసుకుంటుంది.
59. నేను స్టాక్ (స్టాక్) ఆపరేషన్లను ఉపయోగించాలనుకున్నప్పుడు రివర్స్ స్ట్రింగ్ ఫంక్షన్ (ఫంక్షన్) యొక్క బాడీని అమలు చేయాలనుకుంటే సహజంగానే నేను స్టాక్ (స్టాక్) అంటే ఏమిటో తెలుసుకోవాలి.
60. ఆవశ్యకత పరంగా, సోమరితనం అత్యవసరం అనేది చాలా ఉపయోగకరంగా ఉంటుందని మీకు తెలుసు.
61. కాబట్టి, నేను అదే విలోమ స్ట్రింగ్ కోడ్‌ను కొద్దిగా భిన్నమైన రీతిలో చూపిస్తున్నాను, అంతకుముందు ఈ మొత్తం స్టాక్ క్లాస్‌ను స్టాక్ డాట్ హెచ్ ఎంటర్లలో చేర్చారు, తద్వారా మొత్తం ఆలోచన అక్కడ జరుగుతున్నట్లుగా.
62. కొన్ని విషయాలు ఉంటే, ఇప్పుడు నేను ఇక్కడ చేర్చుతున్నాను, ఉదాహరణకు, ఇక్కడ మనం ఫార్వర్డ్ డిక్లరేషన్, కాబట్టి ఆ ఫార్వర్డ్ డిక్లరేషన్‌లో నేను రివర్స్ స్ట్రింగ్ ఫంక్షన్ యొక్క సంతకాన్ని కలిగి ఉండగలను, ఇది ఇక్కడ ఉంచిన స్ట్రింగ్ దీనికి విరుద్ధంగా చేస్తుంది మరియు ఎందుకంటే t ద్వారా టెంప్లేట్ (టెంప్లేట్) అనే స్టాక్‌ను ఉపయోగిస్తున్నారని ప్రతి ఒక్కరూ తెలుసుకోవలసిన సూచన ఈ సందర్భంలో చార్ (చార్) ఉదాహరణ.
63. కానీ ఆ రకం ఏమిటో తెలియదు, రకం ఎలా అమలు చేయబడిందో తెలియదు మరియు పట్టించుకోదు ఎందుకంటే ఇది కేవలం సూచనను చూస్తోంది.
64. నేను ఈ మెయిన్ కలిగి ఉంటే, నేను నిజంగా ఈ ఫంక్షన్‌ను ప్రారంభించగలను, ఎందుకంటే నేను తెలుసుకోవలసినది శరీరం తరువాత రాగల ఫంక్షన్ (ఫంక్షన్) యొక్క సంతకం, కాబట్టి నేను ఉద్దేశపూర్వకంగా శరీరానికి తరువాతి సమయం ఇచ్చాను. ప్రధాన శరీరాన్ని తెలుసుకోవలసిన అవసరం లేదని మీరు చూపిస్తారు.
65. అయితే, నేను ఇక్కడ స్టాక్ యొక్క ఉదాహరణను రిఫరెన్స్ పరామితిగా ఇవ్వడం అవసరం.
అది నిజంగా ఏమిటో నాకు తెలియనప్పుడు ఈ రకాన్ని సూచనగా తీసుకుంటుంది.
నేను స్టాక్ (స్టాక్) ఆపరేషన్లను ఉపయోగించాలనుకున్నప్పుడు రివర్స్ స్ట్రింగ్ ఫంక్షన్ (ఫంక్షన్) యొక్క బాడీని అమలు చేయాలనుకుంటే సహజంగానే నేను స్టాక్ (స్టాక్) అంటే ఏమిటో తెలుసుకోవాలి.
ఆవశ్యకత పరంగా, సోమరితనం అత్యవసరం అనేది చాలా ఉపయోగకరంగా ఉంటుందని మీకు తెలుసు.
కాబట్టి, నేను అదే విలోమ స్ట్రింగ్ కోడ్‌ను కొద్దిగా భిన్నమైన రీతిలో చూపిస్తున్నాను, అంతకుముందు ఈ మొత్తం స్టాక్ క్లాస్‌ను స్టాక్ డాట్ హెచ్ ఎంటర్లలో చేర్చారు, తద్వారా మొత్తం ఆలోచన అక్కడ జరుగుతున్నట్లుగా.
కొన్ని విషయాలు ఉంటే, ఇప్పుడు నేను ఇక్కడ చేర్చుతున్నాను, ఉదాహరణకు, ఇక్కడ మనం ఫార్వర్డ్ డిక్లరేషన్, కాబట్టి ఆ ఫార్వర్డ్ డిక్లరేషన్‌లో నేను రివర్స్ స్ట్రింగ్ ఫంక్షన్ యొక్క సంతకాన్ని కలిగి ఉండగలను, ఇది ఇక్కడ ఉంచిన స్ట్రింగ్ దీనికి విరుద్ధంగా చేస్తుంది మరియు ఎందుకంటే t ద్వారా టెంప్లేట్ (టెంప్లేట్) అనే స్టాక్‌ను ఉపయోగిస్తున్నారని ప్రతి ఒక్కరూ తెలుసుకోవలసిన సూచన ఈ సందర్భంలో చార్ (చార్) ఉదాహరణ.
కానీ ఆ రకం ఏమిటో తెలియదు, రకం ఎలా అమలు చేయబడిందో తెలియదు మరియు పట్టించుకోదు ఎందుకంటే ఇది కేవలం సూచనను చూస్తోంది.
నేను ఈ మెయిన్ కలిగి ఉంటే, నేను నిజంగా ఈ ఫంక్షన్‌ను ప్రారంభించగలను, ఎందుకంటే నేను తెలుసుకోవలసినది శరీరం తరువాత రాగల ఫంక్షన్ (ఫంక్షన్) యొక్క సంతకం, కాబట్టి నేను ఉద్దేశపూర్వకంగా శరీరానికి తరువాతి సమయం ఇచ్చాను. ప్రధాన శరీరాన్ని తెలుసుకోవలసిన అవసరం లేదని మీరు చూపిస్తారు.
అయితే, నేను ఇక్కడ స్టాక్ యొక్క ఉదాహరణను రిఫరెన్స్ పరామితిగా ఇవ్వడం అవసరం.
66. కాబట్టి, ఈ స్టాక్‌ను వెంటనే చేయాల్సిన అవసరం ఉంది.
కాబట్టి, ఈ స్టాక్‌ను వెంటనే చేయాల్సిన అవసరం ఉంది.
67. స్టాక్ (స్టాక్) యొక్క నిర్వచనం తెలియకుండా మీరు రివర్స్ స్ట్రింగ్ యొక్క సంతకాన్ని నిర్వచించగలిగినప్పుడు, మీరు ప్రధాన ఫంక్షన్ (ఫంక్షన్) ను వ్రాయలేరు, ఎందుకంటే మీకు స్టాక్ (స్టాక్) యొక్క నిర్వచనం తెలియదు.
స్టాక్ (స్టాక్) యొక్క నిర్వచనం తెలియకుండా మీరు రివర్స్ స్ట్రింగ్ యొక్క సంతకాన్ని నిర్వచించగలిగినప్పుడు, మీరు ప్రధాన ఫంక్షన్ (ఫంక్షన్) ను వ్రాయలేరు, ఎందుకంటే మీకు స్టాక్ (స్టాక్) యొక్క నిర్వచనం తెలియదు.
68. కాబట్టి స్టాక్ యొక్క నిర్వచనం స్టాక్ యొక్క తక్షణానికి ముందు ఉండాలి.
కాబట్టి స్టాక్ యొక్క నిర్వచనం స్టాక్ యొక్క తక్షణానికి ముందు ఉండాలి.
69. ఎందుకంటే ఇప్పుడు మీకు ఆబ్జెక్ట్ ఉదాహరణ ఉంటే, మేము నిర్మించగలగాలి, అది విధ్వంసం చేయగల సామర్థ్యం ఉండాలి, అది అన్ని వివిధ విధులను అమలు చేయగలగాలి.
ఎందుకంటే ఇప్పుడు మీకు ఆబ్జెక్ట్ ఉదాహరణ ఉంటే, మేము నిర్మించగలగాలి, అది విధ్వంసం చేయగల సామర్థ్యం ఉండాలి, అది అన్ని వివిధ విధులను అమలు చేయగలగాలి.
70. కాబట్టి ఇది ఇలా ఉంది, క్లాస్ టెంప్లేట్ యొక్క ఆవశ్యకత మీరు ఎల్లప్పుడూ అన్నింటినీ ఒకేసారి చేయాల్సిన అవసరం లేదని నేను హైలైట్ చేయాలనుకుంటున్నాను.
కాబట్టి ఇది ఇలా ఉంది, క్లాస్ టెంప్లేట్ యొక్క ఆవశ్యకత మీరు ఎల్లప్పుడూ అన్నింటినీ ఒకేసారి చేయాల్సిన అవసరం లేదని నేను హైలైట్ చేయాలనుకుంటున్నాను.
71. మీరు క్లాస్ రిఫరెన్స్ లేదా తాత్కాలిక క్లాస్‌ని సూచిస్తుంటే, మీరు క్లాస్ యొక్క పూర్తి నిర్వచనాన్ని తెలుసుకోవలసిన అవసరం లేకపోవచ్చు, మీరు క్లాస్ డిక్లరేషన్‌ను తదుపరి డిక్లరేషన్‌తో మాత్రమే నిర్వహించవచ్చు, ఇది తాత్కాలికమేమిటి, ఏమిటి వివిధ రకాలు మొదలైనవి.
మీరు క్లాస్ రిఫరెన్స్ లేదా తాత్కాలిక క్లాస్‌ని సూచిస్తుంటే, మీరు క్లాస్ యొక్క పూర్తి నిర్వచనాన్ని తెలుసుకోవలసిన అవసరం లేకపోవచ్చు, మీరు క్లాస్ డిక్లరేషన్‌ను తదుపరి డిక్లరేషన్‌తో మాత్రమే నిర్వహించవచ్చు, ఇది తాత్కాలికమేమిటి, ఏమిటి వివిధ రకాలు మొదలైనవి.
72. ఇది ప్రాథమిక తరగతి యొక్క టెంప్లేట్.
ఇది ప్రాథమిక తరగతి యొక్క టెంప్లేట్.
73. తరువాత మేము ఏదో చూపిస్తాము, ఇది మీ పరిపూర్ణతపై అవగాహన కోసం, నేను లోతుగా వెళ్ళకూడదు.
తరువాత మేము ఏదో చూపిస్తాము, ఇది మీ పరిపూర్ణతపై అవగాహన కోసం, నేను లోతుగా వెళ్ళకూడదు.
74. టెంప్లేట్ (టెంప్లేట్) పరంగా ఈ ఫంక్షన్ (ఫంక్షన్) ఎలా ఉంటుందో చూపించడానికి ఇది మాత్రమే. గరిష్ట ఫంక్షన్ (ఫంక్షన్) లో ఒక రకమైన పారామితి (పరామితి) టి ఉంటే మరియు నాలుగు నక్షత్రాలకు మనకు వేరే ప్రవర్తన ఉందని మేము చూశాము. కావాలనుకుంటే, అతను ప్రత్యేకత కలిగి ఉన్నాడు మరియు టీని కేవలం నాలుగు నక్షత్రాలకు మరియు మరొకదానికి మార్చాడు; దాని కోసం ఫంక్షన్ యొక్క నిర్వచనం.
టెంప్లేట్ (టెంప్లేట్) పరంగా ఈ ఫంక్షన్ (ఫంక్షన్) ఎలా ఉంటుందో చూపించడానికి ఇది మాత్రమే. గరిష్ట ఫంక్షన్ (ఫంక్షన్) లో ఒక రకమైన పారామితి (పరామితి) టి ఉంటే మరియు నాలుగు నక్షత్రాలకు మనకు వేరే ప్రవర్తన ఉందని మేము చూశాము. కావాలనుకుంటే, అతను ప్రత్యేకత కలిగి ఉన్నాడు మరియు టీని కేవలం నాలుగు నక్షత్రాలకు మరియు మరొకదానికి మార్చాడు; దాని కోసం ఫంక్షన్ యొక్క నిర్వచనం.
75. ఇది తరగతికి కూడా సాధ్యమే మరియు నేను ఒకటి కంటే ఎక్కువ పారామితులను కలిగి ఉంటే నేను ఆ పారామితులను పాక్షికంగా స్పెషలైజ్ చేయగలుగుతున్నాను, కాబట్టి నేను ఇక్కడ వివరించడానికి ప్రయత్నిస్తున్నాను.
76. కాబట్టి, ఇక్కడ విద్యార్థి తరగతి T1 మరియు T2 అనే రెండు రకాలుగా టెంప్లేట్ చేయబడిన ఒక టెంప్లేట్ ఉంది.
ఇది తరగతికి కూడా సాధ్యమే మరియు నేను ఒకటి కంటే ఎక్కువ పారామితులను కలిగి ఉంటే నేను ఆ పారామితులను పాక్షికంగా స్పెషలైజ్ చేయగలుగుతున్నాను, కాబట్టి నేను ఇక్కడ వివరించడానికి ప్రయత్నిస్తున్నాను.
కాబట్టి, ఇక్కడ విద్యార్థి తరగతి T1 మరియు T2 అనే రెండు రకాలుగా టెంప్లేట్ చేయబడిన ఒక టెంప్లేట్ ఉంది.
77. T1 అనేది ఒక రకమైన పాత్ర, T2 పేరు యొక్క రకం.
T1 అనేది ఒక రకమైన పాత్ర, T2 పేరు యొక్క రకం.
78. ఒక పాత్ర పూర్ణాంకం అయ్యే అవకాశం ఉంది, అది స్ట్రింగ్ కావచ్చు.
ఒక పాత్ర పూర్ణాంకం అయ్యే అవకాశం ఉంది, అది స్ట్రింగ్ కావచ్చు.
79. పేరు C ++ లో స్ట్రింగ్ రకం కావచ్చు లేదా ఇది నాలుగు నక్షత్రాలు, సి స్ట్రింగ్ రకం మరియు మొదలైనవి కావచ్చు.
పేరు C ++ లో స్ట్రింగ్ రకం కావచ్చు లేదా ఇది నాలుగు నక్షత్రాలు, సి స్ట్రింగ్ రకం మరియు మొదలైనవి కావచ్చు.
80. ఇవి మన వద్ద ఉన్న రెండు వేర్వేరు రకాలు.
ఇవి మన వద్ద ఉన్న రెండు వేర్వేరు రకాలు.
81. కాబట్టి, మీరు చేసేది ప్రాథమికంగా, నేను ఇచ్చిన కార్యాచరణ చాలా లేదు, మీరు ఒకదాన్ని సృష్టించి, ఈ రెండు ఫీల్డ్‌లను ప్రింట్ చేయగల ముద్రణను కలిగి ఉన్నారు, కాబట్టి ఉదాహరణ కోసం మాత్రమే.
కాబట్టి, మీరు చేసేది ప్రాథమికంగా, నేను ఇచ్చిన కార్యాచరణ చాలా లేదు, మీరు ఒకదాన్ని సృష్టించి, ఈ రెండు ఫీల్డ్‌లను ప్రింట్ చేయగల ముద్రణను కలిగి ఉన్నారు, కాబట్టి ఉదాహరణ కోసం మాత్రమే.
82. ఇప్పుడు, ఆసక్తికరమైనది ఏమిటంటే, ఈ నిపుణుడు మనం ఎక్కడ పాక్షికంగా ఉన్నాము? T1 మరియు T2 రెండు పారామితులు మరియు నేను పాక్షికంగా ప్రత్యేకత కలిగి ఉన్నాను, నాకు ఇప్పటికీ T1 పరామితి అయిన ఒక టెంప్లేట్ ఉంది, కానీ T2 స్పష్టంగా నాలుగు నక్షత్రాలను కలిగి ఉంది మరియు తరువాత నేను దానిని ఉపయోగించాను.
ఇప్పుడు, ఆసక్తికరమైనది ఏమిటంటే, ఈ నిపుణుడు మనం ఎక్కడ పాక్షికంగా ఉన్నాము? T1 మరియు T2 రెండు పారామితులు మరియు నేను పాక్షికంగా ప్రత్యేకత కలిగి ఉన్నాను, నాకు ఇప్పటికీ T1 పరామితి అయిన ఒక టెంప్లేట్ ఉంది, కానీ T2 స్పష్టంగా నాలుగు నక్షత్రాలను కలిగి ఉంది మరియు తరువాత నేను దానిని ఉపయోగించాను.
83. టి 2 విషయంలో, నేను నాలుగు నక్షత్రాలను ఉపయోగిస్తున్నాను. ఆ నాలుగు నక్షత్రాలను నేను స్పష్టంగా ఉంచాను.
టి 2 విషయంలో, నేను నాలుగు నక్షత్రాలను ఉపయోగిస్తున్నాను. ఆ నాలుగు నక్షత్రాలను నేను స్పష్టంగా ఉంచాను.
84. అప్పుడు అది టెంప్లేట్ యొక్క పాక్షిక ఉదాహరణ అవుతుంది.
అప్పుడు అది టెంప్లేట్ యొక్క పాక్షిక ఉదాహరణ అవుతుంది.
85. ఇంతకుముందు విద్యార్థి తరగతి యొక్క ఈ టెంప్లేట్కు T1 మరియు T2 ని పేర్కొనడానికి రెండు రకాలు అవసరమయ్యాయి, దీని కోసం ఒక రకాన్ని మాత్రమే T1 అని పేర్కొనవలసి ఉంది, మరొకటి ఇప్పటికే నిర్దిష్టంగా ఉంది.
ఇంతకుముందు విద్యార్థి తరగతి యొక్క ఈ టెంప్లేట్కు T1 మరియు T2 ని పేర్కొనడానికి రెండు రకాలు అవసరమయ్యాయి, దీని కోసం ఒక రకాన్ని మాత్రమే T1 అని పేర్కొనవలసి ఉంది, మరొకటి ఇప్పటికే నిర్దిష్టంగా ఉంది.
86. టెంప్లేట్ నిర్వచనంలో, మీరు అన్ని రకాల పారామితులను పేర్కొన్నప్పుడు, టెంప్లేట్ పూర్తిగా ప్రత్యేకమైనదని మీరు చెప్తారు, లేకపోతే అది పాక్షికంగా ప్రత్యేకమైనదని మీరు చెబుతారు.
టెంప్లేట్ నిర్వచనంలో, మీరు అన్ని రకాల పారామితులను పేర్కొన్నప్పుడు, టెంప్లేట్ పూర్తిగా ప్రత్యేకమైనదని మీరు చెప్తారు, లేకపోతే అది పాక్షికంగా ప్రత్యేకమైనదని మీరు చెబుతారు.
87. మేము దీన్ని కొన్ని తరగతి ఉదంతాలతో చూస్తే, మనం సహజంగా స్ట్రింగ్‌లో రెండింటినీ నిర్దేశించే ఒక ఉదాహరణను సృష్టించాము.
మేము దీన్ని కొన్ని తరగతి ఉదంతాలతో చూస్తే, మనం సహజంగా స్ట్రింగ్‌లో రెండింటినీ నిర్దేశించే ఒక ఉదాహరణను సృష్టించాము.
88. కాబట్టి ఈ టెంప్లేట్ T1 int మరియు T2 స్ట్రింగ్ గురించి మాట్లాడటానికి ప్రయత్నిస్తోంది.
కాబట్టి ఈ టెంప్లేట్ T1 int మరియు T2 స్ట్రింగ్ గురించి మాట్లాడటానికి ప్రయత్నిస్తోంది.
89. మీరు అవుట్పుట్ నుండి సులభంగా సృష్టించవచ్చు, మీరు S1 చుక్కలు కలిగి ఉన్నారు; S1 ఈ టెంప్లేట్ సంస్కరణ కోసం సృష్టించబడిన ఒక వస్తువు మరియు మేము S1 డాట్‌ను ప్రింట్ చేస్తున్నాము, ఇది ఉపయోగించబడుతున్న సంస్కరణ.
మీరు అవుట్పుట్ నుండి సులభంగా సృష్టించవచ్చు, మీరు S1 చుక్కలు కలిగి ఉన్నారు; S1 ఈ టెంప్లేట్ సంస్కరణ కోసం సృష్టించబడిన ఒక వస్తువు మరియు మేము S1 డాట్‌ను ప్రింట్ చేస్తున్నాము, ఇది ఉపయోగించబడుతున్న సంస్కరణ.
90. మరొకటి, మేము ఏమి ఉపయోగించాము? రెండవదానిలో, మేము ఆసక్తికరమైనదాన్ని ఉపయోగించాము.
మరొకటి, మేము ఏమి ఉపయోగించాము? రెండవదానిలో, మేము ఆసక్తికరమైనదాన్ని ఉపయోగించాము.
91. సెకనులో మీరు ఏమి చెబుతున్నారో గమనించండి, దీనిలో మేము T1 int సమానమైన లేదా T2 స్ట్రింగ్ సమానమైనదాన్ని కూడా పేర్కొన్నాము.
సెకనులో మీరు ఏమి చెబుతున్నారో గమనించండి, దీనిలో మేము T1 int సమానమైన లేదా T2 స్ట్రింగ్ సమానమైనదాన్ని కూడా పేర్కొన్నాము.
92. ఒక ఫంక్షన్ (ఫంక్షన్) సందర్భంలో మనం విలువల ఫంక్షన్ల యొక్క డిఫాల్ట్ పారామితిని (పరామితి) కలిగి ఉండవచ్చని గుర్తుంచుకోండి, మనం 5 తో ప్రారంభించటానికి సమానంగా int x ను వ్రాయగలము, తద్వారా నేను ఆ పరామితిని పాస్ చేయకపోతే (పరామితి) ) నేను చేస్తే, అది 5 గా తీసుకోబడుతుంది.
ఒక ఫంక్షన్ (ఫంక్షన్) సందర్భంలో మనం విలువల ఫంక్షన్ల యొక్క డిఫాల్ట్ పారామితిని (పరామితి) కలిగి ఉండవచ్చని గుర్తుంచుకోండి, మనం 5 తో ప్రారంభించటానికి సమానంగా int x ను వ్రాయగలము, తద్వారా నేను ఆ పరామితిని పాస్ చేయకపోతే (పరామితి) ) నేను చేస్తే, అది 5 గా తీసుకోబడుతుంది.
93. అదేవిధంగా, మీరు డిఫాల్ట్ రకం పరామితి కావచ్చు.
అదేవిధంగా, మీరు డిఫాల్ట్ రకం పరామితి కావచ్చు.
94. నేను దానిని పేర్కొనకపోతే అది అలా తీసుకోబడుతుంది.
నేను దానిని పేర్కొనకపోతే అది అలా తీసుకోబడుతుంది.
95. నేను స్ట్రింగ్ స్టూడెంట్ ఇంట్ అని చెప్తుంటే, నేను స్టూడెంట్ ఇంట్ అని చెబితే నేను తీసుకుంటున్నాను.
నేను స్ట్రింగ్ స్టూడెంట్ ఇంట్ అని చెప్తుంటే, నేను స్టూడెంట్ ఇంట్ అని చెబితే నేను తీసుకుంటున్నాను.
96. మరియు నేను T2 ను డిఫాల్ట్‌గా స్ట్రింగ్‌గా తీసుకోలేదు.
మరియు నేను T2 ను డిఫాల్ట్‌గా స్ట్రింగ్‌గా తీసుకోలేదు.
97. కనుక ఇది అప్రమేయంగా స్ట్రింగ్ గా తీసుకోబడుతుంది.
కనుక ఇది అప్రమేయంగా స్ట్రింగ్ గా తీసుకోబడుతుంది.
98. నేను దీన్ని చేయగలను, ఇది మళ్ళీ అర్ధం, ఇక్కడ రెండూ డిఫాల్ట్ పరామితిని med హించాయి.
నేను దీన్ని చేయగలను, ఇది మళ్ళీ అర్ధం, ఇక్కడ రెండూ డిఫాల్ట్ పరామితిని med హించాయి.
99. డిఫాల్ట్ T1 int, డిఫాల్ట్ T2 int.
డిఫాల్ట్ T1 int, డిఫాల్ట్ T2 int.
100. నేను ఒక విద్యార్థిని స్ట్రింగ్ చేయగలను, అప్పుడు నేను స్టూడెంట్ స్ట్రింగ్ చేస్తాను. అంటే నేను T1 కు స్ట్రింగ్ చేశాను మరియు T2 డిఫాల్ట్, ఇది కూడా స్ట్రింగ్.
101. మీరు ఉత్పత్తి చేసే అవుట్‌పుట్‌ను నేను చూపించానని మీరు చూడవచ్చు.
నేను ఒక విద్యార్థిని స్ట్రింగ్ చేయగలను, అప్పుడు నేను స్టూడెంట్ స్ట్రింగ్ చేస్తాను. అంటే నేను T1 కు స్ట్రింగ్ చేశాను మరియు T2 డిఫాల్ట్, ఇది కూడా స్ట్రింగ్.
మీరు ఉత్పత్తి చేసే అవుట్‌పుట్‌ను నేను చూపించానని మీరు చూడవచ్చు.
102. చివరగా, మేము ఇక్కడ ఏమి చేసామో నేను చెబితే? రెండవ పరామితి నాలుగు నక్షత్రాలకు పాక్షికంగా నిర్దిష్టంగా ఉందని మేము చెప్పాము.
చివరగా, మేము ఇక్కడ ఏమి చేసామో నేను చెబితే? రెండవ పరామితి నాలుగు నక్షత్రాలకు పాక్షికంగా నిర్దిష్టంగా ఉందని మేము చెప్పాము.
103. నేను Int చార్ స్టార్‌ను ఉంచినట్లయితే అది టెంప్లేట్ అని అర్ధం కాదు ఎందుకంటే రెండవ పరామితి పాక్షికంగా పేర్కొనబడింది, కనుక ఇది టెంప్లేట్ అని అర్ధం అని మీరు చెబితే మరియు మేము S5 కోసం ప్రింట్ చేస్తున్నామని చూస్తే. మేము S5 డాట్‌ను ప్రింట్ చేసినప్పుడు, మీరు చూడవచ్చు ఆ సంస్కరణ రెండు ముద్రించబడుతోంది, ఇది మీరు ఒక నిర్దిష్ట టెంప్లేట్ సంస్కరణను పాక్షికంగా ఉపయోగిస్తున్నట్లు చూపిస్తుంది. ఉపయోగిస్తున్నారు.
నేను Int చార్ స్టార్‌ను ఉంచినట్లయితే అది టెంప్లేట్ అని అర్ధం కాదు ఎందుకంటే రెండవ పరామితి పాక్షికంగా పేర్కొనబడింది, కనుక ఇది టెంప్లేట్ అని అర్ధం అని మీరు చెబితే మరియు మేము S5 కోసం ప్రింట్ చేస్తున్నామని చూస్తే. మేము S5 డాట్‌ను ప్రింట్ చేసినప్పుడు, మీరు చూడవచ్చు ఆ సంస్కరణ రెండు ముద్రించబడుతోంది, ఇది మీరు ఒక నిర్దిష్ట టెంప్లేట్ సంస్కరణను పాక్షికంగా ఉపయోగిస్తున్నట్లు చూపిస్తుంది. ఉపయోగిస్తున్నారు.
104. ఇది మీరు బహుళ పారామితులతో ఈ రకమైన పనులను చేయగలరని మరియు వాటిని పాక్షికంగా నిపుణులుగా చేయగలరని మీకు చూపించడమే ఎందుకంటే మీరు ఒకదాని నుండి మరొకదానికి వెళతారు మరియు మీరు డిఫాల్ట్ పారామితులను కూడా కలిగి ఉంటారు.
ఇది మీరు బహుళ పారామితులతో ఈ రకమైన పనులను చేయగలరని మరియు వాటిని పాక్షికంగా నిపుణులుగా చేయగలరని మీకు చూపించడమే ఎందుకంటే మీరు ఒకదాని నుండి మరొకదానికి వెళతారు మరియు మీరు డిఫాల్ట్ పారామితులను కూడా కలిగి ఉంటారు.
105. చివరగా, నేను పూర్తి చేయడానికి ముందు, తరగతి వారసత్వంతో మాత్రమే ఒక టెంప్లేట్‌ను ఉపయోగించటానికి ఒక ఉదాహరణను మీకు చూపిస్తాను, కాబట్టి ఇది బౌండ్ సెట్ రకం యొక్క డేటా నిర్మాణాన్ని సృష్టించే ప్రయత్నం.
చివరగా, నేను పూర్తి చేయడానికి ముందు, తరగతి వారసత్వంతో మాత్రమే ఒక టెంప్లేట్‌ను ఉపయోగించటానికి ఒక ఉదాహరణను మీకు చూపిస్తాను, కాబట్టి ఇది బౌండ్ సెట్ రకం యొక్క డేటా నిర్మాణాన్ని సృష్టించే ప్రయత్నం.
106. ఒక జాబితా ఉంది, జాబితా గురించి ప్రత్యేకంగా ఆసక్తికరంగా ఏమీ లేదు, ఇది యాడ్ ఫంక్షన్ (ఫంక్షన్) కలిగి ఉన్న జాబితా, దీనిలో పొడవు ఫంక్షన్ (ఫంక్షన్), ఒక నిర్దిష్ట మూలకాన్ని (ఫంక్షన్) కనుగొనే ఫంక్షన్, వెక్టర్‌ను అంతర్గతంగా ఉపయోగిస్తుంది మూలకాలను పట్టుకోవటానికి.
ఒక జాబితా ఉంది, జాబితా గురించి ప్రత్యేకంగా ఆసక్తికరంగా ఏమీ లేదు, ఇది యాడ్ ఫంక్షన్ (ఫంక్షన్) కలిగి ఉన్న జాబితా, దీనిలో పొడవు ఫంక్షన్ (ఫంక్షన్), ఒక నిర్దిష్ట మూలకాన్ని (ఫంక్షన్) కనుగొనే ఫంక్షన్, వెక్టర్‌ను అంతర్గతంగా ఉపయోగిస్తుంది మూలకాలను పట్టుకోవటానికి.
107. కాబట్టి ఇది సహాయక డేటా నిర్మాణం లాంటిది.
కాబట్టి ఇది సహాయక డేటా నిర్మాణం లాంటిది.
108. అప్పుడు మీరు ఈ జాబితాను ఉపయోగించి సమితిని నిర్వచించండి.
అప్పుడు మీరు ఈ జాబితాను ఉపయోగించి సమితిని నిర్వచించండి.
109. ఒక సమితి తరగతి t యొక్క అంశాల జాబితాను కలిగి ఉంటుంది.
ఒక సమితి తరగతి t యొక్క అంశాల జాబితాను కలిగి ఉంటుంది.
110. ఇది వర్చువల్ ఫంక్షన్ (ఫంక్షన్) ను కలిగి ఉంటుంది, ఇది మూలకాలకు పొడవును జోడించగలదు.
ఇది వర్చువల్ ఫంక్షన్ (ఫంక్షన్) ను కలిగి ఉంటుంది, ఇది మూలకాలకు పొడవును జోడించగలదు.
111. కాబట్టి ప్రాథమికంగా మీరు ఒక మూలకాన్ని జోడిస్తే అది జాబితాలోకి వెళుతుంది, అది ఐటెమ్‌కు వెళ్లి పుట్ చేస్తుంది.
కాబట్టి ప్రాథమికంగా మీరు ఒక మూలకాన్ని జోడిస్తే అది జాబితాలోకి వెళుతుంది, అది ఐటెమ్‌కు వెళ్లి పుట్ చేస్తుంది.
112. మీరు ఇక్కడ ఒక పుట్ చేయాలనుకుంటే, నేను ఏదైనా కోల్పోయానా? లేదు.
మీరు ఇక్కడ ఒక పుట్ చేయాలనుకుంటే, నేను ఏదైనా కోల్పోయానా? లేదు.
113. ఇది దీన్ని జోడిస్తుంది, వాస్తవానికి జోడిస్తుంది. మీరు ఒక సెట్‌కు జోడించాలనుకుంటే, ఇప్పుడు అది ఒక సెట్, ఇది ఆసక్తికరంగా ఉంది, ఇది ఒక సెట్ కాబట్టి ప్రతి మూలకం ప్రత్యేకంగా ఉండాలి, సెట్ ప్రత్యేకతను కలిగి ఉంటుంది.
114.  నేను దీన్ని చేస్తున్న విధానం, నేను మొదట ఈ జాబితాలోని విలువను తీసుకుంటాను. మూలకం ఈ జాబితాకు చెందినదా అని నేను కనుగొన్నాను. అది ఉంటే అది ఇప్పటికే సెట్‌లో ఉంది కాబట్టి మీరు ఇప్పుడే తిరిగి రండి.
ఇది దీన్ని జోడిస్తుంది, వాస్తవానికి జోడిస్తుంది. మీరు ఒక సెట్‌కు జోడించాలనుకుంటే, ఇప్పుడు అది ఒక సెట్, ఇది ఆసక్తికరంగా ఉంది, ఇది ఒక సెట్ కాబట్టి ప్రతి మూలకం ప్రత్యేకంగా ఉండాలి, సెట్ ప్రత్యేకతను కలిగి ఉంటుంది.
 నేను దీన్ని చేస్తున్న విధానం, నేను మొదట ఈ జాబితాలోని విలువను తీసుకుంటాను. మూలకం ఈ జాబితాకు చెందినదా అని నేను కనుగొన్నాను. అది ఉంటే అది ఇప్పటికే సెట్‌లో ఉంది కాబట్టి మీరు ఇప్పుడే తిరిగి రండి.
115. నాకు ఆందోళన లేకపోతే నియంత్రణ ఇక్కడ వస్తుంది, కాబట్టి మీరు దాన్ని జాబితాకు చేర్చండి, కనుక ఇది అదే.
నాకు ఆందోళన లేకపోతే నియంత్రణ ఇక్కడ వస్తుంది, కాబట్టి మీరు దాన్ని జాబితాకు చేర్చండి, కనుక ఇది అదే.
116. పొడవు జాబితా యొక్క పొడవులో కేవలం ఒక రేపర్ ఉంది, కానీ ఒక రేపర్ను కనుగొనండి.
పొడవు జాబితా యొక్క పొడవులో కేవలం ఒక రేపర్ ఉంది, కానీ ఒక రేపర్ను కనుగొనండి.
117. ఏదైనా మూలకం రకానికి సెట్ చేయవలసిన రకాన్ని ఇది మీకు ఇస్తుంది.
ఏదైనా మూలకం రకానికి సెట్ చేయవలసిన రకాన్ని ఇది మీకు ఇస్తుంది.
118. ఇప్పుడు, నాకు డిఫాల్ట్ సెట్ కావాలి అనుకుందాం.
ఇప్పుడు, నాకు డిఫాల్ట్ సెట్ కావాలి అనుకుందాం.
119. ఇక్కడ పేరు పెట్టబడిన సెట్, ఇది రెండు సరిహద్దులతో కూడిన సమితి; ఎలిమెంట్స్ ఆ పరిమితిలో ఉండాలి, నిర్వచించిన సెట్‌లో కనీస మరియు గరిష్ట విలువల్లో ఉన్న సభ్యులు మాత్రమే ఉంటారు.
ఇక్కడ పేరు పెట్టబడిన సెట్, ఇది రెండు సరిహద్దులతో కూడిన సమితి; ఎలిమెంట్స్ ఆ పరిమితిలో ఉండాలి, నిర్వచించిన సెట్‌లో కనీస మరియు గరిష్ట విలువల్లో ఉన్న సభ్యులు మాత్రమే ఉంటారు.
120. కాబట్టి ఇది సెట్ నుండి ఒక స్పెషలైజేషన్.
కాబట్టి ఇది సెట్ నుండి ఒక స్పెషలైజేషన్.
121. మీరు నైపుణ్యాన్ని ఎలా వ్రాస్తారో మీరు చూడవచ్చు.
మీరు నైపుణ్యాన్ని ఎలా వ్రాస్తారో మీరు చూడవచ్చు.
122. బౌండ్ సెట్ కూడా టెంప్లేట్ ఎందుకంటే దీనికి మూలకం రకం అయిన టెంప్లేట్ పరామితి ఉంది, అయితే ఇది సెట్ t లో ప్రత్యేకత కలిగి ఉంది.
బౌండ్ సెట్ కూడా టెంప్లేట్ ఎందుకంటే దీనికి మూలకం రకం అయిన టెంప్లేట్ పరామితి ఉంది, అయితే ఇది సెట్ t లో ప్రత్యేకత కలిగి ఉంది.
123. అప్పుడు దానికి బౌండ్ సెట్‌లో కన్స్ట్రక్టర్ ఉంటుంది, దీనికి యాడ్ ఉంటుంది.
అప్పుడు దానికి బౌండ్ సెట్‌లో కన్స్ట్రక్టర్ ఉంటుంది, దీనికి యాడ్ ఉంటుంది.
124. మరియు, మీరు జోడించడానికి ప్రయత్నించినప్పుడు ఏమి జరుగుతుంది, అది ఇప్పటికే ఉంటే, అది తిరిగి వస్తుంది, ఇది సమితి యొక్క ప్రవర్తన.
మరియు, మీరు జోడించడానికి ప్రయత్నించినప్పుడు ఏమి జరుగుతుంది, అది ఇప్పటికే ఉంటే, అది తిరిగి వస్తుంది, ఇది సమితి యొక్క ప్రవర్తన.
125. కానీ, విలువ కనిష్ట మరియు గరిష్టంగా ఉంటే అది బేస్ క్లాస్ ఆబ్జెక్ట్ అయిన అసలు సెట్ క్లాస్ ఆబ్జెక్ట్‌కు వెళ్లి దాన్ని జోడిస్తుంది.
కానీ, విలువ కనిష్ట మరియు గరిష్టంగా ఉంటే అది బేస్ క్లాస్ ఆబ్జెక్ట్ అయిన అసలు సెట్ క్లాస్ ఆబ్జెక్ట్‌కు వెళ్లి దాన్ని జోడిస్తుంది.
126. అది కాకపోతే, అది ఏమీ చేయదు, ఇది ఇక్కడ మినహాయింపు ద్వారా మిమ్మల్ని విస్మరిస్తుంది మరియు కొన్ని ఇతర ప్రవర్తనలను కూడా చేస్తుంది.
అది కాకపోతే, అది ఏమీ చేయదు, ఇది ఇక్కడ మినహాయింపు ద్వారా మిమ్మల్ని విస్మరిస్తుంది మరియు కొన్ని ఇతర ప్రవర్తనలను కూడా చేస్తుంది.
127. కానీ నేను చూపించడానికి ప్రయత్నిస్తున్నది ఇక్కడ ఉంది, ఇది సెట్ యొక్క ప్రత్యేకత అయిన ఒక బౌండ్ సెట్‌ను కలిగి ఉంది, ఇది టెంప్లేట్ చేయబడింది, ఇది కూడా టెంప్లేట్ చేయబడింది మరియు దానిలో కొంత భాగం ఎందుకంటే దానిలో ఒకటి అయిన భాగాల జాబితా ఉంది ఒక వెక్టర్ భాగంగా.
కానీ నేను చూపించడానికి ప్రయత్నిస్తున్నది ఇక్కడ ఉంది, ఇది సెట్ యొక్క ప్రత్యేకత అయిన ఒక బౌండ్ సెట్‌ను కలిగి ఉంది, ఇది టెంప్లేట్ చేయబడింది, ఇది కూడా టెంప్లేట్ చేయబడింది మరియు దానిలో కొంత భాగం ఎందుకంటే దానిలో ఒకటి అయిన భాగాల జాబితా ఉంది ఒక వెక్టర్ భాగంగా.
128. ఇవన్నీ టెంప్లేట్ చేయబడ్డాయి, చివరికి నేను ఈ టెంప్లేటెడ్ క్లాస్‌లో ఈ టెంప్లేటెడ్ క్లాసులు మరియు వారసత్వాన్ని ఉపయోగించి ఏ రకమైన బౌండ్ సెట్‌ను పొందుతాను.
ఇవన్నీ టెంప్లేట్ చేయబడ్డాయి, చివరికి నేను ఈ టెంప్లేటెడ్ క్లాస్‌లో ఈ టెంప్లేటెడ్ క్లాసులు మరియు వారసత్వాన్ని ఉపయోగించి ఏ రకమైన బౌండ్ సెట్‌ను పొందుతాను.
129. కాబట్టి, వారసత్వ లక్షణంతో టెంప్లేట్‌ను ఈ విధంగా కలపవచ్చు.
కాబట్టి, వారసత్వ లక్షణంతో టెంప్లేట్‌ను ఈ విధంగా కలపవచ్చు.
130. ఇది తుది బౌండ్ సెట్ అప్లికేషన్, మీరు ఇప్పుడే పూర్తి చేసి, అప్లికేషన్‌ను తనిఖీ చేసి, దీన్ని అమలు చేయవచ్చు, తద్వారా మీరు ఈ సెట్‌కు కొన్ని సంఖ్యలను జోడించారు, ఆపై మీరు కనుగొనే నాలుగు ఆశలను కనుగొనడానికి ప్రయత్నిస్తారు.
ఇది తుది బౌండ్ సెట్ అప్లికేషన్, మీరు ఇప్పుడే పూర్తి చేసి, అప్లికేషన్‌ను తనిఖీ చేసి, దీన్ని అమలు చేయవచ్చు, తద్వారా మీరు ఈ సెట్‌కు కొన్ని సంఖ్యలను జోడించారు, ఆపై మీరు కనుగొనే నాలుగు ఆశలను కనుగొనడానికి ప్రయత్నిస్తారు.
131. మీ జాబితాలో 0 లేదా 25 వంటివి ఉన్నాయా అని మీరు తనిఖీ చేస్తారు, ఎందుకంటే మీ జాబితా 3 మరియు 21 మధ్య ఉంటుంది.
మీ జాబితాలో 0 లేదా 25 వంటివి ఉన్నాయా అని మీరు తనిఖీ చేస్తారు, ఎందుకంటే మీ జాబితా 3 మరియు 21 మధ్య ఉంటుంది.
132. అందువల్ల మీరు unexpected ఊహించని విలువ లేదని చెప్పారు.
అందువల్ల మీరు unexpected ఊహించని విలువ లేదని చెప్పారు.
133. ఇది మీ నిర్బంధ సెట్ డేటా రకం ఎలా పనిచేస్తుందో ఉదాహరణతో చూపిస్తుంది.
ఇది మీ నిర్బంధ సెట్ డేటా రకం ఎలా పనిచేస్తుందో ఉదాహరణతో చూపిస్తుంది.
134. సంక్షిప్తంగా, మేము C ++ లో టెంప్లేట్‌లను పరిచయం చేసాము మరియు క్లాస్ మూస డేటా నిర్మాణానికి ఒక సాధారణ పరిష్కారం అని చర్చించాము.
సంక్షిప్తంగా, మేము C ++ లో టెంప్లేట్‌లను పరిచయం చేసాము మరియు క్లాస్ మూస డేటా నిర్మాణానికి ఒక సాధారణ పరిష్కారం అని చర్చించాము.
ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్‌తో కలిపి, జెనరిక్ ప్రోగ్రామింగ్, ప్రోగ్రామింగ్ కోడ్ మరియు ప్రామాణిక టెంప్లేట్ లైబ్రరీ లేదా సి ++ వ్రాయగలిగే విషయంలో ఇది మాకు ఒక ప్రధాన ప్రయోజనాన్ని ఇస్తుంది. STL అని పిలవబడే వాటికి పునాది ఇస్తుంది.
135. ఫంక్షన్ (ఫంక్షన్) టెంప్లేట్‌తో కలిపి, జెనరిక్ ప్రోగ్రామింగ్, ప్రోగ్రామింగ్ కోడ్ మరియు ప్రామాణిక టెంప్లేట్ లైబ్రరీ లేదా సి ++ వ్రాయగలిగే విషయంలో ఇది మాకు ఒక ప్రధాన ప్రయోజనాన్ని ఇస్తుంది. STL అని పిలవబడే వాటికి పునాది ఇస్తుంది.
136.
inhouse/NPTEL/PreFinal/c++/Telugu/05. ProgramminginCplusplus_Multiple Inheritance (Contd.) (Lecture 51)-1HE5dACnRZs.txt
View file @ 956c0d4e
 1. C ++ లో ప్రోగ్రామింగ్ లో మాడ్యూల్ 35 కు స్వాగతం.
2. మేము అనేక వారసత్వం గురించి చర్చించాము మరియు నిర్మాణం, నాశనం, లేఅవుట్, డేటా సభ్యులు, సభ్యుల విధులు మరియు బహుళ బేస్ తరగతులు మధ్య, డేటా సభ్యుడు లేదా సభ్యుడు విధులు ఒకే పేర్లు నకిలీ ఉంటే, మేము ఏమి జరుగుతుంది.
3. ఇప్పుడు, మేము మరికొన్ని ఇంటిగ్రేటెడ్ వినియోగ దృశ్యాలను పరిశీలిస్తాము మరియు మనకు విద్యార్థి ఉపాధ్యాయుడు టిఎ దృష్టాంతం ఉందని చూపిస్తాము, ఇక్కడ టిఎ విద్యార్థి, టిఎ ఒక ఉపాధ్యాయుడు మరియు ఇద్దరూ వ్యక్తులు.
4. అందువల్ల, మనకు వజ్రం లాంటి పరిస్థితి ఉంది మరియు మేము దీనిని డైమండ్ సమస్య అని పిలవండి, దాన్ని ఎందుకు డైమండ్ సమస్య అని పిలుస్తామో చూద్దాం.
5. బహుళ వారసత్వంలో కనిపించే తరగతి యొక్క ప్రాథమిక తరగతుల కోసం మీకు సాధారణ బేస్ క్లాస్ ఉండడం చాలా సాధారణమని నేను ఇప్పటికే వివరించాను.
6. కాబట్టి, కోడ్ వ్యక్తిని చూడటానికి ప్రయత్నిద్దాం, ఇది ఒక తరగతి, ఇక్కడ నేను దానిని ఫ్యాకల్టీ అని పిలిచాను, ఉదాహరణలో నేను దానిని ఫ్యాకల్టీ అని పిలిచాను, అంటే ఉపాధ్యాయుడు ఒక తరగతి విద్యార్థి అని అర్ధం.) కాబట్టి వారు వారసత్వంగా ఒక వ్యక్తిని కలుస్తారు .
7. కాబట్టి, ఆపై TA అధ్యాపకులు మరియు విద్యార్థి రెండింటి నుండి వారసత్వంగా పొందారు, కాబట్టి ఇది దృష్టాంతం.
 C ++ లో ప్రోగ్రామింగ్ లో మాడ్యూల్ 35 కు స్వాగతం.
మేము అనేక వారసత్వం గురించి చర్చించాము మరియు నిర్మాణం, నాశనం, లేఅవుట్, డేటా సభ్యులు, సభ్యుల విధులు మరియు బహుళ బేస్ తరగతులు మధ్య, డేటా సభ్యుడు లేదా సభ్యుడు విధులు ఒకే పేర్లు నకిలీ ఉంటే, మేము ఏమి జరుగుతుంది.
ఇప్పుడు, మేము మరికొన్ని ఇంటిగ్రేటెడ్ వినియోగ దృశ్యాలను పరిశీలిస్తాము మరియు మనకు విద్యార్థి ఉపాధ్యాయుడు టిఎ దృష్టాంతం ఉందని చూపిస్తాము, ఇక్కడ టిఎ విద్యార్థి, టిఎ ఒక ఉపాధ్యాయుడు మరియు ఇద్దరూ వ్యక్తులు.
అందువల్ల, మనకు వజ్రం లాంటి పరిస్థితి ఉంది మరియు మేము దీనిని డైమండ్ సమస్య అని పిలవండి, దాన్ని ఎందుకు డైమండ్ సమస్య అని పిలుస్తామో చూద్దాం.
బహుళ వారసత్వంలో కనిపించే తరగతి యొక్క ప్రాథమిక తరగతుల కోసం మీకు సాధారణ బేస్ క్లాస్ ఉండడం చాలా సాధారణమని నేను ఇప్పటికే వివరించాను.
కాబట్టి, కోడ్ వ్యక్తిని చూడటానికి ప్రయత్నిద్దాం, ఇది ఒక తరగతి, ఇక్కడ నేను దానిని ఫ్యాకల్టీ అని పిలిచాను, ఉదాహరణలో నేను దానిని ఫ్యాకల్టీ అని పిలిచాను, అంటే ఉపాధ్యాయుడు ఒక తరగతి విద్యార్థి అని అర్ధం.) కాబట్టి వారు వారసత్వంగా ఒక వ్యక్తిని కలుస్తారు .
కాబట్టి, ఆపై TA అధ్యాపకులు మరియు విద్యార్థి రెండింటి నుండి వారసత్వంగా పొందారు, కాబట్టి ఇది దృష్టాంతం.
మరియు ప్రతి బిల్డర్‌కు బిల్డ్‌లో ఏమి జరుగుతుందో చూడటానికి సందేశం ఉంది.
8. అందువల్ల, నిర్మాణం ఖచ్చితంగా బేస్ క్లాస్‌ని నిర్మించాలి.
9. కాబట్టి, టిఎ వస్తువును నిర్మించడానికి ఏమి చేయాలి, అధ్యాపకులను నిర్మించడం.
10. ఇప్పుడు, అధ్యాపకులకు వ్యక్తి నుండి నైపుణ్యం ఉంది.
11. కాబట్టి, అధ్యాపక వస్తువును నిర్మించటానికి ఏమి చేయాలి అంటే ఒక వ్యక్తి నిర్మించవలసి ఉంటుంది, కాబట్టి ఈ రెండు అధ్యాపక వస్తువును ఏర్పరుస్తాయి.
12. అప్పుడు విద్యార్థి నిర్మించవలసి ఉంటుంది మరియు విద్యార్థికి వ్యక్తి నుండి నైపుణ్యం లభిస్తుంది.
13. కాబట్టి, నేను ఒక విద్యార్థిని నిర్మించవలసి వస్తే, నేను మళ్ళీ ఒక వ్యక్తిని నిర్మించాలి.
14. కాబట్టి, మరో వ్యక్తిని నిర్మిస్తారు, ఆపై విద్యార్థిని నిర్మిస్తారు, అప్పుడు టిఎ సృష్టించబడుతుంది.
15. కాబట్టి, నేను మొత్తం ఆబ్జెక్ట్ దృష్టాంతాన్ని పరిశీలిస్తే, నాకు రెండు బేస్ క్లాసులు ఉన్నాయి.ఇది అధ్యాపకులు మరియు ఇది ఒక విద్యార్థి.
16. మరియు అది ఒక వ్యక్తి అవుతుంది, అది ఒక వ్యక్తిని కలిగి ఉంటుంది, మీకు వేర్వేరు ఫ్యాకల్టీ డేటా ఉంటుంది, మీకు ఇక్కడ విద్యార్థుల డేటా ఉంటుంది, మీకు ఉత్పన్నమైన తరగతి ఉంటుంది, ఈ టిఎ వస్తువు.
17. కాబట్టి, మీకు ఇక్కడ TA డేటా ఉంటుంది, ఇవి TA డేటా.
18. కానీ అది నిజంగా ఎలా నిర్మిస్తుంది.
19. అందువల్ల, మీరు ఈ విధంగా నిర్మించినప్పుడు, మా వారసత్వం యొక్క ప్రాథమిక సూత్రం ఒకే TA వస్తువులో ఇద్దరు వ్యక్తుల వస్తువులు ఉండాలి అని చెబుతుంది.
20. ఎందుకంటే, లేకపోతే అధ్యాపకులను నిర్మించలేము ఎందుకంటే బేస్ ఆబ్జెక్ట్ తప్పనిసరిగా దానిలో పొందుపరచబడాలి, విద్యార్థిని నిర్మించలేము ఎందుకంటే ఆ వ్యక్తి తప్పనిసరిగా దానిలో పొందుపరచబడాలి.
21. అందువల్ల, టీఏకు అధ్యాపకులు మరియు విద్యార్థులు ఇద్దరూ అవసరం.
22. కాబట్టి, మీకు బేస్ క్లాస్ ఆబ్జెక్ట్ యొక్క రెండు ఉదాహరణలు ఉంటాయి మరియు ఇది ఖచ్చితంగా చాలా కావాల్సిన పరిస్థితి కాదు, ఎందుకంటే నేను వ్యక్తి క్లాస్ (క్లాస్) రెండు ఉదాహరణలు కలిగి ఉంటే TA గా ఉన్న వ్యక్తికి ఒకే ఒక లక్షణం ఉంటుంది మరియు నేను ఎలా చేస్తాను దాన్ని పరిష్కరించండి, మీరు డేటాను ఎలా నిర్వహించబోతున్నారు.
23. కాబట్టి, ఇది వర్చువల్ వారసత్వం మరియు బహుళ వారసత్వం అని పిలువబడుతుంది.
24. అది చెప్పేది ఏమిటంటే, మేము వర్చువల్ అనే కీవర్డ్‌ని ఉపయోగిస్తాము, ఎరుపు రంగును మళ్ళీ ఉపయోగించుకుందాం, ఆ తర్వాత అది పట్టింపు లేదు, మీరు దీన్ని బహిరంగంగా వ్రాసినా, బహిరంగపరచండి. మీరు వారసత్వంగా పొందుతున్న కీవర్డ్ వర్చువల్.
25. మీరు దీన్ని చేసినప్పుడు, వారసత్వం వర్చువల్ అవుతుంది, అంటే TA ను సృష్టించాల్సిన మొదటి విషయం ఏమిటంటే అధ్యాపకులు తప్పనిసరిగా నిర్మించబడాలి.
26. ఇప్పుడు, అధ్యాపక వ్యక్తి వర్చువల్ మార్గంలో వారసత్వంగా వచ్చాడని మీరు చెబితే, మరికొన్ని నిర్దిష్ట తరగతి సృష్టించబడుతోందని తెలుసు, దాని కోసం ఇతర బేస్ క్లాస్ (క్లాస్)) కావచ్చు.
27. అందువల్ల, అధ్యాపకులు దాని స్వంత వ్యక్తి తరగతిని నిర్మించరు, వ్యక్తి వస్తువు ఉన్న చోట నిర్మాణం ఉదాహరణను సృష్టించదు.
28. అదేవిధంగా, ఈ విద్యార్థి మేము చేసేటప్పుడు తరగతి యొక్క వ్యక్తిగత ఉదాహరణను సృష్టించడు, లేకపోతే నాకు అది అవసరం.
29. కానీ ఈ ప్రక్రియ అధ్యాపకులకు మరియు విద్యార్థికి ఒక సాధారణ వ్యక్తి ఉదాహరణను సృష్టిస్తుంది.
30. ఇప్పుడు, ఇది ఎలా నిర్మించబడుతుందో, ఇప్పుడు అధ్యాపకులు ఖచ్చితంగా విద్యార్థిని నిర్మించటం లేదు, ఎందుకంటే వారు వారసత్వంగా ఉన్న వ్యక్తి నుండి స్వీకరిస్తున్నారు.
31. కాబట్టి, ఇది డిఫాల్ట్ కన్స్ట్రక్టర్ అయి ఉండాలి, దీని కోసం ఒకే బేస్ క్లాస్, ప్రత్యేకమైన బేస్ క్లాస్ ఇంట్రస్ట్ సృష్టించబడే వర్చువల్ వారసత్వ ప్రక్రియ ఉండాలి.
32. అందువల్ల, నేను ఇక్కడ వ్యక్తి తరగతి కోసం డిఫాల్ట్ కన్స్ట్రక్టర్‌ను పరిచయం చేసాను.
33. ఇప్పుడు, వ్యక్తిగత తరగతి ఒక్కసారి మాత్రమే నిర్మించబడిందని మరియు అధ్యాపకులు మరియు విద్యార్థుల ఉదాహరణలు దానిపై ఆధారపడి ఉన్నాయని మనం చూడవచ్చు.
34. కాబట్టి, మేము అధ్యాపకుల బేస్ క్లాస్ యొక్క భాగాన్ని పరిశీలిస్తే, మీరు ఈ వ్యక్తిని పొందుతారు, మీరు విద్యార్థి యొక్క బేస్ క్లాస్ భాగాన్ని చూస్తే, మీరు మళ్ళీ అదే వ్యక్తి యొక్క ఉదాహరణను పొందుతారు., మీరు ఖచ్చితంగా కొంత భాగాన్ని చూస్తే TA యొక్క బేస్ క్లాస్.
35. వాస్తవానికి, మీరు ఒక వ్యక్తిని మాత్రమే పొందుతారు.
36. కాబట్టి, మీరు బేస్ క్లాస్ ఉదాహరణను ప్రత్యేకంగా చేస్తారు.
37. అందువల్ల, మేము వర్చువల్ వారసత్వాన్ని ఉపయోగిస్తున్నప్పుడు మరియు రూట్ క్లాస్ యొక్క బహుళ సందర్భాలను ఈ విధంగా నివారించడానికి సోపానక్రమం నిర్మించినప్పుడు, డైమండ్ క్లాస్ యొక్క అనేక ఉదాహరణలు ఉత్పన్నమైన తరగతి (తరగతి) ఉదాహరణ నుండి తీసుకోబడ్డాయి, మేము వర్చువల్ వారసత్వం మరియు తెలిసిన తరగతులను ఉపయోగిస్తాము వర్చువల్ బేస్ క్లాసులు.
38. కాబట్టి, ఇది వర్చువల్ బేస్ క్లాస్, ఇది వర్చువల్ బేస్ క్లాస్, ఈ వర్చువల్ బేస్ క్లాసులు VBC లు.
39. ఎందుకంటే వారు తమ బేస్ క్లాస్ భాగాన్ని నేరుగా నిర్మించరు; మొత్తం, ఉత్పన్నమైన తరగతి వస్తువుతో సాధారణమైన బేస్ క్లాస్ భాగానికి ఉదాహరణ.
40. ఇప్పుడు, ఈ ప్రక్రియలో ఇది వజ్రం విషయంలో ఆబ్జెక్ట్ లేఅవుట్ యొక్క ప్రాథమిక సమస్యను పరిష్కరిస్తుంది, అందుకే మీకు వజ్రం ఉంటే.
41. కాబట్టి, ఈ తరగతిని ఇక్కడ కూడా నిర్మిస్తున్నారు.
42. కాబట్టి, వర్చువల్ వారసత్వం ప్రాథమికంగా ఆ సమస్యను తొలగిస్తుంది, కానీ అలా చేయడానికి ఒక చిన్న పరిమితితో.
43. మేము దీన్ని స్వయంచాలకంగా చేసినందున మనం డిఫాల్ట్ కన్స్ట్రక్టర్ పర్సన్ క్లాస్ మాత్రమే ఉపయోగించగలం.
44. కాబట్టి, నేను ఈ కన్స్ట్రక్టర్ అని పిలవాలనుకునే తరగతికి పారామితులను పాస్ చేయాలనుకుంటే.
45. బహుళ వారసత్వంగా దీన్ని చేయడానికి ఇది చాలా సులభమైన మార్గం, మీరు చేయాల్సిందల్లా ఇవి మీకు వారసత్వంగా లభించాయి, వాస్తవానికి ఇది వారసత్వంగా కనుగొనబడింది, ఈ VBC లు వర్చువల్ తరగతులు బేస్ క్లాస్‌లుగా ఉంటాయి అన్నీ ఒకే విధంగా ఉంటాయి.
46. TA క్లాస్ యొక్క కన్స్ట్రక్టర్లో, దాని కన్స్ట్రక్టర్లో, ఉత్పన్నమైన క్లాస్ యొక్క కన్స్ట్రక్టర్లో మాత్రమే తేడా ఉంది, మీరు రూట్ క్లాస్ యొక్క కన్స్ట్రక్టర్ను స్పష్టంగా పిలుస్తారు మరియు అక్కడ మీరు పారామితులను పాస్ చేస్తారు.
47. కాబట్టి, మీరు ఇలా చేస్తే ఏమి జరుగుతుంది, పారామితిని కలిగి ఉన్న ఈ కన్స్ట్రక్టర్‌ను పిలిచే మొదటిది అవుతుంది.
48. అప్పుడు ఈ ఆర్డర్ ప్రకారం ఇది కాల్ పక్కన ఉంటుంది మరియు ఇది చివరిగా పిలువబడుతుంది కాబట్టి మీరు ఈ వ్యక్తి ఫ్యాకల్టీ విద్యార్ధి అని మరియు టిఎ కన్స్ట్రక్టర్ అది నిర్మించబడే క్రమంలో ఉన్నారని మీరు చూస్తారు.
49. మరియు మీరు ఇప్పటికీ ఆ ప్రాథమిక సమస్యను పరిష్కరించారు. మీకు బేస్ క్లాస్ యొక్క ప్రత్యేకమైన ఉదాహరణ ఉంది, కానీ మీరు పారామితిని కన్స్ట్రక్టర్‌కు పంపించగలుగుతారు.
50. కాబట్టి, బహుళ వారసత్వ సోపానక్రమం నిర్మించడానికి ఇది ప్రాథమిక మార్గం.
51. ఇప్పుడు మీరు ముందుకు వెళ్లి, ఆ పాలిమార్ఫిక్ మరియు ఒక వ్యక్తికి ఎలా బోధించాలో చూపించగలరు, ఆ వ్యక్తి యొక్క బేస్ క్లాస్ దానిని పూర్తిగా వర్చువల్‌గా చేస్తుంది, ఎందుకంటే మీకు తెలియని వ్యక్తి ఎలా బోధించగలడు, కాబట్టి అత్యవసరం, స్వచ్ఛమైన వర్చువల్‌గా ఫంక్షన్, అధ్యాపకులకు వర్తించు, మళ్ళీ విద్యార్థులు మరియు మొదలైనవి.
52. కానీ మీరు అలా చేస్తున్నప్పుడు మీరు దాన్ని ఉపయోగిస్తారా లేదా మీరు ఉపయోగిస్తారా లేదా పాలిమార్ఫిక్ సోపానక్రమంలో మీకు వివాదం ఉంటుంది, అయితే మీరు ఏ సభ్యుల ఫంక్షన్ పాలిమార్ఫిక్ కాని పద్ధతిని ఉపయోగిస్తారో మీరు పేర్కొనలేరు. మీరు కాని విషయంలో చేసారు.
53. కాబట్టి, TA తరగతిలో క్రొత్త సభ్యుల ఫంక్షన్ (ఫంక్షన్) ను ఉపయోగించడం రెండింటినీ అధిగమించడం ద్వారా మీరు దీన్ని సద్వినియోగం చేసుకోవచ్చు.
54. మీరు దీన్ని చేయకపోతే, మీరు TA యొక్క ఉదాహరణ చేయడానికి ప్రయత్నించినప్పుడు, మేము దీన్ని చేయలేమని అది చెబుతుంది ఎందుకంటే ఈ రెండు అభ్యాస పనులలో ఏది ఈ వస్తువు (వస్తువు) మీకు తెలియదు.
55. కాబట్టి, మీరు దీన్ని వ్రాసిన తర్వాత, మీరు దీన్ని నేరుగా వర్చువల్ ఫంక్షన్ పట్టికలో దాచారని అర్థం, అప్పుడు మీరు కోడ్ పనిచేస్తుందని మీరు చేయవచ్చు మరియు తరువాత మీరు ఏమి చేయాలనుకుంటున్నారో దానిపై ఆధారపడి ఉంటుంది.
56. మీరు ఈ ఫంక్షన్‌ను తిరిగి ఉపయోగించాలనుకుంటే, TA తరగతిలో బోధన అమలులో, మీరు ఖచ్చితంగా ఫ్యాకల్టీ కోలన్ చేత సూచించబడవచ్చు లేదా మీరు విద్యార్థి తరగతి అయితే. మీరు (తరగతి) బోధనను తిరిగి ఉపయోగించాలనుకుంటే, మీరు స్టూడెంట్ కోలన్ కోలన్ ను ఉపయోగించవచ్చు లేదా మీరు మీ స్వంతంగా దరఖాస్తు చేసుకోవచ్చు.
57. కాబట్టి, వజ్రాల నిర్మాణంతో బహుళ వారసత్వ పరంగా ఇది అస్పష్టత యొక్క ప్రాథమిక సమస్య, మీకు వజ్రాల నిర్మాణం లేకపోతే, మాకు అది ఉండదు.
58. మీరు వజ్రం కలిగి ఉండటమే దీనికి కారణం.
59. కాబట్టి, మీకు వజ్రం ఉన్నందున, బోధనా పని ఇక్కడకు చేరుకోవడానికి రెండు మార్గాలు ఉన్నాయి, బోధించగల రెండు మార్గాలు ఇక్కడకు చేరుకోవచ్చు, మీకు ఎక్కువ బేస్ క్లాసులు మరియు ఒక సాధారణ వజ్రం ఉంటే, మీకు ఎక్కువ మార్గాలు ఉంటాయి, కానీ గందరగోళానికి రెండు సరిపోతాయి.
60. కాబట్టి, ఇక్కడ మీరు ఈ బోధను ఉపయోగించాలా వద్దా అని మీకు తెలియదు.
61. కాబట్టి, ఇది ఒక ప్రాథమిక సమస్య మరియు మీరు నిజంగా ఒక సాధారణ బహుళ వారసత్వ సోపానక్రమం కావాలనుకుంటే అది చాలా సమస్యలకు దారితీస్తుంది.
62. మరియు చాలా తరచుగా, అనేక వారసత్వ పరిస్థితులలో, మీరు దీన్ని ఉపయోగించకూడదని చాలా సంస్థలు పేర్కొన్నాయి, ఇది బహుళ వారసత్వ సంపద యొక్క మొత్తం వినియోగాన్ని తీవ్రంగా పరిమితం చేస్తుంది.
63. కానీ ఇది తీవ్రమైన వ్యాఖ్యాన సమస్య.
64. కాబట్టి, ఈ సందర్భంలో, ఒకటి ఉంది; ఇది ఒక తరగతి A, ఒక తరగతి B.
65. అందువల్ల ఒక తరగతి A తరగతి B మరియు తరువాత తరగతి C మరియు తరువాత తరగతి D.
66. కాబట్టి, ఇది ఇలాంటి దృశ్యం.
67. కాబట్టి, ఇది మళ్ళీ బహుళ వారసత్వ దృశ్యం, కానీ ఇది వజ్రం కాదు.
68. కాబట్టి, వేర్వేరు సభ్యుల విధులు foo మరియు foobar దానిపై నిర్వచించబడ్డాయి.
69. అందువల్ల, మీరు ఒక వారసత్వంలో అధ్యయనం చేసిన వారందరితో పాటు అనేక వారసత్వాలను మీకు తెలుసు అని మాత్రమే నేను మీకు సూచిస్తాను.
70. మీరు వేర్వేరు తరగతి వస్తువుల ఉదాహరణలను సృష్టించడానికి ప్రయత్నిస్తారు, వివిధ రకాల పాయింట్లను తీసుకోవడానికి ప్రయత్నించండి మరియు ఈ సోపానక్రమానికి మీరు వేర్వేరు సభ్యుల విధులను ఎలా అన్వయించవచ్చో వివరించడానికి ప్రయత్నించండి.
71. వాస్తవానికి, మీరు C నుండి A ను పొందడం ద్వారా మొత్తం విషయాన్ని క్లిష్టతరం చేయవచ్చు, మీరు వజ్రం నుండి A ను పొందటానికి అనుమతించిన క్షణం మరియు మీకు అస్పష్టత యొక్క ఆసక్తికరమైన సమస్య వస్తుంది.
72. కాబట్టి, చివరకు, నేను మూసివేసే ముందు, డిజైన్ ఎంపిక యొక్క ఒక సంగ్రహావలోకనం మీకు ఇవ్వాలనుకుంటున్నాను, అంటే మనం ఎల్లప్పుడూ వారసత్వ పరంగా మోడల్ చేయగలము మరియు బదులుగా మనం మరొకదాన్ని సృష్టించగలము. సోపానక్రమం యొక్క క్రమబద్ధీకరణ.
73. మీరు వారసత్వంగా ఉందా లేదా మీరు సృష్టించాలా అనే దానిపై డిజైనర్లలో ఎప్పుడూ వ్యాపారం ఉంటుంది.
74. కాబట్టి, మీరు ఎలాంటి ఇబ్బందులను అంగీకరిస్తున్నారో మీకు చూపించడానికి ఇక్కడ ఒక ఉదాహరణ సృష్టించబడింది.
75. ఉదాహరణకు, నేను వాహన సోపానక్రమం వైపు చూస్తున్నాను మరియు ఇవి వాహనం యొక్క ఉపవర్గాలు మీకు తెలిసిన ప్రాధమికవి, వీల్ వాహనాల తరగతి ప్రపంచంలో ఉందని మీరు చూస్తున్నారు.
76. వివిధ రకాలైన డ్రైవింగ్ మెకానిజమ్స్ ఉన్నప్పటికీ, ఇంజిన్ క్లాస్ ప్రాథమికంగా వేర్వేరు డ్రైవ్ మెకానిజమ్స్, దాని కోసం కావచ్చు మరియు మీరు దానిని చూస్తే, చక్రం పరంగా, మీకు ఒక జంట ఉంది మీకు చక్రాల వాహనం ఉండవచ్చు, మీరు చేయవచ్చు మూడు చక్రాల వాహనం కలిగి ఉండండి మరియు మీకు నాలుగు చక్రాల వాహనం ఉండవచ్చు. ఇవి వేర్వేరు ఎంపికలు.
77. మరియు ఇంజిన్ క్లాస్ సందర్భంలో, మీరు ఒక మాన్యువల్ డ్రైవ్ కలిగి ఉండవచ్చు, దీనిలో మీరు పెట్రోల్ ద్రవాన్ని నడపవచ్చు, మీరు ఎలక్ట్రిక్ డ్రైవ్ కలిగి ఉంటారు - ఇవి వేర్వేరు రకాలు.
78. కాబట్టి, మీకు ఇవన్నీ ఉంటే, ప్రాథమికంగా మీకు వీల్ డ్రైవ్, ఇంజిన్ క్లాస్ ఆధారంగా రెండు ప్రధాన సోపానక్రమాలు ఉన్నాయి.
79. కాబట్టి, మీరు దానిని చూస్తే, వాటి ఆధారంగా మీకు చాలా కాంబినేషన్ల ఆధారంగా చాలా క్లాసులు ఉన్నాయి, నేను సైకిల్ గురించి మాట్లాడగలను, ఇది మాన్యువల్ మరియు త్రీ వీలర్.
80. కాబట్టి, ఇది బహుళ వారసత్వంగా జరుగుతోంది, నాకు ఒక కారు ఉంది, ఇది నాలుగు చక్రాల మరియు పెట్రోల్ ద్రవం, నాకు ఎలక్ట్రిక్ కారు ఉంది, ఇది నాలుగు చక్రాలు, కానీ ఎలక్ట్రిక్ ద్రవం మరియు మొదలైనవి.
81. కాబట్టి, నా దగ్గర మూడు రకాల చక్రాల వాహనాలు ఉన్నాయి, నా దగ్గర మూడు రకాల ఇంజన్ డ్రైవ్‌లు ఉన్నాయి.
82. కాబట్టి, వాస్తవానికి నాకు మూడు నుండి తొమ్మిది కలయికలు ఉన్నాయి మరియు ఒకే బేస్ క్లాస్ తల్లిదండ్రులను కలిగి ఉన్న బహుళ జీవన తరగతులను కలిగి ఉంటాయి.
83. కాబట్టి, మీరు నిజంగా తొమ్మిది కంటే ఎక్కువ పేలుడు రకం కలయికలను కలిగి ఉంటారు, ఇవి ప్రత్యక్ష స్థాయిలో సమానంగా పేలుడు రకం కలయికలను సాధిస్తాయి.
84. కాబట్టి, మోడలింగ్ పరంగా ఇది చాలా చక్కనిది, కానీ మీరు నిజంగా కోడ్‌ను నిర్వహించాల్సి వచ్చినప్పుడు, మరియు ఈ మొత్తం సోపానక్రమాలను గుర్తుంచుకోండి మరియు పైభాగంలో ఉన్న తర్కాన్ని ఇష్టపడతారు, వారసత్వం (వారసత్వం) కాదా అని ప్రతి దశలో నిర్ణయించండి.
85. మరియు మీరు ఏమి ఉపయోగించాలో మరియు మీరు ఏమి అధిగమించాలో మీకు తెలుసు, ఇది డిజైన్‌లో చాలా మంచి సహాయంగా మారదు కానీ అది ఒక అవరోధంగా మారుతుంది.
86. కాబట్టి, ఒక సాధారణ రెసిపీ అంటే ఏమిటి, మీకు ఒక డొమైన్‌లో చాలా ఎక్కువ సోపానక్రమం ఉంటే, అప్పుడు మీరు ఒకదాన్ని ఎన్నుకోవాలి, ఇది ప్రధానమైనది, ఇది చాలా చోట్ల మీకు సహాయపడే చూడటానికి ఒక మార్గం. బహుళ వారసత్వం గురించి చదవండి a వాహన సోపానక్రమం.
87. కాబట్టి, నేను చక్రాల వాహనాల సోపానక్రమం వైపు చూస్తున్నాను.
88. అందువల్ల, నేను ఇంజిన్ రకాలను చూడటం లేదు.
89. కాబట్టి, నేను ఏ రకమైన ఉత్పన్న వాహనాన్ని వస్తువుగా చేసినప్పుడు నేను ఏమి చేస్తాను.
90. కాబట్టి, ఇవి వేర్వేరు చక్రాల వాహనాలు, అవి నాలుగు, మూడు, రెండు, ఆపై మీకు అన్ని బేస్ క్లాసులు ఉన్నాయి.
91. దీని కోసం నేను ఈ వస్తువులో ఇంజిన్ స్టార్ కలిగి ఉంటాను, ఇది ఇంజిన్ను సూచిస్తుంది మరియు ఇది ప్రాథమికంగా ఇంజిన్ క్లాస్‌ను సూచిస్తుంది.
92. విభిన్న స్పెషలైజేషన్.
93. కాబట్టి, నా దగ్గర మాన్యువల్ ఉందా, నాకు విద్యుత్తు ఉందా, పెట్రోల్ ఫ్లూయిడ్ ఉందా, మొదలైనవి, ఈ వస్తువును రెండు సోపానక్రమాల నుండి సంయుక్తంగా పొందే బదులు, నేను దీన్ని ప్రత్యేకంగా చేయగలను నేను ఇక్కడ చక్రాల వైపు ఒక్కొక్కటిగా పొందుతాను ఇంజిన్ సోపానక్రమం చూడండి.
94. సభ్యుడిగా, ఒక కూర్పు.
95. కాబట్టి, ఈ పాయింటర్ అప్పుడు నాకు కావలసిన విధంగా నిర్దిష్ట రకం ఇంజిన్‌ను తీసుకుంటుంది.
96. వాస్తవానికి, నేను దీన్ని చేస్తుంటే, నేను దీన్ని మరొక విధంగా చేయగలను, నేను మళ్ళీ వాహన సోపానక్రమం చేయగలను, ఇది ప్రాథమికంగా ఇంజిన్ తరగతిపై ఆధారపడి ఉంటుంది.
97. కాబట్టి, నాకు ఎలక్ట్రిక్ ఇంజిన్, పెట్రోల్ ఫ్యూయల్ ఇంజిన్, మాన్యువల్ ఉన్నాయి, దానిపై నా లీఫ్ లేబుల్ క్లాసులు ఉన్నాయి, కానీ ఇప్పుడు నా దగ్గర ఒక చక్రంలో ఒక పాయింటర్ ఉంది, ఇది ప్రాథమికంగా నాకు రెండు వీలర్, త్రీ వీలర్, ఫోర్ వీలర్ సోపానక్రమం మరియు ఇలా చెబుతుంది పై.
98. మరియు నేను ప్రధానంగా ఇంజిన్ రకంపై కీ సోపానక్రమంగా పని చేస్తాను మరియు ఈ వాహన రకం యొక్క మరొక HASA లేదా భాగాన్ని ఉపయోగిస్తాను.
99. కాబట్టి, గాని చేయవచ్చు, వారసత్వ నిర్మాణంలో చాలా సమాచారం ఉంటే మీకు అలాంటి అనేక ఎంపికలు ఉంటాయి.
100. మరియు వాటిలో సాధారణంగా గుర్తించబడిన మరియు సాధారణంగా ఉపయోగించే శైలి ఏమిటంటే, మీరు వారసత్వంలోని వివిధ ఎంపికలలో ఒకటి మీరు కనుగొన్న సోపానక్రమం, వాటిలో ఒకదాన్ని గుర్తించండి. ఏది ప్రధానమైనది మరియు ఒకే బహుళ-స్థాయి మరియు మీరు సోపానక్రమంలో తెలుసుకోండి.
101. మరియు మీరు పొందుతున్న అన్ని ఇతర సోపానక్రమం ఇంజిన్ వంటి సంబంధం, వాటిని వాటి భాగాలుగా చేయడానికి మేము ఇక్కడ చూశాము.
102. ఆపై మీరు ఆ భాగానికి ప్రయాణించి ప్రత్యేక సోపానక్రమంలోకి వెళతారు.
103. మరియు ఈ సోపానక్రమంలో ఇంజిన్ రకం గురించి వాదించండి, మీరు ప్రయాణీకుల కోసం క్యారేజ్ రకాన్ని బట్టి మరొక సోపానక్రమం కావాలనుకుంటే, అది సామాను కోసం కాదా. ఇది అదుపు కోసం మరియు మొదలైనవి.
104. కాబట్టి, తదనుగుణంగా మీరు దీన్ని చేయాలి; ఇప్పుడు ఇది ఒక సోపానక్రమంలో ఉండాలి.
105. కాబట్టి, మీరు దానిపై పాలిమార్ఫిక్ కోడ్‌ను వ్రాసి, ఆపై ప్రత్యామ్నాయ సోపానక్రమంలో వేర్వేరు భాగాలను చూడండి.
106. మరియు మీరు రెండు స్వతంత్ర సోపానక్రమాలను సంయుక్తంగా నిర్ణయించగలిగే డబుల్ ట్రాన్స్‌మిట్‌పై నిర్ణయించే అనేక డిజైన్ టెక్నిక్‌లు ఉన్నాయి మరియు వాస్తవానికి ఈ కోర్సు యొక్క పరిధి నుండి విస్తరించే పాలిమార్ఫిక్ ఫంక్షన్‌ను పంపవచ్చు. మీరు మరింతగా మారడంతో మించి ఉంటుంది మరింత నిపుణుడు.
107. , మీరు అన్నీ నేర్చుకోగలరు మరియు చూడగలరు.
108. కాబట్టి, ఈ మాడ్యూల్‌లోని రెండు ఉపన్యాసాలను సంగ్రహించడానికి, మేము అనేక వారసత్వ భావనలను ప్రవేశపెట్టాము, మేము ప్రాథమిక అర్థాలను వివరించాము.
109. మీరు బహుళ వారసత్వాన్ని ఉపయోగించినప్పుడు, విభిన్న వారసత్వం ఏమిటో మీకు చూపించడానికి మాత్రమే ప్రయత్నించాను.
110. చివరకు, వారసత్వ ఉపయోగం మధ్య డిజైన్ ఎంపిక గురించి మీకు కొంత ఆలోచన ఇవ్వడానికి ప్రయత్నించండి, ఎందుకంటే దృశ్య నిర్మాణం మరియు నిర్మాణం యొక్క ఒక వ్యవస్థ మాత్రమే వారసత్వం మరియు నిర్మాణం యొక్క మిశ్రమాన్ని సృష్టిస్తుంది మరియు ఒక ప్రధాన పాలిమార్ఫిక్ వస్తువు యొక్క ప్రధాన సోపానక్రమంపై నిర్ణయిస్తుంది ప్రాతినిధ్యం.
111. వస్తువుల.
112. మరియు సందర్భానుసారంగా ఇతరుల సృష్టిని ఉపయోగించడం మరియు తదనుగుణంగా వారి పాలిమార్ఫిక్‌ను పంపించడం.
113.
అందువల్ల, నిర్మాణం ఖచ్చితంగా బేస్ క్లాస్‌ని నిర్మించాలి.
కాబట్టి, టిఎ వస్తువును నిర్మించడానికి ఏమి చేయాలి, అధ్యాపకులను నిర్మించడం.
ఇప్పుడు, అధ్యాపకులకు వ్యక్తి నుండి నైపుణ్యం ఉంది.
కాబట్టి, అధ్యాపక వస్తువును నిర్మించటానికి ఏమి చేయాలి అంటే ఒక వ్యక్తి నిర్మించవలసి ఉంటుంది, కాబట్టి ఈ రెండు అధ్యాపక వస్తువును ఏర్పరుస్తాయి.
అప్పుడు విద్యార్థి నిర్మించవలసి ఉంటుంది మరియు విద్యార్థికి వ్యక్తి నుండి నైపుణ్యం లభిస్తుంది.
కాబట్టి, నేను ఒక విద్యార్థిని నిర్మించవలసి వస్తే, నేను మళ్ళీ ఒక వ్యక్తిని నిర్మించాలి.
కాబట్టి, మరో వ్యక్తిని నిర్మిస్తారు, ఆపై విద్యార్థిని నిర్మిస్తారు, అప్పుడు టిఎ సృష్టించబడుతుంది.
కాబట్టి, నేను మొత్తం ఆబ్జెక్ట్ దృష్టాంతాన్ని పరిశీలిస్తే, నాకు రెండు బేస్ క్లాసులు ఉన్నాయి.ఇది అధ్యాపకులు మరియు ఇది ఒక విద్యార్థి.
మరియు అది ఒక వ్యక్తి అవుతుంది, అది ఒక వ్యక్తిని కలిగి ఉంటుంది, మీకు వేర్వేరు ఫ్యాకల్టీ డేటా ఉంటుంది, మీకు ఇక్కడ విద్యార్థుల డేటా ఉంటుంది, మీకు ఉత్పన్నమైన తరగతి ఉంటుంది, ఈ టిఎ వస్తువు.
కాబట్టి, మీకు ఇక్కడ TA డేటా ఉంటుంది, ఇవి TA డేటా.
కానీ అది నిజంగా ఎలా నిర్మిస్తుంది.
అందువల్ల, మీరు ఈ విధంగా నిర్మించినప్పుడు, మా వారసత్వం యొక్క ప్రాథమిక సూత్రం ఒకే TA వస్తువులో ఇద్దరు వ్యక్తుల వస్తువులు ఉండాలి అని చెబుతుంది.
ఎందుకంటే, లేకపోతే అధ్యాపకులను నిర్మించలేము ఎందుకంటే బేస్ ఆబ్జెక్ట్ తప్పనిసరిగా దానిలో పొందుపరచబడాలి, విద్యార్థిని నిర్మించలేము ఎందుకంటే ఆ వ్యక్తి తప్పనిసరిగా దానిలో పొందుపరచబడాలి.
అందువల్ల, టీఏకు అధ్యాపకులు మరియు విద్యార్థులు ఇద్దరూ అవసరం.
కాబట్టి, మీకు బేస్ క్లాస్ ఆబ్జెక్ట్ యొక్క రెండు ఉదాహరణలు ఉంటాయి మరియు ఇది ఖచ్చితంగా చాలా కావాల్సిన పరిస్థితి కాదు, ఎందుకంటే నేను వ్యక్తి క్లాస్ (క్లాస్) రెండు ఉదాహరణలు కలిగి ఉంటే TA గా ఉన్న వ్యక్తికి ఒకే ఒక లక్షణం ఉంటుంది మరియు నేను ఎలా చేస్తాను దాన్ని పరిష్కరించండి, మీరు డేటాను ఎలా నిర్వహించబోతున్నారు.
కాబట్టి, ఇది వర్చువల్ వారసత్వం మరియు బహుళ వారసత్వం అని పిలువబడుతుంది.
అది చెప్పేది ఏమిటంటే, మేము వర్చువల్ అనే కీవర్డ్‌ని ఉపయోగిస్తాము, ఎరుపు రంగును మళ్ళీ ఉపయోగించుకుందాం, ఆ తర్వాత అది పట్టింపు లేదు, మీరు దీన్ని బహిరంగంగా వ్రాసినా, బహిరంగపరచండి. మీరు వారసత్వంగా పొందుతున్న కీవర్డ్ వర్చువల్.
మీరు దీన్ని చేసినప్పుడు, వారసత్వం వర్చువల్ అవుతుంది, అంటే TA ను సృష్టించాల్సిన మొదటి విషయం ఏమిటంటే అధ్యాపకులు తప్పనిసరిగా నిర్మించబడాలి.
ఇప్పుడు, అధ్యాపక వ్యక్తి వర్చువల్ మార్గంలో వారసత్వంగా వచ్చాడని మీరు చెబితే, మరికొన్ని నిర్దిష్ట తరగతి సృష్టించబడుతోందని తెలుసు, దాని కోసం ఇతర బేస్ క్లాస్ (క్లాస్)) కావచ్చు.
అందువల్ల, అధ్యాపకులు దాని స్వంత వ్యక్తి తరగతిని నిర్మించరు, వ్యక్తి వస్తువు ఉన్న చోట నిర్మాణం ఉదాహరణను సృష్టించదు.
అదేవిధంగా, ఈ విద్యార్థి మేము చేసేటప్పుడు తరగతి యొక్క వ్యక్తిగత ఉదాహరణను సృష్టించడు, లేకపోతే నాకు అది అవసరం.
కానీ ఈ ప్రక్రియ అధ్యాపకులకు మరియు విద్యార్థికి ఒక సాధారణ వ్యక్తి ఉదాహరణను సృష్టిస్తుంది.
ఇప్పుడు, ఇది ఎలా నిర్మించబడుతుందో, ఇప్పుడు అధ్యాపకులు ఖచ్చితంగా విద్యార్థిని నిర్మించటం లేదు, ఎందుకంటే వారు వారసత్వంగా ఉన్న వ్యక్తి నుండి స్వీకరిస్తున్నారు.
కాబట్టి, ఇది డిఫాల్ట్ కన్స్ట్రక్టర్ అయి ఉండాలి, దీని కోసం ఒకే బేస్ క్లాస్, ప్రత్యేకమైన బేస్ క్లాస్ ఇంట్రస్ట్ సృష్టించబడే వర్చువల్ వారసత్వ ప్రక్రియ ఉండాలి.
అందువల్ల, నేను ఇక్కడ వ్యక్తి తరగతి కోసం డిఫాల్ట్ కన్స్ట్రక్టర్‌ను పరిచయం చేసాను.
ఇప్పుడు, వ్యక్తిగత తరగతి ఒక్కసారి మాత్రమే నిర్మించబడిందని మరియు అధ్యాపకులు మరియు విద్యార్థుల ఉదాహరణలు దానిపై ఆధారపడి ఉన్నాయని మనం చూడవచ్చు.
కాబట్టి, మేము అధ్యాపకుల బేస్ క్లాస్ యొక్క భాగాన్ని పరిశీలిస్తే, మీరు ఈ వ్యక్తిని పొందుతారు, మీరు విద్యార్థి యొక్క బేస్ క్లాస్ భాగాన్ని చూస్తే, మీరు మళ్ళీ అదే వ్యక్తి యొక్క ఉదాహరణను పొందుతారు., మీరు ఖచ్చితంగా కొంత భాగాన్ని చూస్తే TA యొక్క బేస్ క్లాస్.
వాస్తవానికి, మీరు ఒక వ్యక్తిని మాత్రమే పొందుతారు.
కాబట్టి, మీరు బేస్ క్లాస్ ఉదాహరణను ప్రత్యేకంగా చేస్తారు.
అందువల్ల, మేము వర్చువల్ వారసత్వాన్ని ఉపయోగిస్తున్నప్పుడు మరియు రూట్ క్లాస్ యొక్క బహుళ సందర్భాలను ఈ విధంగా నివారించడానికి సోపానక్రమం నిర్మించినప్పుడు, డైమండ్ క్లాస్ యొక్క అనేక ఉదాహరణలు ఉత్పన్నమైన తరగతి (తరగతి) ఉదాహరణ నుండి తీసుకోబడ్డాయి, మేము వర్చువల్ వారసత్వం మరియు తెలిసిన తరగతులను ఉపయోగిస్తాము వర్చువల్ బేస్ క్లాసులు.
కాబట్టి, ఇది వర్చువల్ బేస్ క్లాస్, ఇది వర్చువల్ బేస్ క్లాస్, ఈ వర్చువల్ బేస్ క్లాసులు VBC లు.
ఎందుకంటే వారు తమ బేస్ క్లాస్ భాగాన్ని నేరుగా నిర్మించరు; మొత్తం, ఉత్పన్నమైన తరగతి వస్తువుతో సాధారణమైన బేస్ క్లాస్ భాగానికి ఉదాహరణ.
ఇప్పుడు, ఈ ప్రక్రియలో ఇది వజ్రం విషయంలో ఆబ్జెక్ట్ లేఅవుట్ యొక్క ప్రాథమిక సమస్యను పరిష్కరిస్తుంది, అందుకే మీకు వజ్రం ఉంటే.
కాబట్టి, ఈ తరగతిని ఇక్కడ కూడా నిర్మిస్తున్నారు.
కాబట్టి, వర్చువల్ వారసత్వం ప్రాథమికంగా ఆ సమస్యను తొలగిస్తుంది, కానీ అలా చేయడానికి ఒక చిన్న పరిమితితో.
మేము దీన్ని స్వయంచాలకంగా చేసినందున మనం డిఫాల్ట్ కన్స్ట్రక్టర్ పర్సన్ క్లాస్ మాత్రమే ఉపయోగించగలం.
కాబట్టి, నేను ఈ కన్స్ట్రక్టర్ అని పిలవాలనుకునే తరగతికి పారామితులను పాస్ చేయాలనుకుంటే.
బహుళ వారసత్వంగా దీన్ని చేయడానికి ఇది చాలా సులభమైన మార్గం, మీరు చేయాల్సిందల్లా ఇవి మీకు వారసత్వంగా లభించాయి, వాస్తవానికి ఇది వారసత్వంగా కనుగొనబడింది, ఈ VBC లు వర్చువల్ తరగతులు బేస్ క్లాస్‌లుగా ఉంటాయి అన్నీ ఒకే విధంగా ఉంటాయి.
TA క్లాస్ యొక్క కన్స్ట్రక్టర్లో, దాని కన్స్ట్రక్టర్లో, ఉత్పన్నమైన క్లాస్ యొక్క కన్స్ట్రక్టర్లో మాత్రమే తేడా ఉంది, మీరు రూట్ క్లాస్ యొక్క కన్స్ట్రక్టర్ను స్పష్టంగా పిలుస్తారు మరియు అక్కడ మీరు పారామితులను పాస్ చేస్తారు.
కాబట్టి, మీరు ఇలా చేస్తే ఏమి జరుగుతుంది, పారామితిని కలిగి ఉన్న ఈ కన్స్ట్రక్టర్‌ను పిలిచే మొదటిది అవుతుంది.
అప్పుడు ఈ ఆర్డర్ ప్రకారం ఇది కాల్ పక్కన ఉంటుంది మరియు ఇది చివరిగా పిలువబడుతుంది కాబట్టి మీరు ఈ వ్యక్తి ఫ్యాకల్టీ విద్యార్ధి అని మరియు టిఎ కన్స్ట్రక్టర్ అది నిర్మించబడే క్రమంలో ఉన్నారని మీరు చూస్తారు.
మరియు మీరు ఇప్పటికీ ఆ ప్రాథమిక సమస్యను పరిష్కరించారు. మీకు బేస్ క్లాస్ యొక్క ప్రత్యేకమైన ఉదాహరణ ఉంది, కానీ మీరు పారామితిని కన్స్ట్రక్టర్‌కు పంపించగలుగుతారు.
కాబట్టి, బహుళ వారసత్వ సోపానక్రమం నిర్మించడానికి ఇది ప్రాథమిక మార్గం.
ఇప్పుడు మీరు ముందుకు వెళ్లి, ఆ పాలిమార్ఫిక్ మరియు ఒక వ్యక్తికి ఎలా బోధించాలో చూపించగలరు, ఆ వ్యక్తి యొక్క బేస్ క్లాస్ దానిని పూర్తిగా వర్చువల్‌గా చేస్తుంది, ఎందుకంటే మీకు తెలియని వ్యక్తి ఎలా బోధించగలడు, కాబట్టి అత్యవసరం, స్వచ్ఛమైన వర్చువల్‌గా ఫంక్షన్, అధ్యాపకులకు వర్తించు, మళ్ళీ విద్యార్థులు మరియు మొదలైనవి.
కానీ మీరు అలా చేస్తున్నప్పుడు మీరు దాన్ని ఉపయోగిస్తారా లేదా మీరు ఉపయోగిస్తారా లేదా పాలిమార్ఫిక్ సోపానక్రమంలో మీకు వివాదం ఉంటుంది, అయితే మీరు ఏ సభ్యుల ఫంక్షన్ పాలిమార్ఫిక్ కాని పద్ధతిని ఉపయోగిస్తారో మీరు పేర్కొనలేరు. మీరు కాని విషయంలో చేసారు.
కాబట్టి, TA తరగతిలో క్రొత్త సభ్యుల ఫంక్షన్ (ఫంక్షన్) ను ఉపయోగించడం రెండింటినీ అధిగమించడం ద్వారా మీరు దీన్ని సద్వినియోగం చేసుకోవచ్చు.
మీరు దీన్ని చేయకపోతే, మీరు TA యొక్క ఉదాహరణ చేయడానికి ప్రయత్నించినప్పుడు, మేము దీన్ని చేయలేమని అది చెబుతుంది ఎందుకంటే ఈ రెండు అభ్యాస పనులలో ఏది ఈ వస్తువు (వస్తువు) మీకు తెలియదు.
కాబట్టి, మీరు దీన్ని వ్రాసిన తర్వాత, మీరు దీన్ని నేరుగా వర్చువల్ ఫంక్షన్ పట్టికలో దాచారని అర్థం, అప్పుడు మీరు కోడ్ పనిచేస్తుందని మీరు చేయవచ్చు మరియు తరువాత మీరు ఏమి చేయాలనుకుంటున్నారో దానిపై ఆధారపడి ఉంటుంది.
మీరు ఈ ఫంక్షన్‌ను తిరిగి ఉపయోగించాలనుకుంటే, TA తరగతిలో బోధన అమలులో, మీరు ఖచ్చితంగా ఫ్యాకల్టీ కోలన్ చేత సూచించబడవచ్చు లేదా మీరు విద్యార్థి తరగతి అయితే. మీరు (తరగతి) బోధనను తిరిగి ఉపయోగించాలనుకుంటే, మీరు స్టూడెంట్ కోలన్ కోలన్ ను ఉపయోగించవచ్చు లేదా మీరు మీ స్వంతంగా దరఖాస్తు చేసుకోవచ్చు.
కాబట్టి, వజ్రాల నిర్మాణంతో బహుళ వారసత్వ పరంగా ఇది అస్పష్టత యొక్క ప్రాథమిక సమస్య, మీకు వజ్రాల నిర్మాణం లేకపోతే, మాకు అది ఉండదు.
మీరు వజ్రం కలిగి ఉండటమే దీనికి కారణం.
కాబట్టి, మీకు వజ్రం ఉన్నందున, బోధనా పని ఇక్కడకు చేరుకోవడానికి రెండు మార్గాలు ఉన్నాయి, బోధించగల రెండు మార్గాలు ఇక్కడకు చేరుకోవచ్చు, మీకు ఎక్కువ బేస్ క్లాసులు మరియు ఒక సాధారణ వజ్రం ఉంటే, మీకు ఎక్కువ మార్గాలు ఉంటాయి, కానీ గందరగోళానికి రెండు సరిపోతాయి.
కాబట్టి, ఇక్కడ మీరు ఈ బోధను ఉపయోగించాలా వద్దా అని మీకు తెలియదు.
కాబట్టి, ఇది ఒక ప్రాథమిక సమస్య మరియు మీరు నిజంగా ఒక సాధారణ బహుళ వారసత్వ సోపానక్రమం కావాలనుకుంటే అది చాలా సమస్యలకు దారితీస్తుంది.
మరియు చాలా తరచుగా, అనేక వారసత్వ పరిస్థితులలో, మీరు దీన్ని ఉపయోగించకూడదని చాలా సంస్థలు పేర్కొన్నాయి, ఇది బహుళ వారసత్వ సంపద యొక్క మొత్తం వినియోగాన్ని తీవ్రంగా పరిమితం చేస్తుంది.
కానీ ఇది తీవ్రమైన వ్యాఖ్యాన సమస్య.
కాబట్టి, ఈ సందర్భంలో, ఒకటి ఉంది; ఇది ఒక తరగతి A, ఒక తరగతి B.
అందువల్ల ఒక తరగతి A తరగతి B మరియు తరువాత తరగతి C మరియు తరువాత తరగతి D.
కాబట్టి, ఇది ఇలాంటి దృశ్యం.
కాబట్టి, ఇది మళ్ళీ బహుళ వారసత్వ దృశ్యం, కానీ ఇది వజ్రం కాదు.
కాబట్టి, వేర్వేరు సభ్యుల విధులు foo మరియు foobar దానిపై నిర్వచించబడ్డాయి.
అందువల్ల, మీరు ఒక వారసత్వంలో అధ్యయనం చేసిన వారందరితో పాటు అనేక వారసత్వాలను మీకు తెలుసు అని మాత్రమే నేను మీకు సూచిస్తాను.
మీరు వేర్వేరు తరగతి వస్తువుల ఉదాహరణలను సృష్టించడానికి ప్రయత్నిస్తారు, వివిధ రకాల పాయింట్లను తీసుకోవడానికి ప్రయత్నించండి మరియు ఈ సోపానక్రమానికి మీరు వేర్వేరు సభ్యుల విధులను ఎలా అన్వయించవచ్చో వివరించడానికి ప్రయత్నించండి.
వాస్తవానికి, మీరు C నుండి A ను పొందడం ద్వారా మొత్తం విషయాన్ని క్లిష్టతరం చేయవచ్చు, మీరు వజ్రం నుండి A ను పొందటానికి అనుమతించిన క్షణం మరియు మీకు అస్పష్టత యొక్క ఆసక్తికరమైన సమస్య వస్తుంది.
కాబట్టి, చివరకు, నేను మూసివేసే ముందు, డిజైన్ ఎంపిక యొక్క ఒక సంగ్రహావలోకనం మీకు ఇవ్వాలనుకుంటున్నాను, అంటే మనం ఎల్లప్పుడూ వారసత్వ పరంగా మోడల్ చేయగలము మరియు బదులుగా మనం మరొకదాన్ని సృష్టించగలము. సోపానక్రమం యొక్క క్రమబద్ధీకరణ.
మీరు వారసత్వంగా ఉందా లేదా మీరు సృష్టించాలా అనే దానిపై డిజైనర్లలో ఎప్పుడూ వ్యాపారం ఉంటుంది.
కాబట్టి, మీరు ఎలాంటి ఇబ్బందులను అంగీకరిస్తున్నారో మీకు చూపించడానికి ఇక్కడ ఒక ఉదాహరణ సృష్టించబడింది.
ఉదాహరణకు, నేను వాహన సోపానక్రమం వైపు చూస్తున్నాను మరియు ఇవి వాహనం యొక్క ఉపవర్గాలు మీకు తెలిసిన ప్రాధమికవి, వీల్ వాహనాల తరగతి ప్రపంచంలో ఉందని మీరు చూస్తున్నారు.
వివిధ రకాలైన డ్రైవింగ్ మెకానిజమ్స్ ఉన్నప్పటికీ, ఇంజిన్ క్లాస్ ప్రాథమికంగా వేర్వేరు డ్రైవ్ మెకానిజమ్స్, దాని కోసం కావచ్చు మరియు మీరు దానిని చూస్తే, చక్రం పరంగా, మీకు ఒక జంట ఉంది మీకు చక్రాల వాహనం ఉండవచ్చు, మీరు చేయవచ్చు మూడు చక్రాల వాహనం కలిగి ఉండండి మరియు మీకు నాలుగు చక్రాల వాహనం ఉండవచ్చు. ఇవి వేర్వేరు ఎంపికలు.
మరియు ఇంజిన్ క్లాస్ సందర్భంలో, మీరు ఒక మాన్యువల్ డ్రైవ్ కలిగి ఉండవచ్చు, దీనిలో మీరు పెట్రోల్ ద్రవాన్ని నడపవచ్చు, మీరు ఎలక్ట్రిక్ డ్రైవ్ కలిగి ఉంటారు - ఇవి వేర్వేరు రకాలు.
కాబట్టి, మీకు ఇవన్నీ ఉంటే, ప్రాథమికంగా మీకు వీల్ డ్రైవ్, ఇంజిన్ క్లాస్ ఆధారంగా రెండు ప్రధాన సోపానక్రమాలు ఉన్నాయి.
కాబట్టి, మీరు దానిని చూస్తే, వాటి ఆధారంగా మీకు చాలా కాంబినేషన్ల ఆధారంగా చాలా క్లాసులు ఉన్నాయి, నేను సైకిల్ గురించి మాట్లాడగలను, ఇది మాన్యువల్ మరియు త్రీ వీలర్.
కాబట్టి, ఇది బహుళ వారసత్వంగా జరుగుతోంది, నాకు ఒక కారు ఉంది, ఇది నాలుగు చక్రాల మరియు పెట్రోల్ ద్రవం, నాకు ఎలక్ట్రిక్ కారు ఉంది, ఇది నాలుగు చక్రాలు, కానీ ఎలక్ట్రిక్ ద్రవం మరియు మొదలైనవి.
కాబట్టి, నా దగ్గర మూడు రకాల చక్రాల వాహనాలు ఉన్నాయి, నా దగ్గర మూడు రకాల ఇంజన్ డ్రైవ్‌లు ఉన్నాయి.
కాబట్టి, వాస్తవానికి నాకు మూడు నుండి తొమ్మిది కలయికలు ఉన్నాయి మరియు ఒకే బేస్ క్లాస్ తల్లిదండ్రులను కలిగి ఉన్న బహుళ జీవన తరగతులను కలిగి ఉంటాయి.
కాబట్టి, మీరు నిజంగా తొమ్మిది కంటే ఎక్కువ పేలుడు రకం కలయికలను కలిగి ఉంటారు, ఇవి ప్రత్యక్ష స్థాయిలో సమానంగా పేలుడు రకం కలయికలను సాధిస్తాయి.
కాబట్టి, మోడలింగ్ పరంగా ఇది చాలా చక్కనిది, కానీ మీరు నిజంగా కోడ్‌ను నిర్వహించాల్సి వచ్చినప్పుడు, మరియు ఈ మొత్తం సోపానక్రమాలను గుర్తుంచుకోండి మరియు పైభాగంలో ఉన్న తర్కాన్ని ఇష్టపడతారు, వారసత్వం (వారసత్వం) కాదా అని ప్రతి దశలో నిర్ణయించండి.
మరియు మీరు ఏమి ఉపయోగించాలో మరియు మీరు ఏమి అధిగమించాలో మీకు తెలుసు, ఇది డిజైన్‌లో చాలా మంచి సహాయంగా మారదు కానీ అది ఒక అవరోధంగా మారుతుంది.
కాబట్టి, ఒక సాధారణ రెసిపీ అంటే ఏమిటి, మీకు ఒక డొమైన్‌లో చాలా ఎక్కువ సోపానక్రమం ఉంటే, అప్పుడు మీరు ఒకదాన్ని ఎన్నుకోవాలి, ఇది ప్రధానమైనది, ఇది చాలా చోట్ల మీకు సహాయపడే చూడటానికి ఒక మార్గం. బహుళ వారసత్వం గురించి చదవండి a వాహన సోపానక్రమం.
కాబట్టి, నేను చక్రాల వాహనాల సోపానక్రమం వైపు చూస్తున్నాను.
అందువల్ల, నేను ఇంజిన్ రకాలను చూడటం లేదు.
కాబట్టి, నేను ఏ రకమైన ఉత్పన్న వాహనాన్ని వస్తువుగా చేసినప్పుడు నేను ఏమి చేస్తాను.
కాబట్టి, ఇవి వేర్వేరు చక్రాల వాహనాలు, అవి నాలుగు, మూడు, రెండు, ఆపై మీకు అన్ని బేస్ క్లాసులు ఉన్నాయి.
దీని కోసం నేను ఈ వస్తువులో ఇంజిన్ స్టార్ కలిగి ఉంటాను, ఇది ఇంజిన్ను సూచిస్తుంది మరియు ఇది ప్రాథమికంగా ఇంజిన్ క్లాస్‌ను సూచిస్తుంది.
విభిన్న స్పెషలైజేషన్.
కాబట్టి, నా దగ్గర మాన్యువల్ ఉందా, నాకు విద్యుత్తు ఉందా, పెట్రోల్ ఫ్లూయిడ్ ఉందా, మొదలైనవి, ఈ వస్తువును రెండు సోపానక్రమాల నుండి సంయుక్తంగా పొందే బదులు, నేను దీన్ని ప్రత్యేకంగా చేయగలను నేను ఇక్కడ చక్రాల వైపు ఒక్కొక్కటిగా పొందుతాను ఇంజిన్ సోపానక్రమం చూడండి.
సభ్యుడిగా, ఒక కూర్పు.
కాబట్టి, ఈ పాయింటర్ అప్పుడు నాకు కావలసిన విధంగా నిర్దిష్ట రకం ఇంజిన్‌ను తీసుకుంటుంది.
వాస్తవానికి, నేను దీన్ని చేస్తుంటే, నేను దీన్ని మరొక విధంగా చేయగలను, నేను మళ్ళీ వాహన సోపానక్రమం చేయగలను, ఇది ప్రాథమికంగా ఇంజిన్ తరగతిపై ఆధారపడి ఉంటుంది.
కాబట్టి, నాకు ఎలక్ట్రిక్ ఇంజిన్, పెట్రోల్ ఫ్యూయల్ ఇంజిన్, మాన్యువల్ ఉన్నాయి, దానిపై నా లీఫ్ లేబుల్ క్లాసులు ఉన్నాయి, కానీ ఇప్పుడు నా దగ్గర ఒక చక్రంలో ఒక పాయింటర్ ఉంది, ఇది ప్రాథమికంగా నాకు రెండు వీలర్, త్రీ వీలర్, ఫోర్ వీలర్ సోపానక్రమం మరియు ఇలా చెబుతుంది పై.
మరియు నేను ప్రధానంగా ఇంజిన్ రకంపై కీ సోపానక్రమంగా పని చేస్తాను మరియు ఈ వాహన రకం యొక్క మరొక HASA లేదా భాగాన్ని ఉపయోగిస్తాను.
కాబట్టి, గాని చేయవచ్చు, వారసత్వ నిర్మాణంలో చాలా సమాచారం ఉంటే మీకు అలాంటి అనేక ఎంపికలు ఉంటాయి.
మరియు వాటిలో సాధారణంగా గుర్తించబడిన మరియు సాధారణంగా ఉపయోగించే శైలి ఏమిటంటే, మీరు వారసత్వంలోని వివిధ ఎంపికలలో ఒకటి మీరు కనుగొన్న సోపానక్రమం, వాటిలో ఒకదాన్ని గుర్తించండి. ఏది ప్రధానమైనది మరియు ఒకే బహుళ-స్థాయి మరియు మీరు సోపానక్రమంలో తెలుసుకోండి.
మరియు మీరు పొందుతున్న అన్ని ఇతర సోపానక్రమం ఇంజిన్ వంటి సంబంధం, వాటిని వాటి భాగాలుగా చేయడానికి మేము ఇక్కడ చూశాము.
ఆపై మీరు ఆ భాగానికి ప్రయాణించి ప్రత్యేక సోపానక్రమంలోకి వెళతారు.
మరియు ఈ సోపానక్రమంలో ఇంజిన్ రకం గురించి వాదించండి, మీరు ప్రయాణీకుల కోసం క్యారేజ్ రకాన్ని బట్టి మరొక సోపానక్రమం కావాలనుకుంటే, అది సామాను కోసం కాదా. ఇది అదుపు కోసం మరియు మొదలైనవి.
కాబట్టి, తదనుగుణంగా మీరు దీన్ని చేయాలి; ఇప్పుడు ఇది ఒక సోపానక్రమంలో ఉండాలి.
కాబట్టి, మీరు దానిపై పాలిమార్ఫిక్ కోడ్‌ను వ్రాసి, ఆపై ప్రత్యామ్నాయ సోపానక్రమంలో వేర్వేరు భాగాలను చూడండి.
మరియు మీరు రెండు స్వతంత్ర సోపానక్రమాలను సంయుక్తంగా నిర్ణయించగలిగే డబుల్ ట్రాన్స్‌మిట్‌పై నిర్ణయించే అనేక డిజైన్ టెక్నిక్‌లు ఉన్నాయి మరియు వాస్తవానికి ఈ కోర్సు యొక్క పరిధి నుండి విస్తరించే పాలిమార్ఫిక్ ఫంక్షన్‌ను పంపవచ్చు. మీరు మరింతగా మారడంతో మించి ఉంటుంది మరింత నిపుణుడు.
, మీరు అన్నీ నేర్చుకోగలరు మరియు చూడగలరు.
కాబట్టి, ఈ మాడ్యూల్‌లోని రెండు ఉపన్యాసాలను సంగ్రహించడానికి, మేము అనేక వారసత్వ భావనలను ప్రవేశపెట్టాము, మేము ప్రాథమిక అర్థాలను వివరించాము.
మీరు బహుళ వారసత్వాన్ని ఉపయోగించినప్పుడు, విభిన్న వారసత్వం ఏమిటో మీకు చూపించడానికి మాత్రమే ప్రయత్నించాను.
చివరకు, వారసత్వ ఉపయోగం మధ్య డిజైన్ ఎంపిక గురించి మీకు కొంత ఆలోచన ఇవ్వడానికి ప్రయత్నించండి, ఎందుకంటే దృశ్య నిర్మాణం మరియు నిర్మాణం యొక్క ఒక వ్యవస్థ మాత్రమే వారసత్వం మరియు నిర్మాణం యొక్క మిశ్రమాన్ని సృష్టిస్తుంది మరియు ఒక ప్రధాన పాలిమార్ఫిక్ వస్తువు యొక్క ప్రధాన సోపానక్రమంపై నిర్ణయిస్తుంది ప్రాతినిధ్యం.
వస్తువుల.
మరియు సందర్భానుసారంగా ఇతరుల సృష్టిని ఉపయోగించడం మరియు తదనుగుణంగా వారి పాలిమార్ఫిక్‌ను పంపించడం.
inhouse/NPTEL/PreFinal/c++/Telugu/06. ProgramminginCplusplus_Dynamic Memory Management (Contd.) (Lecture 18)-5kZrXXPfvns.txt
View file @ 956c0d4e
 1. మాడ్యూల్ 10 యొక్క పార్ట్ -2 కు స్వాగతం.
2. మేము C ++ లో డైనమిక్ మెమరీ మేనేజ్మెంట్ను చర్చిస్తున్నాము.
3. మేము మాలోక్ (Malloc )మరియు ఫ్రీ (Free) ని ఉపయోగించి సి లో మెమరీ నిర్వహణ డైనమిక్ మెమరీ నిర్వహణ యొక్క శీఘ్ర సమీక్షను చేశాము.
4. ఆపై మేము C ++ లో డైనమిక్ మెమరీ మ్యానేజ్మెంట్ కోసం ఆపరేటర్ల 3 జతలను పరిచయం చేశాము, ఆపరేటర్ కొత్త మరియు ఆపరేటర్ తొలగించండి.
5. ఆపరేటర్ క్రొత్త రకాన్ని తీసుకోవచ్చు మరియు ప్రారంభ విలువను కూడా తీసుకోవచ్చు మరియు ఉచిత స్టోర్‌లో డైనమిక్‌గా ఒక మెమరీని కేటాయించవచ్చు, ఇచ్చిన విలువతో ప్రారంభించండి. ఆపై సృష్టించబడిన విలువ యొక్క సూచికను తిరిగి ఇవ్వండి.
6. అటువంటి విలువల శ్రేణిని ఉచిత దుకాణానికి డైనమిక్‌గా కేటాయించాలని మీరు కోరుకుంటే, మాకు కొత్తగా ఒక ఆపరేటర్ ఉంది, దానిని మేము శ్రేణి అని పిలుస్తాము. రకం, శ్రేణి ఆపరేటర్ కొత్తది మరియు సరిపోలే శ్రేణి ఆపరేటర్ తీసివేయబడుతుంది.
7. జ్ఞాపకశక్తి మెమరీ మేనేజర్ అని అవసరం లేదని ఇచ్చిన మెమరీ చిరునామాతో ఆపరేటర్‌ను పునరుద్ధరించే అవకాశం ఉందని మేము చివరికి చూపించాము. కేటాయింపు నుండి వస్తుంది, నేను ఇప్పటికే ఒక బఫర్ కలిగి ఉంటాను స్టాక్ ప్రాంతంలోని బఫర్ ప్రాంతంలో, బఫర్ గ్లోబల్ ఏరియాలో ఉండవచ్చు, కాని నేను బఫర్ యొక్క చిరునామాను పాస్ చేసి, ఆ బఫర్ లోపల వస్తువులను సృష్టించగలను.
8. ఇప్పుడు, మేము ముందుకు వెళ్లి, అలా చేసేటప్పుడు మీరు పాటించాల్సిన కొన్ని పరిమితులను చర్చిస్తాము.
9. కాబట్టి, మనకు చాలా వేర్వేరు ఆపరేటర్లు మరియు చాలా వేర్వేరు ఆపరేటర్లు ఉన్నందున, మేము కూడా వేర్వేరు ఫంక్షన్లను కేటాయించాలి మరియు మెమరీని డైనమిక్‌గా కేటాయించాలి. కోసం; కేటాయించిన మరియు డి-కేటాయించిన ఏదైనా మెమరీని ఎల్లప్పుడూ కేటాయింపు, డి-కేటాయింపు జత ఉపయోగించాలని మేము గుర్తుంచుకోవాలి.
10. అందువల్ల, పట్టికలో నేను ఈ జతలను జాబితా చేసాను మరియు మీరు దానిని అనుసరించడానికి చాలా జాగ్రత్తగా ఉండాలి.
11. మెమోక్ స్థానం మెమోక్ స్థానానికి డైనమిక్‌గా కేటాయించినట్లయితే, అది ఉచితంగా విడుదల చేయాలి.
12. ఇది ఆపరేటర్ చేత కొత్తగా కేటాయించబడితే, అది ఆపరేటర్ డిలీట్ ద్వారా జారీ చేయబడాలి.
13. ఇది ఆపరేటర్ అర్రే ద్వారా కేటాయించబడితే, దానిని ఆపరేటర్ (అర్రే) డిలీట్ ద్వారా విడుదల చేయాలి మరియు అది సరిదిద్దబడితే కొత్త ప్లేస్‌మెంట్ జరుగుతుంది. తొలగించాల్సిన అవసరం లేదు.
14. ఇప్పుడు, ఎలాంటి ఇతర మిశ్రమాలు అస్పష్టతకు మరియు అనిశ్చిత ఫలితాలకు దారి తీస్తాయి.
15. ఉదాహరణకు, మీరు మాలోడోక్ ద్వారా మెమరీని కేటాయించి, ఆపరేటర్‌ను తొలగించడానికి దాన్ని తీసివేయడానికి ప్రయత్నిస్తే, లేదా ఆపరేటర్ కొత్తగా మెమరీని కేటాయించండి.మరియు ఉచితంగా విడుదల చేయండి లేదా మీరు ఆపరేటర్ అర్రే అర్రే ద్వారా మెమరీని కేటాయించి దాన్ని విడుదల చేయడానికి ప్రయత్నిస్తే సింపుల్ డిలీట్ మరియు కేటాయింపు) మరియు మీరు చేయగలిగే డి-కేటాయింపు యొక్క మిక్స్ కలయిక ఊహించని ఫలితాలకు దారి తీస్తుంది.
16. అందువల్ల, వాటిని జంటగా ఉపయోగించడానికి ఎల్లప్పుడూ చాలా జాగ్రత్తగా ఉండండి.
17. మరియు మీరు C ++ లో ప్రోగ్రామింగ్ చేస్తున్నప్పుడు, నా సలహా ఏమిటంటే, మీరు ఎల్లప్పుడూ క్రొత్త మరియు తీసివేసిన ఆపరేటర్లను మాత్రమే ఉపయోగించడానికి ప్రయత్నిస్తారు.
18. చాలా అసాధారణమైన సందర్భాల్లో వాటి ఉపయోగం ఖచ్చితంగా అవసరం తప్ప మాలోక్ మరియు ఫ్రీని ఉపయోగించకపోవడమే మంచిది.
19. కానీ, ఒక సాధారణ ప్రోగ్రామ్‌లో మీకు మల్లాక్ మరియు ఫ్రీ అవసరం లేదు, మీరు దీన్ని ఎల్లప్పుడూ ఆపరేటర్ (ఆపరేటర్) కొత్త లేదా ఆపరేటర్ ఆపరేటర్ అర్రే (అర్రే) కొత్త మరియు సంబంధిత డిలీట్ (డిలీట్) ఫంక్షన్‌ను ఉపయోగించవచ్చు.
20. అందువల్ల, ఎల్లప్పుడూ ఆపరేటర్లను తొలగించండి, ఎల్లప్పుడూ దీన్ని చేయడానికి ప్రయత్నించండి మరియు తొలగించబడిన ఆపరేటర్ (ఆపరేటర్) ను NULL పాయింటర్ (పాయింటర్) కు పంపించే అవకాశం కూడా ఉంది.
21. కాబట్టి, మీరు తనిఖీ చేయవలసిన అవసరం లేదు, మీరు మెమరీని విడుదల చేయడానికి ప్రయత్నిస్తుంటే, ఆ మెమరీ వాస్తవానికి ఉనికిలో ఉంది.
22. ఆ మెమరీ NULL అయితే, పాయింటర్ కూడా శూన్యంగా ఉంటే, తొలగించు ఇప్పటికీ సురక్షితంగా పనిచేస్తుంది.
23. కాబట్టి, మీరు ఈ మెమరీ నిర్వహణ కోర్సు చేసినప్పుడు, దయచేసి ఈ అంశాలను గుర్తుంచుకోండి.
24. తరువాత, సి ++ పరంగా పూర్తిగా క్రొత్తగా ఉన్న కొన్ని విషయాలను పరిశీలిస్తాము, సి లో సంబంధిత భావన ఏదీ లేదు.
25. ఆపరేటర్లను ఓవర్‌లోడ్ చేయవచ్చని మేము చూశాము మరియు కేటాయింపు ఆపరేటర్లు కొత్తవారని మరియు డి-కేటాయింపు ఆపరేటర్లు వాస్తవానికి ఆపరేటర్లేనని, ఆపరేటర్లు (ఆపరేటర్) ఇలాంటి విధులను కలిగి ఉంటారు మరియు అందువల్ల వారు కూడా ఓవర్‌లోడ్ చేయవచ్చు.
26. కాబట్టి, ఈ మొదటి ఇక్కడ నేను కొత్త ఆపరేటర్, సింపుల్ ఆపరేటర్ ఆపరేటర్ యొక్క ఉదాహరణను ఓవర్లోడ్ చేస్తున్నాను.
27. కాబట్టి, మీరు ఆపరేటర్ క్రొత్త నిర్వచనాన్ని పరిశీలిస్తే, పరామితిని తీసుకునే పరామితి సైజు_టి పరామితి అని మీరు చూస్తారు.
28. ఇప్పుడు, ఇది నిజంగా ఆశించేది మరియు దాని గురించి ఆలోచిస్తుంది.
29. కాబట్టి, ఈ కాల్ వాస్తవానికి ఈ ఫంక్షన్‌ను అమలు చేస్తుంది.
30. కాబట్టి, మీరు కాల్‌ని చూస్తే, కాల్‌కు పరామితి లేదు - కాల్‌కు కొత్త పూర్ణాంకం (పూర్ణాంకానికి) ఉంది.
31. కాబట్టి, కొత్త రకం పూర్ణాంకానికి ఆపరేటర్‌ను వర్తింపజేయమని కాల్ చెబుతుంటే, అసలు ఆపరేటర్ ఫంక్షన్ ఒక సైజు_టిని ఆశిస్తుంది, సైజు_టి సంతకం చేయని పూర్ణాంకం తప్ప మరొకటి కాదు.
32. కాబట్టి, int C అనేది ప్రామాణిక లైబ్రరీ size_t typedef, ఇది సంతకం చేయని పూర్ణాంకంతో మారుపేరు.
33. అందువల్ల, దాని పరిమాణం అండర్ స్కోర్ t (size_t) అని వ్రాసినప్పుడల్లా, మీరు సంతకం చేయని పూర్ణాంకం అంటే మరియు అది ఏదో యొక్క పరిమాణం అని మీరు తెలుసుకుంటారు, చాలా తరచుగా ఇది కొన్ని నిర్మాణం యొక్క బైట్ల సంఖ్య మరియు ఇలా ఉంటుంది.
34. అందువల్ల, ఆపరేటర్ ఫంక్షన్ కోసం n పరామితి (పరామితి) తప్పనిసరిగా int (sizeof (int)) యొక్క పరిమాణం అని size_t తప్పనిసరిగా ఆశిస్తుంది.
35. ఇప్పుడు, మీరు ఆ పరిమాణాన్ని పేర్కొనలేదు.
36. కాబట్టి, ట్రిక్ కంపైలర్ చేత చేయబడుతుంది.
37. మీకు పూర్ణాంకం (పూర్ణాంకానికి) కావాలని తెలుసుకున్న కంపైలర్ వాస్తవానికి మార్చబడుతుంది; మేము ఆ పూర్ణాంక పరిమాణాన్ని లెక్కించి దానిని పారామితి n గా పాస్ చేస్తాము.
38. అందువల్ల, మీరు ఆపరేటర్‌ను ఓవర్‌లోడ్ చేసినప్పుడు, అది సైజు_టి n మొదటి పరామితి అయి ఉండాలి, అది ఆపరేటర్ కొత్తగా పనిచేయదని పేర్కొనాలి.
39. ఆపై మేము ఏమి చేసాము, మేము ఈ ఆపరేటర్ కోసం క్రొత్త ఎంటిటీని అందించాము, ఓవర్లోడ్ ఆపరేటర్ యొక్క ఈ ప్రత్యేకమైన సంస్కరణ ఉపయోగించబడుతుందని నిర్ధారించుకోవడానికి ఇక్కడ నేను ఒక సందేశాన్ని ఇచ్చాను గోయింగ్, అప్పుడు నేను స్థానిక పాయింటర్ వేరియబుల్‌ను సున్నాకి తరలిస్తాను, అప్పుడు అంతర్గతంగా నేను నిజంగా మాలోక్ చేస్తున్నాను.
40. కాబట్టి, ఈ ఆపరేటర్ క్రొత్తది అని అనిపిస్తుంది, కాని అంతర్గతంగా నేను ఒక పూర్ణాంకానికి (పూర్ణాంకానికి) పరిమాణంలో ముడి మొత్తాన్ని కేటాయించటానికి ఒక మాలోక్‌ను ఉపయోగిస్తున్నాను, ఇది ఇప్పుడు n, ఆపై మనం ఆ పాయింటర్‌ను తిరిగి ఇవ్వాలి ఎందుకంటే పాయింటర్ తిరిగి ఇవ్వాలి.
41. క్రొత్త ఆపరేటర్ వాస్తవానికి మీకు అవసరమైన రకం యొక్క సూచికను తిరిగి ఇస్తారని నేను ఇప్పటికే వివరించాను, అది మీకు పూర్ణాంక (పూర్ణాంక) నక్షత్రాన్ని తిరిగి ఇస్తుంది.
42. ఈ సందర్భంలో, దీన్ని చేయడానికి కాస్టింగ్ అవసరం లేదు, ఇది మళ్ళీ కంపైలర్ చేసే ఒక ఉపాయం.
43. కాబట్టి, కాల్ సమయంలో కంపైలర్ రకం నుండి, పరిమాణాన్ని లెక్కించి తగిన విధంగా పాస్ చేయండి. తిరిగి వచ్చే సమయంలో కంపైలర్ తగిన రకమైన పాయింటర్‌ను మారుస్తుంది మరియు అవసరమైన పూర్ణాంకానికి (పాయింటర్) రకాన్ని పాయింటర్ (పాయింటర్) తిరిగి ఇస్తుంది, కానీ (ఆపరేటర్) క్రొత్త ఫంక్షన్‌ను వ్రాయడం ద్వారా మరియు మీరు ఓవర్‌లోడ్ చేయగలిగే వాటికి నిర్వచనం రాయడం ద్వారా.
44. కాబట్టి, క్రొత్త ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయవచ్చని మీరు చూడవచ్చు, మొదటి పరామితి (పరామితి) పరిమాణం_టి అయి ఉండాలి, దీనిలో కంపైలర్ రకం పరిమాణాన్ని చొప్పిస్తుంది.
45. మీరు రిటర్న్ రకాన్ని శూన్యంగా మార్చలేరు * కాబట్టి ఇది ఆపరేటర్‌గా ప్రవర్తించదు, కానీ మీరు దీనికి ఎక్కువ పారామితులను జోడించవచ్చు.
46. ఇక్కడ, మేము పరామితిని జోడించలేదు, ఇక్కడ మేము ఈ ప్రత్యేకమైన ఓవర్లోడ్ ఆపరేటర్ ఫంక్షన్ పనిచేసేటప్పుడు ఒక కేటాయింపు చేయడం మరియు సందేశాన్ని అందించడం ద్వారా వేరే ప్రవర్తనను చూపించాము, కానీ మీరు ఎక్కువ పారామితిని (పరామితి) పొందవచ్చు మరియు ఆ పారామితులను క్రొత్త సైట్‌కు పంపవచ్చు .
47. అదేవిధంగా, ఆపరేటర్ తొలగింపును మనం ఇక్కడ మళ్ళీ చేసినట్లుగా ఓవర్‌లోడ్ చేయవచ్చు, మొదట మనం విడుదల చేయవలసిన పాయింటర్ అయిన పరామితిని రద్దు చేయాలి. అవసరం మరియు రకం తిరిగి రావడం శూన్యంగా ఉండాలి ఎందుకంటే; సహజంగానే, తొలగించు ఏ గణనలను తిరిగి తీసుకురాలేదు, కాని డిఫాల్ట్ ఆపరేటర్ చేత వేరే అమలును తొలగించగలము.
48. కాబట్టి, మీరు ఈ ప్రోగ్రామ్‌ను నడుపుతుంటే, అది కేటాయించిన సమయంలో క్రొత్తదాన్ని ఓవర్‌లోడ్ చేసినట్లు మీరు కనుగొంటారు, అనగా ఇది ప్రత్యేకంగా కౌట్.
49. అప్పుడు ఇది 30 నుండి ఈ పాయింట్ నుండి విలువను ప్రింట్ చేస్తుంది మరియు చివరకు, ఓవర్లోడ్ (ఓవర్లోడ్) తొలగించిన ఆపరేటర్ నుండి వచ్చే అవుట్పుట్ ఓవర్లోడ్ (ఓవర్లోడ్) తొలగించిన సందేశాన్ని ప్రింట్ చేస్తుంది.
50. అందువల్ల, క్రొత్త మరియు తొలగింపు రెండూ ఓవర్‌లోడ్ అవుతున్నాయని మరియు మీ ప్రవర్తనను కొనసాగించవచ్చని ఇది మీకు స్పష్టంగా చూపిస్తుంది.
51. మీరు ఓవర్‌లోడ్‌ను తీసివేసినప్పుడు, సాధారణంగా అదనపు పారామితులతో ఓవర్‌లోడ్ చేయకుండా ప్రయత్నించండి. C ++ లో ఇది తప్పు అని నేను చెప్పలేను, కాని స్థిర సూచన ఉంది, దీనిలో మీరు తొలగించిన ఆపరేటర్‌ను మాత్రమే ఉపయోగించగలరు సున్నా శూన్యత * p కంటే ఎక్కువ పారామితులతో ఓవర్‌లోడ్ చేయబడింది, మరియు మేము ఆ సూచనలను అర్థం చేసుకునే వరకు మీకు అప్పటి వరకు ఉండదు, మీరు అదనపు పారామితులతో తొలగింపును ఓవర్‌లోడ్ చేసినప్పటికీ, మీరు ఉపయోగించలేరు వాటిని, ప్రతిదీ సంకలన లోపంగా చూపబడుతుంది.
52. కాబట్టి, ఇక్కడ మరొక ఉదాహరణ ఆపరేటర్ అర్రే కొత్త (ఆపరేటర్ [] క్రొత్తది) చూపిస్తాము.
53. కాబట్టి, ఇది కూడా ఓవర్‌లోడ్.
54. ఇప్పుడు, నేను ఆపరేటర్ కొత్త శ్రేణిని ఓవర్‌లోడ్ చేయడానికి ప్రయత్నిస్తున్నాను.
55. కాబట్టి, ఈ ఆపరేటర్ 10 మూలకాల అక్షరాల శ్రేణిని కేటాయించడానికి ఉపయోగించబడుతుంది.
56. అందువల్ల, సహజంగానే మొదటి పరామితి ఇప్పటికీ సైజు_టిగా మిగిలిపోయింది, ఇది కేటాయించాల్సిన మొత్తం బైట్ల సంఖ్య, అందువల్ల ఇక్కడ మూలకాల సంఖ్యతో కూడా లెక్కించవచ్చు.
57. కాబట్టి, sizeof char [10], ఇది size_t os పారామితి (పారామితి) గా వెళుతుంది మరియు ఇది కంపైలర్ చేత చేయబడుతుంది.
58. గమనించదగ్గ విషయం ఏమిటంటే, ఇప్పుడు మీరు రెండవ పరామితిని చూడవచ్చు, ఆపరేటర్ అర్రే (అర్రే) క్రొత్త వాటిలో రెండవ పరామితి కాదు, కానీ ఇప్పుడు మనం దానిని మరొక పరామితితో ఓవర్లోడ్ చేసాము.మరియు రెండవ పారామితి ఉన్న వాక్యనిర్మాణాన్ని చూడండి ఉపయోగించవలసిన.
59. కాబట్టి, ఇది ఇక్కడ అధికారిక పరామితి మరియు అసలు పరామితి క్రొత్త కీవర్డ్ తర్వాత మరియు మేము డైనమిక్‌గా కేటాయించదలిచిన రకానికి ముందు ఒక జత బ్రాకెట్లలో పేర్కొనబడింది. హుహ్.
60. కాబట్టి, దీని అర్థం # అక్షర చిహ్నం # setv యొక్క విలువగా పాస్ చేయబడుతుంది మరియు మీరు ఈ కోడ్‌ను పరిశీలిస్తే మేము గందరగోళాన్ని చేస్తున్నట్లు మీకు తెలుస్తుంది.
61. మొదటి పంక్తిని చూద్దాం, ఇక్కడ మనం ఆపరేటర్ యొక్క క్రొత్త ఫంక్షన్‌ను ఉపయోగిస్తున్నాము, వీటిని మనం మాలోక్ కూడా ఉపయోగించవచ్చు, కాని మేము ఆపరేటర్ యొక్క క్రొత్త ఫంక్షన్‌ను ఉపయోగిస్తున్నాము, తద్వారా అవసరమైన OS మొత్తాన్ని కేటాయించవచ్చు మరియు మనకు లభిస్తుంది అది శూన్యమైన పాయింటర్‌గా ఆపై ఆ పాయింటర్‌ను ఉపయోగించి ఈ సెట్ పరామితిని ఉపయోగిస్తాము, మేము నిజంగా ఆ బఫర్‌ను setv విలువతో నింపుతాము.
62. కాబట్టి, మేము T తో ప్రారంభిస్తాము, ఒక అక్షరాన్ని తీసుకొని OS ల సంఖ్యను చాలాసార్లు చూస్తాము ఎందుకంటే OS సంఖ్య బైట్లు ఉన్నాయని మాకు తెలుసు.
63. ఇవి సి లో ఉన్న ప్రాథమిక మెమ్ ఫంక్షన్లు, మీకు ఈ ఫంక్షన్ గురించి తెలియకపోతే మీ సి ప్రోగ్రామింగ్‌లో విడిగా పరిశీలించమని నేను మీకు సలహా ఇస్తాను.
64. మీరు దీన్ని ప్రయత్నించవచ్చు, కానీ ఇది ప్రాథమికంగా సూచికను తీసుకుంటుంది.
65. కాబట్టి, ఇది అలా ఉంది, ఈ బఫర్‌కు T అనేది పాయింటర్, ఇది డైనమిక్‌గా కేటాయించబడుతుంది.
66. ఇది OS యొక్క స్థానాల సంఖ్యను కలిగి ఉంది మరియు వెళ్లి ఈ సెట్‌ను ఈ స్థితిలో ఉంచుతుంది, వీటిలో ప్రతి ఒక్కటి # అక్షరాలను కలిగి ఉంటుంది.
67. అందువల్ల, ఇతర ఆపరేటర్‌తో తేడాలు, శ్రేణి క్రొత్తది మరియు ఓవర్‌లోడ్ చేయబడిన శ్రేణి క్రొత్తది.ఇప్పుడు ఇది అక్షర శ్రేణిని కేటాయించగలదు, కానీ ఇది ప్రారంభ సమయంలో ఇచ్చిన అక్షరాన్ని కూడా కేటాయిస్తుంది.
68. కాబట్టి, ఇది వేరే విధంగా ప్రారంభిస్తుంది.
69. కాబట్టి, ఈ విధంగా మీకు అవసరమైన ఇతర ఓవర్‌లోడింగ్ గురించి మీరు ఆలోచించవచ్చు మరియు తదనుగుణంగా మీరు మరింత ఎక్కువ పారామితులు మరియు ప్రవర్తనలు మరియు ఆ పారామితులను కలిగి ఉండవచ్చు, మీకు అవసరమైన అదనపు పారామితులు మీరు చూపించే కామాతో వేరు చేయబడిన జాబితాగా పాయింట్ గుండా ఇక్కడ ఉండాలి.
70. అదేవిధంగా, ఇక్కడ శ్రేణి తొలగింపు కూడా ఓవర్‌లోడ్ చేయబడింది, అయినప్పటికీ మేము దీనికి కొత్త కార్యాచరణను జోడించలేదు.
71. ఈ ఓవర్‌లోడ్ అర్రే డిలీట్‌లో డిలీట్ ఆపరేటర్ ఫంక్షన్‌ను మేము ఇప్పుడే పిలిచాము.
72. అందువల్ల, ఈ సందర్భంలో ఆపరేటర్‌ను కొత్తగా ఎలా ఓవర్‌లోడ్ చేయాలో మేము చూపించాము మరియు కొత్త ఆపరేటర్ ఆపరేటర్ అర్రే వంటి ఐటెమ్ ఆపరేటర్ ఆపరేటర్‌ను తిరిగి కేటాయించడం. మొదటి పరామితి size_t అయి ఉండాలి.
73. ఇది ఎల్లప్పుడూ రిటర్న్ రకంగా ఉంటుంది, ఇది శూన్యమైనది మరియు ఆపరేటర్‌ను మళ్ళీ తొలగించడం వంటి ఆపరేటర్ పరామితిని తొలగించడానికి బహుళ పారామితులను ఉపయోగించవచ్చు, ఓవర్‌లోడ్ సాధారణంగా అదనపు పారామితి కానట్లయితే, ఆ అదనపు పారామితులను ఎలా ఉపయోగించాలో అర్థం చేసుకోకపోతే .
74. సారాంశంలో, సి ++ లో డైనమిక్ మెమరీ నిర్వహణ కోసం కొత్త మరియు తొలగించే ఆపరేటర్లను పరిచయం చేసాము, ఇక్కడ సికి విరుద్ధంగా మాలోక్, ఉచిత మరియు ఇతర విధులు వాస్తవానికి ప్రామాణిక గ్రంథాలయాలు. భాషా లక్షణాలు కాదు, లక్షణాలు ఉన్నాయి, ఇక్కడ అవి భాషా లక్షణాలు.
75. వేర్వేరు కొత్త ఆపరేటర్లు మరియు వాటి సంబంధిత డిలీట్ ఆపరేటర్ల మధ్య తేడాలు మరియు వారు నేర్చుకున్న ప్రాథమిక సూత్రం, మనం కేటాయించినా లేదా ఫంక్షన్ చేసినా, కేటాయించిన వాటిని మేము జాగ్రత్తగా అర్థం చేసుకున్నాము. మేము దానిని ఉపయోగిస్తాము సంబంధిత డి-కేటాయింపు ఫంక్షన్ లేదా ఆపరేటర్ - మల్లాక్ ఉచితంగా, ఆపరేటర్ తొలగింపుతో ఆపరేటర్ కొత్తది, ఆపరేటర్ అర్రే, ఆపరేటర్ అర్రేతో) తొలగింపు, ఆపరేటర్ (లు) కొత్తవి మరియు నేను ప్లేస్‌మెంట్‌ను పునరుద్ధరించినట్లయితే, మీకు ఎటువంటి తొలగింపు ఉండకూడదు మరియు లేకపోతే మాకు పూర్తిగా unexpected హించని సమస్యలు వచ్చే అవకాశం ఉంది.
76. చివరకు ఈ కొత్త ఆపరేటర్లను ఓవర్‌లోడ్ చేయడం మరియు ఆపరేటర్లను ఎలా తొలగించాలో కూడా చూశాము, ఇది ఇప్పుడు ఆపరేటర్‌గా ఉండటం వల్ల ప్రయోజనం.
77. మరియు ఈ ఆపరేటర్లను ఓవర్‌లోడ్ చేయడం ద్వారా వినియోగదారు కోరుకున్న విధంగా విభిన్న కార్యాచరణను ఎలా నిర్వహించవచ్చో మేము చూపించాము.
78.
 మాడ్యూల్ 10 యొక్క పార్ట్ -2 కు స్వాగతం.
మేము C ++ లో డైనమిక్ మెమరీ మేనేజ్మెంట్ను చర్చిస్తున్నాము.
మేము మాలోక్ (Malloc )మరియు ఫ్రీ (Free) ని ఉపయోగించి సి లో మెమరీ నిర్వహణ డైనమిక్ మెమరీ నిర్వహణ యొక్క శీఘ్ర సమీక్షను చేశాము.
ఆపై మేము C ++ లో డైనమిక్ మెమరీ మ్యానేజ్మెంట్ కోసం ఆపరేటర్ల 3 జతలను పరిచయం చేశాము, ఆపరేటర్ కొత్త మరియు ఆపరేటర్ తొలగించండి.
ఆపరేటర్ క్రొత్త రకాన్ని తీసుకోవచ్చు మరియు ప్రారంభ విలువను కూడా తీసుకోవచ్చు మరియు ఉచిత స్టోర్‌లో డైనమిక్‌గా ఒక మెమరీని కేటాయించవచ్చు, ఇచ్చిన విలువతో ప్రారంభించండి. ఆపై సృష్టించబడిన విలువ యొక్క సూచికను తిరిగి ఇవ్వండి.
అటువంటి విలువల శ్రేణిని ఉచిత దుకాణానికి డైనమిక్‌గా కేటాయించాలని మీరు కోరుకుంటే, మాకు కొత్తగా ఒక ఆపరేటర్ ఉంది, దానిని మేము శ్రేణి అని పిలుస్తాము. రకం, శ్రేణి ఆపరేటర్ కొత్తది మరియు సరిపోలే శ్రేణి ఆపరేటర్ తీసివేయబడుతుంది.
జ్ఞాపకశక్తి మెమరీ మేనేజర్ అని అవసరం లేదని ఇచ్చిన మెమరీ చిరునామాతో ఆపరేటర్‌ను పునరుద్ధరించే అవకాశం ఉందని మేము చివరికి చూపించాము. కేటాయింపు నుండి వస్తుంది, నేను ఇప్పటికే ఒక బఫర్ కలిగి ఉంటాను స్టాక్ ప్రాంతంలోని బఫర్ ప్రాంతంలో, బఫర్ గ్లోబల్ ఏరియాలో ఉండవచ్చు, కాని నేను బఫర్ యొక్క చిరునామాను పాస్ చేసి, ఆ బఫర్ లోపల వస్తువులను సృష్టించగలను.
ఇప్పుడు, మేము ముందుకు వెళ్లి, అలా చేసేటప్పుడు మీరు పాటించాల్సిన కొన్ని పరిమితులను చర్చిస్తాము.
కాబట్టి, మనకు చాలా వేర్వేరు ఆపరేటర్లు మరియు చాలా వేర్వేరు ఆపరేటర్లు ఉన్నందున, మేము కూడా వేర్వేరు ఫంక్షన్లను కేటాయించాలి మరియు మెమరీని డైనమిక్‌గా కేటాయించాలి. కోసం; కేటాయించిన మరియు డి-కేటాయించిన ఏదైనా మెమరీని ఎల్లప్పుడూ కేటాయింపు, డి-కేటాయింపు జత ఉపయోగించాలని మేము గుర్తుంచుకోవాలి.
అందువల్ల, పట్టికలో నేను ఈ జతలను జాబితా చేసాను మరియు మీరు దానిని అనుసరించడానికి చాలా జాగ్రత్తగా ఉండాలి.
మెమోక్ స్థానం మెమోక్ స్థానానికి డైనమిక్‌గా కేటాయించినట్లయితే, అది ఉచితంగా విడుదల చేయాలి.
ఇది ఆపరేటర్ చేత కొత్తగా కేటాయించబడితే, అది ఆపరేటర్ డిలీట్ ద్వారా జారీ చేయబడాలి.
ఇది ఆపరేటర్ అర్రే ద్వారా కేటాయించబడితే, దానిని ఆపరేటర్ (అర్రే) డిలీట్ ద్వారా విడుదల చేయాలి మరియు అది సరిదిద్దబడితే కొత్త ప్లేస్‌మెంట్ జరుగుతుంది. తొలగించాల్సిన అవసరం లేదు.
ఇప్పుడు, ఎలాంటి ఇతర మిశ్రమాలు అస్పష్టతకు మరియు అనిశ్చిత ఫలితాలకు దారి తీస్తాయి.
ఉదాహరణకు, మీరు మాలోడోక్ ద్వారా మెమరీని కేటాయించి, ఆపరేటర్‌ను తొలగించడానికి దాన్ని తీసివేయడానికి ప్రయత్నిస్తే, లేదా ఆపరేటర్ కొత్తగా మెమరీని కేటాయించండి.మరియు ఉచితంగా విడుదల చేయండి లేదా మీరు ఆపరేటర్ అర్రే అర్రే ద్వారా మెమరీని కేటాయించి దాన్ని విడుదల చేయడానికి ప్రయత్నిస్తే సింపుల్ డిలీట్ మరియు కేటాయింపు) మరియు మీరు చేయగలిగే డి-కేటాయింపు యొక్క మిక్స్ కలయిక ఊహించని ఫలితాలకు దారి తీస్తుంది.
అందువల్ల, వాటిని జంటగా ఉపయోగించడానికి ఎల్లప్పుడూ చాలా జాగ్రత్తగా ఉండండి.
మరియు మీరు C ++ లో ప్రోగ్రామింగ్ చేస్తున్నప్పుడు, నా సలహా ఏమిటంటే, మీరు ఎల్లప్పుడూ క్రొత్త మరియు తీసివేసిన ఆపరేటర్లను మాత్రమే ఉపయోగించడానికి ప్రయత్నిస్తారు.
చాలా అసాధారణమైన సందర్భాల్లో వాటి ఉపయోగం ఖచ్చితంగా అవసరం తప్ప మాలోక్ మరియు ఫ్రీని ఉపయోగించకపోవడమే మంచిది.
కానీ, ఒక సాధారణ ప్రోగ్రామ్‌లో మీకు మల్లాక్ మరియు ఫ్రీ అవసరం లేదు, మీరు దీన్ని ఎల్లప్పుడూ ఆపరేటర్ (ఆపరేటర్) కొత్త లేదా ఆపరేటర్ ఆపరేటర్ అర్రే (అర్రే) కొత్త మరియు సంబంధిత డిలీట్ (డిలీట్) ఫంక్షన్‌ను ఉపయోగించవచ్చు.
అందువల్ల, ఎల్లప్పుడూ ఆపరేటర్లను తొలగించండి, ఎల్లప్పుడూ దీన్ని చేయడానికి ప్రయత్నించండి మరియు తొలగించబడిన ఆపరేటర్ (ఆపరేటర్) ను NULL పాయింటర్ (పాయింటర్) కు పంపించే అవకాశం కూడా ఉంది.
కాబట్టి, మీరు తనిఖీ చేయవలసిన అవసరం లేదు, మీరు మెమరీని విడుదల చేయడానికి ప్రయత్నిస్తుంటే, ఆ మెమరీ వాస్తవానికి ఉనికిలో ఉంది.
ఆ మెమరీ NULL అయితే, పాయింటర్ కూడా శూన్యంగా ఉంటే, తొలగించు ఇప్పటికీ సురక్షితంగా పనిచేస్తుంది.
కాబట్టి, మీరు ఈ మెమరీ నిర్వహణ కోర్సు చేసినప్పుడు, దయచేసి ఈ అంశాలను గుర్తుంచుకోండి.
తరువాత, సి ++ పరంగా పూర్తిగా క్రొత్తగా ఉన్న కొన్ని విషయాలను పరిశీలిస్తాము, సి లో సంబంధిత భావన ఏదీ లేదు.
ఆపరేటర్లను ఓవర్‌లోడ్ చేయవచ్చని మేము చూశాము మరియు కేటాయింపు ఆపరేటర్లు కొత్తవారని మరియు డి-కేటాయింపు ఆపరేటర్లు వాస్తవానికి ఆపరేటర్లేనని, ఆపరేటర్లు (ఆపరేటర్) ఇలాంటి విధులను కలిగి ఉంటారు మరియు అందువల్ల వారు కూడా ఓవర్‌లోడ్ చేయవచ్చు.
కాబట్టి, ఈ మొదటి ఇక్కడ నేను కొత్త ఆపరేటర్, సింపుల్ ఆపరేటర్ ఆపరేటర్ యొక్క ఉదాహరణను ఓవర్లోడ్ చేస్తున్నాను.
కాబట్టి, మీరు ఆపరేటర్ క్రొత్త నిర్వచనాన్ని పరిశీలిస్తే, పరామితిని తీసుకునే పరామితి సైజు_టి పరామితి అని మీరు చూస్తారు.
ఇప్పుడు, ఇది నిజంగా ఆశించేది మరియు దాని గురించి ఆలోచిస్తుంది.
కాబట్టి, ఈ కాల్ వాస్తవానికి ఈ ఫంక్షన్‌ను అమలు చేస్తుంది.
కాబట్టి, మీరు కాల్‌ని చూస్తే, కాల్‌కు పరామితి లేదు - కాల్‌కు కొత్త పూర్ణాంకం (పూర్ణాంకానికి) ఉంది.
కాబట్టి, కొత్త రకం పూర్ణాంకానికి ఆపరేటర్‌ను వర్తింపజేయమని కాల్ చెబుతుంటే, అసలు ఆపరేటర్ ఫంక్షన్ ఒక సైజు_టిని ఆశిస్తుంది, సైజు_టి సంతకం చేయని పూర్ణాంకం తప్ప మరొకటి కాదు.
కాబట్టి, int C అనేది ప్రామాణిక లైబ్రరీ size_t typedef, ఇది సంతకం చేయని పూర్ణాంకంతో మారుపేరు.
అందువల్ల, దాని పరిమాణం అండర్ స్కోర్ t (size_t) అని వ్రాసినప్పుడల్లా, మీరు సంతకం చేయని పూర్ణాంకం అంటే మరియు అది ఏదో యొక్క పరిమాణం అని మీరు తెలుసుకుంటారు, చాలా తరచుగా ఇది కొన్ని నిర్మాణం యొక్క బైట్ల సంఖ్య మరియు ఇలా ఉంటుంది.
అందువల్ల, ఆపరేటర్ ఫంక్షన్ కోసం n పరామితి (పరామితి) తప్పనిసరిగా int (sizeof (int)) యొక్క పరిమాణం అని size_t తప్పనిసరిగా ఆశిస్తుంది.
ఇప్పుడు, మీరు ఆ పరిమాణాన్ని పేర్కొనలేదు.
కాబట్టి, ట్రిక్ కంపైలర్ చేత చేయబడుతుంది.
మీకు పూర్ణాంకం (పూర్ణాంకానికి) కావాలని తెలుసుకున్న కంపైలర్ వాస్తవానికి మార్చబడుతుంది; మేము ఆ పూర్ణాంక పరిమాణాన్ని లెక్కించి దానిని పారామితి n గా పాస్ చేస్తాము.
అందువల్ల, మీరు ఆపరేటర్‌ను ఓవర్‌లోడ్ చేసినప్పుడు, అది సైజు_టి n మొదటి పరామితి అయి ఉండాలి, అది ఆపరేటర్ కొత్తగా పనిచేయదని పేర్కొనాలి.
ఆపై మేము ఏమి చేసాము, మేము ఈ ఆపరేటర్ కోసం క్రొత్త ఎంటిటీని అందించాము, ఓవర్లోడ్ ఆపరేటర్ యొక్క ఈ ప్రత్యేకమైన సంస్కరణ ఉపయోగించబడుతుందని నిర్ధారించుకోవడానికి ఇక్కడ నేను ఒక సందేశాన్ని ఇచ్చాను గోయింగ్, అప్పుడు నేను స్థానిక పాయింటర్ వేరియబుల్‌ను సున్నాకి తరలిస్తాను, అప్పుడు అంతర్గతంగా నేను నిజంగా మాలోక్ చేస్తున్నాను.
కాబట్టి, ఈ ఆపరేటర్ క్రొత్తది అని అనిపిస్తుంది, కాని అంతర్గతంగా నేను ఒక పూర్ణాంకానికి (పూర్ణాంకానికి) పరిమాణంలో ముడి మొత్తాన్ని కేటాయించటానికి ఒక మాలోక్‌ను ఉపయోగిస్తున్నాను, ఇది ఇప్పుడు n, ఆపై మనం ఆ పాయింటర్‌ను తిరిగి ఇవ్వాలి ఎందుకంటే పాయింటర్ తిరిగి ఇవ్వాలి.
క్రొత్త ఆపరేటర్ వాస్తవానికి మీకు అవసరమైన రకం యొక్క సూచికను తిరిగి ఇస్తారని నేను ఇప్పటికే వివరించాను, అది మీకు పూర్ణాంక (పూర్ణాంక) నక్షత్రాన్ని తిరిగి ఇస్తుంది.
ఈ సందర్భంలో, దీన్ని చేయడానికి కాస్టింగ్ అవసరం లేదు, ఇది మళ్ళీ కంపైలర్ చేసే ఒక ఉపాయం.
కాబట్టి, కాల్ సమయంలో కంపైలర్ రకం నుండి, పరిమాణాన్ని లెక్కించి తగిన విధంగా పాస్ చేయండి. తిరిగి వచ్చే సమయంలో కంపైలర్ తగిన రకమైన పాయింటర్‌ను మారుస్తుంది మరియు అవసరమైన పూర్ణాంకానికి (పాయింటర్) రకాన్ని పాయింటర్ (పాయింటర్) తిరిగి ఇస్తుంది, కానీ (ఆపరేటర్) క్రొత్త ఫంక్షన్‌ను వ్రాయడం ద్వారా మరియు మీరు ఓవర్‌లోడ్ చేయగలిగే వాటికి నిర్వచనం రాయడం ద్వారా.
కాబట్టి, క్రొత్త ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయవచ్చని మీరు చూడవచ్చు, మొదటి పరామితి (పరామితి) పరిమాణం_టి అయి ఉండాలి, దీనిలో కంపైలర్ రకం పరిమాణాన్ని చొప్పిస్తుంది.
మీరు రిటర్న్ రకాన్ని శూన్యంగా మార్చలేరు * కాబట్టి ఇది ఆపరేటర్‌గా ప్రవర్తించదు, కానీ మీరు దీనికి ఎక్కువ పారామితులను జోడించవచ్చు.
ఇక్కడ, మేము పరామితిని జోడించలేదు, ఇక్కడ మేము ఈ ప్రత్యేకమైన ఓవర్లోడ్ ఆపరేటర్ ఫంక్షన్ పనిచేసేటప్పుడు ఒక కేటాయింపు చేయడం మరియు సందేశాన్ని అందించడం ద్వారా వేరే ప్రవర్తనను చూపించాము, కానీ మీరు ఎక్కువ పారామితిని (పరామితి) పొందవచ్చు మరియు ఆ పారామితులను క్రొత్త సైట్‌కు పంపవచ్చు .
అదేవిధంగా, ఆపరేటర్ తొలగింపును మనం ఇక్కడ మళ్ళీ చేసినట్లుగా ఓవర్‌లోడ్ చేయవచ్చు, మొదట మనం విడుదల చేయవలసిన పాయింటర్ అయిన పరామితిని రద్దు చేయాలి. అవసరం మరియు రకం తిరిగి రావడం శూన్యంగా ఉండాలి ఎందుకంటే; సహజంగానే, తొలగించు ఏ గణనలను తిరిగి తీసుకురాలేదు, కాని డిఫాల్ట్ ఆపరేటర్ చేత వేరే అమలును తొలగించగలము.
కాబట్టి, మీరు ఈ ప్రోగ్రామ్‌ను నడుపుతుంటే, అది కేటాయించిన సమయంలో క్రొత్తదాన్ని ఓవర్‌లోడ్ చేసినట్లు మీరు కనుగొంటారు, అనగా ఇది ప్రత్యేకంగా కౌట్.
అప్పుడు ఇది 30 నుండి ఈ పాయింట్ నుండి విలువను ప్రింట్ చేస్తుంది మరియు చివరకు, ఓవర్లోడ్ (ఓవర్లోడ్) తొలగించిన ఆపరేటర్ నుండి వచ్చే అవుట్పుట్ ఓవర్లోడ్ (ఓవర్లోడ్) తొలగించిన సందేశాన్ని ప్రింట్ చేస్తుంది.
అందువల్ల, క్రొత్త మరియు తొలగింపు రెండూ ఓవర్‌లోడ్ అవుతున్నాయని మరియు మీ ప్రవర్తనను కొనసాగించవచ్చని ఇది మీకు స్పష్టంగా చూపిస్తుంది.
మీరు ఓవర్‌లోడ్‌ను తీసివేసినప్పుడు, సాధారణంగా అదనపు పారామితులతో ఓవర్‌లోడ్ చేయకుండా ప్రయత్నించండి. C ++ లో ఇది తప్పు అని నేను చెప్పలేను, కాని స్థిర సూచన ఉంది, దీనిలో మీరు తొలగించిన ఆపరేటర్‌ను మాత్రమే ఉపయోగించగలరు సున్నా శూన్యత * p కంటే ఎక్కువ పారామితులతో ఓవర్‌లోడ్ చేయబడింది, మరియు మేము ఆ సూచనలను అర్థం చేసుకునే వరకు మీకు అప్పటి వరకు ఉండదు, మీరు అదనపు పారామితులతో తొలగింపును ఓవర్‌లోడ్ చేసినప్పటికీ, మీరు ఉపయోగించలేరు వాటిని, ప్రతిదీ సంకలన లోపంగా చూపబడుతుంది.
కాబట్టి, ఇక్కడ మరొక ఉదాహరణ ఆపరేటర్ అర్రే కొత్త (ఆపరేటర్ [] క్రొత్తది) చూపిస్తాము.
కాబట్టి, ఇది కూడా ఓవర్‌లోడ్.
ఇప్పుడు, నేను ఆపరేటర్ కొత్త శ్రేణిని ఓవర్‌లోడ్ చేయడానికి ప్రయత్నిస్తున్నాను.
కాబట్టి, ఈ ఆపరేటర్ 10 మూలకాల అక్షరాల శ్రేణిని కేటాయించడానికి ఉపయోగించబడుతుంది.
అందువల్ల, సహజంగానే మొదటి పరామితి ఇప్పటికీ సైజు_టిగా మిగిలిపోయింది, ఇది కేటాయించాల్సిన మొత్తం బైట్ల సంఖ్య, అందువల్ల ఇక్కడ మూలకాల సంఖ్యతో కూడా లెక్కించవచ్చు.
కాబట్టి, sizeof char [10], ఇది size_t os పారామితి (పారామితి) గా వెళుతుంది మరియు ఇది కంపైలర్ చేత చేయబడుతుంది.
గమనించదగ్గ విషయం ఏమిటంటే, ఇప్పుడు మీరు రెండవ పరామితిని చూడవచ్చు, ఆపరేటర్ అర్రే (అర్రే) క్రొత్త వాటిలో రెండవ పరామితి కాదు, కానీ ఇప్పుడు మనం దానిని మరొక పరామితితో ఓవర్లోడ్ చేసాము.మరియు రెండవ పారామితి ఉన్న వాక్యనిర్మాణాన్ని చూడండి ఉపయోగించవలసిన.
కాబట్టి, ఇది ఇక్కడ అధికారిక పరామితి మరియు అసలు పరామితి క్రొత్త కీవర్డ్ తర్వాత మరియు మేము డైనమిక్‌గా కేటాయించదలిచిన రకానికి ముందు ఒక జత బ్రాకెట్లలో పేర్కొనబడింది. హుహ్.
కాబట్టి, దీని అర్థం # అక్షర చిహ్నం # setv యొక్క విలువగా పాస్ చేయబడుతుంది మరియు మీరు ఈ కోడ్‌ను పరిశీలిస్తే మేము గందరగోళాన్ని చేస్తున్నట్లు మీకు తెలుస్తుంది.
మొదటి పంక్తిని చూద్దాం, ఇక్కడ మనం ఆపరేటర్ యొక్క క్రొత్త ఫంక్షన్‌ను ఉపయోగిస్తున్నాము, వీటిని మనం మాలోక్ కూడా ఉపయోగించవచ్చు, కాని మేము ఆపరేటర్ యొక్క క్రొత్త ఫంక్షన్‌ను ఉపయోగిస్తున్నాము, తద్వారా అవసరమైన OS మొత్తాన్ని కేటాయించవచ్చు మరియు మనకు లభిస్తుంది అది శూన్యమైన పాయింటర్‌గా ఆపై ఆ పాయింటర్‌ను ఉపయోగించి ఈ సెట్ పరామితిని ఉపయోగిస్తాము, మేము నిజంగా ఆ బఫర్‌ను setv విలువతో నింపుతాము.
కాబట్టి, మేము T తో ప్రారంభిస్తాము, ఒక అక్షరాన్ని తీసుకొని OS ల సంఖ్యను చాలాసార్లు చూస్తాము ఎందుకంటే OS సంఖ్య బైట్లు ఉన్నాయని మాకు తెలుసు.
ఇవి సి లో ఉన్న ప్రాథమిక మెమ్ ఫంక్షన్లు, మీకు ఈ ఫంక్షన్ గురించి తెలియకపోతే మీ సి ప్రోగ్రామింగ్‌లో విడిగా పరిశీలించమని నేను మీకు సలహా ఇస్తాను.
మీరు దీన్ని ప్రయత్నించవచ్చు, కానీ ఇది ప్రాథమికంగా సూచికను తీసుకుంటుంది.
కాబట్టి, ఇది అలా ఉంది, ఈ బఫర్‌కు T అనేది పాయింటర్, ఇది డైనమిక్‌గా కేటాయించబడుతుంది.
ఇది OS యొక్క స్థానాల సంఖ్యను కలిగి ఉంది మరియు వెళ్లి ఈ సెట్‌ను ఈ స్థితిలో ఉంచుతుంది, వీటిలో ప్రతి ఒక్కటి # అక్షరాలను కలిగి ఉంటుంది.
అందువల్ల, ఇతర ఆపరేటర్‌తో తేడాలు, శ్రేణి క్రొత్తది మరియు ఓవర్‌లోడ్ చేయబడిన శ్రేణి క్రొత్తది.ఇప్పుడు ఇది అక్షర శ్రేణిని కేటాయించగలదు, కానీ ఇది ప్రారంభ సమయంలో ఇచ్చిన అక్షరాన్ని కూడా కేటాయిస్తుంది.
కాబట్టి, ఇది వేరే విధంగా ప్రారంభిస్తుంది.
కాబట్టి, ఈ విధంగా మీకు అవసరమైన ఇతర ఓవర్‌లోడింగ్ గురించి మీరు ఆలోచించవచ్చు మరియు తదనుగుణంగా మీరు మరింత ఎక్కువ పారామితులు మరియు ప్రవర్తనలు మరియు ఆ పారామితులను కలిగి ఉండవచ్చు, మీకు అవసరమైన అదనపు పారామితులు మీరు చూపించే కామాతో వేరు చేయబడిన జాబితాగా పాయింట్ గుండా ఇక్కడ ఉండాలి.
అదేవిధంగా, ఇక్కడ శ్రేణి తొలగింపు కూడా ఓవర్‌లోడ్ చేయబడింది, అయినప్పటికీ మేము దీనికి కొత్త కార్యాచరణను జోడించలేదు.
ఈ ఓవర్‌లోడ్ అర్రే డిలీట్‌లో డిలీట్ ఆపరేటర్ ఫంక్షన్‌ను మేము ఇప్పుడే పిలిచాము.
అందువల్ల, ఈ సందర్భంలో ఆపరేటర్‌ను కొత్తగా ఎలా ఓవర్‌లోడ్ చేయాలో మేము చూపించాము మరియు కొత్త ఆపరేటర్ ఆపరేటర్ అర్రే వంటి ఐటెమ్ ఆపరేటర్ ఆపరేటర్‌ను తిరిగి కేటాయించడం. మొదటి పరామితి size_t అయి ఉండాలి.
ఇది ఎల్లప్పుడూ రిటర్న్ రకంగా ఉంటుంది, ఇది శూన్యమైనది మరియు ఆపరేటర్‌ను మళ్ళీ తొలగించడం వంటి ఆపరేటర్ పరామితిని తొలగించడానికి బహుళ పారామితులను ఉపయోగించవచ్చు, ఓవర్‌లోడ్ సాధారణంగా అదనపు పారామితి కానట్లయితే, ఆ అదనపు పారామితులను ఎలా ఉపయోగించాలో అర్థం చేసుకోకపోతే .
సారాంశంలో, సి ++ లో డైనమిక్ మెమరీ నిర్వహణ కోసం కొత్త మరియు తొలగించే ఆపరేటర్లను పరిచయం చేసాము, ఇక్కడ సికి విరుద్ధంగా మాలోక్, ఉచిత మరియు ఇతర విధులు వాస్తవానికి ప్రామాణిక గ్రంథాలయాలు. భాషా లక్షణాలు కాదు, లక్షణాలు ఉన్నాయి, ఇక్కడ అవి భాషా లక్షణాలు.
వేర్వేరు కొత్త ఆపరేటర్లు మరియు వాటి సంబంధిత డిలీట్ ఆపరేటర్ల మధ్య తేడాలు మరియు వారు నేర్చుకున్న ప్రాథమిక సూత్రం, మనం కేటాయించినా లేదా ఫంక్షన్ చేసినా, కేటాయించిన వాటిని మేము జాగ్రత్తగా అర్థం చేసుకున్నాము. మేము దానిని ఉపయోగిస్తాము సంబంధిత డి-కేటాయింపు ఫంక్షన్ లేదా ఆపరేటర్ - మల్లాక్ ఉచితంగా, ఆపరేటర్ తొలగింపుతో ఆపరేటర్ కొత్తది, ఆపరేటర్ అర్రే, ఆపరేటర్ అర్రేతో) తొలగింపు, ఆపరేటర్ (లు) కొత్తవి మరియు నేను ప్లేస్‌మెంట్‌ను పునరుద్ధరించినట్లయితే, మీకు ఎటువంటి తొలగింపు ఉండకూడదు మరియు లేకపోతే మాకు పూర్తిగా unexpected హించని సమస్యలు వచ్చే అవకాశం ఉంది.
చివరకు ఈ కొత్త ఆపరేటర్లను ఓవర్‌లోడ్ చేయడం మరియు ఆపరేటర్లను ఎలా తొలగించాలో కూడా చూశాము, ఇది ఇప్పుడు ఆపరేటర్‌గా ఉండటం వల్ల ప్రయోజనం.
మరియు ఈ ఆపరేటర్లను ఓవర్‌లోడ్ చేయడం ద్వారా వినియోగదారు కోరుకున్న విధంగా విభిన్న కార్యాచరణను ఎలా నిర్వహించవచ్చో మేము చూపించాము.
inhouse/NPTEL/PreFinal/c++/Telugu/07. ProgramminginCplusplus_Programs with IO and Loop (Lecture 04)-1sibb2PGR-Q.txt
View file @ 956c0d4e
 1. మనము  ఇప్పుడు C ++ కోర్సులో మాడ్యూల్ 2. మాడ్యూల్ను2 గురించి చర్చిస్తాము,
2. మొదటి మాడ్యూల్ లో, మనము  C ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క క్లుప్త సారాంశం చూసాము .
3. మనము  భావనలను పునరావృతం చేసాము, C లో ఉన్న సాధారణ అంశాలు మరియు మనము నెమ్మదిగా సి ++ తో తెలుసుకునేలా సిద్దపడ్డాము .
4. ఈ మాడ్యూల్ మరియు తరువాతి 3 మాడ్యూళ్ళలో, మేము వివిధ ప్రోగ్రామింగ్ ఉదాహరణల గురించి మాట్లాడుతాము మరియు సి ++ లో, ఈ ప్రోగ్రామ్ మరింత సమర్థవంతంగా మరియు తరచుగా మెరుగ్గా ఎలా చేయవచ్చో చూపిస్తాము. సి లో అవసరమయ్యే దానికంటే మంచి మార్గంలో వ్రాయవచ్చు.
5. 2, సి మరియు సి ++ ప్రోగ్రామ్‌ల మధ్య ప్రాథమిక తేడాలను అర్థం చేసుకోవడంతో ప్రారంభిస్తాము.
6. మరియు మేము ఈ మాడ్యూల్‌తో పాటు ఈ క్రింది 3 మాడ్యూళ్ళకు వెళ్లేటప్పుడు సి ++ లో ప్రోగ్రామింగ్ సౌలభ్యాన్ని అభినందించడానికి ప్రయత్నిస్తాము.
7. మేము ప్రధానంగా IO వేరియబుల్స్, అంకగణిత లైబ్రరీ ప్రామాణిక లైబ్రరీ హెడర్స్, లూప్ మరియు బూల్ రకం ఫీల్డ్‌ల గురించి విరుద్ధంగా మాట్లాడుతాము.
8. కాబట్టి, మేము "హలో వరల్డ్" ను ప్రింట్ చేయవలసిన సి యొక్క ప్రారంభ ప్రోగ్రామ్తో ప్రారంభిస్తాము.
9. కాబట్టి, ఇక్కడ రెండు నిలువు వరుసలలో, "హలో వరల్డ్" ను సి తో పాటు సి ++ లో ప్రింట్ చేసే ప్రోగ్రామ్ ను చూపిస్తాము.
10. మీరు కొన్ని ప్రాథమిక తేడాలను గమనించవచ్చు, మొదట IO హెడర్ మార్చబడింది.
11. C లో, ఇది stdio.h; C ++ లో ఇది IO స్ట్రీమ్ అవుతుంది.
12. C లో, మేము printf చేసినప్పుడు, మేము కన్సోల్‌కు వ్రాస్తాము; మేము కన్సోల్‌లో ప్రింట్ చేస్తాము.
13. ఇక్కడ, మేము ఒక ఆపరేటర్‌ని ఉపయోగిస్తాము, స్ట్రీమింగ్ ఆపరేటర్‌ను నియంత్రించడానికి ఒక జత ఎడమ బాణం ఆపరేటర్లు అవుట్‌పుట్‌ను ప్రసారం చేస్తారు మరియు కన్సోల్ C లోని ఫైల్ స్టడౌట్, ఇది ఇప్పుడు C ++ లో ఒక కౌట్ స్ట్రీమ్.
14. మేము std అని పిలువబడే కౌట్ ముందు ఉపసర్గను ఉపయోగిస్తున్నామని మరియు std :: తో వ్రాసినట్లు గమనించండి.
15. మేము ఈ సంజ్ఞామానాన్ని త్వరగా ఉపయోగించడం అలవాటు చేసుకుంటాము, ఈ STD ని నేమ్‌స్పేస్ అంటారు; ప్రామాణిక నేమ్‌స్పేస్.
16. కాబట్టి, C ++ లోని ఏదైనా ప్రామాణిక లైబ్రరీ గుర్తు ఈ ప్రత్యేక ఉపసర్గ std తో ప్రిఫిక్స్ చేయబడుతుంది.
17. ఇప్పుడు, ఈ సరళమైన 'హలో వరల్డ్' ప్రోగ్రామ్‌లో గమనించదగ్గ మరో ముఖ్యమైన విషయం ఏమిటంటే, మనం ప్రింట్ ఎఫ్ చేసినప్పుడు, మనకు ఏకపక్ష సంఖ్యలు ఉండవచ్చు, ఈ వైవిధ్య ఫంక్షన్‌ను (ఫంక్షన్) అంటారు.
18. కాబట్టి, ఇక్కడ 'హలో వరల్డ్' ఉదాహరణలో మనం ప్రింట్ ఎఫ్ యొక్క రెండు ఉపయోగాలను చూస్తున్నాము, రెండూ పారామితి, ఫార్మాట్ స్ట్రీమ్ ఉపయోగించి.
19. వాస్తవానికి, మాకు ఇక్కడ ఫార్మాట్ లేదు; ఇది నిరంతర స్ట్రింగ్ ముద్రించబడుతోంది.
20. దీనికి విరుద్ధంగా, సి ++ లోని అవుట్పుట్ స్ట్రీమింగ్ ఆపరేటర్‌గా బైనరీ ఆపరేటర్‌గా మెటీరియల్ రూపంలో ఎడమ వైపు ప్రింట్ చేసి కుడి వైపున ప్రింట్ చేస్తుంది మరియు ఇది ఈ రూపంలో ప్రింట్ చేస్తుంది.
21. అందువల్ల, మేము మొదటి అవుట్పుట్ లైన్, std :: cout అవుట్పుట్ ఆపరేటర్ మరియు సందేహ కోట్లలో చూస్తే, మనకు స్థిరమైన స్ట్రింగ్ ఉంది. దీని అర్థం C ++ స్ట్రింగ్ (స్ట్రింగ్) హలో వరల్డ్ కన్సోల్కు ప్రసారం చేయబడుతుంది.
22. C లో తప్పించుకున్న కొత్త క్యూ క్యారెక్టర్ స్లాష్ n అని కూడా గమనించండి.
23. C ++ లో కూడా దీనిని ఉపయోగించవచ్చు, కాని ఎండల్ అని పిలువబడే కొత్త పంక్తికి వెళ్ళడానికి మరొక మార్గం ఉంది, ఇది ఎండ్ లైన్ యొక్క సంక్షిప్తీకరణ మరియు దానిపై మేము తరువాత మరింత తెలుసుకుంటాము.
24. ఇది, అండాల్ ప్రాథమికంగా ఒక ప్రవాహం.
25. కాబట్టి, ఈ దశలో మేము C ++ ప్రోగ్రామ్‌లో సిస్టమ్ కౌట్ మరియు అవుట్పుట్ ఆపరేటర్ ఉపయోగించి ప్రాథమిక అవుట్పుట్ చేయవచ్చని చూడటానికి ప్రయత్నిస్తున్నాము.
26. మేము తరువాతి ప్రోగ్రామ్‌కు వెళ్తాము, ఇక్కడ మేము చాలా సరళమైన అంకగణిత ప్రోగ్రామ్‌ను వివరిస్తున్నాము, ఇందులో a మరియు b అనే రెండు వేరియబుల్స్ ఉంటాయి మరియు వాటిని మన మొత్తాన్ని ఏర్పరుస్తాయి.
27. ఈ వేరియబుల్స్ యొక్క విలువలు C లో std అయిన కన్సోల్ నుండి చదవబడతాయి మరియు మేము అన్ని ఫార్మాట్ స్ట్రింగ్ (స్కాన్ఫ్) లో మీకు తెలిసిన స్కాన్ఫ్ ఫంక్షన్‌ను ఉపయోగిస్తాము, ఉదాహరణకు, printf అనేది ఒక వైవిధ్య ఫంక్షన్. పారామితుల వేరియబుల్ సంఖ్యలు.
28. ఇక్కడ, మేము 3 పారామితులను తీసుకుంటున్న స్కాన్ఫ్ యొక్క రూపాన్ని చూస్తాము; వరుసగా A మరియు B యొక్క స్ట్రింగ్ మరియు చిరునామాలను ఫార్మాట్ చేయండి.
29. దీనికి విరుద్ధంగా, సి ++ ప్రోగ్రామ్‌లో ఇన్పుట్ స్ట్రీమ్ నుండి స్ట్రీమింగ్ కోసం ఉపయోగించే మరొక ఆపరేటర్‌ను మేము పరిచయం చేస్తున్నాము.
30. కాబట్టి, దీనిని ఇన్పుట్ స్ట్రీమింగ్ ఆపరేటర్ అని పిలుస్తారు, మళ్ళీ ఒక జత బాణాలు, కానీ బాణం ఇప్పుడు ఎడమ నుండి కుడికి దర్శకత్వం వహించబడుతుంది.
31. కాబట్టి, మీరు ఇన్పుట్ ఆపరేటర్లో std :: cin ను చూస్తే, C చదవబడుతుందని అర్థం.
32. ఆసక్తికరమైన విషయం ఏమిటంటే, ఈ ఆకృతిలో C ++ లో మీరు ఇక్కడ చూపిస్తున్నట్లుగా మీరు బహుళ ఆపరేటర్లను ఒక్కొక్కటిగా అనేక వేరియబుల్స్కు చేర్చవచ్చు.
33. అందువల్ల, మేము ప్రామాణిక ఇన్పుట్ నుండి మళ్ళీ ప్రసారం చేసిన తరువాత, ప్రామాణిక ఇన్పుట్ నుండి బి స్ట్రీమ్ చేయండి.
34. కాబట్టి, ఈ సంజ్ఞామానం అంటే కన్సోల్ యొక్క ప్రామాణిక ఇన్పుట్ నుండి మొదటిది మరియు తరువాత వేరియబుల్ B చదవబడుతుంది.
35. ఈ వేరియబుల్స్ ప్రామాణిక స్ట్రీమింగ్ అవుట్పుట్ యొక్క అవుట్పుట్ (అవుట్పుట్) ఎలా ఉన్నాయో కూడా మేము చూపిస్తాము, ఇది సి ప్రోగ్రామ్ (ప్రోగ్రామ్) గా కౌట్ లేదా స్టడ్ అవుట్ అవుతుంది.
36. రెండు ప్రధాన తేడాలు ఉన్నాయి, మీరు ఇక్కడ గమనించాలి, ఒకటి మేము C ++ లో ఫార్మాట్ స్ట్రింగ్ ఉపయోగించాల్సిన అవసరం లేదు.
37. C లో మనకు తెలుసు, నేను ఒక పూర్ణాంక వేరియబుల్‌ను ప్రింట్ చేయాలనుకుంటే, అప్పుడు వేరియబుల్ శాతం d ఫార్మాట్‌లో ముద్రించబడాలని ఫార్మాట్ స్ట్రింగ్‌లో పేర్కొనాలి, ఇది ఒక పూర్ణాంకం C + లో ముద్రించవలసిన డేటా రకం అని సూచిస్తుంది. +, వేరియబుల్‌కు విరుద్ధంగా ఫార్మాట్‌తో పేర్కొనవలసిన అవసరం లేదు, కంపైలర్ ఇది పూర్ణాంక వేరియబుల్ అని తెలుసుకోవడం స్వయంచాలకంగా దాన్ని ప్రింట్ చేయడానికి ఫార్మాట్‌ను నిర్ణయిస్తుంది. అవసరం మరియు సరిగ్గా ప్రింట్ చేయండి.
38. ఈ రెండు ప్రోగ్రామ్‌ల మధ్య మీరు గమనించవలసిన మరో ప్రధాన వ్యత్యాసం ఏమిటంటే, మేము స్కాన్ చేసినప్పుడు, మేము `std in 'నుండి విలువను చదువుతున్నాము మరియు ఆ విలువను చదివిన తరువాత వేరియబుల్ యొక్క అసలు విలువను విలువకు మార్చండి వినియోగదారు ఇన్పుట్ అవుతుంది.
39. మేము సి యొక్క చిరునామాను పాస్ చేయాలి ఎందుకంటే ఇది సి తో సుపరిచితం.
40. ఈ చిరునామా వాడుతున్న యంత్రాంగం చేసిన కాల్‌కు సమానంగా ఉంటుంది, ఇక్కడ మేము వేరియబుల్ విలువను స్కాన్ఫ్ పరామితి విలువ నుండి కాల్ పరామితిగా పాస్ చేస్తాము.
41. దీనికి విరుద్ధంగా, మేము C ++ లో ఇన్పుట్ స్ట్రీమ్ నుండి చదువుతున్నప్పుడు, పాస్ చేయడానికి మాకు చిరునామా అవసరం లేదు; మేము వేరియబుల్స్ మాత్రమే పేర్కొనగలము మరియు కంపైలర్ మిగిలిన వాటిని చూసుకుంటుంది.
42. మేము సి ++ ఆపరేటర్లు మరియు కాల్ మెకానిజమ్‌ల గురించి మరింత తెలుసుకున్నప్పుడు, ఇది వాస్తవంగా ఎలా పనిచేస్తుందో మేము అర్థం చేసుకుంటాము, అయితే ఇది ఖచ్చితంగా ఫార్మాట్ స్ట్రింగ్‌తో పాటు ప్రింట్ ఎఫ్ లేదా చిరునామాలను కూడా చదివేలా చేస్తుంది.
43. C ++ లో, స్కాన్ఫ్ కోసం వేరియబుల్ కూడా అదే విధంగా చేయవచ్చు.
44. సి ప్రోగ్రామ్‌లో, వేరియబుల్ మొత్తాన్ని డిక్లరేషన్ పరంగా మీరు గమనించగల మరొక చిన్న వ్యత్యాసం, వేరియబుల్ బి మరియు బి తరువాత వేరియబుల్ ఎగువన ప్రకటించబడుతుంది, ఎందుకంటే సి 89 పేర్కొన్న అసలు సి లేదా సి యొక్క అసలు వెర్షన్ వేరియబుల్స్ యొక్క అన్ని డిక్లరేషన్లు ప్రోగ్రామ్‌లోని మొదటి ఎక్జిక్యూటబుల్ స్టేట్‌మెంట్‌కు ముందు ఉండాలి.
45. సి ప్రోగ్రామ్‌లో, మొదటి ఎక్జిక్యూటబుల్‌లో మనం ఇక్కడ చూస్తున్నది ప్రింట్ ఎఫ్ ఫంక్షన్ కాల్.
46. కాబట్టి, అన్ని వేరియబుల్స్ దీనికి ముందు ప్రకటించబడాలి.
47. ఈ పరిమితి C ++ లో లేదు.
48. కాబట్టి, మేము పేరును ప్రారంభించేటప్పుడు, మనం వేరియబుల్ ను డిక్లేర్ చేయవచ్చు మరియు మనం పేరును ప్రారంభించాల్సిన అవసరం వచ్చినప్పుడు, మనకు A మరియు B వేరియబుల్స్ అవసరం, ఎందుకంటే చదవడం అవసరం, కానీ వాటి మొత్తాన్ని మనం చేయవలసి వచ్చినప్పుడు, మేము కూడా మొత్తాన్ని ప్రకటించగలము .
49. వేరియబుల్ ఉపయోగించండి, ఆపై ప్లస్ బి మరియు మొత్తం విలువను ప్రారంభించడానికి మొత్తాన్ని చొప్పించండి.
50. వాస్తవానికి, C యొక్క తరువాతి సంస్కరణ C99 అని గమనించాలి, ఇది మీకు వేరియబుల్ అవసరమైనప్పుడు వేరియబుల్స్ యొక్క డిక్లరేషన్‌ను C ++ లోని బిందువుకు తరలించడానికి మిమ్మల్ని అనుమతిస్తుంది.
51. అందువల్ల, సారూప్యతలు మరియు తేడాలను బాగా అర్థం చేసుకోవడానికి దయచేసి మీ కంప్యూటర్‌లో ఈ ప్రోగ్రామ్‌ను జాగ్రత్తగా చదవండి మరియు అమలు చేయండి.
52. మేము మరొక ప్రోగ్రామ్‌కు వెళ్తాము, ఇది మళ్ళీ గణిత గణనను ఉపయోగించి ఒక సాధారణ ప్రోగ్రామ్, ఇది మీరు సి ప్రోగ్రామ్‌లో ఏదో ఒక సమయంలో చేశారని నేను ఖచ్చితంగా అనుకుంటున్నాను.
53. కాబట్టి, సి ప్రామాణిక లైబ్రరీలో భాగంగా సికి math.h హెడర్ ఉందని మాకు తెలుసు, ఇది చాలా ఉపయోగకరమైన విధులను కలిగి ఉంది.
54. కాబట్టి, డబుల్ వేరియబుల్ యొక్క వర్గమూలాన్ని కనుగొనడానికి sqrt అని పిలువబడే ఇలాంటి ఫంక్షన్ యొక్క ఉపయోగాన్ని ఇక్కడ చూపిస్తున్నాము.
55. ఇది డబుల్ వేరియబుల్ తీసుకుంటుంది మరియు డబుల్ ఫలితాన్ని ఇస్తుంది, ఇది చదరపుకి పంపబడిన పరామితి యొక్క వర్గమూలం.
56. అదే ఫంక్షన్ C ++ లో కూడా అమలు చేయవచ్చు.
57. కాబట్టి, దీన్ని ఎలా చేయాలో మేము చూపిస్తున్నాము, కాబట్టి దయచేసి C ++ లో మనం ఉపయోగించే హెడర్ పేరు మార్చబడింది.
58. సి లో మేము దీనిని math.h అని పిలుస్తున్నాము.
59. అదే శీర్షికను C ++ లో cmath అని పిలుస్తారు మరియు ఇది ఏదైనా ప్రామాణిక లైబ్రరీ హెడర్‌ను C ++ లో ఉపయోగించవచ్చని ఒక సాధారణ సమావేశం అని మేము చూస్తాము, కానీ మీరు దానిని ఉపయోగించినప్పుడు, మీరు పేరు ప్రారంభంలో ఒక C ని జోడిస్తారు.
60. సి అంటే ప్రామాణిక లైబ్రరీ హెడర్ సి స్టాండర్డ్ లైబ్రరీ నుండి వస్తున్నదని మరియు ఇతర వ్యత్యాసం ఏమిటంటే మీరు సి లోని ఫైల్ పేరు కోసం డాట్ హెచ్ ఎక్స్‌టెన్షన్‌ను వదిలివేస్తారు, మీరు దానిని సమ్మత్ అని పిలుస్తారు.
61. వాస్తవానికి, మనం ఇంతకుముందు చెప్పినట్లుగా, కౌట్ మరియు ఎండ్ల్ పేర్ల పరంగా, ఇవి కూడా అదే నేమ్‌స్పేస్‌లో (నేమ్‌స్పేస్) std వలె ఉన్నాయి, అంటే C లోని ఫంక్షన్ (ఫంక్షన్) sqrt నుండి sqrt C ++ ++ లో, ఫంక్షన్ పేరు (sq) sqrt, std తో ఉపసర్గ అవుతుంది, దీని పూర్తి పేరు std :: sqrt.
62. ఇప్పుడు, ఇక్కడ మేము ప్రామాణిక లైబ్రరీ చిహ్నాలను వ్యక్తీకరించడానికి మరొక షార్ట్ కట్ లేదా అనుకూలమైన మార్గాన్ని కూడా చూపిస్తాము, C ++ ప్రోగ్రామ్‌లో హాష్ చేర్చబడిన తరువాత, మేము నేమ్‌స్పేస్‌ను కలిగి ఉన్న ఒక పంక్తిని వ్రాసాము. Std ఉపయోగించబడుతుంది.
63. దీని అర్థం మనం ఈ పంక్తిని చేర్చుకుంటే, C ++ ప్రోగ్రామ్ (ప్రోగ్రామ్) లోని ఏదైనా ప్రామాణిక లైబ్రరీ చిహ్నం ఉపసర్గగా పరిగణించబడుతుంది, std :: cout, std :: cin., Std :: endl or std: : చ.
64. కాబట్టి, దీన్ని చేయడానికి అనుకూలమైన మార్గం ఏమిటంటే, మీరు సి ++ లో నేమ్‌స్పేస్ లక్షణాన్ని ఉపయోగించవచ్చు లేదా మీరు దానిని ఉపయోగించకపోతే, అన్ని ప్రామాణిక లైబ్రరీ చిహ్నాలను std :: ఉపసర్గ చేయండి.
65. మిగిలిన ప్రోగ్రామ్ అర్థం చేసుకోవడం చాలా సులభం మరియు మీరు ఎడమ వైపున చూసే ప్రోగ్రామ్ లాగా ఉంటుంది. మార్పులు స్ట్రీమింగ్ ఇన్పుట్ మరియు అవుట్పుట్కు అనుగుణంగా ఉంటాయి, మేము ఇప్పటికే చేసినట్లుగా. చూశాము.
66. కాబట్టి, మేము దీనితో ముందుకు వెళ్లి C ++ ప్రామాణిక లైబ్రరీని పరిశీలిస్తాము.
67. సంగ్రహంగా చెప్పాలంటే, సి స్టాండర్డ్ లైబ్రరీలోని అన్ని పేర్లు గ్లోబల్ అని నేను ఇప్పటికే పేర్కొన్నది, ఇవన్నీ ప్రామాణిక లైబ్రరీ ఫంక్షన్లు, మాక్రోలు; అవి ఆ పేరుతో ఏదైనా ఫంక్షన్ కోసం అందుబాటులో ఉంటాయి.
68. కాబట్టి, అన్ని సి ప్రామాణిక లైబ్రరీ పేర్లు వాస్తవానికి అన్ని ఆచరణాత్మక ప్రయోజనాల కోసం మీరు మీ స్వంత ప్రింట్ ఎఫ్ ఫంక్షన్ మరియు సి స్టాండర్డ్ లైబ్రరీ (ఫంక్షన్) ను వ్రాయలేని విధంగా రిజర్వు చేయబడ్డాయి ఎందుకంటే మీరు లైబ్రరీలో ఇచ్చిన ప్రింట్ ఎఫ్ ఫంక్షన్‌ను ఉపయోగించడం కొనసాగించవచ్చు) ఎందుకంటే ఈ క్షణం మీరు మీ స్వంత ప్రింట్ ఎఫ్ ఫంక్షన్‌ను వ్రాస్తారు, అది కూడా గ్లోబల్ స్పేస్ లో పేరు.
69. మీరు C ++ లో నేమ్‌స్పేస్‌ల గురించి అధికారికంగా అధ్యయనం చేసినప్పుడు, మీరు దీన్ని మరింత అర్థం చేసుకుంటారు, కాని దయచేసి అన్ని పేర్లు ప్రపంచవ్యాప్తంగా అందుబాటులో ఉన్నాయని గమనించండి.
70. దీనికి విరుద్ధంగా, C ++ ప్రామాణిక లైబ్రరీలోని అన్ని పేర్లు std నేమ్‌స్పేస్‌లో ఉన్నాయి.
71. ఇది ప్రత్యేకంగా నేమ్‌స్పేస్‌లు మరియు అన్ని పేరు ఉపసర్గలతో కూడిన ప్రామాణిక లైబ్రరీ నేమ్‌స్పేస్‌ల కోసం ప్రత్యేకించబడింది :: అంటే ఈ పేరు ఈ స్టేడ్ నేమ్‌స్పేస్‌లోనే సంభవిస్తుంది.
72. అందువల్ల, నేమ్‌స్పేస్ అంటే మన స్వంత పేర్లను ఉపయోగించినప్పుడు ఏమి జరుగుతుంది, ఇది మేము ఉపయోగించే కుటుంబ పేరు లేదా చివరి పేరు వంటిది.
73. అందువలన, నేను పార్థా ప్రతిమ దాస్.
74. కాబట్టి, దాస్ నా చివరి పేరు మరియు నా పేరు పార్థ్.
75. అందువల్ల, మరికొన్ని కుటుంబ పేర్లలో మరొక పార్థా ఉండవచ్చు అని పార్థా ప్రతిం చక్రవర్తి పేర్కొంది.
76. కాబట్టి, ఇవి ఉన్న వివిధ కుటుంబ పేర్లకు భిన్నంగా ఉంటాయి.
77. కాబట్టి, పేరు స్థలం దీనికి సమానంగా ఉంటుంది.
78. దీని గురించి మేము తరువాత మాట్లాడుతాము.
79. కాబట్టి, మీరు ఇక్కడ std ని ఉపయోగించి పేరు ఖాళీలను చిన్నగా కత్తిరించినట్లయితే, మీరు అన్ని ప్రామాణిక లైబ్రరీ పేర్లను ఆ std :: నేమ్‌స్పేస్‌తో ప్రిఫిక్స్ చేయనవసరం లేదు.
80. ఇప్పుడు, ప్రామాణిక లైబ్రరీ యొక్క శీర్షిక గురించి చాలా ప్రత్యేకమైనదాన్ని హైలైట్ చేయాలనుకుంటున్నాను.
81. కాబట్టి, సి ++, సి అంటే దాని అర్థం అని మేము గుర్తించాము; అంటే ఏదైనా సి ప్రోగ్రామ్‌ను సి ++ ప్రోగ్రామ్‌గా కూడా అమలు చేయాలి.
82. సి యొక్క ప్రామాణిక లైబ్రరీతో మేము ఏమి చేస్తాం అనేదానికి ఇది మరొక ప్రశ్నను తెస్తుంది, సి యొక్క ప్రామాణిక లైబ్రరీని సి ++ ప్రోగ్రామ్‌లో కూడా ఉపయోగించవచ్చని నేను ఇప్పటికే స్పష్టం చేశాను, అయితే ప్రోగ్రామ్‌ను మిళితం చేయడానికి మీకు ఒక చిన్న విషయం C ++ నుండి ప్రోగ్రామ్‌కు ప్రామాణిక లైబ్రరీ హెడర్‌ను మీరు ఎలా పేర్కొంటారు.
83. కాబట్టి, మీరు దీన్ని ఎడమ వైపున ఎలా చేయవచ్చో ఈ పట్టిక మీకు చూపుతుంది, మీరు ప్రోగ్రామ్‌ను వ్రాస్తున్న భాషలో మరియు మేము శీర్షికను చూపిస్తున్న కాలమ్‌లో ఏ ప్రామాణిక లైబ్రరీలో మేము శీర్షికను చూపిస్తున్నాము. ఇది సి నుండి లేదా సి ++ నుండి.
84. కాబట్టి, మీరు సి ప్రోగ్రామ్ వ్రాస్తుంటే మరియు మీరు సి స్టాండర్డ్ లైబ్రరీ హెడర్ ఉపయోగిస్తుంటే, మీరు stdio.h లాగా చేరతారని మాకు తెలుసు.
85. మీరు సి ++ ప్రోగ్రామ్‌ను వ్రాస్తూ, సి స్టాండర్డ్ లైబ్రరీ హెడర్‌ను కలిగి ఉంటే, నేను చెప్పినట్లుగా, మీరు సి స్టాండర్డ్ లైబ్రరీ పేరును సి తో ప్రిఫిక్స్ చేయాలి.
86. అందువల్ల, stdio.h ఇప్పుడు C stdio గా మారింది మరియు మీరు ప్రామాణిక లైబ్రరీ నుండి dot h మరియు C నుండి పేరును వదలాలి ఈ చిహ్నాలన్నీ ఇప్పుడు std నేమ్‌స్పేస్ (నేమ్‌స్పేస్) లో పొందుతాయి మరియు మనకు std తో ఉపసర్గ లభిస్తుంది :: కలిగి ఉండాలి చేయండి.
87. మీరు C ++ ప్రోగ్రామ్‌ను వ్రాసి, C ++ ప్రామాణిక లైబ్రరీని కలిగి ఉంటే, మీరు దానిని హాష్ IO స్ట్రీమ్‌గా మాత్రమే చేర్చారు.
88. C ++ లోని అన్ని ప్రామాణిక లైబ్రరీ హెడర్‌లకు వాటి ఫైల్ ఎక్స్‌టెన్షన్స్‌లో డాట్ హెచ్ లేదు, ఇది ఒక చారిత్రక కారణం, నేను తరువాతి దశలో వివరించడానికి ప్రయత్నిస్తాను, కాని దయచేసి IO స్ట్రీమ్‌లు ఉండకూడదని గమనించండి.
89. మరియు చేర్చకూడదు.
90. ఈ మాతృకలోని చివరి పెట్టె మీరు సి ప్రోగ్రామ్ వ్రాస్తున్నప్పుడు మరియు మీరు సి ++ హెడర్‌ను ఉపయోగించాలనుకుంటే, అది ఖచ్చితంగా వర్తించదు ఎందుకంటే మీరు సి ++ లో చాలా ఫీచర్లు చేయలేరు. సి మద్దతు ఇవ్వనివి మరియు కాబట్టి, ఉపయోగించబడదు.
91. ముఖ్యంగా గమనించండి మరియు నేను ఎరుపు రంగులో హైలైట్ చేసాను, పొరపాటున లేదా సి లో ప్రామాణిక లైబ్రరీ (లైబ్రరీ) శీర్షికల కోసం డాట్ హెచ్ ను ఫైల్ నేమ్ ఎక్స్‌టెన్షన్‌గా ఉపయోగించడం ద్వారా.
92. మీరు I ++ స్ట్రీమ్‌ను కలిగి ఉంటే.
93. C ++ ప్రోగ్రామ్‌లో, మీ కంపైలర్ నిజంగా మీకు లోపం ఇవ్వదు అంటే మీ కంపైలర్ నిజంగా నాటిది మరియు మీరు ఇటీవల కంపైలర్‌కు వెళ్లాలి మరియు అందువల్ల ఇది చాలా ప్రమాదకరమైన ప్రతిపాదన. ఎందుకంటే మీరు పొరపాటు చేస్తున్నారు IO stream.h లేదా హెడర్ డాట్ h తో ఉన్న పదార్థం పొడిగింపు ఫైళ్ళ కోసం ఏదైనా C ++ ప్రామాణిక లైబ్రరీ, ఇవన్నీ వర్ణించబడ్డాయి.
94. అవి పెద్దగా ఉపయోగంలో లేవు, అయితే కొన్ని కంపైలర్లు సి ++ ప్రమాణంలో తయారు చేయబడటానికి ముందే వ్రాయబడినందున వాటిని అనుమతించడం కొనసాగిస్తున్నాయి.
95. కాబట్టి, దయచేసి ప్రామాణిక లైబ్రరీ శీర్షికల యొక్క ఈ సమావేశాలను గుర్తుంచుకోండి.
96. తరువాత, మీ సి. లూప్‌ల వాడకంపై మేము దృష్టి పెడతాము.
97. చాలా పోలి ఉంటాయి.
98. అందువల్ల, మేము 0 నుండి ప్రారంభమయ్యే అంకెల క్రమాన్ని మాత్రమే ఇక్కడ జోడిస్తున్నాము.
99. n మరియు లూప్ కోసం వాటిని చేర్చండి.
100. IO శీర్షికలు మరియు కౌట్ స్ట్రీమింగ్ సమావేశాలలో తేడాలు మినహా ఇలాంటి ప్రోగ్రామ్‌లు C ++ కోసం దాదాపు సమానంగా పనిచేస్తాయి.
101. లూప్ లూప్ సూచికల కోసం, కుండలీకరణాల్లో నన్ను 'నిర్మించు' అని ప్రకటించవచ్చు.
102. మీరు ఇలా చేస్తే, నేను ఈ డిక్లరేషన్ లూప్‌కు స్థానికంగా ఉంటుంది, మీరు లూప్ కోసం బయటకు వచ్చిన తర్వాత మీరు తరువాత మంచం స్టేట్‌మెంట్‌లో ఉన్నారు లేదా నేను తరువాత ప్రకటించబడను.
103. కాబట్టి, ఇది ప్రవేశపెట్టబడింది, తద్వారా మీకు స్థానిక ఇండెక్స్ వేరియబుల్స్ అవసరమైనప్పుడు మీరు వాటిని త్వరగా స్థానికంగా ఉపయోగించుకోవచ్చు మరియు మీరు ఆ వేరియబుల్‌ను ఇంతకు ముందు ప్రకటించారా లేదా అనే దాని గురించి నిజంగా ఆలోచించకండి, అది మరొక సందర్భంలో ఉపయోగించబడుతుందా లేదా అనే దాని గురించి నిజంగా ఆలోచించవద్దు.
104. మీరు వాటిని స్థానికంగా మాత్రమే ప్రకటించవచ్చు మరియు వాటిని C ++ లో ఉపయోగించవచ్చు.
105. C89 లో ఇది సాధ్యం కాలేదు, కానీ ఇప్పుడు C99 లో కూడా ఇది సాధ్యమే.
106. చివరగా, ఈ మాడ్యూల్ యొక్క చివరి భాగంలో, మేము బూలియన్ రకాన్ని ఉపయోగించడాన్ని వివరిస్తాము.
107. సి బూలియన్ రకాన్ని ఉపయోగించుకునే అవకాశం ఉందని మనందరికీ తెలుసు, ఇది ఒక రకం, ఇది నిజమైన లేదా తప్పుడు విలువను తీసుకోగలదని మేము చెబుతున్నాము.
108. ఇప్పుడు, సి ఇది సి 89, అసలు పాత సి మనకు బూల్ కోసం వేరే రకం లేదు.
109. కాబట్టి, అది ఏమిటంటే, అది బూల్‌ను అర్థం చేసుకోవడానికి పూర్ణాంకాన్ని ఉపయోగిస్తోంది, మీరు బూలియన్ స్థానం లేదా బూలియన్ విలువను ఏ ప్రదేశంలో ఉంచాలనుకుంటున్నారో, మీరు తేడా వేరియబుల్‌ను ప్రకటిస్తారు. మరియు 0 అని సెట్ చేయండి, మీరు తప్పుడు అర్థం చేసుకోవాలనుకుంటే మరియు కానిదాన్ని సెట్ చేయండి -జెరో, మనం నిజం అని అనుకుంటే.
110. అందువల్ల, ఈ 3 నిలువు వరుసలలో, మీరు ఎడమ వైపు చూస్తే, సి ప్రోగ్రామ్ బూలియన్‌తో పనిచేస్తున్న అత్యంత సాధారణ మార్గం ఏమిటంటే, సౌలభ్యం కోసం మీరు రెండు స్థిరాంకాలను నిర్వచించవచ్చు; 1 మరియు 0 కలిగి ఉండటం మరియు వాటిని మీ ప్రోగ్రామ్‌లో ఉపయోగించడం నిజం మరియు తప్పు, కానీ నేను చూపించినట్లుగా బూలియన్ స్థానానికి ఉపయోగించే వేరియబుల్ x వ్యత్యాస రకంగా ప్రకటించబడింది. పూర్తయింది మరియు ఇది సత్యంతో ప్రారంభమైంది..
111. కాబట్టి, మీరు ప్రింట్ చేస్తే దాని విలువ 1 అని చూపిస్తుంది; ఇది C89 లో ఉంది.
112. తదనంతరం, C99 లో, బూల్ రకాన్ని ప్రవేశపెట్టడానికి మార్పు చేయబడింది.
113. ఇప్పుడు, దీనిని చూడటానికి ముందు, మొదట కుడివైపు కాలమ్ చూద్దాం, ఇది C ++ ప్రోగ్రామ్.
114. C ++ లో మీకు అంతర్నిర్మిత రకంగా బూల్ ఉంది, మీకు పూర్ణాంకం, చార్, ఫ్లోట్, డబుల్ ఉన్నాయి.
115. అదేవిధంగా, మీకు బూల్ రకం ఉంది, ఈ బూల్ రకం కేవలం రెండు అక్షరాస్యులు; చిన్న కేసులో నిజం మరియు తప్పు రెండూ.
116. అందువల్ల, ఆ కీలకపదాలు ఇప్పటికీ రిజర్వు చేయబడ్డాయి.
117. కాబట్టి, మీరు బూలియన్ వేరియబుల్‌గా ఉపయోగించడానికి x ను సమానంగా నిర్వచించాలనుకుంటే, మీరు నేరుగా బూల్‌ని ఉపయోగించవచ్చు, ఇది మీరు నిజంగా బూలియన్ అని అర్థం చేసుకోవడం చాలా సులభం. విలువతో పనిచేయడం మరియు మీరు దానిని నిజమైన లేదా తప్పుడుతో ప్రారంభించవచ్చు, కానీ మీరు ఈ వేరియబుల్ యొక్క విలువను ప్రింట్ చేయడానికి ప్రయత్నిస్తే, అది నిజం లేదా తప్పు అని ముద్రించదు, వాస్తవానికి ఇది 1 లేదా 0 ను ప్రింట్ చేస్తుంది) విల్, అది నిజమైతే అది 1 మరియు 0 లేకపోతే.
118. సహజంగానే, నిర్మించిన రకాన్ని స్పష్టంగా మరియు స్పష్టంగా ఉపయోగించుకోవడంలో చాలా ప్రయోజనాలు ఉన్నాయి.
119. వీటిలో చాలా ముఖ్యమైనది C ++ ప్రోగ్రామ్ నుండి, మీరు మీ బూలియన్ విలువను పేర్కొనడానికి బూల్ ఉపయోగించినట్లయితే, అప్పుడు ప్రోగ్రామ్ చదివే ఎవరైనా దానిని అర్థం చేసుకోవచ్చు.ఈ వేరియబుల్ నిజమైన లేదా తప్పుడు తప్ప వేరే విలువను తీసుకోలేరని అనుమతిస్తుంది.
120. దీనికి విరుద్ధంగా, మేము బూలియన్ విలువ కోసం పూర్ణాంకాన్ని ఉపయోగించే సి శైలిని ఉపయోగిస్తే, అది వాస్తవానికి చాలా భిన్నమైన విలువలను నిజం లేదా తప్పు అని అర్ధం చేసుకోవచ్చు. ఆమె వెళుతుంది.
121. ఇప్పుడు, మధ్య కాలమ్‌లో, C99 ఎవరితో వచ్చారో C99 ప్రమాణంలో C ప్రోగ్రామింగ్ భాష యొక్క ఆసక్తికరమైన పొడిగింపును చూస్తాము.
122. C99 ఒక స్పష్టమైన బూలియన్ రకాన్ని ప్రవేశపెట్టింది మరియు దీనికి అండర్ స్కోర్ బూల్ అని పేరు పెట్టారు, ఇక్కడ B మూలధనంలో వ్రాయబడింది, అయితే ఇది బూల్ ఇస్ రాయడానికి చాలా సాధారణమైన సహజ మార్గం కానందున, ఇది stdbool.h అనే కొత్త ప్రామాణిక లైబ్రరీ హెడర్‌ను కూడా అందించింది. మాక్రోలు అందించబడతాయి.
123. మొదటి స్థూల లోయర్ కేసులో బూల్‌ను నిర్వచిస్తుంది మరియు అండర్ స్కోర్ క్యాపిటల్ బూల్‌తో సమానంగా ఉంటుంది.
124. కాబట్టి, మేము C99 ప్రోగ్రామ్‌లో దిగువ కేసులో బూల్ ఉపయోగిస్తే, మీరు నిజంగా ఆ కొత్త ముందే నిర్వచించిన రకమైన అండర్ స్కోర్ క్యాపిటల్ బూల్ (బూల్) ను ఉపయోగిస్తున్నారు మరియు ఇది 1 మరియు 0 గా హెడర్‌లో ఉంది నేను సరైనది మరియు తప్పు అని నిర్వచించాను, తద్వారా మీరు దీన్ని స్థిరంగా ఇక్కడ ఉపయోగించండి.
125. అందువల్ల, మనం ఉంటే; మీరు సి ఉపయోగిస్తున్నప్పుడల్లా, మీరు ఎల్లప్పుడూ బూల్ అని టైప్ చేయాలి మరియు పూర్ణాంకానికి వాడకండి మరియు దానిని బూల్ రకంగా అర్థం చేసుకోవాలి. సి ++ లో ఇది ఖచ్చితంగా నిర్మించబడింది- ఈ రకాలు రూపంలో వస్తుంది.
126. కాబట్టి, దీనికి అనేక ఇతర ప్రయోజనాలు ఉన్నాయని మేము ఎత్తి చూపాము మరియు అదే సమయంలో మేము వివిధ రకాలతో వెళ్తాము.
127. కాబట్టి ఈ మాడ్యూల్‌లో, సి మరియు సి ++ మధ్య ప్రాథమిక వ్యత్యాసాన్ని అర్థం చేసుకోవడానికి ప్రయత్నించాము; మీరు ఇన్‌పుట్‌ను ఎలా అవుట్పుట్ చేస్తారు? మీరు వేరియబుల్ ఎలా ప్రకటిస్తారు? C ++ లో C మరియు C ++ యొక్క ప్రామాణిక లైబ్రరీ ఎలా ఉపయోగించబడుతుంది? C ++ మనకు ఎలా ప్రకటించగలదో మరియు ఎలా అవుట్పుట్ చేయగలదో మాకు మరింత సౌలభ్యాన్ని ఇస్తుందని చూడటం ప్రారంభించాము.
128. ఇప్పుడు, ఆ సంక్లిష్టమైన printf స్టేట్‌మెంట్‌లు, ఫార్మాట్‌లు వేర్వేరు తీగలలో ఉన్న స్ట్రీమ్ ప్రింట్ ఎఫ్ (ప్రింట్ ఎఫ్) ఫంక్షన్ (ఫంక్షన్) కాల్స్ మాకు అవసరం లేదు, వేరియబుల్స్ విడిగా జాబితా చేయబడతాయి.
129. స్కాన్ఫ్‌కు వేరియబుల్స్ మరియు సారూప్య చిరునామాలు అవసరమని మనం గుర్తుంచుకోవాల్సిన అవసరం లేదు మరియు ఈ విధంగా సి ++ లో చాలా నిర్మాణాలు మరియు విధులు సరళీకృతం చేయబడ్డాయి, ఇవి ప్రోగ్రామింగ్‌ను పెంచడానికి సహాయపడతాయి.
130.
 మనము  ఇప్పుడు C ++ కోర్సులో మాడ్యూల్ 2. మాడ్యూల్ను2 గురించి చర్చిస్తాము,
మొదటి మాడ్యూల్ లో, మనము  C ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క క్లుప్త సారాంశం చూసాము .
మనము  భావనలను పునరావృతం చేసాము, C లో ఉన్న సాధారణ అంశాలు మరియు మనము నెమ్మదిగా సి ++ తో తెలుసుకునేలా సిద్దపడ్డాము .
ఈ మాడ్యూల్ మరియు తరువాతి 3 మాడ్యూళ్ళలో, మేము వివిధ ప్రోగ్రామింగ్ ఉదాహరణల గురించి మాట్లాడుతాము మరియు సి ++ లో, ఈ ప్రోగ్రామ్ మరింత సమర్థవంతంగా మరియు తరచుగా మెరుగ్గా ఎలా చేయవచ్చో చూపిస్తాము. సి లో అవసరమయ్యే దానికంటే మంచి మార్గంలో వ్రాయవచ్చు.
2, సి మరియు సి ++ ప్రోగ్రామ్‌ల మధ్య ప్రాథమిక తేడాలను అర్థం చేసుకోవడంతో ప్రారంభిస్తాము.
మరియు మేము ఈ మాడ్యూల్‌తో పాటు ఈ క్రింది 3 మాడ్యూళ్ళకు వెళ్లేటప్పుడు సి ++ లో ప్రోగ్రామింగ్ సౌలభ్యాన్ని అభినందించడానికి ప్రయత్నిస్తాము.
మేము ప్రధానంగా IO వేరియబుల్స్, అంకగణిత లైబ్రరీ ప్రామాణిక లైబ్రరీ హెడర్స్, లూప్ మరియు బూల్ రకం ఫీల్డ్‌ల గురించి విరుద్ధంగా మాట్లాడుతాము.
కాబట్టి, మేము "హలో వరల్డ్" ను ప్రింట్ చేయవలసిన సి యొక్క ప్రారంభ ప్రోగ్రామ్తో ప్రారంభిస్తాము.
కాబట్టి, ఇక్కడ రెండు నిలువు వరుసలలో, "హలో వరల్డ్" ను సి తో పాటు సి ++ లో ప్రింట్ చేసే ప్రోగ్రామ్ ను చూపిస్తాము.
మీరు కొన్ని ప్రాథమిక తేడాలను గమనించవచ్చు, మొదట IO హెడర్ మార్చబడింది.
C లో, ఇది stdio.h; C ++ లో ఇది IO స్ట్రీమ్ అవుతుంది.
C లో, మేము printf చేసినప్పుడు, మేము కన్సోల్‌కు వ్రాస్తాము; మేము కన్సోల్‌లో ప్రింట్ చేస్తాము.
ఇక్కడ, మేము ఒక ఆపరేటర్‌ని ఉపయోగిస్తాము, స్ట్రీమింగ్ ఆపరేటర్‌ను నియంత్రించడానికి ఒక జత ఎడమ బాణం ఆపరేటర్లు అవుట్‌పుట్‌ను ప్రసారం చేస్తారు మరియు కన్సోల్ C లోని ఫైల్ స్టడౌట్, ఇది ఇప్పుడు C ++ లో ఒక కౌట్ స్ట్రీమ్.
మేము std అని పిలువబడే కౌట్ ముందు ఉపసర్గను ఉపయోగిస్తున్నామని మరియు std :: తో వ్రాసినట్లు గమనించండి.
మేము ఈ సంజ్ఞామానాన్ని త్వరగా ఉపయోగించడం అలవాటు చేసుకుంటాము, ఈ STD ని నేమ్‌స్పేస్ అంటారు; ప్రామాణిక నేమ్‌స్పేస్.
కాబట్టి, C ++ లోని ఏదైనా ప్రామాణిక లైబ్రరీ గుర్తు ఈ ప్రత్యేక ఉపసర్గ std తో ప్రిఫిక్స్ చేయబడుతుంది.
ఇప్పుడు, ఈ సరళమైన 'హలో వరల్డ్' ప్రోగ్రామ్‌లో గమనించదగ్గ మరో ముఖ్యమైన విషయం ఏమిటంటే, మనం ప్రింట్ ఎఫ్ చేసినప్పుడు, మనకు ఏకపక్ష సంఖ్యలు ఉండవచ్చు, ఈ వైవిధ్య ఫంక్షన్‌ను (ఫంక్షన్) అంటారు.
కాబట్టి, ఇక్కడ 'హలో వరల్డ్' ఉదాహరణలో మనం ప్రింట్ ఎఫ్ యొక్క రెండు ఉపయోగాలను చూస్తున్నాము, రెండూ పారామితి, ఫార్మాట్ స్ట్రీమ్ ఉపయోగించి.
వాస్తవానికి, మాకు ఇక్కడ ఫార్మాట్ లేదు; ఇది నిరంతర స్ట్రింగ్ ముద్రించబడుతోంది.
దీనికి విరుద్ధంగా, సి ++ లోని అవుట్పుట్ స్ట్రీమింగ్ ఆపరేటర్‌గా బైనరీ ఆపరేటర్‌గా మెటీరియల్ రూపంలో ఎడమ వైపు ప్రింట్ చేసి కుడి వైపున ప్రింట్ చేస్తుంది మరియు ఇది ఈ రూపంలో ప్రింట్ చేస్తుంది.
అందువల్ల, మేము మొదటి అవుట్పుట్ లైన్, std :: cout అవుట్పుట్ ఆపరేటర్ మరియు సందేహ కోట్లలో చూస్తే, మనకు స్థిరమైన స్ట్రింగ్ ఉంది. దీని అర్థం C ++ స్ట్రింగ్ (స్ట్రింగ్) హలో వరల్డ్ కన్సోల్కు ప్రసారం చేయబడుతుంది.
C లో తప్పించుకున్న కొత్త క్యూ క్యారెక్టర్ స్లాష్ n అని కూడా గమనించండి.
C ++ లో కూడా దీనిని ఉపయోగించవచ్చు, కాని ఎండల్ అని పిలువబడే కొత్త పంక్తికి వెళ్ళడానికి మరొక మార్గం ఉంది, ఇది ఎండ్ లైన్ యొక్క సంక్షిప్తీకరణ మరియు దానిపై మేము తరువాత మరింత తెలుసుకుంటాము.
ఇది, అండాల్ ప్రాథమికంగా ఒక ప్రవాహం.
కాబట్టి, ఈ దశలో మేము C ++ ప్రోగ్రామ్‌లో సిస్టమ్ కౌట్ మరియు అవుట్పుట్ ఆపరేటర్ ఉపయోగించి ప్రాథమిక అవుట్పుట్ చేయవచ్చని చూడటానికి ప్రయత్నిస్తున్నాము.
మేము తరువాతి ప్రోగ్రామ్‌కు వెళ్తాము, ఇక్కడ మేము చాలా సరళమైన అంకగణిత ప్రోగ్రామ్‌ను వివరిస్తున్నాము, ఇందులో a మరియు b అనే రెండు వేరియబుల్స్ ఉంటాయి మరియు వాటిని మన మొత్తాన్ని ఏర్పరుస్తాయి.
ఈ వేరియబుల్స్ యొక్క విలువలు C లో std అయిన కన్సోల్ నుండి చదవబడతాయి మరియు మేము అన్ని ఫార్మాట్ స్ట్రింగ్ (స్కాన్ఫ్) లో మీకు తెలిసిన స్కాన్ఫ్ ఫంక్షన్‌ను ఉపయోగిస్తాము, ఉదాహరణకు, printf అనేది ఒక వైవిధ్య ఫంక్షన్. పారామితుల వేరియబుల్ సంఖ్యలు.
ఇక్కడ, మేము 3 పారామితులను తీసుకుంటున్న స్కాన్ఫ్ యొక్క రూపాన్ని చూస్తాము; వరుసగా A మరియు B యొక్క స్ట్రింగ్ మరియు చిరునామాలను ఫార్మాట్ చేయండి.
దీనికి విరుద్ధంగా, సి ++ ప్రోగ్రామ్‌లో ఇన్పుట్ స్ట్రీమ్ నుండి స్ట్రీమింగ్ కోసం ఉపయోగించే మరొక ఆపరేటర్‌ను మేము పరిచయం చేస్తున్నాము.
కాబట్టి, దీనిని ఇన్పుట్ స్ట్రీమింగ్ ఆపరేటర్ అని పిలుస్తారు, మళ్ళీ ఒక జత బాణాలు, కానీ బాణం ఇప్పుడు ఎడమ నుండి కుడికి దర్శకత్వం వహించబడుతుంది.
కాబట్టి, మీరు ఇన్పుట్ ఆపరేటర్లో std :: cin ను చూస్తే, C చదవబడుతుందని అర్థం.
ఆసక్తికరమైన విషయం ఏమిటంటే, ఈ ఆకృతిలో C ++ లో మీరు ఇక్కడ చూపిస్తున్నట్లుగా మీరు బహుళ ఆపరేటర్లను ఒక్కొక్కటిగా అనేక వేరియబుల్స్కు చేర్చవచ్చు.
అందువల్ల, మేము ప్రామాణిక ఇన్పుట్ నుండి మళ్ళీ ప్రసారం చేసిన తరువాత, ప్రామాణిక ఇన్పుట్ నుండి బి స్ట్రీమ్ చేయండి.
కాబట్టి, ఈ సంజ్ఞామానం అంటే కన్సోల్ యొక్క ప్రామాణిక ఇన్పుట్ నుండి మొదటిది మరియు తరువాత వేరియబుల్ B చదవబడుతుంది.
ఈ వేరియబుల్స్ ప్రామాణిక స్ట్రీమింగ్ అవుట్పుట్ యొక్క అవుట్పుట్ (అవుట్పుట్) ఎలా ఉన్నాయో కూడా మేము చూపిస్తాము, ఇది సి ప్రోగ్రామ్ (ప్రోగ్రామ్) గా కౌట్ లేదా స్టడ్ అవుట్ అవుతుంది.
రెండు ప్రధాన తేడాలు ఉన్నాయి, మీరు ఇక్కడ గమనించాలి, ఒకటి మేము C ++ లో ఫార్మాట్ స్ట్రింగ్ ఉపయోగించాల్సిన అవసరం లేదు.
C లో మనకు తెలుసు, నేను ఒక పూర్ణాంక వేరియబుల్‌ను ప్రింట్ చేయాలనుకుంటే, అప్పుడు వేరియబుల్ శాతం d ఫార్మాట్‌లో ముద్రించబడాలని ఫార్మాట్ స్ట్రింగ్‌లో పేర్కొనాలి, ఇది ఒక పూర్ణాంకం C + లో ముద్రించవలసిన డేటా రకం అని సూచిస్తుంది. +, వేరియబుల్‌కు విరుద్ధంగా ఫార్మాట్‌తో పేర్కొనవలసిన అవసరం లేదు, కంపైలర్ ఇది పూర్ణాంక వేరియబుల్ అని తెలుసుకోవడం స్వయంచాలకంగా దాన్ని ప్రింట్ చేయడానికి ఫార్మాట్‌ను నిర్ణయిస్తుంది. అవసరం మరియు సరిగ్గా ప్రింట్ చేయండి.
ఈ రెండు ప్రోగ్రామ్‌ల మధ్య మీరు గమనించవలసిన మరో ప్రధాన వ్యత్యాసం ఏమిటంటే, మేము స్కాన్ చేసినప్పుడు, మేము `std in 'నుండి విలువను చదువుతున్నాము మరియు ఆ విలువను చదివిన తరువాత వేరియబుల్ యొక్క అసలు విలువను విలువకు మార్చండి వినియోగదారు ఇన్పుట్ అవుతుంది.
మేము సి యొక్క చిరునామాను పాస్ చేయాలి ఎందుకంటే ఇది సి తో సుపరిచితం.
ఈ చిరునామా వాడుతున్న యంత్రాంగం చేసిన కాల్‌కు సమానంగా ఉంటుంది, ఇక్కడ మేము వేరియబుల్ విలువను స్కాన్ఫ్ పరామితి విలువ నుండి కాల్ పరామితిగా పాస్ చేస్తాము.
దీనికి విరుద్ధంగా, మేము C ++ లో ఇన్పుట్ స్ట్రీమ్ నుండి చదువుతున్నప్పుడు, పాస్ చేయడానికి మాకు చిరునామా అవసరం లేదు; మేము వేరియబుల్స్ మాత్రమే పేర్కొనగలము మరియు కంపైలర్ మిగిలిన వాటిని చూసుకుంటుంది.
మేము సి ++ ఆపరేటర్లు మరియు కాల్ మెకానిజమ్‌ల గురించి మరింత తెలుసుకున్నప్పుడు, ఇది వాస్తవంగా ఎలా పనిచేస్తుందో మేము అర్థం చేసుకుంటాము, అయితే ఇది ఖచ్చితంగా ఫార్మాట్ స్ట్రింగ్‌తో పాటు ప్రింట్ ఎఫ్ లేదా చిరునామాలను కూడా చదివేలా చేస్తుంది.
C ++ లో, స్కాన్ఫ్ కోసం వేరియబుల్ కూడా అదే విధంగా చేయవచ్చు.
సి ప్రోగ్రామ్‌లో, వేరియబుల్ మొత్తాన్ని డిక్లరేషన్ పరంగా మీరు గమనించగల మరొక చిన్న వ్యత్యాసం, వేరియబుల్ బి మరియు బి తరువాత వేరియబుల్ ఎగువన ప్రకటించబడుతుంది, ఎందుకంటే సి 89 పేర్కొన్న అసలు సి లేదా సి యొక్క అసలు వెర్షన్ వేరియబుల్స్ యొక్క అన్ని డిక్లరేషన్లు ప్రోగ్రామ్‌లోని మొదటి ఎక్జిక్యూటబుల్ స్టేట్‌మెంట్‌కు ముందు ఉండాలి.
సి ప్రోగ్రామ్‌లో, మొదటి ఎక్జిక్యూటబుల్‌లో మనం ఇక్కడ చూస్తున్నది ప్రింట్ ఎఫ్ ఫంక్షన్ కాల్.
కాబట్టి, అన్ని వేరియబుల్స్ దీనికి ముందు ప్రకటించబడాలి.
ఈ పరిమితి C ++ లో లేదు.
కాబట్టి, మేము పేరును ప్రారంభించేటప్పుడు, మనం వేరియబుల్ ను డిక్లేర్ చేయవచ్చు మరియు మనం పేరును ప్రారంభించాల్సిన అవసరం వచ్చినప్పుడు, మనకు A మరియు B వేరియబుల్స్ అవసరం, ఎందుకంటే చదవడం అవసరం, కానీ వాటి మొత్తాన్ని మనం చేయవలసి వచ్చినప్పుడు, మేము కూడా మొత్తాన్ని ప్రకటించగలము .
వేరియబుల్ ఉపయోగించండి, ఆపై ప్లస్ బి మరియు మొత్తం విలువను ప్రారంభించడానికి మొత్తాన్ని చొప్పించండి.
వాస్తవానికి, C యొక్క తరువాతి సంస్కరణ C99 అని గమనించాలి, ఇది మీకు వేరియబుల్ అవసరమైనప్పుడు వేరియబుల్స్ యొక్క డిక్లరేషన్‌ను C ++ లోని బిందువుకు తరలించడానికి మిమ్మల్ని అనుమతిస్తుంది.
అందువల్ల, సారూప్యతలు మరియు తేడాలను బాగా అర్థం చేసుకోవడానికి దయచేసి మీ కంప్యూటర్‌లో ఈ ప్రోగ్రామ్‌ను జాగ్రత్తగా చదవండి మరియు అమలు చేయండి.
మేము మరొక ప్రోగ్రామ్‌కు వెళ్తాము, ఇది మళ్ళీ గణిత గణనను ఉపయోగించి ఒక సాధారణ ప్రోగ్రామ్, ఇది మీరు సి ప్రోగ్రామ్‌లో ఏదో ఒక సమయంలో చేశారని నేను ఖచ్చితంగా అనుకుంటున్నాను.
కాబట్టి, సి ప్రామాణిక లైబ్రరీలో భాగంగా సికి math.h హెడర్ ఉందని మాకు తెలుసు, ఇది చాలా ఉపయోగకరమైన విధులను కలిగి ఉంది.
కాబట్టి, డబుల్ వేరియబుల్ యొక్క వర్గమూలాన్ని కనుగొనడానికి sqrt అని పిలువబడే ఇలాంటి ఫంక్షన్ యొక్క ఉపయోగాన్ని ఇక్కడ చూపిస్తున్నాము.
ఇది డబుల్ వేరియబుల్ తీసుకుంటుంది మరియు డబుల్ ఫలితాన్ని ఇస్తుంది, ఇది చదరపుకి పంపబడిన పరామితి యొక్క వర్గమూలం.
అదే ఫంక్షన్ C ++ లో కూడా అమలు చేయవచ్చు.
కాబట్టి, దీన్ని ఎలా చేయాలో మేము చూపిస్తున్నాము, కాబట్టి దయచేసి C ++ లో మనం ఉపయోగించే హెడర్ పేరు మార్చబడింది.
సి లో మేము దీనిని math.h అని పిలుస్తున్నాము.
అదే శీర్షికను C ++ లో cmath అని పిలుస్తారు మరియు ఇది ఏదైనా ప్రామాణిక లైబ్రరీ హెడర్‌ను C ++ లో ఉపయోగించవచ్చని ఒక సాధారణ సమావేశం అని మేము చూస్తాము, కానీ మీరు దానిని ఉపయోగించినప్పుడు, మీరు పేరు ప్రారంభంలో ఒక C ని జోడిస్తారు.
సి అంటే ప్రామాణిక లైబ్రరీ హెడర్ సి స్టాండర్డ్ లైబ్రరీ నుండి వస్తున్నదని మరియు ఇతర వ్యత్యాసం ఏమిటంటే మీరు సి లోని ఫైల్ పేరు కోసం డాట్ హెచ్ ఎక్స్‌టెన్షన్‌ను వదిలివేస్తారు, మీరు దానిని సమ్మత్ అని పిలుస్తారు.
వాస్తవానికి, మనం ఇంతకుముందు చెప్పినట్లుగా, కౌట్ మరియు ఎండ్ల్ పేర్ల పరంగా, ఇవి కూడా అదే నేమ్‌స్పేస్‌లో (నేమ్‌స్పేస్) std వలె ఉన్నాయి, అంటే C లోని ఫంక్షన్ (ఫంక్షన్) sqrt నుండి sqrt C ++ ++ లో, ఫంక్షన్ పేరు (sq) sqrt, std తో ఉపసర్గ అవుతుంది, దీని పూర్తి పేరు std :: sqrt.
ఇప్పుడు, ఇక్కడ మేము ప్రామాణిక లైబ్రరీ చిహ్నాలను వ్యక్తీకరించడానికి మరొక షార్ట్ కట్ లేదా అనుకూలమైన మార్గాన్ని కూడా చూపిస్తాము, C ++ ప్రోగ్రామ్‌లో హాష్ చేర్చబడిన తరువాత, మేము నేమ్‌స్పేస్‌ను కలిగి ఉన్న ఒక పంక్తిని వ్రాసాము. Std ఉపయోగించబడుతుంది.
దీని అర్థం మనం ఈ పంక్తిని చేర్చుకుంటే, C ++ ప్రోగ్రామ్ (ప్రోగ్రామ్) లోని ఏదైనా ప్రామాణిక లైబ్రరీ చిహ్నం ఉపసర్గగా పరిగణించబడుతుంది, std :: cout, std :: cin., Std :: endl or std: : చ.
కాబట్టి, దీన్ని చేయడానికి అనుకూలమైన మార్గం ఏమిటంటే, మీరు సి ++ లో నేమ్‌స్పేస్ లక్షణాన్ని ఉపయోగించవచ్చు లేదా మీరు దానిని ఉపయోగించకపోతే, అన్ని ప్రామాణిక లైబ్రరీ చిహ్నాలను std :: ఉపసర్గ చేయండి.
మిగిలిన ప్రోగ్రామ్ అర్థం చేసుకోవడం చాలా సులభం మరియు మీరు ఎడమ వైపున చూసే ప్రోగ్రామ్ లాగా ఉంటుంది. మార్పులు స్ట్రీమింగ్ ఇన్పుట్ మరియు అవుట్పుట్కు అనుగుణంగా ఉంటాయి, మేము ఇప్పటికే చేసినట్లుగా. చూశాము.
కాబట్టి, మేము దీనితో ముందుకు వెళ్లి C ++ ప్రామాణిక లైబ్రరీని పరిశీలిస్తాము.
సంగ్రహంగా చెప్పాలంటే, సి స్టాండర్డ్ లైబ్రరీలోని అన్ని పేర్లు గ్లోబల్ అని నేను ఇప్పటికే పేర్కొన్నది, ఇవన్నీ ప్రామాణిక లైబ్రరీ ఫంక్షన్లు, మాక్రోలు; అవి ఆ పేరుతో ఏదైనా ఫంక్షన్ కోసం అందుబాటులో ఉంటాయి.
కాబట్టి, అన్ని సి ప్రామాణిక లైబ్రరీ పేర్లు వాస్తవానికి అన్ని ఆచరణాత్మక ప్రయోజనాల కోసం మీరు మీ స్వంత ప్రింట్ ఎఫ్ ఫంక్షన్ మరియు సి స్టాండర్డ్ లైబ్రరీ (ఫంక్షన్) ను వ్రాయలేని విధంగా రిజర్వు చేయబడ్డాయి ఎందుకంటే మీరు లైబ్రరీలో ఇచ్చిన ప్రింట్ ఎఫ్ ఫంక్షన్‌ను ఉపయోగించడం కొనసాగించవచ్చు) ఎందుకంటే ఈ క్షణం మీరు మీ స్వంత ప్రింట్ ఎఫ్ ఫంక్షన్‌ను వ్రాస్తారు, అది కూడా గ్లోబల్ స్పేస్ లో పేరు.
మీరు C ++ లో నేమ్‌స్పేస్‌ల గురించి అధికారికంగా అధ్యయనం చేసినప్పుడు, మీరు దీన్ని మరింత అర్థం చేసుకుంటారు, కాని దయచేసి అన్ని పేర్లు ప్రపంచవ్యాప్తంగా అందుబాటులో ఉన్నాయని గమనించండి.
దీనికి విరుద్ధంగా, C ++ ప్రామాణిక లైబ్రరీలోని అన్ని పేర్లు std నేమ్‌స్పేస్‌లో ఉన్నాయి.
ఇది ప్రత్యేకంగా నేమ్‌స్పేస్‌లు మరియు అన్ని పేరు ఉపసర్గలతో కూడిన ప్రామాణిక లైబ్రరీ నేమ్‌స్పేస్‌ల కోసం ప్రత్యేకించబడింది :: అంటే ఈ పేరు ఈ స్టేడ్ నేమ్‌స్పేస్‌లోనే సంభవిస్తుంది.
అందువల్ల, నేమ్‌స్పేస్ అంటే మన స్వంత పేర్లను ఉపయోగించినప్పుడు ఏమి జరుగుతుంది, ఇది మేము ఉపయోగించే కుటుంబ పేరు లేదా చివరి పేరు వంటిది.
అందువలన, నేను పార్థా ప్రతిమ దాస్.
కాబట్టి, దాస్ నా చివరి పేరు మరియు నా పేరు పార్థ్.
అందువల్ల, మరికొన్ని కుటుంబ పేర్లలో మరొక పార్థా ఉండవచ్చు అని పార్థా ప్రతిం చక్రవర్తి పేర్కొంది.
కాబట్టి, ఇవి ఉన్న వివిధ కుటుంబ పేర్లకు భిన్నంగా ఉంటాయి.
కాబట్టి, పేరు స్థలం దీనికి సమానంగా ఉంటుంది.
దీని గురించి మేము తరువాత మాట్లాడుతాము.
కాబట్టి, మీరు ఇక్కడ std ని ఉపయోగించి పేరు ఖాళీలను చిన్నగా కత్తిరించినట్లయితే, మీరు అన్ని ప్రామాణిక లైబ్రరీ పేర్లను ఆ std :: నేమ్‌స్పేస్‌తో ప్రిఫిక్స్ చేయనవసరం లేదు.
ఇప్పుడు, ప్రామాణిక లైబ్రరీ యొక్క శీర్షిక గురించి చాలా ప్రత్యేకమైనదాన్ని హైలైట్ చేయాలనుకుంటున్నాను.
కాబట్టి, సి ++, సి అంటే దాని అర్థం అని మేము గుర్తించాము; అంటే ఏదైనా సి ప్రోగ్రామ్‌ను సి ++ ప్రోగ్రామ్‌గా కూడా అమలు చేయాలి.
సి యొక్క ప్రామాణిక లైబ్రరీతో మేము ఏమి చేస్తాం అనేదానికి ఇది మరొక ప్రశ్నను తెస్తుంది, సి యొక్క ప్రామాణిక లైబ్రరీని సి ++ ప్రోగ్రామ్‌లో కూడా ఉపయోగించవచ్చని నేను ఇప్పటికే స్పష్టం చేశాను, అయితే ప్రోగ్రామ్‌ను మిళితం చేయడానికి మీకు ఒక చిన్న విషయం C ++ నుండి ప్రోగ్రామ్‌కు ప్రామాణిక లైబ్రరీ హెడర్‌ను మీరు ఎలా పేర్కొంటారు.
కాబట్టి, మీరు దీన్ని ఎడమ వైపున ఎలా చేయవచ్చో ఈ పట్టిక మీకు చూపుతుంది, మీరు ప్రోగ్రామ్‌ను వ్రాస్తున్న భాషలో మరియు మేము శీర్షికను చూపిస్తున్న కాలమ్‌లో ఏ ప్రామాణిక లైబ్రరీలో మేము శీర్షికను చూపిస్తున్నాము. ఇది సి నుండి లేదా సి ++ నుండి.
కాబట్టి, మీరు సి ప్రోగ్రామ్ వ్రాస్తుంటే మరియు మీరు సి స్టాండర్డ్ లైబ్రరీ హెడర్ ఉపయోగిస్తుంటే, మీరు stdio.h లాగా చేరతారని మాకు తెలుసు.
మీరు సి ++ ప్రోగ్రామ్‌ను వ్రాస్తూ, సి స్టాండర్డ్ లైబ్రరీ హెడర్‌ను కలిగి ఉంటే, నేను చెప్పినట్లుగా, మీరు సి స్టాండర్డ్ లైబ్రరీ పేరును సి తో ప్రిఫిక్స్ చేయాలి.
అందువల్ల, stdio.h ఇప్పుడు C stdio గా మారింది మరియు మీరు ప్రామాణిక లైబ్రరీ నుండి dot h మరియు C నుండి పేరును వదలాలి ఈ చిహ్నాలన్నీ ఇప్పుడు std నేమ్‌స్పేస్ (నేమ్‌స్పేస్) లో పొందుతాయి మరియు మనకు std తో ఉపసర్గ లభిస్తుంది :: కలిగి ఉండాలి చేయండి.
మీరు C ++ ప్రోగ్రామ్‌ను వ్రాసి, C ++ ప్రామాణిక లైబ్రరీని కలిగి ఉంటే, మీరు దానిని హాష్ IO స్ట్రీమ్‌గా మాత్రమే చేర్చారు.
C ++ లోని అన్ని ప్రామాణిక లైబ్రరీ హెడర్‌లకు వాటి ఫైల్ ఎక్స్‌టెన్షన్స్‌లో డాట్ హెచ్ లేదు, ఇది ఒక చారిత్రక కారణం, నేను తరువాతి దశలో వివరించడానికి ప్రయత్నిస్తాను, కాని దయచేసి IO స్ట్రీమ్‌లు ఉండకూడదని గమనించండి.
మరియు చేర్చకూడదు.
ఈ మాతృకలోని చివరి పెట్టె మీరు సి ప్రోగ్రామ్ వ్రాస్తున్నప్పుడు మరియు మీరు సి ++ హెడర్‌ను ఉపయోగించాలనుకుంటే, అది ఖచ్చితంగా వర్తించదు ఎందుకంటే మీరు సి ++ లో చాలా ఫీచర్లు చేయలేరు. సి మద్దతు ఇవ్వనివి మరియు కాబట్టి, ఉపయోగించబడదు.
ముఖ్యంగా గమనించండి మరియు నేను ఎరుపు రంగులో హైలైట్ చేసాను, పొరపాటున లేదా సి లో ప్రామాణిక లైబ్రరీ (లైబ్రరీ) శీర్షికల కోసం డాట్ హెచ్ ను ఫైల్ నేమ్ ఎక్స్‌టెన్షన్‌గా ఉపయోగించడం ద్వారా.
మీరు I ++ స్ట్రీమ్‌ను కలిగి ఉంటే.
C ++ ప్రోగ్రామ్‌లో, మీ కంపైలర్ నిజంగా మీకు లోపం ఇవ్వదు అంటే మీ కంపైలర్ నిజంగా నాటిది మరియు మీరు ఇటీవల కంపైలర్‌కు వెళ్లాలి మరియు అందువల్ల ఇది చాలా ప్రమాదకరమైన ప్రతిపాదన. ఎందుకంటే మీరు పొరపాటు చేస్తున్నారు IO stream.h లేదా హెడర్ డాట్ h తో ఉన్న పదార్థం పొడిగింపు ఫైళ్ళ కోసం ఏదైనా C ++ ప్రామాణిక లైబ్రరీ, ఇవన్నీ వర్ణించబడ్డాయి.
అవి పెద్దగా ఉపయోగంలో లేవు, అయితే కొన్ని కంపైలర్లు సి ++ ప్రమాణంలో తయారు చేయబడటానికి ముందే వ్రాయబడినందున వాటిని అనుమతించడం కొనసాగిస్తున్నాయి.
కాబట్టి, దయచేసి ప్రామాణిక లైబ్రరీ శీర్షికల యొక్క ఈ సమావేశాలను గుర్తుంచుకోండి.
తరువాత, మీ సి. లూప్‌ల వాడకంపై మేము దృష్టి పెడతాము.
చాలా పోలి ఉంటాయి.
అందువల్ల, మేము 0 నుండి ప్రారంభమయ్యే అంకెల క్రమాన్ని మాత్రమే ఇక్కడ జోడిస్తున్నాము.
n మరియు లూప్ కోసం వాటిని చేర్చండి.
IO శీర్షికలు మరియు కౌట్ స్ట్రీమింగ్ సమావేశాలలో తేడాలు మినహా ఇలాంటి ప్రోగ్రామ్‌లు C ++ కోసం దాదాపు సమానంగా పనిచేస్తాయి.
లూప్ లూప్ సూచికల కోసం, కుండలీకరణాల్లో నన్ను 'నిర్మించు' అని ప్రకటించవచ్చు.
మీరు ఇలా చేస్తే, నేను ఈ డిక్లరేషన్ లూప్‌కు స్థానికంగా ఉంటుంది, మీరు లూప్ కోసం బయటకు వచ్చిన తర్వాత మీరు తరువాత మంచం స్టేట్‌మెంట్‌లో ఉన్నారు లేదా నేను తరువాత ప్రకటించబడను.
కాబట్టి, ఇది ప్రవేశపెట్టబడింది, తద్వారా మీకు స్థానిక ఇండెక్స్ వేరియబుల్స్ అవసరమైనప్పుడు మీరు వాటిని త్వరగా స్థానికంగా ఉపయోగించుకోవచ్చు మరియు మీరు ఆ వేరియబుల్‌ను ఇంతకు ముందు ప్రకటించారా లేదా అనే దాని గురించి నిజంగా ఆలోచించకండి, అది మరొక సందర్భంలో ఉపయోగించబడుతుందా లేదా అనే దాని గురించి నిజంగా ఆలోచించవద్దు.
మీరు వాటిని స్థానికంగా మాత్రమే ప్రకటించవచ్చు మరియు వాటిని C ++ లో ఉపయోగించవచ్చు.
C89 లో ఇది సాధ్యం కాలేదు, కానీ ఇప్పుడు C99 లో కూడా ఇది సాధ్యమే.
చివరగా, ఈ మాడ్యూల్ యొక్క చివరి భాగంలో, మేము బూలియన్ రకాన్ని ఉపయోగించడాన్ని వివరిస్తాము.
సి బూలియన్ రకాన్ని ఉపయోగించుకునే అవకాశం ఉందని మనందరికీ తెలుసు, ఇది ఒక రకం, ఇది నిజమైన లేదా తప్పుడు విలువను తీసుకోగలదని మేము చెబుతున్నాము.
ఇప్పుడు, సి ఇది సి 89, అసలు పాత సి మనకు బూల్ కోసం వేరే రకం లేదు.
కాబట్టి, అది ఏమిటంటే, అది బూల్‌ను అర్థం చేసుకోవడానికి పూర్ణాంకాన్ని ఉపయోగిస్తోంది, మీరు బూలియన్ స్థానం లేదా బూలియన్ విలువను ఏ ప్రదేశంలో ఉంచాలనుకుంటున్నారో, మీరు తేడా వేరియబుల్‌ను ప్రకటిస్తారు. మరియు 0 అని సెట్ చేయండి, మీరు తప్పుడు అర్థం చేసుకోవాలనుకుంటే మరియు కానిదాన్ని సెట్ చేయండి -జెరో, మనం నిజం అని అనుకుంటే.
అందువల్ల, ఈ 3 నిలువు వరుసలలో, మీరు ఎడమ వైపు చూస్తే, సి ప్రోగ్రామ్ బూలియన్‌తో పనిచేస్తున్న అత్యంత సాధారణ మార్గం ఏమిటంటే, సౌలభ్యం కోసం మీరు రెండు స్థిరాంకాలను నిర్వచించవచ్చు; 1 మరియు 0 కలిగి ఉండటం మరియు వాటిని మీ ప్రోగ్రామ్‌లో ఉపయోగించడం నిజం మరియు తప్పు, కానీ నేను చూపించినట్లుగా బూలియన్ స్థానానికి ఉపయోగించే వేరియబుల్ x వ్యత్యాస రకంగా ప్రకటించబడింది. పూర్తయింది మరియు ఇది సత్యంతో ప్రారంభమైంది..
కాబట్టి, మీరు ప్రింట్ చేస్తే దాని విలువ 1 అని చూపిస్తుంది; ఇది C89 లో ఉంది.
తదనంతరం, C99 లో, బూల్ రకాన్ని ప్రవేశపెట్టడానికి మార్పు చేయబడింది.
ఇప్పుడు, దీనిని చూడటానికి ముందు, మొదట కుడివైపు కాలమ్ చూద్దాం, ఇది C ++ ప్రోగ్రామ్.
C ++ లో మీకు అంతర్నిర్మిత రకంగా బూల్ ఉంది, మీకు పూర్ణాంకం, చార్, ఫ్లోట్, డబుల్ ఉన్నాయి.
అదేవిధంగా, మీకు బూల్ రకం ఉంది, ఈ బూల్ రకం కేవలం రెండు అక్షరాస్యులు; చిన్న కేసులో నిజం మరియు తప్పు రెండూ.
అందువల్ల, ఆ కీలకపదాలు ఇప్పటికీ రిజర్వు చేయబడ్డాయి.
కాబట్టి, మీరు బూలియన్ వేరియబుల్‌గా ఉపయోగించడానికి x ను సమానంగా నిర్వచించాలనుకుంటే, మీరు నేరుగా బూల్‌ని ఉపయోగించవచ్చు, ఇది మీరు నిజంగా బూలియన్ అని అర్థం చేసుకోవడం చాలా సులభం. విలువతో పనిచేయడం మరియు మీరు దానిని నిజమైన లేదా తప్పుడుతో ప్రారంభించవచ్చు, కానీ మీరు ఈ వేరియబుల్ యొక్క విలువను ప్రింట్ చేయడానికి ప్రయత్నిస్తే, అది నిజం లేదా తప్పు అని ముద్రించదు, వాస్తవానికి ఇది 1 లేదా 0 ను ప్రింట్ చేస్తుంది) విల్, అది నిజమైతే అది 1 మరియు 0 లేకపోతే.
సహజంగానే, నిర్మించిన రకాన్ని స్పష్టంగా మరియు స్పష్టంగా ఉపయోగించుకోవడంలో చాలా ప్రయోజనాలు ఉన్నాయి.
వీటిలో చాలా ముఖ్యమైనది C ++ ప్రోగ్రామ్ నుండి, మీరు మీ బూలియన్ విలువను పేర్కొనడానికి బూల్ ఉపయోగించినట్లయితే, అప్పుడు ప్రోగ్రామ్ చదివే ఎవరైనా దానిని అర్థం చేసుకోవచ్చు.ఈ వేరియబుల్ నిజమైన లేదా తప్పుడు తప్ప వేరే విలువను తీసుకోలేరని అనుమతిస్తుంది.
దీనికి విరుద్ధంగా, మేము బూలియన్ విలువ కోసం పూర్ణాంకాన్ని ఉపయోగించే సి శైలిని ఉపయోగిస్తే, అది వాస్తవానికి చాలా భిన్నమైన విలువలను నిజం లేదా తప్పు అని అర్ధం చేసుకోవచ్చు. ఆమె వెళుతుంది.
ఇప్పుడు, మధ్య కాలమ్‌లో, C99 ఎవరితో వచ్చారో C99 ప్రమాణంలో C ప్రోగ్రామింగ్ భాష యొక్క ఆసక్తికరమైన పొడిగింపును చూస్తాము.
C99 ఒక స్పష్టమైన బూలియన్ రకాన్ని ప్రవేశపెట్టింది మరియు దీనికి అండర్ స్కోర్ బూల్ అని పేరు పెట్టారు, ఇక్కడ B మూలధనంలో వ్రాయబడింది, అయితే ఇది బూల్ ఇస్ రాయడానికి చాలా సాధారణమైన సహజ మార్గం కానందున, ఇది stdbool.h అనే కొత్త ప్రామాణిక లైబ్రరీ హెడర్‌ను కూడా అందించింది. మాక్రోలు అందించబడతాయి.
మొదటి స్థూల లోయర్ కేసులో బూల్‌ను నిర్వచిస్తుంది మరియు అండర్ స్కోర్ క్యాపిటల్ బూల్‌తో సమానంగా ఉంటుంది.
కాబట్టి, మేము C99 ప్రోగ్రామ్‌లో దిగువ కేసులో బూల్ ఉపయోగిస్తే, మీరు నిజంగా ఆ కొత్త ముందే నిర్వచించిన రకమైన అండర్ స్కోర్ క్యాపిటల్ బూల్ (బూల్) ను ఉపయోగిస్తున్నారు మరియు ఇది 1 మరియు 0 గా హెడర్‌లో ఉంది నేను సరైనది మరియు తప్పు అని నిర్వచించాను, తద్వారా మీరు దీన్ని స్థిరంగా ఇక్కడ ఉపయోగించండి.
అందువల్ల, మనం ఉంటే; మీరు సి ఉపయోగిస్తున్నప్పుడల్లా, మీరు ఎల్లప్పుడూ బూల్ అని టైప్ చేయాలి మరియు పూర్ణాంకానికి వాడకండి మరియు దానిని బూల్ రకంగా అర్థం చేసుకోవాలి. సి ++ లో ఇది ఖచ్చితంగా నిర్మించబడింది- ఈ రకాలు రూపంలో వస్తుంది.
కాబట్టి, దీనికి అనేక ఇతర ప్రయోజనాలు ఉన్నాయని మేము ఎత్తి చూపాము మరియు అదే సమయంలో మేము వివిధ రకాలతో వెళ్తాము.
కాబట్టి ఈ మాడ్యూల్‌లో, సి మరియు సి ++ మధ్య ప్రాథమిక వ్యత్యాసాన్ని అర్థం చేసుకోవడానికి ప్రయత్నించాము; మీరు ఇన్‌పుట్‌ను ఎలా అవుట్పుట్ చేస్తారు? మీరు వేరియబుల్ ఎలా ప్రకటిస్తారు? C ++ లో C మరియు C ++ యొక్క ప్రామాణిక లైబ్రరీ ఎలా ఉపయోగించబడుతుంది? C ++ మనకు ఎలా ప్రకటించగలదో మరియు ఎలా అవుట్పుట్ చేయగలదో మాకు మరింత సౌలభ్యాన్ని ఇస్తుందని చూడటం ప్రారంభించాము.
ఇప్పుడు, ఆ సంక్లిష్టమైన printf స్టేట్‌మెంట్‌లు, ఫార్మాట్‌లు వేర్వేరు తీగలలో ఉన్న స్ట్రీమ్ ప్రింట్ ఎఫ్ (ప్రింట్ ఎఫ్) ఫంక్షన్ (ఫంక్షన్) కాల్స్ మాకు అవసరం లేదు, వేరియబుల్స్ విడిగా జాబితా చేయబడతాయి.
స్కాన్ఫ్‌కు వేరియబుల్స్ మరియు సారూప్య చిరునామాలు అవసరమని మనం గుర్తుంచుకోవాల్సిన అవసరం లేదు మరియు ఈ విధంగా సి ++ లో చాలా నిర్మాణాలు మరియు విధులు సరళీకృతం చేయబడ్డాయి, ఇవి ప్రోగ్రామింగ్‌ను పెంచడానికి సహాయపడతాయి.
inhouse/NPTEL/PreFinal/c++/Telugu/08. ProgramminginCplusplus_Stack and its Applications (Lecture 07)-aG0HjeXBUDU.txt
View file @ 956c0d4e
 1. C ++ ప్రోగ్రామింగులో  మాడ్యూల్ 5 కు స్వాగతం.
2. మీరు సాధారణంగా సి లో వ్రాసిన వివిధ ఉదాహరణ ప్రోగ్రామ్‌లను మేము చర్చిస్తున్నాము మరియు ఇప్పుడు వాటిని సి ++ లో ఎలా వ్రాయవచ్చో చూపిస్తున్నాము.
3. దీని కోసం సి ++ ప్రామాణిక లైబ్రరీని ఎంత తరచుగా ఉపయోగించవచ్చో మరియు దీనితో, సి ++ ప్రోగ్రామింగ్ సౌలభ్యాన్ని ఎలా పెంచుతుందో చూపించాలనుకుంటున్నాము.
4. కాబట్టి, ఈ మాడ్యూల్‌లో మనం స్టాక్‌లు మరియు దాని అనువర్తనాల గురించి మాట్లాడుతాము.
5. సి లో స్టాక్ అమలు మరియు వాడకాన్ని అర్థం చేసుకోవడానికి మేము ప్రయత్నిస్తాము, ఇది మీ అందరికీ తెలుసు, ఆపై సి ++ లో ప్రామాణిక స్టాక్ లైబ్రరీని ఎలా ఉపయోగించవచ్చో చూపిస్తాము.
6. అందువల్ల, ఇవి స్ట్రింగ్ (స్ట్రింగ్) ను రివర్స్ చేయడం ద్వారా పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను ఉదాహరణగా అంచనా వేసే అంశాలు.
7. స్టాక్ పరిచయంపై, రీక్యాప్ చేయడానికి.
8. స్టాక్ అనేది LIFO నిర్మాణం; డేటా అంశాల యొక్క ఏకపక్ష సంఖ్యల సేకరణను నిర్వహించే చివరి-మొదటి-మొదటి కంటైనర్.
9. శ్రేణిలో పరిమితులు లేవు; శ్రేణుల పరిమాణాన్ని బట్టి నేను ఎన్ని అంశాలను ఉంచగలను అనే దానిపై పరిమితులు ఉన్నాయి.
10. ఎటువంటి నిర్వచనం లేకుండా స్టాక్ చేయండి, స్టాక్‌లో ఉండే అన్ని ఎలిమెంట్ డేటా ఎలిమెంట్స్ ఒకే రకంగా ఉండాలి, కాని నేను ఎన్ని మూలకాలను కలిగి ఉంటాను.
11. కాబట్టి, సి లో స్టాక్ చేయడానికి, మనం చేయాలి; ఇవి మనం అనుసరించాల్సిన సాధారణ దశలు.
12. మొదట మనం మూలకం యొక్క డేటా రకాన్ని నిర్ణయించాలి, ఒక నిర్మాణం లేదా కంటైనర్‌ను నిర్వచించాలి, వాస్తవానికి సి లో మనం కొంత గరిష్ట పరిమాణాన్ని ఉపయోగించాల్సి ఉంటుంది, లేకపోతే సి కంపైలర్ దీనిని నిర్వచించటానికి అనుమతించదు, శీర్షాన్ని ప్రకటించండి స్టాక్ (స్టాక్) పైభాగాన్ని నిర్వహించే వేరియబుల్ మరియు ఆ స్టాక్ (స్టాక్) యొక్క ఆపరేషన్ కోసం అవసరమైన నాలుగు ఫంక్షన్లను వ్రాయాలి.
13. ఫంక్షన్ పుష్, ఇది స్టాక్‌కు ఒక మూలకాన్ని జోడిస్తుంది; ఫంక్షన్ పాప్, ఇది అగ్ర మూలకాన్ని తొలగిస్తుంది, మూలకం చివరిగా జోడించబడింది; ఫంక్షన్ టాప్, ఇది తీసివేయకుండా నాకు చాలా ఎక్కువ మూలకాన్ని ఇస్తుంది, చివరకు, మనకు ఒక ఫంక్షన్ (ఫంక్షన్) isempty () లేదా ఖాళీగా ఉండాలి, ఇది స్టాక్ (స్టాక్) లో ఏదైనా మూలకాలను కలిగి ఉంటే నాకు తెలియజేస్తుంది. కాదు.
14. కాబట్టి, isempty () నిజమైతే, పాప్ మరియు టాప్ వంటి ఆపరేషన్లు చెల్లవు ఎందుకంటే తొలగించడానికి లేదా తిరిగి రావడానికి అగ్ర మూలకం లేదు.
15. అందువల్ల, మేము స్టాక్ కోసం మూలకాల రకాన్ని మార్చిన వెంటనే, మనం తిరిగి దరఖాస్తు చేసుకోవాలి, స్టాక్ యొక్క మొత్తం కోడ్‌ను తిరిగి వ్రాయాలి, ఇది పూర్ణాంకం యొక్క స్టాక్. (స్టాక్) కోసం కోడ్ స్టాక్, మరియు స్టాక్ (స్టాక్) కోసం కోడ్ తీగలను స్టాక్ భిన్నంగా ఉంటుంది, అయినప్పటికీ LIFO యొక్క ప్రాథమిక umption హ రెండు సందర్భాల్లోనూ చెల్లుతుంది.
16. కాబట్టి, సి స్టాండర్డ్ లైబ్రరీలో మనకు ఉన్న ఈ ఫంక్షన్లన్నింటికీ కాకుండా, గణితంలో మనం ఇంతకుముందు చూశాము, మనకు చాలా లైబ్రరీ ఫంక్షన్లు ఉన్నాయి.
17. కాబట్టి, నేను గుర్తును లెక్కించాలనుకుంటే లేదా వర్గమూలాన్ని లెక్కించాలనుకుంటే లేదా ఆర్క్టాన్‌ను లెక్కించాలనుకుంటే, నేను ఆ ఫంక్షన్‌ను (ఫంక్షన్) వ్రాయవలసిన అవసరం లేదు, నేను దానిని లైబ్రరీ నుండి మాత్రమే ఉపయోగించగలను.
18. దీనికి విరుద్ధంగా, సి స్టాండర్డ్ లైబ్రరీ నాకు స్టాక్‌ను ఉపయోగించటానికి ఒక యంత్రాంగాన్ని ఇవ్వదు.
19. నేను వెంటనే ఉపయోగించగల స్టాక్ నాకు ఇవ్వదు.
20. కాబట్టి, సి ప్రోగ్రామింగ్‌తో ప్రస్తుత పరిస్థితుల పరిస్థితి ఇది.
21. కాబట్టి, ఈ సందర్భంలో, మీరు C ++ ఉపయోగిస్తే విషయాలు ఎలా మారతాయో చూడటానికి మేము ప్రయత్నిస్తాము.
22. కాబట్టి, స్టాక్ ఉపయోగించి పరిష్కరించడానికి మేము ప్రయత్నించిన కొన్ని సాధారణ సమస్యలపై కూడా దృష్టి పెడదాం.
23. నేను ఎడమ నుండి కుడికి క్రమంలో ఉన్న స్ట్రింగ్‌ను రివర్స్ చేయాలనుకుంటున్నాను, ఇది ఎడమ నుండి కుడికి మార్చాలనుకుంటున్నాను ఒక నిర్దిష్ట ప్రోగ్రామ్.
24. మరొక పోస్ట్‌ఫిక్స్ అనేది వ్యక్తీకరణల మూల్యాంకనం, ఆపరేటర్లు ఒపెరాండ్ల మధ్య ఉన్న చోట మేము సాధారణంగా వ్యక్తీకరణలను అఫిక్స్ సంజ్ఞామానం తో వ్రాస్తాము.
25. కాబట్టి, నేను ఈ వ్యక్తీకరణను అంచనా వేయాలనుకుంటే 1 + 2 * 3 - 4 ఉదాహరణను చూపిస్తున్నాను; మేము వ్యక్తీకరణను ఎడమ నుండి కుడికి చదివినప్పటికీ, దాన్ని అంచనా వేయడానికి వెళ్ళినప్పుడు మనం దానిని ఎడమ నుండి కుడికి ఖచ్చితంగా అంచనా వేయలేము.
26. నక్షత్రం గుణకారం అదనంగా మరియు వ్యవకలనం కంటే ఎక్కువ ప్రాధాన్యతనిస్తుందని మాకు తెలుసు.
27. కాబట్టి, మొదట మనం 2 తో 3 తో ​​గుణించాలి, ఫలితం 6 ను పొందాలి, ఆపై మనకు ప్లస్ మరియు మైనస్ ఉన్నాయి, ఇవి రెండూ ఒకే పూర్వజన్మను కలిగి ఉంటాయి, కానీ అవి అనుబంధంగా ఉంటాయి.
28. అందువల్ల, మనం ఎడమ నుండి కుడికి కదిలి, ఫలితం 3 అవుతుందని లెక్కించాలి.
29. కాబట్టి, మనం వ్యక్తీకరణను ఎలా వ్రాస్తామో పరంగా ఇన్ఫిక్స్ సంజ్ఞామానం చాలా మంచిది.
30. ఈ వ్యక్తీకరణలను వ్రాయడానికి మరియు దానిని అంచనా వేయడానికి BODMAS నియమాలను అనుసరించడానికి మా పాఠశాల రోజుల నుండి మాకు నేర్పించాం, కాని పోస్ట్‌ఫిక్స్ వ్యక్తీకరణలను అంచనా వేయడం చాలా కష్టమవుతుంది ఎందుకంటే ఆపరేటర్ల క్రమాన్ని అమలు చేయాలి, ఇది అసోసియేషన్ ఆధారంగా వారి ప్రాధాన్యత.
31. అందువల్ల, మేము పోస్ట్ఫిక్స్ సంజ్ఞామానం అని పిలువబడే వేరే సంజ్ఞామానాన్ని ఆశ్రయిస్తాము.
32. పోస్ట్‌ఫిక్స్ సంజ్ఞామానం లో, ఇది మొదట ఒపెరాండ్ పేర్కొనబడి, ఆపై ఆపరేటర్ వస్తాడు. అందుకే ఇది పోస్ట్‌ఫిక్స్.
33. కాబట్టి, నాకు సి ఆపరేటర్ ఉంటే, దాని కోసం ఒపెరాండ్ ఇప్పటికే జరిగింది.
34. కాబట్టి, ఆపరేటర్‌కు శ్రేణి 2 ఉంటే, ఆ ఆపరేటర్‌కు 2 ఆపరేటర్ ఒపెరాండ్‌లు వెంటనే వర్తింపజేయాలని నాకు తెలుసు.
35. కాబట్టి, ఇక్కడ ఇచ్చిన సమాచారంతో భర్తీ చేయబడిన ఈ వ్యక్తీకరణను నేను చూస్తే, నా వ్యక్తీకరణ 1 2 3 * + 4 - మరియు ఇది ఇన్ఫిక్స్ను ఎలా మార్చాలో కూడా ఒక సమస్య అని మీరు చూడగల ఉదాహరణను ఇక్కడ చూపిస్తాము. వ్యక్తీకరణ ఉపసర్గ వ్యక్తీకరణకు.
36. ఇది స్టాక్‌ను ఉపయోగించి కూడా పరిష్కరించవచ్చు, కాని ఇక్కడ పోస్ట్‌ఫిక్స్ వ్యక్తీకరణ ఇచ్చినట్లయితే, స్టాక్‌ను ఉపయోగించి దాన్ని ఎలా అంచనా వేస్తామో చూపిస్తాము.
37. కాబట్టి, ఇవన్నీ మనం చేయగలిగినవి చేయగల వేర్వేరు స్టాక్‌లు; వ్యక్తీకరణను ఎడమ నుండి కుడికి స్కాన్ చేయండి, ఉచిత ఒపెరాండ్ తీసుకోండి, దాన్ని స్టాక్‌లోకి చొప్పించండి, మేము ఆపరేటర్‌లోకి వచ్చే వరకు స్టాకింగ్ ఉంచండి.
38. కాబట్టి, ఇక్కడ మనం 1 పుష్ (పుష్) ఇస్తాము, తరువాత మనం 2 పుష్ (పుష్) ఇస్తాము, తరువాత 3 పుష్ (పుష్) ఇస్తాము, ఆపై 2 నిర్వచనాలు ఉన్న ఆపరేటర్ స్టార్ వద్దకు వస్తాము.
39. కాబట్టి, దీనికి చివరి 2 ఒపెరాండ్ అవసరమని నాకు తెలుసు, మేము ఈ 2 ని పాప్ చేస్తాము.
40. 3 శక్తిని పొందడానికి 6 ను పొందండి మరియు దానిని వెనక్కి నెట్టండి.
41. అప్పుడు మనకు ప్లస్ నెక్స్ట్ ఆపరేటర్ వస్తుంది.
42. అందువల్ల, రెండు ఒపెరాండ్‌లు కూడా అవసరమని మాకు తెలుసు.
43. కాబట్టి, మేము 6 మరియు 1 ని పాప్ చేస్తాము, స్టాక్ ఖాళీ అవుతుంది, 7 ను పొందటానికి మేము దానిని ప్లస్ తో ఆపరేట్ చేస్తాము మరియు దానిని వెనుకకు నెట్టేస్తాము మరియు ఫలితాన్ని పొందడానికి మేము ఈ విధంగా కదులుతాము.
44. అందువల్ల, చూడటానికి మంచి ఉదాహరణ ఏమిటంటే, స్టాక్ యొక్క విభిన్న విధులను ఉపయోగించి మనం ముందుకు సాగాలి, ఇది మనకు అందుబాటులో ఉన్న పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను వాస్తవంగా లెక్కిస్తుంది.
45. అదేవిధంగా, రెండు వైపుల నుండి ఒకే విధమైన పఠనం ఉన్న, మధ్యలో ఒక ప్రత్యేక పాత్ర అయిన సెంటర్ మార్కర్‌తో లేదా లేకుండా, పాలిండ్రోమ్ యొక్క గుర్తింపు వంటి అనేక ఇతర సమస్యలను స్టాక్ ఉపయోగించి గుర్తించవచ్చు. వాస్తవానికి, ఇన్ఫిక్స్ వ్యక్తీకరణ పోస్ట్‌ఫిక్స్ ద్వారా లోతుగా అన్వేషించవచ్చు మరియు ఒక ఉదాహరణ చాలా ఉంది.
46. కాబట్టి, ఏదైనా సాఫ్ట్‌వేర్ సిస్టమ్ యొక్క ప్రోగ్రామింగ్‌లో స్టాక్ ఒక ముఖ్యమైన పాత్ర పోషిస్తుంది మరియు అందువల్ల, స్టాక్‌ను ఉపయోగించడానికి మీకు అనుకూలమైన, నమ్మదగిన, దృ mechan మైన యంత్రాంగం ఉంటే మేము గట్టిగా ప్రయోజనం పొందుతాము.అప్పుడు సి ++ మాకు రెడీమేడ్‌గా ఇస్తుంది పరిష్కారం.
47. కాబట్టి, స్ట్రింగ్ రివర్స్ చేయడాన్ని చూద్దాం.
48. ఇది మీ కోసం రీక్యాప్ కంటే ఎక్కువ, ఇది స్ట్రింగ్ రివర్స్ చేయడానికి ప్రయత్నిస్తున్న సి ప్రోగ్రామ్, ఎందుకంటే స్టాక్ ఒక నిర్మాణంగా నిర్వచించబడిందని మీరు చూడవచ్చు, మూలకాల కంటైనర్ మరియు మార్కర్ అయిన మార్కర్ ఉన్న శ్రేణిని కలిగి ఉంటుంది. అత్యధిక మూలకం యొక్క ప్రస్తుత సూచికను నిర్వహించే సూచిక, మరియు ఈ నాలుగు ఫంక్షన్ల అమలు ఖాళీ, టాప్, బుష్ మరియు పాప్; శీర్ష విలువ -1 అని ఖాళీగా తనిఖీ చేస్తుంది; -1 మూలకాలు లేవని సూచిస్తుంది ఎందుకంటే శ్రేణి (శ్రేణి) కనిష్ట సూచిక విలువను 0 కలిగి ఉంటుంది.
49. అందువల్ల, ఇది మైనస్ 1 అయితే, స్టాక్ ఖాళీగా ఉందని మేము నిర్దేశిస్తాము.
50. పైభాగం మూలకాన్ని ఎగువ స్థానం నుండి తిరిగి ఇస్తుంది; పుష్ గరిష్ట స్థానాన్ని పెంచుతుంది మరియు స్టాక్‌లోని స్టాక్‌కు జోడించబడిన క్రొత్త మూలకాన్ని తిరిగి ఇస్తుంది మరియు పాప్ కేవలం టాప్ పాయింట్ లేదా టాప్ ఇండెక్స్‌ను తీసివేస్తుంది.
 C ++ ప్రోగ్రామింగులో  మాడ్యూల్ 5 కు స్వాగతం.
మీరు సాధారణంగా సి లో వ్రాసిన వివిధ ఉదాహరణ ప్రోగ్రామ్‌లను మేము చర్చిస్తున్నాము మరియు ఇప్పుడు వాటిని సి ++ లో ఎలా వ్రాయవచ్చో చూపిస్తున్నాము.
దీని కోసం సి ++ ప్రామాణిక లైబ్రరీని ఎంత తరచుగా ఉపయోగించవచ్చో మరియు దీనితో, సి ++ ప్రోగ్రామింగ్ సౌలభ్యాన్ని ఎలా పెంచుతుందో చూపించాలనుకుంటున్నాము.
కాబట్టి, ఈ మాడ్యూల్‌లో మనం స్టాక్‌లు మరియు దాని అనువర్తనాల గురించి మాట్లాడుతాము.
సి లో స్టాక్ అమలు మరియు వాడకాన్ని అర్థం చేసుకోవడానికి మేము ప్రయత్నిస్తాము, ఇది మీ అందరికీ తెలుసు, ఆపై సి ++ లో ప్రామాణిక స్టాక్ లైబ్రరీని ఎలా ఉపయోగించవచ్చో చూపిస్తాము.
అందువల్ల, ఇవి స్ట్రింగ్ (స్ట్రింగ్) ను రివర్స్ చేయడం ద్వారా పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను ఉదాహరణగా అంచనా వేసే అంశాలు.
స్టాక్ పరిచయంపై, రీక్యాప్ చేయడానికి.
స్టాక్ అనేది LIFO నిర్మాణం; డేటా అంశాల యొక్క ఏకపక్ష సంఖ్యల సేకరణను నిర్వహించే చివరి-మొదటి-మొదటి కంటైనర్.
శ్రేణిలో పరిమితులు లేవు; శ్రేణుల పరిమాణాన్ని బట్టి నేను ఎన్ని అంశాలను ఉంచగలను అనే దానిపై పరిమితులు ఉన్నాయి.
ఎటువంటి నిర్వచనం లేకుండా స్టాక్ చేయండి, స్టాక్‌లో ఉండే అన్ని ఎలిమెంట్ డేటా ఎలిమెంట్స్ ఒకే రకంగా ఉండాలి, కాని నేను ఎన్ని మూలకాలను కలిగి ఉంటాను.
కాబట్టి, సి లో స్టాక్ చేయడానికి, మనం చేయాలి; ఇవి మనం అనుసరించాల్సిన సాధారణ దశలు.
మొదట మనం మూలకం యొక్క డేటా రకాన్ని నిర్ణయించాలి, ఒక నిర్మాణం లేదా కంటైనర్‌ను నిర్వచించాలి, వాస్తవానికి సి లో మనం కొంత గరిష్ట పరిమాణాన్ని ఉపయోగించాల్సి ఉంటుంది, లేకపోతే సి కంపైలర్ దీనిని నిర్వచించటానికి అనుమతించదు, శీర్షాన్ని ప్రకటించండి స్టాక్ (స్టాక్) పైభాగాన్ని నిర్వహించే వేరియబుల్ మరియు ఆ స్టాక్ (స్టాక్) యొక్క ఆపరేషన్ కోసం అవసరమైన నాలుగు ఫంక్షన్లను వ్రాయాలి.
ఫంక్షన్ పుష్, ఇది స్టాక్‌కు ఒక మూలకాన్ని జోడిస్తుంది; ఫంక్షన్ పాప్, ఇది అగ్ర మూలకాన్ని తొలగిస్తుంది, మూలకం చివరిగా జోడించబడింది; ఫంక్షన్ టాప్, ఇది తీసివేయకుండా నాకు చాలా ఎక్కువ మూలకాన్ని ఇస్తుంది, చివరకు, మనకు ఒక ఫంక్షన్ (ఫంక్షన్) isempty () లేదా ఖాళీగా ఉండాలి, ఇది స్టాక్ (స్టాక్) లో ఏదైనా మూలకాలను కలిగి ఉంటే నాకు తెలియజేస్తుంది. కాదు.
కాబట్టి, isempty () నిజమైతే, పాప్ మరియు టాప్ వంటి ఆపరేషన్లు చెల్లవు ఎందుకంటే తొలగించడానికి లేదా తిరిగి రావడానికి అగ్ర మూలకం లేదు.
అందువల్ల, మేము స్టాక్ కోసం మూలకాల రకాన్ని మార్చిన వెంటనే, మనం తిరిగి దరఖాస్తు చేసుకోవాలి, స్టాక్ యొక్క మొత్తం కోడ్‌ను తిరిగి వ్రాయాలి, ఇది పూర్ణాంకం యొక్క స్టాక్. (స్టాక్) కోసం కోడ్ స్టాక్, మరియు స్టాక్ (స్టాక్) కోసం కోడ్ తీగలను స్టాక్ భిన్నంగా ఉంటుంది, అయినప్పటికీ LIFO యొక్క ప్రాథమిక umption హ రెండు సందర్భాల్లోనూ చెల్లుతుంది.
కాబట్టి, సి స్టాండర్డ్ లైబ్రరీలో మనకు ఉన్న ఈ ఫంక్షన్లన్నింటికీ కాకుండా, గణితంలో మనం ఇంతకుముందు చూశాము, మనకు చాలా లైబ్రరీ ఫంక్షన్లు ఉన్నాయి.
కాబట్టి, నేను గుర్తును లెక్కించాలనుకుంటే లేదా వర్గమూలాన్ని లెక్కించాలనుకుంటే లేదా ఆర్క్టాన్‌ను లెక్కించాలనుకుంటే, నేను ఆ ఫంక్షన్‌ను (ఫంక్షన్) వ్రాయవలసిన అవసరం లేదు, నేను దానిని లైబ్రరీ నుండి మాత్రమే ఉపయోగించగలను.
దీనికి విరుద్ధంగా, సి స్టాండర్డ్ లైబ్రరీ నాకు స్టాక్‌ను ఉపయోగించటానికి ఒక యంత్రాంగాన్ని ఇవ్వదు.
నేను వెంటనే ఉపయోగించగల స్టాక్ నాకు ఇవ్వదు.
కాబట్టి, సి ప్రోగ్రామింగ్‌తో ప్రస్తుత పరిస్థితుల పరిస్థితి ఇది.
కాబట్టి, ఈ సందర్భంలో, మీరు C ++ ఉపయోగిస్తే విషయాలు ఎలా మారతాయో చూడటానికి మేము ప్రయత్నిస్తాము.
కాబట్టి, స్టాక్ ఉపయోగించి పరిష్కరించడానికి మేము ప్రయత్నించిన కొన్ని సాధారణ సమస్యలపై కూడా దృష్టి పెడదాం.
నేను ఎడమ నుండి కుడికి క్రమంలో ఉన్న స్ట్రింగ్‌ను రివర్స్ చేయాలనుకుంటున్నాను, ఇది ఎడమ నుండి కుడికి మార్చాలనుకుంటున్నాను ఒక నిర్దిష్ట ప్రోగ్రామ్.
మరొక పోస్ట్‌ఫిక్స్ అనేది వ్యక్తీకరణల మూల్యాంకనం, ఆపరేటర్లు ఒపెరాండ్ల మధ్య ఉన్న చోట మేము సాధారణంగా వ్యక్తీకరణలను అఫిక్స్ సంజ్ఞామానం తో వ్రాస్తాము.
కాబట్టి, నేను ఈ వ్యక్తీకరణను అంచనా వేయాలనుకుంటే 1 + 2 * 3 - 4 ఉదాహరణను చూపిస్తున్నాను; మేము వ్యక్తీకరణను ఎడమ నుండి కుడికి చదివినప్పటికీ, దాన్ని అంచనా వేయడానికి వెళ్ళినప్పుడు మనం దానిని ఎడమ నుండి కుడికి ఖచ్చితంగా అంచనా వేయలేము.
నక్షత్రం గుణకారం అదనంగా మరియు వ్యవకలనం కంటే ఎక్కువ ప్రాధాన్యతనిస్తుందని మాకు తెలుసు.
కాబట్టి, మొదట మనం 2 తో 3 తో ​​గుణించాలి, ఫలితం 6 ను పొందాలి, ఆపై మనకు ప్లస్ మరియు మైనస్ ఉన్నాయి, ఇవి రెండూ ఒకే పూర్వజన్మను కలిగి ఉంటాయి, కానీ అవి అనుబంధంగా ఉంటాయి.
అందువల్ల, మనం ఎడమ నుండి కుడికి కదిలి, ఫలితం 3 అవుతుందని లెక్కించాలి.
కాబట్టి, మనం వ్యక్తీకరణను ఎలా వ్రాస్తామో పరంగా ఇన్ఫిక్స్ సంజ్ఞామానం చాలా మంచిది.
ఈ వ్యక్తీకరణలను వ్రాయడానికి మరియు దానిని అంచనా వేయడానికి BODMAS నియమాలను అనుసరించడానికి మా పాఠశాల రోజుల నుండి మాకు నేర్పించాం, కాని పోస్ట్‌ఫిక్స్ వ్యక్తీకరణలను అంచనా వేయడం చాలా కష్టమవుతుంది ఎందుకంటే ఆపరేటర్ల క్రమాన్ని అమలు చేయాలి, ఇది అసోసియేషన్ ఆధారంగా వారి ప్రాధాన్యత.
అందువల్ల, మేము పోస్ట్ఫిక్స్ సంజ్ఞామానం అని పిలువబడే వేరే సంజ్ఞామానాన్ని ఆశ్రయిస్తాము.
పోస్ట్‌ఫిక్స్ సంజ్ఞామానం లో, ఇది మొదట ఒపెరాండ్ పేర్కొనబడి, ఆపై ఆపరేటర్ వస్తాడు. అందుకే ఇది పోస్ట్‌ఫిక్స్.
కాబట్టి, నాకు సి ఆపరేటర్ ఉంటే, దాని కోసం ఒపెరాండ్ ఇప్పటికే జరిగింది.
కాబట్టి, ఆపరేటర్‌కు శ్రేణి 2 ఉంటే, ఆ ఆపరేటర్‌కు 2 ఆపరేటర్ ఒపెరాండ్‌లు వెంటనే వర్తింపజేయాలని నాకు తెలుసు.
కాబట్టి, ఇక్కడ ఇచ్చిన సమాచారంతో భర్తీ చేయబడిన ఈ వ్యక్తీకరణను నేను చూస్తే, నా వ్యక్తీకరణ 1 2 3 * + 4 - మరియు ఇది ఇన్ఫిక్స్ను ఎలా మార్చాలో కూడా ఒక సమస్య అని మీరు చూడగల ఉదాహరణను ఇక్కడ చూపిస్తాము. వ్యక్తీకరణ ఉపసర్గ వ్యక్తీకరణకు.
ఇది స్టాక్‌ను ఉపయోగించి కూడా పరిష్కరించవచ్చు, కాని ఇక్కడ పోస్ట్‌ఫిక్స్ వ్యక్తీకరణ ఇచ్చినట్లయితే, స్టాక్‌ను ఉపయోగించి దాన్ని ఎలా అంచనా వేస్తామో చూపిస్తాము.
కాబట్టి, ఇవన్నీ మనం చేయగలిగినవి చేయగల వేర్వేరు స్టాక్‌లు; వ్యక్తీకరణను ఎడమ నుండి కుడికి స్కాన్ చేయండి, ఉచిత ఒపెరాండ్ తీసుకోండి, దాన్ని స్టాక్‌లోకి చొప్పించండి, మేము ఆపరేటర్‌లోకి వచ్చే వరకు స్టాకింగ్ ఉంచండి.
కాబట్టి, ఇక్కడ మనం 1 పుష్ (పుష్) ఇస్తాము, తరువాత మనం 2 పుష్ (పుష్) ఇస్తాము, తరువాత 3 పుష్ (పుష్) ఇస్తాము, ఆపై 2 నిర్వచనాలు ఉన్న ఆపరేటర్ స్టార్ వద్దకు వస్తాము.
కాబట్టి, దీనికి చివరి 2 ఒపెరాండ్ అవసరమని నాకు తెలుసు, మేము ఈ 2 ని పాప్ చేస్తాము.
3 శక్తిని పొందడానికి 6 ను పొందండి మరియు దానిని వెనక్కి నెట్టండి.
అప్పుడు మనకు ప్లస్ నెక్స్ట్ ఆపరేటర్ వస్తుంది.
అందువల్ల, రెండు ఒపెరాండ్‌లు కూడా అవసరమని మాకు తెలుసు.
కాబట్టి, మేము 6 మరియు 1 ని పాప్ చేస్తాము, స్టాక్ ఖాళీ అవుతుంది, 7 ను పొందటానికి మేము దానిని ప్లస్ తో ఆపరేట్ చేస్తాము మరియు దానిని వెనుకకు నెట్టేస్తాము మరియు ఫలితాన్ని పొందడానికి మేము ఈ విధంగా కదులుతాము.
అందువల్ల, చూడటానికి మంచి ఉదాహరణ ఏమిటంటే, స్టాక్ యొక్క విభిన్న విధులను ఉపయోగించి మనం ముందుకు సాగాలి, ఇది మనకు అందుబాటులో ఉన్న పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను వాస్తవంగా లెక్కిస్తుంది.
అదేవిధంగా, రెండు వైపుల నుండి ఒకే విధమైన పఠనం ఉన్న, మధ్యలో ఒక ప్రత్యేక పాత్ర అయిన సెంటర్ మార్కర్‌తో లేదా లేకుండా, పాలిండ్రోమ్ యొక్క గుర్తింపు వంటి అనేక ఇతర సమస్యలను స్టాక్ ఉపయోగించి గుర్తించవచ్చు. వాస్తవానికి, ఇన్ఫిక్స్ వ్యక్తీకరణ పోస్ట్‌ఫిక్స్ ద్వారా లోతుగా అన్వేషించవచ్చు మరియు ఒక ఉదాహరణ చాలా ఉంది.
కాబట్టి, ఏదైనా సాఫ్ట్‌వేర్ సిస్టమ్ యొక్క ప్రోగ్రామింగ్‌లో స్టాక్ ఒక ముఖ్యమైన పాత్ర పోషిస్తుంది మరియు అందువల్ల, స్టాక్‌ను ఉపయోగించడానికి మీకు అనుకూలమైన, నమ్మదగిన, దృ mechan మైన యంత్రాంగం ఉంటే మేము గట్టిగా ప్రయోజనం పొందుతాము.అప్పుడు సి ++ మాకు రెడీమేడ్‌గా ఇస్తుంది పరిష్కారం.
కాబట్టి, స్ట్రింగ్ రివర్స్ చేయడాన్ని చూద్దాం.
ఇది మీ కోసం రీక్యాప్ కంటే ఎక్కువ, ఇది స్ట్రింగ్ రివర్స్ చేయడానికి ప్రయత్నిస్తున్న సి ప్రోగ్రామ్, ఎందుకంటే స్టాక్ ఒక నిర్మాణంగా నిర్వచించబడిందని మీరు చూడవచ్చు, మూలకాల కంటైనర్ మరియు మార్కర్ అయిన మార్కర్ ఉన్న శ్రేణిని కలిగి ఉంటుంది. అత్యధిక మూలకం యొక్క ప్రస్తుత సూచికను నిర్వహించే సూచిక, మరియు ఈ నాలుగు ఫంక్షన్ల అమలు ఖాళీ, టాప్, బుష్ మరియు పాప్; శీర్ష విలువ -1 అని ఖాళీగా తనిఖీ చేస్తుంది; -1 మూలకాలు లేవని సూచిస్తుంది ఎందుకంటే శ్రేణి (శ్రేణి) కనిష్ట సూచిక విలువను 0 కలిగి ఉంటుంది.
అందువల్ల, ఇది మైనస్ 1 అయితే, స్టాక్ ఖాళీగా ఉందని మేము నిర్దేశిస్తాము.
పైభాగం మూలకాన్ని ఎగువ స్థానం నుండి తిరిగి ఇస్తుంది; పుష్ గరిష్ట స్థానాన్ని పెంచుతుంది మరియు స్టాక్‌లోని స్టాక్‌కు జోడించబడిన క్రొత్త మూలకాన్ని తిరిగి ఇస్తుంది మరియు పాప్ కేవలం టాప్ పాయింట్ లేదా టాప్ ఇండెక్స్‌ను తీసివేస్తుంది.
అందువల్ల, పైభాగా పరిగణించబడిన మూలకం ఇప్పటికీ పైభాగా పరిగణించబడలేదు, దాని క్రింద ఉన్న మూలకం వెంటనే పైభాగా పరిగణించబడుతుంది మరియు స్టాక్ ఇప్పటికే ఉంటే మేము ఈ ఆపరేషన్ చేయలేము కాబట్టి ఖాళీగా ఉంటే, ఏమిటో తనిఖీ చేయడం మంచిది క్రింద? మేము నిజంగా పాప్ ఆపరేషన్ చేయడానికి ముందు స్టాక్ ఖాళీగా ఉంది.
51. ఇప్పుడు అది; మీరు ఇక్కడ ABCDE స్ట్రింగ్ ఉపయోగిస్తుంటే, మేము ఒక లూప్‌లోకి వెళ్లి, ఈ అక్షరాలన్నింటినీ ABCD మరియు E లను ఒకదాని తరువాత ఒకటి స్టాక్‌లో చేర్చగలమని మనందరికీ తెలుసు.
52. ఆపై మనం టాప్ ఎలిమెంట్‌ను గుర్తించి, ఆ పైభాగాన్ని పాపింగ్ చేస్తే మూలకం, అప్పుడు E ఖచ్చితంగా చివరిగా జోడించబడుతుంది.
53. కాబట్టి, అది మొదట బయటకు రాకముందే D జతచేయబడుతుంది, కాబట్టి ఇది తరువాత బయటకు వస్తుంది మరియు దాని ఫలితంగా మనం ఇక్కడ చూపిస్తున్న స్ట్రింగ్ వస్తుంది, ఇది EDCBA మరియు మనందరికీ దాని గురించి బాగా తెలుసు.
54. కాబట్టి, మీరు రివర్స్ స్ట్రింగ్‌ను ప్రోగ్రామ్ చేయాలనుకుంటే ఇదే మార్గం, మీరు ఈ ప్రధాన ఫంక్షన్ (ఫంక్షన్) లేదా ఫంక్షన్ (ఫంక్షన్) ను వ్రాయవలసి ఉంటుంది, ఇది స్ట్రింగ్ రివర్స్ చేయడానికి స్టాక్, ఉపయోగాలు, మీరు ఇచ్చిన కోడ్‌ను కూడా వ్రాయాలి .
55. సి లోని దృష్టాంతమైన ఎడమ కాలమ్‌లో, పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను అంచనా వేయడానికి ఇలాంటి దృశ్యం ఇవ్వబడుతుంది, మళ్ళీ సి ఎడమ కాలమ్‌లోని మునుపటి ఉదాహరణతో సమానంగా ఉంటుంది, ఇక్కడ స్టాక్ అమలు ఇవ్వబడుతుంది మరియు కుడి కాలమ్ ఇవ్వబడుతుంది.
56. ఇది నేను రెండు స్లైడ్‌లకు వివరించిన అల్గోరిథం కోడ్ మాత్రమే; మీరు దాని ద్వారా వెళ్లి మాకు నిజంగా ఏమి పని చేస్తుందో అర్థం చేసుకోవచ్చు.
57. మీరు ఈ పాయింట్‌పై ప్రత్యేకంగా దృష్టి పెడితే, ఈ సమయంలో ఏదైనా ఆపరేషన్ ఉందా అని తెలుసుకోవడానికి ఇది పనిచేస్తుంది.
58. వ్యక్తీకరణలోని కొన్ని అక్షరాలు ఒపెరాండ్స్ కాదా అని మేము గుర్తించామని మీరు చూస్తారు.
59. కాబట్టి, ఇది అంకె అయితే దాన్ని న్యూమరేటర్‌గా పరిగణిస్తారు.
60. కాబట్టి, ఈ వ్యక్తీకరణలో, ప్రతి అంకె ch అయితే, అది ఒక అంకె కాదా అనేది ఒక ఒపెరాండ్, ఒకే అంకెల ఒపెరాండ్, ఆపై మనం దానిని పుష్ (పుష్) ఇవ్వగలము, లేకపోతే మనం హుహ్ అని భావిస్తాము.
61. ఇది ఒక ఆపరేటర్ అని మాకు తెలుసు మరియు ఆ ఆపరేటర్ ప్రకారం అది అగ్రశ్రేణి అంశాలను కనుగొని తీసుకుంటుంది, వాటిని బయటకు తీసుకొని ఫలితాన్ని లెక్కించి వెనక్కి నెట్టివేస్తుంది.
62. పోస్ట్‌ఫిక్స్ వ్యక్తీకరణ యొక్క సాధారణ కోడ్ చాలా క్లిష్టంగా ఉంటుంది ఎందుకంటే మీరు ఆపరేటర్ యొక్క యోగ్యతలను కూడా పరిగణనలోకి తీసుకోవాలి మరియు దాని ఆధారంగా మాకు నాలుగు ఆపరేటర్లు తెలుసు, ఆపరేటర్ బైనరీ.
63. కాబట్టి, ఆ పైల్స్ అన్నీ ఇక్కడ లేవు.
64. ఇప్పుడు, సి ++ లో ఏమి జరుగుతుందో చూద్దాం.
65. C ++ లో, మంచి విషయం ఏమిటంటే, C ++ ప్రామాణిక లైబ్రరీ మాకు రెడీమేడ్ స్టాక్‌ను అందిస్తుంది.
66. కాబట్టి, ఆ స్టాక్‌ను సృష్టించడం లేదా మనం చేయవలసిన స్టాక్‌ను ఉపయోగించడం అంటే స్టాక్ (స్టాక్) హెడర్ అని పిలువబడే కొత్త హెడర్‌ను చేర్చడం.
67. స్టాక్ శీర్షికలో నిర్వచించబడిన స్టాక్‌ను వేగవంతం చేసి, ఆపై ఆ స్టాక్ (స్టాక్) ఆబ్జెక్ట్ యొక్క ఫంక్షన్లను ఉపయోగించడం ప్రారంభించండి మరియు మనకు స్టాక్ (స్టాక్) సిద్ధంగా ఉంటుంది.
68. కాబట్టి, ఇక్కడ మేము రివర్స్ స్ట్రింగ్ ఉదాహరణను చూపిస్తున్నాము.
69. మళ్ళీ కుడి వైపున సి ప్రోగ్రామ్ ఉంది, మనం ఇప్పటికే చర్చించిన మరియు ఇక్కడ చూపించని స్టాక్ కోడ్, స్టాక్ (స్టాక్) వాడకం రివర్స్ స్టాకింగ్ విషయంలో మాత్రమే చూపబడుతుంది. మరియు సమానమైన కోడ్ ఎడమ చేతిలో వ్రాయబడుతుంది వైపు.
70. ఇక్కడ, దయచేసి C ++ కోడ్‌లో, మేము స్టాక్ కోడ్‌ను వ్రాయవలసిన అవసరం లేదు, బదులుగా మనం చేయడానికి ప్రయత్నిస్తున్నది నిర్దిష్ట శీర్షికను కలిగి ఉంటుంది.
71. ఈ హెడర్ స్టాక్‌ను కలిగి ఉంది, ఇది స్టాక్ హెడర్‌ను కలిగి ఉంది.
72. మేము చేర్చాము, ఇందులో స్టాక్ నిర్వచనాలు ఉన్నాయి మరియు ఈ విధంగా మేము స్టాక్‌ను ఆపుతాము.
73. మేము శ్రేణులకు విరుద్ధంగా వెక్టర్స్ గురించి మాట్లాడినప్పుడు మీరు ఈ సంజ్ఞామానాన్ని చూశారు, మీరు గమనించారా, నాకు వెక్టర్ ఉంటే మూలకం రకాన్ని మూలలో బ్రాకెట్‌లో సమానంగా ఉంచగలను, ఈ కోణ బ్రాకెట్‌లో నాకు స్టాక్ ఉంటే, అప్పుడు మేము చూపిస్తున్నాము స్టాక్ ఏ రకమైన మూలకంతో తయారు చేయబడింది మరియు స్టాక్ వస్తువులకు s అని పేరు పెట్టబడుతుంది.
74. ఇప్పుడు, మేము దానిని ఎలా ఉపయోగిస్తాము అనే దానిపై దృష్టి పెడతాము.
75. ఇక్కడ సి లో, మీరు నెట్టాలనుకుంటే, మేము రెండు పారామితులను పాస్ చేయాలి, స్టాక్ అంటే ఏమిటి, ఇది చిరునామా మరియు మనం నెట్టాలనుకునే మూలకం ఏది.
76. ఇక్కడ, మేము డాట్; వెక్టర్ సందర్భంలో మీరు ఈ సంజ్ఞామానాన్ని కూడా క్లుప్తంగా చూశారు, కాని మేము దీని గురించి మరింత మాట్లాడుతాము, కానీ ఇది ఒక నిర్దిష్ట సంజ్ఞామానం; మేము నిర్మాణాలలో ఏమి ఉపయోగిస్తున్నామో, కానీ కొంత భిన్నంగా వివరించబడుతుందనే like హ వలె, s.push () ఇది స్టాక్ (ల) లో, నేను నెట్టాలనుకుంటున్నాను (నెట్టడం) మరియు నేను ఏమి నెట్టాలనుకుంటున్నాను? నేను ప్రత్యేకమైన మూలకం అయిన str ని నెట్టాలనుకుంటున్నాను.
77. అదేవిధంగా, నేను దీన్ని ఇక్కడ చేయాలనుకుంటే, నేను ఖాళీగా ఉన్న శూన్యతను తనిఖీ చేయాలనుకుంటున్నాను.
78. దీనికి విరుద్ధంగా, ఇక్కడ నేను చూడగలిగే విధంగా నేను s.empty () చేస్తాను.
79. కాబట్టి, కోడ్ సందర్భంలో స్టాక్ ఉపయోగించే కోడ్ చాలా సారూప్యంగా ఉందని మీరు చూడవచ్చు మరియు వాస్తవానికి మనం అర్థం చేసుకోగలిగినట్లుగా కోడ్ రాయడం చాలా సులభం ఎందుకంటే నాకు సి వంటి పునరావృత పారామితులు లేవు, నేను ఎక్కడ పాస్ చేయాలి పారామితులు, ప్రతి పాయింట్ వద్ద స్టాక్‌కు పాయింటర్ మరియు నేను ఫంక్షన్ కాల్ వెలుపల ఉంచవచ్చు మరియు పుష్ విషయంలో అవసరమైన పారామితులను పాస్ చేయవచ్చు ఒక పరామితి; మిగిలిన కేసులో పారామితులు అవసరం లేదు.
80. చివరగా, C లో కూడా గమనించండి, మేము స్టాక్‌ను నిర్వచించినప్పుడు; మేము మైనస్ 1 యొక్క టాప్ మార్కర్‌ను కూడా ప్రారంభించాల్సిన అవసరం ఉంది.
81. ఇక్కడ, సిస్టమ్ ఏదో ఒకవిధంగా జాగ్రత్త తీసుకుంటుంది మరియు కంపైలర్ దానిని చూసుకుంటుంది.
82. కాబట్టి, ఈ అగ్ర మార్కర్‌ను ప్రారంభించడం గురించి నేను బాధపడవలసిన అవసరం లేదు.
83. కాబట్టి, మేము ప్రామాణిక లైబ్రరీ నుండి స్టాక్‌ను ఉపయోగిస్తే, ప్రతిసారీ స్టాక్ కోడ్‌ను తిరిగి వ్రాయకుండా ఉండటంలో ప్రయోజనం ఉంది.
84. ఈ పాయింట్లు ఇక్కడ క్రింద ఇవ్వబడ్డాయి మరియు బదులుగా, దీని కోసం మాకు బాగా పరీక్షించిన రెడీమేడ్ స్టాక్ అందుబాటులో ఉంది.
85. మీరు తరువాతి ఉదాహరణలో చూస్తే నేను ముందుకు వెళ్తాను.
86. ఇది మేము C లో చేసినట్లుగానే ఉంది, కాని ఇప్పుడు మేము C ++ లో పోస్ట్‌ఫిక్స్ వ్యక్తీకరణలో పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను అంచనా వేయడానికి ఇలా చేస్తున్నాము మరియు ఈ కోడ్ మళ్ళీ మన వద్ద ఉన్న C కోడ్‌తో సమానంగా ఉంటుంది. స్టాక్ హెడర్ చేర్చడానికి వ్రాయబడింది మినహాయింపు, ఈ సంజ్ఞామానం తో స్టాక్‌ను నిర్వచించండి, ఆపై అన్ని స్టాక్ (స్టాక్) ఫంక్షన్లు (ఫంక్షన్) కొద్దిగా భిన్నమైన ఆకృతిలో వ్రాయబడతాయి, కాని కోడ్ లేకపోతే, ఎందుకంటే ఇది సి లో ఉంది మరియు మనకు ఏమీ చేయలేని ప్రయోజనంతో.
87. సి స్టాక్ కోడ్ అమలు.
88. కాబట్టి, ఈ మాడ్యూల్‌లో మేము చూపించినవి, మీరు సి ++ లో ప్రోగ్రామింగ్ చేస్తుంటే, స్టాక్‌ను ఉపయోగించడం ద్వారా మీకు పెద్ద ప్రయోజనం లభిస్తుంది.
89. మీరు స్టాక్ కోడ్‌ను అమలు చేయవలసిన అవసరం లేదు; స్టాక్ కోసం కంటైనర్ యొక్క గరిష్ట పరిమాణం ఎలా ఉండాలో మీరు ఆందోళన చెందాల్సిన అవసరం లేదు.
90. C ++ ప్రామాణిక లైబ్రరీ స్టాక్ స్వయంచాలకంగా దానిని చూసుకుంటుంది.
91. ఆ శీర్షికను ఎలా ప్రారంభించాలో ఇది జాగ్రత్త తీసుకుంటుంది మరియు స్టాక్ కోసం నాకు అవసరమైన ఏ రకమైన మూలకానికైనా ఉపయోగించవచ్చు మరియు మొత్తం C ++ ప్రోగ్రామింగ్ మరియు ప్రామాణిక లైబ్రరీ (లైబ్రరీ యొక్క చాలా ఆసక్తికరమైన మరియు ఉత్తేజకరమైన భాగం) కథ లేదు దానితో ఆగవద్దు.
92. క్యూ వంటి తరచుగా అవసరమయ్యే అన్ని సాధారణ డేటా నిర్మాణాలు వెలుపల ఉన్నాయి; క్యూక్, ఇది డబుల్ ఎండ్ క్యూ (క్యూ), ఇక్కడ మీరు ఒక క్రమం యొక్క రెండు చివరలను జోడించవచ్చు మరియు తీసివేయవచ్చు.
93. జాబితా; ఒకే లింక్డ్ జాబితా, మ్యాప్, ఇది పేరు విలువ జత లాంటిది; సెట్, ఆర్డరింగ్ ముఖ్యం కానప్పుడు, మీరు దానిలోని యూనియన్‌ను దాటవచ్చు.
94. ఈ డేటా నిర్మాణాలన్నీ సి ++ ప్రామాణిక లైబ్రరీలో రెడీమేడ్‌లో అందుబాటులో ఉన్నాయి.
95. కాబట్టి, ప్రోగ్రామింగ్ భాష యొక్క వివరణాత్మక సూక్ష్మ నైపుణ్యాలను అర్థం చేసుకోవడానికి ముందు మేము C ++ లో ప్రోగ్రామింగ్ ప్రారంభించేటప్పుడు, C ++ ప్రామాణిక లైబ్రరీని మళ్లీ మళ్లీ పరిశీలించాలనుకుంటున్నాము.ఈ ప్రోగ్రామ్‌లన్నీ డేటా స్ట్రక్చర్‌లను ఉపయోగించే ప్రోగ్రామ్‌లను వ్రాస్తాయి మరియు మనవి ప్రోగ్రామింగ్ సులభం మరియు ఉపయోగించడానికి మరింత బలంగా ఉంది.
96.
ఇప్పుడు అది; మీరు ఇక్కడ ABCDE స్ట్రింగ్ ఉపయోగిస్తుంటే, మేము ఒక లూప్‌లోకి వెళ్లి, ఈ అక్షరాలన్నింటినీ ABCD మరియు E లను ఒకదాని తరువాత ఒకటి స్టాక్‌లో చేర్చగలమని మనందరికీ తెలుసు.
ఆపై మనం టాప్ ఎలిమెంట్‌ను గుర్తించి, ఆ పైభాగాన్ని పాపింగ్ చేస్తే మూలకం, అప్పుడు E ఖచ్చితంగా చివరిగా జోడించబడుతుంది.
కాబట్టి, అది మొదట బయటకు రాకముందే D జతచేయబడుతుంది, కాబట్టి ఇది తరువాత బయటకు వస్తుంది మరియు దాని ఫలితంగా మనం ఇక్కడ చూపిస్తున్న స్ట్రింగ్ వస్తుంది, ఇది EDCBA మరియు మనందరికీ దాని గురించి బాగా తెలుసు.
కాబట్టి, మీరు రివర్స్ స్ట్రింగ్‌ను ప్రోగ్రామ్ చేయాలనుకుంటే ఇదే మార్గం, మీరు ఈ ప్రధాన ఫంక్షన్ (ఫంక్షన్) లేదా ఫంక్షన్ (ఫంక్షన్) ను వ్రాయవలసి ఉంటుంది, ఇది స్ట్రింగ్ రివర్స్ చేయడానికి స్టాక్, ఉపయోగాలు, మీరు ఇచ్చిన కోడ్‌ను కూడా వ్రాయాలి .
సి లోని దృష్టాంతమైన ఎడమ కాలమ్‌లో, పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను అంచనా వేయడానికి ఇలాంటి దృశ్యం ఇవ్వబడుతుంది, మళ్ళీ సి ఎడమ కాలమ్‌లోని మునుపటి ఉదాహరణతో సమానంగా ఉంటుంది, ఇక్కడ స్టాక్ అమలు ఇవ్వబడుతుంది మరియు కుడి కాలమ్ ఇవ్వబడుతుంది.
ఇది నేను రెండు స్లైడ్‌లకు వివరించిన అల్గోరిథం కోడ్ మాత్రమే; మీరు దాని ద్వారా వెళ్లి మాకు నిజంగా ఏమి పని చేస్తుందో అర్థం చేసుకోవచ్చు.
మీరు ఈ పాయింట్‌పై ప్రత్యేకంగా దృష్టి పెడితే, ఈ సమయంలో ఏదైనా ఆపరేషన్ ఉందా అని తెలుసుకోవడానికి ఇది పనిచేస్తుంది.
వ్యక్తీకరణలోని కొన్ని అక్షరాలు ఒపెరాండ్స్ కాదా అని మేము గుర్తించామని మీరు చూస్తారు.
కాబట్టి, ఇది అంకె అయితే దాన్ని న్యూమరేటర్‌గా పరిగణిస్తారు.
కాబట్టి, ఈ వ్యక్తీకరణలో, ప్రతి అంకె ch అయితే, అది ఒక అంకె కాదా అనేది ఒక ఒపెరాండ్, ఒకే అంకెల ఒపెరాండ్, ఆపై మనం దానిని పుష్ (పుష్) ఇవ్వగలము, లేకపోతే మనం హుహ్ అని భావిస్తాము.
ఇది ఒక ఆపరేటర్ అని మాకు తెలుసు మరియు ఆ ఆపరేటర్ ప్రకారం అది అగ్రశ్రేణి అంశాలను కనుగొని తీసుకుంటుంది, వాటిని బయటకు తీసుకొని ఫలితాన్ని లెక్కించి వెనక్కి నెట్టివేస్తుంది.
పోస్ట్‌ఫిక్స్ వ్యక్తీకరణ యొక్క సాధారణ కోడ్ చాలా క్లిష్టంగా ఉంటుంది ఎందుకంటే మీరు ఆపరేటర్ యొక్క యోగ్యతలను కూడా పరిగణనలోకి తీసుకోవాలి మరియు దాని ఆధారంగా మాకు నాలుగు ఆపరేటర్లు తెలుసు, ఆపరేటర్ బైనరీ.
కాబట్టి, ఆ పైల్స్ అన్నీ ఇక్కడ లేవు.
ఇప్పుడు, సి ++ లో ఏమి జరుగుతుందో చూద్దాం.
C ++ లో, మంచి విషయం ఏమిటంటే, C ++ ప్రామాణిక లైబ్రరీ మాకు రెడీమేడ్ స్టాక్‌ను అందిస్తుంది.
కాబట్టి, ఆ స్టాక్‌ను సృష్టించడం లేదా మనం చేయవలసిన స్టాక్‌ను ఉపయోగించడం అంటే స్టాక్ (స్టాక్) హెడర్ అని పిలువబడే కొత్త హెడర్‌ను చేర్చడం.
స్టాక్ శీర్షికలో నిర్వచించబడిన స్టాక్‌ను వేగవంతం చేసి, ఆపై ఆ స్టాక్ (స్టాక్) ఆబ్జెక్ట్ యొక్క ఫంక్షన్లను ఉపయోగించడం ప్రారంభించండి మరియు మనకు స్టాక్ (స్టాక్) సిద్ధంగా ఉంటుంది.
కాబట్టి, ఇక్కడ మేము రివర్స్ స్ట్రింగ్ ఉదాహరణను చూపిస్తున్నాము.
మళ్ళీ కుడి వైపున సి ప్రోగ్రామ్ ఉంది, మనం ఇప్పటికే చర్చించిన మరియు ఇక్కడ చూపించని స్టాక్ కోడ్, స్టాక్ (స్టాక్) వాడకం రివర్స్ స్టాకింగ్ విషయంలో మాత్రమే చూపబడుతుంది. మరియు సమానమైన కోడ్ ఎడమ చేతిలో వ్రాయబడుతుంది వైపు.
ఇక్కడ, దయచేసి C ++ కోడ్‌లో, మేము స్టాక్ కోడ్‌ను వ్రాయవలసిన అవసరం లేదు, బదులుగా మనం చేయడానికి ప్రయత్నిస్తున్నది నిర్దిష్ట శీర్షికను కలిగి ఉంటుంది.
ఈ హెడర్ స్టాక్‌ను కలిగి ఉంది, ఇది స్టాక్ హెడర్‌ను కలిగి ఉంది.
మేము చేర్చాము, ఇందులో స్టాక్ నిర్వచనాలు ఉన్నాయి మరియు ఈ విధంగా మేము స్టాక్‌ను ఆపుతాము.
మేము శ్రేణులకు విరుద్ధంగా వెక్టర్స్ గురించి మాట్లాడినప్పుడు మీరు ఈ సంజ్ఞామానాన్ని చూశారు, మీరు గమనించారా, నాకు వెక్టర్ ఉంటే మూలకం రకాన్ని మూలలో బ్రాకెట్‌లో సమానంగా ఉంచగలను, ఈ కోణ బ్రాకెట్‌లో నాకు స్టాక్ ఉంటే, అప్పుడు మేము చూపిస్తున్నాము స్టాక్ ఏ రకమైన మూలకంతో తయారు చేయబడింది మరియు స్టాక్ వస్తువులకు s అని పేరు పెట్టబడుతుంది.
ఇప్పుడు, మేము దానిని ఎలా ఉపయోగిస్తాము అనే దానిపై దృష్టి పెడతాము.
ఇక్కడ సి లో, మీరు నెట్టాలనుకుంటే, మేము రెండు పారామితులను పాస్ చేయాలి, స్టాక్ అంటే ఏమిటి, ఇది చిరునామా మరియు మనం నెట్టాలనుకునే మూలకం ఏది.
ఇక్కడ, మేము డాట్; వెక్టర్ సందర్భంలో మీరు ఈ సంజ్ఞామానాన్ని కూడా క్లుప్తంగా చూశారు, కాని మేము దీని గురించి మరింత మాట్లాడుతాము, కానీ ఇది ఒక నిర్దిష్ట సంజ్ఞామానం; మేము నిర్మాణాలలో ఏమి ఉపయోగిస్తున్నామో, కానీ కొంత భిన్నంగా వివరించబడుతుందనే like హ వలె, s.push () ఇది స్టాక్ (ల) లో, నేను నెట్టాలనుకుంటున్నాను (నెట్టడం) మరియు నేను ఏమి నెట్టాలనుకుంటున్నాను? నేను ప్రత్యేకమైన మూలకం అయిన str ని నెట్టాలనుకుంటున్నాను.
అదేవిధంగా, నేను దీన్ని ఇక్కడ చేయాలనుకుంటే, నేను ఖాళీగా ఉన్న శూన్యతను తనిఖీ చేయాలనుకుంటున్నాను.
దీనికి విరుద్ధంగా, ఇక్కడ నేను చూడగలిగే విధంగా నేను s.empty () చేస్తాను.
కాబట్టి, కోడ్ సందర్భంలో స్టాక్ ఉపయోగించే కోడ్ చాలా సారూప్యంగా ఉందని మీరు చూడవచ్చు మరియు వాస్తవానికి మనం అర్థం చేసుకోగలిగినట్లుగా కోడ్ రాయడం చాలా సులభం ఎందుకంటే నాకు సి వంటి పునరావృత పారామితులు లేవు, నేను ఎక్కడ పాస్ చేయాలి పారామితులు, ప్రతి పాయింట్ వద్ద స్టాక్‌కు పాయింటర్ మరియు నేను ఫంక్షన్ కాల్ వెలుపల ఉంచవచ్చు మరియు పుష్ విషయంలో అవసరమైన పారామితులను పాస్ చేయవచ్చు ఒక పరామితి; మిగిలిన కేసులో పారామితులు అవసరం లేదు.
చివరగా, C లో కూడా గమనించండి, మేము స్టాక్‌ను నిర్వచించినప్పుడు; మేము మైనస్ 1 యొక్క టాప్ మార్కర్‌ను కూడా ప్రారంభించాల్సిన అవసరం ఉంది.
ఇక్కడ, సిస్టమ్ ఏదో ఒకవిధంగా జాగ్రత్త తీసుకుంటుంది మరియు కంపైలర్ దానిని చూసుకుంటుంది.
కాబట్టి, ఈ అగ్ర మార్కర్‌ను ప్రారంభించడం గురించి నేను బాధపడవలసిన అవసరం లేదు.
కాబట్టి, మేము ప్రామాణిక లైబ్రరీ నుండి స్టాక్‌ను ఉపయోగిస్తే, ప్రతిసారీ స్టాక్ కోడ్‌ను తిరిగి వ్రాయకుండా ఉండటంలో ప్రయోజనం ఉంది.
ఈ పాయింట్లు ఇక్కడ క్రింద ఇవ్వబడ్డాయి మరియు బదులుగా, దీని కోసం మాకు బాగా పరీక్షించిన రెడీమేడ్ స్టాక్ అందుబాటులో ఉంది.
మీరు తరువాతి ఉదాహరణలో చూస్తే నేను ముందుకు వెళ్తాను.
ఇది మేము C లో చేసినట్లుగానే ఉంది, కాని ఇప్పుడు మేము C ++ లో పోస్ట్‌ఫిక్స్ వ్యక్తీకరణలో పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను అంచనా వేయడానికి ఇలా చేస్తున్నాము మరియు ఈ కోడ్ మళ్ళీ మన వద్ద ఉన్న C కోడ్‌తో సమానంగా ఉంటుంది. స్టాక్ హెడర్ చేర్చడానికి వ్రాయబడింది మినహాయింపు, ఈ సంజ్ఞామానం తో స్టాక్‌ను నిర్వచించండి, ఆపై అన్ని స్టాక్ (స్టాక్) ఫంక్షన్లు (ఫంక్షన్) కొద్దిగా భిన్నమైన ఆకృతిలో వ్రాయబడతాయి, కాని కోడ్ లేకపోతే, ఎందుకంటే ఇది సి లో ఉంది మరియు మనకు ఏమీ చేయలేని ప్రయోజనంతో.
సి స్టాక్ కోడ్ అమలు.
కాబట్టి, ఈ మాడ్యూల్‌లో మేము చూపించినవి, మీరు సి ++ లో ప్రోగ్రామింగ్ చేస్తుంటే, స్టాక్‌ను ఉపయోగించడం ద్వారా మీకు పెద్ద ప్రయోజనం లభిస్తుంది.
మీరు స్టాక్ కోడ్‌ను అమలు చేయవలసిన అవసరం లేదు; స్టాక్ కోసం కంటైనర్ యొక్క గరిష్ట పరిమాణం ఎలా ఉండాలో మీరు ఆందోళన చెందాల్సిన అవసరం లేదు.
C ++ ప్రామాణిక లైబ్రరీ స్టాక్ స్వయంచాలకంగా దానిని చూసుకుంటుంది.
ఆ శీర్షికను ఎలా ప్రారంభించాలో ఇది జాగ్రత్త తీసుకుంటుంది మరియు స్టాక్ కోసం నాకు అవసరమైన ఏ రకమైన మూలకానికైనా ఉపయోగించవచ్చు మరియు మొత్తం C ++ ప్రోగ్రామింగ్ మరియు ప్రామాణిక లైబ్రరీ (లైబ్రరీ యొక్క చాలా ఆసక్తికరమైన మరియు ఉత్తేజకరమైన భాగం) కథ లేదు దానితో ఆగవద్దు.
క్యూ వంటి తరచుగా అవసరమయ్యే అన్ని సాధారణ డేటా నిర్మాణాలు వెలుపల ఉన్నాయి; క్యూక్, ఇది డబుల్ ఎండ్ క్యూ (క్యూ), ఇక్కడ మీరు ఒక క్రమం యొక్క రెండు చివరలను జోడించవచ్చు మరియు తీసివేయవచ్చు.
జాబితా; ఒకే లింక్డ్ జాబితా, మ్యాప్, ఇది పేరు విలువ జత లాంటిది; సెట్, ఆర్డరింగ్ ముఖ్యం కానప్పుడు, మీరు దానిలోని యూనియన్‌ను దాటవచ్చు.
ఈ డేటా నిర్మాణాలన్నీ సి ++ ప్రామాణిక లైబ్రరీలో రెడీమేడ్‌లో అందుబాటులో ఉన్నాయి.
కాబట్టి, ప్రోగ్రామింగ్ భాష యొక్క వివరణాత్మక సూక్ష్మ నైపుణ్యాలను అర్థం చేసుకోవడానికి ముందు మేము C ++ లో ప్రోగ్రామింగ్ ప్రారంభించేటప్పుడు, C ++ ప్రామాణిక లైబ్రరీని మళ్లీ మళ్లీ పరిశీలించాలనుకుంటున్నాము.ఈ ప్రోగ్రామ్‌లన్నీ డేటా స్ట్రక్చర్‌లను ఉపయోగించే ప్రోగ్రామ్‌లను వ్రాస్తాయి మరియు మనవి ప్రోగ్రామింగ్ సులభం మరియు ఉపయోగించడానికి మరింత బలంగా ఉంది.
inhouse/NPTEL/PreFinal/c++/Telugu/09. ProgramminginCplusplus_Copy Constructor and Copy Assignment Operator (Contd.) (Lecture 28)-si8HRtDgI1A.txt
View file @ 956c0d4e
 1. ప్రోగ్రామింగ్ ఇన్ C++ లో మాడ్యూల్ 14 కు స్వాగతం.
2. మేము కాపీ గురించి చర్చించాము, మేము లోతుగా కాపీ కన్స్ట్రక్టర్ గురించి చర్చించాము మరియు కాపీ అసైన్మెంట్ ఆపరేటర్ అంటే ఏమిటో పరిచయం చేసాము.
3. త్వరగా రీక్యాప్ చేయడానికి, మీరు ఒక ఆబ్జెక్ట్ యొక్క క్లోన్ను తయారు చేయాలని కోరుకున్నప్పుడు మేము ఒక కాపీ కన్స్ట్రక్షన్(copy construction) చేస్తాము మరియు మేము ఇప్పటికే ఉన్న ఆబ్జెక్ట్ ను కలిగి ఉన్నప్పుడు, కాపీని అసైన్మెంట్ చేస్తాము మరియు అదే రకమైన మరొక ఆబ్జెక్ట్ ను ప్రస్తుత ఆబ్జెక్ట్ లో కాపీ చేయాలనుకుంటున్నాము.
4. ఒక కాపీని ఆపరేటర్ ఫంక్షన్గా(operator function) నిర్వచించవచ్చని మేము చూశాము; ఆపరేటర్ ఫంక్షన్ మరియు ఇది పారామితిని క్లాస్ యొక్క కాన్సస్టెంట్ రెఫరెన్స్(constant reference) గా తీసుకుంటుంది మరియు అదే క్లాస్ యొక్కనాన్- కాన్సస్టెంట్ రెఫరెన్స్(non-constant reference) ను తిరిగి ఇస్తుంది, ఇది క్లాస్ యొక్క కాన్సస్టెంట్ రెఫరెన్స్(constant reference)ను కూడా తిరిగి పొందవచ్చు.
5. ఇప్పుడు, కాపీ అసైన్మెంట్ యొక్క మరింత గమ్మత్తైన ప్రాంతాలలో కొన్నింటిని పరిశీలిస్తాము.
6. సో, మీరు కాపీ కన్స్ట్రక్షన్ పరంగా, మీరు ఇప్పటికే shallow కాపీ మరియు deep కాపీని యొక్క భావం వివరించారు గుర్తుచేసుకున్నారు.
7. ఇప్పుడు shallow కాపీ మరియు deep కాపీ యొక్క పరిణామాలు కూడా కాపీ అప్పగింతలోకి వక్రీకరిస్తాయని మేము చూస్తాము.
8. కాబట్టి, ప్రత్యేకంగా దీన్ని స్ట్రింగ్ ఉదాహరణగా దృష్టి పెట్టండి మరియు కాపీ అసైన్మెంట్ ఆపరేటర్ పై దృష్టి పెట్టండి.
9. ఇప్పుడు, మీరు ఏమి ప్రయత్నిస్తున్నారు? ఇది మీ; నాకు కేవలం రెండు ఆబ్జెక్ట్ లను గీయండి.
10. ఈ s1 ఉంది, ఈ s2 ఉంది .
11. సో, ఈ ఫుట్బాల్(football) ఉంది.
12. కాబట్టి, అది ఏమంటే, అది పొడవు(length) 8 ఉంటుంది. ఇది క్రికెట్; ఇది పొడవు(length) 7 ఉంటుంది. ఇప్పుడు, నేను కాపీ చేయడానికి ప్రయత్నిస్తున్నాను.
13. కాబట్టి, నేను s2ను  s1 కి కేటాయించడానికి ప్రయత్నిస్తాను.
14. కాబట్టి, నేను దీనిని కాపీ చేస్తే; సహజంగా నేను కాపీ చేస్తున్నప్పుడు ఈ స్ట్రింగ్ ఇక్కడ కాపీ చేయబడిందని నాకు తెలుసు మరియు దీనికి రెండు ఎంపికలు ఉన్నాయి అని మాకు తెలుసు.
15. ఒక పాయింటర్ కాపీ ఉంది; ఇతర వాస్తవానికి ఆబ్జెక్ట్ ను కాపీ చేయడం.
16. కాబట్టి, మేము డీప్ కాపీని చేయాలనుకుంటున్నాము, ఈ సందర్భంలో మేము ఒక లోతైన కాపీని చేస్తున్నాము.
17. కాబట్టి, మీరు ఒక పారామితి యొక్క strdup ను తయారు చేస్తున్నారు, ఇది ప్రధానంగా s1 యొక్క strdup.
18. ఇప్పుడు, మీరు దానిని str కు అప్పగిస్తే ఏమి జరుగుతుంది? కేవలం, మరొక ఫుట్బాల్ సృష్టించింది, strdup మేము డూప్లికేట్(duplicate) చేసిన.
19. కాబట్టి, మరో ఫుట్బాల్ క్రరియేట్ చేసింది.
20. ఇప్పుడు, నేను ఈ పాయింటర్ను str గా ఉంచినట్లయితే, సహజంగా నేను ఈ పాయింటర్ ను కోల్పోతాను మరియు ఈ స్ట్రింగ్ను తిరిగి పొందటానికి ఏ మార్గం లేదు.
21. కాబట్టి, నేను దీన్ని ముందు, నేను ఫ్రీ(free) చేయవలసి ఉంటుంది, లేకపోతే రీసోర్స్(resource) ని లీక్ చేస్తుంది, మెమరీ లీక్ అవుతుంది.
22. కాబట్టి, ఇది ముఖ్యమైన అంశం.
23. నేను మొదట దీన్ని విడిపించాను, అప్పుడు నేను స్ట్రింగ్ కాపీని చేస్తున్నాను.
24. కాబట్టి, నేను ఈ విడివిడిగా ఈ పోయింది, నేను ఒక strdup చేయండి.
25. ఇప్పుడు, నేను ఇక్కడ ఒక కొత్త ఫుట్బాల్ సూచించాను, ఇది కాపీ చేయబడుతుంది.
26. కాబట్టి, ఇది ఇక్కడ 8 గా మారుతుంది మరియు గత సందర్భంలో చేసిన విధంగానే లక్ష్యం తిరిగి వస్తుంది.
27. ఇది ప్రాథమికంగా ఇది ప్రస్తుత ఆబ్జెక్ట్ (object) అని మొదట తెలియజేస్తుంది.
28. కాబట్టి, ఆ ఆబ్జెక్ట్ తిరిగి రావాల్సిన object ను తిరిగి ఇవ్వాలి ఎందుకంటే అది తిరిగి వస్తుంది.
29. కాబట్టి, నేను చెప్పినట్లుగా, ఈ ఆబ్జెక్ట్ ఇప్పుడు చైన్ అసైన్మెంట్(chain assignment) కోసం ఉపయోగించబడుతుంది.
30. నేను ఇప్పటికే వివరించినందున ఇది చైన్ అసైన్మెంట్(chain assignment) లో ఉపయోగించబడుతుంది.
31. అందువల్ల, ఈ ఆబ్జెక్ట్ లో ఉన్న పాయింటర్ మెంబర్లను కలిగి ఉన్నప్పుడల్లా, ఒక కాపీని ఒక డీప్ కాపీ(deep copy) కోసం ఉపయోగించవచ్చు.
32. ఇప్పుడు, మనం ఇప్పటికే చూచిన కోడ్తో చాలా చిన్న, కానీ అపాయకరమైన(dangerous) సమస్యగా చూద్దాం.
33. ఇది మీరు చూసిన సరిగ్గా ఉన్న కోడ్, ఇది s1 కు s2 ను మేము అధిగమించాము.
34. ఇప్పుడు, నేను s1 కు s1 ను కాపీ చేసాను.
35. ఇప్పుడు, మీరు చాలా చట్టబద్ధంగా నన్ను అడగవచ్చు, ఎందుకు ఎవరైనా ఈ రకమైన కోడ్ను రాయాలి, దానికి రెండు సమాధానాలు ఉన్నాయి; ఎవరైనా రాసినట్లయితే ఒకటి.
36.  ఏమి జరగబోతుందో మేము తెలుసుకోవాలి.
37. ఇతర సమస్య ఎల్లప్పుడూ కోడ్ ఇలా ఉంటుంది, ఉదాహరణకు, అది కావచ్చు; నేను స్ట్రింగ్ కలిగి, నేను S1 ఒక రెఫరెన్స్(reference) కలిగి ఎక్కడా జరుగుతుంది; ఇది ఎక్కడ జరిగిందో నాకు తెలియదు.
38. ఇది కొన్ని ఇతర ఫంక్షన్లో చేయబడి ఉండవచ్చు, కొన్ని ఇతర క్లాస్ లలో అది వచ్చినది మరియు ఇప్పుడు నేను s1 కేటాయించిన చేస్తున్నాను.
39. సిన్టాటిక్(Syntactically) గా, కోడ్ చూడటం అనేది ఒక సెల్ఫ్ కాపీ(self copy) వలె కనిపించడం లేదు, కానీ వాస్తవానికి ఇది సెల్ఫ్ కాపీ(self copy).
40. కాబట్టి, సెల్ఫ్ కాపీ(self copy) మేము పరిశీలించాల్సిన ఒక సంభావ్య పరిస్థితి(potential situation).
41. ఇప్పుడు ఖచ్చితంగా సమస్యలు ఉన్నాయని మేము చూస్తున్నాం.
42. కాబట్టి, దీనిని పరిశీలించండి సెల్ఫ్ కాపీ.
43. కాబట్టి, ఈ నేను ఏమి ఉంది, ఈ నా s 1, ఈ నా స్ట్రింగ్(my string), నా s1 ఫుట్బాల్ ఉంది.
44. కాబట్టి, నేను ఇక్కడ ఫుట్బాల్ మరియు వెయిట్(weight) కలిగి ఉన్నాను.
45. ఇప్పుడు, నేను s1 చేస్తాను ఈ ఒకటి అసైన్(assign) చేయండి.
46. కాబట్టి, ఏమి జరుగుతుంది? ఇది మొదట ఎగ్జిక్యూట్(execute) అవుతుంది, ఇది నా s1.
47. కాబట్టి, ఇది ఫ్రీ.
48. ఇప్పుడు, ఇది చేయటానికి ప్రయత్నిస్తుంది, అనగా, ఈ ఆబ్జెక్ట్ s డాట్ స్ట్రింగ్ ను తీసుకోవటానికి ప్రయత్నిస్తుంది, ఒక కాపీని తయారు చేసి ఆపై దాన్ని ఇక్కడ పెట్టండి.
49. ఇప్పుడు, ఈ ఆబ్జెక్ట్ ఇప్పటికే పోయిందని ఇది ఫ్రీ చేయబడింది.
50. కాబట్టి, ఇక్కడ మీరు ఏమి కాపీ చేస్తున్నారో తెలియదు, ప్రశ్న కాదు అది కేవలం తెలియదు, ఇది ఏదో ఇన్వాలిడ్(invalid) అయ్యేది మరియు ఆపై ఉంటుంది.
51. సో, మీరు కాపీని తర్వాత ప్రింట్ అయినప్పుడు ఊహించినంత నిశ్శబ్దంగా చేస్తే, మీరు చెత్తను సంపాదించిన తరువాత నేను గార్బేజ్(garbage) ను పొంది, ఒక చెత్త వచ్చింది, కానీ నేను గార్బేజ్(garbage) కు గురైనప్పుడు అది గార్బేజ్(garbage) గా ఉంటుంది, ఎందుకంటే ఇది మెమరీని ఎలా ఉల్లంఘిస్తుందో(violated) దానిపై ఆధారపడి ఉంటుంది.
52. సో, పాయింటర్ టైపుతో సెల్ఫ్ కాపీ ఇమేజ్ ఎదుర్కోవటానికి చాలా కష్టంగా ఉందని నిరూపించేది.
53. కాబట్టి, దాని గురించి ఏదో చేయవలసి ఉంటుంది.
54. కాబట్టి, మేము దీనిని నిర్వహించటం మరియు ఇది చాలా ప్రత్యేకంగా మీరు నేను సెల్ఫ్ కాపీ(self copy)ని చేస్తున్నట్లయితే, నేను ఇలా చేస్తే, అప్పుడు నా కాపీ అసైన్మెంట్ ఆపరేటర్(copy assignment operator) కాపీ చేయకూడదని చెప్పాలి.
55. మీరు ఒక సెల్ఫ్ కాపీ ని చేస్తున్నట్లయితే అప్పుడు నేను చెప్పాల్సిన అన్నిటిని కాపీ చేయడం లేదు ఎందుకంటే అది బైపాస్, ఇది ఒక ఆబ్జెక్ట్ .
56. కాబట్టి, కోడ్ మిగిలిన ఉంది, కానీ నేను జోడించే అన్ని ఇది ఒక ఆబ్జెక్ట్ ఉంటే తనిఖీ ఉంది.
57. ఇది ఒకే ఆబ్జెక్ట్ అయితే నేను ఎలా తనిఖీ చేయాలి? S1 s1 అసైన్ చేయబడుతుందని అర్థం.
58. కాబట్టి, ఇది s1 డాట్ ఆపరేటర్లు కేటాయింపు s1, ఇది s అవుతుంది మరియు ఇది ఆబ్జెక్టు జరుగుతున్న ఆబ్జెక్ట్ , కాబట్టి ఇది * ఇది.
59. కాబట్టి, మీరు ఈ మరియు s star లేదో చూడాలనుకుంటున్నారా.
60. మేము ఈ ఆబ్జెక్ట్ లను పోల్చుకోలేము ఎందుకంటే ఇది ఏ ఆబ్జెక్ట్ అయినా కావచ్చు, దానికి పోలిక ఆపరేటర్ లేదు.
61. ఈ నేను పూర్ణాంకానికి సమానంగా వ్రాసే పూర్ణాంకం లాంటిది కాదు కానీ నాకు తెలిసినది ఏమిటంటే అది ఒకే ఆబ్జెక్ట్ అయితే అది కొన్ని మెమరీలో ఉంటుంది.
62. కాబట్టి, ఈ 2 ఒకే విధంగా వుండాలి, అప్పుడు ఇది s & s వలె ఉంటుంది.
63. అడ్రస్ లను(addresses) ఒకే ఆబ్జెక్ట్ గా ఉన్నట్లయితే వారి అడ్రస్ లను(addresses) ఒకే విధంగా ఉండాలి; అడ్రస్ లను(addresses) వేరుగా ఉంటే అవి ఒకే ఆబ్జెక్ట్ కాదు.
64. కాబట్టి, అడ్రస్ లను వేర్వేరుగా ఉన్నట్లయితే, మీరు చేసేదాన్ని కేవలం తనిఖీ చేస్తారు.
65. అడ్రస్ లను(addresses) వేర్వేరుగా ఉన్నట్లయితే, కాపీ ద్వారా మీరు పాస్ అయినట్లైతే సాధారణమైనది కాదు.
66. సో, ఈ కాపీని అప్పగించటం ఆపరేటర్లో సెల్ఫ్ కాపీ గురించి చిన్న విషయం మీరు ఎల్లప్పుడూ మనసులో ఉంచుకోవాలి మరియు ఇది ఒక కాపీని అప్పగింత ఆపరేటర్ను వ్రాయడానికి ప్రత్యేకమైన మార్గం, ప్రత్యేకించి మీకు మీరు డేటా మెంబర్ పాయింటర్ టైప్ కలిగి ఉంటారు.
67. కాపీ అసైన్మెంట్ ఆపరేటర్(copy assignment operator) యొక్కసంతకం(signature), మేము ఇప్పటికే చూసిన.
68. ఇది ఒక ప్రత్యేకమైన సంతకం మరియు ఇది మీరు మొదట సెల్ఫ్ కాపి కోసం తనిఖీ చేసినట్లు చూపించిన ఒక ప్రాధమిక structure, అప్పుడు మీరు ప్రస్తుతం ఉన్న ఆబ్జెక్ట్ ద్వారా నిర్వహించబడుతున్న రీసోర్స్ లను విడుదల చేసి, ఆపై మిగిలిన మెంబర్ లను current ఆబ్జెక్ట్ కాపీ చేయండి.
69. అనగా, మీరు తారాగణాన్ని ఉపయోగించకపోవటం కూడా సాధ్యమే. మీరు పరామితిలో స్థిరంగా లేకుండా ఒక కాపీని చేస్తారు.
70. సో, ఇది కాపీ సమయంలో అర్థం మీరు నుండి కాపి చేస్తున్న ఆబ్జెక్ట్ మార్చవచ్చు మరియు మేము ఈ ప్రత్యేక లక్షణం ఉంటుంది పేరు స్మార్ట్ గమనికలు అని పిలుస్తారు కొన్ని స్మార్ట్ డిజైన్లలో(smart designs), డిజైన్ పరంగా చాలా తీవ్రమైన ఉపయోగం అని చూస్తారు. విస్తృతంగా ఉపయోగించారు, అయితే ఆ సమయంలో వచ్చినప్పుడు మరియు అనేక ఇతర సంతకాలు ఉన్నాయి; నేను వాటిని లిస్ట్ చేసాను.
71. అర్థం చేసుకోవడానికి లేదా వీటిని అనుమతించిన వాటిని గుర్తుంచుకోవడానికి చాలా ప్రయత్నాలు చేయవద్దు మరియు ఇవి అప్పుడప్పుడు ఉపయోగించబడతాయి, కానీ అవి పరిస్థితిలో చాలా అరుదుగా ఉంటాయి.
72. కాబట్టి, అలాంటి కాపీ అసైన్మెంట్(copy assignment) ఆపరేటర్లు సాధ్యమే, కానీ మీరు దీన్ని ప్రధానంగా ఉపయోగించుకుంటారు మరియు కొన్ని సందర్భాల్లో దీన్ని ఉపయోగించుకుంటారు.
73. కాబట్టి, ఇక్కడ మొత్తమ్మీద మేము కాపీ కన్స్ట్రక్టర్(copy constructors) చూసాము, అక్కడ కొత్త ఆబ్జెక్ట్ సృష్టించబడింది, ఈ కొత్త ఆబ్జెక్ట్ మరొక ఆబ్జెక్ట్ యొక్క డేటా మెంబర్ యొక్క విలువతో ప్రారంభమవుతుంది మరియు కాపీ యొక్క ప్రధాన అవసరం కాపి కన్స్ట్రక్షన్(copy construction) విలువ ద్వారా కాల్ కోసం జరుగుతుంది మరియు డిఫైన్డ్ టైప్(defined type) డేటా మెంబర్లను ఉపయోగించడం ప్రారంభించడం కోసం.
74. కాపీ కన్స్ట్రక్టర్ యూజర్ చేత అందించబడతారు, అయితే వినియోగదారు కాపీని కన్స్ట్రక్టర్(copy constructor) చేయకపోతే అప్పుడు కంపైలర్ ఒక కాపీని తయారుచేస్తుంది, ఇది ఒక బిట్ కాపీ(bit copy) వలె ఉంటుంది.
75. మేము కాపీని అప్పగించిన ఆపరేటర్ గురించి చర్చించాము, ఇది ఆబ్జెక్ట్ ఇప్పటికే ఉన్నపుడు కాపీని చేస్తోంది.
76. కాబట్టి, ఇది ఇప్పటికే ఇప్పటికే ప్రారంభించబడి ఉంటుంది, అప్పుడు ఆ ఆబ్జెక్ట్ యొక్క మెంబర్ నుండి భర్తీ చేయవలసి ఉంటుంది, మరియు కాపీ అప్పగించిన ఆపరేటర్ సెల్ఫ్ కాపీలో ముఖ్యమైన సమస్యగా ఉంటుంది మరియు జాగ్రత్త తీసుకోవాలి.
77. మరలా దయచేసి ఇది స్పష్టంగా స్లయిడ్లో వ్రాయబడలేదని దయచేసి గుర్తుంచుకోండి, అయితే దయచేసి వినియోగదారు కాపీని అప్పగించిన ఆపరేటర్ను అందించకపోతే, కానీ దానిని ప్రోగ్రామ్లో ఉపయోగిస్తుంటే దయచేసి కంపైలర్ ఫ్రీ కాపీని అసైన్మెంట్ ఆపరేటర్ను(copy assignment operator) అందిస్తుంది, మళ్లీ ఇష్టం; కాపీని కలిగి ఉన్న నిర్దిష్ట అవసరాలను పరిగణనలోకి తీసుకోకుండా ఫ్రీ కాపీ కన్స్ట్రక్టర్ కాపీరైటు మరలా ఒక బిట్ వారీగా కాపీని చేస్తుంది.
78. కాబట్టి, తయారీదారులాగే, మీరు కాపీలు తయారు చేయగల తరగతికి లేదా రూపకల్పనలో విలువలో విధులు జారీ చేయబడగల చోటును రూపొందిస్తున్నప్పుడు, మీరు నకలు తయారీదారు మరియు కాపీ అప్పగింత ఆపరేటర్ను కూడా అందించాలి.
79. ప్రత్యేకమైన పరంగా, మేము ఇక్కడ ఉన్న లోతైన మరియు నిస్సార కాపీల భావాలను కూడా గమనించాము.
80. దయచేసి గుర్తుంచుకోండి, నిస్సార కాపీని పాయింటర్ను కాపీ చేస్తాను.
81. కాబట్టి ఒక నిస్సార కాపీ తర్వాత ఒకే ఆబ్జెక్ట్ మరియు లోతైన కాపీకి ఒకటి కంటే ఎక్కువ పాయింట్ పాయింటర్ పాయింట్లు పాయింటర్ను కాపీ చేయదు, అది సూచించబడిన ఆబ్జెక్ట్ ను కాపీ చేస్తుంది.
82. అందువల్ల, డీపైన కాపీ(deep copy)తర్వాత 2 గమనికలు బహుశా ఈ రెండు విభిన్న కాపీలు ఇదే బహుశా ఒకే ఆబ్జెక్ట్ తరువాత, కానీ అవి వివిధ ఆబ్జెక్ట్ లు మారింది.
83. కాబట్టి, డీపైన కాపీ(deep copy)మరియు షాలో కాపీ(shallow copy)సహజంగా న్యాయంగా ఉపయోగించబడుతుంది.
84. ఇది అవసరమైతే ఖచ్చితంగా ఉండకపోతే, మేము డీప్ కాపీని చేయటానికి ప్రయత్నించము ఎందుకంటే ఎందుకంటే అది సున్నితమైనదిగా ఉన్న కాచెడ్ డేటా యొక్క కాపీని కలిగి ఉంటుంది, ఎందుకంటే పునరావృత తర్కం ద్వారా మళ్లీ కాపీ కన్స్ట్రక్షన్(copy construction) అవసరం అవుతుంది, కానీ భద్రత పరంగా, డీపైన కాపీ(deep copy)ని ఉపయోగించి షాలో కాపీ(shallow copy)ని ఉపయోగించి పోలిస్తే తరచూ మరింత సురక్షితం.
85.
 ప్రోగ్రామింగ్ ఇన్ C++ లో మాడ్యూల్ 14 కు స్వాగతం.
మేము కాపీ గురించి చర్చించాము, మేము లోతుగా కాపీ కన్స్ట్రక్టర్ గురించి చర్చించాము మరియు కాపీ అసైన్మెంట్ ఆపరేటర్ అంటే ఏమిటో పరిచయం చేసాము.
త్వరగా రీక్యాప్ చేయడానికి, మీరు ఒక ఆబ్జెక్ట్ యొక్క క్లోన్ను తయారు చేయాలని కోరుకున్నప్పుడు మేము ఒక కాపీ కన్స్ట్రక్షన్(copy construction) చేస్తాము మరియు మేము ఇప్పటికే ఉన్న ఆబ్జెక్ట్ ను కలిగి ఉన్నప్పుడు, కాపీని అసైన్మెంట్ చేస్తాము మరియు అదే రకమైన మరొక ఆబ్జెక్ట్ ను ప్రస్తుత ఆబ్జెక్ట్ లో కాపీ చేయాలనుకుంటున్నాము.
ఒక కాపీని ఆపరేటర్ ఫంక్షన్గా(operator function) నిర్వచించవచ్చని మేము చూశాము; ఆపరేటర్ ఫంక్షన్ మరియు ఇది పారామితిని క్లాస్ యొక్క కాన్సస్టెంట్ రెఫరెన్స్(constant reference) గా తీసుకుంటుంది మరియు అదే క్లాస్ యొక్కనాన్- కాన్సస్టెంట్ రెఫరెన్స్(non-constant reference) ను తిరిగి ఇస్తుంది, ఇది క్లాస్ యొక్క కాన్సస్టెంట్ రెఫరెన్స్(constant reference)ను కూడా తిరిగి పొందవచ్చు.
ఇప్పుడు, కాపీ అసైన్మెంట్ యొక్క మరింత గమ్మత్తైన ప్రాంతాలలో కొన్నింటిని పరిశీలిస్తాము.
సో, మీరు కాపీ కన్స్ట్రక్షన్ పరంగా, మీరు ఇప్పటికే shallow కాపీ మరియు deep కాపీని యొక్క భావం వివరించారు గుర్తుచేసుకున్నారు.
ఇప్పుడు shallow కాపీ మరియు deep కాపీ యొక్క పరిణామాలు కూడా కాపీ అప్పగింతలోకి వక్రీకరిస్తాయని మేము చూస్తాము.
కాబట్టి, ప్రత్యేకంగా దీన్ని స్ట్రింగ్ ఉదాహరణగా దృష్టి పెట్టండి మరియు కాపీ అసైన్మెంట్ ఆపరేటర్ పై దృష్టి పెట్టండి.
ఇప్పుడు, మీరు ఏమి ప్రయత్నిస్తున్నారు? ఇది మీ; నాకు కేవలం రెండు ఆబ్జెక్ట్ లను గీయండి.
ఈ s1 ఉంది, ఈ s2 ఉంది .
సో, ఈ ఫుట్బాల్(football) ఉంది.
కాబట్టి, అది ఏమంటే, అది పొడవు(length) 8 ఉంటుంది. ఇది క్రికెట్; ఇది పొడవు(length) 7 ఉంటుంది. ఇప్పుడు, నేను కాపీ చేయడానికి ప్రయత్నిస్తున్నాను.
కాబట్టి, నేను s2ను  s1 కి కేటాయించడానికి ప్రయత్నిస్తాను.
కాబట్టి, నేను దీనిని కాపీ చేస్తే; సహజంగా నేను కాపీ చేస్తున్నప్పుడు ఈ స్ట్రింగ్ ఇక్కడ కాపీ చేయబడిందని నాకు తెలుసు మరియు దీనికి రెండు ఎంపికలు ఉన్నాయి అని మాకు తెలుసు.
ఒక పాయింటర్ కాపీ ఉంది; ఇతర వాస్తవానికి ఆబ్జెక్ట్ ను కాపీ చేయడం.
కాబట్టి, మేము డీప్ కాపీని చేయాలనుకుంటున్నాము, ఈ సందర్భంలో మేము ఒక లోతైన కాపీని చేస్తున్నాము.
కాబట్టి, మీరు ఒక పారామితి యొక్క strdup ను తయారు చేస్తున్నారు, ఇది ప్రధానంగా s1 యొక్క strdup.
ఇప్పుడు, మీరు దానిని str కు అప్పగిస్తే ఏమి జరుగుతుంది? కేవలం, మరొక ఫుట్బాల్ సృష్టించింది, strdup మేము డూప్లికేట్(duplicate) చేసిన.
కాబట్టి, మరో ఫుట్బాల్ క్రరియేట్ చేసింది.
ఇప్పుడు, నేను ఈ పాయింటర్ను str గా ఉంచినట్లయితే, సహజంగా నేను ఈ పాయింటర్ ను కోల్పోతాను మరియు ఈ స్ట్రింగ్ను తిరిగి పొందటానికి ఏ మార్గం లేదు.
కాబట్టి, నేను దీన్ని ముందు, నేను ఫ్రీ(free) చేయవలసి ఉంటుంది, లేకపోతే రీసోర్స్(resource) ని లీక్ చేస్తుంది, మెమరీ లీక్ అవుతుంది.
కాబట్టి, ఇది ముఖ్యమైన అంశం.
నేను మొదట దీన్ని విడిపించాను, అప్పుడు నేను స్ట్రింగ్ కాపీని చేస్తున్నాను.
కాబట్టి, నేను ఈ విడివిడిగా ఈ పోయింది, నేను ఒక strdup చేయండి.
ఇప్పుడు, నేను ఇక్కడ ఒక కొత్త ఫుట్బాల్ సూచించాను, ఇది కాపీ చేయబడుతుంది.
కాబట్టి, ఇది ఇక్కడ 8 గా మారుతుంది మరియు గత సందర్భంలో చేసిన విధంగానే లక్ష్యం తిరిగి వస్తుంది.
ఇది ప్రాథమికంగా ఇది ప్రస్తుత ఆబ్జెక్ట్ (object) అని మొదట తెలియజేస్తుంది.
కాబట్టి, ఆ ఆబ్జెక్ట్ తిరిగి రావాల్సిన object ను తిరిగి ఇవ్వాలి ఎందుకంటే అది తిరిగి వస్తుంది.
కాబట్టి, నేను చెప్పినట్లుగా, ఈ ఆబ్జెక్ట్ ఇప్పుడు చైన్ అసైన్మెంట్(chain assignment) కోసం ఉపయోగించబడుతుంది.
నేను ఇప్పటికే వివరించినందున ఇది చైన్ అసైన్మెంట్(chain assignment) లో ఉపయోగించబడుతుంది.
అందువల్ల, ఈ ఆబ్జెక్ట్ లో ఉన్న పాయింటర్ మెంబర్లను కలిగి ఉన్నప్పుడల్లా, ఒక కాపీని ఒక డీప్ కాపీ(deep copy) కోసం ఉపయోగించవచ్చు.
ఇప్పుడు, మనం ఇప్పటికే చూచిన కోడ్తో చాలా చిన్న, కానీ అపాయకరమైన(dangerous) సమస్యగా చూద్దాం.
ఇది మీరు చూసిన సరిగ్గా ఉన్న కోడ్, ఇది s1 కు s2 ను మేము అధిగమించాము.
ఇప్పుడు, నేను s1 కు s1 ను కాపీ చేసాను.
ఇప్పుడు, మీరు చాలా చట్టబద్ధంగా నన్ను అడగవచ్చు, ఎందుకు ఎవరైనా ఈ రకమైన కోడ్ను రాయాలి, దానికి రెండు సమాధానాలు ఉన్నాయి; ఎవరైనా రాసినట్లయితే ఒకటి.
 ఏమి జరగబోతుందో మేము తెలుసుకోవాలి.
ఇతర సమస్య ఎల్లప్పుడూ కోడ్ ఇలా ఉంటుంది, ఉదాహరణకు, అది కావచ్చు; నేను స్ట్రింగ్ కలిగి, నేను S1 ఒక రెఫరెన్స్(reference) కలిగి ఎక్కడా జరుగుతుంది; ఇది ఎక్కడ జరిగిందో నాకు తెలియదు.
ఇది కొన్ని ఇతర ఫంక్షన్లో చేయబడి ఉండవచ్చు, కొన్ని ఇతర క్లాస్ లలో అది వచ్చినది మరియు ఇప్పుడు నేను s1 కేటాయించిన చేస్తున్నాను.
సిన్టాటిక్(Syntactically) గా, కోడ్ చూడటం అనేది ఒక సెల్ఫ్ కాపీ(self copy) వలె కనిపించడం లేదు, కానీ వాస్తవానికి ఇది సెల్ఫ్ కాపీ(self copy).
కాబట్టి, సెల్ఫ్ కాపీ(self copy) మేము పరిశీలించాల్సిన ఒక సంభావ్య పరిస్థితి(potential situation).
ఇప్పుడు ఖచ్చితంగా సమస్యలు ఉన్నాయని మేము చూస్తున్నాం.
కాబట్టి, దీనిని పరిశీలించండి సెల్ఫ్ కాపీ.
కాబట్టి, ఈ నేను ఏమి ఉంది, ఈ నా s 1, ఈ నా స్ట్రింగ్(my string), నా s1 ఫుట్బాల్ ఉంది.
కాబట్టి, నేను ఇక్కడ ఫుట్బాల్ మరియు వెయిట్(weight) కలిగి ఉన్నాను.
ఇప్పుడు, నేను s1 చేస్తాను ఈ ఒకటి అసైన్(assign) చేయండి.
కాబట్టి, ఏమి జరుగుతుంది? ఇది మొదట ఎగ్జిక్యూట్(execute) అవుతుంది, ఇది నా s1.
కాబట్టి, ఇది ఫ్రీ.
ఇప్పుడు, ఇది చేయటానికి ప్రయత్నిస్తుంది, అనగా, ఈ ఆబ్జెక్ట్ s డాట్ స్ట్రింగ్ ను తీసుకోవటానికి ప్రయత్నిస్తుంది, ఒక కాపీని తయారు చేసి ఆపై దాన్ని ఇక్కడ పెట్టండి.
ఇప్పుడు, ఈ ఆబ్జెక్ట్ ఇప్పటికే పోయిందని ఇది ఫ్రీ చేయబడింది.
కాబట్టి, ఇక్కడ మీరు ఏమి కాపీ చేస్తున్నారో తెలియదు, ప్రశ్న కాదు అది కేవలం తెలియదు, ఇది ఏదో ఇన్వాలిడ్(invalid) అయ్యేది మరియు ఆపై ఉంటుంది.
సో, మీరు కాపీని తర్వాత ప్రింట్ అయినప్పుడు ఊహించినంత నిశ్శబ్దంగా చేస్తే, మీరు చెత్తను సంపాదించిన తరువాత నేను గార్బేజ్(garbage) ను పొంది, ఒక చెత్త వచ్చింది, కానీ నేను గార్బేజ్(garbage) కు గురైనప్పుడు అది గార్బేజ్(garbage) గా ఉంటుంది, ఎందుకంటే ఇది మెమరీని ఎలా ఉల్లంఘిస్తుందో(violated) దానిపై ఆధారపడి ఉంటుంది.
సో, పాయింటర్ టైపుతో సెల్ఫ్ కాపీ ఇమేజ్ ఎదుర్కోవటానికి చాలా కష్టంగా ఉందని నిరూపించేది.
కాబట్టి, దాని గురించి ఏదో చేయవలసి ఉంటుంది.
కాబట్టి, మేము దీనిని నిర్వహించటం మరియు ఇది చాలా ప్రత్యేకంగా మీరు నేను సెల్ఫ్ కాపీ(self copy)ని చేస్తున్నట్లయితే, నేను ఇలా చేస్తే, అప్పుడు నా కాపీ అసైన్మెంట్ ఆపరేటర్(copy assignment operator) కాపీ చేయకూడదని చెప్పాలి.
మీరు ఒక సెల్ఫ్ కాపీ ని చేస్తున్నట్లయితే అప్పుడు నేను చెప్పాల్సిన అన్నిటిని కాపీ చేయడం లేదు ఎందుకంటే అది బైపాస్, ఇది ఒక ఆబ్జెక్ట్ .
కాబట్టి, కోడ్ మిగిలిన ఉంది, కానీ నేను జోడించే అన్ని ఇది ఒక ఆబ్జెక్ట్ ఉంటే తనిఖీ ఉంది.
ఇది ఒకే ఆబ్జెక్ట్ అయితే నేను ఎలా తనిఖీ చేయాలి? S1 s1 అసైన్ చేయబడుతుందని అర్థం.
కాబట్టి, ఇది s1 డాట్ ఆపరేటర్లు కేటాయింపు s1, ఇది s అవుతుంది మరియు ఇది ఆబ్జెక్టు జరుగుతున్న ఆబ్జెక్ట్ , కాబట్టి ఇది * ఇది.
కాబట్టి, మీరు ఈ మరియు s star లేదో చూడాలనుకుంటున్నారా.
మేము ఈ ఆబ్జెక్ట్ లను పోల్చుకోలేము ఎందుకంటే ఇది ఏ ఆబ్జెక్ట్ అయినా కావచ్చు, దానికి పోలిక ఆపరేటర్ లేదు.
ఈ నేను పూర్ణాంకానికి సమానంగా వ్రాసే పూర్ణాంకం లాంటిది కాదు కానీ నాకు తెలిసినది ఏమిటంటే అది ఒకే ఆబ్జెక్ట్ అయితే అది కొన్ని మెమరీలో ఉంటుంది.
కాబట్టి, ఈ 2 ఒకే విధంగా వుండాలి, అప్పుడు ఇది s & s వలె ఉంటుంది.
అడ్రస్ లను(addresses) ఒకే ఆబ్జెక్ట్ గా ఉన్నట్లయితే వారి అడ్రస్ లను(addresses) ఒకే విధంగా ఉండాలి; అడ్రస్ లను(addresses) వేరుగా ఉంటే అవి ఒకే ఆబ్జెక్ట్ కాదు.
కాబట్టి, అడ్రస్ లను వేర్వేరుగా ఉన్నట్లయితే, మీరు చేసేదాన్ని కేవలం తనిఖీ చేస్తారు.
అడ్రస్ లను(addresses) వేర్వేరుగా ఉన్నట్లయితే, కాపీ ద్వారా మీరు పాస్ అయినట్లైతే సాధారణమైనది కాదు.
సో, ఈ కాపీని అప్పగించటం ఆపరేటర్లో సెల్ఫ్ కాపీ గురించి చిన్న విషయం మీరు ఎల్లప్పుడూ మనసులో ఉంచుకోవాలి మరియు ఇది ఒక కాపీని అప్పగింత ఆపరేటర్ను వ్రాయడానికి ప్రత్యేకమైన మార్గం, ప్రత్యేకించి మీకు మీరు డేటా మెంబర్ పాయింటర్ టైప్ కలిగి ఉంటారు.
కాపీ అసైన్మెంట్ ఆపరేటర్(copy assignment operator) యొక్కసంతకం(signature), మేము ఇప్పటికే చూసిన.
ఇది ఒక ప్రత్యేకమైన సంతకం మరియు ఇది మీరు మొదట సెల్ఫ్ కాపి కోసం తనిఖీ చేసినట్లు చూపించిన ఒక ప్రాధమిక structure, అప్పుడు మీరు ప్రస్తుతం ఉన్న ఆబ్జెక్ట్ ద్వారా నిర్వహించబడుతున్న రీసోర్స్ లను విడుదల చేసి, ఆపై మిగిలిన మెంబర్ లను current ఆబ్జెక్ట్ కాపీ చేయండి.
అనగా, మీరు తారాగణాన్ని ఉపయోగించకపోవటం కూడా సాధ్యమే. మీరు పరామితిలో స్థిరంగా లేకుండా ఒక కాపీని చేస్తారు.
సో, ఇది కాపీ సమయంలో అర్థం మీరు నుండి కాపి చేస్తున్న ఆబ్జెక్ట్ మార్చవచ్చు మరియు మేము ఈ ప్రత్యేక లక్షణం ఉంటుంది పేరు స్మార్ట్ గమనికలు అని పిలుస్తారు కొన్ని స్మార్ట్ డిజైన్లలో(smart designs), డిజైన్ పరంగా చాలా తీవ్రమైన ఉపయోగం అని చూస్తారు. విస్తృతంగా ఉపయోగించారు, అయితే ఆ సమయంలో వచ్చినప్పుడు మరియు అనేక ఇతర సంతకాలు ఉన్నాయి; నేను వాటిని లిస్ట్ చేసాను.
అర్థం చేసుకోవడానికి లేదా వీటిని అనుమతించిన వాటిని గుర్తుంచుకోవడానికి చాలా ప్రయత్నాలు చేయవద్దు మరియు ఇవి అప్పుడప్పుడు ఉపయోగించబడతాయి, కానీ అవి పరిస్థితిలో చాలా అరుదుగా ఉంటాయి.
కాబట్టి, అలాంటి కాపీ అసైన్మెంట్(copy assignment) ఆపరేటర్లు సాధ్యమే, కానీ మీరు దీన్ని ప్రధానంగా ఉపయోగించుకుంటారు మరియు కొన్ని సందర్భాల్లో దీన్ని ఉపయోగించుకుంటారు.
కాబట్టి, ఇక్కడ మొత్తమ్మీద మేము కాపీ కన్స్ట్రక్టర్(copy constructors) చూసాము, అక్కడ కొత్త ఆబ్జెక్ట్ సృష్టించబడింది, ఈ కొత్త ఆబ్జెక్ట్ మరొక ఆబ్జెక్ట్ యొక్క డేటా మెంబర్ యొక్క విలువతో ప్రారంభమవుతుంది మరియు కాపీ యొక్క ప్రధాన అవసరం కాపి కన్స్ట్రక్షన్(copy construction) విలువ ద్వారా కాల్ కోసం జరుగుతుంది మరియు డిఫైన్డ్ టైప్(defined type) డేటా మెంబర్లను ఉపయోగించడం ప్రారంభించడం కోసం.
కాపీ కన్స్ట్రక్టర్ యూజర్ చేత అందించబడతారు, అయితే వినియోగదారు కాపీని కన్స్ట్రక్టర్(copy constructor) చేయకపోతే అప్పుడు కంపైలర్ ఒక కాపీని తయారుచేస్తుంది, ఇది ఒక బిట్ కాపీ(bit copy) వలె ఉంటుంది.
మేము కాపీని అప్పగించిన ఆపరేటర్ గురించి చర్చించాము, ఇది ఆబ్జెక్ట్ ఇప్పటికే ఉన్నపుడు కాపీని చేస్తోంది.
కాబట్టి, ఇది ఇప్పటికే ఇప్పటికే ప్రారంభించబడి ఉంటుంది, అప్పుడు ఆ ఆబ్జెక్ట్ యొక్క మెంబర్ నుండి భర్తీ చేయవలసి ఉంటుంది, మరియు కాపీ అప్పగించిన ఆపరేటర్ సెల్ఫ్ కాపీలో ముఖ్యమైన సమస్యగా ఉంటుంది మరియు జాగ్రత్త తీసుకోవాలి.
మరలా దయచేసి ఇది స్పష్టంగా స్లయిడ్లో వ్రాయబడలేదని దయచేసి గుర్తుంచుకోండి, అయితే దయచేసి వినియోగదారు కాపీని అప్పగించిన ఆపరేటర్ను అందించకపోతే, కానీ దానిని ప్రోగ్రామ్లో ఉపయోగిస్తుంటే దయచేసి కంపైలర్ ఫ్రీ కాపీని అసైన్మెంట్ ఆపరేటర్ను(copy assignment operator) అందిస్తుంది, మళ్లీ ఇష్టం; కాపీని కలిగి ఉన్న నిర్దిష్ట అవసరాలను పరిగణనలోకి తీసుకోకుండా ఫ్రీ కాపీ కన్స్ట్రక్టర్ కాపీరైటు మరలా ఒక బిట్ వారీగా కాపీని చేస్తుంది.
కాబట్టి, తయారీదారులాగే, మీరు కాపీలు తయారు చేయగల తరగతికి లేదా రూపకల్పనలో విలువలో విధులు జారీ చేయబడగల చోటును రూపొందిస్తున్నప్పుడు, మీరు నకలు తయారీదారు మరియు కాపీ అప్పగింత ఆపరేటర్ను కూడా అందించాలి.
ప్రత్యేకమైన పరంగా, మేము ఇక్కడ ఉన్న లోతైన మరియు నిస్సార కాపీల భావాలను కూడా గమనించాము.
దయచేసి గుర్తుంచుకోండి, నిస్సార కాపీని పాయింటర్ను కాపీ చేస్తాను.
కాబట్టి ఒక నిస్సార కాపీ తర్వాత ఒకే ఆబ్జెక్ట్ మరియు లోతైన కాపీకి ఒకటి కంటే ఎక్కువ పాయింట్ పాయింటర్ పాయింట్లు పాయింటర్ను కాపీ చేయదు, అది సూచించబడిన ఆబ్జెక్ట్ ను కాపీ చేస్తుంది.
అందువల్ల, డీపైన కాపీ(deep copy)తర్వాత 2 గమనికలు బహుశా ఈ రెండు విభిన్న కాపీలు ఇదే బహుశా ఒకే ఆబ్జెక్ట్ తరువాత, కానీ అవి వివిధ ఆబ్జెక్ట్ లు మారింది.
కాబట్టి, డీపైన కాపీ(deep copy)మరియు షాలో కాపీ(shallow copy)సహజంగా న్యాయంగా ఉపయోగించబడుతుంది.
ఇది అవసరమైతే ఖచ్చితంగా ఉండకపోతే, మేము డీప్ కాపీని చేయటానికి ప్రయత్నించము ఎందుకంటే ఎందుకంటే అది సున్నితమైనదిగా ఉన్న కాచెడ్ డేటా యొక్క కాపీని కలిగి ఉంటుంది, ఎందుకంటే పునరావృత తర్కం ద్వారా మళ్లీ కాపీ కన్స్ట్రక్షన్(copy construction) అవసరం అవుతుంది, కానీ భద్రత పరంగా, డీపైన కాపీ(deep copy)ని ఉపయోగించి షాలో కాపీ(shallow copy)ని ఉపయోగించి పోలిస్తే తరచూ మరింత సురక్షితం.
inhouse/NPTEL/PreFinal/c++/Telugu/11. ProgramminginCplusplus_Operator Overloading (Contd.) (Lecture 16)-0jpOwe4d-FE.txt
View file @ 956c0d4e
 1. C++ లో ప్రోగ్రామింగ్ మాడ్యూల్ 9 కు స్వాగతం.
2. ఆపరేటర్ ఓవర్లోడింగ్ గురించి మేము చర్చించాము.
3. ఆపరేటర్లు మరియు ఫంక్షన్ల మధ్య సారూప్యతలు మరియు వ్యత్యాసాలను మేము చూశాము మరియు C ++ లో, ఆపరేటర్ ఫంక్షన్లను నిర్వచించడానికి మరియు ఓవర్లోడ్ చేయడానికి ఫీచర్లు ఎలా అందించబడ్డాయో చూశాము మరియు దీనికి అదనంగా, ఆపరేటర్ ప్లస్ ఓవర్లోడ్ చేయడానికి మునుపటి విభాగంలో మాకు రెండు ఉదాహరణలు ఉన్నాయి (ఆపరేటర్ +) స్ట్రింగ్ రకం కోసం మేము రెండు తీగలను నిర్వచించాము మరియు సంక్షిప్తీకరించాము.మరియు రకాలు కోసం క్లోజ్డ్ యాడ్ ఆపరేషన్ ఎలా చేయవచ్చో చూపించడానికి, ఆపరేటర్‌ను వేరే రకం సందర్భంలో అదనపు రకంతో ఓవర్‌లోడ్ చేసాము.
4. ఇప్పుడు, మేము ముందుకు వెళ్లి, ఓవర్‌లోడ్ చేయగల దాని గురించి మరియు మీరు మీ స్వంత రకాన్ని, ఏ రకమైన ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయవచ్చో నిర్వచిస్తుంటే ఎలా మరియు ఏమి జరుగుతుందో గురించి మరింత తెలుసుకుంటాము మరియు మీరు దీన్ని ఎలా చేయగలరు? ఏమి సాధ్యమవుతుంది? సాధ్యం కాదు సలహా మరియు మొదలైనవి ఏమిటి? అందువల్ల, నేను ఇక్కడ నిబంధనల సారాంశాన్ని ప్రదర్శిస్తున్నాను.
5. వాటిని చాలా జాగ్రత్తగా చూద్దాం.
6. మొదట సహజంగా; మేము మీ మొదటి ప్రశ్నను ఓవర్‌లోడ్ చేయవలసి వస్తే - ఓవర్‌లోడ్ చేయగల ఆపరేటర్ ఏది? ఖచ్చితంగా, C ++ లో చాలా మంది ఆపరేటర్లు ఉన్నారు; ప్లస్, మైనస్, డివిజన్, గుణకారం, అసైన్‌మెంట్, అసైన్‌మెంట్ల యొక్క వివిధ రకాల పొడిగింపులు, ఇవన్నీ ఉన్నాయి.
7. కాబట్టి, మీరు క్రొత్త ఆపరేటర్ చిహ్నాన్ని నిర్వచించి దాన్ని ఓవర్‌లోడ్ చేయగలరా? మీకు ప్రశ్న ఉంటే, సమాధానం లేదు; మీరు సిస్టమ్‌లో నిర్వచించిన ఆపరేటర్ల సమితికి మాత్రమే మిమ్మల్ని పరిమితం చేయాలి.
8. ఉదాహరణకు, నాకు ఓవర్‌లోడింగ్ ఉందని మీరు చెప్పలేరు; ఈ ఆపరేటర్ చెప్పడానికి లేదా నాకు ఈ ఆపరేటర్ ఉంటుంది.
9. వాస్తవానికి, మీలో కొందరు పాస్కల్‌లో పాత ప్రోగ్రామర్లు, ఇది పాస్కల్‌లో అసమానత అని మీరు గుర్తిస్తారు, అయితే ఇది సి ++ లో నిర్వచించబడిన చిహ్నం కాదు.
10. అందువల్ల, మీరు కొత్త చిహ్నాలతో ఆపరేటర్లను ఓవర్‌లోడ్ చేయలేరు.
11. మీరు ఆపరేటర్‌ను ఓవర్‌లోడ్ చేసినప్పుడు చాలా ముఖ్యమైన రెండవ విషయం; మీరు దాని అంతర్గత లక్షణాలను మార్చలేరు.
12. అంతర్గత లక్షణాలు ఒకే విధంగా ఉండాలి మరియు ఆపరేటర్ కోసం 3 అంతర్గత లక్షణాలు ఉన్నాయి; ఒక సంఖ్య ఉందా, దీనికి అనేక రకాల ఆపరేషన్లు ఉన్నాయి, ఇతర ఆపరేటర్లు మరియు సహకార సంస్థలకు సంబంధించి వారి ఆపరేటర్ల సమూహానికి లేదా ఇలాంటి ఆపరేషన్ల ఆపరేటర్లకు సంబంధించి ప్రాధాన్యత.
13. ఈ 3 అంతర్గత లక్షణాలను మార్చలేము.
14. కాబట్టి, మీరు వాదించినట్లయితే, నాకు ఆపరేటర్ ప్లస్ ఉంది, దీనిని ఇలా వ్రాయవచ్చు లేదా దీన్ని ఇలా వ్రాయవచ్చు.
15. నాకు ఆపరేటర్ మైనస్ ఉంది, దీనిని ఇలా వ్రాయవచ్చు, దీనిని ఇలా వ్రాయవచ్చు.
16. కాబట్టి, ఇది ఇక్కడ ఉందని అర్థం, అరిటీ 2, ఇక్కడ అరిటీ 1, కానీ అలాంటి మార్పులు మాత్రమే మీరు మీరే చేయలేరు.
17. ఆపరేటర్ కోసం బహుళ సంస్కరణలు ఉంటే మరియు వేర్వేరు పూర్వీకులు మరియు సానుభూతులు ఒకే విధంగా నిర్వచించబడితే, మీరు దాని ద్వారా వెళ్ళాలి, కానీ మీరు చేయలేరు; ఆపరేటర్లు ఎవరూ దాని స్వచ్ఛత ప్రాధాన్యత మరియు సానుభూతిని నిర్వచించరు లేదా మార్చరు.
18. కాబట్టి, అంతర్గత లక్షణాలను పూర్తిగా గౌరవించాలి.
19. మూడవది జాబితా; C ++ లో సాధారణంగా ఉపయోగించే 38 ఆపరేటర్లు ఇవి ఓవర్‌లోడ్ చేయగలవు.
20. కాబట్టి, మీరు ప్రాథమిక అంకగణిత ఆపరేటర్ మరియు మొత్తం అసైన్‌మెంట్ ఆపరేటర్‌తో సహా మీరు ఆలోచించగలిగే దాదాపు అన్ని ఆపరేటర్లను కలిగి ఉన్నారని మీరు చూడవచ్చు, అప్పుడు మీ షిఫ్ట్ ఆపరేటర్, మీ లాజికల్ ఆపరేటర్, మీ పాయింటర్ రిఫరెన్సింగ్ ఆపరేటర్, మీ అర్రే ఆపరేటర్, మీ ఫంక్షన్ ఆపరేటర్ మరియు కాబట్టి.
21. కాబట్టి, ఇవన్నీ ఓవర్‌లోడ్ చేయవచ్చు.
22. మీకు యూనిరీ ఆపరేటర్ ఉంటే, మీకు తెలిసినట్లుగా రెండు రకాల యూనిరీ ఆపరేటర్లు, ఒపెరాండ్‌కు ముందు ఉన్న ఉపసర్గ ఆపరేటర్. ఉన్నారా, ఇది ఇలా ఉంటుంది; వీరంతా ఉపసర్గ ఆపరేటర్లు లేదా వారు పోస్ట్ ఫిక్స్ రకానికి చెందినవారు కావచ్చు.
23. కాబట్టి, ప్రశ్న ప్రత్యేకంగా అదే ఆపరేటర్, మీరు ++ చూస్తే, నేను ++ వ్రాయగలను లేదా నేను ++ వ్రాయగలను.
24. ప్రశ్న సహజంగా ఒక ఆపరేటర్ మరియు తరువాత ఆపరేటర్ ఫంక్షన్ మధ్య కరస్పాండెన్స్ ఇవ్వబడుతుంది, ఆపరేటర్ ఆపరేటర్ ఫంక్షన్ (ఫంక్షన్) ఆపరేటర్ ఆపరేటర్కు మాత్రమే ఆపరేటర్ ఆపరేటర్ అని మేము చెప్పాము.
25. కాబట్టి, ఇది ఆపరేటర్ చిహ్నం తరువాత ఆపరేటర్ చిహ్నం.
26. కాబట్టి, ఈ రెండు తప్పనిసరిగా ఒకే ఆపరేటర్ పేరును కలిగి ఉంటాయి.
27. కాబట్టి, మీ ప్రశ్న ఉంటుంది, కానీ అవి వేర్వేరు ఆపరేటర్లు, ఉపసర్గ మరియు పోస్ట్ పరిష్కారాలు వేర్వేరు ఆపరేటర్లు, ప్రీ-ఇంక్రిమెంట్ మరియు పోస్ట్-ఇంక్రిమెంట్ వేర్వేరు ప్రవర్తన.
28. కాబట్టి, మేము దానిని ఎలా వేరు చేస్తాము? కాబట్టి, ఈ రెండు పాయింట్లలో మీరు అప్రెంటిస్ ఆపరేటర్ ఉపసర్గ అయితే, ఈ విధంగా మీరు దీనిని వ్రాస్తే, సంతకం ఇలా కనిపిస్తుంది, ఇది మీ రకానికి భిన్నంగా ఉంటుంది మరియు ఇది వస్తుంది ఇంక్రిమెంట్ తర్వాత తీసుకున్న ఒపెరాండ్‌కు తిరిగి వెళ్ళు.
29. అయితే, ఈ పోస్ట్ ఫిక్స్ ఆపరేటర్ అయితే, ఆసక్తికరమైన విషయం ఏమిటంటే, మీరు ఒక పూర్ణాంకానికి మరొక పరామితిగా పేర్కొనాలి మరియు ఈ పూర్ణాంకానికి నిజంగా క్రియాశీల పరామితి కాదు.
30. మీరు నిజంగా టిని ఇన్వోక్ చేసినప్పుడు, అది ఆపరేటర్. మీరు పాస్ చేయబోతున్నారనే ఉద్దేశ్యం లేదు, అది కేవలం సంతకంలో ఉంది.
31. ఆపరేటర్ ఆపరేటర్ యొక్క ఈ ఉదాహరణ పోస్ట్ ఫిక్స్ రకం కోసం కాదా మరియు ఉపసర్గ రకం కాదా అని కంపైలర్ నిర్ణయించడంలో ఇది సహాయపడుతుంది.
32. కాబట్టి, నేను ++ వ్రాస్తే అది చెడుగా కనిపిస్తుంది.
33. నేను ++ a వ్రాస్తే, ఇది ఇలా అనిపిస్తుంది.
34. సర్‌చార్జ్ కోసం ఉపసర్గ మరియు పోస్ట్ యునరీ ఆపరేటర్లను పరిష్కరించడానికి ఇది ప్రాథమిక విధానం.
35. తరువాత, స్కోప్ రిజల్యూషన్ ఆపరేటర్ లాగా ఓవర్లోడ్ చేయడానికి అనుమతించని కొన్ని ఆపరేటర్లు ఉన్నారని దయచేసి గమనించండి, ఉదాహరణకు, సభ్యుని ఉపయోగించడం వంటివి, ఉదాహరణకు, మనకు ఒక నిర్మాణం ఉంటే, కాబట్టి మేము Ri మరియు Im తో సంక్లిష్ట నిర్మాణాన్ని భాగాలుగా చూశాము.
36. కాబట్టి, నేను నిర్మాణానికి పేరు పెట్టవచ్చు మరియు చుక్కను ఉంచగలను.
37. కాబట్టి, ఇది నిర్మాణం యొక్క పున-భాగం.
38. అందువల్ల, సభ్యుల ప్రాప్యత ఓవర్‌లోడ్ చేయబడదు.
39. ఏదైనా వేరియబుల్ లేదా రకం యొక్క బైట్ల సంఖ్యను కనుగొనడానికి పరిమాణాన్ని ఓవర్‌లోడ్ చేయలేము; టెర్నరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయలేము మరియు మొదలైనవి.
40. తార్కిక మరియు తార్కిక లేదా కామాలతో ఓవర్‌లోడ్ చేయడానికి అనుమతించబడిన కొన్ని ఆపరేటర్లు ఉన్నారు.
41. అయితే మీరు వాటిని ఓవర్‌లోడ్ చేస్తే, వాటి ప్రాథమిక లక్షణాలు, కొన్ని అదనపు లక్షణాలు నాశనం అవుతాయని మీరు గుర్తుంచుకోవాలి.
42. ఇది ఆంపర్సండ్ 'లాజికల్' మరియు 'నేను ఈ వ్యక్తీకరణను వ్రాస్తే (a = = b && b = = c), ఇది తార్కికం మరియు దాని ప్రవర్తన ఏమిటంటే వ్యక్తీకరణ యొక్క ఈ భాగం కనుగొనబడితే అది అబద్ధం. కనుక ఇది లేదు రెండవ భాగాన్ని అంచనా వేయండి.
43. వ్యక్తీకరణ యొక్క ఈ భాగం తప్పుగా ఉంటే, అది రెండవ భాగాన్ని అంచనా వేయదు, మీరు వాదన యొక్క ఖచ్చితత్వాన్ని చూస్తున్నారా.
44. A కి సమానం కాకపోతే; a మరియు b భిన్నంగా ఉంటాయి, అప్పుడు b కి సమానమైనది తప్పు మరియు ఒకసారి అది అబద్ధం అవుతుంది, ఎందుకంటే ఇది ఒక AND ఆపరేషన్ మరియు b యొక్క నిజం లేదా పురాణం c కి సమానంగా ఉందా, రెండవ భాగం నిజం లేదా రెండవ భాగం తప్పుడు, ఈ మొత్తం వ్యక్తీకరణ ఏమైనప్పటికీ తప్పు అవుతుంది.
45. కాబట్టి, ఈ విధంగా కేవలం ఒక భాగాన్ని మూల్యాంకనం చేయడం మరియు మరొకటి మూల్యాంకనం చేయకపోవడం మూల్యాంకనంలో షార్ట్ సర్క్యూట్ అని పిలుస్తారు మరియు ఇది క్రమం చేయడం ద్వారా జరుగుతుంది, ఎందుకంటే మీరు వాటిని ఏ క్రమంలో అంచనా వేస్తారో మీరు నిర్ణయించుకోవాలి. మేము చేస్తాము.
46. ఇవి ఈ ఆపరేటర్ యొక్క ప్రత్యేక ప్రవర్తనలు.
47. అందువల్ల, మీరు ఆ ప్రవర్తనలను ఓవర్లోడ్ చేస్తే, మీరు కోల్పోతారు, ఓవర్లోడ్ అయిన తర్వాత మీరు ఆ ప్రవర్తనలను cannot హించలేరని మీరు జాగ్రత్తగా ఉండాలి.
48. చివరగా, మీరు పాయింటర్ పరోక్ష ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తే, ఆ ఆపరేటర్ మరొక పాయింటర్‌ను తిరిగి ఇవ్వాలి, లేదా అది నేరుగా పాయింటర్.
49. ఈ విషయాన్ని గమనించండి, ఈ దశలో అర్థం చేసుకోవడం అంత సులభం కాదు.
50. మేము ఈ ఆపరేటర్ గురించి ఏదో ఒక సమయంలో మాట్లాడుతాము, ముఖ్యంగా ఓవర్‌లోడింగ్, ఇది భాషతో సంబంధం లేకుండా C ++ ప్రోగ్రామింగ్ యొక్క చాలా బలమైన లక్షణం.
51. దీన్ని స్మార్ట్ పాయింటర్లు మరియు ఉపయోగించేవారు అంటారు.
52. అందువల్ల, మీరు ఈ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తుంటే, మీరు తప్పక పాయింటర్ లేదా మరలా పాయింటర్‌గా మారవచ్చు.
53. ఓవర్‌లోడింగ్ యొక్క ప్రాథమిక నియమాలు ఇవి.
54. కాబట్టి, దీని తరువాత మీరు మీ ఆపరేటర్లకు రాయడం ప్రారంభించవచ్చు మరియు నేను స్ట్రింగ్ మరియు ఎనుమ్ రూపంలో ఉదాహరణలను చూపించాను, మీరు నిజంగా నియమాలను ఖచ్చితంగా పాటించాలి, కానీ అవి చాలా సౌకర్యవంతంగా మరియు సూటిగా ముందుకు ఉంటాయి మరియు నేను ఇక్కడ చర్చించిన ఉదాహరణలను తీసుకుంటాను.
55. మీరు మీ స్వంత రకాలుగా ఎక్కువ వ్రాయగలరు, పూర్తి సంక్లిష్ట రకాలను వ్రాయడం మంచిది, ఇక్కడ మీరు ఇతర ఆపరేటర్లను నెమ్మదిగా ఓవర్‌లోడ్ చేయవచ్చు మరియు సంక్లిష్ట సంఖ్యలను ఒకేసారి పూర్ణాంకాలుగా పరిగణించవచ్చు.
56. కింది స్లైడ్‌లలో, నేను వివరించను, నేను చెప్పినట్లుగా ఓవర్‌లోడ్ అవ్వడానికి అనుమతించని ఆపరేటర్లను అణిచివేసేందుకు ప్రయత్నించాను మరియు నేను ఒక కారణాన్ని అందించడానికి ప్రయత్నించాను. మీకు మాత్రమే కాదు; టెర్నరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ఎందుకు అనుమతించబడలేదని లేదా ఆకార-రకం ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ఎందుకు అనుమతించలేదని మేము గుర్తుంచుకోవాల్సిన అవసరం లేదు, మీరు వాస్తవానికి కారణాన్ని అర్థం చేసుకోవచ్చు మరియు మీరు గుర్తుంచుకోవడం సులభం అవుతుంది.
57. అందువల్ల, ఇది ఓవర్‌లోడింగ్ (ఓవర్‌లోడింగ్), ఓవర్‌లోడింగ్ (ఓవర్‌లోడింగ్) ఆపివేయబడిన జాబితా మరియు ఆపరేటర్లు ఎక్కడ ఉన్నారు, ఓవర్‌లోడింగ్ వాస్తవానికి అనుమతించబడే చోట నేను క్లుప్తంగా చర్చించిన మరొక జాబితా, కానీ మీరు వాటిని ఓవర్‌లోడ్ చేయవద్దని సలహా ఇస్తారు ఎందుకంటే మీరు వాటిని ఓవర్‌లోడ్ చేస్తే కొన్ని C ++ ప్రోగ్రామ్‌ల యొక్క ప్రాథమిక ప్రవర్తన మారుతుంది.
58. కాబట్టి, వీటిని నిజంగా నిపుణులచే ఓవర్‌లోడ్ చేయాలి మరియు మీరు ఆ స్థాయికి చేరుకునే వరకు, దాన్ని ఓవర్‌లోడ్ చేయవద్దని నేను మీకు సలహా ఇస్తాను.
59. మీ వద్ద ఉన్న మిగిలిన 38 ఆపరేటర్లు ఏ రకమైన మాతృకను అభివృద్ధి చేయగలిగేంత గొప్పవి, ఏ రకమైన మాతృక, సంక్లిష్టమైనవి, మీకు కావలసిన మాతృకలను విభజించడం.
60. దీనితో మేము ఈ మాడ్యూల్‌కు దగ్గరగా వస్తాము, ఇక్కడ, మేము ఆపరేటర్‌ను ఓవర్‌లోడింగ్‌కు పరిచయం చేసాము మరియు ఆపరేటర్ ఓవర్‌లోడింగ్ కోసం వివిధ నియమాలు మరియు మినహాయింపులను వివరించాము.
61. మరియు తరువాతి మాడ్యూల్‌లో, మాడ్యూల్ 10 లో, డైనమిక్ మెమరీ నిర్వహణ పరంగా మరొక ప్రత్యేక విస్తరణ కేసు మరియు ఆపరేటర్ ఓవర్‌లోడ్ యొక్క ప్రత్యేక కేసును చూపిస్తాము.
62. మేము C ++ డైనమిక్ మెమరీ నిర్వహణ కోసం అందించే ఆపరేటర్లను పరిచయం చేస్తాము మరియు డైనమిక్ మెమరీ మేనేజ్‌మెంట్ ఆపరేటర్ల సందర్భంలో ఆపరేటర్ ఓవర్‌లోడింగ్ ఎలా అమలు చేయవచ్చో మేము మళ్ళీ చూపిస్తాము, C ++ లో మెమరీ నిర్వహణలో పలు రకాల బలమైన ప్రయోజనాలను చూడండి.
63.
 C++ లో ప్రోగ్రామింగ్ మాడ్యూల్ 9 కు స్వాగతం.
ఆపరేటర్ ఓవర్లోడింగ్ గురించి మేము చర్చించాము.
ఆపరేటర్లు మరియు ఫంక్షన్ల మధ్య సారూప్యతలు మరియు వ్యత్యాసాలను మేము చూశాము మరియు C ++ లో, ఆపరేటర్ ఫంక్షన్లను నిర్వచించడానికి మరియు ఓవర్లోడ్ చేయడానికి ఫీచర్లు ఎలా అందించబడ్డాయో చూశాము మరియు దీనికి అదనంగా, ఆపరేటర్ ప్లస్ ఓవర్లోడ్ చేయడానికి మునుపటి విభాగంలో మాకు రెండు ఉదాహరణలు ఉన్నాయి (ఆపరేటర్ +) స్ట్రింగ్ రకం కోసం మేము రెండు తీగలను నిర్వచించాము మరియు సంక్షిప్తీకరించాము.మరియు రకాలు కోసం క్లోజ్డ్ యాడ్ ఆపరేషన్ ఎలా చేయవచ్చో చూపించడానికి, ఆపరేటర్‌ను వేరే రకం సందర్భంలో అదనపు రకంతో ఓవర్‌లోడ్ చేసాము.
ఇప్పుడు, మేము ముందుకు వెళ్లి, ఓవర్‌లోడ్ చేయగల దాని గురించి మరియు మీరు మీ స్వంత రకాన్ని, ఏ రకమైన ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయవచ్చో నిర్వచిస్తుంటే ఎలా మరియు ఏమి జరుగుతుందో గురించి మరింత తెలుసుకుంటాము మరియు మీరు దీన్ని ఎలా చేయగలరు? ఏమి సాధ్యమవుతుంది? సాధ్యం కాదు సలహా మరియు మొదలైనవి ఏమిటి? అందువల్ల, నేను ఇక్కడ నిబంధనల సారాంశాన్ని ప్రదర్శిస్తున్నాను.
వాటిని చాలా జాగ్రత్తగా చూద్దాం.
మొదట సహజంగా; మేము మీ మొదటి ప్రశ్నను ఓవర్‌లోడ్ చేయవలసి వస్తే - ఓవర్‌లోడ్ చేయగల ఆపరేటర్ ఏది? ఖచ్చితంగా, C ++ లో చాలా మంది ఆపరేటర్లు ఉన్నారు; ప్లస్, మైనస్, డివిజన్, గుణకారం, అసైన్‌మెంట్, అసైన్‌మెంట్ల యొక్క వివిధ రకాల పొడిగింపులు, ఇవన్నీ ఉన్నాయి.
కాబట్టి, మీరు క్రొత్త ఆపరేటర్ చిహ్నాన్ని నిర్వచించి దాన్ని ఓవర్‌లోడ్ చేయగలరా? మీకు ప్రశ్న ఉంటే, సమాధానం లేదు; మీరు సిస్టమ్‌లో నిర్వచించిన ఆపరేటర్ల సమితికి మాత్రమే మిమ్మల్ని పరిమితం చేయాలి.
ఉదాహరణకు, నాకు ఓవర్‌లోడింగ్ ఉందని మీరు చెప్పలేరు; ఈ ఆపరేటర్ చెప్పడానికి లేదా నాకు ఈ ఆపరేటర్ ఉంటుంది.
వాస్తవానికి, మీలో కొందరు పాస్కల్‌లో పాత ప్రోగ్రామర్లు, ఇది పాస్కల్‌లో అసమానత అని మీరు గుర్తిస్తారు, అయితే ఇది సి ++ లో నిర్వచించబడిన చిహ్నం కాదు.
అందువల్ల, మీరు కొత్త చిహ్నాలతో ఆపరేటర్లను ఓవర్‌లోడ్ చేయలేరు.
మీరు ఆపరేటర్‌ను ఓవర్‌లోడ్ చేసినప్పుడు చాలా ముఖ్యమైన రెండవ విషయం; మీరు దాని అంతర్గత లక్షణాలను మార్చలేరు.
అంతర్గత లక్షణాలు ఒకే విధంగా ఉండాలి మరియు ఆపరేటర్ కోసం 3 అంతర్గత లక్షణాలు ఉన్నాయి; ఒక సంఖ్య ఉందా, దీనికి అనేక రకాల ఆపరేషన్లు ఉన్నాయి, ఇతర ఆపరేటర్లు మరియు సహకార సంస్థలకు సంబంధించి వారి ఆపరేటర్ల సమూహానికి లేదా ఇలాంటి ఆపరేషన్ల ఆపరేటర్లకు సంబంధించి ప్రాధాన్యత.
ఈ 3 అంతర్గత లక్షణాలను మార్చలేము.
కాబట్టి, మీరు వాదించినట్లయితే, నాకు ఆపరేటర్ ప్లస్ ఉంది, దీనిని ఇలా వ్రాయవచ్చు లేదా దీన్ని ఇలా వ్రాయవచ్చు.
నాకు ఆపరేటర్ మైనస్ ఉంది, దీనిని ఇలా వ్రాయవచ్చు, దీనిని ఇలా వ్రాయవచ్చు.
కాబట్టి, ఇది ఇక్కడ ఉందని అర్థం, అరిటీ 2, ఇక్కడ అరిటీ 1, కానీ అలాంటి మార్పులు మాత్రమే మీరు మీరే చేయలేరు.
ఆపరేటర్ కోసం బహుళ సంస్కరణలు ఉంటే మరియు వేర్వేరు పూర్వీకులు మరియు సానుభూతులు ఒకే విధంగా నిర్వచించబడితే, మీరు దాని ద్వారా వెళ్ళాలి, కానీ మీరు చేయలేరు; ఆపరేటర్లు ఎవరూ దాని స్వచ్ఛత ప్రాధాన్యత మరియు సానుభూతిని నిర్వచించరు లేదా మార్చరు.
కాబట్టి, అంతర్గత లక్షణాలను పూర్తిగా గౌరవించాలి.
మూడవది జాబితా; C ++ లో సాధారణంగా ఉపయోగించే 38 ఆపరేటర్లు ఇవి ఓవర్‌లోడ్ చేయగలవు.
కాబట్టి, మీరు ప్రాథమిక అంకగణిత ఆపరేటర్ మరియు మొత్తం అసైన్‌మెంట్ ఆపరేటర్‌తో సహా మీరు ఆలోచించగలిగే దాదాపు అన్ని ఆపరేటర్లను కలిగి ఉన్నారని మీరు చూడవచ్చు, అప్పుడు మీ షిఫ్ట్ ఆపరేటర్, మీ లాజికల్ ఆపరేటర్, మీ పాయింటర్ రిఫరెన్సింగ్ ఆపరేటర్, మీ అర్రే ఆపరేటర్, మీ ఫంక్షన్ ఆపరేటర్ మరియు కాబట్టి.
కాబట్టి, ఇవన్నీ ఓవర్‌లోడ్ చేయవచ్చు.
మీకు యూనిరీ ఆపరేటర్ ఉంటే, మీకు తెలిసినట్లుగా రెండు రకాల యూనిరీ ఆపరేటర్లు, ఒపెరాండ్‌కు ముందు ఉన్న ఉపసర్గ ఆపరేటర్. ఉన్నారా, ఇది ఇలా ఉంటుంది; వీరంతా ఉపసర్గ ఆపరేటర్లు లేదా వారు పోస్ట్ ఫిక్స్ రకానికి చెందినవారు కావచ్చు.
కాబట్టి, ప్రశ్న ప్రత్యేకంగా అదే ఆపరేటర్, మీరు ++ చూస్తే, నేను ++ వ్రాయగలను లేదా నేను ++ వ్రాయగలను.
ప్రశ్న సహజంగా ఒక ఆపరేటర్ మరియు తరువాత ఆపరేటర్ ఫంక్షన్ మధ్య కరస్పాండెన్స్ ఇవ్వబడుతుంది, ఆపరేటర్ ఆపరేటర్ ఫంక్షన్ (ఫంక్షన్) ఆపరేటర్ ఆపరేటర్కు మాత్రమే ఆపరేటర్ ఆపరేటర్ అని మేము చెప్పాము.
కాబట్టి, ఇది ఆపరేటర్ చిహ్నం తరువాత ఆపరేటర్ చిహ్నం.
కాబట్టి, ఈ రెండు తప్పనిసరిగా ఒకే ఆపరేటర్ పేరును కలిగి ఉంటాయి.
కాబట్టి, మీ ప్రశ్న ఉంటుంది, కానీ అవి వేర్వేరు ఆపరేటర్లు, ఉపసర్గ మరియు పోస్ట్ పరిష్కారాలు వేర్వేరు ఆపరేటర్లు, ప్రీ-ఇంక్రిమెంట్ మరియు పోస్ట్-ఇంక్రిమెంట్ వేర్వేరు ప్రవర్తన.
కాబట్టి, మేము దానిని ఎలా వేరు చేస్తాము? కాబట్టి, ఈ రెండు పాయింట్లలో మీరు అప్రెంటిస్ ఆపరేటర్ ఉపసర్గ అయితే, ఈ విధంగా మీరు దీనిని వ్రాస్తే, సంతకం ఇలా కనిపిస్తుంది, ఇది మీ రకానికి భిన్నంగా ఉంటుంది మరియు ఇది వస్తుంది ఇంక్రిమెంట్ తర్వాత తీసుకున్న ఒపెరాండ్‌కు తిరిగి వెళ్ళు.
అయితే, ఈ పోస్ట్ ఫిక్స్ ఆపరేటర్ అయితే, ఆసక్తికరమైన విషయం ఏమిటంటే, మీరు ఒక పూర్ణాంకానికి మరొక పరామితిగా పేర్కొనాలి మరియు ఈ పూర్ణాంకానికి నిజంగా క్రియాశీల పరామితి కాదు.
మీరు నిజంగా టిని ఇన్వోక్ చేసినప్పుడు, అది ఆపరేటర్. మీరు పాస్ చేయబోతున్నారనే ఉద్దేశ్యం లేదు, అది కేవలం సంతకంలో ఉంది.
ఆపరేటర్ ఆపరేటర్ యొక్క ఈ ఉదాహరణ పోస్ట్ ఫిక్స్ రకం కోసం కాదా మరియు ఉపసర్గ రకం కాదా అని కంపైలర్ నిర్ణయించడంలో ఇది సహాయపడుతుంది.
కాబట్టి, నేను ++ వ్రాస్తే అది చెడుగా కనిపిస్తుంది.
నేను ++ a వ్రాస్తే, ఇది ఇలా అనిపిస్తుంది.
సర్‌చార్జ్ కోసం ఉపసర్గ మరియు పోస్ట్ యునరీ ఆపరేటర్లను పరిష్కరించడానికి ఇది ప్రాథమిక విధానం.
తరువాత, స్కోప్ రిజల్యూషన్ ఆపరేటర్ లాగా ఓవర్లోడ్ చేయడానికి అనుమతించని కొన్ని ఆపరేటర్లు ఉన్నారని దయచేసి గమనించండి, ఉదాహరణకు, సభ్యుని ఉపయోగించడం వంటివి, ఉదాహరణకు, మనకు ఒక నిర్మాణం ఉంటే, కాబట్టి మేము Ri మరియు Im తో సంక్లిష్ట నిర్మాణాన్ని భాగాలుగా చూశాము.
కాబట్టి, నేను నిర్మాణానికి పేరు పెట్టవచ్చు మరియు చుక్కను ఉంచగలను.
కాబట్టి, ఇది నిర్మాణం యొక్క పున-భాగం.
అందువల్ల, సభ్యుల ప్రాప్యత ఓవర్‌లోడ్ చేయబడదు.
ఏదైనా వేరియబుల్ లేదా రకం యొక్క బైట్ల సంఖ్యను కనుగొనడానికి పరిమాణాన్ని ఓవర్‌లోడ్ చేయలేము; టెర్నరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయలేము మరియు మొదలైనవి.
తార్కిక మరియు తార్కిక లేదా కామాలతో ఓవర్‌లోడ్ చేయడానికి అనుమతించబడిన కొన్ని ఆపరేటర్లు ఉన్నారు.
అయితే మీరు వాటిని ఓవర్‌లోడ్ చేస్తే, వాటి ప్రాథమిక లక్షణాలు, కొన్ని అదనపు లక్షణాలు నాశనం అవుతాయని మీరు గుర్తుంచుకోవాలి.
ఇది ఆంపర్సండ్ 'లాజికల్' మరియు 'నేను ఈ వ్యక్తీకరణను వ్రాస్తే (a = = b && b = = c), ఇది తార్కికం మరియు దాని ప్రవర్తన ఏమిటంటే వ్యక్తీకరణ యొక్క ఈ భాగం కనుగొనబడితే అది అబద్ధం. కనుక ఇది లేదు రెండవ భాగాన్ని అంచనా వేయండి.
వ్యక్తీకరణ యొక్క ఈ భాగం తప్పుగా ఉంటే, అది రెండవ భాగాన్ని అంచనా వేయదు, మీరు వాదన యొక్క ఖచ్చితత్వాన్ని చూస్తున్నారా.
A కి సమానం కాకపోతే; a మరియు b భిన్నంగా ఉంటాయి, అప్పుడు b కి సమానమైనది తప్పు మరియు ఒకసారి అది అబద్ధం అవుతుంది, ఎందుకంటే ఇది ఒక AND ఆపరేషన్ మరియు b యొక్క నిజం లేదా పురాణం c కి సమానంగా ఉందా, రెండవ భాగం నిజం లేదా రెండవ భాగం తప్పుడు, ఈ మొత్తం వ్యక్తీకరణ ఏమైనప్పటికీ తప్పు అవుతుంది.
కాబట్టి, ఈ విధంగా కేవలం ఒక భాగాన్ని మూల్యాంకనం చేయడం మరియు మరొకటి మూల్యాంకనం చేయకపోవడం మూల్యాంకనంలో షార్ట్ సర్క్యూట్ అని పిలుస్తారు మరియు ఇది క్రమం చేయడం ద్వారా జరుగుతుంది, ఎందుకంటే మీరు వాటిని ఏ క్రమంలో అంచనా వేస్తారో మీరు నిర్ణయించుకోవాలి. మేము చేస్తాము.
ఇవి ఈ ఆపరేటర్ యొక్క ప్రత్యేక ప్రవర్తనలు.
అందువల్ల, మీరు ఆ ప్రవర్తనలను ఓవర్లోడ్ చేస్తే, మీరు కోల్పోతారు, ఓవర్లోడ్ అయిన తర్వాత మీరు ఆ ప్రవర్తనలను cannot హించలేరని మీరు జాగ్రత్తగా ఉండాలి.
చివరగా, మీరు పాయింటర్ పరోక్ష ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తే, ఆ ఆపరేటర్ మరొక పాయింటర్‌ను తిరిగి ఇవ్వాలి, లేదా అది నేరుగా పాయింటర్.
ఈ విషయాన్ని గమనించండి, ఈ దశలో అర్థం చేసుకోవడం అంత సులభం కాదు.
మేము ఈ ఆపరేటర్ గురించి ఏదో ఒక సమయంలో మాట్లాడుతాము, ముఖ్యంగా ఓవర్‌లోడింగ్, ఇది భాషతో సంబంధం లేకుండా C ++ ప్రోగ్రామింగ్ యొక్క చాలా బలమైన లక్షణం.
దీన్ని స్మార్ట్ పాయింటర్లు మరియు ఉపయోగించేవారు అంటారు.
అందువల్ల, మీరు ఈ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తుంటే, మీరు తప్పక పాయింటర్ లేదా మరలా పాయింటర్‌గా మారవచ్చు.
ఓవర్‌లోడింగ్ యొక్క ప్రాథమిక నియమాలు ఇవి.
కాబట్టి, దీని తరువాత మీరు మీ ఆపరేటర్లకు రాయడం ప్రారంభించవచ్చు మరియు నేను స్ట్రింగ్ మరియు ఎనుమ్ రూపంలో ఉదాహరణలను చూపించాను, మీరు నిజంగా నియమాలను ఖచ్చితంగా పాటించాలి, కానీ అవి చాలా సౌకర్యవంతంగా మరియు సూటిగా ముందుకు ఉంటాయి మరియు నేను ఇక్కడ చర్చించిన ఉదాహరణలను తీసుకుంటాను.
మీరు మీ స్వంత రకాలుగా ఎక్కువ వ్రాయగలరు, పూర్తి సంక్లిష్ట రకాలను వ్రాయడం మంచిది, ఇక్కడ మీరు ఇతర ఆపరేటర్లను నెమ్మదిగా ఓవర్‌లోడ్ చేయవచ్చు మరియు సంక్లిష్ట సంఖ్యలను ఒకేసారి పూర్ణాంకాలుగా పరిగణించవచ్చు.
కింది స్లైడ్‌లలో, నేను వివరించను, నేను చెప్పినట్లుగా ఓవర్‌లోడ్ అవ్వడానికి అనుమతించని ఆపరేటర్లను అణిచివేసేందుకు ప్రయత్నించాను మరియు నేను ఒక కారణాన్ని అందించడానికి ప్రయత్నించాను. మీకు మాత్రమే కాదు; టెర్నరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ఎందుకు అనుమతించబడలేదని లేదా ఆకార-రకం ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ఎందుకు అనుమతించలేదని మేము గుర్తుంచుకోవాల్సిన అవసరం లేదు, మీరు వాస్తవానికి కారణాన్ని అర్థం చేసుకోవచ్చు మరియు మీరు గుర్తుంచుకోవడం సులభం అవుతుంది.
అందువల్ల, ఇది ఓవర్‌లోడింగ్ (ఓవర్‌లోడింగ్), ఓవర్‌లోడింగ్ (ఓవర్‌లోడింగ్) ఆపివేయబడిన జాబితా మరియు ఆపరేటర్లు ఎక్కడ ఉన్నారు, ఓవర్‌లోడింగ్ వాస్తవానికి అనుమతించబడే చోట నేను క్లుప్తంగా చర్చించిన మరొక జాబితా, కానీ మీరు వాటిని ఓవర్‌లోడ్ చేయవద్దని సలహా ఇస్తారు ఎందుకంటే మీరు వాటిని ఓవర్‌లోడ్ చేస్తే కొన్ని C ++ ప్రోగ్రామ్‌ల యొక్క ప్రాథమిక ప్రవర్తన మారుతుంది.
కాబట్టి, వీటిని నిజంగా నిపుణులచే ఓవర్‌లోడ్ చేయాలి మరియు మీరు ఆ స్థాయికి చేరుకునే వరకు, దాన్ని ఓవర్‌లోడ్ చేయవద్దని నేను మీకు సలహా ఇస్తాను.
మీ వద్ద ఉన్న మిగిలిన 38 ఆపరేటర్లు ఏ రకమైన మాతృకను అభివృద్ధి చేయగలిగేంత గొప్పవి, ఏ రకమైన మాతృక, సంక్లిష్టమైనవి, మీకు కావలసిన మాతృకలను విభజించడం.
దీనితో మేము ఈ మాడ్యూల్‌కు దగ్గరగా వస్తాము, ఇక్కడ, మేము ఆపరేటర్‌ను ఓవర్‌లోడింగ్‌కు పరిచయం చేసాము మరియు ఆపరేటర్ ఓవర్‌లోడింగ్ కోసం వివిధ నియమాలు మరియు మినహాయింపులను వివరించాము.
మరియు తరువాతి మాడ్యూల్‌లో, మాడ్యూల్ 10 లో, డైనమిక్ మెమరీ నిర్వహణ పరంగా మరొక ప్రత్యేక విస్తరణ కేసు మరియు ఆపరేటర్ ఓవర్‌లోడ్ యొక్క ప్రత్యేక కేసును చూపిస్తాము.
మేము C ++ డైనమిక్ మెమరీ నిర్వహణ కోసం అందించే ఆపరేటర్లను పరిచయం చేస్తాము మరియు డైనమిక్ మెమరీ మేనేజ్‌మెంట్ ఆపరేటర్ల సందర్భంలో ఆపరేటర్ ఓవర్‌లోడింగ్ ఎలా అమలు చేయవచ్చో మేము మళ్ళీ చూపిస్తాము, C ++ లో మెమరీ నిర్వహణలో పలు రకాల బలమైన ప్రయోజనాలను చూడండి.
inhouse/NPTEL/PreFinal/c++/Telugu/12. ProgramminginCplusplus_Dynamic Binding (Polymorphism) Part IV (Lecture 44)-QZu133Opz9U.txt
View file @ 956c0d4e
 1. C++ లో ప్రోగ్రామింగ్ మాడ్యూల్ 9 కు స్వాగతం.
2. ఆపరేటర్ ఓవర్లోడింగ్ గురించి మేము చర్చించాము.
3. ఆపరేటర్లు మరియు ఫంక్షన్ల మధ్య సారూప్యతలు మరియు వ్యత్యాసాలను మేము చూశాము మరియు C ++ లో, ఆపరేటర్ ఫంక్షన్లను నిర్వచించడానికి మరియు ఓవర్లోడ్ చేయడానికి ఫీచర్లు ఎలా అందించబడ్డాయో చూశాము మరియు దీనికి అదనంగా, ఆపరేటర్ ప్లస్ ఓవర్లోడ్ చేయడానికి మునుపటి విభాగంలో మాకు రెండు ఉదాహరణలు ఉన్నాయి (ఆపరేటర్ +) స్ట్రింగ్ రకం కోసం మేము రెండు తీగలను నిర్వచించాము మరియు సంక్షిప్తీకరించాము.మరియు రకాలు కోసం క్లోజ్డ్ యాడ్ ఆపరేషన్ ఎలా చేయవచ్చో చూపించడానికి, ఆపరేటర్‌ను వేరే రకం సందర్భంలో అదనపు రకంతో ఓవర్‌లోడ్ చేసాము.
4. ఇప్పుడు, మేము ముందుకు వెళ్లి, ఓవర్‌లోడ్ చేయగల దాని గురించి మరియు మీరు మీ స్వంత రకాన్ని, ఏ రకమైన ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయవచ్చో నిర్వచిస్తుంటే ఎలా మరియు ఏమి జరుగుతుందో గురించి మరింత తెలుసుకుంటాము మరియు మీరు దీన్ని ఎలా చేయగలరు? ఏమి సాధ్యమవుతుంది? సాధ్యం కాదు సలహా మరియు మొదలైనవి ఏమిటి? అందువల్ల, నేను ఇక్కడ నిబంధనల సారాంశాన్ని ప్రదర్శిస్తున్నాను.
5. వాటిని చాలా జాగ్రత్తగా చూద్దాం.
6. మొదట సహజంగా; మేము మీ మొదటి ప్రశ్నను ఓవర్‌లోడ్ చేయవలసి వస్తే - ఓవర్‌లోడ్ చేయగల ఆపరేటర్ ఏది? ఖచ్చితంగా, C ++ లో చాలా మంది ఆపరేటర్లు ఉన్నారు; ప్లస్, మైనస్, డివిజన్, గుణకారం, అసైన్‌మెంట్, అసైన్‌మెంట్ల యొక్క వివిధ రకాల పొడిగింపులు, ఇవన్నీ ఉన్నాయి.
7. కాబట్టి, మీరు క్రొత్త ఆపరేటర్ చిహ్నాన్ని నిర్వచించి దాన్ని ఓవర్‌లోడ్ చేయగలరా? మీకు ప్రశ్న ఉంటే, సమాధానం లేదు; మీరు సిస్టమ్‌లో నిర్వచించిన ఆపరేటర్ల సమితికి మాత్రమే మిమ్మల్ని పరిమితం చేయాలి.
8. ఉదాహరణకు, నాకు ఓవర్‌లోడింగ్ ఉందని మీరు చెప్పలేరు; ఈ ఆపరేటర్ చెప్పడానికి లేదా నాకు ఈ ఆపరేటర్ ఉంటుంది.
9. వాస్తవానికి, మీలో కొందరు పాస్కల్‌లో పాత ప్రోగ్రామర్లు, ఇది పాస్కల్‌లో అసమానత అని మీరు గుర్తిస్తారు, అయితే ఇది సి ++ లో నిర్వచించబడిన చిహ్నం కాదు.
10. అందువల్ల, మీరు కొత్త చిహ్నాలతో ఆపరేటర్లను ఓవర్‌లోడ్ చేయలేరు.
11. మీరు ఆపరేటర్‌ను ఓవర్‌లోడ్ చేసినప్పుడు చాలా ముఖ్యమైన రెండవ విషయం; మీరు దాని అంతర్గత లక్షణాలను మార్చలేరు.
12. అంతర్గత లక్షణాలు ఒకే విధంగా ఉండాలి మరియు ఆపరేటర్ కోసం 3 అంతర్గత లక్షణాలు ఉన్నాయి; ఒక సంఖ్య ఉందా, దీనికి అనేక రకాల ఆపరేషన్లు ఉన్నాయి, ఇతర ఆపరేటర్లు మరియు సహకార సంస్థలకు సంబంధించి వారి ఆపరేటర్ల సమూహానికి లేదా ఇలాంటి ఆపరేషన్ల ఆపరేటర్లకు సంబంధించి ప్రాధాన్యత.
13. ఈ 3 అంతర్గత లక్షణాలను మార్చలేము.
14. కాబట్టి, మీరు వాదించినట్లయితే, నాకు ఆపరేటర్ ప్లస్ ఉంది, దీనిని ఇలా వ్రాయవచ్చు లేదా దీన్ని ఇలా వ్రాయవచ్చు.
15. నాకు ఆపరేటర్ మైనస్ ఉంది, దీనిని ఇలా వ్రాయవచ్చు, దీనిని ఇలా వ్రాయవచ్చు.
16. కాబట్టి, ఇది ఇక్కడ ఉందని అర్థం, అరిటీ 2, ఇక్కడ అరిటీ 1, కానీ అలాంటి మార్పులు మాత్రమే మీరు మీరే చేయలేరు.
17. ఆపరేటర్ కోసం బహుళ సంస్కరణలు ఉంటే మరియు వేర్వేరు పూర్వీకులు మరియు సానుభూతులు ఒకే విధంగా నిర్వచించబడితే, మీరు దాని ద్వారా వెళ్ళాలి, కానీ మీరు చేయలేరు; ఆపరేటర్లు ఎవరూ దాని స్వచ్ఛత ప్రాధాన్యత మరియు సానుభూతిని నిర్వచించరు లేదా మార్చరు.
18. కాబట్టి, అంతర్గత లక్షణాలను పూర్తిగా గౌరవించాలి.
19. మూడవది జాబితా; C ++ లో సాధారణంగా ఉపయోగించే 38 ఆపరేటర్లు ఇవి ఓవర్‌లోడ్ చేయగలవు.
20. కాబట్టి, మీరు ప్రాథమిక అంకగణిత ఆపరేటర్ మరియు మొత్తం అసైన్‌మెంట్ ఆపరేటర్‌తో సహా మీరు ఆలోచించగలిగే దాదాపు అన్ని ఆపరేటర్లను కలిగి ఉన్నారని మీరు చూడవచ్చు, అప్పుడు మీ షిఫ్ట్ ఆపరేటర్, మీ లాజికల్ ఆపరేటర్, మీ పాయింటర్ రిఫరెన్సింగ్ ఆపరేటర్, మీ అర్రే ఆపరేటర్, మీ ఫంక్షన్ ఆపరేటర్ మరియు కాబట్టి.
21. కాబట్టి, ఇవన్నీ ఓవర్‌లోడ్ చేయవచ్చు.
22. మీకు యూనిరీ ఆపరేటర్ ఉంటే, మీకు తెలిసినట్లుగా రెండు రకాల యూనిరీ ఆపరేటర్లు, ఒపెరాండ్‌కు ముందు ఉన్న ఉపసర్గ ఆపరేటర్. ఉన్నారా, ఇది ఇలా ఉంటుంది; వీరంతా ఉపసర్గ ఆపరేటర్లు లేదా వారు పోస్ట్ ఫిక్స్ రకానికి చెందినవారు కావచ్చు.
23. కాబట్టి, ప్రశ్న ప్రత్యేకంగా అదే ఆపరేటర్, మీరు ++ చూస్తే, నేను a++ వ్రాయగలను లేదా నేను a++ వ్రాయగలను.
24. ప్రశ్న సహజంగా ఒక ఆపరేటర్ మరియు తరువాత ఆపరేటర్ ఫంక్షన్ మధ్య కరస్పాండెన్స్ ఇవ్వబడుతుంది, ఆపరేటర్ ఆపరేటర్ ఫంక్షన్ (ఫంక్షన్) ఆపరేటర్ ఆపరేటర్కు మాత్రమే ఆపరేటర్ ఆపరేటర్ అని మేము చెప్పాము.
25. కాబట్టి, ఇది ఆపరేటర్ చిహ్నం తరువాత ఆపరేటర్ చిహ్నం.
26. కాబట్టి, ఈ రెండు తప్పనిసరిగా ఒకే ఆపరేటర్ పేరును కలిగి ఉంటాయి.
27. కాబట్టి, మీ ప్రశ్న ఉంటుంది, కానీ అవి వేర్వేరు ఆపరేటర్లు, ఉపసర్గ మరియు పోస్ట్ పరిష్కారాలు వేర్వేరు ఆపరేటర్లు, ప్రీ-ఇంక్రిమెంట్ మరియు పోస్ట్-ఇంక్రిమెంట్ వేర్వేరు ప్రవర్తన.
28. కాబట్టి, మేము దానిని ఎలా వేరు చేస్తాము? కాబట్టి, ఈ రెండు పాయింట్లలో మీరు అప్రెంటిస్ ఆపరేటర్ ఉపసర్గ అయితే, ఈ విధంగా మీరు దీనిని వ్రాస్తే, సంతకం ఇలా కనిపిస్తుంది, ఇది మీ రకానికి భిన్నంగా ఉంటుంది మరియు ఇది వస్తుంది ఇంక్రిమెంట్ తర్వాత తీసుకున్న ఒపెరాండ్‌కు తిరిగి వెళ్ళు.
29. అయితే, ఈ పోస్ట్ ఫిక్స్ ఆపరేటర్ అయితే, ఆసక్తికరమైన విషయం ఏమిటంటే, మీరు ఒక పూర్ణాంకానికి మరొక పరామితిగా పేర్కొనాలి మరియు ఈ పూర్ణాంకానికి నిజంగా క్రియాశీల పరామితి కాదు.
30. మీరు నిజంగా టిని ఇన్వోక్ చేసినప్పుడు, అది ఆపరేటర్. మీరు పాస్ చేయబోతున్నారనే ఉద్దేశ్యం లేదు, అది కేవలం సంతకంలో ఉంది.
31. ఆపరేటర్ ఆపరేటర్ యొక్క ఈ ఉదాహరణ పోస్ట్ ఫిక్స్ రకం కోసం కాదా మరియు ఉపసర్గ రకం కాదా అని కంపైలర్ నిర్ణయించడంలో ఇది సహాయపడుతుంది.
32. కాబట్టి, నేను ++ వ్రాస్తే అది చెడుగా కనిపిస్తుంది.
33. నేను ++ a వ్రాస్తే, ఇది ఇలా అనిపిస్తుంది.
34. సర్‌చార్జ్ కోసం ఉపసర్గ మరియు పోస్ట్ యునరీ ఆపరేటర్లను పరిష్కరించడానికి ఇది ప్రాథమిక విధానం.
35. తరువాత, స్కోప్ రిజల్యూషన్ ఆపరేటర్ లాగా ఓవర్లోడ్ చేయడానికి అనుమతించని కొన్ని ఆపరేటర్లు ఉన్నారని దయచేసి గమనించండి, ఉదాహరణకు, సభ్యుని ఉపయోగించడం వంటివి, ఉదాహరణకు, మనకు ఒక నిర్మాణం ఉంటే, కాబట్టి మేము Ri మరియు Im తో సంక్లిష్ట నిర్మాణాన్ని భాగాలుగా చూశాము.
36. కాబట్టి, నేను నిర్మాణానికి పేరు పెట్టవచ్చు మరియు చుక్కను ఉంచగలను.
37. కాబట్టి, ఇది నిర్మాణం యొక్క పున-భాగం.
38. అందువల్ల, సభ్యుల ప్రాప్యత ఓవర్‌లోడ్ చేయబడదు.
39. ఏదైనా వేరియబుల్ లేదా రకం యొక్క బైట్ల సంఖ్యను కనుగొనడానికి పరిమాణాన్ని ఓవర్‌లోడ్ చేయలేము; టెర్నరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయలేము మరియు మొదలైనవి.
40. తార్కిక మరియు తార్కిక లేదా కామాలతో ఓవర్‌లోడ్ చేయడానికి అనుమతించబడిన కొన్ని ఆపరేటర్లు ఉన్నారు. అయితే మీరు వాటిని ఓవర్‌లోడ్ చేస్తే, వాటి ప్రాథమిక లక్షణాలు, కొన్ని అదనపు లక్షణాలు నాశనం అవుతాయని మీరు గుర్తుంచుకోవాలి.
41. ఇది ఆంపర్సండ్ 'లాజికల్' మరియు 'నేను ఈ వ్యక్తీకరణను వ్రాస్తే (a = = b && b = = c), ఇది తార్కికం మరియు దాని ప్రవర్తన ఏమిటంటే వ్యక్తీకరణ యొక్క ఈ భాగం కనుగొనబడితే అది అబద్ధం. కనుక ఇది లేదు రెండవ భాగాన్ని అంచనా వేయండి.
42. వ్యక్తీకరణ యొక్క ఈ భాగం తప్పుగా ఉంటే, అది రెండవ భాగాన్ని అంచనా వేయదు, మీరు వాదన యొక్క ఖచ్చితత్వాన్ని చూస్తున్నారా.
43. A కి సమానం కాకపోతే; a మరియు b భిన్నంగా ఉంటాయి, అప్పుడు b కి సమానమైనది తప్పు మరియు ఒకసారి అది అబద్ధం అవుతుంది, ఎందుకంటే ఇది ఒక AND ఆపరేషన్ మరియు b యొక్క నిజం లేదా పురాణం c కి సమానంగా ఉందా, రెండవ భాగం నిజం లేదా రెండవ భాగం తప్పుడు, ఈ మొత్తం వ్యక్తీకరణ ఏమైనప్పటికీ తప్పు అవుతుంది.
44. కాబట్టి, ఈ విధంగా కేవలం ఒక భాగాన్ని మూల్యాంకనం చేయడం మరియు మరొకటి మూల్యాంకనం చేయకపోవడం మూల్యాంకనంలో షార్ట్ సర్క్యూట్ అని పిలుస్తారు మరియు ఇది క్రమం చేయడం ద్వారా జరుగుతుంది, ఎందుకంటే మీరు వాటిని ఏ క్రమంలో అంచనా వేస్తారో మీరు నిర్ణయించుకోవాలి. మేము చేస్తాము.
45. ఇవి ఈ ఆపరేటర్ యొక్క ప్రత్యేక ప్రవర్తనలు.
46. అందువల్ల, మీరు ఆ ప్రవర్తనలను ఓవర్లోడ్ చేస్తే, మీరు కోల్పోతారు, ఓవర్లోడ్ అయిన తర్వాత మీరు ఆ ప్రవర్తనలను cannot హించలేరని మీరు జాగ్రత్తగా ఉండాలి.
47. చివరగా, మీరు పాయింటర్ పరోక్ష ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తే, ఆ ఆపరేటర్ మరొక పాయింటర్‌ను తిరిగి ఇవ్వాలి, లేదా అది నేరుగా పాయింటర్.
48. ఈ విషయాన్ని గమనించండి, ఈ దశలో అర్థం చేసుకోవడం అంత సులభం కాదు.
49. మేము ఈ ఆపరేటర్ గురించి ఏదో ఒక సమయంలో మాట్లాడుతాము, ముఖ్యంగా ఓవర్‌లోడింగ్, ఇది భాషతో సంబంధం లేకుండా C ++ ప్రోగ్రామింగ్ యొక్క చాలా బలమైన లక్షణం.
50. దీన్ని స్మార్ట్ పాయింటర్లు మరియు ఉపయోగించేవారు అంటారు.
51. అందువల్ల, మీరు ఈ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తుంటే, మీరు తప్పక పాయింటర్ లేదా మరలా పాయింటర్‌గా మారవచ్చు.
52. ఓవర్‌లోడింగ్ యొక్క ప్రాథమిక నియమాలు ఇవి.
53. కాబట్టి, దీని తరువాత మీరు మీ ఆపరేటర్లకు రాయడం ప్రారంభించవచ్చు మరియు నేను స్ట్రింగ్ మరియు ఎనుమ్ రూపంలో ఉదాహరణలను చూపించాను, మీరు నిజంగా నియమాలను ఖచ్చితంగా పాటించాలి, కానీ అవి చాలా సౌకర్యవంతంగా మరియు సూటిగా ముందుకు ఉంటాయి మరియు నేను ఇక్కడ చర్చించిన ఉదాహరణలను తీసుకుంటాను.
54.
55. మీరు మీ స్వంత రకాలుగా ఎక్కువ వ్రాయగలరు, పూర్తి సంక్లిష్ట రకాలను వ్రాయడం మంచిది, ఇక్కడ మీరు ఇతర ఆపరేటర్లను నెమ్మదిగా ఓవర్‌లోడ్ చేయవచ్చు మరియు సంక్లిష్ట సంఖ్యలను ఒకేసారి పూర్ణాంకాలుగా పరిగణించవచ్చు.
56. కింది స్లైడ్‌లలో, నేను వివరించను, నేను చెప్పినట్లుగా ఓవర్‌లోడ్ అవ్వడానికి అనుమతించని ఆపరేటర్లను అణిచివేసేందుకు ప్రయత్నించాను మరియు నేను ఒక కారణాన్ని అందించడానికి ప్రయత్నించాను. మీకు మాత్రమే కాదు; టెర్నరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ఎందుకు అనుమతించబడలేదని లేదా ఆకార-రకం ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ఎందుకు అనుమతించలేదని మేము గుర్తుంచుకోవాల్సిన అవసరం లేదు, మీరు వాస్తవానికి కారణాన్ని అర్థం చేసుకోవచ్చు మరియు మీరు గుర్తుంచుకోవడం సులభం అవుతుంది.
57. అందువల్ల, ఇది ఓవర్‌లోడింగ్ (ఓవర్‌లోడింగ్), ఓవర్‌లోడింగ్ (ఓవర్‌లోడింగ్) ఆపివేయబడిన జాబితా మరియు ఆపరేటర్లు ఎక్కడ ఉన్నారు, ఓవర్‌లోడింగ్ వాస్తవానికి అనుమతించబడే చోట నేను క్లుప్తంగా చర్చించిన మరొక జాబితా, కానీ మీరు వాటిని ఓవర్‌లోడ్ చేయవద్దని సలహా ఇస్తారు ఎందుకంటే మీరు వాటిని ఓవర్‌లోడ్ చేస్తే కొన్ని C ++ ప్రోగ్రామ్‌ల యొక్క ప్రాథమిక ప్రవర్తన మారుతుంది.
58. కాబట్టి, వీటిని నిజంగా నిపుణులచే ఓవర్‌లోడ్ చేయాలి మరియు మీరు ఆ స్థాయికి చేరుకునే వరకు, దాన్ని ఓవర్‌లోడ్ చేయవద్దని నేను మీకు సలహా ఇస్తాను.
59. మీ వద్ద ఉన్న మిగిలిన 38 ఆపరేటర్లు ఏ రకమైన మాతృకను అభివృద్ధి చేయగలిగేంత గొప్పవి, ఏ రకమైన మాతృక, సంక్లిష్టమైనవి, మీకు కావలసిన మాతృకలను విభజించడం.
60. దీనితో మేము ఈ మాడ్యూల్‌కు దగ్గరగా వస్తాము, ఇక్కడ, మేము ఆపరేటర్‌ను ఓవర్‌లోడింగ్‌కు పరిచయం చేసాము మరియు ఆపరేటర్ ఓవర్‌లోడింగ్ కోసం వివిధ నియమాలు మరియు మినహాయింపులను వివరించాము.
61. మరియు తరువాతి మాడ్యూల్‌లో, మాడ్యూల్ 10 లో, డైనమిక్ మెమరీ నిర్వహణ పరంగా మరొక ప్రత్యేక విస్తరణ కేసు మరియు ఆపరేటర్ ఓవర్‌లోడ్ యొక్క ప్రత్యేక కేసును చూపిస్తాము.
62. మేము C ++ డైనమిక్ మెమరీ నిర్వహణ కోసం అందించే ఆపరేటర్లను పరిచయం చేస్తాము మరియు డైనమిక్ మెమరీ మేనేజ్‌మెంట్ ఆపరేటర్ల సందర్భంలో ఆపరేటర్ ఓవర్‌లోడింగ్ ఎలా అమలు చేయవచ్చో మేము మళ్ళీ చూపిస్తాము, C ++ లో మెమరీ నిర్వహణలో పలు రకాల బలమైన ప్రయోజనాలను చూడండి.
63.
 C++ లో ప్రోగ్రామింగ్ మాడ్యూల్ 9 కు స్వాగతం.
ఆపరేటర్ ఓవర్లోడింగ్ గురించి మేము చర్చించాము.
ఆపరేటర్లు మరియు ఫంక్షన్ల మధ్య సారూప్యతలు మరియు వ్యత్యాసాలను మేము చూశాము మరియు C ++ లో, ఆపరేటర్ ఫంక్షన్లను నిర్వచించడానికి మరియు ఓవర్లోడ్ చేయడానికి ఫీచర్లు ఎలా అందించబడ్డాయో చూశాము మరియు దీనికి అదనంగా, ఆపరేటర్ ప్లస్ ఓవర్లోడ్ చేయడానికి మునుపటి విభాగంలో మాకు రెండు ఉదాహరణలు ఉన్నాయి (ఆపరేటర్ +) స్ట్రింగ్ రకం కోసం మేము రెండు తీగలను నిర్వచించాము మరియు సంక్షిప్తీకరించాము.మరియు రకాలు కోసం క్లోజ్డ్ యాడ్ ఆపరేషన్ ఎలా చేయవచ్చో చూపించడానికి, ఆపరేటర్‌ను వేరే రకం సందర్భంలో అదనపు రకంతో ఓవర్‌లోడ్ చేసాము.
ఇప్పుడు, మేము ముందుకు వెళ్లి, ఓవర్‌లోడ్ చేయగల దాని గురించి మరియు మీరు మీ స్వంత రకాన్ని, ఏ రకమైన ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయవచ్చో నిర్వచిస్తుంటే ఎలా మరియు ఏమి జరుగుతుందో గురించి మరింత తెలుసుకుంటాము మరియు మీరు దీన్ని ఎలా చేయగలరు? ఏమి సాధ్యమవుతుంది? సాధ్యం కాదు సలహా మరియు మొదలైనవి ఏమిటి? అందువల్ల, నేను ఇక్కడ నిబంధనల సారాంశాన్ని ప్రదర్శిస్తున్నాను.
వాటిని చాలా జాగ్రత్తగా చూద్దాం.
మొదట సహజంగా; మేము మీ మొదటి ప్రశ్నను ఓవర్‌లోడ్ చేయవలసి వస్తే - ఓవర్‌లోడ్ చేయగల ఆపరేటర్ ఏది? ఖచ్చితంగా, C ++ లో చాలా మంది ఆపరేటర్లు ఉన్నారు; ప్లస్, మైనస్, డివిజన్, గుణకారం, అసైన్‌మెంట్, అసైన్‌మెంట్ల యొక్క వివిధ రకాల పొడిగింపులు, ఇవన్నీ ఉన్నాయి.
కాబట్టి, మీరు క్రొత్త ఆపరేటర్ చిహ్నాన్ని నిర్వచించి దాన్ని ఓవర్‌లోడ్ చేయగలరా? మీకు ప్రశ్న ఉంటే, సమాధానం లేదు; మీరు సిస్టమ్‌లో నిర్వచించిన ఆపరేటర్ల సమితికి మాత్రమే మిమ్మల్ని పరిమితం చేయాలి.
ఉదాహరణకు, నాకు ఓవర్‌లోడింగ్ ఉందని మీరు చెప్పలేరు; ఈ ఆపరేటర్ చెప్పడానికి లేదా నాకు ఈ ఆపరేటర్ ఉంటుంది.
వాస్తవానికి, మీలో కొందరు పాస్కల్‌లో పాత ప్రోగ్రామర్లు, ఇది పాస్కల్‌లో అసమానత అని మీరు గుర్తిస్తారు, అయితే ఇది సి ++ లో నిర్వచించబడిన చిహ్నం కాదు.
అందువల్ల, మీరు కొత్త చిహ్నాలతో ఆపరేటర్లను ఓవర్‌లోడ్ చేయలేరు.
మీరు ఆపరేటర్‌ను ఓవర్‌లోడ్ చేసినప్పుడు చాలా ముఖ్యమైన రెండవ విషయం; మీరు దాని అంతర్గత లక్షణాలను మార్చలేరు.
అంతర్గత లక్షణాలు ఒకే విధంగా ఉండాలి మరియు ఆపరేటర్ కోసం 3 అంతర్గత లక్షణాలు ఉన్నాయి; ఒక సంఖ్య ఉందా, దీనికి అనేక రకాల ఆపరేషన్లు ఉన్నాయి, ఇతర ఆపరేటర్లు మరియు సహకార సంస్థలకు సంబంధించి వారి ఆపరేటర్ల సమూహానికి లేదా ఇలాంటి ఆపరేషన్ల ఆపరేటర్లకు సంబంధించి ప్రాధాన్యత.
ఈ 3 అంతర్గత లక్షణాలను మార్చలేము.
కాబట్టి, మీరు వాదించినట్లయితే, నాకు ఆపరేటర్ ప్లస్ ఉంది, దీనిని ఇలా వ్రాయవచ్చు లేదా దీన్ని ఇలా వ్రాయవచ్చు.
నాకు ఆపరేటర్ మైనస్ ఉంది, దీనిని ఇలా వ్రాయవచ్చు, దీనిని ఇలా వ్రాయవచ్చు.
కాబట్టి, ఇది ఇక్కడ ఉందని అర్థం, అరిటీ 2, ఇక్కడ అరిటీ 1, కానీ అలాంటి మార్పులు మాత్రమే మీరు మీరే చేయలేరు.
ఆపరేటర్ కోసం బహుళ సంస్కరణలు ఉంటే మరియు వేర్వేరు పూర్వీకులు మరియు సానుభూతులు ఒకే విధంగా నిర్వచించబడితే, మీరు దాని ద్వారా వెళ్ళాలి, కానీ మీరు చేయలేరు; ఆపరేటర్లు ఎవరూ దాని స్వచ్ఛత ప్రాధాన్యత మరియు సానుభూతిని నిర్వచించరు లేదా మార్చరు.
కాబట్టి, అంతర్గత లక్షణాలను పూర్తిగా గౌరవించాలి.
మూడవది జాబితా; C ++ లో సాధారణంగా ఉపయోగించే 38 ఆపరేటర్లు ఇవి ఓవర్‌లోడ్ చేయగలవు.
కాబట్టి, మీరు ప్రాథమిక అంకగణిత ఆపరేటర్ మరియు మొత్తం అసైన్‌మెంట్ ఆపరేటర్‌తో సహా మీరు ఆలోచించగలిగే దాదాపు అన్ని ఆపరేటర్లను కలిగి ఉన్నారని మీరు చూడవచ్చు, అప్పుడు మీ షిఫ్ట్ ఆపరేటర్, మీ లాజికల్ ఆపరేటర్, మీ పాయింటర్ రిఫరెన్సింగ్ ఆపరేటర్, మీ అర్రే ఆపరేటర్, మీ ఫంక్షన్ ఆపరేటర్ మరియు కాబట్టి.
కాబట్టి, ఇవన్నీ ఓవర్‌లోడ్ చేయవచ్చు.
మీకు యూనిరీ ఆపరేటర్ ఉంటే, మీకు తెలిసినట్లుగా రెండు రకాల యూనిరీ ఆపరేటర్లు, ఒపెరాండ్‌కు ముందు ఉన్న ఉపసర్గ ఆపరేటర్. ఉన్నారా, ఇది ఇలా ఉంటుంది; వీరంతా ఉపసర్గ ఆపరేటర్లు లేదా వారు పోస్ట్ ఫిక్స్ రకానికి చెందినవారు కావచ్చు.
కాబట్టి, ప్రశ్న ప్రత్యేకంగా అదే ఆపరేటర్, మీరు ++ చూస్తే, నేను a++ వ్రాయగలను లేదా నేను a++ వ్రాయగలను.
ప్రశ్న సహజంగా ఒక ఆపరేటర్ మరియు తరువాత ఆపరేటర్ ఫంక్షన్ మధ్య కరస్పాండెన్స్ ఇవ్వబడుతుంది, ఆపరేటర్ ఆపరేటర్ ఫంక్షన్ (ఫంక్షన్) ఆపరేటర్ ఆపరేటర్కు మాత్రమే ఆపరేటర్ ఆపరేటర్ అని మేము చెప్పాము.
కాబట్టి, ఇది ఆపరేటర్ చిహ్నం తరువాత ఆపరేటర్ చిహ్నం.
కాబట్టి, ఈ రెండు తప్పనిసరిగా ఒకే ఆపరేటర్ పేరును కలిగి ఉంటాయి.
కాబట్టి, మీ ప్రశ్న ఉంటుంది, కానీ అవి వేర్వేరు ఆపరేటర్లు, ఉపసర్గ మరియు పోస్ట్ పరిష్కారాలు వేర్వేరు ఆపరేటర్లు, ప్రీ-ఇంక్రిమెంట్ మరియు పోస్ట్-ఇంక్రిమెంట్ వేర్వేరు ప్రవర్తన.
కాబట్టి, మేము దానిని ఎలా వేరు చేస్తాము? కాబట్టి, ఈ రెండు పాయింట్లలో మీరు అప్రెంటిస్ ఆపరేటర్ ఉపసర్గ అయితే, ఈ విధంగా మీరు దీనిని వ్రాస్తే, సంతకం ఇలా కనిపిస్తుంది, ఇది మీ రకానికి భిన్నంగా ఉంటుంది మరియు ఇది వస్తుంది ఇంక్రిమెంట్ తర్వాత తీసుకున్న ఒపెరాండ్‌కు తిరిగి వెళ్ళు.
అయితే, ఈ పోస్ట్ ఫిక్స్ ఆపరేటర్ అయితే, ఆసక్తికరమైన విషయం ఏమిటంటే, మీరు ఒక పూర్ణాంకానికి మరొక పరామితిగా పేర్కొనాలి మరియు ఈ పూర్ణాంకానికి నిజంగా క్రియాశీల పరామితి కాదు.
మీరు నిజంగా టిని ఇన్వోక్ చేసినప్పుడు, అది ఆపరేటర్. మీరు పాస్ చేయబోతున్నారనే ఉద్దేశ్యం లేదు, అది కేవలం సంతకంలో ఉంది.
ఆపరేటర్ ఆపరేటర్ యొక్క ఈ ఉదాహరణ పోస్ట్ ఫిక్స్ రకం కోసం కాదా మరియు ఉపసర్గ రకం కాదా అని కంపైలర్ నిర్ణయించడంలో ఇది సహాయపడుతుంది.
కాబట్టి, నేను ++ వ్రాస్తే అది చెడుగా కనిపిస్తుంది.
నేను ++ a వ్రాస్తే, ఇది ఇలా అనిపిస్తుంది.
సర్‌చార్జ్ కోసం ఉపసర్గ మరియు పోస్ట్ యునరీ ఆపరేటర్లను పరిష్కరించడానికి ఇది ప్రాథమిక విధానం.
తరువాత, స్కోప్ రిజల్యూషన్ ఆపరేటర్ లాగా ఓవర్లోడ్ చేయడానికి అనుమతించని కొన్ని ఆపరేటర్లు ఉన్నారని దయచేసి గమనించండి, ఉదాహరణకు, సభ్యుని ఉపయోగించడం వంటివి, ఉదాహరణకు, మనకు ఒక నిర్మాణం ఉంటే, కాబట్టి మేము Ri మరియు Im తో సంక్లిష్ట నిర్మాణాన్ని భాగాలుగా చూశాము.
కాబట్టి, నేను నిర్మాణానికి పేరు పెట్టవచ్చు మరియు చుక్కను ఉంచగలను.
కాబట్టి, ఇది నిర్మాణం యొక్క పున-భాగం.
అందువల్ల, సభ్యుల ప్రాప్యత ఓవర్‌లోడ్ చేయబడదు.
ఏదైనా వేరియబుల్ లేదా రకం యొక్క బైట్ల సంఖ్యను కనుగొనడానికి పరిమాణాన్ని ఓవర్‌లోడ్ చేయలేము; టెర్నరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయలేము మరియు మొదలైనవి.
తార్కిక మరియు తార్కిక లేదా కామాలతో ఓవర్‌లోడ్ చేయడానికి అనుమతించబడిన కొన్ని ఆపరేటర్లు ఉన్నారు. అయితే మీరు వాటిని ఓవర్‌లోడ్ చేస్తే, వాటి ప్రాథమిక లక్షణాలు, కొన్ని అదనపు లక్షణాలు నాశనం అవుతాయని మీరు గుర్తుంచుకోవాలి.
ఇది ఆంపర్సండ్ 'లాజికల్' మరియు 'నేను ఈ వ్యక్తీకరణను వ్రాస్తే (a = = b && b = = c), ఇది తార్కికం మరియు దాని ప్రవర్తన ఏమిటంటే వ్యక్తీకరణ యొక్క ఈ భాగం కనుగొనబడితే అది అబద్ధం. కనుక ఇది లేదు రెండవ భాగాన్ని అంచనా వేయండి.
వ్యక్తీకరణ యొక్క ఈ భాగం తప్పుగా ఉంటే, అది రెండవ భాగాన్ని అంచనా వేయదు, మీరు వాదన యొక్క ఖచ్చితత్వాన్ని చూస్తున్నారా.
A కి సమానం కాకపోతే; a మరియు b భిన్నంగా ఉంటాయి, అప్పుడు b కి సమానమైనది తప్పు మరియు ఒకసారి అది అబద్ధం అవుతుంది, ఎందుకంటే ఇది ఒక AND ఆపరేషన్ మరియు b యొక్క నిజం లేదా పురాణం c కి సమానంగా ఉందా, రెండవ భాగం నిజం లేదా రెండవ భాగం తప్పుడు, ఈ మొత్తం వ్యక్తీకరణ ఏమైనప్పటికీ తప్పు అవుతుంది.
కాబట్టి, ఈ విధంగా కేవలం ఒక భాగాన్ని మూల్యాంకనం చేయడం మరియు మరొకటి మూల్యాంకనం చేయకపోవడం మూల్యాంకనంలో షార్ట్ సర్క్యూట్ అని పిలుస్తారు మరియు ఇది క్రమం చేయడం ద్వారా జరుగుతుంది, ఎందుకంటే మీరు వాటిని ఏ క్రమంలో అంచనా వేస్తారో మీరు నిర్ణయించుకోవాలి. మేము చేస్తాము.
ఇవి ఈ ఆపరేటర్ యొక్క ప్రత్యేక ప్రవర్తనలు.
అందువల్ల, మీరు ఆ ప్రవర్తనలను ఓవర్లోడ్ చేస్తే, మీరు కోల్పోతారు, ఓవర్లోడ్ అయిన తర్వాత మీరు ఆ ప్రవర్తనలను cannot హించలేరని మీరు జాగ్రత్తగా ఉండాలి.
చివరగా, మీరు పాయింటర్ పరోక్ష ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తే, ఆ ఆపరేటర్ మరొక పాయింటర్‌ను తిరిగి ఇవ్వాలి, లేదా అది నేరుగా పాయింటర్.
ఈ విషయాన్ని గమనించండి, ఈ దశలో అర్థం చేసుకోవడం అంత సులభం కాదు.
మేము ఈ ఆపరేటర్ గురించి ఏదో ఒక సమయంలో మాట్లాడుతాము, ముఖ్యంగా ఓవర్‌లోడింగ్, ఇది భాషతో సంబంధం లేకుండా C ++ ప్రోగ్రామింగ్ యొక్క చాలా బలమైన లక్షణం.
దీన్ని స్మార్ట్ పాయింటర్లు మరియు ఉపయోగించేవారు అంటారు.
అందువల్ల, మీరు ఈ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేస్తుంటే, మీరు తప్పక పాయింటర్ లేదా మరలా పాయింటర్‌గా మారవచ్చు.
ఓవర్‌లోడింగ్ యొక్క ప్రాథమిక నియమాలు ఇవి.
కాబట్టి, దీని తరువాత మీరు మీ ఆపరేటర్లకు రాయడం ప్రారంభించవచ్చు మరియు నేను స్ట్రింగ్ మరియు ఎనుమ్ రూపంలో ఉదాహరణలను చూపించాను, మీరు నిజంగా నియమాలను ఖచ్చితంగా పాటించాలి, కానీ అవి చాలా సౌకర్యవంతంగా మరియు సూటిగా ముందుకు ఉంటాయి మరియు నేను ఇక్కడ చర్చించిన ఉదాహరణలను తీసుకుంటాను.
మీరు మీ స్వంత రకాలుగా ఎక్కువ వ్రాయగలరు, పూర్తి సంక్లిష్ట రకాలను వ్రాయడం మంచిది, ఇక్కడ మీరు ఇతర ఆపరేటర్లను నెమ్మదిగా ఓవర్‌లోడ్ చేయవచ్చు మరియు సంక్లిష్ట సంఖ్యలను ఒకేసారి పూర్ణాంకాలుగా పరిగణించవచ్చు.
కింది స్లైడ్‌లలో, నేను వివరించను, నేను చెప్పినట్లుగా ఓవర్‌లోడ్ అవ్వడానికి అనుమతించని ఆపరేటర్లను అణిచివేసేందుకు ప్రయత్నించాను మరియు నేను ఒక కారణాన్ని అందించడానికి ప్రయత్నించాను. మీకు మాత్రమే కాదు; టెర్నరీ ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ఎందుకు అనుమతించబడలేదని లేదా ఆకార-రకం ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ఎందుకు అనుమతించలేదని మేము గుర్తుంచుకోవాల్సిన అవసరం లేదు, మీరు వాస్తవానికి కారణాన్ని అర్థం చేసుకోవచ్చు మరియు మీరు గుర్తుంచుకోవడం సులభం అవుతుంది.
అందువల్ల, ఇది ఓవర్‌లోడింగ్ (ఓవర్‌లోడింగ్), ఓవర్‌లోడింగ్ (ఓవర్‌లోడింగ్) ఆపివేయబడిన జాబితా మరియు ఆపరేటర్లు ఎక్కడ ఉన్నారు, ఓవర్‌లోడింగ్ వాస్తవానికి అనుమతించబడే చోట నేను క్లుప్తంగా చర్చించిన మరొక జాబితా, కానీ మీరు వాటిని ఓవర్‌లోడ్ చేయవద్దని సలహా ఇస్తారు ఎందుకంటే మీరు వాటిని ఓవర్‌లోడ్ చేస్తే కొన్ని C ++ ప్రోగ్రామ్‌ల యొక్క ప్రాథమిక ప్రవర్తన మారుతుంది.
కాబట్టి, వీటిని నిజంగా నిపుణులచే ఓవర్‌లోడ్ చేయాలి మరియు మీరు ఆ స్థాయికి చేరుకునే వరకు, దాన్ని ఓవర్‌లోడ్ చేయవద్దని నేను మీకు సలహా ఇస్తాను.
మీ వద్ద ఉన్న మిగిలిన 38 ఆపరేటర్లు ఏ రకమైన మాతృకను అభివృద్ధి చేయగలిగేంత గొప్పవి, ఏ రకమైన మాతృక, సంక్లిష్టమైనవి, మీకు కావలసిన మాతృకలను విభజించడం.
దీనితో మేము ఈ మాడ్యూల్‌కు దగ్గరగా వస్తాము, ఇక్కడ, మేము ఆపరేటర్‌ను ఓవర్‌లోడింగ్‌కు పరిచయం చేసాము మరియు ఆపరేటర్ ఓవర్‌లోడింగ్ కోసం వివిధ నియమాలు మరియు మినహాయింపులను వివరించాము.
మరియు తరువాతి మాడ్యూల్‌లో, మాడ్యూల్ 10 లో, డైనమిక్ మెమరీ నిర్వహణ పరంగా మరొక ప్రత్యేక విస్తరణ కేసు మరియు ఆపరేటర్ ఓవర్‌లోడ్ యొక్క ప్రత్యేక కేసును చూపిస్తాము.
మేము C ++ డైనమిక్ మెమరీ నిర్వహణ కోసం అందించే ఆపరేటర్లను పరిచయం చేస్తాము మరియు డైనమిక్ మెమరీ మేనేజ్‌మెంట్ ఆపరేటర్ల సందర్భంలో ఆపరేటర్ ఓవర్‌లోడింగ్ ఎలా అమలు చేయవచ్చో మేము మళ్ళీ చూపిస్తాము, C ++ లో మెమరీ నిర్వహణలో పలు రకాల బలమైన ప్రయోజనాలను చూడండి.
inhouse/NPTEL/PreFinal/c++/Telugu/15. ProgramminginCplusplus_Access Specifiers (Contd.) (lecture 22)-18dWcNZ7mR0.txt
View file @ 956c0d4e
 1. ప్రోగ్రామింగ్ ఇన్ C ++ మాడ్యూల్ 2 వ భాగం కు స్వాగతం.
2. మేము ఈ మాడ్యూల్‌లో వేర్వేరు యాక్సెస్ స్పెసిఫైయర్‌లను చర్చించాము, అందువల్ల తరగతి సభ్యుడి దృశ్యమానత ఎంపికలు.
3. పబ్లిక్ మరియు ప్రైవేట్ యాక్సెస్‌లు ఒక తరగతిలోని ఏ భాగాన్ని ఎవరు యాక్సెస్ చేయవచ్చో నియంత్రించడానికి ఉపయోగపడే స్పెసిఫైయర్‌లు అని మేము తెలుసుకున్నాము.
4. పబ్లిక్ డిస్క్రిప్టర్స్ అంటే గ్లోబల్ ఫంక్షన్ లేదా మరొక తరగతి అయిన ఎవరైనా బహిరంగంగా పేర్కొన్న సభ్యుడిని యాక్సెస్ చేయవచ్చు, కాని కొంతమంది సభ్యుల డేటా (డేటా) సభ్యుడు లేదా పద్ధతి ప్రైవేట్ అయితే పేర్కొన్నట్లుగా, డేటా సభ్యుడు లేదా పద్ధతిని మాత్రమే యాక్సెస్ చేయవచ్చు లోపల నుండి.
5. ఒక తరగతి యొక్క నిర్వచనం ఒకే తరగతి యొక్క ఇతర పద్ధతుల కంటే చాలా ఖచ్చితమైనది, కానీ దానిని మరెవరూ యాక్సెస్ చేయలేరు.
6. దీని ఆధారంగా, సమాచారాన్ని దాచడం యొక్క సూత్రాన్ని మేము వివరించాము, అక్కడ మేము ఎల్లప్పుడూ గుణాలు లేదా డేటా సభ్యులను ప్రైవేట్‌గా కలిగి ఉండాలని మరియు వస్తువులో బహిరంగంగా ప్రవర్తించడానికి అనుమతించే పద్ధతులు వారు రాష్ట్ర మూలాన్ని దాచిపెడుతున్నారని మేము నిర్ణయించాము.
7. మీరు డేటా సభ్యులను బహిరంగంగా ఉంచితే, మీరు అమలును హైలైట్ చేస్తే, ఒకరు అమలు చేసే ఇబ్బందులు మరియు నష్టాలు ఏమిటి, బదులుగా డేటా (డేటా) సభ్యులు ప్రైవేట్‌గా ఉంటే మరియు పద్ధతులు మాత్రమే స్టాక్ (స్టాక్ ) టైప్ లేదా స్టాక్ (స్టాక్) క్లాస్ (క్లాస్), పుష్ (పుష్), పాప్ (పాప్), టాప్ (టాప్) మరియు ఖాళీ పబ్లిక్, కాబట్టి ఒక అప్లికేషన్ ప్రాథమికంగా ఈ విషయం స్టాక్‌ను ఎంత ఖచ్చితంగా సంబంధం లేకుండా ఉపయోగించగలదు స్టాక్ (స్టాక్) ను దెబ్బతీసే ప్రమాదం లేకుండా రైట్ ప్రాసెస్‌లో స్టాక్ అమలు చేయబడుతుంది.
8. అప్లికేషన్.
9. చివరగా, శీర్షిక మరియు అమలు ఫైళ్ళ సందర్భంలో సమాచారాన్ని దాచడానికి కోడ్-ఆధారిత ఆబ్జెక్ట్ (కోడ్) ఆధారిత సి ++ కోడ్ సాధారణంగా ఎలా నిర్వహించాలో మేము చూపించాము.
10. మేము తరువాత ఒక ఇడియమ్స్ గురించి మాట్లాడుతాము, దీనిని సాధారణంగా గేట్-సెట్ ఇడియమ్స్ అని పిలుస్తారు, ఇది తరగతి లేదా వస్తువు యొక్క వేర్వేరు సభ్యులలో ఉపయోగించబడుతుంది. ధాన్యం యాక్సెస్ నియంత్రణ కోసం ఉపయోగించబడుతుంది.
11. మేము అన్ని లక్షణాలను ప్రైవేట్‌గా ఉంచుతామని మాకు తెలుసు మరియు మేము పద్ధతులను బహిరంగంగా ఉంచుతాము మరియు ఇది డేటాకు ప్రాప్యతను పూర్తిగా పరిమితం చేస్తుంది, ఇది మీకు ఉండవచ్చు.
12. ఇప్పుడు సాధారణంగా మేము ఈ ప్రాప్యతను పరిష్కరించాలనుకుంటున్నాము మరియు మేము ఎంచుకున్న పబ్లిక్ మెంబర్ ఫంక్షన్లను అందించాలనుకుంటున్నాము లేదా ఫంక్షన్ (ఫంక్షన్) చదవాలనుకుంటున్నాము లేదా డేటాను పొందాలనుకుంటున్నాము లేదా ఫంక్షన్ (ఫంక్షన్) రాయాలి లేదా డేటా (డేటా) పై పద్ధతులను సెట్ చేయాలనుకుంటున్నాము.
13. కాబట్టి, నేను మొత్తం ఆలోచనను ఒక ఉదాహరణ పరంగా వివరించాను, ఇక్కడ నేను ఉన్న తరగతి ఉంది. క్లాస్ మైక్లాస్‌గా చెప్పండి, ఇది చాలా ముఖ్యమైనది కాదు.
14. నలుగురు డేటా సభ్యులు ఉన్నారు మరియు నేను ఇక్కడ క్లాస్ డెఫినిషన్ ప్రారంభం నుండి ఎటువంటి యాక్సెస్ స్పెసిఫైయర్‌ను ఉపయోగించలేదు, అంటే అప్రమేయంగా ఈ డేటా సభ్యులు అక్కడ ప్రైవేట్‌గా ఉన్నారు మరియు ఈ డేటా (డేటా) సభ్యుల ఉద్దేశ్యం అంటే మొదట చదివిన డేటా సభ్యులు డేటా సభ్యుడు, నేను డేటా సభ్యుని కాబట్టి, ఇది ప్రైవేట్, కాబట్టి ఎవరైనా నేరుగా రావచ్చు మరియు దాని విలువ మారదు, కానీ దాని ఉపయోగం పరంగా దాని విలువను చదివి వ్రాయాలనుకుంటున్నాను.
15. ఉదాహరణకు, ఇది సంక్లిష్ట సంఖ్య యొక్క పున components- భాగాలు, సంక్లిష్ట సంఖ్య యొక్క im భాగాలు వంటి సభ్యుడు, నేను సంక్లిష్ట సంఖ్యను చదువుతుంటే ఈ భాగం యొక్క విలువను చదివి సెట్ చేయాలి.
16. నేను సంక్లిష్ట సంఖ్య యొక్క ప్రస్తుత విలువను వ్రాస్తున్నట్లయితే, నేను మళ్ళీ చదవాలి, im భాగం మరియు మొదలైనవి.
17. పెద్ద సంఖ్యలో డేటా సభ్యులు చదవలేనివారు.
18. అందువల్ల, నేను దీన్ని చేయగలిగే కొన్ని యంత్రాంగాన్ని అందించాలి మరియు దీన్ని చేయటానికి సరళమైన మార్గం జత గేట్-సెట్ ఫంక్షన్‌ను అందించడం.
19. మీకు ఏమి లభిస్తుంది, ఫంక్షన్ సెట్ చేయండి? ఈ వేరియబుల్‌లోని రీడ్ రైట్‌లో గెట్ ఫంక్షన్ ఒక పేరు getReadWrite అని చెబుతుంది, ఇది ఈ డేటా సభ్యుడిని తీసుకొని తిరిగి ఇస్తుంది.
20. ఈ పద్ధతి బహిరంగ ప్రదేశంలో ఉంచబడుతుంది, కాబట్టి ఏదైనా బాహ్య ఫంక్షన్ (ఫంక్షన్) లేదా మరొక తరగతి (తరగతి) లోని ఏ ఇతర సభ్యుడు ఫంక్షన్ getReadWrite ఫంక్షన్ (ఫంక్షన్) ను స్థానికంగా పిలుస్తారు, ఎందుకంటే ఇది బహిరంగ ప్రదేశంలో లభిస్తుంది.
21. మరియు అది ప్రైవేట్ సభ్యుడిని యాక్సెస్ చేస్తుంది మరియు దాని విలువను తిరిగి ఇస్తుంది.
22. కాబట్టి ఒక విధంగా మనం బయటి ప్రపంచానికి ఎంపిక చేసుకుంటున్నాము, దాని విలువపై నియంత్రణతో ఒకరు దీన్ని ప్రత్యేకంగా చేయవలసి వచ్చినప్పుడల్లా ఈ ప్రత్యేకత ద్వారా వెళ్ళాలి, దాన్ని సాధించడం మధ్య ఒక ప్రాథమిక వ్యత్యాసం ఏమిటి మరియు నేను అని చెప్పనివ్వండి విలువను v తీసుకునే సమితిని కలిగి ఉండండి మరియు వాస్తవానికి డేటా సభ్యులు చదివే శాస్త్రం.
23. కాబట్టి ప్రాథమికంగా, నేను గెట్ మరియు సెట్ రెండింటినీ కలిగి ఉంటే, నేను ఈ వేరియబుల్, రీడ్‌రైట్‌ను చదవగలను.
24. ఇప్పుడు మీరు దీన్ని ప్రైవేట్‌గా ఎందుకు చేయాలనుకుంటున్నారో ఇప్పుడు మీరు ఆశ్చర్యపోతున్నారు, ఆపై దాన్ని పొందగలిగే మరియు సెట్ చేయగలిగే ఒక జత పబ్లిక్ పద్ధతులు ఉన్నాయి, మేము దీన్ని పబ్లిక్‌గా చేయగలము మరియు ఎవరైనా దీన్ని మార్చగలరు.
25. కానీ అవును, చదవడం మరియు వ్రాయడం విషయంలో ఇది ఒకటే, కాని పెద్ద తేడా ఉంది ఎందుకంటే నేను దానిని బహిరంగంగా ఉంచితే ఆ వస్తువు ఎప్పటికీ తెలియదు, అది జరుగుతున్నప్పుడు అది ప్రత్యేక డేటా అవుతుంది. సభ్యుడు చదువుతున్నాడా లేదా అది పూర్తయినప్పుడు చదవండి.
26. కానీ అది ఒక ఫంక్షన్ ద్వారా జరిగితే అది చదివేటప్పుడు ఒక పద్ధతి ఉంటుంది కాబట్టి నేను ఇక్కడ కొన్ని లెక్కలు కూడా చేయగలను.
27. వ్రాసేటప్పుడు ఈ విలువ రాయడానికి ముందు లేదా తరువాత నేను కొన్ని లెక్కలు కూడా చేయగలను.
28. అందువల్ల, రీడ్ రైట్ యొక్క విలువ మార్చబడిందని లేదా రీడ్ రైట్ యొక్క విలువను ఎవరైనా చదివారని ఆ వస్తువు ఎల్లప్పుడూ తెలుసుకుంటుంది.
29. కాబట్టి, ఈ డేటా సభ్యుడిని పబ్లిక్ యాక్సెస్‌గా ఉంచడం సరికాదు.
 ప్రోగ్రామింగ్ ఇన్ C ++ మాడ్యూల్ 2 వ భాగం కు స్వాగతం.
మేము ఈ మాడ్యూల్‌లో వేర్వేరు యాక్సెస్ స్పెసిఫైయర్‌లను చర్చించాము, అందువల్ల తరగతి సభ్యుడి దృశ్యమానత ఎంపికలు.
పబ్లిక్ మరియు ప్రైవేట్ యాక్సెస్‌లు ఒక తరగతిలోని ఏ భాగాన్ని ఎవరు యాక్సెస్ చేయవచ్చో నియంత్రించడానికి ఉపయోగపడే స్పెసిఫైయర్‌లు అని మేము తెలుసుకున్నాము.
పబ్లిక్ డిస్క్రిప్టర్స్ అంటే గ్లోబల్ ఫంక్షన్ లేదా మరొక తరగతి అయిన ఎవరైనా బహిరంగంగా పేర్కొన్న సభ్యుడిని యాక్సెస్ చేయవచ్చు, కాని కొంతమంది సభ్యుల డేటా (డేటా) సభ్యుడు లేదా పద్ధతి ప్రైవేట్ అయితే పేర్కొన్నట్లుగా, డేటా సభ్యుడు లేదా పద్ధతిని మాత్రమే యాక్సెస్ చేయవచ్చు లోపల నుండి.
ఒక తరగతి యొక్క నిర్వచనం ఒకే తరగతి యొక్క ఇతర పద్ధతుల కంటే చాలా ఖచ్చితమైనది, కానీ దానిని మరెవరూ యాక్సెస్ చేయలేరు.
దీని ఆధారంగా, సమాచారాన్ని దాచడం యొక్క సూత్రాన్ని మేము వివరించాము, అక్కడ మేము ఎల్లప్పుడూ గుణాలు లేదా డేటా సభ్యులను ప్రైవేట్‌గా కలిగి ఉండాలని మరియు వస్తువులో బహిరంగంగా ప్రవర్తించడానికి అనుమతించే పద్ధతులు వారు రాష్ట్ర మూలాన్ని దాచిపెడుతున్నారని మేము నిర్ణయించాము.
మీరు డేటా సభ్యులను బహిరంగంగా ఉంచితే, మీరు అమలును హైలైట్ చేస్తే, ఒకరు అమలు చేసే ఇబ్బందులు మరియు నష్టాలు ఏమిటి, బదులుగా డేటా (డేటా) సభ్యులు ప్రైవేట్‌గా ఉంటే మరియు పద్ధతులు మాత్రమే స్టాక్ (స్టాక్ ) టైప్ లేదా స్టాక్ (స్టాక్) క్లాస్ (క్లాస్), పుష్ (పుష్), పాప్ (పాప్), టాప్ (టాప్) మరియు ఖాళీ పబ్లిక్, కాబట్టి ఒక అప్లికేషన్ ప్రాథమికంగా ఈ విషయం స్టాక్‌ను ఎంత ఖచ్చితంగా సంబంధం లేకుండా ఉపయోగించగలదు స్టాక్ (స్టాక్) ను దెబ్బతీసే ప్రమాదం లేకుండా రైట్ ప్రాసెస్‌లో స్టాక్ అమలు చేయబడుతుంది.
అప్లికేషన్.
చివరగా, శీర్షిక మరియు అమలు ఫైళ్ళ సందర్భంలో సమాచారాన్ని దాచడానికి కోడ్-ఆధారిత ఆబ్జెక్ట్ (కోడ్) ఆధారిత సి ++ కోడ్ సాధారణంగా ఎలా నిర్వహించాలో మేము చూపించాము.
మేము తరువాత ఒక ఇడియమ్స్ గురించి మాట్లాడుతాము, దీనిని సాధారణంగా గేట్-సెట్ ఇడియమ్స్ అని పిలుస్తారు, ఇది తరగతి లేదా వస్తువు యొక్క వేర్వేరు సభ్యులలో ఉపయోగించబడుతుంది. ధాన్యం యాక్సెస్ నియంత్రణ కోసం ఉపయోగించబడుతుంది.
మేము అన్ని లక్షణాలను ప్రైవేట్‌గా ఉంచుతామని మాకు తెలుసు మరియు మేము పద్ధతులను బహిరంగంగా ఉంచుతాము మరియు ఇది డేటాకు ప్రాప్యతను పూర్తిగా పరిమితం చేస్తుంది, ఇది మీకు ఉండవచ్చు.
ఇప్పుడు సాధారణంగా మేము ఈ ప్రాప్యతను పరిష్కరించాలనుకుంటున్నాము మరియు మేము ఎంచుకున్న పబ్లిక్ మెంబర్ ఫంక్షన్లను అందించాలనుకుంటున్నాము లేదా ఫంక్షన్ (ఫంక్షన్) చదవాలనుకుంటున్నాము లేదా డేటాను పొందాలనుకుంటున్నాము లేదా ఫంక్షన్ (ఫంక్షన్) రాయాలి లేదా డేటా (డేటా) పై పద్ధతులను సెట్ చేయాలనుకుంటున్నాము.
కాబట్టి, నేను మొత్తం ఆలోచనను ఒక ఉదాహరణ పరంగా వివరించాను, ఇక్కడ నేను ఉన్న తరగతి ఉంది. క్లాస్ మైక్లాస్‌గా చెప్పండి, ఇది చాలా ముఖ్యమైనది కాదు.
నలుగురు డేటా సభ్యులు ఉన్నారు మరియు నేను ఇక్కడ క్లాస్ డెఫినిషన్ ప్రారంభం నుండి ఎటువంటి యాక్సెస్ స్పెసిఫైయర్‌ను ఉపయోగించలేదు, అంటే అప్రమేయంగా ఈ డేటా సభ్యులు అక్కడ ప్రైవేట్‌గా ఉన్నారు మరియు ఈ డేటా (డేటా) సభ్యుల ఉద్దేశ్యం అంటే మొదట చదివిన డేటా సభ్యులు డేటా సభ్యుడు, నేను డేటా సభ్యుని కాబట్టి, ఇది ప్రైవేట్, కాబట్టి ఎవరైనా నేరుగా రావచ్చు మరియు దాని విలువ మారదు, కానీ దాని ఉపయోగం పరంగా దాని విలువను చదివి వ్రాయాలనుకుంటున్నాను.
ఉదాహరణకు, ఇది సంక్లిష్ట సంఖ్య యొక్క పున components- భాగాలు, సంక్లిష్ట సంఖ్య యొక్క im భాగాలు వంటి సభ్యుడు, నేను సంక్లిష్ట సంఖ్యను చదువుతుంటే ఈ భాగం యొక్క విలువను చదివి సెట్ చేయాలి.
నేను సంక్లిష్ట సంఖ్య యొక్క ప్రస్తుత విలువను వ్రాస్తున్నట్లయితే, నేను మళ్ళీ చదవాలి, im భాగం మరియు మొదలైనవి.
పెద్ద సంఖ్యలో డేటా సభ్యులు చదవలేనివారు.
అందువల్ల, నేను దీన్ని చేయగలిగే కొన్ని యంత్రాంగాన్ని అందించాలి మరియు దీన్ని చేయటానికి సరళమైన మార్గం జత గేట్-సెట్ ఫంక్షన్‌ను అందించడం.
మీకు ఏమి లభిస్తుంది, ఫంక్షన్ సెట్ చేయండి? ఈ వేరియబుల్‌లోని రీడ్ రైట్‌లో గెట్ ఫంక్షన్ ఒక పేరు getReadWrite అని చెబుతుంది, ఇది ఈ డేటా సభ్యుడిని తీసుకొని తిరిగి ఇస్తుంది.
ఈ పద్ధతి బహిరంగ ప్రదేశంలో ఉంచబడుతుంది, కాబట్టి ఏదైనా బాహ్య ఫంక్షన్ (ఫంక్షన్) లేదా మరొక తరగతి (తరగతి) లోని ఏ ఇతర సభ్యుడు ఫంక్షన్ getReadWrite ఫంక్షన్ (ఫంక్షన్) ను స్థానికంగా పిలుస్తారు, ఎందుకంటే ఇది బహిరంగ ప్రదేశంలో లభిస్తుంది.
మరియు అది ప్రైవేట్ సభ్యుడిని యాక్సెస్ చేస్తుంది మరియు దాని విలువను తిరిగి ఇస్తుంది.
కాబట్టి ఒక విధంగా మనం బయటి ప్రపంచానికి ఎంపిక చేసుకుంటున్నాము, దాని విలువపై నియంత్రణతో ఒకరు దీన్ని ప్రత్యేకంగా చేయవలసి వచ్చినప్పుడల్లా ఈ ప్రత్యేకత ద్వారా వెళ్ళాలి, దాన్ని సాధించడం మధ్య ఒక ప్రాథమిక వ్యత్యాసం ఏమిటి మరియు నేను అని చెప్పనివ్వండి విలువను v తీసుకునే సమితిని కలిగి ఉండండి మరియు వాస్తవానికి డేటా సభ్యులు చదివే శాస్త్రం.
కాబట్టి ప్రాథమికంగా, నేను గెట్ మరియు సెట్ రెండింటినీ కలిగి ఉంటే, నేను ఈ వేరియబుల్, రీడ్‌రైట్‌ను చదవగలను.
ఇప్పుడు మీరు దీన్ని ప్రైవేట్‌గా ఎందుకు చేయాలనుకుంటున్నారో ఇప్పుడు మీరు ఆశ్చర్యపోతున్నారు, ఆపై దాన్ని పొందగలిగే మరియు సెట్ చేయగలిగే ఒక జత పబ్లిక్ పద్ధతులు ఉన్నాయి, మేము దీన్ని పబ్లిక్‌గా చేయగలము మరియు ఎవరైనా దీన్ని మార్చగలరు.
కానీ అవును, చదవడం మరియు వ్రాయడం విషయంలో ఇది ఒకటే, కాని పెద్ద తేడా ఉంది ఎందుకంటే నేను దానిని బహిరంగంగా ఉంచితే ఆ వస్తువు ఎప్పటికీ తెలియదు, అది జరుగుతున్నప్పుడు అది ప్రత్యేక డేటా అవుతుంది. సభ్యుడు చదువుతున్నాడా లేదా అది పూర్తయినప్పుడు చదవండి.
కానీ అది ఒక ఫంక్షన్ ద్వారా జరిగితే అది చదివేటప్పుడు ఒక పద్ధతి ఉంటుంది కాబట్టి నేను ఇక్కడ కొన్ని లెక్కలు కూడా చేయగలను.
వ్రాసేటప్పుడు ఈ విలువ రాయడానికి ముందు లేదా తరువాత నేను కొన్ని లెక్కలు కూడా చేయగలను.
అందువల్ల, రీడ్ రైట్ యొక్క విలువ మార్చబడిందని లేదా రీడ్ రైట్ యొక్క విలువను ఎవరైనా చదివారని ఆ వస్తువు ఎల్లప్పుడూ తెలుసుకుంటుంది.
కాబట్టి, ఈ డేటా సభ్యుడిని పబ్లిక్ యాక్సెస్‌గా ఉంచడం సరికాదు.
ఇ
30. ప్పుడు, మనం చదవడానికి మాత్రమే చేయాలనుకుంటున్న తదుపరిదాన్ని చూస్తే ఇతర డేటా సభ్యులకు వస్తోంది.
31. అందువల్ల, ఏదైనా మోడల్ యొక్క విభిన్న వాస్తవ-ప్రపంచ డేటా రకాల పరంగా, ఎన్కప్సులేషన్ పుట్టిన తేదీ లాగా మాత్రమే చదివే డేటా చాలా ఉందని మేము కనుగొంటాము.
32. ఒక వ్యక్తి పుట్టిన తేదీ మారదు, కాబట్టి ఆ వ్యక్తి కోసం ఒక వస్తువును సృష్టించేటప్పుడు దానిని ఏదో ఒకదానికి అమర్చాలి మరియు ఆ తరువాత దానిని మార్చడం సాధ్యం కాకూడదు, దానిని నియంత్రించడానికి ఉత్తమ మార్గం ఒక ప్రైవేట్ యాక్సెస్‌తో సృష్టించబడుతుంది ఆపై దానిపై ఒక ఫంక్షన్‌ను మాత్రమే స్వీకరించడానికి అనుమతించండి.
33. కాబట్టి, అది ఎవరైనా పుట్టిన తేదీని చదవడానికి మరియు ఆ వ్యక్తి వయస్సును లెక్కించడానికి లేదా ఉద్యోగి ఐడిని చదివి తనిఖీ చేయడానికి, విద్యార్థి యొక్క రోల్ నంబర్‌ను చదవడానికి మరియు విద్యార్థి గ్రేడ్‌ను కనుగొనటానికి అనుమతిస్తుంది.
34. ఈ ఫంక్షన్లన్నీ ఆ డేటాను పొందడానికి మాకు అనుమతిస్తాయి, కానీ ఆ డేటాను మార్చలేవు.
35. కాబట్టి, దీని అర్థం నేను అందుకున్న ఫంక్షన్‌ను అందించినట్లయితే మరియు ప్రతిస్పందించే డేటా డేటాను మాత్రమే చదివితే.
36. మీరు దాన్ని పొందిన తర్వాత, మిగిలినవి చాలా సరళంగా ముందుకు సాగుతాయి.ఇది సాధ్యమయ్యే అన్ని కలయికలను పూర్తి చేస్తుంది. మీరు ఆ వేరియబుల్‌పై సెట్ పద్ధతిని కలిగి ఉంటే మాత్రమే నిజమైన వేరియబుల్ అవుతుంది, కానీ మార్గం లేదు, కాబట్టి ఆశ్చర్యపోకండి ఒక వేరియబుల్ మాత్రమే వ్రాయబడుతుంది. చాలా వేరియబుల్స్ మాత్రమే వ్రాయబడతాయి.
37. చాలా సాధారణ ఉదాహరణ పాస్వర్డ్, ఎందుకంటే పాస్వర్డ్ చాలా సున్నితంగా ఉంటుంది, సాధారణంగా మీరు కోరుకున్న పాస్వర్డ్ను చదవడానికి ఏ వ్యవస్థను అనుమతించకూడదని, అనుమతించవలసి ఉంటుంది, పాస్వర్డ్ను మార్చడానికి ఒక విధానం ఉంది.
38. కాబట్టి, పాస్‌వర్డ్ మీరు టైప్ చేసే విషయం. మీరు ఆ విలువలను ఎప్పుడూ చదవరు.
39. మీరు కేవలం వ్రాయగలిగే ఏ పనిని మాత్రమే సెట్ చేయవచ్చు మరియు చేయలేరు.
40. అదేవిధంగా, చివరి సమూహంలో మీరు స్టాక్ లేదా డేటా శ్రేణి యొక్క స్టాక్ వంటి అదృశ్య సభ్యులను కలిగి ఉండవచ్చు. స్టాక్ వాటన్నింటినీ ఎలా నిర్వహిస్తుందో మీరు తెలుసుకోవద్దు. మీరు పుష్ (పాప్), పాప్, టాప్ మరియు ఖాళీ ఏమిటో తెలుసుకోవాలనుకుంటున్నారు మీరు పని చేయాలి.
41. కాబట్టి, శీర్షికలు లేదా డేటా (డేటా) యొక్క విలువను చదవడం లేదా శీర్షాలు లేదా డేటా (డేటా) యొక్క విలువను మార్చడం / సెట్ చేయడం వంటి పద్ధతులు ఉండకూడదు మరియు అందువల్ల దానిపై సెట్-గెట్ పద్ధతులు ఉండకూడదు.
42. కాబట్టి, ఈ సెట్-గేట్ ఇడియమ్‌లతో, డేటా సభ్యుల ప్రాప్యతపై మేము చాలా మంచి ధాన్యం నియంత్రణను సృష్టించగలము మరియు విభిన్న పద్ధతులను సమానంగా యాక్సెస్ చేయవచ్చు, అయితే, గేట్-సెట్ అనేది ఒక నిర్దిష్ట పదబంధం మరింత పరిమిత పనులు చేయడానికి మిమ్మల్ని అనుమతించే డేటా సభ్యులు.
43. కలిసి మేము ఈ మాడ్యూల్ను మూసివేస్తాము.
44. ఈ మాడ్యూల్‌లో, తరగతి సభ్యులు, ప్రభుత్వ మరియు ప్రైవేట్ వ్యక్తుల దృశ్యమానతను నియంత్రించడంలో ప్రాప్యత స్పేసర్‌లు ఎలా సహాయపడతాయో మేము అర్థం చేసుకున్నాము.
45. ఒక తరగతి అమలు గురించి సమాచారాన్ని దాచడానికి, ఇంటర్‌ఫేస్ ద్వారా ప్రవర్తనను బహిర్గతం చేయడానికి మేము చూసినట్లుగా వీటిని ఉపయోగించవచ్చు మరియు గేట్-సెట్ యొక్క పద్ధతులు నిర్దిష్ట ఇడియమ్‌లను కలిగి ఉన్నాయని మేము ప్రత్యేకంగా చూశాము C ++ నుండి గొప్ప ధాన్యం నియంత్రణను అందిస్తుంది.
46. మీ రూపకల్పనలో మీరు అందించాలనుకుంటున్న డేటా సభ్యుల పరంగా ఇంటర్ఫేస్.
47.
ప్పుడు, మనం చదవడానికి మాత్రమే చేయాలనుకుంటున్న తదుపరిదాన్ని చూస్తే ఇతర డేటా సభ్యులకు వస్తోంది.
అందువల్ల, ఏదైనా మోడల్ యొక్క విభిన్న వాస్తవ-ప్రపంచ డేటా రకాల పరంగా, ఎన్కప్సులేషన్ పుట్టిన తేదీ లాగా మాత్రమే చదివే డేటా చాలా ఉందని మేము కనుగొంటాము.
ఒక వ్యక్తి పుట్టిన తేదీ మారదు, కాబట్టి ఆ వ్యక్తి కోసం ఒక వస్తువును సృష్టించేటప్పుడు దానిని ఏదో ఒకదానికి అమర్చాలి మరియు ఆ తరువాత దానిని మార్చడం సాధ్యం కాకూడదు, దానిని నియంత్రించడానికి ఉత్తమ మార్గం ఒక ప్రైవేట్ యాక్సెస్‌తో సృష్టించబడుతుంది ఆపై దానిపై ఒక ఫంక్షన్‌ను మాత్రమే స్వీకరించడానికి అనుమతించండి.
కాబట్టి, అది ఎవరైనా పుట్టిన తేదీని చదవడానికి మరియు ఆ వ్యక్తి వయస్సును లెక్కించడానికి లేదా ఉద్యోగి ఐడిని చదివి తనిఖీ చేయడానికి, విద్యార్థి యొక్క రోల్ నంబర్‌ను చదవడానికి మరియు విద్యార్థి గ్రేడ్‌ను కనుగొనటానికి అనుమతిస్తుంది.
ఈ ఫంక్షన్లన్నీ ఆ డేటాను పొందడానికి మాకు అనుమతిస్తాయి, కానీ ఆ డేటాను మార్చలేవు.
కాబట్టి, దీని అర్థం నేను అందుకున్న ఫంక్షన్‌ను అందించినట్లయితే మరియు ప్రతిస్పందించే డేటా డేటాను మాత్రమే చదివితే.
మీరు దాన్ని పొందిన తర్వాత, మిగిలినవి చాలా సరళంగా ముందుకు సాగుతాయి.ఇది సాధ్యమయ్యే అన్ని కలయికలను పూర్తి చేస్తుంది. మీరు ఆ వేరియబుల్‌పై సెట్ పద్ధతిని కలిగి ఉంటే మాత్రమే నిజమైన వేరియబుల్ అవుతుంది, కానీ మార్గం లేదు, కాబట్టి ఆశ్చర్యపోకండి ఒక వేరియబుల్ మాత్రమే వ్రాయబడుతుంది. చాలా వేరియబుల్స్ మాత్రమే వ్రాయబడతాయి.
చాలా సాధారణ ఉదాహరణ పాస్వర్డ్, ఎందుకంటే పాస్వర్డ్ చాలా సున్నితంగా ఉంటుంది, సాధారణంగా మీరు కోరుకున్న పాస్వర్డ్ను చదవడానికి ఏ వ్యవస్థను అనుమతించకూడదని, అనుమతించవలసి ఉంటుంది, పాస్వర్డ్ను మార్చడానికి ఒక విధానం ఉంది.
కాబట్టి, పాస్‌వర్డ్ మీరు టైప్ చేసే విషయం. మీరు ఆ విలువలను ఎప్పుడూ చదవరు.
మీరు కేవలం వ్రాయగలిగే ఏ పనిని మాత్రమే సెట్ చేయవచ్చు మరియు చేయలేరు.
అదేవిధంగా, చివరి సమూహంలో మీరు స్టాక్ లేదా డేటా శ్రేణి యొక్క స్టాక్ వంటి అదృశ్య సభ్యులను కలిగి ఉండవచ్చు. స్టాక్ వాటన్నింటినీ ఎలా నిర్వహిస్తుందో మీరు తెలుసుకోవద్దు. మీరు పుష్ (పాప్), పాప్, టాప్ మరియు ఖాళీ ఏమిటో తెలుసుకోవాలనుకుంటున్నారు మీరు పని చేయాలి.
కాబట్టి, శీర్షికలు లేదా డేటా (డేటా) యొక్క విలువను చదవడం లేదా శీర్షాలు లేదా డేటా (డేటా) యొక్క విలువను మార్చడం / సెట్ చేయడం వంటి పద్ధతులు ఉండకూడదు మరియు అందువల్ల దానిపై సెట్-గెట్ పద్ధతులు ఉండకూడదు.
కాబట్టి, ఈ సెట్-గేట్ ఇడియమ్‌లతో, డేటా సభ్యుల ప్రాప్యతపై మేము చాలా మంచి ధాన్యం నియంత్రణను సృష్టించగలము మరియు విభిన్న పద్ధతులను సమానంగా యాక్సెస్ చేయవచ్చు, అయితే, గేట్-సెట్ అనేది ఒక నిర్దిష్ట పదబంధం మరింత పరిమిత పనులు చేయడానికి మిమ్మల్ని అనుమతించే డేటా సభ్యులు.
కలిసి మేము ఈ మాడ్యూల్ను మూసివేస్తాము.
ఈ మాడ్యూల్‌లో, తరగతి సభ్యులు, ప్రభుత్వ మరియు ప్రైవేట్ వ్యక్తుల దృశ్యమానతను నియంత్రించడంలో ప్రాప్యత స్పేసర్‌లు ఎలా సహాయపడతాయో మేము అర్థం చేసుకున్నాము.
ఒక తరగతి అమలు గురించి సమాచారాన్ని దాచడానికి, ఇంటర్‌ఫేస్ ద్వారా ప్రవర్తనను బహిర్గతం చేయడానికి మేము చూసినట్లుగా వీటిని ఉపయోగించవచ్చు మరియు గేట్-సెట్ యొక్క పద్ధతులు నిర్దిష్ట ఇడియమ్‌లను కలిగి ఉన్నాయని మేము ప్రత్యేకంగా చూశాము C ++ నుండి గొప్ప ధాన్యం నియంత్రణను అందిస్తుంది.
మీ రూపకల్పనలో మీరు అందించాలనుకుంటున్న డేటా సభ్యుల పరంగా ఇంటర్ఫేస్.
inhouse/NPTEL/PreFinal/c++/Telugu/21. ProgramminginCplusplus_Default Parameters and Function Overloading (Lecture 12)-uJGmGAShHeU.txt
View file @ 956c0d4e
 1. C ++ లో ప్రోగ్రామింగ్లో మాడ్యూల్ 8 కు స్వాగతం.
2. C ++ యొక్క ఉత్తమ C ఫీచర్లను( features) మేము చేస్తున్నాము, మేము ఇప్పటికే కాన్స్టేట్( const) మరియు వోలటైల (volatile) మరియు మాక్రోస్ (macros), ఇన్లైన్ ఫంక్షన్లు మరియు రిఫరెన్స్ వేరియబుల్(reference variable) గురించి కూడా ప్రస్తావించాము మరియు రిఫరెన్స్ ద్వారా సూచన మరియు రిఫరెన్స్ ద్వారా కాల్ చేయండి.
3. ఇవి C ++ యొక్క అన్ని మంచి సి లక్షణాలు.
4. ఇప్పుడు ఈ మాడ్యూల్ 8 లో, డిఫాల్ట్ పారామితులు( default parameter) మరియు ఫంక్షన్ ఓవర్లోడింగ్ (function overloading) గురించి మాట్లాడండి.
5. C ++ భాష యొక్క ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రాపర్టీలను ( object oriented properties)ఎనేబుల్ (enable)చేయుటకు రెండు చాలా ముఖ్యమైన చాలా ముఖ్యమైన లక్షణాలు.
6. ఇది ప్రదర్శన యొక్క ఎడమ పానెల్లో (panel) మీరు చూస్తున్న ఈ మాడ్యూల్ యొక్క మొత్తం ఆకారం అవుతుంది.
7. కాబట్టి, మేము ఇప్పుడు ప్రారంభించాము.
8. ఇప్పుడు, ముందుగా మనము డిఫాల్ట్ పారామితుల(default parameters) గురించి చర్చించాము మరియు నేను సి నుండి ఒక ఉదాహరణతో మొదలు పెడతాను, ముఖ్యంగా ఇది MSDN, విండోస్ ప్రోగ్రామింగ్( windows programming) నుండి ఒక ఉదాహరణ.
9. మీరు ఒక గ్రాఫిక్స్ ప్రోగ్రామింగ్ (graphics programming) మరియు విండోస్ గురించి తెలిసి ఉంటే, మీరు ఈ ఫంక్షన్ని చూడవచ్చు, మీరు దీనిని చూడకపోతే, ఇది నిజంగా పట్టింపు లేదు.
10. నేను ఎడమ కాలమ్లో చూపించదలచినది అన్నింటికీ సృష్టించే విండో ఫంక్షన్(window function) నమూనా లేదా శీర్షిక.
11. మీరు ఫంక్షన్ పెద్ద సంఖ్యలో చూడగలరు; ప్రత్యేకించి, నమూనాలో దాని వివరణ కోసం 11 వివిధ పారామితులు.
12. మీరు ఒక గ్రాఫిటీ విండోను సృష్టించాల్సినప్పుడు సృష్టించిన విండో ఫంక్షన్ను కాల్ చేయడానికి మీరు ఈ 11 పరామితులను పేర్కొనవలసి ఉంటుంది.
13. కుడి నిలువు కాలమ్లో లో నేను విండోను రూపొందించడానికి ఒక విలక్షణ సృష్టి విండో విండోను చూపుతాను.
14. ఇప్పుడు, ఈ ప్రత్యేక విధిని పరిగణనలోకి తీసుకుంటే మీరు రెండు విషయాలు చూడగలరు; ఒకటి పారామితులు పెద్ద సంఖ్యలో ఉంది, 11 పారామితులు మరియు మీరు సాధారణంగా ఈ 11 పారామితులు అర్థం తెలుసుకోవాలి ఈ ఉపయోగించడానికి మరియు మీరు ఆ పారామితులు పేర్కొనాలి ఉంటుంది.
15. ఇప్పుడు, మీరు కేవలం నమూనా విండోని సృష్టించాలనుకుంటున్నారా, డిఫాల్ట్ బ్యాక్గ్రౌండ్( default background) రంగు, డిఫాల్ట్ టెక్స్ట్(default text) కలర్, మీరు మానిటర్లో డిఫాల్ట్ సెంటర్ లొకేషన్లో (default center location)ఒక విండో కావాలనుకోండి, మీరు డిఫాల్ట్ వెడల్పు(default width) మరియు ఎత్తు( height)
16. మరియు అందువలన న.
17. మీరు అన్ని విభిన్న విలువలను పేర్కొనడానికి అవసరమైన అవసరం ఉండకపోవచ్చు; ఈ 11 పారామీటర్లలో(parameters) మీ అప్లికేషన్లకు(applications) ప్రత్యేకమైనవి.
18. సో, మీరు అసలు కాల్ లోకి చూస్తే మీరు కాల్ లో అనేక పారామితులు ఉన్నాయి అని చూసే సులభతరం; మీరు ఇక్కడ పరామితులను చూస్తే, ఇవి ప్రాథమికంగా మానిఫెస్ట్ స్థిరాంకాలు( manifest constants)అయినవి, విండో వాడకం డిఫాల్ట్ సృష్టించడానికి CW ని సూచిస్తుంది.
19. ఇది అప్పటికే లైబ్రరీలో నిర్వచించిన కొన్ని డిఫాల్ట్ విలువ(default value) ఉంది కాబట్టి మీరు ఆ విలువలను ఉపయోగించవచ్చు.
20. కాబట్టి ప్రాథమికంగా, మీరు ఆ విలువలను సరఫరా చేయలేదు.
21. అదేవిధంగా, మీరు విండో పేరెంట్ మరియు మెనూలో చూస్తే లేదా విండో పారామితులలోకి చూస్తున్నట్లయితే మనం కేవలం శూన్యాన్ని పంపుతున్నాము, ఇది ప్రాథమికంగా ఒక రకమైన డిఫాల్ట్ విలువ.
22. hInstance, విండో యొక్క ఉదాహరణ.
23. మీకు తెలిసిన విండో ప్రోగ్రామింగ్(programming) మీకు తెలిస్తే మీ అప్లికేషన్ (application)యొక్క ఒక ఉదాహరణ ఇది కూడా ఒక రకమైన డిఫాల్ట్ విలువలను(default value) పొందుతుంది, కాబట్టి మీరు సృష్టించే విండో రకంతో మీరు ఒక అతివ్యాప్తి చెందిన విండోను సృష్టించి, దానితోనే ఉంటుంది.
24. ఈ 11 పారామితులు ఫంక్షన్ లో ఉన్నప్పటికీ మరియు మీరు వాటిని అన్ని పేర్కొనండి అవసరం అనేక లైబ్రరీ ద్వారా డిఫాల్ట్ విలువలు ఇవ్వబడ్డాయి లేదా శూన్య వంటి పాస్ మరియు మీరు నిజంగా మీ విండో తరగతి ఏమిటి వంటి కొన్ని విషయాలు పేర్కొనాలి ఏ మీరు చేస్తున్న నిర్దిష్ట నిర్మాణం మరియు ఈ కాల్ చేయడానికి విండో పేరు బహుశా.
25. అయితే ఇంకా, మొత్తం పదకొండు పారామీటర్ల పూర్తిస్థాయిలో పిలవబడాలి.
26. మీరు పారామీటర్లను ఒక విధంగా ఏర్పాటు చేయగలిగితే, మీ కాల్స్ కోసం మీరు పేర్కొన్న పరామితులను మాత్రమే కాల్ దృష్టిలో ఇవ్వాలి.
27. వ్యవస్థకు కొన్ని డిఫాల్ట్ విలువలను పేర్కొనకుండానే సాధారణంగా డిఫాల్ట్ పారామితులను(default parameters) అర్థం చేసుకుని, తీసుకుంటే, ప్రతిసారీ మీరు ఆ పిలుస్తారు.
28. కాబట్టి, C ++ మాకు దీని గురించి ఏదో చేయటానికి అనుమతిస్తుంది మరియు ఆ లక్షణాన్ని డిఫాల్ట్ పారామిటర్ అని పిలుస్తారు.
29. ఇప్పుడు, ఇక్కడ డిఫాల్ట్ పారామీటర్ల అర్ధం వివరించడానికి ఒక ఉదాహరణ.
30. ఈ ఫంక్షన్(function) పరిగణించండి, కార్యాచరణ నిజంగా చాలా ముఖ్యమైనది కాదు, మేము దీనిని ఐడెంటిటీఫాంక్షన్గా (identity function)పిలుస్తున్నాము, అది పరామితిని తీసుకుంటుంది మరియు అదే పారామీటర్ను తిరిగి అందిస్తుంది.
31. కానీ మనము హైలైట్ చేయటానికి ఆసక్తి కలిగి ఉన్నాము, మీరు ఇక్కడ గమనించవలసిన అవసరం ఉంది, పరామితి యొక్క ప్రాధమిక విలువ యొక్క పారామితి యొక్క ఫంక్షన్ యొక్క సంతకంలో ఇచ్చిన విలువను a.
32. ఇప్పుడు, ఒక నిర్దిష్ట పరిధిలోని వేరియబుల్ (variables)యొక్క ప్రాధమిక విలువ ఏమంటే, ఒక పారామితి కోసం ప్రారంభ లేదా డిఫాల్ట్ యొక్క రకమైన అర్ధం ఏమిటి.
33. మాకు కాల్ చేద్దాం అని అర్థం చేసుకోవడానికి, మాకు ఫంక్షన్ యొక్క మొదటి కాల్ కు చూద్దాం.
34. ఫంక్షన్ యొక్క మొదటి కాల్ మేము గుర్తింపు విలువను వాస్తవంగా పారామితికి పిలుస్తాము x ఇది ప్రస్తుతం విలువ 5 కలిగి ఉంది, కనుక మనం ఇక్కడ ఆ పారామితిని పంపుతున్నాము మరియు అందువల్ల ఇది అదే విలువను ఇస్తుంది మరియు మీరు ఈ లైన్ నుండి అవుట్పుట్(output) చేస్తారు మరియు మీరు పొందుతారు ఈ సమయంలో అవుట్పుట్ యొక్క మొదటి పంక్తి.
35. ఈ పాయింట్( point)వరకు ఆశ్చర్యం లేదు.
36. ఇప్పుడు, మనము అదే ఫంక్షన్ యొక్క రెండవ కాల్ పై దృష్టి పెట్టండి.
37. ఏ పరామితి లేకుండా ఈ ఫంక్షన్ కాల్ చేయవచ్చని గమనించడానికి మీరు ఆశ్చర్యపోతారు.
38. మేము ఇప్పటివరకు C లో ఉన్నాము, అసలు పరామితుల సంఖ్య మరియు అధికారిక పారామితుల సంఖ్య కాల్ మరియు ఫంక్షన్ యొక్క ప్రోటోటైప్(prototype) మధ్య సరిపోవాలి.
39. వాస్తవమైన పారామితులు మరియు ఫార్మల్ పారామితులు(formal parameters) వారి క్రమంలో, వారి డేటా టైప(data type) లో మరియు దానితో సరిపోలాలి.
40. కానీ ఇక్కడ, ఫంక్షన్ నిజానికి ఒక పారామీటర్ ఉంది, కానీ నేను ఇక్కడ కాల్ చేసినప్పుడు నేను పారామితి పేర్కొనడం లేదు.
41. ఈ డిఫాల్ట్ పారామితి ఫీచర్ (default parameter feature)ఏమిటి.
42. C ++ ఏమి చేస్తుంది? మీరు ఏ పరామితి లేకుండానే కాల్ చేసివుండటం వలన మరియు ఫంక్షన్ ఇప్పటికే పారామితి విలువ డిఫాల్ట్ విలువ(default value) 10 తో నిర్వచించబడటం వలన ఇక్కడ మీరు ఈ డిఫాల్ట్ విలువతో ఫంక్షన్ అని పిలిచినట్లు మీరు భావిస్తారు.
43. కాబట్టి, మీరు పారామితి డిఫాల్ట్ చేస్తే, మీరు నిజంగా రెండు ఎంపికలు పొందుతారు; ఒకటి, ఇక్కడ మీరు ఫంక్షన్ కాల్ చేయగలిగేలా మీరు ఫంక్షన్ పిలుపునిచ్చారు, వాస్తవ పారామితిని పేర్కొనడం లేదా మీరు పారామీటర్ యొక్క డిఫాల్ట్ విలువను ఉపయోగించి ఎంపిక చేసుకోవచ్చు మరియు పేర్కొనవలసిన అవసరం లేదు
44. వాస్తవమైన పారామితి మీరు దాటవేయవచ్చు.
45. వ్యవస్థ మీరు పారామితిని వాడుతున్నారని మరియు ఫంక్షన్ డిక్లరేషన్(function declaration) లో డిఫాల్ట్ లో ఇవ్వబడిన విలువను నిర్దేశిస్తుంది.
46. కాబట్టి, ఇది డిఫాల్ట్ పారామితి(default parameter) యొక్క ప్రాథమిక లక్షణం.
47. ఇప్పుడు మనం ముందుకు వెళ్దాము మరియు మరో ఉదాహరణ చూద్దాము.
48. గత ఉదాహరణలో, మనము ఒక ఫంక్షన్ ను అప్రమేయ పారామితి కలిగివున్నాము మరియు ఇప్పుడు మీకు డిఫాల్ట్ పరామితి మాత్రమే వుంటుంది, అది మీకు అప్రమేయ పారామితులు అప్రమేయ పారామీటర్ల సంఖ్య ఏకపక్ష సంఖ్య.
49. మనము ఇక్కడ ఒక ఫంక్షన్ చూపుతాము, ఈ యొక్క కార్యాచరణ గురించి, దీని కోసం అల్గోరిథం గురించి ఆందోళన చెందకండి, అది కేవలం రెండు పారామితులను వాటిని జతచేస్తుంది మరియు వాటిని తిరిగి పంపుతుంది, ఇక్కడ ఈ ఫంక్షన్ నిర్వచనాన్ని చూడండి, మరియు ఇది రెండు పారామితులను కలిగి ఉంటుంది integerకి; int a మరియు int b.
50. మరియు మనం చేసిన పారామితులు ప్రతి ప్రారంభ విలువతో డీఫాల్ట్ చేయబడ్డాయి.
51. కాబట్టి, ఈ ఫంక్షన్ ను వాడేటప్పుడు మరియు కాల్ చేస్తే మీరు మొదటి కాల్ని చూస్తే, మొదటి కాల్ అనేది సాధారణ ఫంక్షన్ కాల్ (function call), x మరియు y రెండు వాస్తవ పారామితులు.
52. X (y,y)ను జోడించాము, కాబట్టి x అక్కడ 'a' కు కాపీ చేయబడుతుంది, మీరు చూడగలిగిన విలువను కాల్ చేస్తారు, y b కు కాపీ చెయ్యబడింది మరియు function is x మరియు y విలువలు మరియు 5 మరియు 6 మరియు అందువలన మీరు ఇక్కడ మొత్తాన్ని ప్రింట్ చేస్తే మొత్తం మొదటి అవుట్పుట్(output) అవుతుంది, ఇది మొత్తం 11 అవుతుంది.
53. ఇప్పుడు, అదే ఫంక్షన్ యొక్క రెండవ కాల్ చూడండి.
54. ఈ ఫంక్షన్ యొక్క రెండవ కాల్ లో, మనము మొదటి పారామితి x ను అందిస్తాము కానీ మనము రెండవ పరామితిని అందించలేదు, అనగా ఫంక్షన్ వాస్తవానికి రెండు పారామితులను కలిగి ఉంటే, దానిని ఒక పరామితితో పిలుస్తాము.
55. కాబట్టి, ఏమి జరుగుతుంది? మేము x కు అనుగుణంగా అందించిన ఈ పరామితి, అధికారిక పరామితికి అనుగుణంగా ఉంటుంది, అందుచే x యొక్క విలువను విలువలో కాల్ ద్వారా కాపీ చేయబడుతుంది.
56. కానీ రెండవ పరామితి అందించబడలేదు, కాబట్టి మీరు రెండవ పరామితి యొక్క డిఫాల్ట్ విలువను( default value) ఉపయోగిస్తున్నారని సిస్టమ్ (system)అర్థం అవుతుంది, అనగా రెండవ పరామితి 20 గా ఉంటుంది, ఎందుకంటే రెండవ పరామితిలో ఇచ్చిన డిఫాల్ట్ విలువ (default value)20.
57. అందువలన, ఈ సందర్భంలో ఫంక్షన్ a తో 5 మరియు b' గా 10 వరకు కొనసాగుతుంది మరియు అది గణన అవుతుంది మరియు మీరు అవుట్పుట్(output) నుండి చూడవచ్చు, + b 25 గా లెక్కించబడుతుంది మరియు అది ముద్రితమవుతుంది.
58. మేము దీనిని మరింత విస్తరించవచ్చు.
59. మేము వాస్తవమైన పారామీటర్ను(parameter) అందించని కాల్ యొక్క మూడవ ఉదాహరణలో మనం ఏమి చేస్తాము.
60. కాబట్టి, ఫంక్షన్ యొక్క రెండు పారామితులు, మరియు b రెండూ వాటి డిఫాల్ట్ విలువలను(default value) తీసుకుంటాయి, అంటే 'a' is 10 మరియు b 20 మరియు ఇది ఇక్కడ ఉన్న ఫంక్షన్ నిజంగా కనిపించదు, కానీ ఇక్కడ ఫంక్షన్ 30 ను కొంత ఫలితంగా ముద్రిస్తుంది.
61. మనము చూడగలము, నేను తప్పకుండా ఒక పారామితి మాత్రమే తప్పనిసరిగా ఉండవలసిన అవసరం లేదు, కానీ అది ఒక ఫంక్షన్లో పారామితుల యొక్క ఏకపక్ష సంఖ్యను నేను డిఫాల్ట్ చేయగలము.
62. మరియు పారామితులు యొక్క మంచి సమితి తరచూ పనిచేయడానికి అప్రమేయ విలువను తీసుకునే పారామితుల సంఖ్యతో ప్రత్యేకంగా రాయడం చాలా ఉపయోగకరంగా ఉంటుంది.
63. మేము డిఫాల్ట్ పారామితుల(default parameter) గురించి ప్రాథమిక అంశాలను హైలైట్(highlight) చేస్తాము, అది C ++ ప్రోగ్రామర్లు ఫంక్షన్ పారామీటర్లకు డిఫాల్ట్ విలువలను కేటాయించటానికి అనుమతిస్తుంది, మీరు దీనిని చూశారు.
64. ఫంక్షన్ను ప్రోటోటిఫై చేస్తున్నప్పుడు అప్రమేయ విలువలు తెలుపబడును.
65. ఫంక్షన్ ప్రోటోటైపింగ్, అంటే ఏమిటి అంటే మీరు చూసినట్లుగా ఫంక్షన్ సంతకం లో( function signature) డిఫాల్ట్ విలువలను వ్రాస్తారు.
66. తక్కువ ఆర్గ్యుమెంట్స్తో(arguments) లేదా వాదన లేకుండానే ఫంక్షన్ను కాల్ చేస్తున్నప్పుడు డిఫాల్ట్ పారామితులు అవసరమవుతాయి, అందువల్ల వారు కాల్ సైట్లో లేనప్పుడు వారి డిఫాల్ట్ విలువతో ఉపయోగించిన ఒకటి లేదా రెండు పారామితులు ఎలా ఉన్నాయో మేము చూసాము.
67. వంటిఒక అభ్యాసం, ఖచ్చితంగా ఏ పారామితులు అప్రమేయంగా ఉండాలి మరియు పారామితులు అప్రమేయంగా ఉండకూడదు అని చెప్పలేము.
68. కానీ ఒక సాధనంగా మీరు తక్కువగా ఉపయోగించిన పారామీటర్ల కోసం డిఫాల్ట్ విలువలను ఉపయోగించడం మంచిది, అయితే మీరు నిజంగానే అన్ని పారామీటర్ల కోసం డిఫాల్ట్ విలువను ఉపయోగించవచ్చు.
69. డిఫాల్ట్ వాదనలు, మీరు ఫంక్షన్ను డిఫాల్ట్ వాదనలు అని పిలుస్తున్నప్పుడు లేదా డిఫాల్ట్ విలువలు కూడా సంకలనం సమయంలో గణించబడేంత కాలం కూడా వ్యక్తీకరణగా ఉండవచ్చు.
70. నేను డిఫాల్ట్ పారామితులుగా 2 +3 వంటి డిఫాల్ట్ విలువలను కలిగి ఉండవచ్చు.
71. ఇది ఒక ఫంక్షన్కు చెల్లుతుంది, నేను 2+ 3 వంటి డిఫాల్ట్ విలువను కలిగి ఉంటుంది, కంపైలర్(compiler) ఏమి చేయాలో, కంపైల్ చేస్తున్నప్పుడు అది 2 +3 ను గణించడం అవుతుంది మరియు డిఫాల్ట్ విలువ 5 గా సెట్ చేయబడుతుంది.
72. ఒక డిఫాల్ట్ విలువను కలిగి ఉండరాదు, ఇది సంకలనం సమయంలో వ్యక్తీకరణగా ఉండదు, అది n + ని, స్థిరమైన విలువగా, నిరంతర integerగా నిర్వచించబడకపోతే, 2 + n అని చెప్పవచ్చు.
73. ఎందుకంటే n వేరియబుల్(variable) అయితే కంపైలర్ మీ ప్రోగ్రామ్ను కంపైల్ చేసే సమయానికి మీకు తెలియదు.
74. ఇప్పుడు మనం చూడాలనుకుంటున్నాము, అది నేను కోరుకున్న విధంగా ఒక ఫంక్షన్ యొక్క పారామితులను డీఫాల్ట్ చేయగలగడానికి, లేదా మనం అనుసరించాల్సిన కొన్ని ప్రాథమిక నియమాలు లేదా పరిమితులు ఉన్నాయి .
75. కాబట్టి, మేము డిఫాల్ట్ పారామితుల యొక్క కొన్ని ప్రాథమిక నియమాలను డిస్కస్ (discuss) చేస్తాము.
76. మొదటి నిబంధన చాలా ముఖ్యమైనది అప్రమేయ వాదనతో పరామితికి అన్ని పరామితులు డిఫాల్ట్ వాదనలు కలిగి ఉండాలి.
77. ఈ నియమం కోసం, ఈ ప్రత్యేక ఫంక్షన్ చూడండి.
78. మేము ఫంక్షన్ f గురించి మాట్లాడుతున్నాము ఇది మూడు పారామితులు కలిగి, Int, డబుల్(double), మరియు పాత్రకు పాయింటర్(pointer).
79. ఈ సందర్భంలో మేము రెండవ పరామితికి డిఫాల్ట్ విలువను అందించాము, ఎందుకు చార్( char) * అనే మూడవ పారామితికి ఏ డిఫాల్ట్ విలువను అందించలేదు.
80. మీరు ఇలా చేస్తే అప్పుడు కంపైలర్ మీకు error ఇస్తాడు మరియు ఈ సందర్భంలో, నేను ఒక కంపైలర్ నుండి దోషం చూపించాను, ఈ పరామితికి పారామీటర్ (parameter) మూడు కోసం డిఫాల్ట్ పారామితి లేదు అని చెప్పేది.
81. కాబట్టి, నేను ఏదైనా ఫంక్షన్ వ్రాస్తే మరియు నేను ఒక పారామీటర్ కలిగి ఉంటే, రెండు పారామితి, మూడు పారామీటర్, మరియు కొన్ని పారామితి డిఫాల్ట్ (parameter default)ఉంటే అప్పుడు అన్ని పారామితులు తర్వాత నేను వ్రాసే అన్ని పారామితులు ఈ అన్ని తరువాత డిఫాల్ట్ పారామితి అప్రమత్తంగా ఉండాలి; తరువాతి మనం అంతా డిపాజిట్(deposit) చేయాల్సినంత వరకు అన్నింటినీ డిపాజిట్ చేయాలి.
82. లేకపోతే, కంపైలర్ మీరు నిజంగా ఏ పారామీటర్లను ఉపయోగిస్తున్నారో పరిష్కరించలేరు.
83. కాబట్టి మొదటి నియమం, అది మనకు పరామితికి డిఫాల్ట్ అయ్యాక అది అన్ని పారామితులను కలిగివుండేది డిఫాల్ట్ విలువలను పొందాలి.
84. ఇక్కడ రెండవ పాలన ఉంది, డిఫాల్ట్ పారామితులు పునర్నిర్వచించలేవు.
85. మీరు చూడండి, ఈ రెండు పంక్తులు చెప్పండి.
86. ఇక్కడ మొదటగా మనము ఒక ఫంక్షన్ f ను నిర్వచించాము, ఇది మూడు పారామితులను మళ్ళీ, Int, డబుల్ మరియు చార్ *, మరియు రెండు పారామితులు రెండవ పరామితి 0 కు మరియు మూడవ పరామితిని ఒక శూన్య పాయింటర్కు (pointer)అప్రమేయంగా మార్చాయి, ఇది ఓకే, సహజంగా.
87. తరువాత, మేము మళ్ళీ అదే చర్య ప్రోటోటైప్ g గురించి మాట్లాడుతున్నాము, కానీ, మీరు ఈ రెండు విలువలతో చూస్తే, ఇప్పుడు మేము రెండవ పరామితి కోసం డిఫాల్ట్ విలువను ఉపయోగిస్తున్నాము.
88. కాబట్టి, ఇది అనుమతించబడదు, మీరు కేవలం ఒక ఫంక్షన్ యొక్క పారామితి విలువను మాత్రమే ఒకసారి డిఫాల్ట్ చేయవచ్చు.
89. మీరు డీఫాల్ట్ చేసిన తర్వాత మళ్ళీ మీరు డిఫాల్ట్ పరామితి విలువను పేర్కొనలేరు.
90. ఇప్పుడు మీరు ఈ సందిగ్ధత అని అనుకుంటారు, ఎందుకంటే మీరు సున్నాకు డబుల్ డీఫాల్ట్ చేసి, మీరు రెండు డిఫాల్ట్ విలువలను ఉపయోగించారని మీరు జాగ్రత్తగా చూస్తున్నట్లయితే మీరు డబుల్ డీఫాల్ట్ చేసి, కంపైలర్ ఇక్కడ చూపిన ఈ error ఇవ్వడం పారామితి రెండు error, కానీ యాదృచ్ఛికంగా కంపైలర్ నిజానికి మీరు అందించిన డిఫాల్ట్ వాస్తవ విలువను చూడండి లేదు.
91. దీన్ని అర్థం చేసుకోవడానికి, దయచేసి మీ దృష్టిని మూడవ పరామితి యొక్క డిఫాల్ట్ విలువకు( default value) దృష్టి పెట్టండి.
92. ఇక్కడ మూడవ పారామిటర్ ప్రారంభంలో మొదటి సందర్భంలో శూన్యంగా ఇవ్వబడింది మరియు రెండో కేసు అది మళ్లీ శూన్యంగా పునర్నిర్వచించబడుతుంది కాబట్టి మీరు నిజంగానే అదే డిఫాల్ట్ విలువను తదుపరి సమయంలో ఉపయోగిస్తున్నారు.
93. కానీ కూడా, కంపైలర్(compiler) గందరగోళం అవుతుంది మరియు పారామీటర్ మూడు కోసం డిఫాల్ట్ పారామితి పునర్నిర్వచించబడిందని, అది ఇప్పటికే నిర్వచించబడిందని మరియు మళ్లీ నిర్వచించబడుతుందని మరియు ఇది అనుమతించబడదు అని మీకు చెప్పబడుతుంది.
94. మీరు ఇంతకు ముందు నిర్వచించబడిన అదే విలువతో డిఫాల్ట్ విలువను తిరిగి నిర్వచించాలో లేదో లేదా మీరు ఇంతకు ముందు ఉపయోగించిన వేరొక విలువను ఉపయోగించి డిఫాల్ట్ విలువను తిరిగి నిర్వచించటం లేదో పట్టింపు లేదు, రెండు సందర్భాలలో ఈ అనుమతి లేదు.
95. కాబట్టి డిఫాల్ట్ పారామితులను వాడుతున్న చోట్ల డిఫాల్ట్ వాదనలు పునర్నిర్వచించబడవు, ఈ నియమం సంఖ్య రెండు.
96. మీరు డిఫాల్ట్ పారామీటర్లను ఉపయోగిస్తున్నప్పటి నుండి వాటిని కాల్ సమయంలో పేర్కొనడానికి ఎంచుకోవచ్చు లేదా మీరు కాల్ సమయంలో వాటిని పేర్కొనలేదని మూడవ నియమం చెబుతుంది.
97. కాబట్టి, మనము ఫంక్షన్ g యొక్క సందర్భంలో చూస్తే, ఖచ్చితంగా ఈ ఖచ్చితమైన నిర్వచనాన్ని అనగా ఖచ్చితమైన నిర్వచనంగా చెప్పండి, అప్పుడు ఈ మూడు కాల్స్ చెల్లుబాటు అయ్యేవి అని నేను చూడగలను, అంటే నేను ఒక పారామితి గ్రా(i)ఇది మొదటిగా తీసుకోబడుతుంది లేదా నేను మొదటి రెండు పారామితులను i మరియు d తో పిలుస్తాము, ఇది Int మరియు డబుల్( double) లేదా నేను మూడు పారామితులతో కాల్ చేయవచ్చు.
98. ముగ్గురూ బాగున్నారు.
99. మీరు ఏదైనా పరామితి లేకుండా ఫంక్షన్ గ్రాని కాల్ చేయడానికి ప్రయత్నిస్తే, అది ఒక error అవుతుంది ఎందుకంటే మీరు ఈ పారామితి లేకుండా ఈ ఫంక్షన్ కాల్ చేయవలసి ఉంటే, అప్పుడు మొదటి పారామితి ఈ సందర్భంలో చేయబడలేదు.
100. కాబట్టి, ఒక ఫంక్షన్ యొక్క కొన్ని పారామితులు డిఫాల్ట్ విలువలకు ఇచ్చినట్లయితే కనీసం అన్ని అప్రమేయ పారామీటర్లను( parameters) వాస్తవ పారామితులుగా మరియు డిఫాల్ట్ పారామితులుగా పేర్కొనవలసి ఉంటుంది, డిఫాల్ట్ పారామీటర్ల విషయంలో మీకు ఎంపిక ఉంది మరియు మీరు పేర్కొనవచ్చు వాటిలో ఏదీ లేదా వాటిలో ఏదీ కాదు, కానీ వాటిలో కొన్నింటిని మీరు పేర్కొన్నట్లయితే, మీరు ఎల్లప్పుడూ నియమాన్ని అనుసరించాల్సి ఉంటుంది, మీరు వాటిని ఎడమవైపున సరైన క్రమంలో పేర్కొనవలసి ఉంటుంది.
101. ఇక్కడ నేను అనుకుందాం, మీరు ఈ ప్రత్యేకమైన వివరణను పరిశీలిస్తే, నాకు శుభ్రం చేసి మళ్ళీ చూపించాను అని పేర్కొనడం చేస్తున్నాను, మీరు ఈ కాల్స్లోకి చూస్తున్నారా అనుకుందాం, ఇక్కడ ఫంక్షన్ మూడు పారామీటర్లను( parameters) కలిగి ఉంది కానీ మనము ఈ రెండింటిని పేర్కొంటున్నాము.
102. కాబట్టి, ఇక్కడ వాటిలో మొదటిది తప్పనిసరిగా నాన్-డిఫాల్ట్ పారామితి( non-default parameter), ఇది తప్పనిసరిగా అవసరం మరియు రెండో పరామితి మీరు పేర్కొన్నట్లు డబల్ గా తీసుకోబడుతుంది.
103. ఇప్పుడు, మీరు నేను కాల్ లాగా కాల్ చేయడానికి ప్రయత్నిస్తాను అనుకుంటాను ఈ కాల్, నేను పూర్ణాంకానికి వెళ్తానని అర్థం, ఇది మూడవ పారామితి చార్( char)* కోసం వెళ్తుంది మరియు మధ్యలో డబుల్ విలువ 0.0 గా తీసుకోబడుతుంది.
104. ఇది సాధ్యం కాదు, ఇది error.
105. దీనికి కారణమేమిటంటే కంపైలర్ రెండు డీఫాల్ట్ పారామీటర్ల (default parameter) మధ్య డబుల్ మరియు చార్ * ల మధ్య తెలుసుకోవటానికి ఎటువంటి మార్గం లేదు, మీరు ఇక్కడ పేర్కొనబడినది మరియు మీరు ఇక్కడ పేర్కొన్నది ఏది.
106. మీరు ఈ పారామితులను వాడుతుంటే, మీరు ఒక నిర్దిష్ట క్రమంలో డిఫాల్ట్ విలువలను ఉపయోగించవచ్చు, వాస్తవానికి ఇచ్చిన పారామితులు కాల్ నుండి ఎడమ నుండి కుడికి సరిపోల్చాలి, మీరు దాటవేయగల పాయింట్ తర్వాత మాత్రమే ఉంటుంది అన్ని పారామితులు ఆ పారామితి యొక్క కుడి వైపున, కానీ మధ్య నుండి ఏదో దాటవేయి లేదు.
107. కాబట్టి, ఇవి డిఫాల్ట్ పారామితులు( default parameter) అనుసరించాల్సిన కొన్ని ప్రాథమిక నియమాలు.
108. ఇక్కడ, మనం మరొకదాన్ని చూపిస్తాము; ఇది సరిగ్గా భాష యొక్క నిర్వచనం ద్వారా నియమం కాదు కానీ నేను ఈ విధంగానే మీరు డిఫాల్ట్ పారామితులను ఉపయోగించి ఎలా చేయాలో ఆచరణలో చూపించాను.
109. కాబట్టి, అతను అప్రమేయ పారామితులు మాత్రమే హెడ్డర్ ఫైల్లో సరఫరా చేయాలి మరియు ఫంక్షన్ నిర్వచనంలో కాదు, మీరు డిఫాల్ట్ పారామీటర్ చేస్తున్నట్లయితే, ఇది మీకు డిఫాల్ట్ పేర్కొనడానికి ఉన్న ఒక శీర్షిక ఫైల్ ఉంటే ఈ నిర్వచనమేమిటంటే, ఆ ఫంక్షన్ కోసం శరీరాన్ని అందించిన ఫంక్షన్ను నిర్వచించిన మూలం ఫైల్.
110. కాబట్టి మనం ఏమి చెప్తున్నామో మీరు ఏ డిఫాల్ట్ పరామితిని ఎక్కడా పేర్కొనకూడదు లేదా ఎక్కడో వేరే ఎక్కడైనా మీరు ఈ ఫంక్షన్ను ఉపయోగించి ఇక్కడ చెప్పండి.
111. ఇప్పుడు, మనము ఏమి జరుగుతుందో చూద్దాం, ఈ ఫంక్షన్ నమూనాలో ఇవ్వబడుతుంది మరియు ఇది ఒక దరఖాస్తు కోడ్, ఇది ఒక ఫంక్షన్ వాడుతూ వున్న ఒక అప్లికేషన్ కోడ్( code) కాబట్టి ఇది ఈ ప్రత్యేక ఫంక్షన్ నిర్వచనం, ఈ ప్రత్యేక ఫంక్షన్ నమూనా చేర్చబడింది.
112. ఇప్పుడు మీరు ఈ వంటి ఏదో రాయడానికి కావలసిన మీ అప్లికేషన్ యొక్క శరీరం అనుకుందాం, ఆశ్చర్యకరంగా ఈ అన్ని ఆమోదయోగ్యమైన అన్ని ఈ అంగీకరించబడుతుంది.
113. కాబట్టి, మీరు ఇక్కడ ఏమి చెప్తున్నారో, మీరు శీర్షిక నుండి మూడవ పారామితి అప్పటికే డిఫాల్ట్(default) అయ్యిందని, ఇప్పుడు మీరు నా రెండవ పారామీటర్ కూడా డిఫాల్ట్ అయ్యారని చెపుతున్నారు.
114. కాబట్టి ఇప్పుడు నాకు ఉంది; నా ఫంక్షన్ గ్రా, కాబట్టి ఈ రెండు కలిసి నిజానికి అర్థం నా ఫంక్షన్ గ్రా రెండు దాని యొక్క పారామితులు డిఫాల్ట్ మరియు అందువలన న.
115. అదేవిధంగా, ఇక్కడ మూడవ సందర్భంలో, మొదటి పారామితి కూడా డీఫాల్ట్ చెయ్యబడింది.
116. అప్రమేయ పారామితి విశేషణము దానిని చేయుటకు అనుమతించును, కానీ మీరు వుపయోగిస్తున్నప్పుడు మీకు ఇబ్బంది ఉండదు, అప్రమేయ నిర్వచనములోని భాగము హెడర్ ఫైలునందు మరియు అప్రమేయ నిర్వచనాల భాగము మీ మూలం ఫైల్, అమలు ఫైలులో వున్నది.
117. కాబట్టి, ఏ పారామీటర్లు డీఫాల్ట్ చేయబడతాయో ఏ ఒక్క అంశంలోనైనా మీకు తెలియదు మరియు ఏ విలువలు అవి డిఫాల్ట్ (default) అవుతాయి.
118. కాబట్టి, అన్ని డిఫాల్ట్లను వాడాలి; మీరు ఈ వంటి ఏదో చేయాలని ఉంటే వాటిని అన్ని శీర్షిక ఫైళ్ళకు తరలించబడింది చేయాలి కాబట్టి ఒక సమయంలో మీరు డిఫాల్ట్ పారామితులు ఉన్నాయి ఏమి చూడగలరు మరియు వారి విలువలు ఏమిటి, లేకపోతే ఈ పద్దతి యొక్క ఈ విధానం డిఫాల్ట్ పారామితులు కోడ్ వ్రాయడం నిజంగా చాలా గందరగోళంగా పొందండి.
119. ఇది ఆచరణాత్మక పాయింట్ నుండి ఒక పరిమితిగా ఉంటుంది, మీరు భాషా చివరికి చూస్తే, మీరు ఈ నిర్వచనాలతో మీరు నిజంగానే నాలుగు వేర్వేరు రూపాలతో ఫంక్షన్ గ్రానికే పిలుస్తారని నేను చూపించినట్లు చూపించాయి ఎందుకంటే మూడు పారామితులు చివరికి అప్రమేయం చేయబడ్డాయి, కానీ ఒకే స్థలంలో వాటిని ఎల్లప్పుడూ అప్రమత్తంగా ఉండేలా చేస్తాయి, తద్వారా ఒకే సంతకం లో వాటిని మూడు వేర్వేరు సంతకాలలో వరుసగా మూడుసార్లు వేరు చేయటానికి బదులు వాటిని ఉపయోగించడం కోసం చాలా గందరగోళంగా మారుతుంది.
120. కాబట్టి, C ++ యొక్క డిఫాల్ట్ పారామితుల( default parameter) లక్షణాన్ని మేము చూశాము మరియు దానిని ఎలా ఉపయోగించాలో మరియు మేము ఉపయోగించే పరిమితులు ఏమిటి?
121.
 C ++ లో ప్రోగ్రామింగ్లో మాడ్యూల్ 8 కు స్వాగతం.
C ++ యొక్క ఉత్తమ C ఫీచర్లను( features) మేము చేస్తున్నాము, మేము ఇప్పటికే కాన్స్టేట్( const) మరియు వోలటైల (volatile) మరియు మాక్రోస్ (macros), ఇన్లైన్ ఫంక్షన్లు మరియు రిఫరెన్స్ వేరియబుల్(reference variable) గురించి కూడా ప్రస్తావించాము మరియు రిఫరెన్స్ ద్వారా సూచన మరియు రిఫరెన్స్ ద్వారా కాల్ చేయండి.
ఇవి C ++ యొక్క అన్ని మంచి సి లక్షణాలు.
ఇప్పుడు ఈ మాడ్యూల్ 8 లో, డిఫాల్ట్ పారామితులు( default parameter) మరియు ఫంక్షన్ ఓవర్లోడింగ్ (function overloading) గురించి మాట్లాడండి.
C ++ భాష యొక్క ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రాపర్టీలను ( object oriented properties)ఎనేబుల్ (enable)చేయుటకు రెండు చాలా ముఖ్యమైన చాలా ముఖ్యమైన లక్షణాలు.
ఇది ప్రదర్శన యొక్క ఎడమ పానెల్లో (panel) మీరు చూస్తున్న ఈ మాడ్యూల్ యొక్క మొత్తం ఆకారం అవుతుంది.
కాబట్టి, మేము ఇప్పుడు ప్రారంభించాము.
ఇప్పుడు, ముందుగా మనము డిఫాల్ట్ పారామితుల(default parameters) గురించి చర్చించాము మరియు నేను సి నుండి ఒక ఉదాహరణతో మొదలు పెడతాను, ముఖ్యంగా ఇది MSDN, విండోస్ ప్రోగ్రామింగ్( windows programming) నుండి ఒక ఉదాహరణ.
మీరు ఒక గ్రాఫిక్స్ ప్రోగ్రామింగ్ (graphics programming) మరియు విండోస్ గురించి తెలిసి ఉంటే, మీరు ఈ ఫంక్షన్ని చూడవచ్చు, మీరు దీనిని చూడకపోతే, ఇది నిజంగా పట్టింపు లేదు.
నేను ఎడమ కాలమ్లో చూపించదలచినది అన్నింటికీ సృష్టించే విండో ఫంక్షన్(window function) నమూనా లేదా శీర్షిక.
మీరు ఫంక్షన్ పెద్ద సంఖ్యలో చూడగలరు; ప్రత్యేకించి, నమూనాలో దాని వివరణ కోసం 11 వివిధ పారామితులు.
మీరు ఒక గ్రాఫిటీ విండోను సృష్టించాల్సినప్పుడు సృష్టించిన విండో ఫంక్షన్ను కాల్ చేయడానికి మీరు ఈ 11 పరామితులను పేర్కొనవలసి ఉంటుంది.
కుడి నిలువు కాలమ్లో లో నేను విండోను రూపొందించడానికి ఒక విలక్షణ సృష్టి విండో విండోను చూపుతాను.
ఇప్పుడు, ఈ ప్రత్యేక విధిని పరిగణనలోకి తీసుకుంటే మీరు రెండు విషయాలు చూడగలరు; ఒకటి పారామితులు పెద్ద సంఖ్యలో ఉంది, 11 పారామితులు మరియు మీరు సాధారణంగా ఈ 11 పారామితులు అర్థం తెలుసుకోవాలి ఈ ఉపయోగించడానికి మరియు మీరు ఆ పారామితులు పేర్కొనాలి ఉంటుంది.
ఇప్పుడు, మీరు కేవలం నమూనా విండోని సృష్టించాలనుకుంటున్నారా, డిఫాల్ట్ బ్యాక్గ్రౌండ్( default background) రంగు, డిఫాల్ట్ టెక్స్ట్(default text) కలర్, మీరు మానిటర్లో డిఫాల్ట్ సెంటర్ లొకేషన్లో (default center location)ఒక విండో కావాలనుకోండి, మీరు డిఫాల్ట్ వెడల్పు(default width) మరియు ఎత్తు( height)
మరియు అందువలన న.
మీరు అన్ని విభిన్న విలువలను పేర్కొనడానికి అవసరమైన అవసరం ఉండకపోవచ్చు; ఈ 11 పారామీటర్లలో(parameters) మీ అప్లికేషన్లకు(applications) ప్రత్యేకమైనవి.
సో, మీరు అసలు కాల్ లోకి చూస్తే మీరు కాల్ లో అనేక పారామితులు ఉన్నాయి అని చూసే సులభతరం; మీరు ఇక్కడ పరామితులను చూస్తే, ఇవి ప్రాథమికంగా మానిఫెస్ట్ స్థిరాంకాలు( manifest constants)అయినవి, విండో వాడకం డిఫాల్ట్ సృష్టించడానికి CW ని సూచిస్తుంది.
ఇది అప్పటికే లైబ్రరీలో నిర్వచించిన కొన్ని డిఫాల్ట్ విలువ(default value) ఉంది కాబట్టి మీరు ఆ విలువలను ఉపయోగించవచ్చు.
కాబట్టి ప్రాథమికంగా, మీరు ఆ విలువలను సరఫరా చేయలేదు.
అదేవిధంగా, మీరు విండో పేరెంట్ మరియు మెనూలో చూస్తే లేదా విండో పారామితులలోకి చూస్తున్నట్లయితే మనం కేవలం శూన్యాన్ని పంపుతున్నాము, ఇది ప్రాథమికంగా ఒక రకమైన డిఫాల్ట్ విలువ.
hInstance, విండో యొక్క ఉదాహరణ.
మీకు తెలిసిన విండో ప్రోగ్రామింగ్(programming) మీకు తెలిస్తే మీ అప్లికేషన్ (application)యొక్క ఒక ఉదాహరణ ఇది కూడా ఒక రకమైన డిఫాల్ట్ విలువలను(default value) పొందుతుంది, కాబట్టి మీరు సృష్టించే విండో రకంతో మీరు ఒక అతివ్యాప్తి చెందిన విండోను సృష్టించి, దానితోనే ఉంటుంది.
ఈ 11 పారామితులు ఫంక్షన్ లో ఉన్నప్పటికీ మరియు మీరు వాటిని అన్ని పేర్కొనండి అవసరం అనేక లైబ్రరీ ద్వారా డిఫాల్ట్ విలువలు ఇవ్వబడ్డాయి లేదా శూన్య వంటి పాస్ మరియు మీరు నిజంగా మీ విండో తరగతి ఏమిటి వంటి కొన్ని విషయాలు పేర్కొనాలి ఏ మీరు చేస్తున్న నిర్దిష్ట నిర్మాణం మరియు ఈ కాల్ చేయడానికి విండో పేరు బహుశా.
అయితే ఇంకా, మొత్తం పదకొండు పారామీటర్ల పూర్తిస్థాయిలో పిలవబడాలి.
మీరు పారామీటర్లను ఒక విధంగా ఏర్పాటు చేయగలిగితే, మీ కాల్స్ కోసం మీరు పేర్కొన్న పరామితులను మాత్రమే కాల్ దృష్టిలో ఇవ్వాలి.
వ్యవస్థకు కొన్ని డిఫాల్ట్ విలువలను పేర్కొనకుండానే సాధారణంగా డిఫాల్ట్ పారామితులను(default parameters) అర్థం చేసుకుని, తీసుకుంటే, ప్రతిసారీ మీరు ఆ పిలుస్తారు.
కాబట్టి, C ++ మాకు దీని గురించి ఏదో చేయటానికి అనుమతిస్తుంది మరియు ఆ లక్షణాన్ని డిఫాల్ట్ పారామిటర్ అని పిలుస్తారు.
ఇప్పుడు, ఇక్కడ డిఫాల్ట్ పారామీటర్ల అర్ధం వివరించడానికి ఒక ఉదాహరణ.
ఈ ఫంక్షన్(function) పరిగణించండి, కార్యాచరణ నిజంగా చాలా ముఖ్యమైనది కాదు, మేము దీనిని ఐడెంటిటీఫాంక్షన్గా (identity function)పిలుస్తున్నాము, అది పరామితిని తీసుకుంటుంది మరియు అదే పారామీటర్ను తిరిగి అందిస్తుంది.
కానీ మనము హైలైట్ చేయటానికి ఆసక్తి కలిగి ఉన్నాము, మీరు ఇక్కడ గమనించవలసిన అవసరం ఉంది, పరామితి యొక్క ప్రాధమిక విలువ యొక్క పారామితి యొక్క ఫంక్షన్ యొక్క సంతకంలో ఇచ్చిన విలువను a.
ఇప్పుడు, ఒక నిర్దిష్ట పరిధిలోని వేరియబుల్ (variables)యొక్క ప్రాధమిక విలువ ఏమంటే, ఒక పారామితి కోసం ప్రారంభ లేదా డిఫాల్ట్ యొక్క రకమైన అర్ధం ఏమిటి.
మాకు కాల్ చేద్దాం అని అర్థం చేసుకోవడానికి, మాకు ఫంక్షన్ యొక్క మొదటి కాల్ కు చూద్దాం.
ఫంక్షన్ యొక్క మొదటి కాల్ మేము గుర్తింపు విలువను వాస్తవంగా పారామితికి పిలుస్తాము x ఇది ప్రస్తుతం విలువ 5 కలిగి ఉంది, కనుక మనం ఇక్కడ ఆ పారామితిని పంపుతున్నాము మరియు అందువల్ల ఇది అదే విలువను ఇస్తుంది మరియు మీరు ఈ లైన్ నుండి అవుట్పుట్(output) చేస్తారు మరియు మీరు పొందుతారు ఈ సమయంలో అవుట్పుట్ యొక్క మొదటి పంక్తి.
ఈ పాయింట్( point)వరకు ఆశ్చర్యం లేదు.
ఇప్పుడు, మనము అదే ఫంక్షన్ యొక్క రెండవ కాల్ పై దృష్టి పెట్టండి.
ఏ పరామితి లేకుండా ఈ ఫంక్షన్ కాల్ చేయవచ్చని గమనించడానికి మీరు ఆశ్చర్యపోతారు.
మేము ఇప్పటివరకు C లో ఉన్నాము, అసలు పరామితుల సంఖ్య మరియు అధికారిక పారామితుల సంఖ్య కాల్ మరియు ఫంక్షన్ యొక్క ప్రోటోటైప్(prototype) మధ్య సరిపోవాలి.
వాస్తవమైన పారామితులు మరియు ఫార్మల్ పారామితులు(formal parameters) వారి క్రమంలో, వారి డేటా టైప(data type) లో మరియు దానితో సరిపోలాలి.
కానీ ఇక్కడ, ఫంక్షన్ నిజానికి ఒక పారామీటర్ ఉంది, కానీ నేను ఇక్కడ కాల్ చేసినప్పుడు నేను పారామితి పేర్కొనడం లేదు.
ఈ డిఫాల్ట్ పారామితి ఫీచర్ (default parameter feature)ఏమిటి.
C ++ ఏమి చేస్తుంది? మీరు ఏ పరామితి లేకుండానే కాల్ చేసివుండటం వలన మరియు ఫంక్షన్ ఇప్పటికే పారామితి విలువ డిఫాల్ట్ విలువ(default value) 10 తో నిర్వచించబడటం వలన ఇక్కడ మీరు ఈ డిఫాల్ట్ విలువతో ఫంక్షన్ అని పిలిచినట్లు మీరు భావిస్తారు.
కాబట్టి, మీరు పారామితి డిఫాల్ట్ చేస్తే, మీరు నిజంగా రెండు ఎంపికలు పొందుతారు; ఒకటి, ఇక్కడ మీరు ఫంక్షన్ కాల్ చేయగలిగేలా మీరు ఫంక్షన్ పిలుపునిచ్చారు, వాస్తవ పారామితిని పేర్కొనడం లేదా మీరు పారామీటర్ యొక్క డిఫాల్ట్ విలువను ఉపయోగించి ఎంపిక చేసుకోవచ్చు మరియు పేర్కొనవలసిన అవసరం లేదు
వాస్తవమైన పారామితి మీరు దాటవేయవచ్చు.
వ్యవస్థ మీరు పారామితిని వాడుతున్నారని మరియు ఫంక్షన్ డిక్లరేషన్(function declaration) లో డిఫాల్ట్ లో ఇవ్వబడిన విలువను నిర్దేశిస్తుంది.
కాబట్టి, ఇది డిఫాల్ట్ పారామితి(default parameter) యొక్క ప్రాథమిక లక్షణం.
ఇప్పుడు మనం ముందుకు వెళ్దాము మరియు మరో ఉదాహరణ చూద్దాము.
గత ఉదాహరణలో, మనము ఒక ఫంక్షన్ ను అప్రమేయ పారామితి కలిగివున్నాము మరియు ఇప్పుడు మీకు డిఫాల్ట్ పరామితి మాత్రమే వుంటుంది, అది మీకు అప్రమేయ పారామితులు అప్రమేయ పారామీటర్ల సంఖ్య ఏకపక్ష సంఖ్య.
మనము ఇక్కడ ఒక ఫంక్షన్ చూపుతాము, ఈ యొక్క కార్యాచరణ గురించి, దీని కోసం అల్గోరిథం గురించి ఆందోళన చెందకండి, అది కేవలం రెండు పారామితులను వాటిని జతచేస్తుంది మరియు వాటిని తిరిగి పంపుతుంది, ఇక్కడ ఈ ఫంక్షన్ నిర్వచనాన్ని చూడండి, మరియు ఇది రెండు పారామితులను కలిగి ఉంటుంది integerకి; int a మరియు int b.
మరియు మనం చేసిన పారామితులు ప్రతి ప్రారంభ విలువతో డీఫాల్ట్ చేయబడ్డాయి.
కాబట్టి, ఈ ఫంక్షన్ ను వాడేటప్పుడు మరియు కాల్ చేస్తే మీరు మొదటి కాల్ని చూస్తే, మొదటి కాల్ అనేది సాధారణ ఫంక్షన్ కాల్ (function call), x మరియు y రెండు వాస్తవ పారామితులు.
X (y,y)ను జోడించాము, కాబట్టి x అక్కడ 'a' కు కాపీ చేయబడుతుంది, మీరు చూడగలిగిన విలువను కాల్ చేస్తారు, y b కు కాపీ చెయ్యబడింది మరియు function is x మరియు y విలువలు మరియు 5 మరియు 6 మరియు అందువలన మీరు ఇక్కడ మొత్తాన్ని ప్రింట్ చేస్తే మొత్తం మొదటి అవుట్పుట్(output) అవుతుంది, ఇది మొత్తం 11 అవుతుంది.
ఇప్పుడు, అదే ఫంక్షన్ యొక్క రెండవ కాల్ చూడండి.
ఈ ఫంక్షన్ యొక్క రెండవ కాల్ లో, మనము మొదటి పారామితి x ను అందిస్తాము కానీ మనము రెండవ పరామితిని అందించలేదు, అనగా ఫంక్షన్ వాస్తవానికి రెండు పారామితులను కలిగి ఉంటే, దానిని ఒక పరామితితో పిలుస్తాము.
కాబట్టి, ఏమి జరుగుతుంది? మేము x కు అనుగుణంగా అందించిన ఈ పరామితి, అధికారిక పరామితికి అనుగుణంగా ఉంటుంది, అందుచే x యొక్క విలువను విలువలో కాల్ ద్వారా కాపీ చేయబడుతుంది.
కానీ రెండవ పరామితి అందించబడలేదు, కాబట్టి మీరు రెండవ పరామితి యొక్క డిఫాల్ట్ విలువను( default value) ఉపయోగిస్తున్నారని సిస్టమ్ (system)అర్థం అవుతుంది, అనగా రెండవ పరామితి 20 గా ఉంటుంది, ఎందుకంటే రెండవ పరామితిలో ఇచ్చిన డిఫాల్ట్ విలువ (default value)20.
అందువలన, ఈ సందర్భంలో ఫంక్షన్ a తో 5 మరియు b' గా 10 వరకు కొనసాగుతుంది మరియు అది గణన అవుతుంది మరియు మీరు అవుట్పుట్(output) నుండి చూడవచ్చు, + b 25 గా లెక్కించబడుతుంది మరియు అది ముద్రితమవుతుంది.
మేము దీనిని మరింత విస్తరించవచ్చు.
మేము వాస్తవమైన పారామీటర్ను(parameter) అందించని కాల్ యొక్క మూడవ ఉదాహరణలో మనం ఏమి చేస్తాము.
కాబట్టి, ఫంక్షన్ యొక్క రెండు పారామితులు, మరియు b రెండూ వాటి డిఫాల్ట్ విలువలను(default value) తీసుకుంటాయి, అంటే 'a' is 10 మరియు b 20 మరియు ఇది ఇక్కడ ఉన్న ఫంక్షన్ నిజంగా కనిపించదు, కానీ ఇక్కడ ఫంక్షన్ 30 ను కొంత ఫలితంగా ముద్రిస్తుంది.
మనము చూడగలము, నేను తప్పకుండా ఒక పారామితి మాత్రమే తప్పనిసరిగా ఉండవలసిన అవసరం లేదు, కానీ అది ఒక ఫంక్షన్లో పారామితుల యొక్క ఏకపక్ష సంఖ్యను నేను డిఫాల్ట్ చేయగలము.
మరియు పారామితులు యొక్క మంచి సమితి తరచూ పనిచేయడానికి అప్రమేయ విలువను తీసుకునే పారామితుల సంఖ్యతో ప్రత్యేకంగా రాయడం చాలా ఉపయోగకరంగా ఉంటుంది.
మేము డిఫాల్ట్ పారామితుల(default parameter) గురించి ప్రాథమిక అంశాలను హైలైట్(highlight) చేస్తాము, అది C ++ ప్రోగ్రామర్లు ఫంక్షన్ పారామీటర్లకు డిఫాల్ట్ విలువలను కేటాయించటానికి అనుమతిస్తుంది, మీరు దీనిని చూశారు.
ఫంక్షన్ను ప్రోటోటిఫై చేస్తున్నప్పుడు అప్రమేయ విలువలు తెలుపబడును.
ఫంక్షన్ ప్రోటోటైపింగ్, అంటే ఏమిటి అంటే మీరు చూసినట్లుగా ఫంక్షన్ సంతకం లో( function signature) డిఫాల్ట్ విలువలను వ్రాస్తారు.
తక్కువ ఆర్గ్యుమెంట్స్తో(arguments) లేదా వాదన లేకుండానే ఫంక్షన్ను కాల్ చేస్తున్నప్పుడు డిఫాల్ట్ పారామితులు అవసరమవుతాయి, అందువల్ల వారు కాల్ సైట్లో లేనప్పుడు వారి డిఫాల్ట్ విలువతో ఉపయోగించిన ఒకటి లేదా రెండు పారామితులు ఎలా ఉన్నాయో మేము చూసాము.
వంటిఒక అభ్యాసం, ఖచ్చితంగా ఏ పారామితులు అప్రమేయంగా ఉండాలి మరియు పారామితులు అప్రమేయంగా ఉండకూడదు అని చెప్పలేము.
కానీ ఒక సాధనంగా మీరు తక్కువగా ఉపయోగించిన పారామీటర్ల కోసం డిఫాల్ట్ విలువలను ఉపయోగించడం మంచిది, అయితే మీరు నిజంగానే అన్ని పారామీటర్ల కోసం డిఫాల్ట్ విలువను ఉపయోగించవచ్చు.
డిఫాల్ట్ వాదనలు, మీరు ఫంక్షన్ను డిఫాల్ట్ వాదనలు అని పిలుస్తున్నప్పుడు లేదా డిఫాల్ట్ విలువలు కూడా సంకలనం సమయంలో గణించబడేంత కాలం కూడా వ్యక్తీకరణగా ఉండవచ్చు.
నేను డిఫాల్ట్ పారామితులుగా 2 +3 వంటి డిఫాల్ట్ విలువలను కలిగి ఉండవచ్చు.
ఇది ఒక ఫంక్షన్కు చెల్లుతుంది, నేను 2+ 3 వంటి డిఫాల్ట్ విలువను కలిగి ఉంటుంది, కంపైలర్(compiler) ఏమి చేయాలో, కంపైల్ చేస్తున్నప్పుడు అది 2 +3 ను గణించడం అవుతుంది మరియు డిఫాల్ట్ విలువ 5 గా సెట్ చేయబడుతుంది.
ఒక డిఫాల్ట్ విలువను కలిగి ఉండరాదు, ఇది సంకలనం సమయంలో వ్యక్తీకరణగా ఉండదు, అది n + ని, స్థిరమైన విలువగా, నిరంతర integerగా నిర్వచించబడకపోతే, 2 + n అని చెప్పవచ్చు.
ఎందుకంటే n వేరియబుల్(variable) అయితే కంపైలర్ మీ ప్రోగ్రామ్ను కంపైల్ చేసే సమయానికి మీకు తెలియదు.
ఇప్పుడు మనం చూడాలనుకుంటున్నాము, అది నేను కోరుకున్న విధంగా ఒక ఫంక్షన్ యొక్క పారామితులను డీఫాల్ట్ చేయగలగడానికి, లేదా మనం అనుసరించాల్సిన కొన్ని ప్రాథమిక నియమాలు లేదా పరిమితులు ఉన్నాయి .
కాబట్టి, మేము డిఫాల్ట్ పారామితుల యొక్క కొన్ని ప్రాథమిక నియమాలను డిస్కస్ (discuss) చేస్తాము.
మొదటి నిబంధన చాలా ముఖ్యమైనది అప్రమేయ వాదనతో పరామితికి అన్ని పరామితులు డిఫాల్ట్ వాదనలు కలిగి ఉండాలి.
ఈ నియమం కోసం, ఈ ప్రత్యేక ఫంక్షన్ చూడండి.
మేము ఫంక్షన్ f గురించి మాట్లాడుతున్నాము ఇది మూడు పారామితులు కలిగి, Int, డబుల్(double), మరియు పాత్రకు పాయింటర్(pointer).
ఈ సందర్భంలో మేము రెండవ పరామితికి డిఫాల్ట్ విలువను అందించాము, ఎందుకు చార్( char) * అనే మూడవ పారామితికి ఏ డిఫాల్ట్ విలువను అందించలేదు.
మీరు ఇలా చేస్తే అప్పుడు కంపైలర్ మీకు error ఇస్తాడు మరియు ఈ సందర్భంలో, నేను ఒక కంపైలర్ నుండి దోషం చూపించాను, ఈ పరామితికి పారామీటర్ (parameter) మూడు కోసం డిఫాల్ట్ పారామితి లేదు అని చెప్పేది.
కాబట్టి, నేను ఏదైనా ఫంక్షన్ వ్రాస్తే మరియు నేను ఒక పారామీటర్ కలిగి ఉంటే, రెండు పారామితి, మూడు పారామీటర్, మరియు కొన్ని పారామితి డిఫాల్ట్ (parameter default)ఉంటే అప్పుడు అన్ని పారామితులు తర్వాత నేను వ్రాసే అన్ని పారామితులు ఈ అన్ని తరువాత డిఫాల్ట్ పారామితి అప్రమత్తంగా ఉండాలి; తరువాతి మనం అంతా డిపాజిట్(deposit) చేయాల్సినంత వరకు అన్నింటినీ డిపాజిట్ చేయాలి.
లేకపోతే, కంపైలర్ మీరు నిజంగా ఏ పారామీటర్లను ఉపయోగిస్తున్నారో పరిష్కరించలేరు.
కాబట్టి మొదటి నియమం, అది మనకు పరామితికి డిఫాల్ట్ అయ్యాక అది అన్ని పారామితులను కలిగివుండేది డిఫాల్ట్ విలువలను పొందాలి.
ఇక్కడ రెండవ పాలన ఉంది, డిఫాల్ట్ పారామితులు పునర్నిర్వచించలేవు.
మీరు చూడండి, ఈ రెండు పంక్తులు చెప్పండి.
ఇక్కడ మొదటగా మనము ఒక ఫంక్షన్ f ను నిర్వచించాము, ఇది మూడు పారామితులను మళ్ళీ, Int, డబుల్ మరియు చార్ *, మరియు రెండు పారామితులు రెండవ పరామితి 0 కు మరియు మూడవ పరామితిని ఒక శూన్య పాయింటర్కు (pointer)అప్రమేయంగా మార్చాయి, ఇది ఓకే, సహజంగా.
తరువాత, మేము మళ్ళీ అదే చర్య ప్రోటోటైప్ g గురించి మాట్లాడుతున్నాము, కానీ, మీరు ఈ రెండు విలువలతో చూస్తే, ఇప్పుడు మేము రెండవ పరామితి కోసం డిఫాల్ట్ విలువను ఉపయోగిస్తున్నాము.
కాబట్టి, ఇది అనుమతించబడదు, మీరు కేవలం ఒక ఫంక్షన్ యొక్క పారామితి విలువను మాత్రమే ఒకసారి డిఫాల్ట్ చేయవచ్చు.
మీరు డీఫాల్ట్ చేసిన తర్వాత మళ్ళీ మీరు డిఫాల్ట్ పరామితి విలువను పేర్కొనలేరు.
ఇప్పుడు మీరు ఈ సందిగ్ధత అని అనుకుంటారు, ఎందుకంటే మీరు సున్నాకు డబుల్ డీఫాల్ట్ చేసి, మీరు రెండు డిఫాల్ట్ విలువలను ఉపయోగించారని మీరు జాగ్రత్తగా చూస్తున్నట్లయితే మీరు డబుల్ డీఫాల్ట్ చేసి, కంపైలర్ ఇక్కడ చూపిన ఈ error ఇవ్వడం పారామితి రెండు error, కానీ యాదృచ్ఛికంగా కంపైలర్ నిజానికి మీరు అందించిన డిఫాల్ట్ వాస్తవ విలువను చూడండి లేదు.
దీన్ని అర్థం చేసుకోవడానికి, దయచేసి మీ దృష్టిని మూడవ పరామితి యొక్క డిఫాల్ట్ విలువకు( default value) దృష్టి పెట్టండి.
ఇక్కడ మూడవ పారామిటర్ ప్రారంభంలో మొదటి సందర్భంలో శూన్యంగా ఇవ్వబడింది మరియు రెండో కేసు అది మళ్లీ శూన్యంగా పునర్నిర్వచించబడుతుంది కాబట్టి మీరు నిజంగానే అదే డిఫాల్ట్ విలువను తదుపరి సమయంలో ఉపయోగిస్తున్నారు.
కానీ కూడా, కంపైలర్(compiler) గందరగోళం అవుతుంది మరియు పారామీటర్ మూడు కోసం డిఫాల్ట్ పారామితి పునర్నిర్వచించబడిందని, అది ఇప్పటికే నిర్వచించబడిందని మరియు మళ్లీ నిర్వచించబడుతుందని మరియు ఇది అనుమతించబడదు అని మీకు చెప్పబడుతుంది.
మీరు ఇంతకు ముందు నిర్వచించబడిన అదే విలువతో డిఫాల్ట్ విలువను తిరిగి నిర్వచించాలో లేదో లేదా మీరు ఇంతకు ముందు ఉపయోగించిన వేరొక విలువను ఉపయోగించి డిఫాల్ట్ విలువను తిరిగి నిర్వచించటం లేదో పట్టింపు లేదు, రెండు సందర్భాలలో ఈ అనుమతి లేదు.
కాబట్టి డిఫాల్ట్ పారామితులను వాడుతున్న చోట్ల డిఫాల్ట్ వాదనలు పునర్నిర్వచించబడవు, ఈ నియమం సంఖ్య రెండు.
మీరు డిఫాల్ట్ పారామీటర్లను ఉపయోగిస్తున్నప్పటి నుండి వాటిని కాల్ సమయంలో పేర్కొనడానికి ఎంచుకోవచ్చు లేదా మీరు కాల్ సమయంలో వాటిని పేర్కొనలేదని మూడవ నియమం చెబుతుంది.
కాబట్టి, మనము ఫంక్షన్ g యొక్క సందర్భంలో చూస్తే, ఖచ్చితంగా ఈ ఖచ్చితమైన నిర్వచనాన్ని అనగా ఖచ్చితమైన నిర్వచనంగా చెప్పండి, అప్పుడు ఈ మూడు కాల్స్ చెల్లుబాటు అయ్యేవి అని నేను చూడగలను, అంటే నేను ఒక పారామితి గ్రా(i)ఇది మొదటిగా తీసుకోబడుతుంది లేదా నేను మొదటి రెండు పారామితులను i మరియు d తో పిలుస్తాము, ఇది Int మరియు డబుల్( double) లేదా నేను మూడు పారామితులతో కాల్ చేయవచ్చు.
ముగ్గురూ బాగున్నారు.
మీరు ఏదైనా పరామితి లేకుండా ఫంక్షన్ గ్రాని కాల్ చేయడానికి ప్రయత్నిస్తే, అది ఒక error అవుతుంది ఎందుకంటే మీరు ఈ పారామితి లేకుండా ఈ ఫంక్షన్ కాల్ చేయవలసి ఉంటే, అప్పుడు మొదటి పారామితి ఈ సందర్భంలో చేయబడలేదు.
కాబట్టి, ఒక ఫంక్షన్ యొక్క కొన్ని పారామితులు డిఫాల్ట్ విలువలకు ఇచ్చినట్లయితే కనీసం అన్ని అప్రమేయ పారామీటర్లను( parameters) వాస్తవ పారామితులుగా మరియు డిఫాల్ట్ పారామితులుగా పేర్కొనవలసి ఉంటుంది, డిఫాల్ట్ పారామీటర్ల విషయంలో మీకు ఎంపిక ఉంది మరియు మీరు పేర్కొనవచ్చు వాటిలో ఏదీ లేదా వాటిలో ఏదీ కాదు, కానీ వాటిలో కొన్నింటిని మీరు పేర్కొన్నట్లయితే, మీరు ఎల్లప్పుడూ నియమాన్ని అనుసరించాల్సి ఉంటుంది, మీరు వాటిని ఎడమవైపున సరైన క్రమంలో పేర్కొనవలసి ఉంటుంది.
ఇక్కడ నేను అనుకుందాం, మీరు ఈ ప్రత్యేకమైన వివరణను పరిశీలిస్తే, నాకు శుభ్రం చేసి మళ్ళీ చూపించాను అని పేర్కొనడం చేస్తున్నాను, మీరు ఈ కాల్స్లోకి చూస్తున్నారా అనుకుందాం, ఇక్కడ ఫంక్షన్ మూడు పారామీటర్లను( parameters) కలిగి ఉంది కానీ మనము ఈ రెండింటిని పేర్కొంటున్నాము.
కాబట్టి, ఇక్కడ వాటిలో మొదటిది తప్పనిసరిగా నాన్-డిఫాల్ట్ పారామితి( non-default parameter), ఇది తప్పనిసరిగా అవసరం మరియు రెండో పరామితి మీరు పేర్కొన్నట్లు డబల్ గా తీసుకోబడుతుంది.
ఇప్పుడు, మీరు నేను కాల్ లాగా కాల్ చేయడానికి ప్రయత్నిస్తాను అనుకుంటాను ఈ కాల్, నేను పూర్ణాంకానికి వెళ్తానని అర్థం, ఇది మూడవ పారామితి చార్( char)* కోసం వెళ్తుంది మరియు మధ్యలో డబుల్ విలువ 0.0 గా తీసుకోబడుతుంది.
ఇది సాధ్యం కాదు, ఇది error.
దీనికి కారణమేమిటంటే కంపైలర్ రెండు డీఫాల్ట్ పారామీటర్ల (default parameter) మధ్య డబుల్ మరియు చార్ * ల మధ్య తెలుసుకోవటానికి ఎటువంటి మార్గం లేదు, మీరు ఇక్కడ పేర్కొనబడినది మరియు మీరు ఇక్కడ పేర్కొన్నది ఏది.
మీరు ఈ పారామితులను వాడుతుంటే, మీరు ఒక నిర్దిష్ట క్రమంలో డిఫాల్ట్ విలువలను ఉపయోగించవచ్చు, వాస్తవానికి ఇచ్చిన పారామితులు కాల్ నుండి ఎడమ నుండి కుడికి సరిపోల్చాలి, మీరు దాటవేయగల పాయింట్ తర్వాత మాత్రమే ఉంటుంది అన్ని పారామితులు ఆ పారామితి యొక్క కుడి వైపున, కానీ మధ్య నుండి ఏదో దాటవేయి లేదు.
కాబట్టి, ఇవి డిఫాల్ట్ పారామితులు( default parameter) అనుసరించాల్సిన కొన్ని ప్రాథమిక నియమాలు.
ఇక్కడ, మనం మరొకదాన్ని చూపిస్తాము; ఇది సరిగ్గా భాష యొక్క నిర్వచనం ద్వారా నియమం కాదు కానీ నేను ఈ విధంగానే మీరు డిఫాల్ట్ పారామితులను ఉపయోగించి ఎలా చేయాలో ఆచరణలో చూపించాను.
కాబట్టి, అతను అప్రమేయ పారామితులు మాత్రమే హెడ్డర్ ఫైల్లో సరఫరా చేయాలి మరియు ఫంక్షన్ నిర్వచనంలో కాదు, మీరు డిఫాల్ట్ పారామీటర్ చేస్తున్నట్లయితే, ఇది మీకు డిఫాల్ట్ పేర్కొనడానికి ఉన్న ఒక శీర్షిక ఫైల్ ఉంటే ఈ నిర్వచనమేమిటంటే, ఆ ఫంక్షన్ కోసం శరీరాన్ని అందించిన ఫంక్షన్ను నిర్వచించిన మూలం ఫైల్.
కాబట్టి మనం ఏమి చెప్తున్నామో మీరు ఏ డిఫాల్ట్ పరామితిని ఎక్కడా పేర్కొనకూడదు లేదా ఎక్కడో వేరే ఎక్కడైనా మీరు ఈ ఫంక్షన్ను ఉపయోగించి ఇక్కడ చెప్పండి.
ఇప్పుడు, మనము ఏమి జరుగుతుందో చూద్దాం, ఈ ఫంక్షన్ నమూనాలో ఇవ్వబడుతుంది మరియు ఇది ఒక దరఖాస్తు కోడ్, ఇది ఒక ఫంక్షన్ వాడుతూ వున్న ఒక అప్లికేషన్ కోడ్( code) కాబట్టి ఇది ఈ ప్రత్యేక ఫంక్షన్ నిర్వచనం, ఈ ప్రత్యేక ఫంక్షన్ నమూనా చేర్చబడింది.
ఇప్పుడు మీరు ఈ వంటి ఏదో రాయడానికి కావలసిన మీ అప్లికేషన్ యొక్క శరీరం అనుకుందాం, ఆశ్చర్యకరంగా ఈ అన్ని ఆమోదయోగ్యమైన అన్ని ఈ అంగీకరించబడుతుంది.
కాబట్టి, మీరు ఇక్కడ ఏమి చెప్తున్నారో, మీరు శీర్షిక నుండి మూడవ పారామితి అప్పటికే డిఫాల్ట్(default) అయ్యిందని, ఇప్పుడు మీరు నా రెండవ పారామీటర్ కూడా డిఫాల్ట్ అయ్యారని చెపుతున్నారు.
కాబట్టి ఇప్పుడు నాకు ఉంది; నా ఫంక్షన్ గ్రా, కాబట్టి ఈ రెండు కలిసి నిజానికి అర్థం నా ఫంక్షన్ గ్రా రెండు దాని యొక్క పారామితులు డిఫాల్ట్ మరియు అందువలన న.
అదేవిధంగా, ఇక్కడ మూడవ సందర్భంలో, మొదటి పారామితి కూడా డీఫాల్ట్ చెయ్యబడింది.
అప్రమేయ పారామితి విశేషణము దానిని చేయుటకు అనుమతించును, కానీ మీరు వుపయోగిస్తున్నప్పుడు మీకు ఇబ్బంది ఉండదు, అప్రమేయ నిర్వచనములోని భాగము హెడర్ ఫైలునందు మరియు అప్రమేయ నిర్వచనాల భాగము మీ మూలం ఫైల్, అమలు ఫైలులో వున్నది.
కాబట్టి, ఏ పారామీటర్లు డీఫాల్ట్ చేయబడతాయో ఏ ఒక్క అంశంలోనైనా మీకు తెలియదు మరియు ఏ విలువలు అవి డిఫాల్ట్ (default) అవుతాయి.
కాబట్టి, అన్ని డిఫాల్ట్లను వాడాలి; మీరు ఈ వంటి ఏదో చేయాలని ఉంటే వాటిని అన్ని శీర్షిక ఫైళ్ళకు తరలించబడింది చేయాలి కాబట్టి ఒక సమయంలో మీరు డిఫాల్ట్ పారామితులు ఉన్నాయి ఏమి చూడగలరు మరియు వారి విలువలు ఏమిటి, లేకపోతే ఈ పద్దతి యొక్క ఈ విధానం డిఫాల్ట్ పారామితులు కోడ్ వ్రాయడం నిజంగా చాలా గందరగోళంగా పొందండి.
ఇది ఆచరణాత్మక పాయింట్ నుండి ఒక పరిమితిగా ఉంటుంది, మీరు భాషా చివరికి చూస్తే, మీరు ఈ నిర్వచనాలతో మీరు నిజంగానే నాలుగు వేర్వేరు రూపాలతో ఫంక్షన్ గ్రానికే పిలుస్తారని నేను చూపించినట్లు చూపించాయి ఎందుకంటే మూడు పారామితులు చివరికి అప్రమేయం చేయబడ్డాయి, కానీ ఒకే స్థలంలో వాటిని ఎల్లప్పుడూ అప్రమత్తంగా ఉండేలా చేస్తాయి, తద్వారా ఒకే సంతకం లో వాటిని మూడు వేర్వేరు సంతకాలలో వరుసగా మూడుసార్లు వేరు చేయటానికి బదులు వాటిని ఉపయోగించడం కోసం చాలా గందరగోళంగా మారుతుంది.
కాబట్టి, C ++ యొక్క డిఫాల్ట్ పారామితుల( default parameter) లక్షణాన్ని మేము చూశాము మరియు దానిని ఎలా ఉపయోగించాలో మరియు మేము ఉపయోగించే పరిమితులు ఏమిటి?
inhouse/NPTEL/PreFinal/c++/Telugu/23. ProgramminginCplusplus_Inheirtnace Part I (Lecture 36)-YraxnPsxZgc.txt
View file @ 956c0d4e
 1. ప్రోగ్రామింగ్ ఇన్ సి ++ మౌడ్యూల్ 21 కు స్వాగతం.
2. ఈ మాడ్యూల్ లో మాడ్యూల్స్ యొక్క తరువాతి సంఖ్యలో కొనసాగుతున్నందున, మనము ఒక ఆబ్జెక్ట్ ఓరియంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క అత్యంత ముఖ్యమైన అంశంపై చర్చను ప్రారంభించబోతున్నాం, ఇది క్లాస్ ల్లోని మరియు ఆబ్జెక్ట్ మధ్య ఇన్హెరిటెన్స్(inheritance) వ్యవహారం.
3. మనము ఇంతవరకు సి++ లో క్లాస్ లను ఎలా డిఫైన్, ఆబ్జెక్ట్స్ ఇప్పటికి ఎలా instantiated చేయాలో తెలుసుకున్నాం.
4. మేము వివిధ డేటా మెంబర్ల మరియు క్లాస్ యొక్క మెంబర్ ఫంక్షన్ ల సామర్ధ్యం గురించి నేర్చుకున్నాము.
5. మనము కన్స్ట్రక్షన్ మరియు డిస్ట్రక్షన్ ప్రోసెస్ మరియు ఆబ్జెక్ట్ ల వివిధ lifetime సమస్యల గురించి తెలుసుకున్నాము.
6. వివిధ రకాల ఎక్స్టెన్షన్ లేదా ఎక్సెప్షన్ యొక్కఎన్కాప్సులేషన్ అనుగుణంగా ఉండే ఇతర లక్షణాల గురించి మనం మాట్లాడాము, ఫ్రెండ్ ఫంక్షన్ పరంగా, ఫంక్షన్ యాక్సెస్ మరియు స్టాక్ ఫంక్షన్ల పరంగా ఫంక్షన్స్, మరియు వివిధ మెంబర్ ఫంక్షన్ మరియు గ్లోబల్ ఫంక్షన్ల ఓవర్లోడింగ్ చేయవచ్చు.
7. ఇప్పుడు, ఇన్హెరిటెన్స్ అనేది ఆబ్జెక్ట్ యొక్క ఆధార రూపకల్పనల డిజైన్ యొక్క ప్రధాన వెన్నెముకను నిర్మించడానికి ఈ అవగాహనను అన్నిటినీ మిళితం చేస్తుంది.
8. అందువలన, మనము ఈ లోతైన అధ్యయనం మొదలు ముందు నేను అన్ని మీరు సవరించడానికి మరియు మేము చాలా చర్చించారు అని C + + యొక్క వివిధ లక్షణాల గురించి చాలా క్షుణ్ణంగా ఉద్భవించటానికి ముందు మేము ఇప్పుడు చాలా తరచుగా క్రమంగా వాటిని అన్ని సూచిస్తూ ఉంటాను .
9.
10. ఇప్పుడు, నేను చెప్పినట్లుగా ఇన్హెరిటెన్స్ గురించి చర్చించడం కోసం ఇది అనేక మాడ్యూల్స్పై విస్తరించింది.
11. ఈ ప్రత్యేక మాడ్యూల్ లో, ISA రిలేషన్షిప్ లేదా ఆబ్జెక్ట్ ఓరియెంటెడ్ అనాలిసిస్ అండ్ డిజైన్ యొక్క క్రమానుగత పునఃసృష్టిని మేము పరిశీలించాము మరియు C ++ ఇన్హెరిటెన్స్ పరంగా ఎలా క్రియేట్ చేయాలో చూద్దాం.
12. నేను ఇక్కడ అందించే ఆకారం కొద్దిగా భిన్నంగా నిర్వహించబడింది.
13. ఇది ప్రస్తుత మాడ్యూల్ యొక్క సరిహద్దు మాత్రమే కాదు.
14. ఇది C ++ లో ఇన్హెరిటెన్స్ మొదటి స్థాయి వద్ద చర్చించడానికి ఉద్దేశించినది.
15. ఈ విషయంలో కొన్ని తదుపరి సీక్వెల్ ఉంటుంది, ఇది మేము ఇన్హెరిటెన్స్ గురించి మాట్లాడే ఒక డైనమిక్ సినారియో లో మాట్లాడతాము, కానీ ఇది ఇన్హెరిటెన్స్ ప్రాథమిక పునాది అంశాలను.
16. మనం ఏమి చేస్తామో, మనము ఒక మాడ్యూల్ నుండి మరొక వైపుకు వెళ్ళేటప్పుడు ప్రత్యేక అంశములను మనము నీలం రంగు పరంగా చర్చించబోతున్నాము.
17. కాబట్టి, మీరు ఈ మొత్తాన్ని పరిశీలించినట్లయితే, మాడ్యూల్ 21 లో చర్చించాలని మేము కోరుతున్నాము.
18. ఇప్పుడు మనము ప్రారంభించాము.
19. కాబట్టి, మేము ISA సంబంధాన్ని గురించి తెలుసుకున్నాము, ఈ కోర్సులో మేము దాని గురించి మాట్లాడలేదు మరియు మీరు ఈ విషయంలో కూడా బాగా తెలిసి ఉండవచ్చు, వాస్తవిక ప్రపంచంలో మనం మరొక ఆబ్జెక్ట్ యొక్క specialization లేదా generalization అని తరచుగా తెలుసుకుంటాం.
20. స్పెషలైజేషన్ మరియు సాధారణీకరణ ప్రధానమైనవి.
21. కాబట్టి, ఒక ఆబ్జెక్ట్ ఇతర specialized లేదా generalized రూపం మరియు ISA సంబంధం మరియు ఆబ్జెక్ట్ ఓరియెంటెడ్ అనాలిసిస్ అని పిలుస్తారు మరియు డిజైన్ ఈ లోతైన మరియు C ++ నమూనాలో ఈ ISA సంబంధాన్ని క్లాసుల ఇన్హెరిటెన్స్ తో పరిగణిస్తుంది.
22. కాబట్టి, C ++ యొక్క ఇన్హెరిటెన్స్ లాజిక్ లోకి రావడానికి ముందు, మాకు త్వరగా ISA సంబంధాన్ని పరిశీలించండి.
23. మీరు స్పెషలైజేషన్ generalization ఏమి చెపుతున్నారో చెప్పండి.
24. అనుకుందాం, మేము ISA పువ్వు పెరిగింది అని అనుకుంటాను.
25. సో, ISA పువ్వు గులాబీ చెప్పడం ద్వారా మీరు అర్థం ఏమిటి. మేము గులాబీ అని అర్థం, ఇది ప్రత్యేకమైనది, ఇది గులాబీకి ప్రత్యేకమైన పువ్వు అని పిలుస్తారు, ఇది పువ్వును కలిగి ఉన్న అన్ని లక్షణాలను కలిగి ఉంది, ఎప్పుడైనా మేము పుష్పం అని చెప్పినప్పుడు; కొన్ని భావాలు మా మనసులోకి వస్తాయి, అది సువాసన కలిగి ఉంటుంది, అది ప్రకాశవంతమైన రంగు కలిగి ఉంటుంది, అది రేకులు మరియు అందువలన ఉంటుంది.
26. అందువల్ల, గులాబి పువ్వు కలిగి ఉన్న అన్ని లక్షణాలను కలిగి ఉంది.
27. కానీ అదనంగా, గులాబీలో కొన్ని అదనపు లక్షణాలను కలిగి ఉంది, అందుకే మీరు ప్రత్యేకంగా చేయాలనుకుంటున్నారు.
28. ఉదాహరణకు, గులాబీ చాలా నిర్దిష్టమైన రోసీ సువాసనను కలిగి ఉంటుంది, ఇది చాలా ఇతర పుష్పాల యొక్క సువాసన వలె లేదు.
29. కాబట్టి, ఇది పూర్తి అయినప్పుడు మనం పూల స్పెషలైజేషన్ అని చెపుతాము మరియు మనము ఒక రివర్స్ రీతిలో అదే విషయం చెప్పగలము.
30. పుష్పం రోజ్ యొక్క generalization అని మేము చెప్పగలను.
31. కాబట్టి, మళ్లీ ఎర్ర గులాబీ మరియు గులాబి ఉన్నట్లయితే, ఎరుపు గులాబీ ISA గులాబీ ప్రొపర్టీస్ కలిగి ఉన్న రెడ్ గులాబీ రంగులో ఉన్నట్లయితే మనం ఎరుపు గులాబి అన్నీ లక్షణాలను కలిగి ఉంటుంది, కానీ అది ఎరుపు రంగులో ఉన్నట్లుగా ఇది ఒక అదనపు ఆస్తి కలిగి ఉంది మరియు ఇది గులాబీ మరియు ఎరుపు మధ్య ఉన్న సాధారణీకరణ ప్రత్యేకత.
32. కాబట్టి, నేను ఇక్కడ గీసిన దాని పరంగా, మీరు చాలామంది దీనిని UML generalization గా పిలుస్తారని మీకు తెలుస్తుంది.
33. యూనిఫైడ్ మోడలింగ్ లాంగ్వేజ్ అనేది ఆబ్జెక్ట్ ఓరియెంటెడ్ రీతిలో సిస్టమ్ ను వివరించడానికి ఒక బలమైన లాంగ్వేజ్.
34. కాబట్టి, ఈ క్లాస్ లు మరియు చివరికి ఓపెన్ త్రిభుజం triangle తో ముగుస్తుంది ఈ arrow ప్రత్యేకతను అర్థం.
35. కాబట్టి, ఇది చదివేది; arrow యొక్క దిశగా ఉన్న ISA పువ్వు పెరిగింది, ఎరుపు పెరిగింది ISA గులాబీ మరియు అందువలన న.
36. కాబట్టి, రేఖాచిత్రంగా మేము ఈ రేఖాచిత్రాల పరంగా ఇన్హెరిటెన్స్ లేదా స్పెషలైజేషన్ generalization ను తరచుగా వర్ణిస్తాము.
37. అదేవిధంగా, మేము కలిగి ఉండవచ్చు; మనం చెప్తాము అని చెప్పవచ్చు, ఇది చుట్టూ తిరగడానికి ఉపయోగించే ఒక వాహనం.
38. కాబట్టి, మేము Twowheelers లో చుట్టూ తరలించవచ్చు, కాబట్టి మేము Twowheeler ISA వాహనం చెప్పగలను.
39. అదేవిధంగా, Threewheelers ISA వాహనం, కానీ మేము వాహనం పరంగా generalization మరియు 3 చక్రాల మరియు 2 చక్రాల వాహనం యొక్క రెండు వేర్వేరు స్పెషలైజేషన్ అని కేటాయించవచ్చు.
40. కాబట్టి, generalization మరియు స్పెషలైజేషన్ మల్టిపుల్ రకాలుగా చెప్పవచ్చు.
41. కాబట్టి, ఇది ఒక generalized భావన ఉన్న ఒక రకంగా మరియు దాని కోసం మల్టిపుల్ specialized అంశాలు ఉన్నాయి.
42. మేము సాధారణంగా దీనిని ఒక ఆధారంగా సూచిస్తాము మరియు వీటిని మేము డిరైవ్ చేస్తాము.
43. వేర్వేరు ల్యాంగ్వేజ్ లో వివిధ పదాలను ఉపయోగించుకుంటాయి, ఉదాహరణకు, మీరు జావా గురించి తెలిసిన వారిలో, ఈ బేస్ లేదా generalization ను సూపర్ క్లాస్గా మరియు సబ్క్లాస్గా తీసుకున్న లేదా స్పెషలైజేషన్ గా గుర్తిస్తాము.
44. కొన్ని సందర్భాల్లో, అత్యంత సాధారణమైన ప్రత్యేకమైన క్లాస్ నను తరచుగా రూట్గా సూచించబడుతుంది.
45. ఇంకా ISA సంబంధం మరొక ఉదాహరణ ఎంప్లాయ్ డొమైన్ నుండి కావచ్చు.
46. మేనేజర్ ISA ఎంప్లాయ్ అని మేము చెబుతున్నాము, అంటే మేనేజర్ యొక్క అన్ని ఫంక్షన్లు నిర్వర్తించగలమని, కానీ ఎంప్లాయ్ కొన్నింటిని చేయగలడు; మేనేజర్ కొన్ని ఫంక్షన్లు చేయవచ్చు ఎంప్లాయ్ చేయలేరు, బహుశా మేనేజర్ తమను చేయలేని ఎంప్లాయ్ ఎంప్లాయ్ లను నియామకం చేయవచ్చు.
47. కాబట్టి, ఇది C ++ ప్రోగ్రామింగ్ సందర్భంలో మనము తీసుకురావాలనే ISA సంబంధానికి సంబంధించిన ప్రాథమిక భావన.
48. కాబట్టి, దీనిలో C ++ లో generalization స్పెషలైజేషన్ యొక్క సమాచారాన్ని ఎన్కోడ్ చేయాలనుకుంటే నేను ఇలా చేస్తాను.
49. కాబట్టి, ఈ కేసుల్లో సరళమైనది మేనేజర్ ISA ఎంప్లాయ్, ఇక్కడ మేము కేవలం రెండు క్లాస్ లను కలిగి ఉన్న మరొకదాని ప్రత్యేకత ఉంది.
50. కాబట్టి, మేము సాధారణంగా దీనిని ఒకే ఇన్హెరిటెన్స్ సూచించండి ఎందుకంటే ఇక్కడ మీరు కేవలం ఒకే సంబంధం కలిగి ఉంటారు.
51. సో, మేము ఒక క్లాస్ ను వ్రాయండి, ఎంప్లాయ్ రెప్రెజెంటేషన్, క్లాస్ ఎంప్లాయ్ చెప్పండి.
52. ఇక్కడ, నేను ఒక రకమైన ఉపయోగించాను మీరు ఒక క్లాస్ యొక్క అసంపూర్తిగా డెఫినిషన్ ని తెలుసు.
53. ఇది డెఫినిషన్ కలిగి ఉండదు, ఇది కేవలం ఎంప్లాయ్ అని పిలవబడుతున్న ఒక క్లాస్ ఉందని చెప్పడం వలన మేము తరువాత డేటా మెంబర్ ని మరియు మెంబర్ ఫంక్షన్ వివరాలను పరిశీలిస్తాము.
54. క్లాస్ మధ్య సంబంధాన్ని నిర్వచించేందుకు మేము ఆసక్తి కలిగి ఉంటాము.
55. అందువల్ల, ఈ రూపంలో మేనేజర్ ఎంప్లాయ్ అని ఇప్పుడు మనం చెప్తున్నాం. కాబట్టి, ఇక్కడ మీరు చేస్తున్న క్లిష్టమైన అదనంగా, క్లాస్ మేనేజర్ కి తర్వాత, విభజన ఉంది అని చూడవచ్చు: ఆపై నేను ఒక కొత్త పదమును పబ్లిక్ గా మరియు తరువాత ఎంప్లాయ్ క్లాస్ నేమ్ ను పెట్టుకున్నాను OOAD నిబంధనలు, ఇది మేనేజర్ ISA ఎంప్లాయ్ లేదా మేనేజర్ ఎంప్లాయ్ నుండి డిరైవ్(derive )చేసినట్లుగా చదవబడుతుంది.
56. సో, ఉద్యోగి బేస్ క్లాస్ మరియు మేనేజర్ ఒక డిరైవ్ క్లాస్.
57. ద్విచక్ర వాహన వాహన ఉదాహరణలో; ఈ రేఖాచిత్రం ఇచ్చినప్పుడు మేము నిజానికి హైబ్రీడ్ ఇన్హెరిటెన్స్ తో వ్యవహరిస్తాము.
58. హైబ్రీడ్ ఇన్హెరిటెన్స్ అనేది ఒక ప్రాథమిక క్లాస్ కి ఒకటి కంటే ఎక్కువ స్పెషలైజేషన్ ఉన్న సందర్భం మరియు మేము సులభంగా వాహనం అయిన రూట్ క్లాస్ ప్రకారం సి ++ లో దానిని సులభంగా ఎన్కోడ్ చేయవచ్చు.
59. అప్పుడు మేము టూవీలర్ అని పిలిచే వాహనం అని పిలుస్తాము: పబ్లిక్ వెహికల్.
60. త్రీవీలర్స్ అనేది టూవీలర్ యొక్క వాహనం: పబ్లిక్ వాహనం.
61. కాబట్టి, అక్కడ ఒక రూట్ క్లాస్ మరియు అక్కడ ఒక బేస్ క్లాస్ మరియు ఈ రెండు డిరైవ్డ్ క్లాస్ లు ఉన్నాయి.
62. చివరగా, గులాబీ ఉదాహరణకి వస్తే, మనం మల్టీలెవల్ ఇన్హెరిటెన్స్ పిలువబడుతున్నాము ఎందుకంటే ఇది ఒక స్థాయి, ఇది మరొక స్థాయి.
63. సో, ఇది ఒక మల్టీలెవల్ ఇన్హెరిటెన్స్ RedRose ISA రోజ్ ISA పువ్వు ఉంది.
64. కాబట్టి, ఇక్కడ పువ్వు బేస్ క్లాస్ మరియు డిరైవ్డ్ క్లాస్ రోజ్, కానీ మేము తదుపరి జత సంబంధాన్ని పరిశీలిస్తే అప్పుడు రోస్ బేస్ క్లాస్ గామారుతుంది మరియు RedRose నుండి డిరైవ్డ్ క్లాస్ గా మారుతుంది.
65. కాబట్టి, ఒక ప్రత్యేక క్లాస్ అనేది బేస్ క్లాస్ గా లేదా ఒక డిరైవ్డ్ క్లాస్ గా నిర్ణయించబడకపోవడమనేది ఆ క్లాస్ పై ఆధారపడినది కాదు, అది క్లాస్ hierarchy పై ఎక్కడ ఉంది అనే దానిపై ఆధారపడి ఉంటుంది.
66. క్లాస్ లో లీఫ్ ,ఆ లీఫ్, ఇది మీది కాదుఏ ఇతర క్లాస్ లకు ప్రత్యేకంగా తెలుసు అనేదానిని తప్పనిసరిగా క్లాస్ కి చెందినదిగా గుర్తిస్తారు.
67. ఏ క్లాస్ కైన సూపర్ క్లాస్ కానీ లేదా పేరెంట్ గానీ లేని బేస్ క్లాస్ మరియు రూట్ క్లాస్ తప్పనిసరిగా ఉండదు, కానీ మధ్యలో ఉన్న వంటి క్లాస్ లకు ఇన్హెరిటెన్స్ ఇతర భాగానికి ఇన్హెరిటెన్స్ మరియు రూట్ క్లాస్ లో ఒక భాగం కోసం క్లాస్ నుండి డిరైవ్ చేయబడుతుంది, మరియు మేము విభిన్న కాంప్లెక్స్ మరియు హైబ్రిడ్ రకమైన ఇన్హెరిటెన్స్ స్ట్రక్చర్ కలిగి ఉన్నాము, మేము C ++ లో ఎన్కోడ్ చేయాలనుకుంటున్నాము.
68. కాబట్టి, ఇక్కడ నేను ఒక ఉదాహరణగా కొంచెం విభిన్న రకాన్ని తీసుకుంటాను.
69. మేము అన్ని ఫోన్లతో సుపరిచితులు, మీరు అన్ని రకాల ఫోన్లను ఉపయోగిస్తున్నారు.
70. సో, నేను మాట్లాడుతున్నాను, మేము నేడు సాధారణమైన 3 సాధారణ రకాల ఫోన్లను పరిగణలోకి తీసుకుంటే; ల్యాండ్లైన్ ఫోన్, మొబైల్ ఫోన్ మరియు స్మార్ట్ ఫోన్, అప్పుడు మేము ఉందని చూడవచ్చు; మరియు నేను ఇక్కడ చేయడానికి ప్రయత్నిస్తున్న అన్ని మేము ఈ ఫోన్లు మానసికంగా అనుబంధం కార్యాచరణ అసోసియేట్ రకం.
71. కాబట్టి, ల్యాండ్లైన్ ఫోను చెప్పండి, మీరు అసోసియేట్ చేస్తారనే కార్యాచరణ ఉంటుంది; మీరు కాల్ చేయవచ్చు, మీరు కాల్కు సమాధానం చెప్పవచ్చు.
72. ఒక మొబైల్ ఫోన్ కోసం మీరు స్పష్టంగా, అలా అన్ని చేయవచ్చు, కానీ మీరు చాలా మొబైల్ ఫోన్ లో, మీరు గత సంఖ్య redial చేయగలరు, మీరు ఒక రింగ్ టోన్ సెట్ చేయగలరు, చాలా ఇతర విషయాలు చేయవచ్చు బహుశా మీరు మీ పరిచయాలను సంఖ్య మరియు పేరుతో పెట్టవచ్చు మరియు తద్వారా మొదలగునవి, అనేకమంది ఇతరులు ఉండవచ్చు.
73. కాబట్టి, ల్యాండ్లైన్ ఫోన్ యొక్క ప్రాథమిక ఫంక్షనాలిటీ కూడా మొబైల్ ఫోన్ ద్వారా సంతృప్తి చెందిందని నేను చూడగలను, ఇది ఇప్పటికే ఉనికిలో ఉంది.
74. కాబట్టి, ఒక మొబైల్ ఫోన్ ISA ల్యాండ్లైన్ ఫోన్ అని నేను చెప్పగలను.
75. ఈ ISA అది అదే అని కాదు, కానీ మొబైల్ ఫోన్ సంతృప్తి చేయవచ్చు అన్ని ఫంక్షనాలిటీ ను మొబైల్ ఫోన్ సంతృప్తి చేయవచ్చు అర్థం.
76. అదేవిధంగా, నేను ఒక స్మార్ట్ ఫోన్కు వచ్చినట్లయితే, కాల్ మరియు జవాబు యొక్క ఈ ఫంక్షనాలిటీ ను నేను మళ్లీ కలిగి ఉంటాను, వీటిని అన్నింటినీ redial చేసుకోవచ్చు, కానీ నేను అదనపు ఫంక్షనాలిటీ ను కలిగి ఉండవచ్చు.
77. నా కాన్టాక్ట్ కు (contact ) సంబంధించి ఒక ఫోటోగ్రాఫ్ ను అనుసంధానించగలగడం మరియు నేను నా కాన్టాక్ట్ తో ఫోటోను అనుసంధానించేటప్పుడు అప్పుడు కాల్ సమయంలో లేదా కాల్ చేసేటప్పుడు బహుశా స్మార్ట్ ఫోన్, కాల్ అందుకోవడం, పునఃప్రారంభ సమయంలో ఫోటోగ్రాఫ్ ను చూడవచ్చు.
78. కాబట్టి, మధ్య సామాన్యత ఉంది; ఈ విభిన్న రకాల ఫోన్ల మధ్య substantial సామాన్యం ఉంది, కానీ ఒక రకమైన ఫోన్ నుండి మరొకదానికి వెళ్లినప్పుడు, మొబైల్కు ల్యాండ్లైన్ మేము దొరుకుతుందాం మరికొన్ని అదనపు ఫంక్షనాలిటీ లు దొరుకుతున్నాయి.
79. మేము మొబైల్ నుండి స్మార్ట్ ఫోన్కు వెళ్తాము ఇంకా కొన్ని మరింత కార్యాచరణలు మరియు ఆ విధంగా ఫోన్లు చాలా nice చిన్న specialization generalization హైరార్కీ కలిగి ఉంటుంది.
80. అందువల్ల, మీరు కేవలం సంజ్ఞల కోసం, వివిధ రకాల గాడ్జెట్లు మరియు సాధ్యమయ్యే వాటి యొక్క హైరార్కీ లు గురించి మీకు అవగాహన కలిగించడానికి.
81. తరువాత మాడ్యూల్ వద్ద మేము ఫోన్లు చేపట్టాలనుకుంటున్నాము మరియు వాస్తవానికి ఇన్హెరిటెన్స్ స్ట్రక్చర్ పూర్తి డిజైన్ చేయాలనుకుంటున్నాను, కానీ ఇప్పుడు C ++ ఇన్హెరిటెన్స్ భావించే కాంక్రీట్ సెమాంటిక్స్కు వెళ్లనివ్వండి.
82. కాబట్టి, సాధారణంగా మేము రెండు క్లాస్ ల గురించి మాట్లాడతాము; బేస్ క్లాస్ మరియు డిరైవవ్డ్ క్లాస్.
83. కాబట్టి, ISA మోడల్; డిరైవవ్డ్ ISA బేస్.
84. అందువల్ల, డిరైవవ్డ్ క్లాస్ యొక్క నేమ్ డిరైవవ్డ్, బేస్ క్లాస్ యొక్క నేమ్ బేస్ మరియు ఖచ్చితంగా ఇది ఇదే C ++ లో ప్రాతినిధ్యం వహించబడిందని మేము ఇప్పటికే చూశాము.
85. కాబట్టి, కొత్త పరిచయం ఇది ఒక కీవర్డ్ ని పబ్లిక్ కీవర్డ్ గా ఉంది ఇది ఇప్పటికే ఉన్న ప్రాముఖ్యత కోసం ఉపయోగించినందున, కానీ ఇక్కడ మేము కొన్ని ప్రత్యేక ప్రయోజనాల కోసం మళ్లీ ఉపయోగిస్తున్నాము, మరియు ఈ ప్రత్యేక కీవర్డ్ యొక్క ప్రాముఖ్యత ఏమిటి అని చూద్దాం మరియు మేము వారి ప్రత్యామ్నాయాల గురించి మాట్లాడతాము, కానీ ఇప్పుడే దీనిని ఒక ప్రిస్క్రిప్షన్గా తీసుకుంటాను, నేను చెప్పేది అది డిరైవవ్డ్ ISA బేస్ అని చెప్పుకునే మార్గం, మరియు ఈ కీవర్డ్ తర్వాత మీకు క్లాస్ నేమ్ మీరు పేర్కొన్న generalized లేదా బేస్ క్లాస్ నేమ్.
86. ఇప్పుడు, ఖచ్చితంగా ఒక ప్రశ్న యొక్క మొత్తం చాలా వరకు చేస్తున్నట్లు మేము మాట్లాడుతున్నాము, ఎందుకంటే ఆ బేస్ వేర్వేరు డేటా మెంబర్లను కలిగి ఉంటుందని మేము ఆశిస్తాం.
87. డిరైవవ్డ్ వివిధ డేటా మెంబర్లను కూడా ఉంటారు, బేస్ వివిధ మెతడ్స్ ను కలిగి ఉంటుంది, డిరైవవ్డ్ కూడా వివిధ మెతడ్స్ ను కలిగి ఉంటుంది.
88. బేస్ కన్స్ట్రక్ట్ చేయాల్సిన అవసరం ఉంది, డిరైవవ్డ్ కూడా మరియు కన్స్ట్రక్ట్ చేయాల్సిన అవసరం ఉంది.
89. కాబట్టి, మనము చాలా జాగ్రత్తగా వివరించాలి మరియు అర్ధం చేసుకోవాలి; ఈ బేస్ ఎలా సంబంధాన్ని కలిగి ఉంటుందో సెమాంటిక్స్ అంటే ఏమిటి? కాబట్టి, నేను మొదట్లో సరిదిద్దటానికి ఇష్టపడుతున్నాను, అప్పుడు మేము వీటిలో ప్రతి ఒక్కదాన్ని తీసుకొని మరింత వివరణాత్మక చర్చ చేయాలని ప్రయత్నిస్తాము.
90. నేను మొదట C ++ లో ఇన్హెరిటెన్స్ యొక్క సెమాంటిక్స్ గురించి మాట్లాడేటప్పుడు, మీరు వీటి గురించి చాలా జాగ్రత్తగా ఉండవలసిన మొదటి స్థాయి అంశాలు.
91. మొదటి విషయం, నను క్షమించండి; మొదటి విషయం డేటా మెంబర్లు.
92. కాబట్టి, బేస్ క్లాస్ యొక్క అన్ని డేటా మెంబర్ నుండి డిరైవవ్డ్ క్లాస్ పొందినట్లు మేము చెబుతాము.
93. కాబట్టి, మీరు డిరైవవ్డ్ క్లాస్ లను ఏ డేటా మెంబర్ని కలిగి లేనప్పటికీ, అది ఇప్పటికీ బేస్ క్లాస్ కి చెందిన అన్ని డేటా మెంబర్లతో కూడిన డేటా మెంబర్లను కలిగి ఉంటుంది, కానీ అది మరింత డేటా మెంబర్లను మరింతగా add చేయగలదు.
94. నేను వీటిలో ప్రతిదానికి ఉదాహరణగా వస్తాను, కానీ నేను ప్రాథమిక ప్రిన్సిపిల్ ను చెప్పడానికి ప్రయత్నిస్తున్నాను.
95. ఇన్హెరిటెన్స్ యొక్క ప్రాధమిక ప్రిన్సిపిల్ ఇది నేను మరియు నేను సాధారణ భావన సంతృప్తి చెంది ప్రతిదీ సంతృప్తి అవసరం మరింత ప్రత్యేక భావన అందించడానికి ప్రత్యేకంగా ప్రయత్నిస్తున్న కొన్ని భావనలు ఉంది.
96. కాబట్టి, బేస్, డిరైవ్డ్ సంతృప్తినిచ్చే ప్రతిదీ సంతృప్తి పరచాలి.
97. కాబట్టి, ఇది మొత్తం డేటా మెంబర్లను కలిగి ఉండాలి, కానీ అది మొత్తం భావనను మరింత మెరుగుపరచడానికి దాని స్వంతని జోడించవచ్చు.
98. మళ్ళీ మెంబర్ ఫంక్షన్ ల పరంగా, మనము చూసే చాలా ముఖ్యమైన ఆలోచనలు ఉన్నాయని తెలుసుకుంటాం.
99. మొదటి భాగము, ఒక డిరైవ్డ్ క్లాస్ బేస్ క్లాస్ కి చెందిన అన్ని మెంబర్ ఫంక్షన్ లను ఇన్హెరిట్ చేసుకుంటుంది, కానీ ఆ తరువాత ఒక పెద్ద వ్యత్యాసం ఉంది; మీరు మెంబర్ ఫంక్షన్ ఇన్హెరిటెన్స్ గా వంటి మీరు తిరిగి సంస్కరణ మార్చకుండా అది తిరిగి నిర్వచించటానికి తిరిగి అమలు ఎంపిక ఉంది.
100. మీరు అదే విధమైన అల్గోరిథంతో మళ్ళీ అదే ఫంక్షన్ నిర్వచించాలనుకుంటున్నారు మరియు మీరు ఇలా చేస్తే అప్పుడు మీరు బేస్ వర్గంలో మెంబర్ల పనిని భర్తీ చేస్తున్నారని చెప్తారు; ఈ భావన చాలా ఓవర్లోడింగ్ భావనతో చాలా దగ్గరగా ఉన్నందున చాలా జాగ్రత్త వహించండి, ఓవర్లోడింగ్ తో మీకు గందరగోళంగా మొదలవుతుంది మరియు మీకు చెడ్డ విషయాలు ఏమిటంటే మీరు నిజంగా ఇన్హెరిటెన్స్ సందర్భంలో ఓవర్లోడింగ్ చేస్తారనే మంచి అవకాశం ఉంది.
101. మీరు ఒకే సిగ్నేచర్ ఒక ఫంక్షన్ని తిరిగి ఓవరైడింగ్ చేస్తే, అది భర్తీ అవుతుంది.
102. మీరు విభిన్న సిగ్నేచర్ తో ఒక ఫంక్షన్ని తిరిగి నిర్వచించినప్పుడు ఓవర్లోడింగ్ అంటారు.
103. సో, ఈ మేము ఇన్హెరిటెన్స్ కింద మెంబర్ ఫంక్షన్ లు ప్రవర్తన పరంగా అర్థం అవసరం వివిధ సెమాంటిక్స్ ఉన్నాయి.
104. యాక్సెస్ స్పెసిఫికేషన్ పరంగా మనము చూడవలసిన తదుపరి అంశం.
105. ఇప్పుడు, యాక్సెస్ స్పెసిఫికేషన్ పరంగా సహజంగా మనకు ప్రైవేటు యాక్సెస్ ఉందని మరియు పబ్లిక్ యాక్సెస్ ఉందని మాకు తెలుసు.
106. ప్రైవేటు యాక్సెస్ క్లాస్ మెంబర్ ల కోసం ఉంది, ప్రజా యాక్సెస్ ప్రతిఒక్కరికీ.
107. కాబట్టి, బేస్ క్లాస్ యొక్క డిరైవ్డ్ క్లాస్ ఖచ్చితంగా ఆ క్లాస్ లో భాగం కాదు.
108. అందువల్ల, ఒక డిరైవ్డ్ క్లాస్ బేస్ క్లాస్ లను ప్రైవేట్ మెంబర్ల ను యాక్సెస్ చేయలేరు.
109. ఇది పబ్లిక్ మెంబర్ లను మాత్రమే యాక్సెస్ చేయగలదు, కానీ అది చాలా కష్టాలకు దారి తీస్తుందని మేము చూస్తాము ఎందుకంటే ప్రత్యేకమైన semantics ప్రత్యేకంగా ఉంచడానికి మేము ప్రయత్నిస్తున్నట్లుగా చెప్పాలంటే ప్రత్యేకంగా సంకేతపదంగా సూచించడంతో, బేస్ క్లాస్ అంతర్గతాలకు ఎటువంటి ప్రాప్తి లేదు.
110. అందువల్ల, ఒక కొత్త టైప్ యాక్సెస్ స్పెసిఫైయర్తో, ప్రొటెక్టడ్ యాక్సెస్ స్పెసిఫైయర్ ఇన్హెరిటెన్స్ మంచి అర్థాలకు మద్దతిస్తుంది.
111. కాబట్టి, ఇన్హెరిటెన్స్ గా మద్దతు ఇచ్చే ఈ మూడవ రకమైన దృశ్యమానత లేదా ప్రాప్యత వివరణ ఏమిటో తెలుసుకోవడానికి మరియు అర్థం చేసుకోవడానికి మాకు ఉంటుంది.
112. అంతిమంగా, సహజంగా ఆబ్జెక్ట్ డిస్ట్రక్ట్ చేయబడాలి మరియు బేస్ మరియు డిరైవ్డ్ క్లాస్ మధ్య ఇన్హెరిటెన్స్ గా ఉన్నప్పుడు, ఒక డిరైవ్డ్ క్లాస్ ఉదాహరణగా పిలువబడే ఒక డిరైవ్డ్ క్లాస్ కన్స్ట్రక్టర్ కావాలి, కాని డిరైవ్డ్ క్లాస్ కన్స్ట్రక్టర్ ఒక బేస్ని కలిగి ఉంటుంది క్లాస్ ఆబ్జెక్ట్ కన్స్ట్రక్టర్ ని పిలుస్తూ క్లాస్ ఆబ్జెక్ట్.
113. కాబట్టి, బేస్ క్లాస్ అవగాహన మరియు డిరైవ్డ్ క్లాస్ ఆబ్జెక్ట్ ఎలా తమకు మరియు వారితో ఎలా సంకర్షణ చెందుతాయో తెలుసుకోవడానికి అవసరమైన ప్రాథమిక అవగాహన.
114. అదేవిధంగా, ఒక డిరైవ్డ్ క్లాస్ ఆబ్జెక్ట్ ను డిస్ట్రక్ట్ చేయవలసి వచ్చినప్పుడు, బేస్ క్లాస్ యొక్క డిస్ట్రక్టర్ ప్రయోగించవలసి ఉంటుంది, తద్వారా మీరు డిరైవ్డ్ క్లాస్ ఆబ్జెక్ట్ యొక్క బేస్ క్లాస్ భాగాలను డెస్ట్రాయ్ చేయవచ్చు.
115. కాబట్టి, ఇది ఇన్హెరిటెన్స్ ను ఎలా ఉపయోగించాలో అర్ధం చేసుకోవడానికి మరియు C ++ ల్యాంగ్వేజ్ చాలా సమర్థవంతమైన రీతిలో వేర్వేరు వాస్తవ ప్రపంచ scenario hierarchy ను ఎలా నిర్దేశించాలో అర్థం చేసుకోవడానికి అవసరమైన అన్ని ప్రధాన అర్థాల సిమాంటిక్స్(semantics) ఇది.
116. ఈ విధంగా సంగ్రహించేందుకు, మనకు OOAD hierarchy యొక్క శ్రేణిని ISA సంబంధం మరియు క్లాస్ హైరార్కీ భావన ఆబ్జెక్ట్ ఓరియంటెడ్ అనాలిసిస్ అండ్ డిజైన్ యొక్క పునర్వ్యవస్థీకరణలో ఉంది మరియు C ++ లో ఇన్హెరిటెన్స్ యొక్క ప్రాథమిక భావనను పరిచయం చేసాము.
117. మరియు అర్థం చేసుకోవడానికి అవసరమైన అర్థాల యొక్క విభిన్న అంశాలను ఏవి గమనించాలో, మేము నిజంగా ప్రభావవంతమైన పద్ధతిలో ఇన్హెరిటెన్స్ ని ఉపయోగించుకునే విధంగా మాస్టర్స్గా ఉండాలి.
118.
 ప్రోగ్రామింగ్ ఇన్ సి ++ మౌడ్యూల్ 21 కు స్వాగతం.
ఈ మాడ్యూల్ లో మాడ్యూల్స్ యొక్క తరువాతి సంఖ్యలో కొనసాగుతున్నందున, మనము ఒక ఆబ్జెక్ట్ ఓరియంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క అత్యంత ముఖ్యమైన అంశంపై చర్చను ప్రారంభించబోతున్నాం, ఇది క్లాస్ ల్లోని మరియు ఆబ్జెక్ట్ మధ్య ఇన్హెరిటెన్స్(inheritance) వ్యవహారం.
మనము ఇంతవరకు సి++ లో క్లాస్ లను ఎలా డిఫైన్, ఆబ్జెక్ట్స్ ఇప్పటికి ఎలా instantiated చేయాలో తెలుసుకున్నాం.
మేము వివిధ డేటా మెంబర్ల మరియు క్లాస్ యొక్క మెంబర్ ఫంక్షన్ ల సామర్ధ్యం గురించి నేర్చుకున్నాము.
మనము కన్స్ట్రక్షన్ మరియు డిస్ట్రక్షన్ ప్రోసెస్ మరియు ఆబ్జెక్ట్ ల వివిధ lifetime సమస్యల గురించి తెలుసుకున్నాము.
వివిధ రకాల ఎక్స్టెన్షన్ లేదా ఎక్సెప్షన్ యొక్కఎన్కాప్సులేషన్ అనుగుణంగా ఉండే ఇతర లక్షణాల గురించి మనం మాట్లాడాము, ఫ్రెండ్ ఫంక్షన్ పరంగా, ఫంక్షన్ యాక్సెస్ మరియు స్టాక్ ఫంక్షన్ల పరంగా ఫంక్షన్స్, మరియు వివిధ మెంబర్ ఫంక్షన్ మరియు గ్లోబల్ ఫంక్షన్ల ఓవర్లోడింగ్ చేయవచ్చు.
ఇప్పుడు, ఇన్హెరిటెన్స్ అనేది ఆబ్జెక్ట్ యొక్క ఆధార రూపకల్పనల డిజైన్ యొక్క ప్రధాన వెన్నెముకను నిర్మించడానికి ఈ అవగాహనను అన్నిటినీ మిళితం చేస్తుంది.
అందువలన, మనము ఈ లోతైన అధ్యయనం మొదలు ముందు నేను అన్ని మీరు సవరించడానికి మరియు మేము చాలా చర్చించారు అని C + + యొక్క వివిధ లక్షణాల గురించి చాలా క్షుణ్ణంగా ఉద్భవించటానికి ముందు మేము ఇప్పుడు చాలా తరచుగా క్రమంగా వాటిని అన్ని సూచిస్తూ ఉంటాను .
ఇప్పుడు, నేను చెప్పినట్లుగా ఇన్హెరిటెన్స్ గురించి చర్చించడం కోసం ఇది అనేక మాడ్యూల్స్పై విస్తరించింది.
ఈ ప్రత్యేక మాడ్యూల్ లో, ISA రిలేషన్షిప్ లేదా ఆబ్జెక్ట్ ఓరియెంటెడ్ అనాలిసిస్ అండ్ డిజైన్ యొక్క క్రమానుగత పునఃసృష్టిని మేము పరిశీలించాము మరియు C ++ ఇన్హెరిటెన్స్ పరంగా ఎలా క్రియేట్ చేయాలో చూద్దాం.
నేను ఇక్కడ అందించే ఆకారం కొద్దిగా భిన్నంగా నిర్వహించబడింది.
ఇది ప్రస్తుత మాడ్యూల్ యొక్క సరిహద్దు మాత్రమే కాదు.
ఇది C ++ లో ఇన్హెరిటెన్స్ మొదటి స్థాయి వద్ద చర్చించడానికి ఉద్దేశించినది.
ఈ విషయంలో కొన్ని తదుపరి సీక్వెల్ ఉంటుంది, ఇది మేము ఇన్హెరిటెన్స్ గురించి మాట్లాడే ఒక డైనమిక్ సినారియో లో మాట్లాడతాము, కానీ ఇది ఇన్హెరిటెన్స్ ప్రాథమిక పునాది అంశాలను.
మనం ఏమి చేస్తామో, మనము ఒక మాడ్యూల్ నుండి మరొక వైపుకు వెళ్ళేటప్పుడు ప్రత్యేక అంశములను మనము నీలం రంగు పరంగా చర్చించబోతున్నాము.
కాబట్టి, మీరు ఈ మొత్తాన్ని పరిశీలించినట్లయితే, మాడ్యూల్ 21 లో చర్చించాలని మేము కోరుతున్నాము.
ఇప్పుడు మనము ప్రారంభించాము.
కాబట్టి, మేము ISA సంబంధాన్ని గురించి తెలుసుకున్నాము, ఈ కోర్సులో మేము దాని గురించి మాట్లాడలేదు మరియు మీరు ఈ విషయంలో కూడా బాగా తెలిసి ఉండవచ్చు, వాస్తవిక ప్రపంచంలో మనం మరొక ఆబ్జెక్ట్ యొక్క specialization లేదా generalization అని తరచుగా తెలుసుకుంటాం.
స్పెషలైజేషన్ మరియు సాధారణీకరణ ప్రధానమైనవి.
కాబట్టి, ఒక ఆబ్జెక్ట్ ఇతర specialized లేదా generalized రూపం మరియు ISA సంబంధం మరియు ఆబ్జెక్ట్ ఓరియెంటెడ్ అనాలిసిస్ అని పిలుస్తారు మరియు డిజైన్ ఈ లోతైన మరియు C ++ నమూనాలో ఈ ISA సంబంధాన్ని క్లాసుల ఇన్హెరిటెన్స్ తో పరిగణిస్తుంది.
కాబట్టి, C ++ యొక్క ఇన్హెరిటెన్స్ లాజిక్ లోకి రావడానికి ముందు, మాకు త్వరగా ISA సంబంధాన్ని పరిశీలించండి.
మీరు స్పెషలైజేషన్ generalization ఏమి చెపుతున్నారో చెప్పండి.
అనుకుందాం, మేము ISA పువ్వు పెరిగింది అని అనుకుంటాను.
సో, ISA పువ్వు గులాబీ చెప్పడం ద్వారా మీరు అర్థం ఏమిటి. మేము గులాబీ అని అర్థం, ఇది ప్రత్యేకమైనది, ఇది గులాబీకి ప్రత్యేకమైన పువ్వు అని పిలుస్తారు, ఇది పువ్వును కలిగి ఉన్న అన్ని లక్షణాలను కలిగి ఉంది, ఎప్పుడైనా మేము పుష్పం అని చెప్పినప్పుడు; కొన్ని భావాలు మా మనసులోకి వస్తాయి, అది సువాసన కలిగి ఉంటుంది, అది ప్రకాశవంతమైన రంగు కలిగి ఉంటుంది, అది రేకులు మరియు అందువలన ఉంటుంది.
అందువల్ల, గులాబి పువ్వు కలిగి ఉన్న అన్ని లక్షణాలను కలిగి ఉంది.
కానీ అదనంగా, గులాబీలో కొన్ని అదనపు లక్షణాలను కలిగి ఉంది, అందుకే మీరు ప్రత్యేకంగా చేయాలనుకుంటున్నారు.
ఉదాహరణకు, గులాబీ చాలా నిర్దిష్టమైన రోసీ సువాసనను కలిగి ఉంటుంది, ఇది చాలా ఇతర పుష్పాల యొక్క సువాసన వలె లేదు.
కాబట్టి, ఇది పూర్తి అయినప్పుడు మనం పూల స్పెషలైజేషన్ అని చెపుతాము మరియు మనము ఒక రివర్స్ రీతిలో అదే విషయం చెప్పగలము.
పుష్పం రోజ్ యొక్క generalization అని మేము చెప్పగలను.
కాబట్టి, మళ్లీ ఎర్ర గులాబీ మరియు గులాబి ఉన్నట్లయితే, ఎరుపు గులాబీ ISA గులాబీ ప్రొపర్టీస్ కలిగి ఉన్న రెడ్ గులాబీ రంగులో ఉన్నట్లయితే మనం ఎరుపు గులాబి అన్నీ లక్షణాలను కలిగి ఉంటుంది, కానీ అది ఎరుపు రంగులో ఉన్నట్లుగా ఇది ఒక అదనపు ఆస్తి కలిగి ఉంది మరియు ఇది గులాబీ మరియు ఎరుపు మధ్య ఉన్న సాధారణీకరణ ప్రత్యేకత.
కాబట్టి, నేను ఇక్కడ గీసిన దాని పరంగా, మీరు చాలామంది దీనిని UML generalization గా పిలుస్తారని మీకు తెలుస్తుంది.
యూనిఫైడ్ మోడలింగ్ లాంగ్వేజ్ అనేది ఆబ్జెక్ట్ ఓరియెంటెడ్ రీతిలో సిస్టమ్ ను వివరించడానికి ఒక బలమైన లాంగ్వేజ్.
కాబట్టి, ఈ క్లాస్ లు మరియు చివరికి ఓపెన్ త్రిభుజం triangle తో ముగుస్తుంది ఈ arrow ప్రత్యేకతను అర్థం.
కాబట్టి, ఇది చదివేది; arrow యొక్క దిశగా ఉన్న ISA పువ్వు పెరిగింది, ఎరుపు పెరిగింది ISA గులాబీ మరియు అందువలన న.
కాబట్టి, రేఖాచిత్రంగా మేము ఈ రేఖాచిత్రాల పరంగా ఇన్హెరిటెన్స్ లేదా స్పెషలైజేషన్ generalization ను తరచుగా వర్ణిస్తాము.
అదేవిధంగా, మేము కలిగి ఉండవచ్చు; మనం చెప్తాము అని చెప్పవచ్చు, ఇది చుట్టూ తిరగడానికి ఉపయోగించే ఒక వాహనం.
కాబట్టి, మేము Twowheelers లో చుట్టూ తరలించవచ్చు, కాబట్టి మేము Twowheeler ISA వాహనం చెప్పగలను.
అదేవిధంగా, Threewheelers ISA వాహనం, కానీ మేము వాహనం పరంగా generalization మరియు 3 చక్రాల మరియు 2 చక్రాల వాహనం యొక్క రెండు వేర్వేరు స్పెషలైజేషన్ అని కేటాయించవచ్చు.
కాబట్టి, generalization మరియు స్పెషలైజేషన్ మల్టిపుల్ రకాలుగా చెప్పవచ్చు.
కాబట్టి, ఇది ఒక generalized భావన ఉన్న ఒక రకంగా మరియు దాని కోసం మల్టిపుల్ specialized అంశాలు ఉన్నాయి.
మేము సాధారణంగా దీనిని ఒక ఆధారంగా సూచిస్తాము మరియు వీటిని మేము డిరైవ్ చేస్తాము.
వేర్వేరు ల్యాంగ్వేజ్ లో వివిధ పదాలను ఉపయోగించుకుంటాయి, ఉదాహరణకు, మీరు జావా గురించి తెలిసిన వారిలో, ఈ బేస్ లేదా generalization ను సూపర్ క్లాస్గా మరియు సబ్క్లాస్గా తీసుకున్న లేదా స్పెషలైజేషన్ గా గుర్తిస్తాము.
కొన్ని సందర్భాల్లో, అత్యంత సాధారణమైన ప్రత్యేకమైన క్లాస్ నను తరచుగా రూట్గా సూచించబడుతుంది.
ఇంకా ISA సంబంధం మరొక ఉదాహరణ ఎంప్లాయ్ డొమైన్ నుండి కావచ్చు.
మేనేజర్ ISA ఎంప్లాయ్ అని మేము చెబుతున్నాము, అంటే మేనేజర్ యొక్క అన్ని ఫంక్షన్లు నిర్వర్తించగలమని, కానీ ఎంప్లాయ్ కొన్నింటిని చేయగలడు; మేనేజర్ కొన్ని ఫంక్షన్లు చేయవచ్చు ఎంప్లాయ్ చేయలేరు, బహుశా మేనేజర్ తమను చేయలేని ఎంప్లాయ్ ఎంప్లాయ్ లను నియామకం చేయవచ్చు.
కాబట్టి, ఇది C ++ ప్రోగ్రామింగ్ సందర్భంలో మనము తీసుకురావాలనే ISA సంబంధానికి సంబంధించిన ప్రాథమిక భావన.
కాబట్టి, దీనిలో C ++ లో generalization స్పెషలైజేషన్ యొక్క సమాచారాన్ని ఎన్కోడ్ చేయాలనుకుంటే నేను ఇలా చేస్తాను.
కాబట్టి, ఈ కేసుల్లో సరళమైనది మేనేజర్ ISA ఎంప్లాయ్, ఇక్కడ మేము కేవలం రెండు క్లాస్ లను కలిగి ఉన్న మరొకదాని ప్రత్యేకత ఉంది.
కాబట్టి, మేము సాధారణంగా దీనిని ఒకే ఇన్హెరిటెన్స్ సూచించండి ఎందుకంటే ఇక్కడ మీరు కేవలం ఒకే సంబంధం కలిగి ఉంటారు.
సో, మేము ఒక క్లాస్ ను వ్రాయండి, ఎంప్లాయ్ రెప్రెజెంటేషన్, క్లాస్ ఎంప్లాయ్ చెప్పండి.
ఇక్కడ, నేను ఒక రకమైన ఉపయోగించాను మీరు ఒక క్లాస్ యొక్క అసంపూర్తిగా డెఫినిషన్ ని తెలుసు.
ఇది డెఫినిషన్ కలిగి ఉండదు, ఇది కేవలం ఎంప్లాయ్ అని పిలవబడుతున్న ఒక క్లాస్ ఉందని చెప్పడం వలన మేము తరువాత డేటా మెంబర్ ని మరియు మెంబర్ ఫంక్షన్ వివరాలను పరిశీలిస్తాము.
క్లాస్ మధ్య సంబంధాన్ని నిర్వచించేందుకు మేము ఆసక్తి కలిగి ఉంటాము.
అందువల్ల, ఈ రూపంలో మేనేజర్ ఎంప్లాయ్ అని ఇప్పుడు మనం చెప్తున్నాం. కాబట్టి, ఇక్కడ మీరు చేస్తున్న క్లిష్టమైన అదనంగా, క్లాస్ మేనేజర్ కి తర్వాత, విభజన ఉంది అని చూడవచ్చు: ఆపై నేను ఒక కొత్త పదమును పబ్లిక్ గా మరియు తరువాత ఎంప్లాయ్ క్లాస్ నేమ్ ను పెట్టుకున్నాను OOAD నిబంధనలు, ఇది మేనేజర్ ISA ఎంప్లాయ్ లేదా మేనేజర్ ఎంప్లాయ్ నుండి డిరైవ్(derive )చేసినట్లుగా చదవబడుతుంది.
సో, ఉద్యోగి బేస్ క్లాస్ మరియు మేనేజర్ ఒక డిరైవ్ క్లాస్.
ద్విచక్ర వాహన వాహన ఉదాహరణలో; ఈ రేఖాచిత్రం ఇచ్చినప్పుడు మేము నిజానికి హైబ్రీడ్ ఇన్హెరిటెన్స్ తో వ్యవహరిస్తాము.
హైబ్రీడ్ ఇన్హెరిటెన్స్ అనేది ఒక ప్రాథమిక క్లాస్ కి ఒకటి కంటే ఎక్కువ స్పెషలైజేషన్ ఉన్న సందర్భం మరియు మేము సులభంగా వాహనం అయిన రూట్ క్లాస్ ప్రకారం సి ++ లో దానిని సులభంగా ఎన్కోడ్ చేయవచ్చు.
అప్పుడు మేము టూవీలర్ అని పిలిచే వాహనం అని పిలుస్తాము: పబ్లిక్ వెహికల్.
త్రీవీలర్స్ అనేది టూవీలర్ యొక్క వాహనం: పబ్లిక్ వాహనం.
కాబట్టి, అక్కడ ఒక రూట్ క్లాస్ మరియు అక్కడ ఒక బేస్ క్లాస్ మరియు ఈ రెండు డిరైవ్డ్ క్లాస్ లు ఉన్నాయి.
చివరగా, గులాబీ ఉదాహరణకి వస్తే, మనం మల్టీలెవల్ ఇన్హెరిటెన్స్ పిలువబడుతున్నాము ఎందుకంటే ఇది ఒక స్థాయి, ఇది మరొక స్థాయి.
సో, ఇది ఒక మల్టీలెవల్ ఇన్హెరిటెన్స్ RedRose ISA రోజ్ ISA పువ్వు ఉంది.
కాబట్టి, ఇక్కడ పువ్వు బేస్ క్లాస్ మరియు డిరైవ్డ్ క్లాస్ రోజ్, కానీ మేము తదుపరి జత సంబంధాన్ని పరిశీలిస్తే అప్పుడు రోస్ బేస్ క్లాస్ గామారుతుంది మరియు RedRose నుండి డిరైవ్డ్ క్లాస్ గా మారుతుంది.
కాబట్టి, ఒక ప్రత్యేక క్లాస్ అనేది బేస్ క్లాస్ గా లేదా ఒక డిరైవ్డ్ క్లాస్ గా నిర్ణయించబడకపోవడమనేది ఆ క్లాస్ పై ఆధారపడినది కాదు, అది క్లాస్ hierarchy పై ఎక్కడ ఉంది అనే దానిపై ఆధారపడి ఉంటుంది.
క్లాస్ లో లీఫ్ ,ఆ లీఫ్, ఇది మీది కాదుఏ ఇతర క్లాస్ లకు ప్రత్యేకంగా తెలుసు అనేదానిని తప్పనిసరిగా క్లాస్ కి చెందినదిగా గుర్తిస్తారు.
ఏ క్లాస్ కైన సూపర్ క్లాస్ కానీ లేదా పేరెంట్ గానీ లేని బేస్ క్లాస్ మరియు రూట్ క్లాస్ తప్పనిసరిగా ఉండదు, కానీ మధ్యలో ఉన్న వంటి క్లాస్ లకు ఇన్హెరిటెన్స్ ఇతర భాగానికి ఇన్హెరిటెన్స్ మరియు రూట్ క్లాస్ లో ఒక భాగం కోసం క్లాస్ నుండి డిరైవ్ చేయబడుతుంది, మరియు మేము విభిన్న కాంప్లెక్స్ మరియు హైబ్రిడ్ రకమైన ఇన్హెరిటెన్స్ స్ట్రక్చర్ కలిగి ఉన్నాము, మేము C ++ లో ఎన్కోడ్ చేయాలనుకుంటున్నాము.
కాబట్టి, ఇక్కడ నేను ఒక ఉదాహరణగా కొంచెం విభిన్న రకాన్ని తీసుకుంటాను.
మేము అన్ని ఫోన్లతో సుపరిచితులు, మీరు అన్ని రకాల ఫోన్లను ఉపయోగిస్తున్నారు.
సో, నేను మాట్లాడుతున్నాను, మేము నేడు సాధారణమైన 3 సాధారణ రకాల ఫోన్లను పరిగణలోకి తీసుకుంటే; ల్యాండ్లైన్ ఫోన్, మొబైల్ ఫోన్ మరియు స్మార్ట్ ఫోన్, అప్పుడు మేము ఉందని చూడవచ్చు; మరియు నేను ఇక్కడ చేయడానికి ప్రయత్నిస్తున్న అన్ని మేము ఈ ఫోన్లు మానసికంగా అనుబంధం కార్యాచరణ అసోసియేట్ రకం.
కాబట్టి, ల్యాండ్లైన్ ఫోను చెప్పండి, మీరు అసోసియేట్ చేస్తారనే కార్యాచరణ ఉంటుంది; మీరు కాల్ చేయవచ్చు, మీరు కాల్కు సమాధానం చెప్పవచ్చు.
ఒక మొబైల్ ఫోన్ కోసం మీరు స్పష్టంగా, అలా అన్ని చేయవచ్చు, కానీ మీరు చాలా మొబైల్ ఫోన్ లో, మీరు గత సంఖ్య redial చేయగలరు, మీరు ఒక రింగ్ టోన్ సెట్ చేయగలరు, చాలా ఇతర విషయాలు చేయవచ్చు బహుశా మీరు మీ పరిచయాలను సంఖ్య మరియు పేరుతో పెట్టవచ్చు మరియు తద్వారా మొదలగునవి, అనేకమంది ఇతరులు ఉండవచ్చు.
కాబట్టి, ల్యాండ్లైన్ ఫోన్ యొక్క ప్రాథమిక ఫంక్షనాలిటీ కూడా మొబైల్ ఫోన్ ద్వారా సంతృప్తి చెందిందని నేను చూడగలను, ఇది ఇప్పటికే ఉనికిలో ఉంది.
కాబట్టి, ఒక మొబైల్ ఫోన్ ISA ల్యాండ్లైన్ ఫోన్ అని నేను చెప్పగలను.
ఈ ISA అది అదే అని కాదు, కానీ మొబైల్ ఫోన్ సంతృప్తి చేయవచ్చు అన్ని ఫంక్షనాలిటీ ను మొబైల్ ఫోన్ సంతృప్తి చేయవచ్చు అర్థం.
అదేవిధంగా, నేను ఒక స్మార్ట్ ఫోన్కు వచ్చినట్లయితే, కాల్ మరియు జవాబు యొక్క ఈ ఫంక్షనాలిటీ ను నేను మళ్లీ కలిగి ఉంటాను, వీటిని అన్నింటినీ redial చేసుకోవచ్చు, కానీ నేను అదనపు ఫంక్షనాలిటీ ను కలిగి ఉండవచ్చు.
నా కాన్టాక్ట్ కు (contact ) సంబంధించి ఒక ఫోటోగ్రాఫ్ ను అనుసంధానించగలగడం మరియు నేను నా కాన్టాక్ట్ తో ఫోటోను అనుసంధానించేటప్పుడు అప్పుడు కాల్ సమయంలో లేదా కాల్ చేసేటప్పుడు బహుశా స్మార్ట్ ఫోన్, కాల్ అందుకోవడం, పునఃప్రారంభ సమయంలో ఫోటోగ్రాఫ్ ను చూడవచ్చు.
కాబట్టి, మధ్య సామాన్యత ఉంది; ఈ విభిన్న రకాల ఫోన్ల మధ్య substantial సామాన్యం ఉంది, కానీ ఒక రకమైన ఫోన్ నుండి మరొకదానికి వెళ్లినప్పుడు, మొబైల్కు ల్యాండ్లైన్ మేము దొరుకుతుందాం మరికొన్ని అదనపు ఫంక్షనాలిటీ లు దొరుకుతున్నాయి.
మేము మొబైల్ నుండి స్మార్ట్ ఫోన్కు వెళ్తాము ఇంకా కొన్ని మరింత కార్యాచరణలు మరియు ఆ విధంగా ఫోన్లు చాలా nice చిన్న specialization generalization హైరార్కీ కలిగి ఉంటుంది.
అందువల్ల, మీరు కేవలం సంజ్ఞల కోసం, వివిధ రకాల గాడ్జెట్లు మరియు సాధ్యమయ్యే వాటి యొక్క హైరార్కీ లు గురించి మీకు అవగాహన కలిగించడానికి.
తరువాత మాడ్యూల్ వద్ద మేము ఫోన్లు చేపట్టాలనుకుంటున్నాము మరియు వాస్తవానికి ఇన్హెరిటెన్స్ స్ట్రక్చర్ పూర్తి డిజైన్ చేయాలనుకుంటున్నాను, కానీ ఇప్పుడు C ++ ఇన్హెరిటెన్స్ భావించే కాంక్రీట్ సెమాంటిక్స్కు వెళ్లనివ్వండి.
కాబట్టి, సాధారణంగా మేము రెండు క్లాస్ ల గురించి మాట్లాడతాము; బేస్ క్లాస్ మరియు డిరైవవ్డ్ క్లాస్.
కాబట్టి, ISA మోడల్; డిరైవవ్డ్ ISA బేస్.
అందువల్ల, డిరైవవ్డ్ క్లాస్ యొక్క నేమ్ డిరైవవ్డ్, బేస్ క్లాస్ యొక్క నేమ్ బేస్ మరియు ఖచ్చితంగా ఇది ఇదే C ++ లో ప్రాతినిధ్యం వహించబడిందని మేము ఇప్పటికే చూశాము.
కాబట్టి, కొత్త పరిచయం ఇది ఒక కీవర్డ్ ని పబ్లిక్ కీవర్డ్ గా ఉంది ఇది ఇప్పటికే ఉన్న ప్రాముఖ్యత కోసం ఉపయోగించినందున, కానీ ఇక్కడ మేము కొన్ని ప్రత్యేక ప్రయోజనాల కోసం మళ్లీ ఉపయోగిస్తున్నాము, మరియు ఈ ప్రత్యేక కీవర్డ్ యొక్క ప్రాముఖ్యత ఏమిటి అని చూద్దాం మరియు మేము వారి ప్రత్యామ్నాయాల గురించి మాట్లాడతాము, కానీ ఇప్పుడే దీనిని ఒక ప్రిస్క్రిప్షన్గా తీసుకుంటాను, నేను చెప్పేది అది డిరైవవ్డ్ ISA బేస్ అని చెప్పుకునే మార్గం, మరియు ఈ కీవర్డ్ తర్వాత మీకు క్లాస్ నేమ్ మీరు పేర్కొన్న generalized లేదా బేస్ క్లాస్ నేమ్.
ఇప్పుడు, ఖచ్చితంగా ఒక ప్రశ్న యొక్క మొత్తం చాలా వరకు చేస్తున్నట్లు మేము మాట్లాడుతున్నాము, ఎందుకంటే ఆ బేస్ వేర్వేరు డేటా మెంబర్లను కలిగి ఉంటుందని మేము ఆశిస్తాం.
డిరైవవ్డ్ వివిధ డేటా మెంబర్లను కూడా ఉంటారు, బేస్ వివిధ మెతడ్స్ ను కలిగి ఉంటుంది, డిరైవవ్డ్ కూడా వివిధ మెతడ్స్ ను కలిగి ఉంటుంది.
బేస్ కన్స్ట్రక్ట్ చేయాల్సిన అవసరం ఉంది, డిరైవవ్డ్ కూడా మరియు కన్స్ట్రక్ట్ చేయాల్సిన అవసరం ఉంది.
కాబట్టి, మనము చాలా జాగ్రత్తగా వివరించాలి మరియు అర్ధం చేసుకోవాలి; ఈ బేస్ ఎలా సంబంధాన్ని కలిగి ఉంటుందో సెమాంటిక్స్ అంటే ఏమిటి? కాబట్టి, నేను మొదట్లో సరిదిద్దటానికి ఇష్టపడుతున్నాను, అప్పుడు మేము వీటిలో ప్రతి ఒక్కదాన్ని తీసుకొని మరింత వివరణాత్మక చర్చ చేయాలని ప్రయత్నిస్తాము.
నేను మొదట C ++ లో ఇన్హెరిటెన్స్ యొక్క సెమాంటిక్స్ గురించి మాట్లాడేటప్పుడు, మీరు వీటి గురించి చాలా జాగ్రత్తగా ఉండవలసిన మొదటి స్థాయి అంశాలు.
మొదటి విషయం, నను క్షమించండి; మొదటి విషయం డేటా మెంబర్లు.
కాబట్టి, బేస్ క్లాస్ యొక్క అన్ని డేటా మెంబర్ నుండి డిరైవవ్డ్ క్లాస్ పొందినట్లు మేము చెబుతాము.
కాబట్టి, మీరు డిరైవవ్డ్ క్లాస్ లను ఏ డేటా మెంబర్ని కలిగి లేనప్పటికీ, అది ఇప్పటికీ బేస్ క్లాస్ కి చెందిన అన్ని డేటా మెంబర్లతో కూడిన డేటా మెంబర్లను కలిగి ఉంటుంది, కానీ అది మరింత డేటా మెంబర్లను మరింతగా add చేయగలదు.
నేను వీటిలో ప్రతిదానికి ఉదాహరణగా వస్తాను, కానీ నేను ప్రాథమిక ప్రిన్సిపిల్ ను చెప్పడానికి ప్రయత్నిస్తున్నాను.
ఇన్హెరిటెన్స్ యొక్క ప్రాధమిక ప్రిన్సిపిల్ ఇది నేను మరియు నేను సాధారణ భావన సంతృప్తి చెంది ప్రతిదీ సంతృప్తి అవసరం మరింత ప్రత్యేక భావన అందించడానికి ప్రత్యేకంగా ప్రయత్నిస్తున్న కొన్ని భావనలు ఉంది.
కాబట్టి, బేస్, డిరైవ్డ్ సంతృప్తినిచ్చే ప్రతిదీ సంతృప్తి పరచాలి.
కాబట్టి, ఇది మొత్తం డేటా మెంబర్లను కలిగి ఉండాలి, కానీ అది మొత్తం భావనను మరింత మెరుగుపరచడానికి దాని స్వంతని జోడించవచ్చు.
మళ్ళీ మెంబర్ ఫంక్షన్ ల పరంగా, మనము చూసే చాలా ముఖ్యమైన ఆలోచనలు ఉన్నాయని తెలుసుకుంటాం.
మొదటి భాగము, ఒక డిరైవ్డ్ క్లాస్ బేస్ క్లాస్ కి చెందిన అన్ని మెంబర్ ఫంక్షన్ లను ఇన్హెరిట్ చేసుకుంటుంది, కానీ ఆ తరువాత ఒక పెద్ద వ్యత్యాసం ఉంది; మీరు మెంబర్ ఫంక్షన్ ఇన్హెరిటెన్స్ గా వంటి మీరు తిరిగి సంస్కరణ మార్చకుండా అది తిరిగి నిర్వచించటానికి తిరిగి అమలు ఎంపిక ఉంది.
మీరు అదే విధమైన అల్గోరిథంతో మళ్ళీ అదే ఫంక్షన్ నిర్వచించాలనుకుంటున్నారు మరియు మీరు ఇలా చేస్తే అప్పుడు మీరు బేస్ వర్గంలో మెంబర్ల పనిని భర్తీ చేస్తున్నారని చెప్తారు; ఈ భావన చాలా ఓవర్లోడింగ్ భావనతో చాలా దగ్గరగా ఉన్నందున చాలా జాగ్రత్త వహించండి, ఓవర్లోడింగ్ తో మీకు గందరగోళంగా మొదలవుతుంది మరియు మీకు చెడ్డ విషయాలు ఏమిటంటే మీరు నిజంగా ఇన్హెరిటెన్స్ సందర్భంలో ఓవర్లోడింగ్ చేస్తారనే మంచి అవకాశం ఉంది.
మీరు ఒకే సిగ్నేచర్ ఒక ఫంక్షన్ని తిరిగి ఓవరైడింగ్ చేస్తే, అది భర్తీ అవుతుంది.
మీరు విభిన్న సిగ్నేచర్ తో ఒక ఫంక్షన్ని తిరిగి నిర్వచించినప్పుడు ఓవర్లోడింగ్ అంటారు.
సో, ఈ మేము ఇన్హెరిటెన్స్ కింద మెంబర్ ఫంక్షన్ లు ప్రవర్తన పరంగా అర్థం అవసరం వివిధ సెమాంటిక్స్ ఉన్నాయి.
యాక్సెస్ స్పెసిఫికేషన్ పరంగా మనము చూడవలసిన తదుపరి అంశం.
ఇప్పుడు, యాక్సెస్ స్పెసిఫికేషన్ పరంగా సహజంగా మనకు ప్రైవేటు యాక్సెస్ ఉందని మరియు పబ్లిక్ యాక్సెస్ ఉందని మాకు తెలుసు.
ప్రైవేటు యాక్సెస్ క్లాస్ మెంబర్ ల కోసం ఉంది, ప్రజా యాక్సెస్ ప్రతిఒక్కరికీ.
కాబట్టి, బేస్ క్లాస్ యొక్క డిరైవ్డ్ క్లాస్ ఖచ్చితంగా ఆ క్లాస్ లో భాగం కాదు.
అందువల్ల, ఒక డిరైవ్డ్ క్లాస్ బేస్ క్లాస్ లను ప్రైవేట్ మెంబర్ల ను యాక్సెస్ చేయలేరు.
ఇది పబ్లిక్ మెంబర్ లను మాత్రమే యాక్సెస్ చేయగలదు, కానీ అది చాలా కష్టాలకు దారి తీస్తుందని మేము చూస్తాము ఎందుకంటే ప్రత్యేకమైన semantics ప్రత్యేకంగా ఉంచడానికి మేము ప్రయత్నిస్తున్నట్లుగా చెప్పాలంటే ప్రత్యేకంగా సంకేతపదంగా సూచించడంతో, బేస్ క్లాస్ అంతర్గతాలకు ఎటువంటి ప్రాప్తి లేదు.
అందువల్ల, ఒక కొత్త టైప్ యాక్సెస్ స్పెసిఫైయర్తో, ప్రొటెక్టడ్ యాక్సెస్ స్పెసిఫైయర్ ఇన్హెరిటెన్స్ మంచి అర్థాలకు మద్దతిస్తుంది.
కాబట్టి, ఇన్హెరిటెన్స్ గా మద్దతు ఇచ్చే ఈ మూడవ రకమైన దృశ్యమానత లేదా ప్రాప్యత వివరణ ఏమిటో తెలుసుకోవడానికి మరియు అర్థం చేసుకోవడానికి మాకు ఉంటుంది.
అంతిమంగా, సహజంగా ఆబ్జెక్ట్ డిస్ట్రక్ట్ చేయబడాలి మరియు బేస్ మరియు డిరైవ్డ్ క్లాస్ మధ్య ఇన్హెరిటెన్స్ గా ఉన్నప్పుడు, ఒక డిరైవ్డ్ క్లాస్ ఉదాహరణగా పిలువబడే ఒక డిరైవ్డ్ క్లాస్ కన్స్ట్రక్టర్ కావాలి, కాని డిరైవ్డ్ క్లాస్ కన్స్ట్రక్టర్ ఒక బేస్ని కలిగి ఉంటుంది క్లాస్ ఆబ్జెక్ట్ కన్స్ట్రక్టర్ ని పిలుస్తూ క్లాస్ ఆబ్జెక్ట్.
కాబట్టి, బేస్ క్లాస్ అవగాహన మరియు డిరైవ్డ్ క్లాస్ ఆబ్జెక్ట్ ఎలా తమకు మరియు వారితో ఎలా సంకర్షణ చెందుతాయో తెలుసుకోవడానికి అవసరమైన ప్రాథమిక అవగాహన.
అదేవిధంగా, ఒక డిరైవ్డ్ క్లాస్ ఆబ్జెక్ట్ ను డిస్ట్రక్ట్ చేయవలసి వచ్చినప్పుడు, బేస్ క్లాస్ యొక్క డిస్ట్రక్టర్ ప్రయోగించవలసి ఉంటుంది, తద్వారా మీరు డిరైవ్డ్ క్లాస్ ఆబ్జెక్ట్ యొక్క బేస్ క్లాస్ భాగాలను డెస్ట్రాయ్ చేయవచ్చు.
కాబట్టి, ఇది ఇన్హెరిటెన్స్ ను ఎలా ఉపయోగించాలో అర్ధం చేసుకోవడానికి మరియు C ++ ల్యాంగ్వేజ్ చాలా సమర్థవంతమైన రీతిలో వేర్వేరు వాస్తవ ప్రపంచ scenario hierarchy ను ఎలా నిర్దేశించాలో అర్థం చేసుకోవడానికి అవసరమైన అన్ని ప్రధాన అర్థాల సిమాంటిక్స్(semantics) ఇది.
ఈ విధంగా సంగ్రహించేందుకు, మనకు OOAD hierarchy యొక్క శ్రేణిని ISA సంబంధం మరియు క్లాస్ హైరార్కీ భావన ఆబ్జెక్ట్ ఓరియంటెడ్ అనాలిసిస్ అండ్ డిజైన్ యొక్క పునర్వ్యవస్థీకరణలో ఉంది మరియు C ++ లో ఇన్హెరిటెన్స్ యొక్క ప్రాథమిక భావనను పరిచయం చేసాము.
మరియు అర్థం చేసుకోవడానికి అవసరమైన అర్థాల యొక్క విభిన్న అంశాలను ఏవి గమనించాలో, మేము నిజంగా ప్రభావవంతమైన పద్ధతిలో ఇన్హెరిటెన్స్ ని ఉపయోగించుకునే విధంగా మాస్టర్స్గా ఉండాలి.
inhouse/NPTEL/PreFinal/c++/Telugu/26 ProgramminginCplusplus_Default Parameters and Function Overloading (Contd.) (Lecture 14)-N4gpIkQKUbc.txt
View file @ 956c0d4e
 1. C++ లో ప్రోగ్రామింగ్ మాడ్యూల్ 8 కు స్వాగతం.
2. మేము ఇప్పటికే డిఫాల్ట్ పారామితులను చర్చించాము మరియు ఫంక్షన్ ఓవర్‌లోడింగ్, ఫంక్షన్‌ను ఓవర్‌లోడ్ చేయడం మరియు ఫంక్షన్‌లను ఓవర్‌లోడ్ చేయడం ఎలా అనే దాని గురించి మేము చర్చించాము. అంటే, సి ++ ఒకే పేరుతో బహుళ ఫంక్షన్లను కలిగి ఉండవచ్చు.
3. కానీ, పారామితుల రకం, సంఖ్య మరియు పారామితుల రకాన్ని బట్టి అవి విభిన్నంగా ఉంటాయి.
4. మరియు, రిటర్న్ రకంతో ఫంక్షన్లను ఓవర్లోడ్ చేయలేమని మేము చూశాము.
5. ఇప్పుడు, ఓవర్లోడ్ రిజల్యూషన్ యొక్క సంగ్రహావలోకనం ఇవ్వడానికి మేము ముందుకు వెళ్తాము.
6. ఓవర్లోడ్ రిజల్యూషన్ అనేది కంపైలర్ అనేక అభ్యర్థి ఫంక్షన్ల మధ్య నిర్ణయించే ప్రక్రియ, ఓవర్లోడ్ ఫంక్షన్ యొక్క బహుళ అభ్యర్థి నిర్వచనాలు ఉన్నాయి.
7. కంపైలర్ అతను ఏది కట్టాలి అని నిర్ణయించుకోవాలి.
8. ఇది ఓవర్‌లోడ్ రిజల్యూషన్, ఫంక్షన్ ఓవర్‌లోడింగ్‌లో కొద్దిగా అభివృద్ధి చెందిన అంశం.
9. కాబట్టి, మీరు ఈ దశలో నిర్వహించడం కొంచెం కష్టమైతే, మీరు దానిని నిషేధంలో ఉంచవచ్చు మరియు సి ++ లో ఓవర్‌లోడింగ్ యొక్క లోతు గురించి చర్చించినప్పుడు మీరు తిరిగి రావచ్చు.
10. అందువల్ల, ఓవర్లోడ్ పనులను ఎలా పరిష్కరించాలో ఇక్కడ మీకు ప్రాథమిక ఆలోచన ఇవ్వడానికి ప్రయత్నిస్తాము.
11. విషయాలు సరళంగా ఉంచడానికి నేను కేవలం ఒక పరామితితో ఇక్కడ ఉదాహరణను ఉపయోగిస్తున్నాను.
12. అభ్యర్థి ఫంక్షన్ల సమితిని గుర్తించే ప్రాథమిక దశలు ఇవి; అంటే, మీరు ముందు నిర్వచించిన అన్ని ఫంక్షన్లను స్కాన్ చేస్తారు.
13. ఖచ్చితంగా, ఒక ఫంక్షన్ ఇప్పటికే నిర్వచించబడితే, దానిని పిలుస్తారు.
14. కాబట్టి, కంపైలర్ ఈ కాల్‌కు ముందు ఇప్పటివరకు అందుకున్న అన్ని నిర్వచనాలను స్కాన్ చేస్తుంది మరియు అభ్యర్థి ఫంక్షన్ల సమితిని సృష్టిస్తుంది.
15. అప్పుడు, ఇది అభ్యర్థి ఫంక్షన్ల సమితి ద్వారా స్కాన్ చేస్తుంది, ఇది సాధ్యమయ్యే ఫంక్షన్ల సమితిని కనుగొనడానికి అభ్యర్థి ఫంక్షన్ల సమితికి పాయింట్ స్కాన్.ఇది పారామితుల సంఖ్యకు అనుగుణంగా ఉంటుంది.
16. ఆపై, ఇది కష్టతరమైన భాగాన్ని చేయడానికి ప్రయత్నిస్తుంది, అనగా, ఉత్తమమైన సాధ్యమయ్యే ఫంక్షన్ ఏమిటో నిర్ణయించండి.
17. మరియు, దీన్ని చేయడానికి ఇది క్రింది వ్యూహాలను ఉపయోగిస్తుంది.
18. మరియు, దయచేసి ఇక్కడ ఆర్డర్ ముఖ్యం అని గమనించండి.
19. అంటే, ఇది ఏకపక్షంగా కాకుండా వ్యూహాలకు వర్తిస్తుంది.
20. కానీ, ఖచ్చితమైన సరిపోలిక, ప్రమోషన్, ప్రామాణిక రకం మార్పిడి మరియు వినియోగదారు నిర్వచించిన రకం మార్పిడి యొక్క ఈ క్రమంలో.
21. ఇప్పుడు, ఖచ్చితంగా మేము ఇక్కడ అన్నింటినీ వివరించలేము.
22. అందువల్ల, మేము చాలా తరువాతి దశలో కూడా దీనికి తిరిగి వస్తాము.
23. ప్రస్తుతానికి, ఖచ్చితమైన సరిపోలికను ఉపయోగించి రిజల్యూషన్ ఎలా చేయబడుతుందనేదానికి ఒక సాధారణ ఉదాహరణను నేను మీకు చూపిస్తాను మరియు ఖచ్చితమైన మ్యాచ్ యొక్క స్థాయి మరియు ప్రమోషన్ యొక్క పరిధి గురించి కొంచెం మాట్లాడతాను.
24. కాబట్టి, ఒక ఉదాహరణ తీసుకుందాం.
25. పరామితితో ఓవర్లోడ్ రిజల్యూషన్ యొక్క ఉదాహరణ తీసుకుందాం.
26. అనుకో; ఇక్కడ ఎగువన ఉన్న జాబితాపై దృష్టి పెట్టండి.
27. ఈ జాబితాపై దృష్టి పెడదాం.
28. ఒక నిర్దిష్ట ఫంక్షన్ (ఫంక్షన్) యొక్క f పేరు మరియు పారామితి 5.6 కు సరిగ్గా సరిపోయే ఫంక్షన్ ఏమిటో తెలుసుకోవడం మన లక్ష్యం అని అనుకుందాం.
29. అంటే, నేను f (5.6) అని చెప్పినట్లయితే, వినియోగదారు చెప్పినట్లయితే, ఏ నిర్దిష్ట ఫంక్షన్ (ల) లో వినియోగదారు కాల్ చేయాలనుకుంటున్నారు.
30. అందువల్ల, 8 వేర్వేరు ఫంక్షన్ (ఫంక్షన్) శీర్షికలు లేదా ఫంక్షన్ (ఫంక్షన్) నిర్వచనాలను కంపైలర్ (కంపైలర్) చూసే ముందు f (5.6) యొక్క కాల్ ఎదురైంది.
31. మరియు, వాటిని సులభంగా సూచించడానికి మేము వాటిని F1 నుండి F8 అని పిలుస్తాము.
32. ఇప్పుడు, మీరు ఎలా నిర్ణయిస్తారు? కాబట్టి, వాస్తవానికి f (5.6) యొక్క కాల్ వాటిలో ఒకదానితో సమానంగా ఉండాలి, తద్వారా ఒక నిర్దిష్ట ఫంక్షన్ (ఫంక్షన్) అని పిలువబడుతుందని నేను చెప్పగలను.
33. కాబట్టి, తీర్మానంలో దశలు ఏమిటి? మీరు ఇక్కడ చూస్తే, మీరు ప్రతిపాదనలలో దశలను ఉపయోగిస్తే, మొదట మీరు అభ్యర్థి ఫంక్షన్‌ను సృష్టించండి.
34. ఈ సందర్భంలో, అభ్యర్థి ఫంక్షన్‌ను నిర్మించడానికి సరళమైన మార్గం పేరు కోసం వెతకడం మరియు సరిపోలే పేరు ఉన్న ఫంక్షన్‌ను కనుగొనడం.
35. ఇక్కడ, మాకు ఇతర అంశాలు లేవు.
36. కాబట్టి, మేము పేరు ద్వారా వెళ్తాము; పేరు ఇక్కడ f.
37. కాబట్టి, f పేరు ఉన్న ఫంక్షన్లు ఏవి అని చూద్దాం; ఈ ఫంక్షన్, ఈ ఫంక్షన్, ఈ ఫంక్షన్, ఈ ఫంక్షన్.
38. కాబట్టి ఎఫ్ 2, ఎఫ్ 3, ఎఫ్ 6, ఎఫ్ 8 నా అభ్యర్థులు.
39. వాస్తవానికి, నేను f (5.6) అని చెబితే, g కి పరామితి ఉన్నప్పటికీ, g కి రెట్టింపు పారామితి రకాన్ని కలిగి ఉన్నప్పటికీ, ఆ ఫంక్షన్ (g) అని అర్ధం కాదు, ఇది 5.6 రకం.
40. కానీ, నా పేర్లు భిన్నంగా ఉన్నందున నేను అర్థం కాలేదు.
41. అందువల్ల, నా అభ్యర్థి పనులు నాకు ఈ నాలుగు పనులను ఇస్తాయి.
42. కాబట్టి, ఇప్పుడు, నేను ఈ అభ్యర్థి ఫంక్షన్ పై మాత్రమే దృష్టి పెడుతున్నాను.
43. ఇప్పుడు దీని నుండి, ఈ అభ్యర్థి ఆధారంగా నేను చేసే తదుపరి స్క్రీనింగ్ పని పారామితుల సంఖ్యపై ఆధారపడి ఉంటుంది.
44. అందువల్ల, ఈ అభ్యర్థి ఫంక్షన్లలో, పారామితుల సంఖ్య ఏమిటో నేను చూస్తున్నాను.
45. కాబట్టి, నేను ఎఫ్ 2 ని చూస్తే, అది 0; నేను ఎఫ్ 3 ని చూస్తే, అది 1; నేను ఎఫ్ 6 ను చూస్తే, అది 2 లేదా 1 మరియు నేను చూస్తే అది 2.
46. అందువల్ల, సంబంధిత అభ్యర్థి యొక్క విధులను పిలవడానికి అవసరమైన పారామితులు ఇవి.
47. మరియు, మనకు ఇక్కడ ఎన్ని పారామితులు ఉన్నాయి? 5.6 - ఒక పరామితి.
48. రెండవది, అది తిరస్కరించబడిందని వెంటనే పేర్కొంది.
49. నేను f (5.6) నుండి F2 కి కాల్ చేయలేను.
50. నేను ఒకే విధంగా చెప్పలేను ఎందుకంటే దీనికి రెండు పారామితులు అవసరం.
51. కాబట్టి, నా ఎంపిక ఈ రెండింటికి దిమ్మదిరుగుతుంది; ఇది ఎఫ్ 3 లేదా ఎఫ్ 6.
52. అందువల్ల, నేను వాటిని సాధ్యమయ్యే ఫంక్షన్ల సమితి అని పిలుస్తాను.
53. ఇప్పుడు ఎఫ్ 3 మరియు ఎఫ్ 6 మధ్య, ఏది ఉపయోగించాలో నేను నిర్ణయించుకోవాలి.
54. అందువల్ల, నేను వాస్తవానికి F3 ఫంక్షన్‌ను పిలుస్తున్నానని అనుకోవచ్చు, దీనికి సన్నిహిత పరామితి అవసరం.
55. కాబట్టి, నేను ఫంక్షన్ (ఫంక్షన్) F3 అని పిలవాలనుకుంటే? ఈ పరామితి వాస్తవానికి డబుల్ పరామితి అని జరుగుతుంది; 5.6 రెట్టింపు.
56. కాబట్టి, అది ఎఫ్ 3 అని పిలవాలంటే, ఈ డబుల్‌ను పూర్ణాంకానికి మార్చాలి; అంటే, కొన్ని తొలగింపులు జరగాలి.
57. నిజానికి, కాల్ F5 అవుతుంది.
58. ఆపై, నేను దానిని కాల్ చేయగలను.
59. లేకపోతే, నేను F6 కి కాల్ చేయవచ్చు, ఇక్కడ, ఇది f (మొదటి పరామితిగా 5.6, రెండవ పరామితి అప్రమేయం).
60. కాబట్టి, ఈ కాల్ {f (5.6,3.4) be కావచ్చు.
61. కాబట్టి, అది కాల్ లేదా కాల్.
62. ఇప్పుడు, ఖచ్చితమైన మ్యాచ్ నేను దీన్ని ఎన్నుకుంటానని చెప్తుంది ఎందుకంటే ఇక్కడ పారామితి రకం, అధికారిక పారామితి మరియు వాస్తవ పరామితి రకం ఈ రెండు మ్యాచ్‌లు.
63. ఈ రెండు రెట్టింపు.
64. దీనికి మరియు దీనికి మధ్య, నేను మార్చాల్సిన అవసరం రెట్టింపు.
65. నేను మార్చాలి, నిజంగా దాన్ని కొనసాగించండి.
66. కాబట్టి, ఇది ఇష్టమైనది కాదు.
67. అందువల్ల, ఖచ్చితమైన మ్యాచింగ్ స్ట్రాటజీని ఉపయోగించి, టైప్ డబుల్ నా పరిష్కరించిన ఫంక్షన్ F6 అని చెబుతుంది.
68. అందువల్ల, నేను పూర్తి చేసిన తర్వాత, మీరు ఈ ఫంక్షన్‌ను పిలిచారో లేదో కంపైలర్ నిర్ణయిస్తుంది.
69. ఇది ఓవర్లోడ్ రిజల్యూషన్ యొక్క ప్రక్రియ.
70. మరియు, ఇది చాలా క్లిష్టమైన ప్రక్రియ, ఎందుకంటే ఇది చాలా రకాలను కలిగి ఉంటుంది.
71. కాబట్టి, అనేక విభిన్న కేసులు ఉండవచ్చు.
72. మరియు, కాబట్టి ఒక కంపైలర్ వ్రాసేటప్పుడు, దానిని బాగా తెలుసుకోవాలి.
73. ప్రోగ్రామర్‌గా, కొన్ని ఆలోచనలు కలిగి ఉండటం మంచిది, ఎందుకంటే మీరు ఒక నిర్దిష్ట ఓవర్‌లోడ్‌ను అర్థం చేసుకోవచ్చు.
74. కంపైలర్ వేరే రకం ఓవర్‌లోడ్‌ను ఉపయోగించినట్లయితే, మీరు సరైన స్థానంలో తప్పు ఫంక్షన్‌ను ఉపయోగిస్తున్నారు.
75. అందువల్ల, ఈ వ్యూహాలలో కొన్నింటిపై మనం దృష్టి పెట్టాలి.
76. ఖచ్చితమైన మ్యాచ్ మునుపటిది.
77. దీన్ని పరిష్కరించడానికి వివిధ మార్గాలు ఉన్నాయి, కేవలం రీక్యాప్ చేయడానికి, ఉత్తమ ఫంక్షన్, ఖచ్చితమైన మ్యాచ్ ప్రమోషన్ మరియు మొదలైనవి.
78. కాబట్టి, మీరు ఖచ్చితమైన మ్యాచ్ ఏమిటో చూస్తున్నారు.
79. కాబట్టి, ఖచ్చితమైన మ్యాచ్; ఇవి ఖచ్చితమైన మ్యాచ్ యొక్క విభిన్న సందర్భాలు.
80. అంటే, మీరు ఒక విలువను 1 విలువకు మార్చవచ్చు; మీరు వేరియబుల్ ఉపయోగిస్తుంటే, ఈ పదం మీకు తెలియకపోతే, l విలువ తొలగించబడుతుంది లేదా ప్రాథమికంగా వేరియబుల్ యొక్క చిరునామా.
81. మరియు, శత్రుత్వం ఒక విలువ; నిజమైన విలువ.
82. కాబట్టి, ఇది నేను a = b (ఒక అసైన్ బి) వ్రాస్తున్నట్లయితే, అప్పుడు నాకు ఆసక్తి ఉన్నది b యొక్క విలువ.
83. మరియు, నాకు ఆసక్తి ఉన్న విషయం ఏమిటంటే, నేను వెళ్లి బి విలువను ఉంచగల స్థలం.
84. కాబట్టి, ఇక్కడ నేను 1 విలువ మరియు విలువపై ఆసక్తి కలిగి ఉన్నాను.
85. కాబట్టి, మీరు 1 విలువ నుండి rvalue కు మార్చవలసి ఉంటుంది.
86. ఇతర అవకాశాలు ఇలా ఉంటాయి, ఇక్కడ మీరు మార్పిడి చేస్తారు మరియు మీరు శ్రేణిని పాస్ చేయడానికి ప్రయత్నిస్తున్నారు, కాని వాస్తవ ఫంక్షన్‌కు పాయింటర్ అవసరం.
87. మీరు ప్రాథమికంగా శ్రేణులను పాయింటర్లుగా మార్చవచ్చు.
88. మీరు ఒక ఫంక్షన్‌ను పాయింటర్‌గా మార్చవచ్చు.
89. ఉదాహరణకు, ఇది ఫంక్షన్ పాయింటర్.
90. ఫంక్షన్ పాయింటర్లు ఏమిటో మనం చూశాము.
91. ఇది నేను పరిష్కరించడానికి ప్రయత్నిస్తున్న ఫంక్షన్.
92. అంటే, రెండవ పరామితి ఫంక్షన్ పాయింటర్; ఈ ప్రత్యేక పని సూచిక.
93. కానీ, నేను దాటినది వాస్తవానికి ఒక ఫంక్షన్.
94. నేను పాయింటర్ పాస్ చేయలేదు.
95. కాబట్టి, నేను తప్పక పాస్ చేయాలి మరియు ఇది పాయింటర్ అయిన జి.
96. అయితే, నేను ఫంక్షన్‌కు పేరు పెట్టాను.
97. కాబట్టి, ఈ మార్పిడి మ్యాచ్‌గా అనుమతించబడుతుంది.
98. మరియు, నేను పాయింటర్లను పాయింటర్లుగా మార్చగలను.
99. కాబట్టి, ఇవి ఓవర్‌లోడ్ రిజల్యూషన్‌ను ఉపయోగించే ఖచ్చితమైన సరిపోలిక యొక్క విభిన్న సందర్భాలు.
100. అదనంగా, మీరు ప్రమోషన్లు మరియు మార్పిడులు తీసుకోవచ్చు.
101. ఉదాహరణకు, నేను ఒక అక్షరాన్ని పూర్ణాంకానికి, ఎనుమ్ నుండి పూర్ణాంకానికి, బూల్ పూర్ణాంకానికి మార్చగలను.
102. లేదా, నేను డబుల్ ఫ్లోట్‌గా మార్చగలను, ఇతర రకాల సమగ్ర మార్పిడుల మధ్య తేలుతాను; ఆ రకాలను అన్ని రకాల పాయింటర్లకు మార్చవచ్చు.
103. కాబట్టి, ఈ ప్రమోషన్లు మరియు పరివర్తనాలన్నీ ఓవర్‌లోడ్ రిజల్యూషన్ కోసం కూడా ఉపయోగించబడతాయి.
104. ఇది మీకు ఒక సంగ్రహావలోకనం ఇవ్వడానికి మాత్రమే.
105. మేము C ++ లో సాధ్యమయ్యే వివిధ రకాల ఓవర్‌లోడింగ్ గురించి మాట్లాడేటప్పుడు చాలా కాలం తరువాత దీనికి వస్తాము.
106. కాబట్టి, ఇది మీకు ప్రాథమిక ఆలోచనను ఇవ్వడం.
107. ఇప్పుడు, నేను పూర్తి చేస్తాను.
108. నేను పూర్తి చేయడానికి ముందు, ఓవర్‌లోడ్ రిజల్యూషన్ వివిధ సందర్భాల్లో విఫలం కావచ్చని కూడా చూపిస్తాను.
109. మరియు, మీరు ఆ వ్యక్తుల గురించి జాగ్రత్తగా ఉండాలి.
110. ఉదాహరణకు, ఈ మూడు రచనలను ఇక్కడ చూడండి; ఫంక్షన్ 1 లో ఫ్లోట్ ఉంది, ఫంక్షన్ 2 కి రెండు పారామితులు ఉన్నాయి, ఫంక్షన్ 2 లో ఒక డిఫాల్ట్ తో రెండు పారామితులు కూడా ఉన్నాయి.
111. మరియు, ఇది మీరు చేయడానికి ప్రయత్నిస్తున్న ఉపయోగం.
112. కాబట్టి, మీరు దాన్ని పరిష్కరించడానికి ప్రయత్నిస్తే, మొదట కాల్ చేయండి - 1, ఇది రెండు పారామితులను తీసుకుంటుంది, అప్పుడు మీ అభ్యర్థులు ఏమిటి? మూడు విధులు మీ అభ్యర్థులు; ఫంక్షన్ 1, 2, 3, ఎందుకంటే పేరు సరిపోతుంది.
113. ఇప్పుడు, ఆచరణీయమైనది ఏమిటి? సాధ్యమయ్యే పారామితుల సంఖ్యను చూస్తే.
114. ఇది ఫంక్షన్ 2 మరియు ఫంక్షన్ 3.
115. ఇప్పుడు ఈ రెండింటి మధ్య ఫంక్షన్ 2 మరియు ఫంక్షన్ 3 లలో ఏది ఉత్తమమైనది? P ఏది ఉత్తమమో చెప్పడం కష్టం, ఎందుకంటే p ఇక్కడ ఫ్లోట్, ఇది ఈ రెండు ఫంక్షన్ల యొక్క మొదటి పారామితి రకానికి సరిపోతుంది.
116. మనం సెకనులో చూస్తే, ఇది s, int, ఇది ఈ రెండు ఫంక్షన్ల యొక్క రెండవ పారామితి రకానికి అనుగుణంగా ఉంటుంది.
117. అందువల్ల, ఫంక్షన్ 2 మరియు ఫంక్షన్ 3 మధ్య పరిష్కరించడం మీకు సాధ్యం కాదు.
118. కాబట్టి, మాకు అలాంటి కాల్ ఉంటే, కంపైలర్ తిరిగి వచ్చి మీకు చెప్తుంది, అది అస్పష్టంగా ఉంది.
119. కంపైలర్ "నేను అయోమయంలో ఉన్నాను, ఏమి చేయాలో నాకు తెలియదు" అని చెబుతుంది.
120. కాబట్టి, ఇవి వివిక్త కేసులు, ఇక్కడ ఓవర్‌లోడ్ రిజల్యూషన్ విఫలమవుతుంది.
121. రెండవది మనం ఒక ఫంక్షన్ కోసం ఒక పరామితిని మాత్రమే ఉపయోగిస్తున్న మరొక సందర్భం.
122. కాబట్టి, సహజంగానే మీ అభ్యర్థులు ముగ్గురూ మళ్ళీ.
123. అయితే, మీ సాధ్యమయ్యేది రెండు ఆచరణీయమైనది కాదు ఎందుకంటే ఇక్కడ మీరు కేవలం ఒక పరామితిని ఉపయోగిస్తున్నారు.
124. ఫంక్షన్ 2 కి రెండు పారామితులు అవసరం.
125. కాబట్టి, ఈ రెండూ ఆచరణీయమైనవి.
126. అయితే, ఈ రెండూ సాధ్యమైతే, మీరు వాటి మధ్య తేలికగా పరిష్కరించలేరు ఎందుకంటే మీరు మార్పిడి ద్వారా, Int యొక్క ఫ్లోట్ ద్వారా ప్రచారం చేయవచ్చు; మేము ఇప్పుడే చూశాము
127. లేదా, ఇది అప్రమేయంగా 3 కాల్స్ చేయవచ్చు.
128. మరియు, ఇది మళ్ళీ తేలుటకు మరొక ప్రమోషన్.
129. కాబట్టి, రెండూ ఒకే రకమైన, మీకు తెలిసిన, ప్రయత్నం, ఒకే రకమైన సంక్లిష్టతను కలిగి ఉంటాయి.
130. కాబట్టి, ఇది అస్పష్టతకు దారితీస్తుంది.
131. అందువల్ల, మీరు ఓవర్‌లోడ్ ఫంక్షన్లను వ్రాసినప్పుడల్లా, అలాంటి సందర్భాలు మీ కోడ్‌లో లేవని లేదా కంపైలర్ (కంపైలర్) దానిని కంపైల్ చేయడానికి నిరాకరించి, అస్పష్టత ఉందని చెబితే, దయచేసి ఈ పరిస్థితులలో కొన్నింటిని చూడండి .
132. ఇప్పుడు మీ కోడ్, ఇప్పుడు మేము డిఫాల్ట్ పారామితులను చూశాము మరియు ఫంక్షన్ ఓవర్లోడింగ్ చూశాము.
133. ఇప్పుడు, మేము వాటిని ఒకే మాడ్యూల్‌లో ఉంచడానికి కారణం అవి ప్రాథమికంగా ఉండటం మాత్రమే అని మీరు చూడవచ్చు; ప్రధానంగా అవి డిఫాల్ట్ పారామితి విషయంలో తప్ప, డిఫాల్ట్ పారామితి విషయంలో తప్ప, అదే లక్షణం.
134. భాషలో మొత్తం వ్యవస్థ ఒకేలా ఉంటుంది.
135. కాబట్టి, మేము ఇక్కడ ఎడమ మరియు కుడి నిలువు వరుసల నుండి ఈ రెండు కోడ్‌లను పరిశీలిస్తే మరియు మీరు ప్రధాన ఫంక్షన్‌ను పరిశీలిస్తే, ఇక్కడ ప్రధాన ఫంక్షన్ ఒకే విధంగా ఉంటుంది.
136. ఇది, ఈ రెండింటిపై ఒకే కోడ్.
137. ఇక్కడ మనకు రెండు ఫంక్షన్లతో ఫంక్షన్ డిఫాల్ట్ ఉంది మరియు ఇక్కడ మనకు మూడు ఫంక్షన్లు ఓవర్లోడ్ ఉన్నాయి.
138. ఇప్పుడు కాల్స్ సందర్భంలో, మూడు కాల్స్ ఒకే ఫంక్షన్‌ను పరిష్కరిస్తాయి.
139. అలాగే, ఇది మీరు ఎన్ని పారామితులను ఉపయోగిస్తున్నారనే దానిపై ఆధారపడి ఉంటుంది.
140. మరియు ఇక్కడ, వారు సంబంధిత పనుల కోసం రిజల్యూషన్ చేస్తారు, దానిపై ఆధారపడి ఇది సాధారణ రిజల్యూషన్; ఎందుకంటే ఈ సందర్భాలలో, మీరు అర్థం చేసుకోగలిగినట్లుగా, ముగ్గురు అభ్యర్థులు మాత్రమే సెట్‌లో ఉంటారు.
141. మరియు, ప్రతి సందర్భంలోనూ సాధ్యమయ్యే సెట్‌లో ఒకే ఒక ఫంక్షన్ ఉంటుంది.
142. కాబట్టి, చూడటానికి ఏమీ లేదు.
143. కాబట్టి, ప్రాథమికంగా మీరు ఆలోచించగలిగేది ఏమిటంటే, మీరు ఫంక్షన్ యొక్క సమితిని, ఫంక్షన్ యొక్క పారామితులను డిఫాల్ట్ చేస్తే, మీకు ఎల్లప్పుడూ డిఫాల్ట్ పారామితి ఉంటుంది, ఈ కాల్ సైట్‌లో ఉండవచ్చు లేదా ఉనికిలో ఉండకపోవచ్చు. .
144. కాల్ సైట్లో.
145. దానిపై ఆధారపడి, మీరు ఒకే ఫంక్షన్ కోసం రెండు వేర్వేరు సంతకాలను సృష్టిస్తున్నారు.
146. అందువల్ల, నేను చెప్పేది ఏమిటంటే, నేను ఈ ఫంక్షన్ వ్రాస్తే; అంటే, నేను Int (int) int (int) తో int (int) అని చెప్పగలను, ఇది ప్రాథమికంగా ఈ ఓవర్లోడ్.
147. నేను రెండవ పరామితిని వదిలివేయగలనని కూడా దీని అర్థం.
148. కాబట్టి, నేను దీనిని ఒక పూర్ణాంకంతో (పూర్ణాంకానికి) చెప్పగలను, ఇది ఈ ఓవర్లోడ్.
149. నేను ఏ పరామితిని పేర్కొనలేనని కూడా దీని అర్థం.
150. పరామితి లేకుండా కాల్ చేయండి, ఇది ఈ ఓవర్లోడ్.
151. అందువల్ల, డిఫాల్ట్ పరామితి ప్రాథమికంగా ఓవర్‌లోడింగ్ ఫంక్షన్ యొక్క ప్రత్యేక సందర్భం తప్ప మరొకటి కాదు.
152. అదనపు లక్షణంతో ఇది పరామితి విలువతో పాటు ప్రారంభంలో ఉన్న ఓవర్‌లోడ్ విలువను కూడా కలిగి ఉంటుంది.
153. లేకపోతే, ఫంక్షన్ సైట్‌ను బట్టి, అటువంటి కాల్ సైట్ లేదా ఫంక్షన్‌కు కట్టుబడి ఉండేది, మళ్ళీ ఓవర్‌లోడ్ రిజల్యూషన్ సమస్య.
154. కాబట్టి, ఇప్పుడు సహజంగా మీరు ఫంక్షన్ ఓవర్‌లోడింగ్‌తో డిఫాల్ట్ పారామితులను ఉపయోగించవచ్చు.
155. మునుపటి కొన్ని ఉదాహరణలు, నేను ఇప్పటికే ఉపయోగించాను.
156. కానీ, ఇక్కడ నేను ఓవర్‌లోడ్ ఫంక్షన్ల మధ్య కొన్ని పారామితులను డిఫాల్ట్ చేయగలనని స్పష్టంగా చర్చించాలనుకుంటున్నాను.
157. కానీ, మీరు కాల్ సైట్ నుండి డిఫాల్ట్ పారామితులతో మొత్తం ఫంక్షన్లను పరిష్కరించగలిగినంత వరకు, ఈ ఉపయోగాలన్నీ చక్కగా ఉంటాయి.
158. కాబట్టి, ఇక్కడ మళ్ళీ ఒక ఉదాహరణ ఇక్కడ ఉంది.
159. కాబట్టి, ఏరియా ఫంక్షన్, మాకు ఈ ఫంక్షన్ ఉంది, మేము ఇంతకు ముందు చూశాము.
160. కాబట్టి, రెండింటికి ఇక్కడ రెండు పారామితులు ఉన్నాయి.
161. అవి వివిధ రకాలు.
162. మరియు, ఈ సందర్భంలో ఒక పరామితి అప్రమేయం.
163. కాబట్టి, మేము ఈ కాల్ చేస్తే, ఈ ఫంక్షన్‌ను మాత్రమే పరామితితో పిలుస్తారు.
164. ఇది ఇక్కడ పరిష్కరించబడుతుంది.
165. మేము ఇలా చెబితే, z రకం రెట్టింపు మరియు y రకం పూర్ణాంకం.
166. కాబట్టి, మీరు మొదట ఫంక్షన్‌కు కాల్ చేయలేరు.
167. మేము రెండవ ఫంక్షన్ అని పిలుస్తాము ఎందుకంటే మొదటి పరామితి రెట్టింపుగా సరిపోతుంది.
168. మరియు, Int (int) ను డబుల్ (డబుల్) గా మార్చడం కంటే int (int) ను డబుల్ (డబుల్) గా మార్చడం చాలా సులభం ఎందుకంటే మీరు డబుల్ (డబుల్) ను int (int) గా మార్చినట్లయితే, మీరు సమాచారం ఇవ్వండి.
169. మీరు Int (int) ను డబుల్ (డబుల్) గా మార్చినట్లయితే, మీరు సమాచారాన్ని కోల్పోరు.
170. కాబట్టి, ఇది ఒక ప్రచార వ్యూహం, ఇది బైండింగ్ ఉంటుందని మీకు తెలియజేస్తుంది, ఎందుకంటే ఇది ఇక్కడ బంధిస్తుంది మరియు ఇది ఇక్కడ బంధిస్తుంది.
171. ఈ సమయంలో మేము చూపించాము.
172. అందువల్ల, బాటమ్ లైన్ మేము వివరించడానికి ప్రయత్నిస్తున్నాము, డిఫాల్ట్ పరామితి మరియు ఫంక్షన్ ఓవర్లోడింగ్ మొత్తం విషయం పరిష్కరించబడే వరకు కలపవచ్చు. వెళ్ళవచ్చు.
173. మరియు, వాస్తవానికి అది విఫలం కావచ్చు.
174. ఉదాహరణకు, ఇది, ఏదో ఒక విధంగా మనం ఇంతకు ముందు చూశాము.
175. కానీ మళ్ళీ, ఇక్కడ ఓవర్లోడ్ చేయబడిన మూడు ఫంక్షన్లు ఉన్నాయని ప్రత్యేకంగా గమనించండి; ఇది సున్నా పరామితి, ఇది ఒక పరామితి మరియు ఇది రెండు పారామితులు.
176. కాబట్టి, ఈ మూడు కాల్స్ ఖచ్చితంగా పరిష్కరించగలవు.
177. ఈ సాధ్యమయ్యే ఫంక్షన్ సెట్ యొక్క ప్రతి సందర్భంలో, ప్రతి ఒక్కటి ఒకే ఫంక్షన్ కలిగి ఉంటుంది; చెయ్యగలుగుట
178. కానీ, మీరు ఈ ఓవర్‌లోడ్ ఫంక్షన్‌లో ఒకదానికి డిఫాల్ట్ పరామితిని నమోదు చేసినప్పుడు, మీకు సమస్య ఉంది ఎందుకంటే ఇప్పుడు ఈ ఫంక్షన్ (ఫంక్షన్) లో పరామితి (పరామితి) ఉంది లేదా శూన్య పరామితి (పరామితి) కావచ్చు.
179. కాబట్టి, నేను సున్నా పరామితితో ఫంక్షన్ కాల్ వ్రాసినప్పుడు, మీరు ఈ రెండింటినీ మీ సాధ్యమయ్యే సెట్‌లో కలిగి ఉంటారు.
180. మరియు, పరామితి లేనందున.
181. మీరు ప్రయత్నించగల సరిపోలిక లేదు ఎందుకంటే పరామితి లేకపోతే, అసలు పరామితి రకం మరియు అధికారిక పరామితి రకం మధ్య మీరు ఏ విధమైన సరిపోలికను చూడబోతున్నారు.
182. అందువల్ల, కంపైలర్ పరిష్కరించదు.
183. మరియు, ఇది మళ్ళీ ఒక సాధారణ కంపైలర్ నుండి.
184. ఇది మీకు అందుతున్న దోష సందేశం.
185. మరియు, కంపైలర్ ఏమి చెబుతుందో చూడండి; ఓవర్‌లోడ్ అనేది ఒక ఫంక్షన్‌కు మసక కాల్.
186. మరియు, ఇది ఈ రెండు ఫంక్షన్ల మధ్య పరిష్కరించలేమని చెప్పింది.
187. అందువల్ల, మీరు ఓవర్‌లోడ్‌తో డిఫాల్ట్ పారామితులను ఉపయోగించినప్పుడు, మీరు ఓవర్‌లోడింగ్‌ను చూడలేరని గుర్తుంచుకోవాలి లేదా డిఫాల్ట్ పరామితిని చూడలేరు.
188. వేర్వేరు ఓవర్‌లోడ్‌లకు కారణమయ్యే డిఫాల్ట్ పారామితులను మీరు చూడాలి మరియు అవి వేర్వేరు ఓవర్‌లోడ్‌లు అయినా, మేము వివరించే యంత్రాంగం యొక్క ఫ్రేమ్‌వర్క్ ద్వారా వాటిని నిజంగా పరిష్కరించవచ్చు.
189. కాబట్టి ఇది ఇది; ఇవి లక్షణాలు.
190. కాబట్టి, చివరికి నేను ఈ మాడ్యూల్‌లో సి ++ భాష యొక్క ప్రధాన అంశాన్ని పరిష్కరించడానికి ప్రయత్నించానని, ఇది ఫంక్షన్ ఓవర్‌లోడింగ్ అని చెప్పాలనుకుంటున్నాను.
191. మొదట, డిఫాల్ట్ పారామితుల యొక్క భావనను మేము పరిగణనలోకి తీసుకున్నాము, ఇది మేము తరువాత వివరించాము, ఇది ఓవర్లోడింగ్ ఫంక్షన్ యొక్క ప్రత్యేక సందర్భం.
192. డిఫాల్ట్ పారామితులు వాటి డిఫాల్ట్ విలువలను అందించడానికి మరియు ఫంక్షన్ లైబ్రరీలను ఉపయోగించడాన్ని సులభతరం చేయడానికి పెద్ద సంఖ్యలో పారామితులతో ఫంక్షన్లను వ్రాయడం చాలా సులభం చేస్తాయి.
193. మరియు, ఫంక్షన్ ఓవర్‌లోడింగ్ అనేది మరొక పారామితి రకాలు భిన్నంగా ఉన్నంత వరకు ఒకే ఫంక్షన్ పేరుతో బహుళ ఫంక్షన్లను వ్రాయడానికి అనుమతించే మరొక లక్షణం.
194. అందువల్ల, ఈ విషయంలో మేము వివిధ ప్రత్యేకతలను పరిశీలించాము.
195. మరియు, మేము ప్రాథమిక స్టాటిక్ పాలిమార్ఫిజం గురించి మాట్లాడాము.
196. మరియు ముఖ్యంగా, మేము అర్థం చేసుకున్న యంత్రాంగాన్ని కూడా చర్చించాము; ఓవర్లోడ్ కోసం వివిధ విధులను పరిష్కరించగల యంత్రాంగం యొక్క చట్రాన్ని మేము చర్చించాము.
197. దీనితో, మేము ఈ మాడ్యూల్‌ను ముగించాము.
198. మరియు, తరువాతి వాటిలో మేము అదే భావనను కొనసాగిస్తాము.
199. మరియు, ఆపరేటర్ల విషయంలో C ++ లో కూడా ఇలాంటి ఓవర్‌లోడింగ్ భావనను అమలు చేయవచ్చని చూడండి, దీనిని ఆపరేటర్ ఓవర్‌లోడింగ్ అని పిలుస్తారు.
200.
 C++ లో ప్రోగ్రామింగ్ మాడ్యూల్ 8 కు స్వాగతం.
మేము ఇప్పటికే డిఫాల్ట్ పారామితులను చర్చించాము మరియు ఫంక్షన్ ఓవర్‌లోడింగ్, ఫంక్షన్‌ను ఓవర్‌లోడ్ చేయడం మరియు ఫంక్షన్‌లను ఓవర్‌లోడ్ చేయడం ఎలా అనే దాని గురించి మేము చర్చించాము. అంటే, సి ++ ఒకే పేరుతో బహుళ ఫంక్షన్లను కలిగి ఉండవచ్చు.
కానీ, పారామితుల రకం, సంఖ్య మరియు పారామితుల రకాన్ని బట్టి అవి విభిన్నంగా ఉంటాయి.
మరియు, రిటర్న్ రకంతో ఫంక్షన్లను ఓవర్లోడ్ చేయలేమని మేము చూశాము.
ఇప్పుడు, ఓవర్లోడ్ రిజల్యూషన్ యొక్క సంగ్రహావలోకనం ఇవ్వడానికి మేము ముందుకు వెళ్తాము.
ఓవర్లోడ్ రిజల్యూషన్ అనేది కంపైలర్ అనేక అభ్యర్థి ఫంక్షన్ల మధ్య నిర్ణయించే ప్రక్రియ, ఓవర్లోడ్ ఫంక్షన్ యొక్క బహుళ అభ్యర్థి నిర్వచనాలు ఉన్నాయి.
కంపైలర్ అతను ఏది కట్టాలి అని నిర్ణయించుకోవాలి.
ఇది ఓవర్‌లోడ్ రిజల్యూషన్, ఫంక్షన్ ఓవర్‌లోడింగ్‌లో కొద్దిగా అభివృద్ధి చెందిన అంశం.
కాబట్టి, మీరు ఈ దశలో నిర్వహించడం కొంచెం కష్టమైతే, మీరు దానిని నిషేధంలో ఉంచవచ్చు మరియు సి ++ లో ఓవర్‌లోడింగ్ యొక్క లోతు గురించి చర్చించినప్పుడు మీరు తిరిగి రావచ్చు.
అందువల్ల, ఓవర్లోడ్ పనులను ఎలా పరిష్కరించాలో ఇక్కడ మీకు ప్రాథమిక ఆలోచన ఇవ్వడానికి ప్రయత్నిస్తాము.
విషయాలు సరళంగా ఉంచడానికి నేను కేవలం ఒక పరామితితో ఇక్కడ ఉదాహరణను ఉపయోగిస్తున్నాను.
అభ్యర్థి ఫంక్షన్ల సమితిని గుర్తించే ప్రాథమిక దశలు ఇవి; అంటే, మీరు ముందు నిర్వచించిన అన్ని ఫంక్షన్లను స్కాన్ చేస్తారు.
ఖచ్చితంగా, ఒక ఫంక్షన్ ఇప్పటికే నిర్వచించబడితే, దానిని పిలుస్తారు.
కాబట్టి, కంపైలర్ ఈ కాల్‌కు ముందు ఇప్పటివరకు అందుకున్న అన్ని నిర్వచనాలను స్కాన్ చేస్తుంది మరియు అభ్యర్థి ఫంక్షన్ల సమితిని సృష్టిస్తుంది.
అప్పుడు, ఇది అభ్యర్థి ఫంక్షన్ల సమితి ద్వారా స్కాన్ చేస్తుంది, ఇది సాధ్యమయ్యే ఫంక్షన్ల సమితిని కనుగొనడానికి అభ్యర్థి ఫంక్షన్ల సమితికి పాయింట్ స్కాన్.ఇది పారామితుల సంఖ్యకు అనుగుణంగా ఉంటుంది.
ఆపై, ఇది కష్టతరమైన భాగాన్ని చేయడానికి ప్రయత్నిస్తుంది, అనగా, ఉత్తమమైన సాధ్యమయ్యే ఫంక్షన్ ఏమిటో నిర్ణయించండి.
మరియు, దీన్ని చేయడానికి ఇది క్రింది వ్యూహాలను ఉపయోగిస్తుంది.
మరియు, దయచేసి ఇక్కడ ఆర్డర్ ముఖ్యం అని గమనించండి.
అంటే, ఇది ఏకపక్షంగా కాకుండా వ్యూహాలకు వర్తిస్తుంది.
కానీ, ఖచ్చితమైన సరిపోలిక, ప్రమోషన్, ప్రామాణిక రకం మార్పిడి మరియు వినియోగదారు నిర్వచించిన రకం మార్పిడి యొక్క ఈ క్రమంలో.
ఇప్పుడు, ఖచ్చితంగా మేము ఇక్కడ అన్నింటినీ వివరించలేము.
అందువల్ల, మేము చాలా తరువాతి దశలో కూడా దీనికి తిరిగి వస్తాము.
ప్రస్తుతానికి, ఖచ్చితమైన సరిపోలికను ఉపయోగించి రిజల్యూషన్ ఎలా చేయబడుతుందనేదానికి ఒక సాధారణ ఉదాహరణను నేను మీకు చూపిస్తాను మరియు ఖచ్చితమైన మ్యాచ్ యొక్క స్థాయి మరియు ప్రమోషన్ యొక్క పరిధి గురించి కొంచెం మాట్లాడతాను.
కాబట్టి, ఒక ఉదాహరణ తీసుకుందాం.
పరామితితో ఓవర్లోడ్ రిజల్యూషన్ యొక్క ఉదాహరణ తీసుకుందాం.
అనుకో; ఇక్కడ ఎగువన ఉన్న జాబితాపై దృష్టి పెట్టండి.
ఈ జాబితాపై దృష్టి పెడదాం.
ఒక నిర్దిష్ట ఫంక్షన్ (ఫంక్షన్) యొక్క f పేరు మరియు పారామితి 5.6 కు సరిగ్గా సరిపోయే ఫంక్షన్ ఏమిటో తెలుసుకోవడం మన లక్ష్యం అని అనుకుందాం.
అంటే, నేను f (5.6) అని చెప్పినట్లయితే, వినియోగదారు చెప్పినట్లయితే, ఏ నిర్దిష్ట ఫంక్షన్ (ల) లో వినియోగదారు కాల్ చేయాలనుకుంటున్నారు.
అందువల్ల, 8 వేర్వేరు ఫంక్షన్ (ఫంక్షన్) శీర్షికలు లేదా ఫంక్షన్ (ఫంక్షన్) నిర్వచనాలను కంపైలర్ (కంపైలర్) చూసే ముందు f (5.6) యొక్క కాల్ ఎదురైంది.
మరియు, వాటిని సులభంగా సూచించడానికి మేము వాటిని F1 నుండి F8 అని పిలుస్తాము.
ఇప్పుడు, మీరు ఎలా నిర్ణయిస్తారు? కాబట్టి, వాస్తవానికి f (5.6) యొక్క కాల్ వాటిలో ఒకదానితో సమానంగా ఉండాలి, తద్వారా ఒక నిర్దిష్ట ఫంక్షన్ (ఫంక్షన్) అని పిలువబడుతుందని నేను చెప్పగలను.
కాబట్టి, తీర్మానంలో దశలు ఏమిటి? మీరు ఇక్కడ చూస్తే, మీరు ప్రతిపాదనలలో దశలను ఉపయోగిస్తే, మొదట మీరు అభ్యర్థి ఫంక్షన్‌ను సృష్టించండి.
ఈ సందర్భంలో, అభ్యర్థి ఫంక్షన్‌ను నిర్మించడానికి సరళమైన మార్గం పేరు కోసం వెతకడం మరియు సరిపోలే పేరు ఉన్న ఫంక్షన్‌ను కనుగొనడం.
ఇక్కడ, మాకు ఇతర అంశాలు లేవు.
కాబట్టి, మేము పేరు ద్వారా వెళ్తాము; పేరు ఇక్కడ f.
కాబట్టి, f పేరు ఉన్న ఫంక్షన్లు ఏవి అని చూద్దాం; ఈ ఫంక్షన్, ఈ ఫంక్షన్, ఈ ఫంక్షన్, ఈ ఫంక్షన్.
కాబట్టి ఎఫ్ 2, ఎఫ్ 3, ఎఫ్ 6, ఎఫ్ 8 నా అభ్యర్థులు.
వాస్తవానికి, నేను f (5.6) అని చెబితే, g కి పరామితి ఉన్నప్పటికీ, g కి రెట్టింపు పారామితి రకాన్ని కలిగి ఉన్నప్పటికీ, ఆ ఫంక్షన్ (g) అని అర్ధం కాదు, ఇది 5.6 రకం.
కానీ, నా పేర్లు భిన్నంగా ఉన్నందున నేను అర్థం కాలేదు.
అందువల్ల, నా అభ్యర్థి పనులు నాకు ఈ నాలుగు పనులను ఇస్తాయి.
కాబట్టి, ఇప్పుడు, నేను ఈ అభ్యర్థి ఫంక్షన్ పై మాత్రమే దృష్టి పెడుతున్నాను.
ఇప్పుడు దీని నుండి, ఈ అభ్యర్థి ఆధారంగా నేను చేసే తదుపరి స్క్రీనింగ్ పని పారామితుల సంఖ్యపై ఆధారపడి ఉంటుంది.
అందువల్ల, ఈ అభ్యర్థి ఫంక్షన్లలో, పారామితుల సంఖ్య ఏమిటో నేను చూస్తున్నాను.
కాబట్టి, నేను ఎఫ్ 2 ని చూస్తే, అది 0; నేను ఎఫ్ 3 ని చూస్తే, అది 1; నేను ఎఫ్ 6 ను చూస్తే, అది 2 లేదా 1 మరియు నేను చూస్తే అది 2.
అందువల్ల, సంబంధిత అభ్యర్థి యొక్క విధులను పిలవడానికి అవసరమైన పారామితులు ఇవి.
మరియు, మనకు ఇక్కడ ఎన్ని పారామితులు ఉన్నాయి? 5.6 - ఒక పరామితి.
రెండవది, అది తిరస్కరించబడిందని వెంటనే పేర్కొంది.
నేను f (5.6) నుండి F2 కి కాల్ చేయలేను.
నేను ఒకే విధంగా చెప్పలేను ఎందుకంటే దీనికి రెండు పారామితులు అవసరం.
కాబట్టి, నా ఎంపిక ఈ రెండింటికి దిమ్మదిరుగుతుంది; ఇది ఎఫ్ 3 లేదా ఎఫ్ 6.
అందువల్ల, నేను వాటిని సాధ్యమయ్యే ఫంక్షన్ల సమితి అని పిలుస్తాను.
ఇప్పుడు ఎఫ్ 3 మరియు ఎఫ్ 6 మధ్య, ఏది ఉపయోగించాలో నేను నిర్ణయించుకోవాలి.
అందువల్ల, నేను వాస్తవానికి F3 ఫంక్షన్‌ను పిలుస్తున్నానని అనుకోవచ్చు, దీనికి సన్నిహిత పరామితి అవసరం.
కాబట్టి, నేను ఫంక్షన్ (ఫంక్షన్) F3 అని పిలవాలనుకుంటే? ఈ పరామితి వాస్తవానికి డబుల్ పరామితి అని జరుగుతుంది; 5.6 రెట్టింపు.
కాబట్టి, అది ఎఫ్ 3 అని పిలవాలంటే, ఈ డబుల్‌ను పూర్ణాంకానికి మార్చాలి; అంటే, కొన్ని తొలగింపులు జరగాలి.
నిజానికి, కాల్ F5 అవుతుంది.
ఆపై, నేను దానిని కాల్ చేయగలను.
లేకపోతే, నేను F6 కి కాల్ చేయవచ్చు, ఇక్కడ, ఇది f (మొదటి పరామితిగా 5.6, రెండవ పరామితి అప్రమేయం).
కాబట్టి, ఈ కాల్ {f (5.6,3.4) be కావచ్చు.
కాబట్టి, అది కాల్ లేదా కాల్.
ఇప్పుడు, ఖచ్చితమైన మ్యాచ్ నేను దీన్ని ఎన్నుకుంటానని చెప్తుంది ఎందుకంటే ఇక్కడ పారామితి రకం, అధికారిక పారామితి మరియు వాస్తవ పరామితి రకం ఈ రెండు మ్యాచ్‌లు.
ఈ రెండు రెట్టింపు.
దీనికి మరియు దీనికి మధ్య, నేను మార్చాల్సిన అవసరం రెట్టింపు.
నేను మార్చాలి, నిజంగా దాన్ని కొనసాగించండి.
కాబట్టి, ఇది ఇష్టమైనది కాదు.
అందువల్ల, ఖచ్చితమైన మ్యాచింగ్ స్ట్రాటజీని ఉపయోగించి, టైప్ డబుల్ నా పరిష్కరించిన ఫంక్షన్ F6 అని చెబుతుంది.
అందువల్ల, నేను పూర్తి చేసిన తర్వాత, మీరు ఈ ఫంక్షన్‌ను పిలిచారో లేదో కంపైలర్ నిర్ణయిస్తుంది.
ఇది ఓవర్లోడ్ రిజల్యూషన్ యొక్క ప్రక్రియ.
మరియు, ఇది చాలా క్లిష్టమైన ప్రక్రియ, ఎందుకంటే ఇది చాలా రకాలను కలిగి ఉంటుంది.
కాబట్టి, అనేక విభిన్న కేసులు ఉండవచ్చు.
మరియు, కాబట్టి ఒక కంపైలర్ వ్రాసేటప్పుడు, దానిని బాగా తెలుసుకోవాలి.
ప్రోగ్రామర్‌గా, కొన్ని ఆలోచనలు కలిగి ఉండటం మంచిది, ఎందుకంటే మీరు ఒక నిర్దిష్ట ఓవర్‌లోడ్‌ను అర్థం చేసుకోవచ్చు.
కంపైలర్ వేరే రకం ఓవర్‌లోడ్‌ను ఉపయోగించినట్లయితే, మీరు సరైన స్థానంలో తప్పు ఫంక్షన్‌ను ఉపయోగిస్తున్నారు.
అందువల్ల, ఈ వ్యూహాలలో కొన్నింటిపై మనం దృష్టి పెట్టాలి.
ఖచ్చితమైన మ్యాచ్ మునుపటిది.
దీన్ని పరిష్కరించడానికి వివిధ మార్గాలు ఉన్నాయి, కేవలం రీక్యాప్ చేయడానికి, ఉత్తమ ఫంక్షన్, ఖచ్చితమైన మ్యాచ్ ప్రమోషన్ మరియు మొదలైనవి.
కాబట్టి, మీరు ఖచ్చితమైన మ్యాచ్ ఏమిటో చూస్తున్నారు.
కాబట్టి, ఖచ్చితమైన మ్యాచ్; ఇవి ఖచ్చితమైన మ్యాచ్ యొక్క విభిన్న సందర్భాలు.
అంటే, మీరు ఒక విలువను 1 విలువకు మార్చవచ్చు; మీరు వేరియబుల్ ఉపయోగిస్తుంటే, ఈ పదం మీకు తెలియకపోతే, l విలువ తొలగించబడుతుంది లేదా ప్రాథమికంగా వేరియబుల్ యొక్క చిరునామా.
మరియు, శత్రుత్వం ఒక విలువ; నిజమైన విలువ.
కాబట్టి, ఇది నేను a = b (ఒక అసైన్ బి) వ్రాస్తున్నట్లయితే, అప్పుడు నాకు ఆసక్తి ఉన్నది b యొక్క విలువ.
మరియు, నాకు ఆసక్తి ఉన్న విషయం ఏమిటంటే, నేను వెళ్లి బి విలువను ఉంచగల స్థలం.
కాబట్టి, ఇక్కడ నేను 1 విలువ మరియు విలువపై ఆసక్తి కలిగి ఉన్నాను.
కాబట్టి, మీరు 1 విలువ నుండి rvalue కు మార్చవలసి ఉంటుంది.
ఇతర అవకాశాలు ఇలా ఉంటాయి, ఇక్కడ మీరు మార్పిడి చేస్తారు మరియు మీరు శ్రేణిని పాస్ చేయడానికి ప్రయత్నిస్తున్నారు, కాని వాస్తవ ఫంక్షన్‌కు పాయింటర్ అవసరం.
మీరు ప్రాథమికంగా శ్రేణులను పాయింటర్లుగా మార్చవచ్చు.
మీరు ఒక ఫంక్షన్‌ను పాయింటర్‌గా మార్చవచ్చు.
ఉదాహరణకు, ఇది ఫంక్షన్ పాయింటర్.
ఫంక్షన్ పాయింటర్లు ఏమిటో మనం చూశాము.
ఇది నేను పరిష్కరించడానికి ప్రయత్నిస్తున్న ఫంక్షన్.
అంటే, రెండవ పరామితి ఫంక్షన్ పాయింటర్; ఈ ప్రత్యేక పని సూచిక.
కానీ, నేను దాటినది వాస్తవానికి ఒక ఫంక్షన్.
నేను పాయింటర్ పాస్ చేయలేదు.
కాబట్టి, నేను తప్పక పాస్ చేయాలి మరియు ఇది పాయింటర్ అయిన జి.
అయితే, నేను ఫంక్షన్‌కు పేరు పెట్టాను.
కాబట్టి, ఈ మార్పిడి మ్యాచ్‌గా అనుమతించబడుతుంది.
మరియు, నేను పాయింటర్లను పాయింటర్లుగా మార్చగలను.
కాబట్టి, ఇవి ఓవర్‌లోడ్ రిజల్యూషన్‌ను ఉపయోగించే ఖచ్చితమైన సరిపోలిక యొక్క విభిన్న సందర్భాలు.
అదనంగా, మీరు ప్రమోషన్లు మరియు మార్పిడులు తీసుకోవచ్చు.
ఉదాహరణకు, నేను ఒక అక్షరాన్ని పూర్ణాంకానికి, ఎనుమ్ నుండి పూర్ణాంకానికి, బూల్ పూర్ణాంకానికి మార్చగలను.
లేదా, నేను డబుల్ ఫ్లోట్‌గా మార్చగలను, ఇతర రకాల సమగ్ర మార్పిడుల మధ్య తేలుతాను; ఆ రకాలను అన్ని రకాల పాయింటర్లకు మార్చవచ్చు.
కాబట్టి, ఈ ప్రమోషన్లు మరియు పరివర్తనాలన్నీ ఓవర్‌లోడ్ రిజల్యూషన్ కోసం కూడా ఉపయోగించబడతాయి.
ఇది మీకు ఒక సంగ్రహావలోకనం ఇవ్వడానికి మాత్రమే.
మేము C ++ లో సాధ్యమయ్యే వివిధ రకాల ఓవర్‌లోడింగ్ గురించి మాట్లాడేటప్పుడు చాలా కాలం తరువాత దీనికి వస్తాము.
కాబట్టి, ఇది మీకు ప్రాథమిక ఆలోచనను ఇవ్వడం.
ఇప్పుడు, నేను పూర్తి చేస్తాను.
నేను పూర్తి చేయడానికి ముందు, ఓవర్‌లోడ్ రిజల్యూషన్ వివిధ సందర్భాల్లో విఫలం కావచ్చని కూడా చూపిస్తాను.
మరియు, మీరు ఆ వ్యక్తుల గురించి జాగ్రత్తగా ఉండాలి.
ఉదాహరణకు, ఈ మూడు రచనలను ఇక్కడ చూడండి; ఫంక్షన్ 1 లో ఫ్లోట్ ఉంది, ఫంక్షన్ 2 కి రెండు పారామితులు ఉన్నాయి, ఫంక్షన్ 2 లో ఒక డిఫాల్ట్ తో రెండు పారామితులు కూడా ఉన్నాయి.
మరియు, ఇది మీరు చేయడానికి ప్రయత్నిస్తున్న ఉపయోగం.
కాబట్టి, మీరు దాన్ని పరిష్కరించడానికి ప్రయత్నిస్తే, మొదట కాల్ చేయండి - 1, ఇది రెండు పారామితులను తీసుకుంటుంది, అప్పుడు మీ అభ్యర్థులు ఏమిటి? మూడు విధులు మీ అభ్యర్థులు; ఫంక్షన్ 1, 2, 3, ఎందుకంటే పేరు సరిపోతుంది.
ఇప్పుడు, ఆచరణీయమైనది ఏమిటి? సాధ్యమయ్యే పారామితుల సంఖ్యను చూస్తే.
ఇది ఫంక్షన్ 2 మరియు ఫంక్షన్ 3.
ఇప్పుడు ఈ రెండింటి మధ్య ఫంక్షన్ 2 మరియు ఫంక్షన్ 3 లలో ఏది ఉత్తమమైనది? P ఏది ఉత్తమమో చెప్పడం కష్టం, ఎందుకంటే p ఇక్కడ ఫ్లోట్, ఇది ఈ రెండు ఫంక్షన్ల యొక్క మొదటి పారామితి రకానికి సరిపోతుంది.
మనం సెకనులో చూస్తే, ఇది s, int, ఇది ఈ రెండు ఫంక్షన్ల యొక్క రెండవ పారామితి రకానికి అనుగుణంగా ఉంటుంది.
అందువల్ల, ఫంక్షన్ 2 మరియు ఫంక్షన్ 3 మధ్య పరిష్కరించడం మీకు సాధ్యం కాదు.
కాబట్టి, మాకు అలాంటి కాల్ ఉంటే, కంపైలర్ తిరిగి వచ్చి మీకు చెప్తుంది, అది అస్పష్టంగా ఉంది.
కంపైలర్ "నేను అయోమయంలో ఉన్నాను, ఏమి చేయాలో నాకు తెలియదు" అని చెబుతుంది.
కాబట్టి, ఇవి వివిక్త కేసులు, ఇక్కడ ఓవర్‌లోడ్ రిజల్యూషన్ విఫలమవుతుంది.
రెండవది మనం ఒక ఫంక్షన్ కోసం ఒక పరామితిని మాత్రమే ఉపయోగిస్తున్న మరొక సందర్భం.
కాబట్టి, సహజంగానే మీ అభ్యర్థులు ముగ్గురూ మళ్ళీ.
అయితే, మీ సాధ్యమయ్యేది రెండు ఆచరణీయమైనది కాదు ఎందుకంటే ఇక్కడ మీరు కేవలం ఒక పరామితిని ఉపయోగిస్తున్నారు.
ఫంక్షన్ 2 కి రెండు పారామితులు అవసరం.
కాబట్టి, ఈ రెండూ ఆచరణీయమైనవి.
అయితే, ఈ రెండూ సాధ్యమైతే, మీరు వాటి మధ్య తేలికగా పరిష్కరించలేరు ఎందుకంటే మీరు మార్పిడి ద్వారా, Int యొక్క ఫ్లోట్ ద్వారా ప్రచారం చేయవచ్చు; మేము ఇప్పుడే చూశాము
లేదా, ఇది అప్రమేయంగా 3 కాల్స్ చేయవచ్చు.
మరియు, ఇది మళ్ళీ తేలుటకు మరొక ప్రమోషన్.
కాబట్టి, రెండూ ఒకే రకమైన, మీకు తెలిసిన, ప్రయత్నం, ఒకే రకమైన సంక్లిష్టతను కలిగి ఉంటాయి.
కాబట్టి, ఇది అస్పష్టతకు దారితీస్తుంది.
అందువల్ల, మీరు ఓవర్‌లోడ్ ఫంక్షన్లను వ్రాసినప్పుడల్లా, అలాంటి సందర్భాలు మీ కోడ్‌లో లేవని లేదా కంపైలర్ (కంపైలర్) దానిని కంపైల్ చేయడానికి నిరాకరించి, అస్పష్టత ఉందని చెబితే, దయచేసి ఈ పరిస్థితులలో కొన్నింటిని చూడండి .
ఇప్పుడు మీ కోడ్, ఇప్పుడు మేము డిఫాల్ట్ పారామితులను చూశాము మరియు ఫంక్షన్ ఓవర్లోడింగ్ చూశాము.
ఇప్పుడు, మేము వాటిని ఒకే మాడ్యూల్‌లో ఉంచడానికి కారణం అవి ప్రాథమికంగా ఉండటం మాత్రమే అని మీరు చూడవచ్చు; ప్రధానంగా అవి డిఫాల్ట్ పారామితి విషయంలో తప్ప, డిఫాల్ట్ పారామితి విషయంలో తప్ప, అదే లక్షణం.
భాషలో మొత్తం వ్యవస్థ ఒకేలా ఉంటుంది.
కాబట్టి, మేము ఇక్కడ ఎడమ మరియు కుడి నిలువు వరుసల నుండి ఈ రెండు కోడ్‌లను పరిశీలిస్తే మరియు మీరు ప్రధాన ఫంక్షన్‌ను పరిశీలిస్తే, ఇక్కడ ప్రధాన ఫంక్షన్ ఒకే విధంగా ఉంటుంది.
ఇది, ఈ రెండింటిపై ఒకే కోడ్.
ఇక్కడ మనకు రెండు ఫంక్షన్లతో ఫంక్షన్ డిఫాల్ట్ ఉంది మరియు ఇక్కడ మనకు మూడు ఫంక్షన్లు ఓవర్లోడ్ ఉన్నాయి.
ఇప్పుడు కాల్స్ సందర్భంలో, మూడు కాల్స్ ఒకే ఫంక్షన్‌ను పరిష్కరిస్తాయి.
అలాగే, ఇది మీరు ఎన్ని పారామితులను ఉపయోగిస్తున్నారనే దానిపై ఆధారపడి ఉంటుంది.
మరియు ఇక్కడ, వారు సంబంధిత పనుల కోసం రిజల్యూషన్ చేస్తారు, దానిపై ఆధారపడి ఇది సాధారణ రిజల్యూషన్; ఎందుకంటే ఈ సందర్భాలలో, మీరు అర్థం చేసుకోగలిగినట్లుగా, ముగ్గురు అభ్యర్థులు మాత్రమే సెట్‌లో ఉంటారు.
మరియు, ప్రతి సందర్భంలోనూ సాధ్యమయ్యే సెట్‌లో ఒకే ఒక ఫంక్షన్ ఉంటుంది.
కాబట్టి, చూడటానికి ఏమీ లేదు.
కాబట్టి, ప్రాథమికంగా మీరు ఆలోచించగలిగేది ఏమిటంటే, మీరు ఫంక్షన్ యొక్క సమితిని, ఫంక్షన్ యొక్క పారామితులను డిఫాల్ట్ చేస్తే, మీకు ఎల్లప్పుడూ డిఫాల్ట్ పారామితి ఉంటుంది, ఈ కాల్ సైట్‌లో ఉండవచ్చు లేదా ఉనికిలో ఉండకపోవచ్చు. .
కాల్ సైట్లో.
దానిపై ఆధారపడి, మీరు ఒకే ఫంక్షన్ కోసం రెండు వేర్వేరు సంతకాలను సృష్టిస్తున్నారు.
అందువల్ల, నేను చెప్పేది ఏమిటంటే, నేను ఈ ఫంక్షన్ వ్రాస్తే; అంటే, నేను Int (int) int (int) తో int (int) అని చెప్పగలను, ఇది ప్రాథమికంగా ఈ ఓవర్లోడ్.
నేను రెండవ పరామితిని వదిలివేయగలనని కూడా దీని అర్థం.
కాబట్టి, నేను దీనిని ఒక పూర్ణాంకంతో (పూర్ణాంకానికి) చెప్పగలను, ఇది ఈ ఓవర్లోడ్.
నేను ఏ పరామితిని పేర్కొనలేనని కూడా దీని అర్థం.
పరామితి లేకుండా కాల్ చేయండి, ఇది ఈ ఓవర్లోడ్.
అందువల్ల, డిఫాల్ట్ పరామితి ప్రాథమికంగా ఓవర్‌లోడింగ్ ఫంక్షన్ యొక్క ప్రత్యేక సందర్భం తప్ప మరొకటి కాదు.
అదనపు లక్షణంతో ఇది పరామితి విలువతో పాటు ప్రారంభంలో ఉన్న ఓవర్‌లోడ్ విలువను కూడా కలిగి ఉంటుంది.
లేకపోతే, ఫంక్షన్ సైట్‌ను బట్టి, అటువంటి కాల్ సైట్ లేదా ఫంక్షన్‌కు కట్టుబడి ఉండేది, మళ్ళీ ఓవర్‌లోడ్ రిజల్యూషన్ సమస్య.
కాబట్టి, ఇప్పుడు సహజంగా మీరు ఫంక్షన్ ఓవర్‌లోడింగ్‌తో డిఫాల్ట్ పారామితులను ఉపయోగించవచ్చు.
మునుపటి కొన్ని ఉదాహరణలు, నేను ఇప్పటికే ఉపయోగించాను.
కానీ, ఇక్కడ నేను ఓవర్‌లోడ్ ఫంక్షన్ల మధ్య కొన్ని పారామితులను డిఫాల్ట్ చేయగలనని స్పష్టంగా చర్చించాలనుకుంటున్నాను.
కానీ, మీరు కాల్ సైట్ నుండి డిఫాల్ట్ పారామితులతో మొత్తం ఫంక్షన్లను పరిష్కరించగలిగినంత వరకు, ఈ ఉపయోగాలన్నీ చక్కగా ఉంటాయి.
కాబట్టి, ఇక్కడ మళ్ళీ ఒక ఉదాహరణ ఇక్కడ ఉంది.
కాబట్టి, ఏరియా ఫంక్షన్, మాకు ఈ ఫంక్షన్ ఉంది, మేము ఇంతకు ముందు చూశాము.
కాబట్టి, రెండింటికి ఇక్కడ రెండు పారామితులు ఉన్నాయి.
అవి వివిధ రకాలు.
మరియు, ఈ సందర్భంలో ఒక పరామితి అప్రమేయం.
కాబట్టి, మేము ఈ కాల్ చేస్తే, ఈ ఫంక్షన్‌ను మాత్రమే పరామితితో పిలుస్తారు.
ఇది ఇక్కడ పరిష్కరించబడుతుంది.
మేము ఇలా చెబితే, z రకం రెట్టింపు మరియు y రకం పూర్ణాంకం.
కాబట్టి, మీరు మొదట ఫంక్షన్‌కు కాల్ చేయలేరు.
మేము రెండవ ఫంక్షన్ అని పిలుస్తాము ఎందుకంటే మొదటి పరామితి రెట్టింపుగా సరిపోతుంది.
మరియు, Int (int) ను డబుల్ (డబుల్) గా మార్చడం కంటే int (int) ను డబుల్ (డబుల్) గా మార్చడం చాలా సులభం ఎందుకంటే మీరు డబుల్ (డబుల్) ను int (int) గా మార్చినట్లయితే, మీరు సమాచారం ఇవ్వండి.
మీరు Int (int) ను డబుల్ (డబుల్) గా మార్చినట్లయితే, మీరు సమాచారాన్ని కోల్పోరు.
కాబట్టి, ఇది ఒక ప్రచార వ్యూహం, ఇది బైండింగ్ ఉంటుందని మీకు తెలియజేస్తుంది, ఎందుకంటే ఇది ఇక్కడ బంధిస్తుంది మరియు ఇది ఇక్కడ బంధిస్తుంది.
ఈ సమయంలో మేము చూపించాము.
అందువల్ల, బాటమ్ లైన్ మేము వివరించడానికి ప్రయత్నిస్తున్నాము, డిఫాల్ట్ పరామితి మరియు ఫంక్షన్ ఓవర్లోడింగ్ మొత్తం విషయం పరిష్కరించబడే వరకు కలపవచ్చు. వెళ్ళవచ్చు.
మరియు, వాస్తవానికి అది విఫలం కావచ్చు.
ఉదాహరణకు, ఇది, ఏదో ఒక విధంగా మనం ఇంతకు ముందు చూశాము.
కానీ మళ్ళీ, ఇక్కడ ఓవర్లోడ్ చేయబడిన మూడు ఫంక్షన్లు ఉన్నాయని ప్రత్యేకంగా గమనించండి; ఇది సున్నా పరామితి, ఇది ఒక పరామితి మరియు ఇది రెండు పారామితులు.
కాబట్టి, ఈ మూడు కాల్స్ ఖచ్చితంగా పరిష్కరించగలవు.
ఈ సాధ్యమయ్యే ఫంక్షన్ సెట్ యొక్క ప్రతి సందర్భంలో, ప్రతి ఒక్కటి ఒకే ఫంక్షన్ కలిగి ఉంటుంది; చెయ్యగలుగుట
కానీ, మీరు ఈ ఓవర్‌లోడ్ ఫంక్షన్‌లో ఒకదానికి డిఫాల్ట్ పరామితిని నమోదు చేసినప్పుడు, మీకు సమస్య ఉంది ఎందుకంటే ఇప్పుడు ఈ ఫంక్షన్ (ఫంక్షన్) లో పరామితి (పరామితి) ఉంది లేదా శూన్య పరామితి (పరామితి) కావచ్చు.
కాబట్టి, నేను సున్నా పరామితితో ఫంక్షన్ కాల్ వ్రాసినప్పుడు, మీరు ఈ రెండింటినీ మీ సాధ్యమయ్యే సెట్‌లో కలిగి ఉంటారు.
మరియు, పరామితి లేనందున.
మీరు ప్రయత్నించగల సరిపోలిక లేదు ఎందుకంటే పరామితి లేకపోతే, అసలు పరామితి రకం మరియు అధికారిక పరామితి రకం మధ్య మీరు ఏ విధమైన సరిపోలికను చూడబోతున్నారు.
అందువల్ల, కంపైలర్ పరిష్కరించదు.
మరియు, ఇది మళ్ళీ ఒక సాధారణ కంపైలర్ నుండి.
ఇది మీకు అందుతున్న దోష సందేశం.
మరియు, కంపైలర్ ఏమి చెబుతుందో చూడండి; ఓవర్‌లోడ్ అనేది ఒక ఫంక్షన్‌కు మసక కాల్.
మరియు, ఇది ఈ రెండు ఫంక్షన్ల మధ్య పరిష్కరించలేమని చెప్పింది.
అందువల్ల, మీరు ఓవర్‌లోడ్‌తో డిఫాల్ట్ పారామితులను ఉపయోగించినప్పుడు, మీరు ఓవర్‌లోడింగ్‌ను చూడలేరని గుర్తుంచుకోవాలి లేదా డిఫాల్ట్ పరామితిని చూడలేరు.
వేర్వేరు ఓవర్‌లోడ్‌లకు కారణమయ్యే డిఫాల్ట్ పారామితులను మీరు చూడాలి మరియు అవి వేర్వేరు ఓవర్‌లోడ్‌లు అయినా, మేము వివరించే యంత్రాంగం యొక్క ఫ్రేమ్‌వర్క్ ద్వారా వాటిని నిజంగా పరిష్కరించవచ్చు.
కాబట్టి ఇది ఇది; ఇవి లక్షణాలు.
కాబట్టి, చివరికి నేను ఈ మాడ్యూల్‌లో సి ++ భాష యొక్క ప్రధాన అంశాన్ని పరిష్కరించడానికి ప్రయత్నించానని, ఇది ఫంక్షన్ ఓవర్‌లోడింగ్ అని చెప్పాలనుకుంటున్నాను.
మొదట, డిఫాల్ట్ పారామితుల యొక్క భావనను మేము పరిగణనలోకి తీసుకున్నాము, ఇది మేము తరువాత వివరించాము, ఇది ఓవర్లోడింగ్ ఫంక్షన్ యొక్క ప్రత్యేక సందర్భం.
డిఫాల్ట్ పారామితులు వాటి డిఫాల్ట్ విలువలను అందించడానికి మరియు ఫంక్షన్ లైబ్రరీలను ఉపయోగించడాన్ని సులభతరం చేయడానికి పెద్ద సంఖ్యలో పారామితులతో ఫంక్షన్లను వ్రాయడం చాలా సులభం చేస్తాయి.
మరియు, ఫంక్షన్ ఓవర్‌లోడింగ్ అనేది మరొక పారామితి రకాలు భిన్నంగా ఉన్నంత వరకు ఒకే ఫంక్షన్ పేరుతో బహుళ ఫంక్షన్లను వ్రాయడానికి అనుమతించే మరొక లక్షణం.
అందువల్ల, ఈ విషయంలో మేము వివిధ ప్రత్యేకతలను పరిశీలించాము.
మరియు, మేము ప్రాథమిక స్టాటిక్ పాలిమార్ఫిజం గురించి మాట్లాడాము.
మరియు ముఖ్యంగా, మేము అర్థం చేసుకున్న యంత్రాంగాన్ని కూడా చర్చించాము; ఓవర్లోడ్ కోసం వివిధ విధులను పరిష్కరించగల యంత్రాంగం యొక్క చట్రాన్ని మేము చర్చించాము.
దీనితో, మేము ఈ మాడ్యూల్‌ను ముగించాము.
మరియు, తరువాతి వాటిలో మేము అదే భావనను కొనసాగిస్తాము.
మరియు, ఆపరేటర్ల విషయంలో C ++ లో కూడా ఇలాంటి ఓవర్‌లోడింగ్ భావనను అమలు చేయవచ్చని చూడండి, దీనిని ఆపరేటర్ ఓవర్‌లోడింగ్ అని పిలుస్తారు.
inhouse/NPTEL/PreFinal/c++/Telugu/27 ProgramminginCplusplus_Constructors, Destructors and Object Lifetime (Lecture 23)-wtuks_f3vP4.txt
View file @ 956c0d4e
 1. సి ++  ప్రొగ్రామ్మింగ్ మోడులెస్  13 అంశం లొకి స్వాగతము.
2. ఈ మాడ్యూల్‌లో, వస్తువులు ఎలా సృష్టించబడుతున్నాయి లేదా ప్రారంభించబడ్డాయి, మరియు అవి ఎలా ఉపయోగించబడుతున్నాయో అవి ఎలా నాశనం చేయబడతాయి లేదా ప్రారంభించబడతాయో అర్థం చేసుకోవడం గురించి మరియు ఆ మొత్తం జీవిత ప్రక్రియలో మనం మాట్లాడుతాము. సమయం అంటే వస్తువు ఉంటుంది.
3. C ++ లోని ఆబ్జెక్ట్-ఓరియెంటెడ్ ఫ్యూచర్స్ సందర్భంలో, తరగతులను ఎలా నిర్వచించవచ్చో మరియు ఒక నిర్దిష్ట తరగతి యొక్క వస్తువులను ఎలా వేగవంతం చేయవచ్చో మేము ఇప్పటికే చూశాము.
4. మేము ఇప్పటికే డేటా సభ్యులు మరియు పద్ధతులను పరిశీలించాము మరియు సమాచారాన్ని దాచడానికి, డిజైన్‌లో డేటా స్పెసిఫికేషన్లను ప్రత్యేకంగా ప్రైవేట్‌గా చేయడానికి మొత్తం నమూనా గురించి మాట్లాడాము. స్పెసిఫికేషన్ మరియు స్పెసిఫికేషన్ ఆంక్షలు మరియు తయారుచేసే పద్ధతుల యొక్క ప్రాథమిక రూపకల్పన ప్రక్రియకు ఇంటర్‌ఫేస్‌ను అందిస్తుంది. ప్రజా.
5. ఇప్పుడు, మేము దానిపై విస్తరిస్తాము మరియు మరింత మాట్లాడతాము, ఇది తరగతి యొక్క నిర్మాణం లేదా విభిన్న వస్తువుల బ్లూప్రింట్ పరంగా డిజైన్ అంశంపై ఎక్కువగా ఉంది.
6. ఇప్పుడు ప్రస్తుత మాడ్యూల్ రన్‌టైమ్ ఎగ్జిక్యూషన్‌లో ప్రత్యేకంగా కనిపిస్తుంది, ఒక వస్తువు యొక్క రన్‌టైమ్ ప్రవర్తన జీవితానికి వచ్చినప్పుడు తెలుసుకోవడానికి ప్రయత్నిస్తుంది మరియు ఇది జీవితంలో ఎంతకాలం ఉంటుంది? మరియు ఒక వస్తువు యొక్క జీవిత చివరలో ఏమి జరుగుతుంది? మేము ఈ చర్చలన్నిటితో ప్రారంభిస్తాము, ఇది మీ ప్యానెల్ యొక్క ఎడమ వైపున చూడగలిగే రూపురేఖలు.
7. కాబట్టి మనం ఇప్పటికే ప్రవేశపెట్టిన స్టాక్ యొక్క మునుపటి ఉదాహరణలలో ఒకదాన్ని ప్రస్తావిద్దాం.
8. ఈ స్టాక్‌లో ఇద్దరు డేటా సభ్యులు ఉంటారు, స్టాక్ ఎలిమెంట్స్‌ను నిల్వ చేయడానికి అక్షరాల శ్రేణి, టాప్ ఎలిమెంట్ యొక్క ఇండెక్స్ మరియు దాని నాలుగు LIFO పద్ధతులను బహిరంగంగా ఉంచే హెడర్ మార్కర్., ఈ స్టాక్‌ను ఉపయోగించడానికి LIFO ఇంటర్ఫేస్ ఖాళీగా ఉంది, పుష్, పాప్ మరియు టాప్. మరియు ఇక్కడ మేము స్ట్రింగ్ రివర్స్ చేయడానికి ఈ స్టాక్ యొక్క ఉపయోగాన్ని చూపుతాము.
9. ఇప్పుడు, మేము దీనిని పరిశీలిస్తే, ఇక్కడ మనం ఉపయోగిస్తున్నట్లు ఒక వస్తువును సృష్టించడానికి వెంటనే ఈ స్టాక్‌ను సృష్టిస్తుందని మీరు కనుగొంటారు, కాని మేము స్టాక్ వస్తువును సృష్టించిన వెంటనే, రివర్స్ స్ట్రింగ్ ఆపరేషన్ చేయడానికి దాన్ని ఉపయోగించలేము మేము ఇక్కడ చేస్తున్నాం, మధ్యలో మనం స్టాక్ వన్ సరైన ప్రారంభమని నిర్ధారించుకోవాలి, అంటే S తక్షణం అయిన తర్వాత నేను తెలుసుకోవాలి, ఈ సమయంలో టాప్ మార్కర్ యొక్క విలువ ఏమిటో తెలుసుకోండి.
10. ఇది ఇప్పటివరకు ఎటువంటి ఆపరేషన్ చేయని పాయింట్, కాబట్టి మీరు ఒక స్టాక్ కేవలం కొన్ని ఖాళీ స్టాక్ (స్టాక్) కలిగి ఉన్న శూన్య స్టాక్‌తో సంభావితంగా సృష్టించబడిందని నిర్ధారించుకోవాలి. అందువల్ల, దాని హెడ్ మార్కర్ తక్కువగా ఉండాలి అగ్ర మార్కర్ -1 గా ఉండే శ్రేణిలోకి వెళ్ళగల మొదటి మూలకం కంటే.
11. అందువల్ల, ఈ కోడ్ పనిచేయడానికి, స్టాక్ వేరియబుల్ అయిన వెంటనే అసైన్‌మెంట్ ద్వారా టాప్ మార్కర్ యొక్క ప్రారంభ విలువను జోడించడం చాలా ముఖ్యం.
12. మీరు మరింత దగ్గరగా చూస్తే, మేము దీన్ని చేయగలమని మీరు గ్రహిస్తారు, ఎందుకంటే నేను దీనిని స్టాక్ వేరియబుల్‌గా నిర్వచించాను, డేటా సభ్యులుగా పబ్లిక్.
13. అందువల్ల, నేను టాప్_డేటా సభ్యుడిని సులభంగా యాక్సెస్ చేయగలను మరియు ఈ నియామకాన్ని చేయగలను, అందువల్ల మనం ఇక్కడ చూసినవి ఈ పరిష్కారంలో ఉన్నాయి. సమాచారాన్ని దాచిపెట్టే సూత్రాలకు విరుద్ధంగా ఉండే ఒక ప్రారంభాన్ని మేము కలిగి ఉన్నాము. మనం ఇంతకుముందు ఆహ్వానించిన లోపలి భాగాన్ని బహిర్గతం చేస్తుంది.
14. కాబట్టి, మనం ఎదురుగా ఉన్న పబ్లిక్ డేటా ఇక్కడ ఉపయోగించబడే కుడి కాలమ్‌కు వెళ్దాం, దీనికి విరుద్ధంగా మేము ప్రైవేట్ డేటాను ఉపయోగిస్తాము, మన సమాచారాన్ని దాచడానికి తిరిగి వెళ్తాము, తద్వారా మేము డేటాను ప్రైవేట్‌గా చేయగలము మరియు మనం సహజంగా చేస్తే, మేము ఇకపై ఇక్కడ వ్రాయలేము ఎందుకంటే మేము s.top_ = -1 వ్రాయడానికి ప్రయత్నిస్తే మీరు బాగా అర్థం చేసుకోవచ్చు; అప్పుడు కంపైలర్ ఈ ప్రోగ్రామ్‌ను కంపైల్ చేయదు, ఇది హెడర్ ఒక ప్రైవేట్ డేటా సభ్యుడు మరియు యాక్సెస్ చేయలేమని చెప్పడంలో లోపం ఇస్తుంది.
15. Init () అని పిలువబడే వేరే ఫంక్షన్ (init) ను పరిచయం చేయడం ద్వారా మేము ఆ సమస్యను పరిష్కరిస్తాము, దీనిని మేము ఇంటర్‌ఫేస్‌లో పబ్లిక్ పద్దతిగా ఉంచాము మరియు init () ప్రాథమికంగా టాప్ -1 ను ప్రారంభిస్తుంది. మరియు ఇక్కడ s.top = -1 చేయడానికి బదులుగా మేము init () అని పిలుస్తాము.
16. వారు అదే ప్రయోజనాన్ని అందించాలి.దీనితో మనం ఆబ్జెక్ట్-ఓరియెంటెడ్ డిజైన్‌ను తప్పనిసరిగా అనుసరించాల్సిన సమాచారాన్ని దాచడం యొక్క సూత్రాన్ని కొనసాగించవచ్చు మరియు పరిష్కారం పనిచేస్తుందని నిర్ధారించుకోవచ్చు.
17. మరియు ఇలా చేయడం వల్ల కలిగే ప్రయోజనం ఏమిటంటే, మీరు ఈ రెండు పంక్తులను పోల్చవచ్చు, ఉదాహరణకు డేటా సభ్యుడు పబ్లిక్‌గా ఉన్నప్పుడు యాక్సెస్ స్పెసిఫికేషన్ మాడ్యూల్ పరంగా మేము ఇంతకుముందు వివరించినట్లు డేటా సభ్యుడు పబ్లిక్‌గా ఉంటే ఏదైనా సృష్టించడం సాధ్యమైతే, అనుకోకుండా s.top మధ్యలో కొంత విలువకు కేటాయించినట్లయితే సంభావ్య ప్రమాదం.
18. అయినప్పటికీ, మేము సమాచారాన్ని దాచడం అనే సూత్రానికి తిరిగి వచ్చినప్పుడు, అటువంటి కోడ్ ప్రైవేట్ డేటాతో తిరిగి ఇవ్వబడదు ఎందుకంటే ఇది సంకలన లోపంగా మారుతుంది.
19. ఆ విధంగా డేటా సభ్యుడిని ప్రైవేట్‌గా చేయడం మరియు ప్రారంభ ఫంక్షన్‌ను అందించడం ప్రారంభ సమస్యకు మంచి పరిష్కారం, మరియు మేము ఈ ప్రైవేట్ డేటాతో మరింత పని చేయాలనుకుంటున్నాము.
20. దీనితో మనము ఆబ్జెక్ట్-ఓరియంటెడ్ డిజైన్(object-oriented design) తప్పనిసరిగా అనుసరిస్తూ, పరిష్కారం పని చేస్తుంది.
21. ఇప్పుడు మరియు వెళ్దాం.
22. ఎడమ కాలమ్‌లో, శీర్షికను ప్రారంభించడానికి init () పద్ధతిలో సహా ప్రైవేట్ డేటా మరియు పబ్లిక్ పద్ధతులను కలిగి ఉన్న మీరు చూసిన కోడ్‌ను మీరు చూస్తారు.
23. మేము చూసినట్లుగా ఇది క్లీన్ ఇనిషియలైజేషన్‌ను అందిస్తుంది, అయితే అప్లికేషన్ init () కి కాల్ చేయడం మరచిపోతే ప్రశ్న ఖచ్చితంగా ఉంటుంది, లేదా అప్లికేషన్ తప్పు స్థితిలో పిలుస్తే? అనువర్తనం స్ట్రింగ్‌ను రివర్స్ చేయడానికి ప్రయత్నిస్తున్నందున మరియు ఇది ఖాళీ, టాప్, పాప్ మరియు పుష్‌లను కలిగి ఉన్న LIFO నిర్మాణం అని తెలుసు కాబట్టి ఇది ప్రయోజనం లేని అనువర్తనం కోసం ఉద్దేశించిన ఈ init () ని పిలవడానికి అనువర్తనం గుర్తుంచుకుంటే, ఇవి నాలుగు పద్ధతులు కానీ, వీటన్నింటికీ పిలుపుగా పనిచేయడం, కానీ అది తప్పిపోతే, సహజంగానే మనకు అగ్రస్థానం ఉంటుంది. ఏకపక్ష విలువ ఉంది, అందువల్ల మొత్తం ప్రోగ్రామ్ చాలా అనూహ్య ప్రవర్తనను ఇస్తుంది.కాబట్టి మీరు దీని కంటే మెరుగైన పని చేయగలరా అని మీరు ఒక ప్రశ్న అడగండి, మేము దానిని పేర్చగలమా. వాస్తవానికి ఇది నిర్వచించబడినప్పుడు, ఈ ప్రారంభ కాల్‌ను ఎలాగైనా చేయగలిగితే అది తక్షణ సమయంలో సరైనది.
24. కన్స్ట్రక్టర్ యొక్క వ్యవస్థ ప్రాథమికంగా ఈ పరిష్కారాన్ని అందిస్తుంది.
25. C ++ ఒక యంత్రాంగాన్ని అందిస్తుంది, దీని ద్వారా మీరు ఒక వస్తువును ఒక నిర్దిష్ట ఫంక్షన్‌కు పిలిస్తే, ఈ సమయంలో కన్స్ట్రక్టర్ సరిగ్గా ఆరంభించబడతారు మరియు ఈ కన్స్ట్రక్టర్ యొక్క ఉపయోగం అవసరం సభ్యుల విలువలను ప్రారంభించడానికి డేటాను ఉపయోగించవచ్చు.
26. ఈ ఉదాహరణను చూస్తే, మనకు init () కాల్ లేదు, అది కాదు. బదులుగా ఈ వస్తువు యొక్క కన్స్ట్రక్టర్ అనే కొత్త పద్ధతిని ప్రవేశపెట్టాము.
27. ఇది నిర్మాత అని మీకు ఎలా తెలుసు? ఇది క్లాస్ పేరుకు సమానమైన పేరుతో ఒక నిర్దిష్ట సంతకాన్ని కలిగి ఉంది, కాబట్టి ఇది కన్స్ట్రక్టర్ అని మీకు తెలిసిన పేరు దానిలో వస్తువులను ఉంచడానికి వేరే మార్గాన్ని కలిగి ఉంది మరియు మేము దానిని చర్చిస్తాము.
28. కానీ, మేము ఇక్కడ చెప్పేది ఏమిటంటే, మేము డేటా సభ్యుడిని పైకి కదిలి, 1 ను ప్రారంభ విలువగా ఉంచాలి.
29. రెండవది, ఇది శ్రేణిని ప్రారంభించాల్సిన అవసరం లేదు ఎందుకంటే ఇది పుష్ మరియు పాప్‌గా ఉపయోగించబడుతుంది.
30. కానీ ప్రయోజనం ఏమిటంటే, మేము ఒక కన్స్ట్రక్టర్‌ను నిర్వచించినట్లయితే, నియంత్రణ ఈ నిర్దిష్ట బిందువును దాటిన వెంటనే, ఆ వస్తువు ఆటోమేటిక్ కాల్‌గా మారినప్పుడు, ఈ పద్ధతి ద్వారా ఒక అవ్యక్త కాల్ ఉంటుంది., మరియు ఈ కాల్ వాస్తవానికి శీర్షం అని నిర్ధారించుకుంటుంది -1 కు కేటాయించబడింది.
31. అందువల్ల, మేము ఈ సమయంలో ఈ కాల్ నుండి తిరిగి వచ్చినప్పుడు, మనకు ఇప్పటికే అవును -1 యొక్క అగ్ర ప్రారంభ ఉంది మరియు ఇది, ఇది అంతర్లీన ప్రారంభ నిర్మాణం యొక్క సౌందర్యం.
32. ఇక్కడ మరిన్ని ఉదాహరణలు చెప్తాము, కన్స్ట్రక్టర్ ఉన్న స్టాక్‌తో అదే ఉదాహరణతో మళ్ళీ రండి మరియు ఎడమ వైపున కన్స్ట్రక్టర్ పైభాగాన్ని ప్రారంభిస్తారని మనకు తెలుసు, నేను ఇక్కడ చూపిస్తున్నదాన్ని చేస్తాను.
33. కన్స్ట్రక్టర్ తరగతిలో భాగంగా వ్రాయబడింది, ఈ సమయంలో మీరు గుర్తుంచుకుంటారు.
34. కానీ ఇప్పుడు, మేము దానిని తరగతి వెలుపల వ్రాసాము, ఇది స్టాక్ (స్టాక్) :: స్టాక్ (స్టాక్) :, దీనికి పేరు పెట్టడం మీరు ఏదైనా తరగతి (తరగతి) సభ్యునికి పేరు కలిగి ఉన్నారని గుర్తుంచుకుంటారు. తరగతి పేరు.
35. కాబట్టి, ఇది క్లాస్ స్టాక్ పేరు, ఇది కన్స్ట్రక్టర్ పేరు.
36. మన వద్ద ఉన్నది కన్స్ట్రక్టర్ యొక్క శరీరం, మరియు ఆ శరీరంలో మేము టాప్ -1 ను ప్రారంభించాము మరియు తరువాత మిగిలిన స్టేట్మెంట్.
37. మేము ఇలా చేస్తే, ఇక్కడ స్టాక్ వేగవంతం అయిన వెంటనే పైభాగంలో ఈ సమయంలో కాల్ చేయబడిన ఒక కోర్ట్ ఉంది, ఇది నియంత్రణ ఇక్కడ తిరిగి వస్తుందని మీరు చూస్తారు మరియు అది స్ట్రింగ్ యొక్క విలోమం జరుగుతుంది.
38. శీర్షిక స్పష్టంగా ప్రారంభించబడుతున్న చాలా స్పష్టమైన ప్రక్రియ, ఇది మరొక డేటా సభ్యుని యొక్క స్వయంచాలక డిఫాల్ట్ ప్రారంభించడం, ఇది శ్రేణి, ఎందుకంటే ఇది ఇచ్చిన స్థిర పరిమాణం (శ్రేణి).
39. ఇప్పుడు, మీరు అక్షరానికి పాయింటర్ అయితే స్వయంచాలక శ్రేణి (శ్రేణి) గా కాకుండా చిన్న మార్పు చేద్దామా అని చూద్దాం, కాబట్టి మనం చేయడానికి ప్రయత్నిస్తున్నది ఈ శ్రేణిని (శ్రేణి) డైనమిక్‌గా మార్చడం) తయారు చేయాలి.
40. మనము దేనిని కన్స్ట్రక్టర్ (constructor) యొక్క బాడి, మరియు ఆ బాడి లో మొదట మేము -1 మరియు తరువాత cout స్టేట్మెంట్ మిగిలిన.
41. కాబట్టి సహజంగా స్టాక్ కోడ్‌లో పైకి ప్రారంభించడం అదే విధంగా ఉంటుంది, కాని ఇప్పుడు మనం అర్రే పాయింటర్‌ను కూడా ప్రారంభించాలి, దీన్ని డైనమిక్‌గా కేటాయించడం ద్వారా మేము చేస్తాము.
42. ఈ సమయంలో వ్రాసే ప్రారంభ విధానాన్ని అర్థం చేసుకుందాం.
43. ప్రారంభంలో మేము మొదట డేటా సభ్యుని పేరును వ్రాస్తాము మరియు తరువాత ఒక జత కుండలీకరణాల్లో మనం ప్రారంభీకరణగా ఉపయోగించాలనుకునే విలువను వ్రాస్తాము.
44. మేము డేటాను పరిశీలిస్తే, ఇది డేటా పాయింటర్ మరియు మీకు తెలిసినట్లుగా ఈ వ్యక్తీకరణ ఆపరేటర్ 10 అక్షరాల యొక్క కొత్త శ్రేణిని (శ్రేణి) కేటాయింపును పాయింటర్ రకంగా పాయింటర్ రకంగా ఉపయోగిస్తుంది.ఆ శ్రేణిని తిరిగి ఇస్తుంది మరియు ఆ పాయింటర్ డేటాలో ప్రారంభ విలువగా సెట్ చేయబడుతోంది.
45. ఇది మేము ఇంతకు ముందు చూడని విషయం.
46. మునుపటి అప్పగింత శైలి, ఇక్కడ మేము top_ = 1 అని చెప్తాము, లేదా డేటా (డేటా) = కొత్త చార్ [10] ఇలా చెబుతాము.
47. మీరు ఇక్కడ ఒక కన్స్ట్రక్టర్‌ను ఉపయోగిస్తున్నప్పుడు మరియు కన్స్ట్రక్టర్ (కన్స్ట్రక్టర్) సంతకం చేసిన తర్వాత మీకు పెద్దప్రేగు రూపంలో ఒక సెపరేటర్ ఉందని మరియు మీరు అవసరం అని గమనించండి. కొలోన్ మరియు కన్స్ట్రక్టర్ బాడీ యొక్క ప్రారంభ వంకర బ్రాకెట్ల మధ్య డేటా సభ్యుల ప్రారంభం యొక్క పూర్తి జాబితాను రాయండి.
48. ఇక్కడ మీరు కోమా లోపల డేటా సభ్యుడిని కోమాతో వేరు చేసిన తర్వాత వ్రాస్తారు మరియు ప్రతి డేటా సభ్యుడు ఒక జత బ్రాకెట్లలోని తర్వాత మీరు వాటిని ప్రారంభించాలనుకుంటున్న విలువను వ్రాస్తారు.
49. వాస్తవానికి, ప్రతి డేటా సభ్యుడు ఒక్కసారి మాత్రమే ఇక్కడ ఉండగలడు మరియు అన్ని డేటా సభ్యులను ప్రారంభించాల్సిన అవసరం లేదు, కానీ మేము వారందరినీ కూడా ప్రారంభించగలము, ఈ సందర్భంలో మనకు కావలసినట్లే.
50. స్టాక్ యొక్క ఈ ప్రత్యేక సంస్కరణకు ఏమి జరుగుతుంది? నియంత్రణను ఈ కన్స్ట్రక్టర్ అని పిలిచే పాయింట్ గుండా వెళుతున్నప్పుడు, స్టాక్ ఆబ్జెక్ట్ యొక్క పైభాగం -1 కు ప్రారంభమవుతుంది, పరిమాణం 10 (శ్రేణి) యొక్క అక్షర శ్రేణి డైనమిక్ కేటాయింపును కలిగి ఉంటుంది మరియు దాని పాయింటర్ దీనికి సెట్ చేయబడుతుంది డేటా, ఆపై స్టాక్ కాల్, ఈ సందేశం ముద్రించబడుతుంది మరియు నియంత్రణ పూర్తయినప్పుడు స్ట్రింగ్ రివర్స్ ఫార్వర్డ్ ఉన్న చోటికి తిరిగి వస్తుంది. పెరుగుతుంది.
51. దీనితో మనం కన్స్ట్రక్టర్‌ను డేటా సభ్యునిని అనేక రకాలుగా ప్రారంభించడానికి ఉపయోగించవచ్చని మరియు C ++ యొక్క యంత్రాంగం ఆ వస్తువునే వస్తువు అని నిర్ధారిస్తుంది. ప్రారంభించడం.
52. స్టాకింగ్ డేటా భాగం లేదా స్టాక్ టాప్ మార్కర్ భాగం కోసం ప్రారంభించడం గుర్తుకు రావడానికి లేదా చేయడానికి తలకి అనువర్తనం హక్కు లేదు, ఇది కన్స్ట్రక్టర్ మరియు కంపైలర్ యొక్క బాధ్యత అవుతుంది.ఈ కన్స్ట్రక్టర్‌ను అవ్యక్తంగా పిలుస్తుంది.
53. కాల్ చేయడానికి ఇది గుర్తుంచుకోవాలి, సహేతుకమైన సమయంలో ప్రతిసారీ పిలువబడుతుంది.
54. ఇప్పుడు, ఒక కన్స్ట్రక్టర్ ఏమి చేస్తాడో, మనం చూసినట్లుగా, ఒక కన్స్ట్రక్టర్ తప్పనిసరిగా సభ్యుల ఫంక్షన్, కానీ దీనికి సభ్యుల ఫంక్షన్‌తో చాలా తేడాలు ఉన్నాయి.
55. అందువల్ల, సభ్యుల ఫంక్షన్ అయినందున, ఇది ఏదైనా సభ్యుల ఫంక్షన్ లాగా ఈ పాయింటర్‌ను కలిగి ఉంటుంది, కాని దాని పేరు, నేను ఇప్పటికే చెప్పినట్లుగా, ప్రత్యేకంగా తరగతి పేరు ఇతర సభ్యుల ఫంక్షన్లకు అలా కాదు.
56. కన్స్ట్రక్టర్ యొక్క పని వస్తువును సృష్టించడం మరియు దానిని ప్రారంభించడం ఎందుకంటే రిటర్న్ రకం చూపబడటం లేదని మీరు ఇప్పటికే గమనించి ఉండవచ్చు, ఇది గణన చేయడం మరియు మీకు విలువను తిరిగి ఇవ్వడం కాదు.
57. కన్స్ట్రక్టర్ ఒక ఫంక్షన్ అయినప్పటికీ, అది ఏ విలువను ఇవ్వదు మరియు తిరిగి వచ్చే రకం కూడా శూన్యమైనది కాదు.
58. నేను దేనినీ తిరిగి ఇవ్వడం లేదని చెప్పే సున్నా రిటర్న్ రకాలను కలిగి ఉన్న ఫంక్షన్‌ను మీరు చూశారు, కాని కన్స్ట్రక్టర్ అలా చేయడు.
59. కన్స్ట్రక్టర్‌లో మీరు చెప్పినదానిలో ఏదైనా విలువను తిరిగి ఇవ్వడానికి యంత్రాంగం లేదు, కాబట్టి పేర్కొనడానికి రిటర్న్ రకం లేదు.
60. రిటర్న్ రకం లేనందున, రిటర్న్ స్టేట్మెంట్ లేదు, కాబట్టి మీకు రిటర్న్ స్టేట్మెంట్ లభించదు. సాధారణ సభ్యుల ఫంక్షన్ మాదిరిగా కాకుండా, రిటర్న్ స్టేట్మెంట్ ఎక్కడ ఉంటుంది లేదా మీ రిటర్న్ రకం సున్నా అయితే రిటర్న్ సూచించవచ్చు, కానీ a కన్స్ట్రక్టర్‌కు రిటర్న్ స్టేట్‌మెంట్ అవసరం లేదు, అది పరోక్షంగా తిరిగి వస్తుంది.
61. అదనంగా, కన్స్ట్రక్టర్‌కు ప్రారంభ జాబితా ఉంటుంది, ఇది కుండలీకరణాల్లోని డేటా సభ్యుల జాబితాకు ప్రారంభ విలువ విలువను వివరించాను.
62. జాబితా కన్స్ట్రక్టర్ బాడీ ప్రారంభంతో ప్రారంభమయ్యే పెద్దప్రేగుతో మొదలవుతుంది మరియు ఇది ఇతర సభ్యుల ఫంక్షన్లకు సమాంతరంగా ఉండదు.
63. కన్స్ట్రక్టర్‌కు స్పష్టమైన కాల్ లేదు, దానిని అత్యవసరంగా పిలుస్తారు.నేను ఈ వస్తువును ఇన్‌స్టాంట్ చేసిన వెంటనే కన్స్ట్రక్టర్ అని పిలుస్తారు, ఇక్కడ ప్రకృతిలో కాల్ ఆబ్జెక్ట్ (ఆబ్జెక్ట్) అవసరం. స్పష్టంగా ఉన్నాయి.
64. మేము ఉదాహరణను చూస్తాము, కాని చివరికి ఒక కన్స్ట్రక్టర్ యొక్క ఉదాహరణ పారామితి లేదని మనం చూసిన ఏదైనా పరామితిని కలిగి ఉంటుంది, కానీ ఇతర సభ్యుల ఫంక్షన్ వంటి కన్స్ట్రక్టర్. ఎన్ని పారామితులను కలిగి ఉండవచ్చు మరియు ఒక కన్స్ట్రక్టర్ లోడ్ చేయవచ్చు ఏ ఇతర సభ్యుల ఫంక్షన్ లాగా.
65. కన్స్ట్రక్టర్ అనేది ఒక ప్రత్యేకమైన ఫంక్షన్, ఇది అంతర్లీన వస్తువులను అన్ని సమయాలలో ప్రారంభించడానికి ప్రాథమికంగా మాకు సహాయపడుతుంది.
66. మీరు C ++ లో నిర్వచించగలిగే వివిధ రకాల కన్స్ట్రక్టర్లను చూసే ఒక జత స్లైడర్‌ల ద్వారా మేము త్వరగా తిరుగుతాము, పారామిటరైజ్డ్ కన్స్ట్రక్టర్స్ (కన్స్ట్రక్టర్) అని పిలువబడే కన్స్ట్రక్టర్‌లో మీరు పారామితులను (కన్స్ట్రక్టర్లను) కలిగి ఉండవచ్చు.
67. మేము ఇప్పటికే చూసిన డబుల్ రకాలను మళ్ళీ చూపిస్తున్నాము, కాబట్టి ఈ పారామితి విలువ ప్రారంభ సభ్యుల జాబితా ద్వారా డేటా సభ్యులను ప్రారంభించడానికి ఉపయోగపడుతుంది.
68. అప్పుడు కన్స్ట్రక్టర్ ఆవశ్యకతతో అవ్యక్తంగా పిలువబడుతుంది మరియు సాధారణంగా దీనికి రెండు వాక్యనిర్మాణాలు ఉపయోగించబడతాయి.
69. వాక్యనిర్మాణం ఒక నిర్దిష్ట ఫంక్షన్ కాల్ రకాన్ని కలిగి ఉంది, ఇక్కడ మీరు ఆబ్జెక్ట్ పేరు మరియు బ్రాకెట్లను ఉంచారు.మీరు కన్స్ట్రక్టర్ యొక్క పారామితులను కన్స్ట్రక్టర్ కోసం నిర్వచించిన క్రమంలో ఉంచుతారు.
70. కాబట్టి నేను ఈ ప్రత్యేకమైన ఆబ్జెక్ట్ ఇన్‌స్టాంటియేషన్‌ను వ్రాసేటప్పుడు, నియంత్రణ ఈ పాయింట్ గుండా వెళుతున్నప్పుడు కాంప్లెక్స్ యొక్క కన్స్ట్రక్టర్ అని పిలుస్తారు, ఇక్కడ 4.2 మళ్ళీ విలువగా, 5.3 IM విలువగా వెళ్ళాలి. ఇది దానిలోకి మరియు దానితో పాటు వెళ్తుంది దానితో వస్తువు నిర్మించబడుతుంది మరియు వస్తువు c గా సెట్ చేయబడుతుంది.
71. దీనికి మించి, మీరు c.re చేస్తే, మీరు విలువ 4.2 ను పొందాలి, అనగా, ఈ ముద్రణ ప్రకటన ఇక్కడ చూపబడింది, ఇక్కడ మేము సంక్లిష్ట సంఖ్య సంక్లిష్ట సంజ్ఞామానాన్ని ముద్రించి దాని ప్రమాణాన్ని లెక్కిస్తాము.
72. అదేవిధంగా, నేను సి భాగాన్ని సి చేస్తే నాకు 5.3 లభిస్తుంది.
73. రెండవది, d విషయంలో మనం వేరే ప్రత్యామ్నాయ సంజ్ఞామానం లో ఒకదాన్ని మాత్రమే చూపిస్తే, దానిని జాబితా ప్రారంభించడం అంటారు.
74. అంటే, మీరు ఒక కన్స్ట్రక్టర్‌లో బహుళ పారామితులను కలిగి ఉంటే, మీరు ఈ పారామితుల యొక్క ప్రారంభ విలువలను జాబితా సంజ్ఞామానం లో ఒక జత వంకర కలుపులు (సూచన సమయం: 21:22) మరియు వస్తువుతో సూచించవచ్చు. మీరు ప్రారంభ చిహ్నాన్ని ఉపయోగించవచ్చు పేరు తరువాత.
75. రెండూ ఒకే ప్రభావాన్ని కలిగి ఉంటాయి, అవి ఒకే ఆపరేషన్ చేయడానికి ప్రత్యామ్నాయ సంజ్ఞామానం మాత్రమే.
76. కాబట్టి, ఒకటి లేదా అంతకంటే ఎక్కువ పారామితులను కలిగి ఉన్న కన్స్ట్రక్టర్లను పారామీటర్ చేయబడిన కన్స్ట్రక్టర్స్ అంటారు.
77. ప్రస్తుతం, ప్రతి విషయంలో కన్స్ట్రక్టర్ మరొక సభ్యుల ఫంక్షన్, లేదా సి ++ లో ప్రత్యేకంగా మరో ఫంక్షన్ మాత్రమే ఉంది, కాబట్టి, నాకు పారామితులు ఉంటే, నేను డిఫాల్ట్ విలువను కూడా ఉంచగలను.
78. అందువల్ల, నేను వేర్వేరు డిఫాల్ట్ విలువలతో ఒక కన్స్ట్రక్టర్‌ను కలిగి ఉండగలను, కాబట్టి మీరు ఇక్కడ రెండు పారామితులతో మళ్ళీ ఒక ఉదాహరణను చూపిస్తారు మరియు డిఫాల్ట్ విలువలు 0.0 వాటిని.
79. ఫంక్షన్ల కోసం డిఫాల్ట్ పరామితి యొక్క అన్ని నియమాలు మరియు ఫంక్షన్లను ప్రారంభించడానికి డిఫాల్ట్ పరామితి ఆధారంగా మూడు వేర్వేరు మార్గాల్లో వస్తువులను సృష్టించడానికి మనం ఇదే కన్స్ట్రక్టర్‌ను ఉపయోగించవచ్చు.నేను నేను మొదటి పారామితిని మాత్రమే పేర్కొనగల రెండు పారామితులను ఉంచగలను లేదా నేను పారామితులను పేర్కొనలేను.
80. పేర్కొన్న పారామితులు డిఫాల్ట్ విలువలను తీసుకుంటాయి మరియు తదనుగుణంగా మీరు ప్రింట్ చేస్తే సంబంధిత వస్తువులు సృష్టించబడినప్పుడు మీరు వాటిని చూడగలరు.
81. డిఫాల్ట్ పారామితులతో కూడిన ఫంక్షన్ కోసం మేము నేర్చుకున్న అన్ని నియమాలు, ఆ పారామితులన్నింటినీ డిఫాల్ట్ చేసే మొత్తం విధానం కన్స్ట్రక్టర్లకు కూడా వర్తిస్తుందని ఇది చూపిస్తుంది.
82. ఇది ఇక్కడ మరొక ఉదాహరణ, మేము తిరిగి స్టాక్ చేయబోతున్నాం, కాబట్టి దీని కోసం ఒక కన్స్ట్రక్టర్‌ను డిఫాల్ట్ సైజు_టి విలువ 10 (సైజు_టి = 10) తో చూపిస్తాము.
83. కన్స్ట్రక్టర్ నిర్వచనంలో, మనకు ఒక పరామితి ఉంది, కాబట్టి నాకు కావాలంటే, నేను ఈ పారామితి విలువను ఉదాహరణకు ఇక్కడ పాస్ చేయగలను, అప్పుడు మేము ఆ స్ట్రింగ్ యొక్క పొడవును తీసుకుంటాము, మనం రివర్స్ చేయదలిచిన వస్తువును నిర్మిస్తున్నాము ఎందుకంటే ఈ స్టాక్ ఉంటే ఇచ్చిన స్ట్రింగ్ STR ను రివర్స్ చేసి, స్ట్రింగ్ యొక్క పొడవు ద్వారా రివర్స్ చేయండి ఎక్కువ పరిమాణం అవసరం లేదు, కాబట్టి మనం దానిని ఉపయోగించుకోవచ్చు మరియు స్ట్రింగ్‌కు తగినట్లుగా పెద్దదిగా ఉండే స్టాక్‌ను సృష్టించవచ్చు మరియు ఇక్కడ మీరు కన్స్ట్రక్టర్‌గా ముద్రించడం ద్వారా చూడవచ్చు సృష్టించబడిన స్టాక్ పరిమాణం ఎంత.
84. నేను దానిని ఉపయోగించకపోతే, పరిమాణం ఎలా ఉండాలో మేము ఈ సమాచారాన్ని అందించకపోతే, మనం స్టాక్ వ్రాస్తే అది ఖచ్చితంగా డిఫాల్ట్ పారామితి విలువ 10 మరియు 10 మూలకాల స్టాక్ తీసుకుంటుంది. (స్టాక్).
85. కాబట్టి, ఇవి మన వద్ద ఉన్న కన్స్ట్రక్టర్ల యొక్క వివిధ ఉదాహరణలు.
86. ఏదైనా తరువాతి C ++ సమూహ ఫంక్షన్ల మాదిరిగానే, కన్స్ట్రక్టర్లను కూడా ఓవర్‌లోడ్ చేయవచ్చు, అంటే ఒక తరగతి ఒకటి కంటే ఎక్కువ కన్స్ట్రక్టర్లను కలిగి ఉంటుంది, ఎందుకంటే దాని పేరు తప్పనిసరిగా కన్స్ట్రక్టర్ కావడం తరగతి పేరు. అదే విధంగా ఉంటుంది, కాబట్టి నేను ఉంటే ఇద్దరు కన్స్ట్రక్టర్లను వ్రాయాలనుకుంటున్నారు, వారికి ఒకే పేరు అవసరం, కానీ పారామితులు లేదా టైప్ పారామితులలో తేడా ఉన్నంత వరకు అలా చేయడానికి అనుమతి ఉంది.
87. ఫంక్షన్ ఓవర్‌లోడింగ్ యొక్క అన్ని నియమాలు మనం నేర్చుకున్నట్లే, అధిక-లోడ్ చేసిన కన్స్ట్రక్టర్ సందర్భంలో వర్తిస్తాయి.
88. కాబట్టి ఇక్కడ మేము ఒక కాంప్లెక్స్ కోసం మూడు కన్స్ట్రక్టర్లను చూపిస్తున్నాము, అది రెండు పారామితులను తీసుకొని రెండింటినీ తిరిగి అమలు చేస్తుంది, ఒకటి శ్రేణులను మాత్రమే తీసుకుంటుంది మరియు ఏమీ తీసుకోదు.
89. మరియు మేము ఈ పారామితులను ఉపయోగిస్తున్నాము, ఇది పరిష్కరించాల్సిన పారామితుల సంఖ్య యొక్క మూడు ఆవశ్యకత దృష్ట్యా ఒక నిర్దిష్ట రూపం కన్స్ట్రక్టర్‌ను పిలుస్తుంది.
90. ఉదాహరణకు, సి 2 యొక్క ఈ ఆవశ్యకతను మనం చూసినట్లయితే, ఎప్పుడు సి 2 త్వరగా పొందబడుతుందో, అప్పుడు సహజంగానే ఈ కన్స్ట్రక్టర్‌తో ఒక కన్స్ట్రక్టర్ ఆహ్వానించబడతారు.
91. అయితే, సి 1, సి 1 తక్షణం చేయబడినప్పుడు, రెండు పారామితులతో కూడిన కన్స్ట్రక్టర్ ఆహ్వానించబడతారు, కాబట్టి ఈ సందర్భంలో ఓవర్‌లోడ్ చేసిన కన్స్ట్రక్టర్ (ల) యొక్క అన్ని నియమాలు వర్తిస్తాయి.
92. ఈ విధంగా కన్స్ట్రక్టర్లను లోడ్ చేయవచ్చు మరియు మేము వివిధ రకాల పారామితులు మరియు వాటి కలయికల పరంగా బిల్డ్ ప్రాసెస్‌ను వ్రాయవచ్చు మరియు మనం వెళ్తున్నప్పుడు, వివిధ తరగతుల కోసం ఓవర్‌లోడ్ నిర్మాణాలు ఎలా జరుగుతాయో చెప్పడానికి ఇంకా చాలా ఉదాహరణలు చూస్తాము. మేము నిర్మించిన చాలా ప్రభావవంతమైన నిర్మాణ విధానాలను వ్రాయడానికి.
 సి ++  ప్రొగ్రామ్మింగ్ మోడులెస్  13 అంశం లొకి స్వాగతము.
ఈ మాడ్యూల్‌లో, వస్తువులు ఎలా సృష్టించబడుతున్నాయి లేదా ప్రారంభించబడ్డాయి, మరియు అవి ఎలా ఉపయోగించబడుతున్నాయో అవి ఎలా నాశనం చేయబడతాయి లేదా ప్రారంభించబడతాయో అర్థం చేసుకోవడం గురించి మరియు ఆ మొత్తం జీవిత ప్రక్రియలో మనం మాట్లాడుతాము. సమయం అంటే వస్తువు ఉంటుంది.
C ++ లోని ఆబ్జెక్ట్-ఓరియెంటెడ్ ఫ్యూచర్స్ సందర్భంలో, తరగతులను ఎలా నిర్వచించవచ్చో మరియు ఒక నిర్దిష్ట తరగతి యొక్క వస్తువులను ఎలా వేగవంతం చేయవచ్చో మేము ఇప్పటికే చూశాము.
మేము ఇప్పటికే డేటా సభ్యులు మరియు పద్ధతులను పరిశీలించాము మరియు సమాచారాన్ని దాచడానికి, డిజైన్‌లో డేటా స్పెసిఫికేషన్లను ప్రత్యేకంగా ప్రైవేట్‌గా చేయడానికి మొత్తం నమూనా గురించి మాట్లాడాము. స్పెసిఫికేషన్ మరియు స్పెసిఫికేషన్ ఆంక్షలు మరియు తయారుచేసే పద్ధతుల యొక్క ప్రాథమిక రూపకల్పన ప్రక్రియకు ఇంటర్‌ఫేస్‌ను అందిస్తుంది. ప్రజా.
ఇప్పుడు, మేము దానిపై విస్తరిస్తాము మరియు మరింత మాట్లాడతాము, ఇది తరగతి యొక్క నిర్మాణం లేదా విభిన్న వస్తువుల బ్లూప్రింట్ పరంగా డిజైన్ అంశంపై ఎక్కువగా ఉంది.
ఇప్పుడు ప్రస్తుత మాడ్యూల్ రన్‌టైమ్ ఎగ్జిక్యూషన్‌లో ప్రత్యేకంగా కనిపిస్తుంది, ఒక వస్తువు యొక్క రన్‌టైమ్ ప్రవర్తన జీవితానికి వచ్చినప్పుడు తెలుసుకోవడానికి ప్రయత్నిస్తుంది మరియు ఇది జీవితంలో ఎంతకాలం ఉంటుంది? మరియు ఒక వస్తువు యొక్క జీవిత చివరలో ఏమి జరుగుతుంది? మేము ఈ చర్చలన్నిటితో ప్రారంభిస్తాము, ఇది మీ ప్యానెల్ యొక్క ఎడమ వైపున చూడగలిగే రూపురేఖలు.
కాబట్టి మనం ఇప్పటికే ప్రవేశపెట్టిన స్టాక్ యొక్క మునుపటి ఉదాహరణలలో ఒకదాన్ని ప్రస్తావిద్దాం.
ఈ స్టాక్‌లో ఇద్దరు డేటా సభ్యులు ఉంటారు, స్టాక్ ఎలిమెంట్స్‌ను నిల్వ చేయడానికి అక్షరాల శ్రేణి, టాప్ ఎలిమెంట్ యొక్క ఇండెక్స్ మరియు దాని నాలుగు LIFO పద్ధతులను బహిరంగంగా ఉంచే హెడర్ మార్కర్., ఈ స్టాక్‌ను ఉపయోగించడానికి LIFO ఇంటర్ఫేస్ ఖాళీగా ఉంది, పుష్, పాప్ మరియు టాప్. మరియు ఇక్కడ మేము స్ట్రింగ్ రివర్స్ చేయడానికి ఈ స్టాక్ యొక్క ఉపయోగాన్ని చూపుతాము.
ఇప్పుడు, మేము దీనిని పరిశీలిస్తే, ఇక్కడ మనం ఉపయోగిస్తున్నట్లు ఒక వస్తువును సృష్టించడానికి వెంటనే ఈ స్టాక్‌ను సృష్టిస్తుందని మీరు కనుగొంటారు, కాని మేము స్టాక్ వస్తువును సృష్టించిన వెంటనే, రివర్స్ స్ట్రింగ్ ఆపరేషన్ చేయడానికి దాన్ని ఉపయోగించలేము మేము ఇక్కడ చేస్తున్నాం, మధ్యలో మనం స్టాక్ వన్ సరైన ప్రారంభమని నిర్ధారించుకోవాలి, అంటే S తక్షణం అయిన తర్వాత నేను తెలుసుకోవాలి, ఈ సమయంలో టాప్ మార్కర్ యొక్క విలువ ఏమిటో తెలుసుకోండి.
ఇది ఇప్పటివరకు ఎటువంటి ఆపరేషన్ చేయని పాయింట్, కాబట్టి మీరు ఒక స్టాక్ కేవలం కొన్ని ఖాళీ స్టాక్ (స్టాక్) కలిగి ఉన్న శూన్య స్టాక్‌తో సంభావితంగా సృష్టించబడిందని నిర్ధారించుకోవాలి. అందువల్ల, దాని హెడ్ మార్కర్ తక్కువగా ఉండాలి అగ్ర మార్కర్ -1 గా ఉండే శ్రేణిలోకి వెళ్ళగల మొదటి మూలకం కంటే.
అందువల్ల, ఈ కోడ్ పనిచేయడానికి, స్టాక్ వేరియబుల్ అయిన వెంటనే అసైన్‌మెంట్ ద్వారా టాప్ మార్కర్ యొక్క ప్రారంభ విలువను జోడించడం చాలా ముఖ్యం.
మీరు మరింత దగ్గరగా చూస్తే, మేము దీన్ని చేయగలమని మీరు గ్రహిస్తారు, ఎందుకంటే నేను దీనిని స్టాక్ వేరియబుల్‌గా నిర్వచించాను, డేటా సభ్యులుగా పబ్లిక్.
అందువల్ల, నేను టాప్_డేటా సభ్యుడిని సులభంగా యాక్సెస్ చేయగలను మరియు ఈ నియామకాన్ని చేయగలను, అందువల్ల మనం ఇక్కడ చూసినవి ఈ పరిష్కారంలో ఉన్నాయి. సమాచారాన్ని దాచిపెట్టే సూత్రాలకు విరుద్ధంగా ఉండే ఒక ప్రారంభాన్ని మేము కలిగి ఉన్నాము. మనం ఇంతకుముందు ఆహ్వానించిన లోపలి భాగాన్ని బహిర్గతం చేస్తుంది.
కాబట్టి, మనం ఎదురుగా ఉన్న పబ్లిక్ డేటా ఇక్కడ ఉపయోగించబడే కుడి కాలమ్‌కు వెళ్దాం, దీనికి విరుద్ధంగా మేము ప్రైవేట్ డేటాను ఉపయోగిస్తాము, మన సమాచారాన్ని దాచడానికి తిరిగి వెళ్తాము, తద్వారా మేము డేటాను ప్రైవేట్‌గా చేయగలము మరియు మనం సహజంగా చేస్తే, మేము ఇకపై ఇక్కడ వ్రాయలేము ఎందుకంటే మేము s.top_ = -1 వ్రాయడానికి ప్రయత్నిస్తే మీరు బాగా అర్థం చేసుకోవచ్చు; అప్పుడు కంపైలర్ ఈ ప్రోగ్రామ్‌ను కంపైల్ చేయదు, ఇది హెడర్ ఒక ప్రైవేట్ డేటా సభ్యుడు మరియు యాక్సెస్ చేయలేమని చెప్పడంలో లోపం ఇస్తుంది.
Init () అని పిలువబడే వేరే ఫంక్షన్ (init) ను పరిచయం చేయడం ద్వారా మేము ఆ సమస్యను పరిష్కరిస్తాము, దీనిని మేము ఇంటర్‌ఫేస్‌లో పబ్లిక్ పద్దతిగా ఉంచాము మరియు init () ప్రాథమికంగా టాప్ -1 ను ప్రారంభిస్తుంది. మరియు ఇక్కడ s.top = -1 చేయడానికి బదులుగా మేము init () అని పిలుస్తాము.
వారు అదే ప్రయోజనాన్ని అందించాలి.దీనితో మనం ఆబ్జెక్ట్-ఓరియెంటెడ్ డిజైన్‌ను తప్పనిసరిగా అనుసరించాల్సిన సమాచారాన్ని దాచడం యొక్క సూత్రాన్ని కొనసాగించవచ్చు మరియు పరిష్కారం పనిచేస్తుందని నిర్ధారించుకోవచ్చు.
మరియు ఇలా చేయడం వల్ల కలిగే ప్రయోజనం ఏమిటంటే, మీరు ఈ రెండు పంక్తులను పోల్చవచ్చు, ఉదాహరణకు డేటా సభ్యుడు పబ్లిక్‌గా ఉన్నప్పుడు యాక్సెస్ స్పెసిఫికేషన్ మాడ్యూల్ పరంగా మేము ఇంతకుముందు వివరించినట్లు డేటా సభ్యుడు పబ్లిక్‌గా ఉంటే ఏదైనా సృష్టించడం సాధ్యమైతే, అనుకోకుండా s.top మధ్యలో కొంత విలువకు కేటాయించినట్లయితే సంభావ్య ప్రమాదం.
అయినప్పటికీ, మేము సమాచారాన్ని దాచడం అనే సూత్రానికి తిరిగి వచ్చినప్పుడు, అటువంటి కోడ్ ప్రైవేట్ డేటాతో తిరిగి ఇవ్వబడదు ఎందుకంటే ఇది సంకలన లోపంగా మారుతుంది.
ఆ విధంగా డేటా సభ్యుడిని ప్రైవేట్‌గా చేయడం మరియు ప్రారంభ ఫంక్షన్‌ను అందించడం ప్రారంభ సమస్యకు మంచి పరిష్కారం, మరియు మేము ఈ ప్రైవేట్ డేటాతో మరింత పని చేయాలనుకుంటున్నాము.
దీనితో మనము ఆబ్జెక్ట్-ఓరియంటెడ్ డిజైన్(object-oriented design) తప్పనిసరిగా అనుసరిస్తూ, పరిష్కారం పని చేస్తుంది.
ఇప్పుడు మరియు వెళ్దాం.
ఎడమ కాలమ్‌లో, శీర్షికను ప్రారంభించడానికి init () పద్ధతిలో సహా ప్రైవేట్ డేటా మరియు పబ్లిక్ పద్ధతులను కలిగి ఉన్న మీరు చూసిన కోడ్‌ను మీరు చూస్తారు.
మేము చూసినట్లుగా ఇది క్లీన్ ఇనిషియలైజేషన్‌ను అందిస్తుంది, అయితే అప్లికేషన్ init () కి కాల్ చేయడం మరచిపోతే ప్రశ్న ఖచ్చితంగా ఉంటుంది, లేదా అప్లికేషన్ తప్పు స్థితిలో పిలుస్తే? అనువర్తనం స్ట్రింగ్‌ను రివర్స్ చేయడానికి ప్రయత్నిస్తున్నందున మరియు ఇది ఖాళీ, టాప్, పాప్ మరియు పుష్‌లను కలిగి ఉన్న LIFO నిర్మాణం అని తెలుసు కాబట్టి ఇది ప్రయోజనం లేని అనువర్తనం కోసం ఉద్దేశించిన ఈ init () ని పిలవడానికి అనువర్తనం గుర్తుంచుకుంటే, ఇవి నాలుగు పద్ధతులు కానీ, వీటన్నింటికీ పిలుపుగా పనిచేయడం, కానీ అది తప్పిపోతే, సహజంగానే మనకు అగ్రస్థానం ఉంటుంది. ఏకపక్ష విలువ ఉంది, అందువల్ల మొత్తం ప్రోగ్రామ్ చాలా అనూహ్య ప్రవర్తనను ఇస్తుంది.కాబట్టి మీరు దీని కంటే మెరుగైన పని చేయగలరా అని మీరు ఒక ప్రశ్న అడగండి, మేము దానిని పేర్చగలమా. వాస్తవానికి ఇది నిర్వచించబడినప్పుడు, ఈ ప్రారంభ కాల్‌ను ఎలాగైనా చేయగలిగితే అది తక్షణ సమయంలో సరైనది.
కన్స్ట్రక్టర్ యొక్క వ్యవస్థ ప్రాథమికంగా ఈ పరిష్కారాన్ని అందిస్తుంది.
C ++ ఒక యంత్రాంగాన్ని అందిస్తుంది, దీని ద్వారా మీరు ఒక వస్తువును ఒక నిర్దిష్ట ఫంక్షన్‌కు పిలిస్తే, ఈ సమయంలో కన్స్ట్రక్టర్ సరిగ్గా ఆరంభించబడతారు మరియు ఈ కన్స్ట్రక్టర్ యొక్క ఉపయోగం అవసరం సభ్యుల విలువలను ప్రారంభించడానికి డేటాను ఉపయోగించవచ్చు.
ఈ ఉదాహరణను చూస్తే, మనకు init () కాల్ లేదు, అది కాదు. బదులుగా ఈ వస్తువు యొక్క కన్స్ట్రక్టర్ అనే కొత్త పద్ధతిని ప్రవేశపెట్టాము.
ఇది నిర్మాత అని మీకు ఎలా తెలుసు? ఇది క్లాస్ పేరుకు సమానమైన పేరుతో ఒక నిర్దిష్ట సంతకాన్ని కలిగి ఉంది, కాబట్టి ఇది కన్స్ట్రక్టర్ అని మీకు తెలిసిన పేరు దానిలో వస్తువులను ఉంచడానికి వేరే మార్గాన్ని కలిగి ఉంది మరియు మేము దానిని చర్చిస్తాము.
కానీ, మేము ఇక్కడ చెప్పేది ఏమిటంటే, మేము డేటా సభ్యుడిని పైకి కదిలి, 1 ను ప్రారంభ విలువగా ఉంచాలి.
రెండవది, ఇది శ్రేణిని ప్రారంభించాల్సిన అవసరం లేదు ఎందుకంటే ఇది పుష్ మరియు పాప్‌గా ఉపయోగించబడుతుంది.
కానీ ప్రయోజనం ఏమిటంటే, మేము ఒక కన్స్ట్రక్టర్‌ను నిర్వచించినట్లయితే, నియంత్రణ ఈ నిర్దిష్ట బిందువును దాటిన వెంటనే, ఆ వస్తువు ఆటోమేటిక్ కాల్‌గా మారినప్పుడు, ఈ పద్ధతి ద్వారా ఒక అవ్యక్త కాల్ ఉంటుంది., మరియు ఈ కాల్ వాస్తవానికి శీర్షం అని నిర్ధారించుకుంటుంది -1 కు కేటాయించబడింది.
అందువల్ల, మేము ఈ సమయంలో ఈ కాల్ నుండి తిరిగి వచ్చినప్పుడు, మనకు ఇప్పటికే అవును -1 యొక్క అగ్ర ప్రారంభ ఉంది మరియు ఇది, ఇది అంతర్లీన ప్రారంభ నిర్మాణం యొక్క సౌందర్యం.
ఇక్కడ మరిన్ని ఉదాహరణలు చెప్తాము, కన్స్ట్రక్టర్ ఉన్న స్టాక్‌తో అదే ఉదాహరణతో మళ్ళీ రండి మరియు ఎడమ వైపున కన్స్ట్రక్టర్ పైభాగాన్ని ప్రారంభిస్తారని మనకు తెలుసు, నేను ఇక్కడ చూపిస్తున్నదాన్ని చేస్తాను.
కన్స్ట్రక్టర్ తరగతిలో భాగంగా వ్రాయబడింది, ఈ సమయంలో మీరు గుర్తుంచుకుంటారు.
కానీ ఇప్పుడు, మేము దానిని తరగతి వెలుపల వ్రాసాము, ఇది స్టాక్ (స్టాక్) :: స్టాక్ (స్టాక్) :, దీనికి పేరు పెట్టడం మీరు ఏదైనా తరగతి (తరగతి) సభ్యునికి పేరు కలిగి ఉన్నారని గుర్తుంచుకుంటారు. తరగతి పేరు.
కాబట్టి, ఇది క్లాస్ స్టాక్ పేరు, ఇది కన్స్ట్రక్టర్ పేరు.
మన వద్ద ఉన్నది కన్స్ట్రక్టర్ యొక్క శరీరం, మరియు ఆ శరీరంలో మేము టాప్ -1 ను ప్రారంభించాము మరియు తరువాత మిగిలిన స్టేట్మెంట్.
మేము ఇలా చేస్తే, ఇక్కడ స్టాక్ వేగవంతం అయిన వెంటనే పైభాగంలో ఈ సమయంలో కాల్ చేయబడిన ఒక కోర్ట్ ఉంది, ఇది నియంత్రణ ఇక్కడ తిరిగి వస్తుందని మీరు చూస్తారు మరియు అది స్ట్రింగ్ యొక్క విలోమం జరుగుతుంది.
శీర్షిక స్పష్టంగా ప్రారంభించబడుతున్న చాలా స్పష్టమైన ప్రక్రియ, ఇది మరొక డేటా సభ్యుని యొక్క స్వయంచాలక డిఫాల్ట్ ప్రారంభించడం, ఇది శ్రేణి, ఎందుకంటే ఇది ఇచ్చిన స్థిర పరిమాణం (శ్రేణి).
ఇప్పుడు, మీరు అక్షరానికి పాయింటర్ అయితే స్వయంచాలక శ్రేణి (శ్రేణి) గా కాకుండా చిన్న మార్పు చేద్దామా అని చూద్దాం, కాబట్టి మనం చేయడానికి ప్రయత్నిస్తున్నది ఈ శ్రేణిని (శ్రేణి) డైనమిక్‌గా మార్చడం) తయారు చేయాలి.
మనము దేనిని కన్స్ట్రక్టర్ (constructor) యొక్క బాడి, మరియు ఆ బాడి లో మొదట మేము -1 మరియు తరువాత cout స్టేట్మెంట్ మిగిలిన.
కాబట్టి సహజంగా స్టాక్ కోడ్‌లో పైకి ప్రారంభించడం అదే విధంగా ఉంటుంది, కాని ఇప్పుడు మనం అర్రే పాయింటర్‌ను కూడా ప్రారంభించాలి, దీన్ని డైనమిక్‌గా కేటాయించడం ద్వారా మేము చేస్తాము.
ఈ సమయంలో వ్రాసే ప్రారంభ విధానాన్ని అర్థం చేసుకుందాం.
ప్రారంభంలో మేము మొదట డేటా సభ్యుని పేరును వ్రాస్తాము మరియు తరువాత ఒక జత కుండలీకరణాల్లో మనం ప్రారంభీకరణగా ఉపయోగించాలనుకునే విలువను వ్రాస్తాము.
మేము డేటాను పరిశీలిస్తే, ఇది డేటా పాయింటర్ మరియు మీకు తెలిసినట్లుగా ఈ వ్యక్తీకరణ ఆపరేటర్ 10 అక్షరాల యొక్క కొత్త శ్రేణిని (శ్రేణి) కేటాయింపును పాయింటర్ రకంగా పాయింటర్ రకంగా ఉపయోగిస్తుంది.ఆ శ్రేణిని తిరిగి ఇస్తుంది మరియు ఆ పాయింటర్ డేటాలో ప్రారంభ విలువగా సెట్ చేయబడుతోంది.
ఇది మేము ఇంతకు ముందు చూడని విషయం.
మునుపటి అప్పగింత శైలి, ఇక్కడ మేము top_ = 1 అని చెప్తాము, లేదా డేటా (డేటా) = కొత్త చార్ [10] ఇలా చెబుతాము.
మీరు ఇక్కడ ఒక కన్స్ట్రక్టర్‌ను ఉపయోగిస్తున్నప్పుడు మరియు కన్స్ట్రక్టర్ (కన్స్ట్రక్టర్) సంతకం చేసిన తర్వాత మీకు పెద్దప్రేగు రూపంలో ఒక సెపరేటర్ ఉందని మరియు మీరు అవసరం అని గమనించండి. కొలోన్ మరియు కన్స్ట్రక్టర్ బాడీ యొక్క ప్రారంభ వంకర బ్రాకెట్ల మధ్య డేటా సభ్యుల ప్రారంభం యొక్క పూర్తి జాబితాను రాయండి.
ఇక్కడ మీరు కోమా లోపల డేటా సభ్యుడిని కోమాతో వేరు చేసిన తర్వాత వ్రాస్తారు మరియు ప్రతి డేటా సభ్యుడు ఒక జత బ్రాకెట్లలోని తర్వాత మీరు వాటిని ప్రారంభించాలనుకుంటున్న విలువను వ్రాస్తారు.
వాస్తవానికి, ప్రతి డేటా సభ్యుడు ఒక్కసారి మాత్రమే ఇక్కడ ఉండగలడు మరియు అన్ని డేటా సభ్యులను ప్రారంభించాల్సిన అవసరం లేదు, కానీ మేము వారందరినీ కూడా ప్రారంభించగలము, ఈ సందర్భంలో మనకు కావలసినట్లే.
స్టాక్ యొక్క ఈ ప్రత్యేక సంస్కరణకు ఏమి జరుగుతుంది? నియంత్రణను ఈ కన్స్ట్రక్టర్ అని పిలిచే పాయింట్ గుండా వెళుతున్నప్పుడు, స్టాక్ ఆబ్జెక్ట్ యొక్క పైభాగం -1 కు ప్రారంభమవుతుంది, పరిమాణం 10 (శ్రేణి) యొక్క అక్షర శ్రేణి డైనమిక్ కేటాయింపును కలిగి ఉంటుంది మరియు దాని పాయింటర్ దీనికి సెట్ చేయబడుతుంది డేటా, ఆపై స్టాక్ కాల్, ఈ సందేశం ముద్రించబడుతుంది మరియు నియంత్రణ పూర్తయినప్పుడు స్ట్రింగ్ రివర్స్ ఫార్వర్డ్ ఉన్న చోటికి తిరిగి వస్తుంది. పెరుగుతుంది.
దీనితో మనం కన్స్ట్రక్టర్‌ను డేటా సభ్యునిని అనేక రకాలుగా ప్రారంభించడానికి ఉపయోగించవచ్చని మరియు C ++ యొక్క యంత్రాంగం ఆ వస్తువునే వస్తువు అని నిర్ధారిస్తుంది. ప్రారంభించడం.
స్టాకింగ్ డేటా భాగం లేదా స్టాక్ టాప్ మార్కర్ భాగం కోసం ప్రారంభించడం గుర్తుకు రావడానికి లేదా చేయడానికి తలకి అనువర్తనం హక్కు లేదు, ఇది కన్స్ట్రక్టర్ మరియు కంపైలర్ యొక్క బాధ్యత అవుతుంది.ఈ కన్స్ట్రక్టర్‌ను అవ్యక్తంగా పిలుస్తుంది.
కాల్ చేయడానికి ఇది గుర్తుంచుకోవాలి, సహేతుకమైన సమయంలో ప్రతిసారీ పిలువబడుతుంది.
ఇప్పుడు, ఒక కన్స్ట్రక్టర్ ఏమి చేస్తాడో, మనం చూసినట్లుగా, ఒక కన్స్ట్రక్టర్ తప్పనిసరిగా సభ్యుల ఫంక్షన్, కానీ దీనికి సభ్యుల ఫంక్షన్‌తో చాలా తేడాలు ఉన్నాయి.
అందువల్ల, సభ్యుల ఫంక్షన్ అయినందున, ఇది ఏదైనా సభ్యుల ఫంక్షన్ లాగా ఈ పాయింటర్‌ను కలిగి ఉంటుంది, కాని దాని పేరు, నేను ఇప్పటికే చెప్పినట్లుగా, ప్రత్యేకంగా తరగతి పేరు ఇతర సభ్యుల ఫంక్షన్లకు అలా కాదు.
కన్స్ట్రక్టర్ యొక్క పని వస్తువును సృష్టించడం మరియు దానిని ప్రారంభించడం ఎందుకంటే రిటర్న్ రకం చూపబడటం లేదని మీరు ఇప్పటికే గమనించి ఉండవచ్చు, ఇది గణన చేయడం మరియు మీకు విలువను తిరిగి ఇవ్వడం కాదు.
కన్స్ట్రక్టర్ ఒక ఫంక్షన్ అయినప్పటికీ, అది ఏ విలువను ఇవ్వదు మరియు తిరిగి వచ్చే రకం కూడా శూన్యమైనది కాదు.
నేను దేనినీ తిరిగి ఇవ్వడం లేదని చెప్పే సున్నా రిటర్న్ రకాలను కలిగి ఉన్న ఫంక్షన్‌ను మీరు చూశారు, కాని కన్స్ట్రక్టర్ అలా చేయడు.
కన్స్ట్రక్టర్‌లో మీరు చెప్పినదానిలో ఏదైనా విలువను తిరిగి ఇవ్వడానికి యంత్రాంగం లేదు, కాబట్టి పేర్కొనడానికి రిటర్న్ రకం లేదు.
రిటర్న్ రకం లేనందున, రిటర్న్ స్టేట్మెంట్ లేదు, కాబట్టి మీకు రిటర్న్ స్టేట్మెంట్ లభించదు. సాధారణ సభ్యుల ఫంక్షన్ మాదిరిగా కాకుండా, రిటర్న్ స్టేట్మెంట్ ఎక్కడ ఉంటుంది లేదా మీ రిటర్న్ రకం సున్నా అయితే రిటర్న్ సూచించవచ్చు, కానీ a కన్స్ట్రక్టర్‌కు రిటర్న్ స్టేట్‌మెంట్ అవసరం లేదు, అది పరోక్షంగా తిరిగి వస్తుంది.
అదనంగా, కన్స్ట్రక్టర్‌కు ప్రారంభ జాబితా ఉంటుంది, ఇది కుండలీకరణాల్లోని డేటా సభ్యుల జాబితాకు ప్రారంభ విలువ విలువను వివరించాను.
జాబితా కన్స్ట్రక్టర్ బాడీ ప్రారంభంతో ప్రారంభమయ్యే పెద్దప్రేగుతో మొదలవుతుంది మరియు ఇది ఇతర సభ్యుల ఫంక్షన్లకు సమాంతరంగా ఉండదు.
కన్స్ట్రక్టర్‌కు స్పష్టమైన కాల్ లేదు, దానిని అత్యవసరంగా పిలుస్తారు.నేను ఈ వస్తువును ఇన్‌స్టాంట్ చేసిన వెంటనే కన్స్ట్రక్టర్ అని పిలుస్తారు, ఇక్కడ ప్రకృతిలో కాల్ ఆబ్జెక్ట్ (ఆబ్జెక్ట్) అవసరం. స్పష్టంగా ఉన్నాయి.
మేము ఉదాహరణను చూస్తాము, కాని చివరికి ఒక కన్స్ట్రక్టర్ యొక్క ఉదాహరణ పారామితి లేదని మనం చూసిన ఏదైనా పరామితిని కలిగి ఉంటుంది, కానీ ఇతర సభ్యుల ఫంక్షన్ వంటి కన్స్ట్రక్టర్. ఎన్ని పారామితులను కలిగి ఉండవచ్చు మరియు ఒక కన్స్ట్రక్టర్ లోడ్ చేయవచ్చు ఏ ఇతర సభ్యుల ఫంక్షన్ లాగా.
కన్స్ట్రక్టర్ అనేది ఒక ప్రత్యేకమైన ఫంక్షన్, ఇది అంతర్లీన వస్తువులను అన్ని సమయాలలో ప్రారంభించడానికి ప్రాథమికంగా మాకు సహాయపడుతుంది.
మీరు C ++ లో నిర్వచించగలిగే వివిధ రకాల కన్స్ట్రక్టర్లను చూసే ఒక జత స్లైడర్‌ల ద్వారా మేము త్వరగా తిరుగుతాము, పారామిటరైజ్డ్ కన్స్ట్రక్టర్స్ (కన్స్ట్రక్టర్) అని పిలువబడే కన్స్ట్రక్టర్‌లో మీరు పారామితులను (కన్స్ట్రక్టర్లను) కలిగి ఉండవచ్చు.
మేము ఇప్పటికే చూసిన డబుల్ రకాలను మళ్ళీ చూపిస్తున్నాము, కాబట్టి ఈ పారామితి విలువ ప్రారంభ సభ్యుల జాబితా ద్వారా డేటా సభ్యులను ప్రారంభించడానికి ఉపయోగపడుతుంది.
అప్పుడు కన్స్ట్రక్టర్ ఆవశ్యకతతో అవ్యక్తంగా పిలువబడుతుంది మరియు సాధారణంగా దీనికి రెండు వాక్యనిర్మాణాలు ఉపయోగించబడతాయి.
వాక్యనిర్మాణం ఒక నిర్దిష్ట ఫంక్షన్ కాల్ రకాన్ని కలిగి ఉంది, ఇక్కడ మీరు ఆబ్జెక్ట్ పేరు మరియు బ్రాకెట్లను ఉంచారు.మీరు కన్స్ట్రక్టర్ యొక్క పారామితులను కన్స్ట్రక్టర్ కోసం నిర్వచించిన క్రమంలో ఉంచుతారు.
కాబట్టి నేను ఈ ప్రత్యేకమైన ఆబ్జెక్ట్ ఇన్‌స్టాంటియేషన్‌ను వ్రాసేటప్పుడు, నియంత్రణ ఈ పాయింట్ గుండా వెళుతున్నప్పుడు కాంప్లెక్స్ యొక్క కన్స్ట్రక్టర్ అని పిలుస్తారు, ఇక్కడ 4.2 మళ్ళీ విలువగా, 5.3 IM విలువగా వెళ్ళాలి. ఇది దానిలోకి మరియు దానితో పాటు వెళ్తుంది దానితో వస్తువు నిర్మించబడుతుంది మరియు వస్తువు c గా సెట్ చేయబడుతుంది.
దీనికి మించి, మీరు c.re చేస్తే, మీరు విలువ 4.2 ను పొందాలి, అనగా, ఈ ముద్రణ ప్రకటన ఇక్కడ చూపబడింది, ఇక్కడ మేము సంక్లిష్ట సంఖ్య సంక్లిష్ట సంజ్ఞామానాన్ని ముద్రించి దాని ప్రమాణాన్ని లెక్కిస్తాము.
అదేవిధంగా, నేను సి భాగాన్ని సి చేస్తే నాకు 5.3 లభిస్తుంది.
రెండవది, d విషయంలో మనం వేరే ప్రత్యామ్నాయ సంజ్ఞామానం లో ఒకదాన్ని మాత్రమే చూపిస్తే, దానిని జాబితా ప్రారంభించడం అంటారు.
అంటే, మీరు ఒక కన్స్ట్రక్టర్‌లో బహుళ పారామితులను కలిగి ఉంటే, మీరు ఈ పారామితుల యొక్క ప్రారంభ విలువలను జాబితా సంజ్ఞామానం లో ఒక జత వంకర కలుపులు (సూచన సమయం: 21:22) మరియు వస్తువుతో సూచించవచ్చు. మీరు ప్రారంభ చిహ్నాన్ని ఉపయోగించవచ్చు పేరు తరువాత.
రెండూ ఒకే ప్రభావాన్ని కలిగి ఉంటాయి, అవి ఒకే ఆపరేషన్ చేయడానికి ప్రత్యామ్నాయ సంజ్ఞామానం మాత్రమే.
కాబట్టి, ఒకటి లేదా అంతకంటే ఎక్కువ పారామితులను కలిగి ఉన్న కన్స్ట్రక్టర్లను పారామీటర్ చేయబడిన కన్స్ట్రక్టర్స్ అంటారు.
ప్రస్తుతం, ప్రతి విషయంలో కన్స్ట్రక్టర్ మరొక సభ్యుల ఫంక్షన్, లేదా సి ++ లో ప్రత్యేకంగా మరో ఫంక్షన్ మాత్రమే ఉంది, కాబట్టి, నాకు పారామితులు ఉంటే, నేను డిఫాల్ట్ విలువను కూడా ఉంచగలను.
అందువల్ల, నేను వేర్వేరు డిఫాల్ట్ విలువలతో ఒక కన్స్ట్రక్టర్‌ను కలిగి ఉండగలను, కాబట్టి మీరు ఇక్కడ రెండు పారామితులతో మళ్ళీ ఒక ఉదాహరణను చూపిస్తారు మరియు డిఫాల్ట్ విలువలు 0.0 వాటిని.
ఫంక్షన్ల కోసం డిఫాల్ట్ పరామితి యొక్క అన్ని నియమాలు మరియు ఫంక్షన్లను ప్రారంభించడానికి డిఫాల్ట్ పరామితి ఆధారంగా మూడు వేర్వేరు మార్గాల్లో వస్తువులను సృష్టించడానికి మనం ఇదే కన్స్ట్రక్టర్‌ను ఉపయోగించవచ్చు.నేను నేను మొదటి పారామితిని మాత్రమే పేర్కొనగల రెండు పారామితులను ఉంచగలను లేదా నేను పారామితులను పేర్కొనలేను.
పేర్కొన్న పారామితులు డిఫాల్ట్ విలువలను తీసుకుంటాయి మరియు తదనుగుణంగా మీరు ప్రింట్ చేస్తే సంబంధిత వస్తువులు సృష్టించబడినప్పుడు మీరు వాటిని చూడగలరు.
డిఫాల్ట్ పారామితులతో కూడిన ఫంక్షన్ కోసం మేము నేర్చుకున్న అన్ని నియమాలు, ఆ పారామితులన్నింటినీ డిఫాల్ట్ చేసే మొత్తం విధానం కన్స్ట్రక్టర్లకు కూడా వర్తిస్తుందని ఇది చూపిస్తుంది.
ఇది ఇక్కడ మరొక ఉదాహరణ, మేము తిరిగి స్టాక్ చేయబోతున్నాం, కాబట్టి దీని కోసం ఒక కన్స్ట్రక్టర్‌ను డిఫాల్ట్ సైజు_టి విలువ 10 (సైజు_టి = 10) తో చూపిస్తాము.
కన్స్ట్రక్టర్ నిర్వచనంలో, మనకు ఒక పరామితి ఉంది, కాబట్టి నాకు కావాలంటే, నేను ఈ పారామితి విలువను ఉదాహరణకు ఇక్కడ పాస్ చేయగలను, అప్పుడు మేము ఆ స్ట్రింగ్ యొక్క పొడవును తీసుకుంటాము, మనం రివర్స్ చేయదలిచిన వస్తువును నిర్మిస్తున్నాము ఎందుకంటే ఈ స్టాక్ ఉంటే ఇచ్చిన స్ట్రింగ్ STR ను రివర్స్ చేసి, స్ట్రింగ్ యొక్క పొడవు ద్వారా రివర్స్ చేయండి ఎక్కువ పరిమాణం అవసరం లేదు, కాబట్టి మనం దానిని ఉపయోగించుకోవచ్చు మరియు స్ట్రింగ్‌కు తగినట్లుగా పెద్దదిగా ఉండే స్టాక్‌ను సృష్టించవచ్చు మరియు ఇక్కడ మీరు కన్స్ట్రక్టర్‌గా ముద్రించడం ద్వారా చూడవచ్చు సృష్టించబడిన స్టాక్ పరిమాణం ఎంత.
నేను దానిని ఉపయోగించకపోతే, పరిమాణం ఎలా ఉండాలో మేము ఈ సమాచారాన్ని అందించకపోతే, మనం స్టాక్ వ్రాస్తే అది ఖచ్చితంగా డిఫాల్ట్ పారామితి విలువ 10 మరియు 10 మూలకాల స్టాక్ తీసుకుంటుంది. (స్టాక్).
కాబట్టి, ఇవి మన వద్ద ఉన్న కన్స్ట్రక్టర్ల యొక్క వివిధ ఉదాహరణలు.
ఏదైనా తరువాతి C ++ సమూహ ఫంక్షన్ల మాదిరిగానే, కన్స్ట్రక్టర్లను కూడా ఓవర్‌లోడ్ చేయవచ్చు, అంటే ఒక తరగతి ఒకటి కంటే ఎక్కువ కన్స్ట్రక్టర్లను కలిగి ఉంటుంది, ఎందుకంటే దాని పేరు తప్పనిసరిగా కన్స్ట్రక్టర్ కావడం తరగతి పేరు. అదే విధంగా ఉంటుంది, కాబట్టి నేను ఉంటే ఇద్దరు కన్స్ట్రక్టర్లను వ్రాయాలనుకుంటున్నారు, వారికి ఒకే పేరు అవసరం, కానీ పారామితులు లేదా టైప్ పారామితులలో తేడా ఉన్నంత వరకు అలా చేయడానికి అనుమతి ఉంది.
ఫంక్షన్ ఓవర్‌లోడింగ్ యొక్క అన్ని నియమాలు మనం నేర్చుకున్నట్లే, అధిక-లోడ్ చేసిన కన్స్ట్రక్టర్ సందర్భంలో వర్తిస్తాయి.
కాబట్టి ఇక్కడ మేము ఒక కాంప్లెక్స్ కోసం మూడు కన్స్ట్రక్టర్లను చూపిస్తున్నాము, అది రెండు పారామితులను తీసుకొని రెండింటినీ తిరిగి అమలు చేస్తుంది, ఒకటి శ్రేణులను మాత్రమే తీసుకుంటుంది మరియు ఏమీ తీసుకోదు.
మరియు మేము ఈ పారామితులను ఉపయోగిస్తున్నాము, ఇది పరిష్కరించాల్సిన పారామితుల సంఖ్య యొక్క మూడు ఆవశ్యకత దృష్ట్యా ఒక నిర్దిష్ట రూపం కన్స్ట్రక్టర్‌ను పిలుస్తుంది.
ఉదాహరణకు, సి 2 యొక్క ఈ ఆవశ్యకతను మనం చూసినట్లయితే, ఎప్పుడు సి 2 త్వరగా పొందబడుతుందో, అప్పుడు సహజంగానే ఈ కన్స్ట్రక్టర్‌తో ఒక కన్స్ట్రక్టర్ ఆహ్వానించబడతారు.
అయితే, సి 1, సి 1 తక్షణం చేయబడినప్పుడు, రెండు పారామితులతో కూడిన కన్స్ట్రక్టర్ ఆహ్వానించబడతారు, కాబట్టి ఈ సందర్భంలో ఓవర్‌లోడ్ చేసిన కన్స్ట్రక్టర్ (ల) యొక్క అన్ని నియమాలు వర్తిస్తాయి.
ఈ విధంగా కన్స్ట్రక్టర్లను లోడ్ చేయవచ్చు మరియు మేము వివిధ రకాల పారామితులు మరియు వాటి కలయికల పరంగా బిల్డ్ ప్రాసెస్‌ను వ్రాయవచ్చు మరియు మనం వెళ్తున్నప్పుడు, వివిధ తరగతుల కోసం ఓవర్‌లోడ్ నిర్మాణాలు ఎలా జరుగుతాయో చెప్పడానికి ఇంకా చాలా ఉదాహరణలు చూస్తాము. మేము నిర్మించిన చాలా ప్రభావవంతమైన నిర్మాణ విధానాలను వ్రాయడానికి.
inhouse/NPTEL/PreFinal/c++/Telugu/28 ProgramminginCplusplus_Constructors, Destructors and Object Lifetime (Contd.) (Lecture 24)-Dgv9ErvGnLo.txt
View file @ 956c0d4e
 1. మాడ్యూల్ 13, పార్ట్ -2  ప్రోగ్రామింగ్ ఇన్ C ++ కు స్వాగతం.
2. ఈ మాడ్యూల్ యొక్క మొదటి భాగంలో, తరగతుల కన్స్ట్రక్టర్లను ఉపయోగించి వస్తువులను ఎలా నిర్మించవచ్చో చూశాము, అవ్యక్త కన్స్ట్రక్టర్లను ఎలా పిలుస్తారు మరియు ప్రారంభ జాబితా ద్వారా వస్తువులను పేర్కొనడానికి వాటిని ఉపయోగిస్తాము. (ఆబ్జెక్ట్స్) యొక్క డేటా సభ్యులను ప్రారంభించడానికి చేయవచ్చు, మరియు మేము ఎలా నిర్మించగలమో కూడా చూశాము? ఆ పారామితుల కోసం డిఫాల్ట్ విలువలను ఎలా ఉపయోగించగలం? అన్ని రకాల నిర్మాణ మరియు ప్రారంభ విధానాల కోసం ఓవర్‌లోడ్ కన్స్ట్రక్టర్లను ఎలా అందించగలం? ఇప్పుడు, కథ యొక్క మరొక కోణాన్ని పరిశీలిస్తాము.
3. ఒక వస్తువు జీవిత చివరకి చేరుకున్నప్పుడు లేదా అది విధ్వంసక సమయం అయినప్పుడు ఏమి జరుగుతుందో దానిపై మేము దృష్టి పెడతాము.
4. కాబట్టి, మళ్ళీ మనం స్టాక్ ఉదాహరణకి తిరిగి వెళ్తాము.
5. మేము ప్రైవేట్ డేటాను కలిగి ఉన్న స్టాక్‌ను చూస్తున్నాము మరియు స్టాక్ యొక్క అంశాలను కలిగి ఉన్న కంటైనర్ డైనమిక్‌గా కేటాయించిన శ్రేణి, కాబట్టి మనకు ఒక పాయింటర్ ఉంది.
6. కాబట్టి, స్టాక్ సందర్భంలో మనకు ఏమి చేయాలో తెలుసు, నిర్మాణ పరంగా ఏమి చేయాలో మాకు తెలుసు, మేము దీనిని చూశాము.
7. 10 అక్షరాల శ్రేణికి క్రొత్త ఆపరేటర్‌తో డైనమిక్ కేటాయింపు జరుగుతుంది మరియు ఆ పాయింటర్ డేటాలో నిల్వ చేయబడుతుంది.
8. కాబట్టి, స్టాక్ పని చేస్తుంది, ఇది ఈ బిల్డ్ ద్వారా ప్రారంభమవుతుంది మరియు తరువాత అది రివర్స్ అవుతుంది.
9. కాబట్టి, ప్రదర్శన యొక్క స్పష్టత కొరకు నేను స్టాక్ పద్ధతుల యొక్క అన్ని వివరాలను వదిలివేసాను మరియు స్ట్రింగ్ కోడ్‌ను రివర్స్ చేసాను, ఇది మునుపటిలాగే ఉంది, కానీ అలా చేస్తున్నప్పుడు, మేము ఈ దశకు చేరుకున్నప్పుడు, మేము దీనిని పూర్తి చేసాము స్టాక్ మరియు మేము తిరిగి రావాలి.
10. పాయింట్, మనం ఇప్పటికే గుర్తించినట్లుగా, డైనమిక్‌గా కేటాయించిన శ్రేణి ఉంది, దీని పాయింటర్ స్టాక్ ఆబ్జెక్ట్ యొక్క డేటా భాగం ద్వారా ఉంటుంది.
11. ఇప్పుడు, మేము ఈ దశకు తిరిగి వస్తే; మేము ప్రధాన నుండి తిరిగి వచ్చి నియంత్రణ ముగిస్తే, అప్పుడు ఈ డైనమిక్‌గా నిర్మించిన శ్రేణి సాధించలేనిది, ఎందుకంటే నిశ్శబ్దంగా S, ఇక్కడ వేగవంతం అయిన వస్తువు S ఈ ఫంక్షన్ యొక్క పరిధి.
12. కాబట్టి, నేను తిరిగి వచ్చి దాని నుండి బయటికి వెళితే నేను s ని యాక్సెస్ చేయగల మార్గం లేదు, అందువల్ల నేను s.data ని యాక్సెస్ చేయగలిగే మార్గం లేదు లేదా మన దగ్గర ఉన్న మెమరీని విడుదల చేయటం కొత్త ప్రక్రియ ద్వారా సాధించబడుతుంది.
13. నిర్మాణం.
14. అందువల్ల, ఈ సమస్యను నివారించడానికి మా వనరులను సరిగ్గా నిర్వహించడానికి మరియు విడుదల చేయడానికి, వనరును ఉపయోగించడం పూర్తయినప్పుడల్లా, డి-ఇనిషియలైజేషన్ యొక్క సరిపోయే విధానం ఉండాలి, ఇది మేము ప్రారంభ సమయంలో చేసిన వాటిని రద్దు చేస్తుంది.
15. కాబట్టి, మొదట మనం ప్రారంభించినట్లే అదే umption హను చేస్తాము, ఒక ఫంక్షన్ (ఫంక్షన్) de_init (), మనకు ఫంక్షన్ (ఫంక్షన్) ఎందుకు అవసరం? మరియు మనం ఆ ఫంక్షన్‌ను ఇక్కడ ఎందుకు ఉంచాలి? ఎందుకంటే కేటాయించిన శ్రేణిని విడుదల చేయడానికి, మేము స్టాక్ క్లాస్ యొక్క "డేటా (డేటా) _" డేటా (డేటా) సభ్యుడిని యాక్సెస్ చేయాలి.
16. అందువల్ల, మేము de_init () పద్ధతిని బహిరంగంగా ఉంచి, ఆ పద్ధతిని పిలుస్తాము, ప్రారంభంలో మేము చేసిన శైలి మరియు దానికి కారణమయ్యే సమస్యలు ప్రారంభానికి సమానంగా ఉంటాయి.
17. అనువర్తనం init అని పిలవడం మర్చిపోయే ఒక భాగం అయితే మంచిది.
18. రెండవది, ఈ సందర్భంలో మనకు పెద్ద సమస్య ఉంది, ఎందుకంటే ఇది de_init () ని పిలవడం మర్చిపోవడమే కాదు, ఒక పెద్ద సమస్య కూడా నాకు గుర్తుంటే, నేను కాల్ చేసిన తర్వాత స్టాక్ (స్టాక్) ను ఉపయోగించటానికి ప్రయత్నించే ఖచ్చితమైన స్థానం ఏమిటి? de_init (), నేను de_init () మరియు de_init () అని పిలిస్తే.
19. స్టాక్‌లో కంటైనర్ లేనందున అప్పుడు నాకు మూల్యాంకనం ఉంటుంది.
20. నేను ఇప్పటికే దీన్ని విడుదల చేసాను, కాని డి_నిట్ () స్టాక్ నిర్వచించబడిన అదే పరిధిలో ఉంది.
21. అందువల్ల, ఇక్కడ కాల్ చేసిన తర్వాత de_init () స్టాక్ (స్టాక్) ను ఉపయోగించడానికి ప్రయత్నించవచ్చు.
22. అందువల్ల, ప్రతి కాల్ de_init () ఆ తరువాత S యొక్క ఉపయోగం లేదని నిర్ధారించడానికి నేను చాలా జాగ్రత్తగా ఉండాలి.
23. ఒక ఫంక్షన్ నుండి మరొక ఫంక్షన్ వరకు; ఇది మేము ఇక్కడ చూపిస్తున్న చాలా సులభమైన కేసు, ఒక ఫంక్షన్ నుండి, నేను వాస్తవానికి తిరిగి వచ్చే చాలా ప్రదేశాలు ఉండవచ్చు, నేను చాలా ప్రదేశాల నుండి తిరిగి వస్తున్నట్లయితే నాకు మొదట తెలియదు మరియు నియంత్రణ ప్రవాహం ద్వారా ఎవరు ఒక నిర్దిష్ట స్పెసిఫికేషన్ ఉపసంహరించబడతారు .
24. అందువల్ల, నేను ఈ ప్రదేశాలలో ప్రతిదానిని గుర్తుంచుకోవాలి మరియు de_init () ను ఉంచాలి.
25. కాబట్టి, ఇది పూర్తి గజిబిజి, ఇది పూర్తి గజిబిజి మరియు దీనికి ప్రధాన కారణం సి లోని సమస్యకు తెలిసిన మూలం, కేటాయించిన వనరులు సరిగా కేటాయించబడలేదు లేదా సరిగా విడుదల చేయబడలేదు.
26. C ++ లో, మనకు విధ్వంసక అని పిలువబడే అందమైన పరిష్కారం ఉంది.
27. ఆ పరిష్కారాన్ని చూద్దాం; మనం చేసేది క్లాసులో మరొక సభ్యుల ఫంక్షన్ ప్రారంభించడం.
28. ఈ సభ్యుల ఫంక్షన్ కూడా తరగతికి సమానమైన పేరును కలిగి ఉంది, కానీ దానిలోని తేడాలు ప్రత్యేక చిహ్నం టిల్డే (~) తో ప్రిఫిక్స్ చేయబడతాయి మరియు వాటిని క్లాస్ డిస్ట్రక్టర్స్ అంటారు.
29. కాబట్టి, ఏమి జరుగుతుందో ఆ వస్తువును కన్స్ట్రక్టర్ అని పిలుస్తారు, ఇది అత్యవసర సమయం.
30. అదేవిధంగా, వస్తువు ఇక్కడ నుండి నిష్క్రమించినప్పుడు, ఇది ఒక వంకర కలుపు, ఈ వస్తువు పరిధి నుండి బయటకు వెళుతుంది, ఈ వంకర కలుపును నియంత్రణ ద్వారా దాటిన తరువాత, C యొక్క స్కోప్ నియమం యొక్క పరిధి అని మాట్లాడటానికి మార్గం లేదు సి ++.
31. అందువల్ల, ఈ స్కోప్ ముగింపును దాటడానికి ప్రయత్నిస్తున్నప్పుడు, తరగతి యొక్క విధ్వంసకుడిని ఈ వస్తువు కోసం పిలుస్తారు.
32. ఈ సమయంలో s ~ stack (), ఈ ఫంక్షన్ (ఫంక్షన్) అని పిలువబడుతుంది మరియు మొత్తం యొక్క అందం ఏమిటంటే వినియోగదారు లేదా ప్రోగ్రామర్ కాల్ చేసి గుర్తుంచుకోవలసిన అవసరం లేదు.
33. కంపైలర్ క్లుప్తంగా లెక్కిస్తుంది, ఇది s యొక్క స్కోప్ యొక్క ముగింపు మరియు ఈ కాల్ స్కోప్ చివరిలో పరోక్షంగా ఉంచబడుతుంది.
34. కాబట్టి, ఇప్పుడు మనం మొత్తం వ్యవస్థను కలిసి చూస్తే, మనకు ఈ రకమైన డి_ఇనిట్ () అవసరం లేదు, ఇక్కడ అవసరం లేదు.
35. కన్స్ట్రక్టర్ ఈ ఫంక్షన్‌ను మరియు అది ముద్రించే సందేశాన్ని పిలవడానికి స్టాక్ ఈ సమయంలో ప్రారంభించబడుతుంది.
36. అప్పుడు స్ట్రింగ్ రివర్స్ చేయడానికి స్టాక్ ఉపయోగించబడుతుంది.
37. రివర్స్ స్ట్రింగ్ అవుట్పుట్ మరియు తరువాత నియంత్రణ ఈ సమయంలో స్కోప్ నుండి బయటపడుతుంది మరియు దీనిని స్పష్టంగా డిస్ట్రక్టర్ ఫంక్షన్ అని పిలుస్తారు మరియు డిస్ట్రక్టర్ ఫంక్షన్ లోపల సందేశం ముద్రించబడిందని గుర్తించడానికి డిస్ట్రక్టర్ ఫంక్షన్ అని పిలుస్తారు.
38. కాబట్టి, స్టాక్ క్లాస్ యొక్క ఈ డేటా సభ్యునిలో డైనమిక్‌గా ఉంచిన డేటాను ఈ సమయంలో విడుదల చేయవచ్చని ఇది నిర్ధారిస్తుంది.
39. కాబట్టి, నేను స్టాక్‌ను ఏ సందర్భంలో ఉపయోగించినా, నేను స్టాక్‌ను వేగవంతం చేసినప్పుడల్లా, బిల్డర్ తగిన విధంగా డేటా కేటాయించబడిందని నిర్ధారిస్తుంది. సరైన ప్రారంభాన్ని నిరోధించడమే అవుతుంది, మరియు పేర్చబడిన స్టాక్ ఆబ్జెక్ట్ పరిధికి దూరంగా ఉన్నప్పుడు, కంపైలర్ కన్‌స్ట్రక్టర్‌ను పిలిచారని కూడా నిర్ధారించుకోండి, తద్వారా కేటాయింపుదారుడు డేటాను సరైన విడుదలను నిర్ధారించడానికి.
40. కాబట్టి, ఈ మిశ్రమ జత కన్స్ట్రక్టర్లు మరియు డిస్ట్రక్టర్లు C ++ లోని ప్రతి వస్తువు యొక్క జీవిత కాలాన్ని చాలా చక్కగా నిర్వహించే పూర్తిగా నిర్వచించిన నిర్మాణాత్మక మార్గాన్ని మాకు అందిస్తుంది.
41. అందువల్ల, మనం ఇప్పటికే చూసినట్లుగా డిస్ట్రక్టర్ యొక్క అధికారిక లక్షణాలను చూడటానికి, డిస్ట్రక్టర్ కూడా సభ్యుల ఫంక్షన్.
42. ఈ పాయింటర్‌లోని ఇతర సభ్యుల ఫంక్షన్ మాదిరిగానే, దీనికి ప్రత్యేక పేరు ఉంది, ఇది క్లాస్ పేరును అనుసరించి ఒక టిల్డే, డిస్ట్రక్టర్ కూడా డిస్ట్రక్టర్ దగ్గర రిటర్న్ రకాన్ని కలిగి ఉంటుంది. దీనిని స్కోప్ యొక్క ముగింపు అని పిలుస్తారు మరియు అందువల్ల, అది ఏదైనా తిరిగి ఇస్తే, ఆ తిరిగి వచ్చిన విలువకు టేకర్ ఉండదు.
43. ఒక వస్తువును నాశనం చేయడం ద్వారా రిటర్న్ లెక్కించడంలో అర్థం లేదు, కాబట్టి డిస్ట్రక్టర్‌కు కూడా రిటర్న్ రకం లేదు - శూన్యమైనది కాదు.
44. ఖచ్చితంగా, ఫలితంగా ఒక డిస్ట్రక్టర్‌కు రిటర్న్ స్టేట్‌మెంట్ లేదు మరియు మనం ఇప్పటికే చూసినట్లుగా చాలా ముఖ్యమైన మరియు ముఖ్యమైన భాగం ఏమిటంటే, డిస్ట్రక్టర్ స్కోప్ చివరిలో ఉన్నట్లు చెప్పబడింది మరియు ఏదైనా స్వయంచాలక వస్తువు కోసం స్థానికంగా ఉపయోగించవచ్చు.
45. డిస్ట్రక్టర్‌ను పిలవడానికి ఇతర మార్గాలు ఉన్నాయి, మేము దానిని స్పష్టం చేస్తాము, కాని సాధారణంగా ఒక డిస్ట్రక్టర్‌కు కాల్ అనేది కంపైలర్ చేత సూచించబడుతుంది, ఈ ఆటోమేటిక్ స్కోప్ యొక్క కొలత ద్వారా నిర్దిష్ట వస్తువు నిర్మించబడింది.
46. కన్స్ట్రక్టర్ మాదిరిగా కాకుండా, ఒక డిస్ట్రక్టర్ ఏ పరామితిని అనుమతించదు.
47. ఇది అనుమతించబడనందున, మీరు ఇప్పటివరకు అర్థం చేసుకునే ఏదైనా పరామితి ఫలితం చాలా సరైనది, మీరు డిస్ట్రక్టర్‌ను ఓవర్‌లోడ్ చేయలేరు.
48. అందువల్ల, మీకు పరామితి లేకపోతే మరియు మీరు డిస్ట్రక్టర్‌ను ఓవర్‌లోడ్ చేయలేకపోతే, తరగతి యొక్క డిస్ట్రక్టర్ ప్రత్యేకమైనదని అర్థం.
49. అందువల్ల, దృష్టాంతంలో ఓవర్లోడింగ్ యొక్క వేర్వేరు యంత్రాంగాల ద్వారా ఒకటి లేదా అంతకంటే ఎక్కువ మంది కన్స్ట్రక్టర్లను కలిగి ఉండగల తరగతి, కానీ దీనికి ఒకే విధమైన విధ్వంసం ఉండాలి మరియు విషయాలు ఒక విధంగా నిర్వచించబడటానికి లోతైన కారణం ఉంది ఎందుకంటే స్పష్టంగా, ఒకసారి మీరు ఒక వస్తువును నిర్మించబోతున్నారు, మీకు ఖచ్చితంగా ఒక ఎంపిక ఉంటుంది, మీకు ఏ పరామితి మరియు అన్నింటిని మీరు ఇష్టపడతారు మీరు ఏ రకమైన వస్తువును సెట్ చేయాలనుకుంటున్నారో బట్టి మరియు నిశ్శబ్దంగా తార్కికంగా మీకు వేర్వేరు యంత్రాంగాలు లేదా విభిన్న పారామితులు అవసరం వస్తువును నిర్మించడానికి సెట్ చేయబడింది మరియు అందువల్ల, మీకు ఓవర్‌లోడ్ కన్స్ట్రక్టర్లు చాలా అవసరం.
50. కానీ, మేము వస్తువును నిర్మించిన తర్వాత, దానిని నిర్మించడానికి ఏ కన్స్ట్రక్టర్ ఉపయోగించబడ్డాడనే దానిపై ఎటువంటి ఆధారాలు లేవు.
51. డేటా సభ్యుడు ప్రారంభించబడిందా లేదా దాని విలువ తరువాత నిర్ణయించబడిందో తెలియదు.
52. అందువల్ల, మీరు నాశనం చేయాలనుకున్నప్పుడు, అన్ని విషయాలు ఒకటే.
53. నేను ఈ వస్తువుతో పూర్తి చేశానని అతను చెబుతున్నదంతా, నా డేటా సభ్యులు కలిగి ఉన్న అన్ని కేటాయించిన వనరులను విడుదల చేయాలనుకుంటున్నాను మరియు ఆ వస్తువు ప్రస్తుతం నివసిస్తున్న మెమరీని విడిపించాలనుకుంటున్నాను
54. అందువల్ల, నేను డిస్ట్రక్ట్ ప్రాసెస్‌కు అనుగుణంగా ఉండాలి మరియు అందువల్ల, డిస్ట్రక్ట్ ప్రాసెస్ ఒక తరగతిలోని ఒక వస్తువుకు ప్రత్యేకంగా ఉండాలి మరియు అందువల్ల, సి ++ డిజైన్‌లోని ప్రతి తరగతికి ప్రత్యేకమైన సింగిల్ డిస్ట్రక్టర్.
55. ఈ సమయంలో, మేము కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్‌ని చూసిన తర్వాత, కన్స్ట్రక్టర్ (కన్స్ట్రక్టర్) డిఫాల్ట్‌గా ఉండవచ్చని కూడా గమనించండి.
56. పరామితి లేని కన్స్ట్రక్టర్‌ను డిఫాల్ట్ కన్స్ట్రక్టర్ అంటారు.
57. అందువల్ల, వినియోగదారుకు వాస్తవానికి రెండు ఎంపికలు ఉన్నాయి, వినియోగదారు ఒక కన్స్ట్రక్టర్‌ను వ్రాయగలడు లేదా అతను ఒక కన్స్ట్రక్టర్‌ను వ్రాయలేడు, కాని C ++ లో ఒక విధానం ఉంది, అది ప్రతి తరగతికి (కన్స్ట్రక్టర్) కన్స్ట్రక్టర్.
58. అందువల్ల, కంపైలర్ ఏమి చేస్తుంది, వినియోగదారు కన్స్ట్రక్టర్‌ను అందిస్తే అది ఆ కన్స్ట్రక్టర్‌ను ఉపయోగిస్తుంది, కాని వినియోగదారు క్లాస్ కోసం కన్స్ట్రక్టర్‌ను అందించకపోతే, కంపైలర్ (కంపైలర్) ఉచిత డిఫాల్ట్ కన్స్ట్రక్టర్‌ను సరఫరా చేస్తుంది.
59. ఇప్పుడు, కంపైలర్ ఒక కన్స్ట్రక్టర్‌ను సరఫరా చేస్తే, సహజంగా కంపైలర్‌కు మీకు కావలసిన పరామితి తెలియదు.
60. మీ డేటా సభ్యులను ఎలా ప్రారంభించాలో కంపైలర్‌కు తెలియదు.
61. కాబట్టి, మొత్తం ప్రక్రియను స్థిరంగా చేయడానికి, కంపైలర్ మీకు ఉచిత డిఫాల్ట్ కన్స్ట్రక్టర్‌ను ఇస్తుంది మరియు మీకు ఉచిత డిఫాల్ట్ కన్స్ట్రక్టర్ ఉందని uming హిస్తూ కోడ్‌ను కంపైల్ చేస్తుంది.ఫాల్ట్ కన్స్ట్రక్టర్.
62. అందువల్ల, ఒక పారామితి లేకపోయినా కన్స్ట్రక్టర్‌ను అందించడం మంచిది, ఎందుకంటే మీరు ఒకసారి కన్స్ట్రక్టర్‌ను అందించినప్పుడు, అది డిఫాల్ట్‌గా ఉన్నప్పటికీ, మీ కన్స్ట్రక్టర్. (కన్స్ట్రక్టర్) ఉపయోగించబడుతుంది మరియు కంపైలర్ ఉచిత కన్స్ట్రక్టర్‌ను అందించదు ఎందుకంటే మీరు డిఫాల్ట్ కన్స్ట్రక్టర్ వ్రాస్తే లేదా మీరు మరొక ఓవర్లోడ్ కన్స్ట్రక్టర్ వ్రాస్తే మీకు నిజంగా తెలుసు మీరు ఏమి చేస్తున్నారో
63. కంపైలర్ దీన్ని అందిస్తే, అది మీ డేటా సభ్యులకు చెత్త యొక్క మొత్తం విలువను కలిగి ఉంటుంది, కాని కంపైలర్ మీకు ఉచిత డిఫాల్ట్ కన్స్ట్రక్టర్‌ను ఇస్తుందని యంత్రాంగాలు ఉన్నాయి.
64. అదేవిధంగా, విధ్వంసం కోసం, వినియోగదారు ఒక డిస్ట్రక్టర్‌ను అందించకపోతే, కంపైలర్ ఉచిత డిఫాల్ట్ డిస్ట్రక్టర్‌ను సరఫరా చేస్తుంది, ఇది ఖాళీ శరీరమే తప్ప ఏమీ చేయదు. కనుగొనబడింది, కానీ వారి శరీరంలో కోడ్ లేదు ఎందుకంటే ఆ కంపైలర్ లేదు ' విడుదల చేయవలసినది ఏమిటో తెలియదు లేదా విడుదల చేయడానికి ఏమీ లేకపోతే, కానీ కంపైలర్ వాస్తవానికి మొత్తం వ్యవస్థను పని చేయడానికి పని చేస్తుంది. ఉచిత డిఫాల్ట్ డిస్ట్రక్టర్‌ను అందిస్తుంది.
65. కాబట్టి, డిఫాల్ట్ కన్స్ట్రక్టర్ యొక్క ఉదాహరణను మేము ఇక్కడ చూపిస్తాము.
66. దయచేసి ఈ తరగతిని చూడండి.
67. ఇది మా సంక్లిష్ట తరగతిని కలిగి ఉంది, ఇది మా పాత స్నేహితుడు.
68. ఇలస్ట్రేషన్ కోసం నేను జోడించినది ఏమిటంటే, నేను రెండు సభ్యుల ఫంక్షన్ పద్ధతిని సెట్ చేసాను, అది రెండు డబుల్ విలువలను తీసుకుంటుంది మరియు రెండు విలువలను తరగతిలోని రెండు డేటా సభ్యులుగా సెట్ చేస్తుంది, అవి నా తరగతికి సంక్లిష్ట విలువను కలిగి ఉంటాయి. సమయం, కానీ ఇప్పుడు తప్పిపోయినది ఏమిటంటే, కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ లేడని మీకు తెలుసు.
69. కాబట్టి, మనం ఉంటే; ఈ సమయంలో ఈ ఆవశ్యకత సంభవించినప్పుడు, కంపైలర్ అందించిన డిఫాల్ట్ కన్స్ట్రక్టర్‌ను పిలవడం డిఫాల్ట్? కాబట్టి, మీరు తరగతి శరీరంలో అలాంటి ఫంక్షన్‌ను నిర్వచించకపోయినా ఈ కాల్ జరుగుతుంది.
70. అందువల్ల, ఈ బిల్డర్ ఎలా పున art ప్రారంభించబడుతుంది మరియు ఎవరితో ప్రారంభించాలో తెలియదు మరియు అందువల్ల, ఇది ఈ పాయింట్ల వద్ద కొన్ని చెత్త విలువలను వదిలివేస్తుంది.
71. కాబట్టి, అర్థం చేసుకోవడానికి, ఈ వస్తువు సృష్టించబడితే, మీరు వెంటనే ఆ వస్తువును ప్రింట్ చేస్తే.
72. నా ఉద్దేశ్యం ఇది ఒక సందర్భం, మీరు ఈ ప్రయోగాన్ని మీరే ప్రయత్నిస్తే, మీరు బహుశా కొన్ని విభిన్న విలువలను పొందుతారు.
73. కాబట్టి, రీ మరియు ఇమ్ ఉండాల్సిన కొన్ని చెత్త బిట్ నమూనా ఉన్న దాన్ని ప్రింట్ చేస్తుంది, కాని ఒకసారి నేను సెట్ ఫంక్షన్ (ఫంక్షన్) ను ఉపయోగించిన తర్వాత నేను కాంపోనెంట్ విలువను తిరిగి మరియు ఇమ్ చేయాలి. సెట్ చేయడానికి ఇక్కడ అందించబడింది మరియు తరువాత నేను ప్రింట్, నేను మళ్ళీ సహేతుకమైన ధరలను పొందుతాను.
74. సాధారణ సలహా ఏమిటంటే, మీరు కన్స్ట్రక్టర్‌ను అందించకపోతే, దురదృష్టవశాత్తు కంపైలర్ లోపం ఇవ్వదు, కంపైలర్ డిఫాల్ట్ కన్స్ట్రక్టర్‌ను డిఫాల్ట్ కన్స్ట్రక్టర్‌కు అందిస్తుంది మరియు అతనితో కొనసాగుతుంది.
75. అందువల్ల, ఇది సరసమైన విలువ, సరైన ప్రారంభ వాక్యనిర్మాణం లేని ప్రమాదాన్ని అమలు చేస్తుంది.
76. అందువల్ల, మీరు క్లాస్ వ్రాసినప్పుడల్లా, మీరు కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ వ్రాసేలా చూసుకోండి.
77. ఇక్కడ మేము డిఫాల్ట్ కన్స్ట్రక్టర్‌ని చూపిస్తున్న మరొక ఉదాహరణ, కానీ ఈ సందర్భంలో ఉన్న తేడా ఏమిటంటే డిఫాల్ట్ కన్స్ట్రక్టర్ కంపైలర్ చేత అందించబడలేదు, కాని డిఫాల్ట్ (డిఫాల్ట్) కన్స్ట్రక్టర్ యూజర్ అందించారు.
78. కాబట్టి, వినియోగదారు దీనిని వ్రాశారు.
79. కాబట్టి, మీరు సహజంగా ప్రారంభించిన తర్వాత మొదటి ముద్రణ చేసినప్పుడు, 0 మరియు 0 యొక్క సహేతుకమైన విలువతో ఒక ప్రారంభీకరణ ఉన్నందున, సహేతుకమైన ప్రారంభ విలువలు ఉన్నాయని మీరు అనుకుంటారు, మునుపటి ఉదాహరణలో మన దగ్గర ఉన్న చెత్త రకం కాదు. నేను. చూసింది
80. అదేవిధంగా, ఒక డిస్ట్రక్టర్ కూడా ఇక్కడ ఇవ్వబడింది.
81. ఈ సందర్భంలో, డిస్ట్రక్టర్ ఈ సందేశాన్ని ప్రింట్ చేస్తుంది.
82. వాస్తవానికి ఒక విధ్వంసకుడు సంక్లిష్ట తరగతి కోసం ఏమీ చేయలేడు, కాని ఒకదాన్ని ఖాళీ శరీరంతో అందించడం ఎల్లప్పుడూ మంచిది.
83. దీనితో మేము నిర్మాణం మరియు విధ్వంసం ప్రక్రియను ఆపుతాము.
84. ప్రతి తరగతికి ఒక డిస్ట్రక్టర్ ఉంటుందని మేము తెలుసుకున్నాము, ఇది ప్రత్యేకమైనది మరియు ఇది ఆటోమేటిక్ వస్తువుల కోసం ఉంటుంది, ఈ స్కోప్ చివరిలో పొందబడుతుంది మరియు ఈ డిస్ట్రక్టర్ లోపల, మనం పట్టుకున్న ఏ రకమైన వనరులను అయినా శుభ్రం చేయవచ్చు, మరియు కంపైలర్ డిఫాల్ట్ కన్స్ట్రక్టర్ మరియు డిఫాల్ట్ డిస్ట్రక్టర్ను కూడా అందిస్తుందని మేము చూశాము. వినియోగదారు క్లాస్ కోసం కన్స్ట్రక్టర్ లేదా కన్స్ట్రక్టర్ వ్రాయకపోతే ఇది జరుగుతుంది.
 మాడ్యూల్ 13, పార్ట్ -2  ప్రోగ్రామింగ్ ఇన్ C ++ కు స్వాగతం.
ఈ మాడ్యూల్ యొక్క మొదటి భాగంలో, తరగతుల కన్స్ట్రక్టర్లను ఉపయోగించి వస్తువులను ఎలా నిర్మించవచ్చో చూశాము, అవ్యక్త కన్స్ట్రక్టర్లను ఎలా పిలుస్తారు మరియు ప్రారంభ జాబితా ద్వారా వస్తువులను పేర్కొనడానికి వాటిని ఉపయోగిస్తాము. (ఆబ్జెక్ట్స్) యొక్క డేటా సభ్యులను ప్రారంభించడానికి చేయవచ్చు, మరియు మేము ఎలా నిర్మించగలమో కూడా చూశాము? ఆ పారామితుల కోసం డిఫాల్ట్ విలువలను ఎలా ఉపయోగించగలం? అన్ని రకాల నిర్మాణ మరియు ప్రారంభ విధానాల కోసం ఓవర్‌లోడ్ కన్స్ట్రక్టర్లను ఎలా అందించగలం? ఇప్పుడు, కథ యొక్క మరొక కోణాన్ని పరిశీలిస్తాము.
ఒక వస్తువు జీవిత చివరకి చేరుకున్నప్పుడు లేదా అది విధ్వంసక సమయం అయినప్పుడు ఏమి జరుగుతుందో దానిపై మేము దృష్టి పెడతాము.
కాబట్టి, మళ్ళీ మనం స్టాక్ ఉదాహరణకి తిరిగి వెళ్తాము.
మేము ప్రైవేట్ డేటాను కలిగి ఉన్న స్టాక్‌ను చూస్తున్నాము మరియు స్టాక్ యొక్క అంశాలను కలిగి ఉన్న కంటైనర్ డైనమిక్‌గా కేటాయించిన శ్రేణి, కాబట్టి మనకు ఒక పాయింటర్ ఉంది.
కాబట్టి, స్టాక్ సందర్భంలో మనకు ఏమి చేయాలో తెలుసు, నిర్మాణ పరంగా ఏమి చేయాలో మాకు తెలుసు, మేము దీనిని చూశాము.
10 అక్షరాల శ్రేణికి క్రొత్త ఆపరేటర్‌తో డైనమిక్ కేటాయింపు జరుగుతుంది మరియు ఆ పాయింటర్ డేటాలో నిల్వ చేయబడుతుంది.
కాబట్టి, స్టాక్ పని చేస్తుంది, ఇది ఈ బిల్డ్ ద్వారా ప్రారంభమవుతుంది మరియు తరువాత అది రివర్స్ అవుతుంది.
కాబట్టి, ప్రదర్శన యొక్క స్పష్టత కొరకు నేను స్టాక్ పద్ధతుల యొక్క అన్ని వివరాలను వదిలివేసాను మరియు స్ట్రింగ్ కోడ్‌ను రివర్స్ చేసాను, ఇది మునుపటిలాగే ఉంది, కానీ అలా చేస్తున్నప్పుడు, మేము ఈ దశకు చేరుకున్నప్పుడు, మేము దీనిని పూర్తి చేసాము స్టాక్ మరియు మేము తిరిగి రావాలి.
పాయింట్, మనం ఇప్పటికే గుర్తించినట్లుగా, డైనమిక్‌గా కేటాయించిన శ్రేణి ఉంది, దీని పాయింటర్ స్టాక్ ఆబ్జెక్ట్ యొక్క డేటా భాగం ద్వారా ఉంటుంది.
ఇప్పుడు, మేము ఈ దశకు తిరిగి వస్తే; మేము ప్రధాన నుండి తిరిగి వచ్చి నియంత్రణ ముగిస్తే, అప్పుడు ఈ డైనమిక్‌గా నిర్మించిన శ్రేణి సాధించలేనిది, ఎందుకంటే నిశ్శబ్దంగా S, ఇక్కడ వేగవంతం అయిన వస్తువు S ఈ ఫంక్షన్ యొక్క పరిధి.
కాబట్టి, నేను తిరిగి వచ్చి దాని నుండి బయటికి వెళితే నేను s ని యాక్సెస్ చేయగల మార్గం లేదు, అందువల్ల నేను s.data ని యాక్సెస్ చేయగలిగే మార్గం లేదు లేదా మన దగ్గర ఉన్న మెమరీని విడుదల చేయటం కొత్త ప్రక్రియ ద్వారా సాధించబడుతుంది.
నిర్మాణం.
అందువల్ల, ఈ సమస్యను నివారించడానికి మా వనరులను సరిగ్గా నిర్వహించడానికి మరియు విడుదల చేయడానికి, వనరును ఉపయోగించడం పూర్తయినప్పుడల్లా, డి-ఇనిషియలైజేషన్ యొక్క సరిపోయే విధానం ఉండాలి, ఇది మేము ప్రారంభ సమయంలో చేసిన వాటిని రద్దు చేస్తుంది.
కాబట్టి, మొదట మనం ప్రారంభించినట్లే అదే umption హను చేస్తాము, ఒక ఫంక్షన్ (ఫంక్షన్) de_init (), మనకు ఫంక్షన్ (ఫంక్షన్) ఎందుకు అవసరం? మరియు మనం ఆ ఫంక్షన్‌ను ఇక్కడ ఎందుకు ఉంచాలి? ఎందుకంటే కేటాయించిన శ్రేణిని విడుదల చేయడానికి, మేము స్టాక్ క్లాస్ యొక్క "డేటా (డేటా) _" డేటా (డేటా) సభ్యుడిని యాక్సెస్ చేయాలి.
అందువల్ల, మేము de_init () పద్ధతిని బహిరంగంగా ఉంచి, ఆ పద్ధతిని పిలుస్తాము, ప్రారంభంలో మేము చేసిన శైలి మరియు దానికి కారణమయ్యే సమస్యలు ప్రారంభానికి సమానంగా ఉంటాయి.
అనువర్తనం init అని పిలవడం మర్చిపోయే ఒక భాగం అయితే మంచిది.
రెండవది, ఈ సందర్భంలో మనకు పెద్ద సమస్య ఉంది, ఎందుకంటే ఇది de_init () ని పిలవడం మర్చిపోవడమే కాదు, ఒక పెద్ద సమస్య కూడా నాకు గుర్తుంటే, నేను కాల్ చేసిన తర్వాత స్టాక్ (స్టాక్) ను ఉపయోగించటానికి ప్రయత్నించే ఖచ్చితమైన స్థానం ఏమిటి? de_init (), నేను de_init () మరియు de_init () అని పిలిస్తే.
స్టాక్‌లో కంటైనర్ లేనందున అప్పుడు నాకు మూల్యాంకనం ఉంటుంది.
నేను ఇప్పటికే దీన్ని విడుదల చేసాను, కాని డి_నిట్ () స్టాక్ నిర్వచించబడిన అదే పరిధిలో ఉంది.
అందువల్ల, ఇక్కడ కాల్ చేసిన తర్వాత de_init () స్టాక్ (స్టాక్) ను ఉపయోగించడానికి ప్రయత్నించవచ్చు.
అందువల్ల, ప్రతి కాల్ de_init () ఆ తరువాత S యొక్క ఉపయోగం లేదని నిర్ధారించడానికి నేను చాలా జాగ్రత్తగా ఉండాలి.
ఒక ఫంక్షన్ నుండి మరొక ఫంక్షన్ వరకు; ఇది మేము ఇక్కడ చూపిస్తున్న చాలా సులభమైన కేసు, ఒక ఫంక్షన్ నుండి, నేను వాస్తవానికి తిరిగి వచ్చే చాలా ప్రదేశాలు ఉండవచ్చు, నేను చాలా ప్రదేశాల నుండి తిరిగి వస్తున్నట్లయితే నాకు మొదట తెలియదు మరియు నియంత్రణ ప్రవాహం ద్వారా ఎవరు ఒక నిర్దిష్ట స్పెసిఫికేషన్ ఉపసంహరించబడతారు .
అందువల్ల, నేను ఈ ప్రదేశాలలో ప్రతిదానిని గుర్తుంచుకోవాలి మరియు de_init () ను ఉంచాలి.
కాబట్టి, ఇది పూర్తి గజిబిజి, ఇది పూర్తి గజిబిజి మరియు దీనికి ప్రధాన కారణం సి లోని సమస్యకు తెలిసిన మూలం, కేటాయించిన వనరులు సరిగా కేటాయించబడలేదు లేదా సరిగా విడుదల చేయబడలేదు.
C ++ లో, మనకు విధ్వంసక అని పిలువబడే అందమైన పరిష్కారం ఉంది.
ఆ పరిష్కారాన్ని చూద్దాం; మనం చేసేది క్లాసులో మరొక సభ్యుల ఫంక్షన్ ప్రారంభించడం.
ఈ సభ్యుల ఫంక్షన్ కూడా తరగతికి సమానమైన పేరును కలిగి ఉంది, కానీ దానిలోని తేడాలు ప్రత్యేక చిహ్నం టిల్డే (~) తో ప్రిఫిక్స్ చేయబడతాయి మరియు వాటిని క్లాస్ డిస్ట్రక్టర్స్ అంటారు.
కాబట్టి, ఏమి జరుగుతుందో ఆ వస్తువును కన్స్ట్రక్టర్ అని పిలుస్తారు, ఇది అత్యవసర సమయం.
అదేవిధంగా, వస్తువు ఇక్కడ నుండి నిష్క్రమించినప్పుడు, ఇది ఒక వంకర కలుపు, ఈ వస్తువు పరిధి నుండి బయటకు వెళుతుంది, ఈ వంకర కలుపును నియంత్రణ ద్వారా దాటిన తరువాత, C యొక్క స్కోప్ నియమం యొక్క పరిధి అని మాట్లాడటానికి మార్గం లేదు సి ++.
అందువల్ల, ఈ స్కోప్ ముగింపును దాటడానికి ప్రయత్నిస్తున్నప్పుడు, తరగతి యొక్క విధ్వంసకుడిని ఈ వస్తువు కోసం పిలుస్తారు.
ఈ సమయంలో s ~ stack (), ఈ ఫంక్షన్ (ఫంక్షన్) అని పిలువబడుతుంది మరియు మొత్తం యొక్క అందం ఏమిటంటే వినియోగదారు లేదా ప్రోగ్రామర్ కాల్ చేసి గుర్తుంచుకోవలసిన అవసరం లేదు.
కంపైలర్ క్లుప్తంగా లెక్కిస్తుంది, ఇది s యొక్క స్కోప్ యొక్క ముగింపు మరియు ఈ కాల్ స్కోప్ చివరిలో పరోక్షంగా ఉంచబడుతుంది.
కాబట్టి, ఇప్పుడు మనం మొత్తం వ్యవస్థను కలిసి చూస్తే, మనకు ఈ రకమైన డి_ఇనిట్ () అవసరం లేదు, ఇక్కడ అవసరం లేదు.
కన్స్ట్రక్టర్ ఈ ఫంక్షన్‌ను మరియు అది ముద్రించే సందేశాన్ని పిలవడానికి స్టాక్ ఈ సమయంలో ప్రారంభించబడుతుంది.
అప్పుడు స్ట్రింగ్ రివర్స్ చేయడానికి స్టాక్ ఉపయోగించబడుతుంది.
రివర్స్ స్ట్రింగ్ అవుట్పుట్ మరియు తరువాత నియంత్రణ ఈ సమయంలో స్కోప్ నుండి బయటపడుతుంది మరియు దీనిని స్పష్టంగా డిస్ట్రక్టర్ ఫంక్షన్ అని పిలుస్తారు మరియు డిస్ట్రక్టర్ ఫంక్షన్ లోపల సందేశం ముద్రించబడిందని గుర్తించడానికి డిస్ట్రక్టర్ ఫంక్షన్ అని పిలుస్తారు.
కాబట్టి, స్టాక్ క్లాస్ యొక్క ఈ డేటా సభ్యునిలో డైనమిక్‌గా ఉంచిన డేటాను ఈ సమయంలో విడుదల చేయవచ్చని ఇది నిర్ధారిస్తుంది.
కాబట్టి, నేను స్టాక్‌ను ఏ సందర్భంలో ఉపయోగించినా, నేను స్టాక్‌ను వేగవంతం చేసినప్పుడల్లా, బిల్డర్ తగిన విధంగా డేటా కేటాయించబడిందని నిర్ధారిస్తుంది. సరైన ప్రారంభాన్ని నిరోధించడమే అవుతుంది, మరియు పేర్చబడిన స్టాక్ ఆబ్జెక్ట్ పరిధికి దూరంగా ఉన్నప్పుడు, కంపైలర్ కన్‌స్ట్రక్టర్‌ను పిలిచారని కూడా నిర్ధారించుకోండి, తద్వారా కేటాయింపుదారుడు డేటాను సరైన విడుదలను నిర్ధారించడానికి.
కాబట్టి, ఈ మిశ్రమ జత కన్స్ట్రక్టర్లు మరియు డిస్ట్రక్టర్లు C ++ లోని ప్రతి వస్తువు యొక్క జీవిత కాలాన్ని చాలా చక్కగా నిర్వహించే పూర్తిగా నిర్వచించిన నిర్మాణాత్మక మార్గాన్ని మాకు అందిస్తుంది.
అందువల్ల, మనం ఇప్పటికే చూసినట్లుగా డిస్ట్రక్టర్ యొక్క అధికారిక లక్షణాలను చూడటానికి, డిస్ట్రక్టర్ కూడా సభ్యుల ఫంక్షన్.
ఈ పాయింటర్‌లోని ఇతర సభ్యుల ఫంక్షన్ మాదిరిగానే, దీనికి ప్రత్యేక పేరు ఉంది, ఇది క్లాస్ పేరును అనుసరించి ఒక టిల్డే, డిస్ట్రక్టర్ కూడా డిస్ట్రక్టర్ దగ్గర రిటర్న్ రకాన్ని కలిగి ఉంటుంది. దీనిని స్కోప్ యొక్క ముగింపు అని పిలుస్తారు మరియు అందువల్ల, అది ఏదైనా తిరిగి ఇస్తే, ఆ తిరిగి వచ్చిన విలువకు టేకర్ ఉండదు.
ఒక వస్తువును నాశనం చేయడం ద్వారా రిటర్న్ లెక్కించడంలో అర్థం లేదు, కాబట్టి డిస్ట్రక్టర్‌కు కూడా రిటర్న్ రకం లేదు - శూన్యమైనది కాదు.
ఖచ్చితంగా, ఫలితంగా ఒక డిస్ట్రక్టర్‌కు రిటర్న్ స్టేట్‌మెంట్ లేదు మరియు మనం ఇప్పటికే చూసినట్లుగా చాలా ముఖ్యమైన మరియు ముఖ్యమైన భాగం ఏమిటంటే, డిస్ట్రక్టర్ స్కోప్ చివరిలో ఉన్నట్లు చెప్పబడింది మరియు ఏదైనా స్వయంచాలక వస్తువు కోసం స్థానికంగా ఉపయోగించవచ్చు.
డిస్ట్రక్టర్‌ను పిలవడానికి ఇతర మార్గాలు ఉన్నాయి, మేము దానిని స్పష్టం చేస్తాము, కాని సాధారణంగా ఒక డిస్ట్రక్టర్‌కు కాల్ అనేది కంపైలర్ చేత సూచించబడుతుంది, ఈ ఆటోమేటిక్ స్కోప్ యొక్క కొలత ద్వారా నిర్దిష్ట వస్తువు నిర్మించబడింది.
కన్స్ట్రక్టర్ మాదిరిగా కాకుండా, ఒక డిస్ట్రక్టర్ ఏ పరామితిని అనుమతించదు.
ఇది అనుమతించబడనందున, మీరు ఇప్పటివరకు అర్థం చేసుకునే ఏదైనా పరామితి ఫలితం చాలా సరైనది, మీరు డిస్ట్రక్టర్‌ను ఓవర్‌లోడ్ చేయలేరు.
అందువల్ల, మీకు పరామితి లేకపోతే మరియు మీరు డిస్ట్రక్టర్‌ను ఓవర్‌లోడ్ చేయలేకపోతే, తరగతి యొక్క డిస్ట్రక్టర్ ప్రత్యేకమైనదని అర్థం.
అందువల్ల, దృష్టాంతంలో ఓవర్లోడింగ్ యొక్క వేర్వేరు యంత్రాంగాల ద్వారా ఒకటి లేదా అంతకంటే ఎక్కువ మంది కన్స్ట్రక్టర్లను కలిగి ఉండగల తరగతి, కానీ దీనికి ఒకే విధమైన విధ్వంసం ఉండాలి మరియు విషయాలు ఒక విధంగా నిర్వచించబడటానికి లోతైన కారణం ఉంది ఎందుకంటే స్పష్టంగా, ఒకసారి మీరు ఒక వస్తువును నిర్మించబోతున్నారు, మీకు ఖచ్చితంగా ఒక ఎంపిక ఉంటుంది, మీకు ఏ పరామితి మరియు అన్నింటిని మీరు ఇష్టపడతారు మీరు ఏ రకమైన వస్తువును సెట్ చేయాలనుకుంటున్నారో బట్టి మరియు నిశ్శబ్దంగా తార్కికంగా మీకు వేర్వేరు యంత్రాంగాలు లేదా విభిన్న పారామితులు అవసరం వస్తువును నిర్మించడానికి సెట్ చేయబడింది మరియు అందువల్ల, మీకు ఓవర్‌లోడ్ కన్స్ట్రక్టర్లు చాలా అవసరం.
కానీ, మేము వస్తువును నిర్మించిన తర్వాత, దానిని నిర్మించడానికి ఏ కన్స్ట్రక్టర్ ఉపయోగించబడ్డాడనే దానిపై ఎటువంటి ఆధారాలు లేవు.
డేటా సభ్యుడు ప్రారంభించబడిందా లేదా దాని విలువ తరువాత నిర్ణయించబడిందో తెలియదు.
అందువల్ల, మీరు నాశనం చేయాలనుకున్నప్పుడు, అన్ని విషయాలు ఒకటే.
నేను ఈ వస్తువుతో పూర్తి చేశానని అతను చెబుతున్నదంతా, నా డేటా సభ్యులు కలిగి ఉన్న అన్ని కేటాయించిన వనరులను విడుదల చేయాలనుకుంటున్నాను మరియు ఆ వస్తువు ప్రస్తుతం నివసిస్తున్న మెమరీని విడిపించాలనుకుంటున్నాను
అందువల్ల, నేను డిస్ట్రక్ట్ ప్రాసెస్‌కు అనుగుణంగా ఉండాలి మరియు అందువల్ల, డిస్ట్రక్ట్ ప్రాసెస్ ఒక తరగతిలోని ఒక వస్తువుకు ప్రత్యేకంగా ఉండాలి మరియు అందువల్ల, సి ++ డిజైన్‌లోని ప్రతి తరగతికి ప్రత్యేకమైన సింగిల్ డిస్ట్రక్టర్.
ఈ సమయంలో, మేము కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్‌ని చూసిన తర్వాత, కన్స్ట్రక్టర్ (కన్స్ట్రక్టర్) డిఫాల్ట్‌గా ఉండవచ్చని కూడా గమనించండి.
పరామితి లేని కన్స్ట్రక్టర్‌ను డిఫాల్ట్ కన్స్ట్రక్టర్ అంటారు.
అందువల్ల, వినియోగదారుకు వాస్తవానికి రెండు ఎంపికలు ఉన్నాయి, వినియోగదారు ఒక కన్స్ట్రక్టర్‌ను వ్రాయగలడు లేదా అతను ఒక కన్స్ట్రక్టర్‌ను వ్రాయలేడు, కాని C ++ లో ఒక విధానం ఉంది, అది ప్రతి తరగతికి (కన్స్ట్రక్టర్) కన్స్ట్రక్టర్.
అందువల్ల, కంపైలర్ ఏమి చేస్తుంది, వినియోగదారు కన్స్ట్రక్టర్‌ను అందిస్తే అది ఆ కన్స్ట్రక్టర్‌ను ఉపయోగిస్తుంది, కాని వినియోగదారు క్లాస్ కోసం కన్స్ట్రక్టర్‌ను అందించకపోతే, కంపైలర్ (కంపైలర్) ఉచిత డిఫాల్ట్ కన్స్ట్రక్టర్‌ను సరఫరా చేస్తుంది.
ఇప్పుడు, కంపైలర్ ఒక కన్స్ట్రక్టర్‌ను సరఫరా చేస్తే, సహజంగా కంపైలర్‌కు మీకు కావలసిన పరామితి తెలియదు.
మీ డేటా సభ్యులను ఎలా ప్రారంభించాలో కంపైలర్‌కు తెలియదు.
కాబట్టి, మొత్తం ప్రక్రియను స్థిరంగా చేయడానికి, కంపైలర్ మీకు ఉచిత డిఫాల్ట్ కన్స్ట్రక్టర్‌ను ఇస్తుంది మరియు మీకు ఉచిత డిఫాల్ట్ కన్స్ట్రక్టర్ ఉందని uming హిస్తూ కోడ్‌ను కంపైల్ చేస్తుంది.ఫాల్ట్ కన్స్ట్రక్టర్.
అందువల్ల, ఒక పారామితి లేకపోయినా కన్స్ట్రక్టర్‌ను అందించడం మంచిది, ఎందుకంటే మీరు ఒకసారి కన్స్ట్రక్టర్‌ను అందించినప్పుడు, అది డిఫాల్ట్‌గా ఉన్నప్పటికీ, మీ కన్స్ట్రక్టర్. (కన్స్ట్రక్టర్) ఉపయోగించబడుతుంది మరియు కంపైలర్ ఉచిత కన్స్ట్రక్టర్‌ను అందించదు ఎందుకంటే మీరు డిఫాల్ట్ కన్స్ట్రక్టర్ వ్రాస్తే లేదా మీరు మరొక ఓవర్లోడ్ కన్స్ట్రక్టర్ వ్రాస్తే మీకు నిజంగా తెలుసు మీరు ఏమి చేస్తున్నారో
కంపైలర్ దీన్ని అందిస్తే, అది మీ డేటా సభ్యులకు చెత్త యొక్క మొత్తం విలువను కలిగి ఉంటుంది, కాని కంపైలర్ మీకు ఉచిత డిఫాల్ట్ కన్స్ట్రక్టర్‌ను ఇస్తుందని యంత్రాంగాలు ఉన్నాయి.
అదేవిధంగా, విధ్వంసం కోసం, వినియోగదారు ఒక డిస్ట్రక్టర్‌ను అందించకపోతే, కంపైలర్ ఉచిత డిఫాల్ట్ డిస్ట్రక్టర్‌ను సరఫరా చేస్తుంది, ఇది ఖాళీ శరీరమే తప్ప ఏమీ చేయదు. కనుగొనబడింది, కానీ వారి శరీరంలో కోడ్ లేదు ఎందుకంటే ఆ కంపైలర్ లేదు ' విడుదల చేయవలసినది ఏమిటో తెలియదు లేదా విడుదల చేయడానికి ఏమీ లేకపోతే, కానీ కంపైలర్ వాస్తవానికి మొత్తం వ్యవస్థను పని చేయడానికి పని చేస్తుంది. ఉచిత డిఫాల్ట్ డిస్ట్రక్టర్‌ను అందిస్తుంది.
కాబట్టి, డిఫాల్ట్ కన్స్ట్రక్టర్ యొక్క ఉదాహరణను మేము ఇక్కడ చూపిస్తాము.
దయచేసి ఈ తరగతిని చూడండి.
ఇది మా సంక్లిష్ట తరగతిని కలిగి ఉంది, ఇది మా పాత స్నేహితుడు.
ఇలస్ట్రేషన్ కోసం నేను జోడించినది ఏమిటంటే, నేను రెండు సభ్యుల ఫంక్షన్ పద్ధతిని సెట్ చేసాను, అది రెండు డబుల్ విలువలను తీసుకుంటుంది మరియు రెండు విలువలను తరగతిలోని రెండు డేటా సభ్యులుగా సెట్ చేస్తుంది, అవి నా తరగతికి సంక్లిష్ట విలువను కలిగి ఉంటాయి. సమయం, కానీ ఇప్పుడు తప్పిపోయినది ఏమిటంటే, కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ లేడని మీకు తెలుసు.
కాబట్టి, మనం ఉంటే; ఈ సమయంలో ఈ ఆవశ్యకత సంభవించినప్పుడు, కంపైలర్ అందించిన డిఫాల్ట్ కన్స్ట్రక్టర్‌ను పిలవడం డిఫాల్ట్? కాబట్టి, మీరు తరగతి శరీరంలో అలాంటి ఫంక్షన్‌ను నిర్వచించకపోయినా ఈ కాల్ జరుగుతుంది.
అందువల్ల, ఈ బిల్డర్ ఎలా పున art ప్రారంభించబడుతుంది మరియు ఎవరితో ప్రారంభించాలో తెలియదు మరియు అందువల్ల, ఇది ఈ పాయింట్ల వద్ద కొన్ని చెత్త విలువలను వదిలివేస్తుంది.
కాబట్టి, అర్థం చేసుకోవడానికి, ఈ వస్తువు సృష్టించబడితే, మీరు వెంటనే ఆ వస్తువును ప్రింట్ చేస్తే.
నా ఉద్దేశ్యం ఇది ఒక సందర్భం, మీరు ఈ ప్రయోగాన్ని మీరే ప్రయత్నిస్తే, మీరు బహుశా కొన్ని విభిన్న విలువలను పొందుతారు.
కాబట్టి, రీ మరియు ఇమ్ ఉండాల్సిన కొన్ని చెత్త బిట్ నమూనా ఉన్న దాన్ని ప్రింట్ చేస్తుంది, కాని ఒకసారి నేను సెట్ ఫంక్షన్ (ఫంక్షన్) ను ఉపయోగించిన తర్వాత నేను కాంపోనెంట్ విలువను తిరిగి మరియు ఇమ్ చేయాలి. సెట్ చేయడానికి ఇక్కడ అందించబడింది మరియు తరువాత నేను ప్రింట్, నేను మళ్ళీ సహేతుకమైన ధరలను పొందుతాను.
సాధారణ సలహా ఏమిటంటే, మీరు కన్స్ట్రక్టర్‌ను అందించకపోతే, దురదృష్టవశాత్తు కంపైలర్ లోపం ఇవ్వదు, కంపైలర్ డిఫాల్ట్ కన్స్ట్రక్టర్‌ను డిఫాల్ట్ కన్స్ట్రక్టర్‌కు అందిస్తుంది మరియు అతనితో కొనసాగుతుంది.
అందువల్ల, ఇది సరసమైన విలువ, సరైన ప్రారంభ వాక్యనిర్మాణం లేని ప్రమాదాన్ని అమలు చేస్తుంది.
అందువల్ల, మీరు క్లాస్ వ్రాసినప్పుడల్లా, మీరు కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్ వ్రాసేలా చూసుకోండి.
ఇక్కడ మేము డిఫాల్ట్ కన్స్ట్రక్టర్‌ని చూపిస్తున్న మరొక ఉదాహరణ, కానీ ఈ సందర్భంలో ఉన్న తేడా ఏమిటంటే డిఫాల్ట్ కన్స్ట్రక్టర్ కంపైలర్ చేత అందించబడలేదు, కాని డిఫాల్ట్ (డిఫాల్ట్) కన్స్ట్రక్టర్ యూజర్ అందించారు.
కాబట్టి, వినియోగదారు దీనిని వ్రాశారు.
కాబట్టి, మీరు సహజంగా ప్రారంభించిన తర్వాత మొదటి ముద్రణ చేసినప్పుడు, 0 మరియు 0 యొక్క సహేతుకమైన విలువతో ఒక ప్రారంభీకరణ ఉన్నందున, సహేతుకమైన ప్రారంభ విలువలు ఉన్నాయని మీరు అనుకుంటారు, మునుపటి ఉదాహరణలో మన దగ్గర ఉన్న చెత్త రకం కాదు. నేను. చూసింది
అదేవిధంగా, ఒక డిస్ట్రక్టర్ కూడా ఇక్కడ ఇవ్వబడింది.
ఈ సందర్భంలో, డిస్ట్రక్టర్ ఈ సందేశాన్ని ప్రింట్ చేస్తుంది.
వాస్తవానికి ఒక విధ్వంసకుడు సంక్లిష్ట తరగతి కోసం ఏమీ చేయలేడు, కాని ఒకదాన్ని ఖాళీ శరీరంతో అందించడం ఎల్లప్పుడూ మంచిది.
దీనితో మేము నిర్మాణం మరియు విధ్వంసం ప్రక్రియను ఆపుతాము.
ప్రతి తరగతికి ఒక డిస్ట్రక్టర్ ఉంటుందని మేము తెలుసుకున్నాము, ఇది ప్రత్యేకమైనది మరియు ఇది ఆటోమేటిక్ వస్తువుల కోసం ఉంటుంది, ఈ స్కోప్ చివరిలో పొందబడుతుంది మరియు ఈ డిస్ట్రక్టర్ లోపల, మనం పట్టుకున్న ఏ రకమైన వనరులను అయినా శుభ్రం చేయవచ్చు, మరియు కంపైలర్ డిఫాల్ట్ కన్స్ట్రక్టర్ మరియు డిఫాల్ట్ డిస్ట్రక్టర్ను కూడా అందిస్తుందని మేము చూశాము. వినియోగదారు క్లాస్ కోసం కన్స్ట్రక్టర్ లేదా కన్స్ట్రక్టర్ వ్రాయకపోతే ఇది జరుగుతుంది.
inhouse/NPTEL/PreFinal/c++/Telugu/29 ProgramminginCplusplus_InheritancePart II (Lecture 37)-dLpoq_00DjU(3).txt
View file @ 956c0d4e

1. ప్రోగ్రామింగ్  C ++ లో మాడ్యూల్ 22 కు స్వాగతం.
2. గత మాడ్యూల్ నుండి, మేము ఇన్హెరిటెన్స్ పై చర్చిస్తున్నట్లు; మేము ఇన్హెరిటెన్స్ గా C ++ లో మోడలింగ్, ఎన్కోడింగ్, ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్, generalization మరియు స్పెషలైజేషన్ సంబంధాల యొక్క ISA సంబంధంలో ఒక ప్రాథమిక మెకానిజం.
3. మరియు, ల్యాంగ్వేజ్ లో ప్రాథమిక ఇన్హెరిటెన్స్ సమాచారం ఎలా కోడ్ చేయబడిందో తెలుసుకున్నము.
4. ఈ మాడ్యూల్‌లో, ఇన్హెరిటెన్స్ డేటా సభ్యులు మరియు సభ్యుల పనితీరును ఎలా ప్రభావితం చేస్తుందో చర్చించడానికి ప్రయత్నిస్తాము, ఇది వారసత్వం, డేటా సభ్యులు మరియు సభ్యుల ఫంక్షన్ కింద ఉంది. ఏమి జరుగుతుంది.
5. సభ్యుల ఫంక్షన్లను అధిగమిస్తున్నది ఏమిటో అర్థం చేసుకోవడానికి మేము ప్రయత్నిస్తాము మరియు మీకు ఇప్పటికే తెలిసిన ఓవర్‌లోడింగ్ భావనతో ఇది ఎలా సంకర్షణ చెందుతుంది.
6. ఇది రూపురేఖలు మరియు మునుపటి మాడ్యూల్‌లో నేను చెప్పినట్లుగా, ఇది వారసత్వ మొత్తం ఫ్రేమ్‌వర్క్; మరియు నీలం విభాగం అంటే ఈ ప్రస్తుత మాడ్యూల్‌లో మనం చర్చిస్తాము.
7. కాబట్టి, రీక్యాప్ చేయడానికి, ఇది ఇన్హెరిటెన్స్ అనే పదం యొక్క వారసత్వ అంశం.
8. కాబట్టి, డేటా సభ్యులతో, సభ్యుల పనితీరు, యాక్సెస్ స్పెసిఫికేషన్, నిర్మాణం, విధ్వంసం, ఆబ్జెక్ట్ జీవితకాలం వంటి అన్ని అంశాల గురించి మనకు ఏమి ఉంది, దాని గురించి అర్థం చేసుకోవాలి.
9. మరియు ఇక్కడ మేము డేటా సభ్యుల గురించి చర్చించటం ప్రారంభించాము.
10. ఇప్పుడు ISA బేస్ సాధించినట్లయితే, అప్పుడు ISA రూట్ అనేది మేము ఎన్కోడ్ చేయడానికి ప్రయత్నిస్తున్న ఒక సంబంధం.
11. అప్పుడు ఉత్పన్నమైన తరగతి బేస్ క్లాస్ యొక్క అన్ని డేటా సభ్యులను వారసత్వంగా తిరిగి ఇస్తుందని మనం చూస్తాము.
12. వారసత్వ విషయంలో ఇది నిజం.
13. అదనంగా, ఉత్పన్నమైన తరగతి కొన్ని అదనపు డేటా సభ్యులతో, దాని స్వంత డేటా సభ్యులను జోడించగలదు.
14. కాబట్టి, ఆబ్జెక్ట్ యొక్క లేఅవుట్ గురించి మాకు ఖచ్చితమైన సూచన ఉంటే, మేము మునుపటి మాడ్యూళ్ళలో కొన్ని వస్తువుల లేఅవుట్ గురించి మాట్లాడామని మీరు గుర్తుంచుకుంటారు.
15. మరియు మీరు భావనల గురించి స్పష్టంగా తెలియకపోతే, ముందుకు వెళ్ళే ముందు నేను మిమ్మల్ని జోడించి, ఆ మాడ్యూళ్ళను తిరిగి సందర్శిస్తాను.
16. కాబట్టి, లేఅవుట్ అనేది ప్రాథమికంగా ఒక తరగతి యొక్క వస్తువులోని వేర్వేరు డేటా సభ్యుల జ్ఞాపకశక్తిలో నిర్వహించబడే సంస్థ.
17. గమనించదగ్గ ముఖ్యమైన విషయం ఏమిటంటే, ఉత్పన్నమైన తరగతి యొక్క లేఅవుట్‌లో ఉత్పన్నమైన తరగతికి బేస్ క్లాస్ యొక్క ఉదాహరణలు ఉంటాయి.
18. ఇది ఇక్కడకు వచ్చే కొత్త విషయం.
19. మరింత సహజంగా, ఉత్పన్నమైన తరగతులు వారి స్వంత సభ్యులను కలిగి ఉంటాయి.
20. మరియు నమూనా డేటా సభ్యుల మాదిరిగా కాకుండా, బేస్ క్లాస్ ఉదాహరణ యొక్క సాపేక్ష స్థానం మరియు ఉత్పన్నమైన తరగతి (తరగతి) సభ్యులకు C ++ లో హామీ లేదు.
21. ఒక ఉదాహరణకి వెళ్దాం మరియు మన ఉద్దేశ్యాన్ని చూడటం ప్రారంభిద్దాం.
22. కాబట్టి, మేము బేస్ క్లాస్ నిర్వచనంతో ప్రారంభిస్తాము, B అనేది బేస్ క్లాస్; దీనికి ఇద్దరు డేటా సభ్యులు ఉన్నారు, నేను ఇద్దరు డేటా సభ్యులను ఏకపక్షంగా కలిగి ఉన్నాను, నేను ఇంకా సభ్యుల విధులను చూపించడం లేదు, డేటా సభ్యులను మాత్రమే చూపిస్తున్నాను, కాబట్టి నేను ఎంటర్ చేసిన డేటా 1 బి_ ఒక ప్రైవేట్ సభ్యుడు మరియు డేటా 2 బి_, ఇది ప్రజా సభ్యుడు.
23. అప్పుడు మనకు మరొక తరగతి D ఉంది, ఇది పబ్లిక్ B; ఇది స్పెషలైజేషన్.
24. అందువల్ల, నేను UML సంజ్ఞామానం పరంగా గీస్తే, మేము ఇక్కడ ప్రదర్శిస్తున్నది, D ISA B.
25. ఇప్పుడు మేము D యొక్క డేటా సభ్యులను చూడటానికి ప్రయత్నించినప్పుడు ఏమి జరుగుతుంది, మేము చెబుతున్నది క్లాస్ D లో డేటా సభ్యుడు డేటా 1B_ ను కలిగి ఉంటామని మరియు మేము స్పష్టంగా చేయకపోయినా వ్రాస్తాము
26. అదేవిధంగా, క్లాస్ బి నుండి వారసత్వంగా క్లాస్ డిలో డేటా సభ్యుడు డేటా 2 బి (డేటా 2 బి) _ ను కలిగి ఉంటాము, అందువల్ల ఈ డేటా సభ్యులను నేను ఇక్కడ హైలైట్ చేస్తున్నాను., వారసత్వంగా కలిసిన వారు; వాటిని ఈ వర్గంలో జాబితా చేయలేము.
27. D ISA B, D యొక్క ప్రతి సందర్భంలోనూ ఇది వారసత్వంలో కనుగొనబడింది, కాని నేను ఇక్కడ ఉంచే infoD_ వంటి కొన్ని అదనపు సభ్యులను కూడా కలిగి ఉండగలను, ఇది D యొక్కది. సభ్యుడు మరియు సభ్యుడు కాదు బి; కాబట్టి, ఇది ఇందులో మాత్రమే ఉంటుంది.
28. ఈ సందర్భంలో, నేను వెంటనే ఒక వస్తువు B ను వ్రాస్తే, నేను ఖచ్చితంగా దాని కోసం ఒక లేఅవుట్ కలిగి ఉంటాను, ఇది మేము ఇప్పటికే చర్చించినట్లుగానే కనిపిస్తుంది.
29. మరియు ఒక సాధారణ లేఅవుట్ సందర్భంలో, మేము చర్చించినది ఏమిటంటే, ఒక తరగతి వేగవంతం అయితే, అది వస్తువు మరియు లేఅవుట్ యొక్క ప్రాథమిక ఆస్తి ఏమిటి.
30. మేము చర్చించిన రెండు ప్రాథమిక లక్షణాలు ఉన్నాయి. అన్ని డేటా సభ్యులకు ఒక వస్తువులో మెమరీలో ఒక స్థలాన్ని కేటాయించబడతాయి, ఇది ఒక వస్తువు యొక్క ప్రారంభ చిరునామా మరియు జ్ఞాపకశక్తిలో అనేక బైట్లు ఉండే పరిమాణం.) ఇది విస్తరిస్తుంది.
31. మరియు ఈ స్పేస్ సమ్మర్‌లోని మొత్తం డేటా సభ్యులు.
32. వస్తువు యొక్క ఒక భాగం జ్ఞాపకశక్తి యొక్క ఒక భాగంలో మరియు మరొక భాగం జ్ఞాపకశక్తి యొక్క మరొక భాగంలో ఉందని ఇది ఎప్పటికీ విచ్ఛిన్నం కాదు.
33. కాబట్టి, సందర్భోచితత అనేది మనం ఇప్పటికే చూసిన లేఅవుట్ యొక్క ప్రాథమిక అవసరం, ఇది ఒకటి.
34. మనం చూసిన రెండవది ఏమిటంటే, మనకు అలాంటి ఇద్దరు డేటా సభ్యులు ఉంటే ఒకరు తరువాత వస్తారు.
35. అందువల్ల, అవి తరగతి యొక్క నిర్వచనంలో ఉంచబడిన క్రమంలో సంభవిస్తాయి, ఈ క్రమం నిర్వహించబడుతుంది.
36. ఇది లేఅవుట్ యొక్క ప్రాథమిక నిర్మాణం.
37. కాబట్టి, నేను B యొక్క లేఅవుట్లో చూస్తే, ఈ విలువ ఇలాంటిదేనని వారు చెప్పారు.
38. ఇప్పుడు మేము దానిని పరిగణలోకి తీసుకుంటాము.
39. D యొక్క లేఅవుట్ ఏమిటి, ప్రత్యేకంగా D లో ఏమి జరుగుతుందో ఖచ్చితంగా దాని స్వంత డేటా సభ్యుడిని కలిగి ఉంటుంది, ఇది అర్థం చేసుకోవడం సులభం.
40. D ISA B D వస్తువు యొక్క ఒక భాగంగా B వస్తువు యొక్క స్పష్టమైన ఉదాహరణ అవుతుంది కాబట్టి.
41. కాబట్టి, D ఇక్కడ వస్తువు కాబట్టి, ఒక భాగానికి B వస్తువు ఉంటుంది మరియు D అంటే ఈ డేటా సభ్యుడి నుండి వారసత్వం అని నేను చెప్పినప్పుడు; నేను నిజంగా D.data1b_ గురించి మాట్లాడితే, ఈ ప్రత్యేక మెమరీ ప్రస్తావించబడుతుంది.
42. మరి ఈ జ్ఞాపకం ఏమిటి? ఈ మెమరీ ఉత్పన్నమైన వస్తువు యొక్క మూల వస్తువు భాగం.
43. అదేవిధంగా, నేను D.data2B_ ని సూచిస్తే, నేను జ్ఞాపకశక్తి యొక్క ఈ ప్రత్యేక భాగాన్ని సూచిస్తున్నాను, ఇది వారసత్వ సంపద ద్వారా వారసత్వంగా మరియు వాస్తవానికి వస్తువు ద్వారా కనుగొనబడుతుంది. దీని ఆధారంగా
44. కాబట్టి, ఇక్కడ చాలా ఆసక్తికరమైన విషయం జరుగుతోందని మీరు చూడవచ్చు, మేము ఇంతకు ముందే చూశాము; నేను వివిధ రకాల డేటా సభ్యుల ఉదాహరణను తీసుకుంటే అది పేర్కొంది.
45. నేను ఇప్పుడే ఇక్కడకు వెళ్లి, నాకు క్లాస్ ఎ ఉందని, నాకు క్లాస్ బి ఉందని, నాకు క్లాస్ సి ఉందని, ఇది ఎ ఎ డేటా సభ్యుడిగా, బి బి ఆబ్జెక్ట్ రూపంలో ఉందని మాకు తెలియజేస్తే, బహుశా డేటా సభ్యుడిగా మరియు ఇటుకగా మరియు మొదలైనవి.
46. అప్పుడు నేను సి యొక్క ఉదాహరణను చూసినప్పుడు, x సి యొక్క ఉదాహరణ. నేను x ని చూసినప్పుడు, నాకు ఒక వస్తువు A ఉంటుంది, Ab ఆబ్జెక్ట్ B అవుతుంది, ఒక Int I మరియు మొదలైనవి.
47. అందువల్ల, వేర్వేరు తరగతుల వేర్వేరు వస్తువులు మరొక తరగతి యొక్క లేఅవుట్లో భాగం కావచ్చని మేము ఇప్పటికే చూశాము.
48. కాబట్టి, ఇది క్లాస్ సి యొక్క క్లాస్ సి మరియు ఆబ్జెక్ట్ ఎక్స్, ఇది ఇతర తరగతుల ఉదాహరణలను కలిగి ఉంది మరియు ఇది భాగం యొక్క భావన.
49. మేము ఇక్కడ గమనించినప్పుడు క్షమించండి, ఇక్కడ మా సమస్యలు కేవలం ఒక సెకనులో మారుతున్నాయని గమనించండి.
50. ఇక్కడ, మేము గమనించినట్లుగా, ISA B లో D కూడా ఒక భాగం కాబట్టి, ఈ భాగం చాలా ప్రత్యేకమైనది, ఎందుకంటే నేను ఏ డేటా సభ్యుడిని కలిగి ఉంటాను, నాకు డేటా సభ్యుడు ఉండకూడదు.
51. నేను వారసత్వం పొందినప్పుడు నేను ఉత్పన్నమైన క్లాస్ ఆబ్జెక్ట్‌లో ఒక ప్రత్యేకమైన భాగాన్ని కలిగి ఉంటాను, ఇది బేస్ కాంపోనెంట్ మరియు ఇది ఆబ్జెక్ట్ లేఅవుట్ పరంగా మీరు చాలా తెలుసుకోవాలి.
52. ఇక్కడ కొన్ని అదనపు గమనికలు ఉన్నాయి, ఇది వెంటనే ముఖ్యమైనది కాదు, కానీ ఇది బేస్ క్లాస్ యొక్క ప్రైవేట్ సభ్యుడు కాబట్టి, ప్రైవేట్ సభ్యుడు బయటి నుండి యాక్సెస్ చేయలేరని మీరు గమనించవచ్చు.
53. అందువల్ల, నేను d.data1B_ ను వ్రాయగలిగాను మరియు ఇది నేను నిజంగా యాక్సెస్ చేయలేని ఈ మెమరీని సూచిస్తుంది, ఎందుకంటే ఇది యాక్సెస్ కాదు ఎందుకంటే అది దానిలో భాగం కాదు, కానీ యాక్సెస్ పరిమితం చేయబడింది.
54. అయితే, నేను పబ్లిక్‌గా ఉన్న ఈ ఇతర సభ్యుని గురించి మాట్లాడితే, నేను d.data2B_ ను వ్రాయగలను, నేను కూడా యాక్సెస్ చేయగలను, ఈ యాక్సెస్ సమస్యల గురించి మనం తరువాత మాట్లాడగలను. నేను దాని గురించి చర్చిస్తాను, కానీ నేను దానిపై వెలుగు చూడాలనుకుంటున్నాను .
55. ఇప్పుడు, సభ్యుల ఫంక్షన్‌తో (ఫంక్షన్) ఏమి జరుగుతుందో పరీక్షించడానికి నేను ముందుకు వెళ్తాను. ఇది అన్ని సభ్యుల ఫంక్షన్లను వారసత్వంగా పొందుతుంది, కాని ముఖ్యమైన విషయం ఏమిటంటే వారసత్వం తరువాత ఈ సభ్యుడు ఫంక్షన్ ఫంక్షన్‌ను భర్తీ చేయగలదు లేదా సభ్యుల ఫంక్షన్‌ను ఓవర్‌లోడ్ చేయగలదు.
56. కాబట్టి, ఈ భావనలను మనం చాలా జాగ్రత్తగా అర్థం చేసుకోవాలి.
57. కాబట్టి, నేను దీనిని ఒక ఉదాహరణతో వివరిస్తాను, కాని ప్రయాణిస్తున్నప్పుడు, స్టాటిక్ మెంబర్ ఫంక్షన్ (మెంబర్ ఫంక్షన్) లేదా ఫ్రెండ్ మెంబర్ ఫంక్షన్ (మెంబర్ ఫంక్షన్) యంత్రాంగం ద్వారా వారసత్వంగా పొందబడిందా లేదా చాలా సరళమైన పదాలు ఉండలేదా అని మీరు గమనించాలనుకుంటున్నాను. వారసత్వంలో కనుగొనబడింది.
58. ఇది సభ్యుల ఫంక్షన్, నాన్-స్టాటిక్ మెంబర్ ఫంక్షన్ (మెంబర్ ఫంక్షన్), లేదా ఈ పాయింటర్ ఉన్న లేదా వాస్తవానికి ఈ సిస్టమ్ యొక్క ఆబ్జెక్ట్ ఉదాహరణతో మాత్రమే అనుబంధించబడిన ఫంక్షన్లు మాత్రమే. మాధ్యమాన్ని వారసత్వంగా పొందవచ్చు.
59. అందువల్ల, స్థిర మరియు స్నేహితుల పనితీరుకు వారసత్వం యొక్క అర్థం చాలా భిన్నంగా ఉంటుందని మేము చూస్తాము.
60. కాబట్టి, మనం ఒక ఉదాహరణకి వెళ్లి, వారసత్వం అంటే ఏమిటో అర్థం చేసుకోవడానికి ప్రయత్నిద్దాం.
61. మొదట నేను మీరు ఈ భాగాన్ని మాత్రమే చూడకూడదని, ఈ భాగాన్ని చూడవద్దు, ఈ భాగాన్ని చూడవద్దు, అది భాగం కానట్లు.
62. కాబట్టి, నాకు క్లాస్ బి ఉంది, నాకు క్లాస్ డి యొక్క ఆధారం ఉంది మరియు ఈ సందర్భంలో సరళత కోసం డెరివేటివ్ రిలేషన్ ఒకేలా ఉంటుంది మరియు నేను డేటా సభ్యుల వైపు చూడటం లేదు, నేను మాత్రమే ఉన్న సభ్యుల చర్యలను చూస్తున్నాను .
63. ప్రాప్యత సమస్య ఖచ్చితంగా సమస్య కాదు.ఇప్పుడు నాకు క్లాస్ బి లో ఫంక్షన్ (ఫంక్షన్) ఎఫ్ మరియు ఫంక్షన్ జి ఉన్నాయి, కాని క్లాస్ డిలో నాకు ఫంక్షన్ (ఫంక్షన్) లేదు, క్లాస్ డి కేవలం ఖాళీ క్లాస్. (క్లాస్).
64. కానీ అప్పుడు కూడా అది f ఫంక్షన్‌ను వారసత్వంగా పొందుతుంది, ఇది g ఫంక్షన్‌ను వారసత్వంగా పొందుతుంది మరియు ఇక్కడ మరొక సంజ్ఞామానాన్ని స్పష్టం చేస్తుంది.ఇది ఒక తరగతి పేరు అని మేము ఇంతకుముందు చెప్పిన సంజ్ఞామానం. స్థానం.
65. కాబట్టి, నేను ఈ తరగతికి దూరంగా ఉంటే, అప్పుడు ఈ ఫంక్షన్ పేరు B :: f.
66. కాబట్టి, B :: f (int) ద్వారా నేను ప్రాథమికంగా ఈ బేస్ క్లాస్ ఫంక్షన్ అని అర్ధం, ఇది బేస్ క్లాస్ అని నా ఉద్దేశ్యం.
67. అందువల్ల, నేను చెప్పేది ఏమిటంటే, మీరు దానిని వారసత్వంగా పొందినట్లయితే, మీకు ఈ బేస్ క్లాస్ ఫంక్షన్లు అందుబాటులో ఉంటాయి.
68. కాబట్టి, దీని అర్థం ఏమిటి, మళ్ళీ ఇక్కడ పర్వాలేదు, దాని అర్థం ఏమిటి, నాకు B మరియు D అనే రెండు ఉదాహరణలు ఉంటే, మరియు నేను ఈ ఫంక్షన్ f మరియు g ను అమలు చేయడానికి ప్రయత్నిస్తాను.
69. సహజంగానే నేను ఇలా చేస్తే, b.f ఆవాహన చేస్తుందని మేము ఇప్పటికే అర్థం చేసుకున్నాము.
70. కాబట్టి, దీని అర్థం ఏమిటంటే ఇక్కడ మళ్లీ చూడలేరు, అంటే నేను రెండు సందర్భాల్లో b మరియు d కలిగి ఉంటే, మరియు ఈ ఫంక్షన్లను f మరియు g లను ప్రయోగించటానికి ప్రయత్నిస్తాను.
71. ఈ ఫంక్షన్ b.g ఈ ఫంక్షన్‌ను ప్రారంభిస్తుంది, ఇది ఆశ్చర్యం కలిగించదు.
72. ఆసక్తికరమైన విషయం ఏమిటంటే, నేను నిజంగా DF ని ప్రారంభించగలను, ఇది క్లాస్ D యొక్క నిర్వచనంలో లేదు, దీనికి ఉదాహరణ చిన్న D ఒక వస్తువు, కానీ ఇప్పటికీ నేను D.F ని ఆహ్వానిస్తున్నాను. ఎందుకంటే D వారసత్వంగా B మరియు B నుండి వారసత్వంగా వస్తుంది .
73. కాబట్టి, నేను d.f ను ప్రారంభించినప్పుడు, నేను నిజంగా బేస్ క్లాస్ యొక్క f ఫంక్షన్ (ఫంక్షన్) ను ప్రారంభిస్తున్నాను.
74. అదేవిధంగా, నేను dg చేస్తే, నేను బేస్ క్లాస్ యొక్క g ఫంక్షన్ (ఫంక్షన్) ను ప్రారంభిస్తున్నాను, సభ్యుల ఫంక్షన్ల వారసత్వం యొక్క ప్రధాన మరియు ప్రవాహం ఇదే, మీరు మీ తల్లిదండ్రుల నుండి అన్ని సభ్యుల ఫంక్షన్లకు (ఫంక్షన్) ఉపయోగించవచ్చు. ) వారసత్వం.
75. ఇప్పుడు, ఈ భాగాన్ని మరచి కుడి వైపు చూద్దాం.
76. మళ్ళీ, అదే బేస్ క్లాస్‌లో తేడా లేదు.నేను మార్చలేదు.
77. అందువల్ల, ఈ వారసత్వాన్ని నేను వారసత్వంగా చూసినట్లుగా, ఉత్పన్నమైన తరగతిగా పొందాను.
78. G సందర్భంలో మేము మళ్ళీ ఏమీ చేయలేదు, కానీ F సందర్భంలో నేను ఆసక్తికరంగా ఏదో చేశాను; నేనేం చేశాను? ఇది (రిఫరెన్స్ సమయం: 16:28) f యొక్క సంతకం లేదా ప్రోటోటైప్ b లో చేర్చబడింది ఎందుకంటే సభ్యుల ఫంక్షన్ ఆ నమూనాను మళ్ళీ d లో ఉంచింది.
79. ఇప్పుడు నేను దీన్ని చేసినప్పుడు నేను మునుపటి ఫంక్షన్‌ను అధిగమిస్తున్నానని చెప్తున్నాను, ఎందుకంటే నేను ఉంచిన క్షణం నేను రెండు ఫంక్షన్ల గురించి మాట్లాడుతున్నాను, ఈ ఫంక్షన్ b :: f మరియు ఈ ఫంక్షన్ (ఫంక్షన్) d :: f.
80. నాకు ఈ ఫంక్షన్ (ఫంక్షన్) లేనప్పుడు మరియు ఇంకా ఉపయోగించాలనుకున్నప్పుడు, నేను బేస్ క్లాస్ ఫంక్షన్ (ఫంక్షన్) ను మాత్రమే అర్థం చేసుకున్నాను, కాని ఇప్పుడు నేను అదే సంతకం ద్వారా అదే సభ్యుల ఫంక్షన్ (సభ్యుల ఫంక్షన్) ను స్పష్టంగా పొందగలను. యొక్క నిర్వచనం
81. కాబట్టి, నాకు మళ్ళీ స్పష్టంగా ఉండనివ్వండి.
82. కాబట్టి, నేను ఇక్కడ వస్తువుల ఉదాహరణలను మళ్ళీ చూస్తే, నేను B మరియు ఆబ్జెక్ట్ తో F మరియు G అని చెబితే దాని ప్రభావం ఖచ్చితంగా ఒకే విధంగా ఉంటుంది.
83. నేను d వస్తువుతో f అని పిలిస్తే ఏమి జరుగుతుంది, గతంలో d కి f లేదు, కానీ ఇప్పుడు ఈ f ని భర్తీ చేస్తుంది.
84. అందువల్ల, నేను ఇప్పుడు d.f అని పిలిస్తే, ఈ ఫంక్షన్ (ఫంక్షన్) అంటే అది ఫంక్షన్ (ఫంక్షన్) అని అర్ధం కాదని అర్ధం కాదు, కాబట్టి ఇది d :: f గా మార్చబడింది.
85. అందువల్ల, మీరు దానిని మునుపటి df (3) తో పోల్చినట్లయితే, ఇది f యొక్క ఫంక్షన్. ఇప్పుడు ఇది f యొక్క ఫంక్షన్ మరియు వారసత్వం క్రింద సభ్యుల ఫంక్షన్ల యొక్క ప్రవర్తనను ఓవర్రైడింగ్ అంటారు.
86. ఓవర్‌రైడింగ్‌లో, మీరు ఓవర్‌రైడింగ్ గురించి మాట్లాడినప్పుడల్లా, మీరు ఒకే పేరుతో మరియు తప్పనిసరిగా ఒక ఫంక్షన్‌కు (ఫంక్షన్) రెండు వేర్వేరు నిర్వచనాలను అటాచ్ చేయడానికి ప్రయత్నిస్తున్నారని అర్థం. అదే సంతకం.
87. అవసరమైన భాగాన్ని ఓవర్‌లోడ్ చేయడానికి సంతకం భిన్నంగా ఉండాలి అని మీరు గుర్తుంచుకోవాలి, కనీసం ఒక పరామితి యొక్క అర్ధంలో సంతకం రెండు ఓవర్‌లోడ్ ఫంక్షన్ల మధ్య తేడా ఉండటానికి పేరు ఫంక్షన్ (ఫంక్షన్) కు సమానం. రిటర్న్ రకం పట్టింపు లేదు, కానీ ఫంక్షన్ పరామితి భిన్నంగా ఉండాలి, మరికొన్ని సంతకం భిన్నంగా ఉండాలి.
88. భర్తీ చేయడానికి, సంతకాలు ఒకేలా ఉండాలి, కానీ అవి రెండు వేర్వేరు తరగతులకు చెందినవి, ఇవి సాధారణీకరణ, ప్రత్యేకత, వారసత్వం, సంబంధం.
89. ఆపై మీరు ఏ నిర్దిష్ట వస్తువును ఉపయోగిస్తున్నారనే దానిపై ఆధారపడి, ఇది ఈ ఫంక్షన్ యొక్క విభిన్న సంస్కరణలను పిలుస్తుంది.
90. అందువల్ల మేము bf ను మీరు ఒక ఫంక్షన్ (ఫంక్షన్) అని పిలిచినప్పుడు మీరు ఈ ఫంక్షన్ (ఫంక్షన్) అని పిలుస్తారు, కానీ మీరు df చేసినప్పుడు మీరు వేరే ఫంక్షన్ (ఫంక్షన్) ను ఓవర్రైడ్ చేస్తారు.
91. సభ్యుల ఫంక్షన్లను భర్తీ చేయడానికి ఇది ప్రాథమిక విధానం, ఇది మొత్తం కథకు చాలా కొత్త విలువను మరియు అర్థాలను జోడిస్తుంది.
92. ఇప్పుడు అదే సమయంలో మీరు b లో మరొక ఫంక్షన్ g ను వారసత్వంగా వారసత్వంగా చూస్తే, కానీ ఆ ఫంక్షన్ (ఫంక్షన్) అధిగమించబడదు, అది మనకు G యొక్క క్రొత్త సంతకం కొత్త సంతకాన్ని కలిగి ఉండదు.
93. కాబట్టి, ఈ సందర్భంలో నేను DG అని చెబితే, మేము నిజంగా B లో ఒక ఫంక్షన్ అని పిలుస్తాము, ఎందుకంటే ఇది వారసత్వంగా కనిపించే ఒక ఫంక్షన్.
94. కాబట్టి, ఎడమ మరియు కుడి మధ్య ఈ ప్రవర్తన d.g (4) ను మార్చదు, ఎందుకంటే G ఇన్హెరిటెన్స్లో కనుగొనబడలేదు, ఇది వారసత్వం తరువాత D తరగతిలో భర్తీ చేయబడదు.
95. అందువల్ల, వారసత్వంలో కనిపించే మలినాల మధ్య తేడా ఏమిటో ఇది స్పష్టంగా తెలుపుతుంది.
96. ఒక పని యొక్క వారసత్వం మరియు వారసత్వం మరియు భర్తీ చేయడం.
97. మొత్తం విషయం చాలా రుచిగా ఉంటుంది, నేను దానిని ఒక ఫంక్షన్‌గా ఓవర్‌లోడ్ చేయగలను, ఇది బేస్ క్లాస్.
98. ఇప్పుడు ఈ రెండింటిని చూడండి మరియు ఇది తరచూ విద్యార్థులను కలవరపెడుతుంది మరియు మీకు తెలుసు.
99. నేను ఏమి చేస్తున్నానో, నేను ఏమి చేస్తున్నానో ఓవర్లోడ్ చేస్తున్నాను.
100. ఇక్కడ ఉన్న ప్రత్యేక లక్షణాలు ఏమిటంటే, ఫంక్షన్ యొక్క సంతకం ఈ రెండు కేసుల మధ్య భిన్నంగా ఉంటుంది.
101. అందువల్ల, క్లాస్ డి కేవలం ఒక క్రొత్త ఫంక్షన్‌ను అనుకోకుండా ప్రారంభిస్తున్నట్లుగా మీకు అనిపిస్తుందని మీకు అనిపించదు, ఇది బి. (వారసత్వం) నుండి ఇప్పటికే వారసత్వంగా పొందిన ఫంక్షన్‌కు అదే పేరు.
102. కాబట్టి, నేను ఈ d.f లాంటిదాన్ని తిరిగి అమలు చేస్తే, కానీ స్ట్రింగ్ సి స్ట్రింగ్ అయిన పరామితితో, దానిని స్ట్రింగ్‌లో stl రకంగా కూడా తీసుకోవచ్చు.
103. ఈ రెండు ఫంక్షన్ల మధ్య ఉన్న ఈ d.f మరియు ఈ df మధ్య, ఓవర్‌లోడింగ్ యొక్క సాధారణ రిజల్యూషన్ పనిచేస్తుంది.
104. మరియు ఈ రకమైన పరామితిని బట్టి, ఇది ఈ ఫంక్షన్‌తో మరియు ఈ ఫంక్షన్‌తో అనుబంధిస్తుంది, మరియు ఈ ఫంక్షన్ తప్పనిసరిగా ఇతర ఫంక్షన్ ఎఫ్ యొక్క ఓవర్‌లోడ్, ఇది మాకు వారసత్వ వారసత్వాన్ని ఇస్తుంది. కనుగొనబడింది మరియు తరువాత భర్తీ చేస్తుంది.
105. అందువల్ల, ఓవర్‌రైడింగ్ మాదిరిగా కాకుండా, ఓవర్‌లోడ్ చేసే రెండు ఫంక్షన్లు నేరుగా లేదా వారసత్వం నుండి ఒకే తరగతికి చెందినవి కావాలి మరియు వాటి సంతకంలో తేడా ఉండాలి. ఈ రెండు ఫంక్షన్ల మధ్య తేడా ఉండటానికి వారికి కనీసం ఒక పరామితి అయినా ఉండాలి.
106. మనకు ఇక్కడ ఓవర్‌లోడింగ్ పరిస్థితి ఉందని చెప్పినప్పుడు ఇది జరుగుతుంది.
107. వీటన్నిటికీ మించి, తరగతి ఖచ్చితంగా క్రొత్త ఫంక్షన్లను ప్రవేశపెట్టగలదు, అనగా కొత్తగా పేరు పెట్టబడిన ఫంక్షన్, దీని అర్థం బేస్ క్లాస్‌కు ఎఫ్ లేని సభ్యుల ఫంక్షన్లతో పేరు సారూప్యత లేదు మరియు ఎఫ్ లేదా జి మరొక ఫంక్షన్ హెచ్ కాదు, ఇది క్లాస్ డి ను జతచేస్తుంది.
108. కాబట్టి, క్లాస్ డి వాస్తవానికి ఆ ఫంక్షన్‌ను ఒక ఆబ్జెక్ట్ ఉదాహరణకి వర్తింపజేయవచ్చు మరియు వాస్తవానికి ఈ ఫంక్షన్ జోడించబడుతుంది.
109. మేము చూస్తున్నట్లుగా, సభ్యుల ఫంక్షన్ల పరంగా నాలుగు డైనమిక్స్ ఉండవచ్చు, ఒకటి మీరు వారసత్వంగా పొందగలిగే G వంటిదాన్ని పొందగలరా మరియు కొన్నింటిని భర్తీ చేయగలదా అనేది ఒకటి. సంతకం అదే విధంగా ఉంటుంది.
110. కానీ మీరు పునర్నిర్వచించుకుంటున్నారు, కాబట్టి ఈ ఫంక్షన్ అమలులో మీరు దానికి శరీరాన్ని జోడించినప్పుడు ఈ ఫంక్షన్ (ఫంక్షన్) b.f (int) గా అమలు అయ్యే అవకాశం ఉంది.
111. మరియు ఈ ఫంక్షన్ యొక్క అమలు D :: f దీనికి ఒక శరీరాన్ని జోడిస్తుంది. ఇవి బహుశా మారుతూ ఉంటాయి, కానీ సంతకం ఒకటే. మనకు రెండవ కేసును అధిగమిస్తుంది, మూడవది మీరు చేయగల రెండు సభ్యుల ఫంక్షన్ల మధ్య మునుపటిలా ఓవర్‌లోడ్ కొనసాగించండి.
112. ఒకే స్కోప్‌లో ఒకే పేరుతో రెండు ఫంక్షన్‌లు ఓవర్‌లోడ్ అవ్వడానికి వేర్వేరు పారామితులను కలిగి ఉండాలి మరియు నాల్గవది మనం ఇంకా కొత్త సభ్యుల ఫంక్షన్‌ను (సభ్యుల ఫంక్షన్) జోడించగలము.
113. కాబట్టి, తరగతి మరియు తరగతి యొక్క కార్యాచరణను విస్తరించండి.
114. నా స్వభావంలో పునరావృతమైతే ఈ సూత్రాలు అలాంటివి.
115. కాబట్టి, ఆ d ఇప్పుడు మరొక తరగతికి బేస్ క్లాస్‌గా మారవచ్చు మరియు d మరొక తరగతికి బేస్ క్లాస్‌ అయితే, ఈ ఫంక్షన్లన్నీ ఓవర్‌రైడ్ ఎఫ్, ఓవర్‌లోడ్ ఎఫ్.
116. ఇన్హిరిటెన్స్ మరియు హెచ్ ద్వారా ఇక్కడకు వచ్చిన అదృశ్య జి, ఈ నాలుగు విధులు ఏ తరగతి అయినా వారసత్వంలోకి రావడానికి అందుబాటులో ఉంటాయి, ఇది తరగతి. D ఇక్కడ ప్రత్యేకత, ఇక్కడ వారసత్వం గురించి చర్చించడం కొనసాగించడానికి మాడ్యూల్, డేటా సభ్యులు ఒక తరగతి మరొకటి కంటే మెరుగ్గా ఉన్నప్పుడు జరిగే రెండు వారసత్వ భావనలను మేము చర్చించాము.
117. అలాంటప్పుడు, ఉత్పన్నమైన తరగతి తరగతి వస్తువు యొక్క ఒక భాగంగా వస్తువు యొక్క ఉదాహరణ అవుతుంది.
118. మరియు లేఅవుట్ పరంగా మేము గుర్తించాము.
119. బేస్ క్లాస్ ఆబ్జెక్ట్ తక్కువ చిరునామాకు చేరుకుంటుందని మరియు ఉత్పన్నమైన క్లాస్ యొక్క డేటా సభ్యులు అధిక చిరునామా వద్ద ఉంటారని లేదా దీనికి విరుద్ధంగా లేదా ఇతర మిశ్రమంలో ఉంటారని హామీ లేదు.
120. మరియు వారసత్వ పరంగా, సభ్యుల విధులు ఒక తరగతి నుండి ఉద్భవించిన వారసత్వంలోని ఒక బేస్ తరగతి నుండి ఉద్భవించాయని మేము చూశాము, కానీ వారసత్వం తరువాత చాలా ఆసక్తికరంగా ఉంటుంది. సభ్యుల విధులను భర్తీ చేయవచ్చు.
121. మరియు ఆ సందర్భంలో, ఓవర్‌లోడింగ్ యొక్క ప్రాథమిక నియమాలు కూడా పని చేస్తూనే ఉంటాయి.
122.
 ప్రోగ్రామింగ్  C ++ లో మాడ్యూల్ 22 కు స్వాగతం.
గత మాడ్యూల్ నుండి, మేము ఇన్హెరిటెన్స్ పై చర్చిస్తున్నట్లు; మేము ఇన్హెరిటెన్స్ గా C ++ లో మోడలింగ్, ఎన్కోడింగ్, ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్, generalization మరియు స్పెషలైజేషన్ సంబంధాల యొక్క ISA సంబంధంలో ఒక ప్రాథమిక మెకానిజం.
మరియు, ల్యాంగ్వేజ్ లో ప్రాథమిక ఇన్హెరిటెన్స్ సమాచారం ఎలా కోడ్ చేయబడిందో తెలుసుకున్నము.
ఈ మాడ్యూల్‌లో, ఇన్హెరిటెన్స్ డేటా సభ్యులు మరియు సభ్యుల పనితీరును ఎలా ప్రభావితం చేస్తుందో చర్చించడానికి ప్రయత్నిస్తాము, ఇది వారసత్వం, డేటా సభ్యులు మరియు సభ్యుల ఫంక్షన్ కింద ఉంది. ఏమి జరుగుతుంది.
సభ్యుల ఫంక్షన్లను అధిగమిస్తున్నది ఏమిటో అర్థం చేసుకోవడానికి మేము ప్రయత్నిస్తాము మరియు మీకు ఇప్పటికే తెలిసిన ఓవర్‌లోడింగ్ భావనతో ఇది ఎలా సంకర్షణ చెందుతుంది.
ఇది రూపురేఖలు మరియు మునుపటి మాడ్యూల్‌లో నేను చెప్పినట్లుగా, ఇది వారసత్వ మొత్తం ఫ్రేమ్‌వర్క్; మరియు నీలం విభాగం అంటే ఈ ప్రస్తుత మాడ్యూల్‌లో మనం చర్చిస్తాము.
కాబట్టి, రీక్యాప్ చేయడానికి, ఇది ఇన్హెరిటెన్స్ అనే పదం యొక్క వారసత్వ అంశం.
కాబట్టి, డేటా సభ్యులతో, సభ్యుల పనితీరు, యాక్సెస్ స్పెసిఫికేషన్, నిర్మాణం, విధ్వంసం, ఆబ్జెక్ట్ జీవితకాలం వంటి అన్ని అంశాల గురించి మనకు ఏమి ఉంది, దాని గురించి అర్థం చేసుకోవాలి.
మరియు ఇక్కడ మేము డేటా సభ్యుల గురించి చర్చించటం ప్రారంభించాము.
ఇప్పుడు ISA బేస్ సాధించినట్లయితే, అప్పుడు ISA రూట్ అనేది మేము ఎన్కోడ్ చేయడానికి ప్రయత్నిస్తున్న ఒక సంబంధం.
అప్పుడు ఉత్పన్నమైన తరగతి బేస్ క్లాస్ యొక్క అన్ని డేటా సభ్యులను వారసత్వంగా తిరిగి ఇస్తుందని మనం చూస్తాము.
వారసత్వ విషయంలో ఇది నిజం.
అదనంగా, ఉత్పన్నమైన తరగతి కొన్ని అదనపు డేటా సభ్యులతో, దాని స్వంత డేటా సభ్యులను జోడించగలదు.
కాబట్టి, ఆబ్జెక్ట్ యొక్క లేఅవుట్ గురించి మాకు ఖచ్చితమైన సూచన ఉంటే, మేము మునుపటి మాడ్యూళ్ళలో కొన్ని వస్తువుల లేఅవుట్ గురించి మాట్లాడామని మీరు గుర్తుంచుకుంటారు.
మరియు మీరు భావనల గురించి స్పష్టంగా తెలియకపోతే, ముందుకు వెళ్ళే ముందు నేను మిమ్మల్ని జోడించి, ఆ మాడ్యూళ్ళను తిరిగి సందర్శిస్తాను.
కాబట్టి, లేఅవుట్ అనేది ప్రాథమికంగా ఒక తరగతి యొక్క వస్తువులోని వేర్వేరు డేటా సభ్యుల జ్ఞాపకశక్తిలో నిర్వహించబడే సంస్థ.
గమనించదగ్గ ముఖ్యమైన విషయం ఏమిటంటే, ఉత్పన్నమైన తరగతి యొక్క లేఅవుట్‌లో ఉత్పన్నమైన తరగతికి బేస్ క్లాస్ యొక్క ఉదాహరణలు ఉంటాయి.
ఇది ఇక్కడకు వచ్చే కొత్త విషయం.
మరింత సహజంగా, ఉత్పన్నమైన తరగతులు వారి స్వంత సభ్యులను కలిగి ఉంటాయి.
మరియు నమూనా డేటా సభ్యుల మాదిరిగా కాకుండా, బేస్ క్లాస్ ఉదాహరణ యొక్క సాపేక్ష స్థానం మరియు ఉత్పన్నమైన తరగతి (తరగతి) సభ్యులకు C ++ లో హామీ లేదు.
ఒక ఉదాహరణకి వెళ్దాం మరియు మన ఉద్దేశ్యాన్ని చూడటం ప్రారంభిద్దాం.
కాబట్టి, మేము బేస్ క్లాస్ నిర్వచనంతో ప్రారంభిస్తాము, B అనేది బేస్ క్లాస్; దీనికి ఇద్దరు డేటా సభ్యులు ఉన్నారు, నేను ఇద్దరు డేటా సభ్యులను ఏకపక్షంగా కలిగి ఉన్నాను, నేను ఇంకా సభ్యుల విధులను చూపించడం లేదు, డేటా సభ్యులను మాత్రమే చూపిస్తున్నాను, కాబట్టి నేను ఎంటర్ చేసిన డేటా 1 బి_ ఒక ప్రైవేట్ సభ్యుడు మరియు డేటా 2 బి_, ఇది ప్రజా సభ్యుడు.
అప్పుడు మనకు మరొక తరగతి D ఉంది, ఇది పబ్లిక్ B; ఇది స్పెషలైజేషన్.
అందువల్ల, నేను UML సంజ్ఞామానం పరంగా గీస్తే, మేము ఇక్కడ ప్రదర్శిస్తున్నది, D ISA B.
ఇప్పుడు మేము D యొక్క డేటా సభ్యులను చూడటానికి ప్రయత్నించినప్పుడు ఏమి జరుగుతుంది, మేము చెబుతున్నది క్లాస్ D లో డేటా సభ్యుడు డేటా 1B_ ను కలిగి ఉంటామని మరియు మేము స్పష్టంగా చేయకపోయినా వ్రాస్తాము
అదేవిధంగా, క్లాస్ బి నుండి వారసత్వంగా క్లాస్ డిలో డేటా సభ్యుడు డేటా 2 బి (డేటా 2 బి) _ ను కలిగి ఉంటాము, అందువల్ల ఈ డేటా సభ్యులను నేను ఇక్కడ హైలైట్ చేస్తున్నాను., వారసత్వంగా కలిసిన వారు; వాటిని ఈ వర్గంలో జాబితా చేయలేము.
D ISA B, D యొక్క ప్రతి సందర్భంలోనూ ఇది వారసత్వంలో కనుగొనబడింది, కాని నేను ఇక్కడ ఉంచే infoD_ వంటి కొన్ని అదనపు సభ్యులను కూడా కలిగి ఉండగలను, ఇది D యొక్కది. సభ్యుడు మరియు సభ్యుడు కాదు బి; కాబట్టి, ఇది ఇందులో మాత్రమే ఉంటుంది.
ఈ సందర్భంలో, నేను వెంటనే ఒక వస్తువు B ను వ్రాస్తే, నేను ఖచ్చితంగా దాని కోసం ఒక లేఅవుట్ కలిగి ఉంటాను, ఇది మేము ఇప్పటికే చర్చించినట్లుగానే కనిపిస్తుంది.
మరియు ఒక సాధారణ లేఅవుట్ సందర్భంలో, మేము చర్చించినది ఏమిటంటే, ఒక తరగతి వేగవంతం అయితే, అది వస్తువు మరియు లేఅవుట్ యొక్క ప్రాథమిక ఆస్తి ఏమిటి.
మేము చర్చించిన రెండు ప్రాథమిక లక్షణాలు ఉన్నాయి. అన్ని డేటా సభ్యులకు ఒక వస్తువులో మెమరీలో ఒక స్థలాన్ని కేటాయించబడతాయి, ఇది ఒక వస్తువు యొక్క ప్రారంభ చిరునామా మరియు జ్ఞాపకశక్తిలో అనేక బైట్లు ఉండే పరిమాణం.) ఇది విస్తరిస్తుంది.
మరియు ఈ స్పేస్ సమ్మర్‌లోని మొత్తం డేటా సభ్యులు.
వస్తువు యొక్క ఒక భాగం జ్ఞాపకశక్తి యొక్క ఒక భాగంలో మరియు మరొక భాగం జ్ఞాపకశక్తి యొక్క మరొక భాగంలో ఉందని ఇది ఎప్పటికీ విచ్ఛిన్నం కాదు.
కాబట్టి, సందర్భోచితత అనేది మనం ఇప్పటికే చూసిన లేఅవుట్ యొక్క ప్రాథమిక అవసరం, ఇది ఒకటి.
మనం చూసిన రెండవది ఏమిటంటే, మనకు అలాంటి ఇద్దరు డేటా సభ్యులు ఉంటే ఒకరు తరువాత వస్తారు.
అందువల్ల, అవి తరగతి యొక్క నిర్వచనంలో ఉంచబడిన క్రమంలో సంభవిస్తాయి, ఈ క్రమం నిర్వహించబడుతుంది.
ఇది లేఅవుట్ యొక్క ప్రాథమిక నిర్మాణం.
కాబట్టి, నేను B యొక్క లేఅవుట్లో చూస్తే, ఈ విలువ ఇలాంటిదేనని వారు చెప్పారు.
ఇప్పుడు మేము దానిని పరిగణలోకి తీసుకుంటాము.
D యొక్క లేఅవుట్ ఏమిటి, ప్రత్యేకంగా D లో ఏమి జరుగుతుందో ఖచ్చితంగా దాని స్వంత డేటా సభ్యుడిని కలిగి ఉంటుంది, ఇది అర్థం చేసుకోవడం సులభం.
D ISA B D వస్తువు యొక్క ఒక భాగంగా B వస్తువు యొక్క స్పష్టమైన ఉదాహరణ అవుతుంది కాబట్టి.
కాబట్టి, D ఇక్కడ వస్తువు కాబట్టి, ఒక భాగానికి B వస్తువు ఉంటుంది మరియు D అంటే ఈ డేటా సభ్యుడి నుండి వారసత్వం అని నేను చెప్పినప్పుడు; నేను నిజంగా D.data1b_ గురించి మాట్లాడితే, ఈ ప్రత్యేక మెమరీ ప్రస్తావించబడుతుంది.
మరి ఈ జ్ఞాపకం ఏమిటి? ఈ మెమరీ ఉత్పన్నమైన వస్తువు యొక్క మూల వస్తువు భాగం.
అదేవిధంగా, నేను D.data2B_ ని సూచిస్తే, నేను జ్ఞాపకశక్తి యొక్క ఈ ప్రత్యేక భాగాన్ని సూచిస్తున్నాను, ఇది వారసత్వ సంపద ద్వారా వారసత్వంగా మరియు వాస్తవానికి వస్తువు ద్వారా కనుగొనబడుతుంది. దీని ఆధారంగా
కాబట్టి, ఇక్కడ చాలా ఆసక్తికరమైన విషయం జరుగుతోందని మీరు చూడవచ్చు, మేము ఇంతకు ముందే చూశాము; నేను వివిధ రకాల డేటా సభ్యుల ఉదాహరణను తీసుకుంటే అది పేర్కొంది.
నేను ఇప్పుడే ఇక్కడకు వెళ్లి, నాకు క్లాస్ ఎ ఉందని, నాకు క్లాస్ బి ఉందని, నాకు క్లాస్ సి ఉందని, ఇది ఎ ఎ డేటా సభ్యుడిగా, బి బి ఆబ్జెక్ట్ రూపంలో ఉందని మాకు తెలియజేస్తే, బహుశా డేటా సభ్యుడిగా మరియు ఇటుకగా మరియు మొదలైనవి.
అప్పుడు నేను సి యొక్క ఉదాహరణను చూసినప్పుడు, x సి యొక్క ఉదాహరణ. నేను x ని చూసినప్పుడు, నాకు ఒక వస్తువు A ఉంటుంది, Ab ఆబ్జెక్ట్ B అవుతుంది, ఒక Int I మరియు మొదలైనవి.
అందువల్ల, వేర్వేరు తరగతుల వేర్వేరు వస్తువులు మరొక తరగతి యొక్క లేఅవుట్లో భాగం కావచ్చని మేము ఇప్పటికే చూశాము.
కాబట్టి, ఇది క్లాస్ సి యొక్క క్లాస్ సి మరియు ఆబ్జెక్ట్ ఎక్స్, ఇది ఇతర తరగతుల ఉదాహరణలను కలిగి ఉంది మరియు ఇది భాగం యొక్క భావన.
మేము ఇక్కడ గమనించినప్పుడు క్షమించండి, ఇక్కడ మా సమస్యలు కేవలం ఒక సెకనులో మారుతున్నాయని గమనించండి.
ఇక్కడ, మేము గమనించినట్లుగా, ISA B లో D కూడా ఒక భాగం కాబట్టి, ఈ భాగం చాలా ప్రత్యేకమైనది, ఎందుకంటే నేను ఏ డేటా సభ్యుడిని కలిగి ఉంటాను, నాకు డేటా సభ్యుడు ఉండకూడదు.
నేను వారసత్వం పొందినప్పుడు నేను ఉత్పన్నమైన క్లాస్ ఆబ్జెక్ట్‌లో ఒక ప్రత్యేకమైన భాగాన్ని కలిగి ఉంటాను, ఇది బేస్ కాంపోనెంట్ మరియు ఇది ఆబ్జెక్ట్ లేఅవుట్ పరంగా మీరు చాలా తెలుసుకోవాలి.
ఇక్కడ కొన్ని అదనపు గమనికలు ఉన్నాయి, ఇది వెంటనే ముఖ్యమైనది కాదు, కానీ ఇది బేస్ క్లాస్ యొక్క ప్రైవేట్ సభ్యుడు కాబట్టి, ప్రైవేట్ సభ్యుడు బయటి నుండి యాక్సెస్ చేయలేరని మీరు గమనించవచ్చు.
అందువల్ల, నేను d.data1B_ ను వ్రాయగలిగాను మరియు ఇది నేను నిజంగా యాక్సెస్ చేయలేని ఈ మెమరీని సూచిస్తుంది, ఎందుకంటే ఇది యాక్సెస్ కాదు ఎందుకంటే అది దానిలో భాగం కాదు, కానీ యాక్సెస్ పరిమితం చేయబడింది.
అయితే, నేను పబ్లిక్‌గా ఉన్న ఈ ఇతర సభ్యుని గురించి మాట్లాడితే, నేను d.data2B_ ను వ్రాయగలను, నేను కూడా యాక్సెస్ చేయగలను, ఈ యాక్సెస్ సమస్యల గురించి మనం తరువాత మాట్లాడగలను. నేను దాని గురించి చర్చిస్తాను, కానీ నేను దానిపై వెలుగు చూడాలనుకుంటున్నాను .
ఇప్పుడు, సభ్యుల ఫంక్షన్‌తో (ఫంక్షన్) ఏమి జరుగుతుందో పరీక్షించడానికి నేను ముందుకు వెళ్తాను. ఇది అన్ని సభ్యుల ఫంక్షన్లను వారసత్వంగా పొందుతుంది, కాని ముఖ్యమైన విషయం ఏమిటంటే వారసత్వం తరువాత ఈ సభ్యుడు ఫంక్షన్ ఫంక్షన్‌ను భర్తీ చేయగలదు లేదా సభ్యుల ఫంక్షన్‌ను ఓవర్‌లోడ్ చేయగలదు.
కాబట్టి, ఈ భావనలను మనం చాలా జాగ్రత్తగా అర్థం చేసుకోవాలి.
కాబట్టి, నేను దీనిని ఒక ఉదాహరణతో వివరిస్తాను, కాని ప్రయాణిస్తున్నప్పుడు, స్టాటిక్ మెంబర్ ఫంక్షన్ (మెంబర్ ఫంక్షన్) లేదా ఫ్రెండ్ మెంబర్ ఫంక్షన్ (మెంబర్ ఫంక్షన్) యంత్రాంగం ద్వారా వారసత్వంగా పొందబడిందా లేదా చాలా సరళమైన పదాలు ఉండలేదా అని మీరు గమనించాలనుకుంటున్నాను. వారసత్వంలో కనుగొనబడింది.
ఇది సభ్యుల ఫంక్షన్, నాన్-స్టాటిక్ మెంబర్ ఫంక్షన్ (మెంబర్ ఫంక్షన్), లేదా ఈ పాయింటర్ ఉన్న లేదా వాస్తవానికి ఈ సిస్టమ్ యొక్క ఆబ్జెక్ట్ ఉదాహరణతో మాత్రమే అనుబంధించబడిన ఫంక్షన్లు మాత్రమే. మాధ్యమాన్ని వారసత్వంగా పొందవచ్చు.
అందువల్ల, స్థిర మరియు స్నేహితుల పనితీరుకు వారసత్వం యొక్క అర్థం చాలా భిన్నంగా ఉంటుందని మేము చూస్తాము.
కాబట్టి, మనం ఒక ఉదాహరణకి వెళ్లి, వారసత్వం అంటే ఏమిటో అర్థం చేసుకోవడానికి ప్రయత్నిద్దాం.
మొదట నేను మీరు ఈ భాగాన్ని మాత్రమే చూడకూడదని, ఈ భాగాన్ని చూడవద్దు, ఈ భాగాన్ని చూడవద్దు, అది భాగం కానట్లు.
కాబట్టి, నాకు క్లాస్ బి ఉంది, నాకు క్లాస్ డి యొక్క ఆధారం ఉంది మరియు ఈ సందర్భంలో సరళత కోసం డెరివేటివ్ రిలేషన్ ఒకేలా ఉంటుంది మరియు నేను డేటా సభ్యుల వైపు చూడటం లేదు, నేను మాత్రమే ఉన్న సభ్యుల చర్యలను చూస్తున్నాను .
ప్రాప్యత సమస్య ఖచ్చితంగా సమస్య కాదు.ఇప్పుడు నాకు క్లాస్ బి లో ఫంక్షన్ (ఫంక్షన్) ఎఫ్ మరియు ఫంక్షన్ జి ఉన్నాయి, కాని క్లాస్ డిలో నాకు ఫంక్షన్ (ఫంక్షన్) లేదు, క్లాస్ డి కేవలం ఖాళీ క్లాస్. (క్లాస్).
కానీ అప్పుడు కూడా అది f ఫంక్షన్‌ను వారసత్వంగా పొందుతుంది, ఇది g ఫంక్షన్‌ను వారసత్వంగా పొందుతుంది మరియు ఇక్కడ మరొక సంజ్ఞామానాన్ని స్పష్టం చేస్తుంది.ఇది ఒక తరగతి పేరు అని మేము ఇంతకుముందు చెప్పిన సంజ్ఞామానం. స్థానం.
కాబట్టి, నేను ఈ తరగతికి దూరంగా ఉంటే, అప్పుడు ఈ ఫంక్షన్ పేరు B :: f.
కాబట్టి, B :: f (int) ద్వారా నేను ప్రాథమికంగా ఈ బేస్ క్లాస్ ఫంక్షన్ అని అర్ధం, ఇది బేస్ క్లాస్ అని నా ఉద్దేశ్యం.
అందువల్ల, నేను చెప్పేది ఏమిటంటే, మీరు దానిని వారసత్వంగా పొందినట్లయితే, మీకు ఈ బేస్ క్లాస్ ఫంక్షన్లు అందుబాటులో ఉంటాయి.
కాబట్టి, దీని అర్థం ఏమిటి, మళ్ళీ ఇక్కడ పర్వాలేదు, దాని అర్థం ఏమిటి, నాకు B మరియు D అనే రెండు ఉదాహరణలు ఉంటే, మరియు నేను ఈ ఫంక్షన్ f మరియు g ను అమలు చేయడానికి ప్రయత్నిస్తాను.
సహజంగానే నేను ఇలా చేస్తే, b.f ఆవాహన చేస్తుందని మేము ఇప్పటికే అర్థం చేసుకున్నాము.
కాబట్టి, దీని అర్థం ఏమిటంటే ఇక్కడ మళ్లీ చూడలేరు, అంటే నేను రెండు సందర్భాల్లో b మరియు d కలిగి ఉంటే, మరియు ఈ ఫంక్షన్లను f మరియు g లను ప్రయోగించటానికి ప్రయత్నిస్తాను.
ఈ ఫంక్షన్ b.g ఈ ఫంక్షన్‌ను ప్రారంభిస్తుంది, ఇది ఆశ్చర్యం కలిగించదు.
ఆసక్తికరమైన విషయం ఏమిటంటే, నేను నిజంగా DF ని ప్రారంభించగలను, ఇది క్లాస్ D యొక్క నిర్వచనంలో లేదు, దీనికి ఉదాహరణ చిన్న D ఒక వస్తువు, కానీ ఇప్పటికీ నేను D.F ని ఆహ్వానిస్తున్నాను. ఎందుకంటే D వారసత్వంగా B మరియు B నుండి వారసత్వంగా వస్తుంది .
కాబట్టి, నేను d.f ను ప్రారంభించినప్పుడు, నేను నిజంగా బేస్ క్లాస్ యొక్క f ఫంక్షన్ (ఫంక్షన్) ను ప్రారంభిస్తున్నాను.
అదేవిధంగా, నేను dg చేస్తే, నేను బేస్ క్లాస్ యొక్క g ఫంక్షన్ (ఫంక్షన్) ను ప్రారంభిస్తున్నాను, సభ్యుల ఫంక్షన్ల వారసత్వం యొక్క ప్రధాన మరియు ప్రవాహం ఇదే, మీరు మీ తల్లిదండ్రుల నుండి అన్ని సభ్యుల ఫంక్షన్లకు (ఫంక్షన్) ఉపయోగించవచ్చు. ) వారసత్వం.
ఇప్పుడు, ఈ భాగాన్ని మరచి కుడి వైపు చూద్దాం.
మళ్ళీ, అదే బేస్ క్లాస్‌లో తేడా లేదు.నేను మార్చలేదు.
అందువల్ల, ఈ వారసత్వాన్ని నేను వారసత్వంగా చూసినట్లుగా, ఉత్పన్నమైన తరగతిగా పొందాను.
G సందర్భంలో మేము మళ్ళీ ఏమీ చేయలేదు, కానీ F సందర్భంలో నేను ఆసక్తికరంగా ఏదో చేశాను; నేనేం చేశాను? ఇది (రిఫరెన్స్ సమయం: 16:28) f యొక్క సంతకం లేదా ప్రోటోటైప్ b లో చేర్చబడింది ఎందుకంటే సభ్యుల ఫంక్షన్ ఆ నమూనాను మళ్ళీ d లో ఉంచింది.
ఇప్పుడు నేను దీన్ని చేసినప్పుడు నేను మునుపటి ఫంక్షన్‌ను అధిగమిస్తున్నానని చెప్తున్నాను, ఎందుకంటే నేను ఉంచిన క్షణం నేను రెండు ఫంక్షన్ల గురించి మాట్లాడుతున్నాను, ఈ ఫంక్షన్ b :: f మరియు ఈ ఫంక్షన్ (ఫంక్షన్) d :: f.
నాకు ఈ ఫంక్షన్ (ఫంక్షన్) లేనప్పుడు మరియు ఇంకా ఉపయోగించాలనుకున్నప్పుడు, నేను బేస్ క్లాస్ ఫంక్షన్ (ఫంక్షన్) ను మాత్రమే అర్థం చేసుకున్నాను, కాని ఇప్పుడు నేను అదే సంతకం ద్వారా అదే సభ్యుల ఫంక్షన్ (సభ్యుల ఫంక్షన్) ను స్పష్టంగా పొందగలను. యొక్క నిర్వచనం
కాబట్టి, నాకు మళ్ళీ స్పష్టంగా ఉండనివ్వండి.
కాబట్టి, నేను ఇక్కడ వస్తువుల ఉదాహరణలను మళ్ళీ చూస్తే, నేను B మరియు ఆబ్జెక్ట్ తో F మరియు G అని చెబితే దాని ప్రభావం ఖచ్చితంగా ఒకే విధంగా ఉంటుంది.
నేను d వస్తువుతో f అని పిలిస్తే ఏమి జరుగుతుంది, గతంలో d కి f లేదు, కానీ ఇప్పుడు ఈ f ని భర్తీ చేస్తుంది.
అందువల్ల, నేను ఇప్పుడు d.f అని పిలిస్తే, ఈ ఫంక్షన్ (ఫంక్షన్) అంటే అది ఫంక్షన్ (ఫంక్షన్) అని అర్ధం కాదని అర్ధం కాదు, కాబట్టి ఇది d :: f గా మార్చబడింది.
అందువల్ల, మీరు దానిని మునుపటి df (3) తో పోల్చినట్లయితే, ఇది f యొక్క ఫంక్షన్. ఇప్పుడు ఇది f యొక్క ఫంక్షన్ మరియు వారసత్వం క్రింద సభ్యుల ఫంక్షన్ల యొక్క ప్రవర్తనను ఓవర్రైడింగ్ అంటారు.
ఓవర్‌రైడింగ్‌లో, మీరు ఓవర్‌రైడింగ్ గురించి మాట్లాడినప్పుడల్లా, మీరు ఒకే పేరుతో మరియు తప్పనిసరిగా ఒక ఫంక్షన్‌కు (ఫంక్షన్) రెండు వేర్వేరు నిర్వచనాలను అటాచ్ చేయడానికి ప్రయత్నిస్తున్నారని అర్థం. అదే సంతకం.
అవసరమైన భాగాన్ని ఓవర్‌లోడ్ చేయడానికి సంతకం భిన్నంగా ఉండాలి అని మీరు గుర్తుంచుకోవాలి, కనీసం ఒక పరామితి యొక్క అర్ధంలో సంతకం రెండు ఓవర్‌లోడ్ ఫంక్షన్ల మధ్య తేడా ఉండటానికి పేరు ఫంక్షన్ (ఫంక్షన్) కు సమానం. రిటర్న్ రకం పట్టింపు లేదు, కానీ ఫంక్షన్ పరామితి భిన్నంగా ఉండాలి, మరికొన్ని సంతకం భిన్నంగా ఉండాలి.
భర్తీ చేయడానికి, సంతకాలు ఒకేలా ఉండాలి, కానీ అవి రెండు వేర్వేరు తరగతులకు చెందినవి, ఇవి సాధారణీకరణ, ప్రత్యేకత, వారసత్వం, సంబంధం.
ఆపై మీరు ఏ నిర్దిష్ట వస్తువును ఉపయోగిస్తున్నారనే దానిపై ఆధారపడి, ఇది ఈ ఫంక్షన్ యొక్క విభిన్న సంస్కరణలను పిలుస్తుంది.
అందువల్ల మేము bf ను మీరు ఒక ఫంక్షన్ (ఫంక్షన్) అని పిలిచినప్పుడు మీరు ఈ ఫంక్షన్ (ఫంక్షన్) అని పిలుస్తారు, కానీ మీరు df చేసినప్పుడు మీరు వేరే ఫంక్షన్ (ఫంక్షన్) ను ఓవర్రైడ్ చేస్తారు.
సభ్యుల ఫంక్షన్లను భర్తీ చేయడానికి ఇది ప్రాథమిక విధానం, ఇది మొత్తం కథకు చాలా కొత్త విలువను మరియు అర్థాలను జోడిస్తుంది.
ఇప్పుడు అదే సమయంలో మీరు b లో మరొక ఫంక్షన్ g ను వారసత్వంగా వారసత్వంగా చూస్తే, కానీ ఆ ఫంక్షన్ (ఫంక్షన్) అధిగమించబడదు, అది మనకు G యొక్క క్రొత్త సంతకం కొత్త సంతకాన్ని కలిగి ఉండదు.
కాబట్టి, ఈ సందర్భంలో నేను DG అని చెబితే, మేము నిజంగా B లో ఒక ఫంక్షన్ అని పిలుస్తాము, ఎందుకంటే ఇది వారసత్వంగా కనిపించే ఒక ఫంక్షన్.
కాబట్టి, ఎడమ మరియు కుడి మధ్య ఈ ప్రవర్తన d.g (4) ను మార్చదు, ఎందుకంటే G ఇన్హెరిటెన్స్లో కనుగొనబడలేదు, ఇది వారసత్వం తరువాత D తరగతిలో భర్తీ చేయబడదు.
అందువల్ల, వారసత్వంలో కనిపించే మలినాల మధ్య తేడా ఏమిటో ఇది స్పష్టంగా తెలుపుతుంది.
ఒక పని యొక్క వారసత్వం మరియు వారసత్వం మరియు భర్తీ చేయడం.
మొత్తం విషయం చాలా రుచిగా ఉంటుంది, నేను దానిని ఒక ఫంక్షన్‌గా ఓవర్‌లోడ్ చేయగలను, ఇది బేస్ క్లాస్.
ఇప్పుడు ఈ రెండింటిని చూడండి మరియు ఇది తరచూ విద్యార్థులను కలవరపెడుతుంది మరియు మీకు తెలుసు.
నేను ఏమి చేస్తున్నానో, నేను ఏమి చేస్తున్నానో ఓవర్లోడ్ చేస్తున్నాను.
ఇక్కడ ఉన్న ప్రత్యేక లక్షణాలు ఏమిటంటే, ఫంక్షన్ యొక్క సంతకం ఈ రెండు కేసుల మధ్య భిన్నంగా ఉంటుంది.
అందువల్ల, క్లాస్ డి కేవలం ఒక క్రొత్త ఫంక్షన్‌ను అనుకోకుండా ప్రారంభిస్తున్నట్లుగా మీకు అనిపిస్తుందని మీకు అనిపించదు, ఇది బి. (వారసత్వం) నుండి ఇప్పటికే వారసత్వంగా పొందిన ఫంక్షన్‌కు అదే పేరు.
కాబట్టి, నేను ఈ d.f లాంటిదాన్ని తిరిగి అమలు చేస్తే, కానీ స్ట్రింగ్ సి స్ట్రింగ్ అయిన పరామితితో, దానిని స్ట్రింగ్‌లో stl రకంగా కూడా తీసుకోవచ్చు.
ఈ రెండు ఫంక్షన్ల మధ్య ఉన్న ఈ d.f మరియు ఈ df మధ్య, ఓవర్‌లోడింగ్ యొక్క సాధారణ రిజల్యూషన్ పనిచేస్తుంది.
మరియు ఈ రకమైన పరామితిని బట్టి, ఇది ఈ ఫంక్షన్‌తో మరియు ఈ ఫంక్షన్‌తో అనుబంధిస్తుంది, మరియు ఈ ఫంక్షన్ తప్పనిసరిగా ఇతర ఫంక్షన్ ఎఫ్ యొక్క ఓవర్‌లోడ్, ఇది మాకు వారసత్వ వారసత్వాన్ని ఇస్తుంది. కనుగొనబడింది మరియు తరువాత భర్తీ చేస్తుంది.
అందువల్ల, ఓవర్‌రైడింగ్ మాదిరిగా కాకుండా, ఓవర్‌లోడ్ చేసే రెండు ఫంక్షన్లు నేరుగా లేదా వారసత్వం నుండి ఒకే తరగతికి చెందినవి కావాలి మరియు వాటి సంతకంలో తేడా ఉండాలి. ఈ రెండు ఫంక్షన్ల మధ్య తేడా ఉండటానికి వారికి కనీసం ఒక పరామితి అయినా ఉండాలి.
మనకు ఇక్కడ ఓవర్‌లోడింగ్ పరిస్థితి ఉందని చెప్పినప్పుడు ఇది జరుగుతుంది.
వీటన్నిటికీ మించి, తరగతి ఖచ్చితంగా క్రొత్త ఫంక్షన్లను ప్రవేశపెట్టగలదు, అనగా కొత్తగా పేరు పెట్టబడిన ఫంక్షన్, దీని అర్థం బేస్ క్లాస్‌కు ఎఫ్ లేని సభ్యుల ఫంక్షన్లతో పేరు సారూప్యత లేదు మరియు ఎఫ్ లేదా జి మరొక ఫంక్షన్ హెచ్ కాదు, ఇది క్లాస్ డి ను జతచేస్తుంది.
కాబట్టి, క్లాస్ డి వాస్తవానికి ఆ ఫంక్షన్‌ను ఒక ఆబ్జెక్ట్ ఉదాహరణకి వర్తింపజేయవచ్చు మరియు వాస్తవానికి ఈ ఫంక్షన్ జోడించబడుతుంది.
మేము చూస్తున్నట్లుగా, సభ్యుల ఫంక్షన్ల పరంగా నాలుగు డైనమిక్స్ ఉండవచ్చు, ఒకటి మీరు వారసత్వంగా పొందగలిగే G వంటిదాన్ని పొందగలరా మరియు కొన్నింటిని భర్తీ చేయగలదా అనేది ఒకటి. సంతకం అదే విధంగా ఉంటుంది.
కానీ మీరు పునర్నిర్వచించుకుంటున్నారు, కాబట్టి ఈ ఫంక్షన్ అమలులో మీరు దానికి శరీరాన్ని జోడించినప్పుడు ఈ ఫంక్షన్ (ఫంక్షన్) b.f (int) గా అమలు అయ్యే అవకాశం ఉంది.
మరియు ఈ ఫంక్షన్ యొక్క అమలు D :: f దీనికి ఒక శరీరాన్ని జోడిస్తుంది. ఇవి బహుశా మారుతూ ఉంటాయి, కానీ సంతకం ఒకటే. మనకు రెండవ కేసును అధిగమిస్తుంది, మూడవది మీరు చేయగల రెండు సభ్యుల ఫంక్షన్ల మధ్య మునుపటిలా ఓవర్‌లోడ్ కొనసాగించండి.
ఒకే స్కోప్‌లో ఒకే పేరుతో రెండు ఫంక్షన్‌లు ఓవర్‌లోడ్ అవ్వడానికి వేర్వేరు పారామితులను కలిగి ఉండాలి మరియు నాల్గవది మనం ఇంకా కొత్త సభ్యుల ఫంక్షన్‌ను (సభ్యుల ఫంక్షన్) జోడించగలము.
కాబట్టి, తరగతి మరియు తరగతి యొక్క కార్యాచరణను విస్తరించండి.
నా స్వభావంలో పునరావృతమైతే ఈ సూత్రాలు అలాంటివి.
కాబట్టి, ఆ d ఇప్పుడు మరొక తరగతికి బేస్ క్లాస్‌గా మారవచ్చు మరియు d మరొక తరగతికి బేస్ క్లాస్‌ అయితే, ఈ ఫంక్షన్లన్నీ ఓవర్‌రైడ్ ఎఫ్, ఓవర్‌లోడ్ ఎఫ్.
ఇన్హిరిటెన్స్ మరియు హెచ్ ద్వారా ఇక్కడకు వచ్చిన అదృశ్య జి, ఈ నాలుగు విధులు ఏ తరగతి అయినా వారసత్వంలోకి రావడానికి అందుబాటులో ఉంటాయి, ఇది తరగతి. D ఇక్కడ ప్రత్యేకత, ఇక్కడ వారసత్వం గురించి చర్చించడం కొనసాగించడానికి మాడ్యూల్, డేటా సభ్యులు ఒక తరగతి మరొకటి కంటే మెరుగ్గా ఉన్నప్పుడు జరిగే రెండు వారసత్వ భావనలను మేము చర్చించాము.
అలాంటప్పుడు, ఉత్పన్నమైన తరగతి తరగతి వస్తువు యొక్క ఒక భాగంగా వస్తువు యొక్క ఉదాహరణ అవుతుంది.
మరియు లేఅవుట్ పరంగా మేము గుర్తించాము.
బేస్ క్లాస్ ఆబ్జెక్ట్ తక్కువ చిరునామాకు చేరుకుంటుందని మరియు ఉత్పన్నమైన క్లాస్ యొక్క డేటా సభ్యులు అధిక చిరునామా వద్ద ఉంటారని లేదా దీనికి విరుద్ధంగా లేదా ఇతర మిశ్రమంలో ఉంటారని హామీ లేదు.
మరియు వారసత్వ పరంగా, సభ్యుల విధులు ఒక తరగతి నుండి ఉద్భవించిన వారసత్వంలోని ఒక బేస్ తరగతి నుండి ఉద్భవించాయని మేము చూశాము, కానీ వారసత్వం తరువాత చాలా ఆసక్తికరంగా ఉంటుంది. సభ్యుల విధులను భర్తీ చేయవచ్చు.
మరియు ఆ సందర్భంలో, ఓవర్‌లోడింగ్ యొక్క ప్రాథమిక నియమాలు కూడా పని చేస్తూనే ఉంటాయి.
inhouse/NPTEL/PreFinal/c++/Telugu/30 ProgramminginCplusplus_Constants and Inline Functions-accmUsQzNk0.txt
View file @ 956c0d4e
 1. C ++  ప్రోగ్రామింగ్ మాడ్యూల్ 6 కు స్వాగతం.
2. మొదటి ఐదు మాడ్యూల్స్లో మనము C ప్రోగ్రామింగ్ లాంగ్వేజ్(programming language), C స్టాండర్డ్ గ్రంథాలయం (standard library) మరియు C భాష యొక్క వివిధ నిర్మాణాలను పునఃపరిశీలించాము.+
3. ప్రాధమిక ఇన్పుట్, అవుట్పుట్, అంకగణిత కార్యకలాపాలు, శ్రేణులు, తీగలను మరియు ముఖ్యంగా డేటా నిర్మాణాన్ని ఉపయోగించడానికి లూప్ రకం ఉదాహరణలతో ప్రారంభించి మేము అనేక ఉదాహరణలు తీసుకున్నాము., C ++ మరియు C ++ లైబ్రరీలో ప్రోగ్రామింగ్ ఎలా ఉంటుందో చూపించడానికి మేము నాలుగు ఉదాహరణలను తీసుకున్నాము లైబ్రరీని న్యాయంగా ఉపయోగించుకోండి.
4. C ++ లో ప్రోగ్రామింగ్ వాస్తవానికి మరింత సమర్థవంతంగా మరియు తక్కువ లోపంతో చేయటం సులభం.
5. ఈ మాడ్యూల్‌తో, మేము ఇప్పుడు C ++ ప్రోగ్రామింగ్ భాషలో వివిధ లక్షణాలను చర్చించడం ప్రారంభిస్తాము.
6. తరువాతి కొన్ని మాడ్యూళ్ళలో, సి ++ లో ఉన్న ఆబ్జెక్ట్ ఓరియంటేషన్ యొక్క ప్రాథమిక నమూనాను ఉపయోగించని లక్షణాలు అయిన మెరుగైన సి ఫీచర్స్ అని పిలువబడే లక్షణాల సమితితో మేము ప్రత్యేకంగా వ్యవహరిస్తాము. హుహ్.
7. కానీ ఇవి సి భాషకు విధానపరమైన పొడిగింపులు, ఇవి ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్‌ను సాధ్యం చేయడానికి అవసరమవుతాయి మరియు ఇవి సిలో ఉండగల మంచి లక్షణాలు. యాదృచ్ఛికంగా సి రూపకల్పన చేసినప్పుడు కూడా వారు ఆలోచించలేదు.
8. మరింత ఆసక్తికరంగా, C ++ లో ప్రవేశపెట్టిన తర్వాత ఈ లక్షణాలలో కొన్ని ఉన్నాయి మరియు ఈ మాడ్యూల్‌లో ఆ లక్షణాలలో ఒకదాన్ని మేము చర్చించబోతున్నాము.
9. ఈ లక్షణాలలో కొన్ని అప్పటి నుండి సి ప్రోగ్రామింగ్‌లోకి తీసుకోబడ్డాయి మరియు ఇప్పుడు C99 ప్రమాణంలో అందుబాటులో ఉన్నాయి.
10. మేము ఈ మాడ్యూల్ 6 ను ప్రారంభిస్తాము, ఇక్కడ మేము స్థిరాంకాలు మరియు ఇన్లైన్ ఫంక్షన్ల గురించి చర్చిస్తాము.
11. అందువల్ల, మేము C ++ లో const ను అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము మరియు అదే భావనతో సరిగ్గా అదే భావన కాదు, కానీ అదే భావన C లో నిరంతరం కనిపిస్తుంది మరియు C + లో ఇన్లైన్ ఫంక్షన్లను వివరించడానికి ప్రయత్నిస్తాము. + మరియు దీనికి విరుద్ధంగా వాటిని మాక్రోలతో.
12. కాబట్టి, ఇవి మేము చర్చించబోయే విషయాలు, మీరు దానిని స్క్రీన్ ఎడమ వైపున చూడగలరని మేము క్రమంగా వెల్లడిస్తాము.
13. కాబట్టి సి లోని మానిఫెస్ట్ స్థిరాంకాలతో ప్రారంభిద్దాం.
14. మేము # నిర్వచించును వ్రాస్తే అక్షర లేదా వ్యక్తీకరణను ఉపయోగించి స్థిరమైన విలువను లేదా స్థిర విలువను నిర్వచించగలమని మనందరికీ తెలుసు.
15. ఒక పేరు తరువాత మరియు మేము నిర్వచించదలిచిన ప్రత్యేక వ్యక్తీకరణ.
16. అందువల్ల, ఎడమ వైపున మనకు ఇక్కడ ఉన్నదానికి ఉదాహరణలు చూడవచ్చు; TWO ఒక నిర్వచించిన విలువ చూడండి.
17. 2. అదేవిధంగా, వ్యక్తీకరణ పరంగా నిర్వచించబడిన పైని ఎలా నిర్వచించాలో మేము చూపించాము.
18. పై; అటాన్ (1.0) ఇది PI నుండి 4, కాబట్టి మీరు దానిని 4 తో గుణిస్తే మీరు పై విలువను పొందుతారు.
19. ఒక వృత్తం యొక్క చుట్టుకొలతను లెక్కించడానికి మేము వాటిని ఇక్కడ వ్యక్తీకరణలో ఉపయోగిస్తాము.
20. ఇది సి లో చాలా సాధారణంగా ఉపయోగించే ప్రోగ్రామ్ మరియు మీలో చాలామంది ఇంతకు ముందు వ్రాశారు.
21. ఇప్పుడు, మేము ఈ కార్యక్రమాన్ని కొద్దిగా భిన్నంగా చూస్తాము, కుడి వైపు చూద్దాం.
22. TWO వద్ద మేము ఇక్కడ కలిగి ఉన్న # నిర్వచించు చివరికి ఈ సమయంలో సి ప్రిప్రాసెసర్ ద్వారా భర్తీ చేయబడుతుంది.
23. అందువల్ల, ప్రోగ్రామ్ సంకలనంలోకి వెళ్ళే ముందు ఈ పంక్తి తొలగించబడుతుంది మరియు TWO ఎక్కడ సంభవించినా, ఈ గుర్తు మొదట సంభవించింది, ఇక్కడ నేను గుర్తు ఉండాలి అని నిర్వచించే ముందు.
24. కాబట్టి, ఈ పైలో మొత్తం వ్యక్తీకరణ ద్వారా భర్తీ చేయబడిందని మీరు చూడవచ్చు మరియు ఇది సి కంపైలర్ను కంపైల్ చేయడానికి వాస్తవానికి వెళ్ళే కోడ్.
25. ఇది తెర వెనుక దృష్టాంతంలో ఉంది మరియు మీరు మీ కంపైలర్‌లో ప్రత్యేక ఎంపికను ఉంచకపోతే మేము సాధారణంగా దీన్ని చేయము.ఈ ప్రోగ్రామ్ యొక్క ఈ సంస్కరణను మీరు చూడలేరు, ఇక్కడ ఈ # నిర్వచనాలు మార్చబడ్డాయి
26. # నిర్వచించు యొక్క ఉద్దేశ్యం ఏమిటంటే చిహ్నం మరియు వ్యక్తీకరణకు ఒకే పేరు ఇవ్వడం మరియు సి ప్రిప్రాసెసర్ ప్రత్యామ్నాయాన్ని చేయగలదు.
27. మానిఫెస్ట్ స్థిరాంకం యొక్క దృష్టాంతం ఏమిటో మీరు అర్థం చేసుకోవడం మాత్రమే? కాబట్టి, ఫలితం ఏమిటి? ఫలితం ఏమిటంటే, నేను స్థిరంగా చికిత్స చేయాలనుకున్న విలువను ఉపయోగించాలని నేను నిజంగా కోరుకున్నాను, కాని నేను దాన్ని మళ్ళీ చూసి, వ్యాఖ్యలోని చివరి పంక్తిపై దృష్టి పెడితే నేను కనుగొన్నాను కాబట్టి, నేను దీన్ని ఉచితంగా ఉపయోగించాలనుకున్నాను స్థిరంగా మరియు ప్రక్రియలో కంపైలర్‌కు అవి TWO అని పిలువబడే వేరియబుల్ రూపంలో ఉన్నాయో లేదో తెలియదు లేదా అవి TWO, కంపైలర్ అనే చిహ్నంగా ఉన్నాయా. (కంపైలర్) ఆ సంఖ్యా 3 ను భర్తీ చేసినప్పుడు చూస్తుంది.
28. కాబట్టి దీనిని జాగ్రత్తగా చూసుకోవటానికి ఒక భావన ప్రవేశపెట్టబడింది.
29. కాబట్టి, const (ness) ఎలా జరిగిందో చూస్తే, మేము ఒక ప్రకటన చేస్తున్నట్లు మీరు చూస్తారు, అక్కడ మేము n యొక్క డిక్లరేషన్‌ను కొత్త కీవర్డ్ const (const) ద్వారా ఉపసర్గ చేస్తాము.
30. నేను int n initize 10 ను వ్రాస్తే, n అనేది పూర్ణాంక రకం వేరియబుల్ అని తెలుసు, దీని ప్రారంభ విలువ 10.
31. మేము ఈ కాన్స్ట్ కీవర్డ్‌తో ప్రిఫిక్స్ చేస్తున్నాము, అంటే దాని అర్థం n యొక్క ప్రారంభ విలువ 10 అని మరియు భవిష్యత్తులో దీనిని మార్చలేమని కూడా చెబుతుంది, ఇది ఒక అసైన్‌మెంట్ కాదు. (అసైన్‌మెంట్) లేదా నేను చేయగల ఇతర మార్గాలు మార్పు n, n ప్రోగ్రామ్ ద్వారా 10 వరకు ఉంటుంది.
32. కాబట్టి, నేను ఇక్కడ ఇలాంటివి చేయటానికి ప్రయత్నిస్తే, అది 5 కి కేటాయించబడింది మరియు ఆ కోడ్‌ను కంపైల్ చేయడానికి ప్రయత్నిస్తే, కంపైలర్ (కంపైలర్) n స్థిరంగా ఉందని లోపం ఇస్తుంది, దానిని మార్చలేము.
33. నేను దానిని దాటవేయడానికి ప్రయత్నించవచ్చు మరియు సాధారణంగా నేను మరొక వేరియబుల్ m మరియు పాయింటర్ p కలిగి ఉంటే అది పూర్ణాంక రకం పాయింటర్ అయితే నేను m మరియు p యొక్క చిరునామాను తీసుకుంటాను మరియు వాస్తవానికి నేను ఒక పాయింటర్‌ను ఉపయోగించవచ్చు, m యొక్క విలువ, నేను ఏడు నుండి * p కి కేటాయించినట్లయితే అది మీటర్‌ను వాస్తవంగా మారుస్తుంది.
34. కానీ, నేను ఇక్కడ అదే చేయటానికి ప్రయత్నిస్తే, నేను సూచించిన వేరియబుల్ (p) లో n యొక్క ఈ విలువను మరియు తరువాత n యొక్క విలువను మార్చడానికి ప్రయత్నిస్తే, నేను 5 నుండి * p వరకు కేటాయించవచ్చు. నేను దానిని అనుమతించలేను.
35. అది చెయ్యి.
36. కాబట్టి, మేము ఒక వేరియబుల్‌ను const గా నిర్వచించి, ఆపై ఒక పాయింటర్‌ను ఉపయోగించటానికి ప్రయత్నించి, దాని చిరునామాను కూడా కనుగొంటే, ఇది సంకలన లోపం అని మీరు కొద్దిగా ఆశ్చర్యపోవచ్చు.
37. మరియు అది సంకలన లోపం. అది లోపం కాకపోతే, మీరు దీన్ని చేయగలుగుతారు, ఇది మేము నిర్వచించటానికి ప్రయత్నిస్తున్న const-ness సూత్రాన్ని ఉల్లంఘిస్తోంది, n ను మార్చలేము అని మేము చెబుతున్నాము .
38. ఫలితం ఏమిటి? దీని తదుపరి సహజ పరిణామం ఏమిటంటే, ఒక కాన్ వేరియబుల్ తప్పక ప్రారంభించబడాలి.
39. ఇది నిర్వచించబడిన వెంటనే ఇది ప్రారంభించబడాలి, ఎందుకంటే మీరు దానిని ప్రారంభించకపోతే, దాని విలువను మార్చడానికి మార్గం లేదు, కాబట్టి చెత్త విలువ ఏమైనప్పటికీ, అది కేవలం చెత్త అవుతుంది.
40. అందువల్ల, మీరు ప్రారంభం లేకుండా ఒక స్థితిని ప్రకటించినట్లయితే, అది సంకలన లోపంగా మారుతుంది.
41. కాబట్టి మనం వేర్వేరు రకాల వేరియబుల్స్ ను కూడా డిక్లేర్ చేయవచ్చు, ఎందుకంటే కాస్ట్ టైప్ వాడకం ఒక సంక్లిష్ట సంఖ్యను చెప్పే వేరియబుల్ యొక్క ఉదాహరణ మరియు మేము దానిని స్థిరంగా నిర్వచించగలము, దీని అర్ధం రాశితో మీరు విలువను మార్చలేరు వేరియబుల్ సి.
42. నిర్వచనం ప్రకారం re 2.3 ఎందుకంటే మేము ప్రారంభించాము మరియు c అనేది const అని మేము చెప్పినందున, c const అయితే అది పూర్తయింది, ఎందుకంటే నేను ఏ భాగాన్ని మార్చలేను.
43. కాబట్టి, నేను c.re కి 3.5 ని కేటాయించడానికి ప్రయత్నిస్తే అది సంకలన లోపం అవుతుంది.
44. ఇది కాన్ - నెస్ యొక్క భావన.
45. కాబట్టి మనం దాన్ని ఎలా ఉపయోగిస్తామో చూద్దాం.
46. కాబట్టి, ఇప్పుడు మనకు ఎడమవైపు రెండు ప్రోగ్రామ్‌లు ఉన్నాయి, నిర్దిష్ట సి ప్రోగ్రామ్ # నిర్వచించును ఉపయోగిస్తుంది మరియు కుడి వైపున సి ++ లో ఇలాంటి ప్రోగ్రామ్‌ను వ్రాస్తాము, అదే ప్రయోజనాన్ని సాధించడానికి కాన్-నెస్‌ను ఉపయోగిస్తుంది.
47. ఇంతకుముందు మేము TWO ని విలువ 2 లో నిర్వచించాము, ఇప్పుడు మేము TWO అనేది 2 తో ప్రారంభించిన పూర్ణాంకం అని చెప్తున్నాము, కానీ ఇది కాస్ట్ వేరియబుల్, కాబట్టి మీరు దీన్ని మార్చలేరు.
48. దీని యొక్క ప్రధాన ఫలితం ఏమిటంటే, కుడి వైపున ఉన్న ఈ ప్రోగ్రామ్, ఈ ప్రోగ్రామ్ సరైనది అయినప్పుడు, సి ప్రిప్రాసెసర్ ఖచ్చితంగా ఇది # నిర్వచించబడదని చెప్పింది, కాబట్టి ఈ సమయంలో TWO చిహ్నం భర్తీ చేయబడదు.
49. అదేవిధంగా, PI చిహ్నం అలాగే ఉంటుంది మరియు కంపైలర్ ఇవి ప్రోగ్రామ్‌లో ఉన్న విభిన్న వేరియబుల్స్ అని చూస్తాయి మరియు కంపైలర్‌కు అవి మార్చలేని స్థిరాంకాలు అని తెలుసు.
50. కాబట్టి మీరు C లో కలిగి ఉన్న అదే లక్ష్యాన్ని మీరు సాధించవచ్చు మరియు ఇప్పుడు కంపైలర్ ఇవన్నీ చూడగల అదనపు ప్రయోజనాన్ని మీరు పొందవచ్చు మరియు కంపైలర్ TWO రకం ఏమిటో కంపైలర్కు తెలుస్తుంది. కంపైలర్. (కంపైలర్) రకం ఏమిటో తెలుస్తుంది PI లేదా దాని కోసం. ఏదైనా వేరియబుల్, మీరు నిర్వచించిన ఏ విలువను అయినా const const ఉపయోగించి నిరంతరాయంగా నిర్వచించండి.
51. కాబట్టి మీరు దానిని ఉపయోగించడం ద్వారా చాలా ప్రయోజనాలను పొందుతారు.
52. మీరు స్థిరమైన విలువలను ఉపయోగించాలనుకునే రెండు ప్రధాన సందర్భాలు ఉన్నాయి; ఒక సూచన ఏమిటంటే, మీరు పై వంటి విభిన్న సహజ స్థిరాంకాలతో వ్యవహరించేటప్పుడు ఇ వంటి బంగారు నిష్పత్తి ఫై, తప్పుడు విలువ సున్నా విలువ వంటి బూలియన్ నిజమైన విలువ మరియు మొదలైనవి.
53. ఒక ప్రోగ్రామ్‌లో చాలా సహజ స్థిరాంకాలు ఉన్నాయి, అవి వాటి విలువను కలిగి ఉంటాయి, వాటి రకాన్ని కలిగి ఉంటాయి మరియు సహజ స్థిరాంకం సహజంగా మీరు వారి అసలు ఆస్తిని కలిగి ఉంటారు, మీరు విలువను మార్చలేరు PI యొక్క లేదా మీరు E విలువను మార్చలేరు, కాబట్టి ఆస్తి కూడా అలాగే ఉంచబడుతుంది.
54. అలాగే, మనం తరచుగా స్థిరంగా ఉపయోగించే మరొక ప్రదేశం నా ప్రోగ్రామ్ కోసం ఏదో స్థిరంగా ఉంటుంది లేదా ఒక నిర్దిష్ట ఫంక్షన్ కోసం ఏదో స్థిరంగా ఉంటుంది.
55. కాబట్టి, దీని కోసం మనం మరొక నిర్వచనం యొక్క సమితిని ఉపయోగిస్తాము, అంటే మనకు శ్రేణి ఆకారాన్ని స్థిరంగా నిర్వచించవచ్చు.
56. ఇవి సార్వత్రిక సహజ స్థిరాంకాలు కాదు, కానీ అవి నా పనికి స్థిరాంకాలు.
57. నేను ఇలా చేసి ఉంటే, మనకు లభించే ప్రయోజనం, మనం ప్రోగ్రామ్ రాసేటప్పుడు, వాటిని ఈ వేరియబుల్స్ సందర్భంలో వ్రాయవచ్చు, తద్వారా తరువాత మనం వాటిని మార్చవలసి వస్తే, మనం ప్రారంభ ప్రోగ్రామ్‌ను నిరంతరం మార్చవచ్చు.) ఎగువన లేదా బహుశా కొన్ని హెడర్ ఫైల్‌లో.
58. దీన్ని చేయడం వల్ల మరొక ప్రయోజనం ఏమిటంటే, మీరు # నిర్వచించినట్లయితే, # నిర్వచించు మొత్తం ఫైల్‌లో స్కోప్ ఉంటుంది.
59. ఒక నిర్దిష్ట నిర్దిష్ట స్థిరమైన విలువ కోసం నేను కొంత విలువ n ని పేర్కొంటే, నా ప్రోగ్రామ్‌లో n ఉన్నచోట, అది ఈ # నిర్వచించే విలువతో భర్తీ చేయబడుతుంది.
60. కాని const అనేది వేరియబుల్ డిక్లరేషన్, కాబట్టి ఇది ఏ పరిధిలోనైనా చేయవచ్చు, నేను దీన్ని ఒక ఫంక్షన్‌లో చేయగలను, నేను ఒక ఫంక్షన్‌లో ఒక బ్లాక్‌లో చేయగలను మరియు ఏదైనా వేరియబుల్ డిక్లరేషన్ లాగా, const యొక్క వేరియబుల్ డిక్లరేషన్ కూడా దానిలో పరిమితం అవుతుంది పరిధి.
61. కాబట్టి ఒకే ఫైల్‌లో రెండు వేర్వేరు ఫంక్షన్లలో ఒకే వేరియబుల్ (ఎన్) జరిగే అవకాశం ఉంది, రెండు ప్రదేశాలలో ఇది స్థిరంగా ఉంటుంది, కానీ దీనికి వేర్వేరు విలువలు ఉన్నాయి, మీరు దీన్ని # నిర్వచనంతో చేయవచ్చు ప్రభావాన్ని సాధించలేరు.
62. మేము # నిర్వచించుట కంటే ఎక్కువ const (const) ను ఇష్టపడతామని సంగ్రహించాము ఎందుకంటే ఇది రకం సందర్భంలో సురక్షితం కాదు, ఇది CPP చేత భర్తీ చేయబడుతుంది, ఇక్కడ const (const) లేనిది.
63. అందువల్ల, మీరు డీబగ్గర్ ఉపయోగిస్తుంటే, మీరు డీబగ్గర్లో # చిహ్నాలను నిర్వచించలేరు, ఎందుకంటే మీరు చూడగలరు.
64. ఇతర దుష్ప్రభావం ఏమిటంటే, # ప్రతి దశలో వ్యక్తీకరణను నిర్వచించినందున, ఇది చాలాసార్లు భర్తీ చేయబడినందున మూల్యాంకనం చేయాల్సిన అవసరం ఉంది, ఇక్కడ కాన్ విషయంలో ఇది ప్రారంభ బిందువు వద్ద మాత్రమే అంచనా వేయబడుతుంది.
65. కాబట్టి, తారాగణం ఖచ్చితంగా # నిర్వచించటం కంటే సంపూర్ణ ప్రయోజనం.
66. ఇప్పుడు, ముఖ్యంగా const ని నిర్వచించే కొన్ని ఫలితాలను చూద్దాం, పాయింటర్ రకం డేటా యొక్క const - ness ను పరిశీలిస్తాము.
67. పాయింటర్ రకం డేటాలో, మనకు పాయింటర్ ఉందని మనకు తెలుసు మరియు అది వేరియబుల్‌ను సూచిస్తుంది.
68. కాబట్టి ప్రశ్న ఏమిటంటే, మేము const-ness గురించి మాట్లాడుతుంటే, మనం ఏ const-ness గురించి మాట్లాడుతున్నాము, మీరు పాయింటర్ యొక్క const-ness లేదా పాయింటర్ డేటా యొక్క const-ness గురించి మాట్లాడుతున్నారా?
69. ఇక్కడ, డేటా స్థిరంగా ఉందా లేదా పాయింటర్ కాదా లేదా పాయింటర్ స్థిరంగా ఉందా అని స్థిరమైన డేటాను సూచించే రెండు విషయాల గురించి మాట్లాడుతాము, కాని డేటా (డేటా) స్థిరంగా ఉండవచ్చు లేదా ఉండకపోవచ్చు.
70. ఇక్కడ నేను పాయింటర్ మరియు పాయింటర్‌తో ఎలా లెక్కించాలో ఒక నిర్దిష్ట ఉదాహరణ మాత్రమే చూపిస్తాము.మేము రెండు వేరియబుల్స్ ని నిర్వచించాము, కాబట్టి మనకు పాయింటర్ ఉన్న పాయింటర్ ఉంది. చిరునామా తీసుకుంటుంది మరియు దానిని ఉపయోగించడం ద్వారా నేను నేరుగా వేరియబుల్ మార్చగలను లేదా నేను చేయగలను పాయింటర్ ద్వారా దాన్ని మార్చండి.
71. అదేవిధంగా, ఈ పంక్తిలో, మొదటి పాయింటర్ n కు గురిపెట్టింది, ఇప్పుడు అది m కు సూచించడానికి మార్చబడింది మరియు వారు m యొక్క విలువను మార్చడానికి దాన్ని మళ్ళీ ఉపయోగించవచ్చు.
72. ఇది పాయింటర్-పాయింటి దృష్టాంతంలో ఒక సాధారణ ఉపయోగం.
73. అందువల్ల, const ని ఉపయోగించడం ద్వారా ఈ మార్పును ఎలా నియంత్రించవచ్చో దానితో చర్చిస్తాము.
74. (స్లైడ్ సమయం చూడండి: 17:34) కాబట్టి మొదటిది, స్థిరమైన డేటా కోసం నాకు సూచిక ఉంటే.
75. కాబట్టి, మనం ఇక్కడ చేస్తున్నది ఏమిటంటే, డేటాకు ముందు, పాయింటర్ ఏ రకమైన విలువను సూచిస్తుందో ముందు స్థిరంగా వ్రాసాము.
76. నేను ఈ సమయంలో const వ్రాస్తే, సూచించిన డేటా స్థిరంగా ఉందని అర్థం, దానిని మార్చలేము.
77. కాబట్టి, n ను స్థిరమైన విలువగా నిర్వచించారు.
78. N యొక్క విలువను మార్చడానికి ప్రయత్నించడం లోపం అని మనకు ఇప్పటికే తెలుసు, ఎందుకంటే n స్థిరంగా ఉంటే, మరియు p ను n కు పాయింటర్‌గా భావించాము.
79. కాబట్టి, * p ని కేటాయించిన 7 ను ఉపయోగించి n యొక్క విలువను మార్చడానికి ప్రయత్నించడం కూడా లోపం.
80. కానీ, p అనేది ఒక స్థిరాంకం కాదు, అందుకే నేను వేరే వేరియబుల్ కోసం p పాయింట్ చేయగలనని కోరుకుంటే, m ఇక్కడ ఒక వేరియబుల్, ఇది స్థిరమైన వేరియబుల్ (వేరియబుల్)) కాదు.
81. నేను m ని p పాయింట్‌గా చేయగలను, ఆపై m యొక్క విలువను మార్చడానికి నేను ఈ * p కేటాయించిన 8 ని ఉపయోగించవచ్చు, m ఇప్పుడు 8 అవుతుంది, అది 4 అవుతుంది, ఇప్పుడు 8 అవుతుంది.
82. ఇప్పుడు మీరు చూస్తే, నాకు స్థిరంగా లేని వేరియబుల్ ఉంటే, పూర్ణాంకానికి 5 తో ప్రారంభించిన పూర్ణాంక రకంగా నిర్వచించబడింది మరియు నాకు ఒక పాయింటర్ ఉంది, అది p అనేది స్థిరమైన పూర్ణాంక విలువ యొక్క రకాన్ని సూచిస్తుంది మరియు నేను ప్రవేశించాను.
83. P లో n యొక్క చిరునామా.
84. ఇప్పుడు, సహజంగా 6 నుండి n వరకు m కేటాయింపు చెల్లుతుంది ఎందుకంటే n కూడా స్థిరంగా ఉండదు.
85.  P కేటాయించిన 6 చెల్లుబాటు అయ్యేది, కానీ నేను అలా చేయటానికి ప్రయత్నిస్తే * p 6 ని కేటాయించారు, ఇది చెల్లుబాటు కాదు, ఎందుకంటే m ఒక స్థిరమైన పూర్ణాంకానికి సూచిస్తుంది.
86. కాబట్టి చాలా ఆసక్తికరమైన దృశ్యం; నేను ఇక్కడ n ను సూచిస్తూ AP కలిగి ఉన్నాను.
87. P కి తెలుసు, నేను * P వ్రాస్తే స్థిరంగా ఉంటుందని తెలుసు.
88. ఈ విలువను మార్చడానికి P ఉపయోగించబడదు, కాని n కూడా స్థిరంగా ఉండదు.
89. కాబట్టి, n మార్చవచ్చు.
90. ఇప్పుడు, ఇది చెల్లుతుంది ఎందుకంటే మీరు ఏమి చెప్తున్నారో, మీకు కావాల్సిన దానికంటే ఎక్కువ చెబుతున్నారు, n దాని స్వంతంగా మారగలదని మీరు చెబుతున్నారు.
91. కాబట్టి, నేను దానిని నేరుగా n గా మార్చినా లేదా పాయింటర్ (పాయింటర్) ద్వారా మార్చినా, అది పట్టింపు లేదు ఎందుకంటే n మారవచ్చు, కాని పాయింటర్ (పాయింటర్) నేను మార్చడానికి పరిమితం చేయబడిందని చెప్పాడు.
92. మీరు నా గుండా వెళితే విలువను మార్చడానికి నేను అనుమతించను అని పాయింటర్ చెప్పింది.
93. కాబట్టి, వేరియబుల్ వాస్తవానికి మార్చగల దృష్టాంతం ఇక్కడ ఉంది, కానీ పాయింటర్ దానిని మార్చడానికి మిమ్మల్ని అనుమతించని ఒక వీక్షణను ఇస్తుంది, కానీ నేను నేరుగా వెళితే లేదా స్థిరమైన విలువను సూచించని కొన్ని ఇతర పాయింటర్ (పాయింటర్) కావాలనుకుంటే , అప్పుడు మేము మార్చగలుగుతాము.
94. చివరగా, మేము రివర్స్ చేయడానికి ప్రయత్నిస్తే, నాకు స్థిరమైన వేరియబుల్ (n) ఉంటే మరియు నేను స్థిరంగా లేని విలువ p కోసం పాయింటర్‌ను ఉపయోగించటానికి ప్రయత్నిస్తే, నేను ఇప్పటికీ అలా చేయలేను.
95. కాబట్టి, మేము ఇప్పుడు వివరించడానికి ప్రయత్నిస్తే, ఇక్కడ చివరి చివరి కేసు ఉంది, కాబట్టి మేము ఈ కేసు గురించి మాట్లాడుతున్నాము, నాకు n ను సూచించే ఒక కోతి ఉంటే, అది నిరంతరంగా ఉంటుంది మరియు * p మనకు స్థిరంగా లేదు, అప్పుడు లోపం చాలా చెల్లుతుంది, ఎందుకంటే n స్థిరంగా ఉంటుంది.
96.  P స్థిరంగా లేకపోతే, * p n ను సూచించడానికి ప్రయత్నిస్తుంటే, n యొక్క విలువను మార్చడానికి నేను ఎల్లప్పుడూ * p ని ఇక్కడ ఉపయోగించగలను.
97. కాబట్టి మనం ఇక్కడ నేర్చుకున్నది ఒక విలువ స్థిరంగా లేనట్లయితే, దాన్ని పొందటానికి, నిరంతరాయంగా సూచించడానికి నేను దానిని ఉపయోగించగలను, కాని నేను దానిని ఆ పాయింటర్ (పాయింటర్) అని పిలుస్తాను.
98. విలువ స్థిరంగా ఉంటే, స్థిరమైన విలువను సూచించే పాయింటర్‌ను నేను ఉపయోగించలేను. ఈ స్థిరమైన వేరియబుల్ (పాయింటర్) చిరునామాతో ఆ కాన్స్ట్ (పాయింటర్) ను కేటాయించనివ్వండి ఎందుకంటే ఇది ప్రారంభించడానికి అనుమతించబడదు ఎందుకంటే ఇది ఉల్లంఘిస్తుంది స్థిరమైన-నెస్ యొక్క ప్రాథమిక సూత్రం.
99. తరువాత, మరొక వైపు స్థిరమైన నెస్‌ను చూద్దాం, పాయింటర్ స్థిరంగా ఉంటే? కాబట్టి, మేము ఇక్కడే ఉన్నామని మీరు ఇక్కడ చూస్తే, మేము తారాగణం వ్రాసిన స్థానాన్ని కొద్దిగా మార్చాము.
100. ఇంతకుముందు ఇక్కడ ఈ స్థిరాంకం వ్రాయబడింది, ఇప్పుడు ఖర్చు స్టార్ గుర్తు తర్వాత వ్రాయబడింది, పాయింటర్ స్థిరంగా ఉందని చెప్తుంది, కానీ అది సూచించే విలువ స్థిరంగా లేదు.
101. నేను దానిని గీస్తే, p అనేది const మరియు n const కాదు.
102. కాబట్టి, దీని అర్థం ఏమిటంటే, ఇది n const కాదని నేను సులభంగా వ్రాయగలిగితే, నేను దాని విలువను మార్చగలను, ఎందుకంటే n const కాదు కాబట్టి, నేను దీన్ని చేయటానికి p derence ని ఉపయోగించవచ్చు. ఏడు నుండి * p వరకు కేటాయిస్తుంది, ఇది విలువను మారుస్తుంది యొక్క n.
103. ఎందుకంటే నేను దేనినీ ఉల్లంఘించడం లేదు, కానీ నేను అలా చేయలేను, p లో నిల్వ చేసిన చిరునామాను నేను మార్చలేను.
104. నేను ఇకపై p ను క్రొత్త వేరియబుల్ m కి సూచించలేను, ఎందుకంటే పాయింటర్ కూడా స్థిరంగా ఉందని నేను చెప్పాను. ఈ వైపు స్థిరంగా ఉంటుంది. ఇప్పుడు రెండవ వైపు స్థిరంగా ఉంది.
105. సహజంగానే, మనకు ఇది ఉంటే, పొడిగింపు ద్వారా పాయింటర్ మరియు అది సూచించే డేటా నిరంతరంగా ఉండవచ్చని కూడా మనం జోడించవచ్చు.
106. కాబట్టి, ఇక్కడ మనం రెండు వైపులా కాస్ట్‌లు వ్రాసే ఒక ఉదాహరణను చూపిస్తున్నాము, అంటే p అనేది నిరంతర డేటాకు పాయింటర్, అంటే p కూడా మరొకదానికి సూచించబడదు. N కాకుండా వేరే వేరియబుల్స్ కోసం తయారు చేయవచ్చు, లేదా చేయలేము n విలువను మార్చడానికి p ని ఉపయోగించండి.
107. కాబట్టి, ఇవన్నీ ఇప్పుడు లోపం అవుతాయి.
108. ఇప్పుడు, వాస్తవానికి, మేము సూచించిన డేటా లేదా పాయింటర్‌పై const - ness వ్రాస్తున్నందున, నేను ఎక్కడ const వ్రాయాలి అనేది కొన్నిసార్లు గందరగోళంగా ఉంటుంది మరియు const const keyword ఉంచడం ద్వారా ఏమి జరుగుతుంది.
109. బొటనవేలు నియమం చాలా సులభం, మీకు ఈ ప్రకటన ఉన్నప్పుడు ప్రకటన అంతటా స్టార్ సింబల్‌లో కనిపిస్తుంది.
110. మానసికంగా ఒక నిలువు వరుసను గీయండి, తద్వారా మీరు దీన్ని చేయటానికి ప్రయత్నిస్తుంటే const int * p, మొదలైనవి చెబుతున్నారు. ఈ నక్షత్ర చిహ్నం ద్వారా నిలువు వరుసను గీయండి మరియు const కీవర్డ్ ఏ వైపున కనిపిస్తుంది అని చూడండి, ఇది మీ డేటా వైపు మరియు ఇది మీ పాయింటింగ్ వైపు.
111. కాస్ట్-నెస్ డేటా వైపు ఉంటే, మీరు సూచించేది స్థిరంగా ఉంటుంది.
112. దీనికి విరుద్ధంగా మీకు int * const p et cetera ఉంటే, అది const పాయింటర్‌లో ఉంటుంది కాబట్టి పాయింటర్ స్థిరంగా ఉంటుంది.
113. కాబట్టి ఇది ప్రాథమిక బొటనవేలు నియమం, వీటిలో ఏది స్థిరంగా ఉందో మీరు నిర్ణయించవచ్చు.
114. ఉదాహరణలు క్రింద ఇవ్వబడ్డాయి.
115. కాబట్టి, మీరు దీన్ని ఉపయోగించవచ్చు మరియు ఇది నేను పనిచేసిన స్ట్రింగ్‌కు ఒక ఉదాహరణ. మీరు దీన్ని జాగ్రత్తగా చదవవచ్చు మరియు స్ట్రింగ్ ఇవ్వబడిందని అర్థం చేసుకోవడానికి ప్రయత్నించవచ్చు మరియు మా వద్ద మీకు స్ట్రింగ్ ఉంటే, మీరు మీరు రెండు మార్గాలను మార్చవచ్చు స్ట్రింగ్‌ను సవరించవచ్చు లేదా మీరు స్ట్రింగ్‌ను మార్చవచ్చు.
116. ఎగువన ఉన్న కోడ్‌లో మేము స్ట్రింగ్‌ను సవరించడం లేదా మొత్తం స్ట్రింగ్‌ను పూర్తిగా మార్చడం యొక్క ప్రభావాన్ని చూపుతాము.
117. మీరు ఇలా ఏదైనా చేస్తే, ఇక్కడ స్థిరాంకం ఉంచండి, మీరు ఇక్కడ ఒక కాన్స్ట్ ఉంచినట్లయితే, స్ట్రింగ్ స్థిరంగా మారుతుంది, కాబట్టి మీరు స్ట్రింగ్ చేయవచ్చు) ఏ అక్షరాన్ని మార్చలేరు.
118. అందువల్ల, మీరు ఇకపై చేయలేని మొదటి గుర్తుకు n వ్రాయగలరని మీరు ఇక్కడ చేయలేరు.
119. అయితే, మీరు ఈ వైపు ప్రసారం చేస్తే, మీరు ఇప్పుడు స్ట్రింగ్‌లోని ఏదైనా చిహ్నాన్ని మార్చవచ్చు, కానీ మీరు స్ట్రింగ్‌ను మొత్తంగా మార్చలేరు.
120. ఇక్కడ మీరు స్ట్రింగ్‌ను మార్చవచ్చు.ఇప్పుడు మీరు స్ట్రింగ్‌ను మార్చలేరు ఎందుకంటే పాయింటర్‌ను మార్చడం దీని అర్థం.
121. మీరు పాయింటర్‌కు ఇరువైపులా ప్రసారం చేస్తే, మీరు వరుసగా నాలుగు అక్షరాలను సూచించే నాలుగు నక్షత్రాల నక్షత్రం ఉంటే, రెండింటినీ సవరించలేకపోతే, మీరు రెండు సవరణలను మరియు పేరు మార్పును రక్షించవచ్చు.
122. అలాగే మార్చలేరు.
123. రెండు వైపులా కాస్ట్-నెస్ ఎలా వర్తించబడుతుందో చూపించడానికి ఒక ఉదాహరణ.
124. అందువల్ల, const - ness యొక్క ప్రాథమిక భావనను మరియు పాయింటర్ల పరంగా const - ness ఎలా వర్తించబడుతుందో చర్చించాము.
125.
 C ++  ప్రోగ్రామింగ్ మాడ్యూల్ 6 కు స్వాగతం.
మొదటి ఐదు మాడ్యూల్స్లో మనము C ప్రోగ్రామింగ్ లాంగ్వేజ్(programming language), C స్టాండర్డ్ గ్రంథాలయం (standard library) మరియు C భాష యొక్క వివిధ నిర్మాణాలను పునఃపరిశీలించాము.+
ప్రాధమిక ఇన్పుట్, అవుట్పుట్, అంకగణిత కార్యకలాపాలు, శ్రేణులు, తీగలను మరియు ముఖ్యంగా డేటా నిర్మాణాన్ని ఉపయోగించడానికి లూప్ రకం ఉదాహరణలతో ప్రారంభించి మేము అనేక ఉదాహరణలు తీసుకున్నాము., C ++ మరియు C ++ లైబ్రరీలో ప్రోగ్రామింగ్ ఎలా ఉంటుందో చూపించడానికి మేము నాలుగు ఉదాహరణలను తీసుకున్నాము లైబ్రరీని న్యాయంగా ఉపయోగించుకోండి.
C ++ లో ప్రోగ్రామింగ్ వాస్తవానికి మరింత సమర్థవంతంగా మరియు తక్కువ లోపంతో చేయటం సులభం.
ఈ మాడ్యూల్‌తో, మేము ఇప్పుడు C ++ ప్రోగ్రామింగ్ భాషలో వివిధ లక్షణాలను చర్చించడం ప్రారంభిస్తాము.
తరువాతి కొన్ని మాడ్యూళ్ళలో, సి ++ లో ఉన్న ఆబ్జెక్ట్ ఓరియంటేషన్ యొక్క ప్రాథమిక నమూనాను ఉపయోగించని లక్షణాలు అయిన మెరుగైన సి ఫీచర్స్ అని పిలువబడే లక్షణాల సమితితో మేము ప్రత్యేకంగా వ్యవహరిస్తాము. హుహ్.
కానీ ఇవి సి భాషకు విధానపరమైన పొడిగింపులు, ఇవి ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్‌ను సాధ్యం చేయడానికి అవసరమవుతాయి మరియు ఇవి సిలో ఉండగల మంచి లక్షణాలు. యాదృచ్ఛికంగా సి రూపకల్పన చేసినప్పుడు కూడా వారు ఆలోచించలేదు.
మరింత ఆసక్తికరంగా, C ++ లో ప్రవేశపెట్టిన తర్వాత ఈ లక్షణాలలో కొన్ని ఉన్నాయి మరియు ఈ మాడ్యూల్‌లో ఆ లక్షణాలలో ఒకదాన్ని మేము చర్చించబోతున్నాము.
ఈ లక్షణాలలో కొన్ని అప్పటి నుండి సి ప్రోగ్రామింగ్‌లోకి తీసుకోబడ్డాయి మరియు ఇప్పుడు C99 ప్రమాణంలో అందుబాటులో ఉన్నాయి.
మేము ఈ మాడ్యూల్ 6 ను ప్రారంభిస్తాము, ఇక్కడ మేము స్థిరాంకాలు మరియు ఇన్లైన్ ఫంక్షన్ల గురించి చర్చిస్తాము.
అందువల్ల, మేము C ++ లో const ను అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము మరియు అదే భావనతో సరిగ్గా అదే భావన కాదు, కానీ అదే భావన C లో నిరంతరం కనిపిస్తుంది మరియు C + లో ఇన్లైన్ ఫంక్షన్లను వివరించడానికి ప్రయత్నిస్తాము. + మరియు దీనికి విరుద్ధంగా వాటిని మాక్రోలతో.
కాబట్టి, ఇవి మేము చర్చించబోయే విషయాలు, మీరు దానిని స్క్రీన్ ఎడమ వైపున చూడగలరని మేము క్రమంగా వెల్లడిస్తాము.
కాబట్టి సి లోని మానిఫెస్ట్ స్థిరాంకాలతో ప్రారంభిద్దాం.
మేము # నిర్వచించును వ్రాస్తే అక్షర లేదా వ్యక్తీకరణను ఉపయోగించి స్థిరమైన విలువను లేదా స్థిర విలువను నిర్వచించగలమని మనందరికీ తెలుసు.
ఒక పేరు తరువాత మరియు మేము నిర్వచించదలిచిన ప్రత్యేక వ్యక్తీకరణ.
అందువల్ల, ఎడమ వైపున మనకు ఇక్కడ ఉన్నదానికి ఉదాహరణలు చూడవచ్చు; TWO ఒక నిర్వచించిన విలువ చూడండి.
2. అదేవిధంగా, వ్యక్తీకరణ పరంగా నిర్వచించబడిన పైని ఎలా నిర్వచించాలో మేము చూపించాము.
పై; అటాన్ (1.0) ఇది PI నుండి 4, కాబట్టి మీరు దానిని 4 తో గుణిస్తే మీరు పై విలువను పొందుతారు.
ఒక వృత్తం యొక్క చుట్టుకొలతను లెక్కించడానికి మేము వాటిని ఇక్కడ వ్యక్తీకరణలో ఉపయోగిస్తాము.
ఇది సి లో చాలా సాధారణంగా ఉపయోగించే ప్రోగ్రామ్ మరియు మీలో చాలామంది ఇంతకు ముందు వ్రాశారు.
ఇప్పుడు, మేము ఈ కార్యక్రమాన్ని కొద్దిగా భిన్నంగా చూస్తాము, కుడి వైపు చూద్దాం.
TWO వద్ద మేము ఇక్కడ కలిగి ఉన్న # నిర్వచించు చివరికి ఈ సమయంలో సి ప్రిప్రాసెసర్ ద్వారా భర్తీ చేయబడుతుంది.
అందువల్ల, ప్రోగ్రామ్ సంకలనంలోకి వెళ్ళే ముందు ఈ పంక్తి తొలగించబడుతుంది మరియు TWO ఎక్కడ సంభవించినా, ఈ గుర్తు మొదట సంభవించింది, ఇక్కడ నేను గుర్తు ఉండాలి అని నిర్వచించే ముందు.
కాబట్టి, ఈ పైలో మొత్తం వ్యక్తీకరణ ద్వారా భర్తీ చేయబడిందని మీరు చూడవచ్చు మరియు ఇది సి కంపైలర్ను కంపైల్ చేయడానికి వాస్తవానికి వెళ్ళే కోడ్.
ఇది తెర వెనుక దృష్టాంతంలో ఉంది మరియు మీరు మీ కంపైలర్‌లో ప్రత్యేక ఎంపికను ఉంచకపోతే మేము సాధారణంగా దీన్ని చేయము.ఈ ప్రోగ్రామ్ యొక్క ఈ సంస్కరణను మీరు చూడలేరు, ఇక్కడ ఈ # నిర్వచనాలు మార్చబడ్డాయి
# నిర్వచించు యొక్క ఉద్దేశ్యం ఏమిటంటే చిహ్నం మరియు వ్యక్తీకరణకు ఒకే పేరు ఇవ్వడం మరియు సి ప్రిప్రాసెసర్ ప్రత్యామ్నాయాన్ని చేయగలదు.
మానిఫెస్ట్ స్థిరాంకం యొక్క దృష్టాంతం ఏమిటో మీరు అర్థం చేసుకోవడం మాత్రమే? కాబట్టి, ఫలితం ఏమిటి? ఫలితం ఏమిటంటే, నేను స్థిరంగా చికిత్స చేయాలనుకున్న విలువను ఉపయోగించాలని నేను నిజంగా కోరుకున్నాను, కాని నేను దాన్ని మళ్ళీ చూసి, వ్యాఖ్యలోని చివరి పంక్తిపై దృష్టి పెడితే నేను కనుగొన్నాను కాబట్టి, నేను దీన్ని ఉచితంగా ఉపయోగించాలనుకున్నాను స్థిరంగా మరియు ప్రక్రియలో కంపైలర్‌కు అవి TWO అని పిలువబడే వేరియబుల్ రూపంలో ఉన్నాయో లేదో తెలియదు లేదా అవి TWO, కంపైలర్ అనే చిహ్నంగా ఉన్నాయా. (కంపైలర్) ఆ సంఖ్యా 3 ను భర్తీ చేసినప్పుడు చూస్తుంది.
కాబట్టి దీనిని జాగ్రత్తగా చూసుకోవటానికి ఒక భావన ప్రవేశపెట్టబడింది.
కాబట్టి, const (ness) ఎలా జరిగిందో చూస్తే, మేము ఒక ప్రకటన చేస్తున్నట్లు మీరు చూస్తారు, అక్కడ మేము n యొక్క డిక్లరేషన్‌ను కొత్త కీవర్డ్ const (const) ద్వారా ఉపసర్గ చేస్తాము.
నేను int n initize 10 ను వ్రాస్తే, n అనేది పూర్ణాంక రకం వేరియబుల్ అని తెలుసు, దీని ప్రారంభ విలువ 10.
మేము ఈ కాన్స్ట్ కీవర్డ్‌తో ప్రిఫిక్స్ చేస్తున్నాము, అంటే దాని అర్థం n యొక్క ప్రారంభ విలువ 10 అని మరియు భవిష్యత్తులో దీనిని మార్చలేమని కూడా చెబుతుంది, ఇది ఒక అసైన్‌మెంట్ కాదు. (అసైన్‌మెంట్) లేదా నేను చేయగల ఇతర మార్గాలు మార్పు n, n ప్రోగ్రామ్ ద్వారా 10 వరకు ఉంటుంది.
కాబట్టి, నేను ఇక్కడ ఇలాంటివి చేయటానికి ప్రయత్నిస్తే, అది 5 కి కేటాయించబడింది మరియు ఆ కోడ్‌ను కంపైల్ చేయడానికి ప్రయత్నిస్తే, కంపైలర్ (కంపైలర్) n స్థిరంగా ఉందని లోపం ఇస్తుంది, దానిని మార్చలేము.
నేను దానిని దాటవేయడానికి ప్రయత్నించవచ్చు మరియు సాధారణంగా నేను మరొక వేరియబుల్ m మరియు పాయింటర్ p కలిగి ఉంటే అది పూర్ణాంక రకం పాయింటర్ అయితే నేను m మరియు p యొక్క చిరునామాను తీసుకుంటాను మరియు వాస్తవానికి నేను ఒక పాయింటర్‌ను ఉపయోగించవచ్చు, m యొక్క విలువ, నేను ఏడు నుండి * p కి కేటాయించినట్లయితే అది మీటర్‌ను వాస్తవంగా మారుస్తుంది.
కానీ, నేను ఇక్కడ అదే చేయటానికి ప్రయత్నిస్తే, నేను సూచించిన వేరియబుల్ (p) లో n యొక్క ఈ విలువను మరియు తరువాత n యొక్క విలువను మార్చడానికి ప్రయత్నిస్తే, నేను 5 నుండి * p వరకు కేటాయించవచ్చు. నేను దానిని అనుమతించలేను.
అది చెయ్యి.
కాబట్టి, మేము ఒక వేరియబుల్‌ను const గా నిర్వచించి, ఆపై ఒక పాయింటర్‌ను ఉపయోగించటానికి ప్రయత్నించి, దాని చిరునామాను కూడా కనుగొంటే, ఇది సంకలన లోపం అని మీరు కొద్దిగా ఆశ్చర్యపోవచ్చు.
మరియు అది సంకలన లోపం. అది లోపం కాకపోతే, మీరు దీన్ని చేయగలుగుతారు, ఇది మేము నిర్వచించటానికి ప్రయత్నిస్తున్న const-ness సూత్రాన్ని ఉల్లంఘిస్తోంది, n ను మార్చలేము అని మేము చెబుతున్నాము .
ఫలితం ఏమిటి? దీని తదుపరి సహజ పరిణామం ఏమిటంటే, ఒక కాన్ వేరియబుల్ తప్పక ప్రారంభించబడాలి.
ఇది నిర్వచించబడిన వెంటనే ఇది ప్రారంభించబడాలి, ఎందుకంటే మీరు దానిని ప్రారంభించకపోతే, దాని విలువను మార్చడానికి మార్గం లేదు, కాబట్టి చెత్త విలువ ఏమైనప్పటికీ, అది కేవలం చెత్త అవుతుంది.
అందువల్ల, మీరు ప్రారంభం లేకుండా ఒక స్థితిని ప్రకటించినట్లయితే, అది సంకలన లోపంగా మారుతుంది.
కాబట్టి మనం వేర్వేరు రకాల వేరియబుల్స్ ను కూడా డిక్లేర్ చేయవచ్చు, ఎందుకంటే కాస్ట్ టైప్ వాడకం ఒక సంక్లిష్ట సంఖ్యను చెప్పే వేరియబుల్ యొక్క ఉదాహరణ మరియు మేము దానిని స్థిరంగా నిర్వచించగలము, దీని అర్ధం రాశితో మీరు విలువను మార్చలేరు వేరియబుల్ సి.
నిర్వచనం ప్రకారం re 2.3 ఎందుకంటే మేము ప్రారంభించాము మరియు c అనేది const అని మేము చెప్పినందున, c const అయితే అది పూర్తయింది, ఎందుకంటే నేను ఏ భాగాన్ని మార్చలేను.
కాబట్టి, నేను c.re కి 3.5 ని కేటాయించడానికి ప్రయత్నిస్తే అది సంకలన లోపం అవుతుంది.
ఇది కాన్ - నెస్ యొక్క భావన.
కాబట్టి మనం దాన్ని ఎలా ఉపయోగిస్తామో చూద్దాం.
కాబట్టి, ఇప్పుడు మనకు ఎడమవైపు రెండు ప్రోగ్రామ్‌లు ఉన్నాయి, నిర్దిష్ట సి ప్రోగ్రామ్ # నిర్వచించును ఉపయోగిస్తుంది మరియు కుడి వైపున సి ++ లో ఇలాంటి ప్రోగ్రామ్‌ను వ్రాస్తాము, అదే ప్రయోజనాన్ని సాధించడానికి కాన్-నెస్‌ను ఉపయోగిస్తుంది.
ఇంతకుముందు మేము TWO ని విలువ 2 లో నిర్వచించాము, ఇప్పుడు మేము TWO అనేది 2 తో ప్రారంభించిన పూర్ణాంకం అని చెప్తున్నాము, కానీ ఇది కాస్ట్ వేరియబుల్, కాబట్టి మీరు దీన్ని మార్చలేరు.
దీని యొక్క ప్రధాన ఫలితం ఏమిటంటే, కుడి వైపున ఉన్న ఈ ప్రోగ్రామ్, ఈ ప్రోగ్రామ్ సరైనది అయినప్పుడు, సి ప్రిప్రాసెసర్ ఖచ్చితంగా ఇది # నిర్వచించబడదని చెప్పింది, కాబట్టి ఈ సమయంలో TWO చిహ్నం భర్తీ చేయబడదు.
అదేవిధంగా, PI చిహ్నం అలాగే ఉంటుంది మరియు కంపైలర్ ఇవి ప్రోగ్రామ్‌లో ఉన్న విభిన్న వేరియబుల్స్ అని చూస్తాయి మరియు కంపైలర్‌కు అవి మార్చలేని స్థిరాంకాలు అని తెలుసు.
కాబట్టి మీరు C లో కలిగి ఉన్న అదే లక్ష్యాన్ని మీరు సాధించవచ్చు మరియు ఇప్పుడు కంపైలర్ ఇవన్నీ చూడగల అదనపు ప్రయోజనాన్ని మీరు పొందవచ్చు మరియు కంపైలర్ TWO రకం ఏమిటో కంపైలర్కు తెలుస్తుంది. కంపైలర్. (కంపైలర్) రకం ఏమిటో తెలుస్తుంది PI లేదా దాని కోసం. ఏదైనా వేరియబుల్, మీరు నిర్వచించిన ఏ విలువను అయినా const const ఉపయోగించి నిరంతరాయంగా నిర్వచించండి.
కాబట్టి మీరు దానిని ఉపయోగించడం ద్వారా చాలా ప్రయోజనాలను పొందుతారు.
మీరు స్థిరమైన విలువలను ఉపయోగించాలనుకునే రెండు ప్రధాన సందర్భాలు ఉన్నాయి; ఒక సూచన ఏమిటంటే, మీరు పై వంటి విభిన్న సహజ స్థిరాంకాలతో వ్యవహరించేటప్పుడు ఇ వంటి బంగారు నిష్పత్తి ఫై, తప్పుడు విలువ సున్నా విలువ వంటి బూలియన్ నిజమైన విలువ మరియు మొదలైనవి.
ఒక ప్రోగ్రామ్‌లో చాలా సహజ స్థిరాంకాలు ఉన్నాయి, అవి వాటి విలువను కలిగి ఉంటాయి, వాటి రకాన్ని కలిగి ఉంటాయి మరియు సహజ స్థిరాంకం సహజంగా మీరు వారి అసలు ఆస్తిని కలిగి ఉంటారు, మీరు విలువను మార్చలేరు PI యొక్క లేదా మీరు E విలువను మార్చలేరు, కాబట్టి ఆస్తి కూడా అలాగే ఉంచబడుతుంది.
అలాగే, మనం తరచుగా స్థిరంగా ఉపయోగించే మరొక ప్రదేశం నా ప్రోగ్రామ్ కోసం ఏదో స్థిరంగా ఉంటుంది లేదా ఒక నిర్దిష్ట ఫంక్షన్ కోసం ఏదో స్థిరంగా ఉంటుంది.
కాబట్టి, దీని కోసం మనం మరొక నిర్వచనం యొక్క సమితిని ఉపయోగిస్తాము, అంటే మనకు శ్రేణి ఆకారాన్ని స్థిరంగా నిర్వచించవచ్చు.
ఇవి సార్వత్రిక సహజ స్థిరాంకాలు కాదు, కానీ అవి నా పనికి స్థిరాంకాలు.
నేను ఇలా చేసి ఉంటే, మనకు లభించే ప్రయోజనం, మనం ప్రోగ్రామ్ రాసేటప్పుడు, వాటిని ఈ వేరియబుల్స్ సందర్భంలో వ్రాయవచ్చు, తద్వారా తరువాత మనం వాటిని మార్చవలసి వస్తే, మనం ప్రారంభ ప్రోగ్రామ్‌ను నిరంతరం మార్చవచ్చు.) ఎగువన లేదా బహుశా కొన్ని హెడర్ ఫైల్‌లో.
దీన్ని చేయడం వల్ల మరొక ప్రయోజనం ఏమిటంటే, మీరు # నిర్వచించినట్లయితే, # నిర్వచించు మొత్తం ఫైల్‌లో స్కోప్ ఉంటుంది.
ఒక నిర్దిష్ట నిర్దిష్ట స్థిరమైన విలువ కోసం నేను కొంత విలువ n ని పేర్కొంటే, నా ప్రోగ్రామ్‌లో n ఉన్నచోట, అది ఈ # నిర్వచించే విలువతో భర్తీ చేయబడుతుంది.
కాని const అనేది వేరియబుల్ డిక్లరేషన్, కాబట్టి ఇది ఏ పరిధిలోనైనా చేయవచ్చు, నేను దీన్ని ఒక ఫంక్షన్‌లో చేయగలను, నేను ఒక ఫంక్షన్‌లో ఒక బ్లాక్‌లో చేయగలను మరియు ఏదైనా వేరియబుల్ డిక్లరేషన్ లాగా, const యొక్క వేరియబుల్ డిక్లరేషన్ కూడా దానిలో పరిమితం అవుతుంది పరిధి.
కాబట్టి ఒకే ఫైల్‌లో రెండు వేర్వేరు ఫంక్షన్లలో ఒకే వేరియబుల్ (ఎన్) జరిగే అవకాశం ఉంది, రెండు ప్రదేశాలలో ఇది స్థిరంగా ఉంటుంది, కానీ దీనికి వేర్వేరు విలువలు ఉన్నాయి, మీరు దీన్ని # నిర్వచనంతో చేయవచ్చు ప్రభావాన్ని సాధించలేరు.
మేము # నిర్వచించుట కంటే ఎక్కువ const (const) ను ఇష్టపడతామని సంగ్రహించాము ఎందుకంటే ఇది రకం సందర్భంలో సురక్షితం కాదు, ఇది CPP చేత భర్తీ చేయబడుతుంది, ఇక్కడ const (const) లేనిది.
అందువల్ల, మీరు డీబగ్గర్ ఉపయోగిస్తుంటే, మీరు డీబగ్గర్లో # చిహ్నాలను నిర్వచించలేరు, ఎందుకంటే మీరు చూడగలరు.
ఇతర దుష్ప్రభావం ఏమిటంటే, # ప్రతి దశలో వ్యక్తీకరణను నిర్వచించినందున, ఇది చాలాసార్లు భర్తీ చేయబడినందున మూల్యాంకనం చేయాల్సిన అవసరం ఉంది, ఇక్కడ కాన్ విషయంలో ఇది ప్రారంభ బిందువు వద్ద మాత్రమే అంచనా వేయబడుతుంది.
కాబట్టి, తారాగణం ఖచ్చితంగా # నిర్వచించటం కంటే సంపూర్ణ ప్రయోజనం.
ఇప్పుడు, ముఖ్యంగా const ని నిర్వచించే కొన్ని ఫలితాలను చూద్దాం, పాయింటర్ రకం డేటా యొక్క const - ness ను పరిశీలిస్తాము.
పాయింటర్ రకం డేటాలో, మనకు పాయింటర్ ఉందని మనకు తెలుసు మరియు అది వేరియబుల్‌ను సూచిస్తుంది.
కాబట్టి ప్రశ్న ఏమిటంటే, మేము const-ness గురించి మాట్లాడుతుంటే, మనం ఏ const-ness గురించి మాట్లాడుతున్నాము, మీరు పాయింటర్ యొక్క const-ness లేదా పాయింటర్ డేటా యొక్క const-ness గురించి మాట్లాడుతున్నారా?
ఇక్కడ, డేటా స్థిరంగా ఉందా లేదా పాయింటర్ కాదా లేదా పాయింటర్ స్థిరంగా ఉందా అని స్థిరమైన డేటాను సూచించే రెండు విషయాల గురించి మాట్లాడుతాము, కాని డేటా (డేటా) స్థిరంగా ఉండవచ్చు లేదా ఉండకపోవచ్చు.
ఇక్కడ నేను పాయింటర్ మరియు పాయింటర్‌తో ఎలా లెక్కించాలో ఒక నిర్దిష్ట ఉదాహరణ మాత్రమే చూపిస్తాము.మేము రెండు వేరియబుల్స్ ని నిర్వచించాము, కాబట్టి మనకు పాయింటర్ ఉన్న పాయింటర్ ఉంది. చిరునామా తీసుకుంటుంది మరియు దానిని ఉపయోగించడం ద్వారా నేను నేరుగా వేరియబుల్ మార్చగలను లేదా నేను చేయగలను పాయింటర్ ద్వారా దాన్ని మార్చండి.
అదేవిధంగా, ఈ పంక్తిలో, మొదటి పాయింటర్ n కు గురిపెట్టింది, ఇప్పుడు అది m కు సూచించడానికి మార్చబడింది మరియు వారు m యొక్క విలువను మార్చడానికి దాన్ని మళ్ళీ ఉపయోగించవచ్చు.
ఇది పాయింటర్-పాయింటి దృష్టాంతంలో ఒక సాధారణ ఉపయోగం.
అందువల్ల, const ని ఉపయోగించడం ద్వారా ఈ మార్పును ఎలా నియంత్రించవచ్చో దానితో చర్చిస్తాము.
(స్లైడ్ సమయం చూడండి: 17:34) కాబట్టి మొదటిది, స్థిరమైన డేటా కోసం నాకు సూచిక ఉంటే.
కాబట్టి, మనం ఇక్కడ చేస్తున్నది ఏమిటంటే, డేటాకు ముందు, పాయింటర్ ఏ రకమైన విలువను సూచిస్తుందో ముందు స్థిరంగా వ్రాసాము.
నేను ఈ సమయంలో const వ్రాస్తే, సూచించిన డేటా స్థిరంగా ఉందని అర్థం, దానిని మార్చలేము.
కాబట్టి, n ను స్థిరమైన విలువగా నిర్వచించారు.
N యొక్క విలువను మార్చడానికి ప్రయత్నించడం లోపం అని మనకు ఇప్పటికే తెలుసు, ఎందుకంటే n స్థిరంగా ఉంటే, మరియు p ను n కు పాయింటర్‌గా భావించాము.
కాబట్టి, * p ని కేటాయించిన 7 ను ఉపయోగించి n యొక్క విలువను మార్చడానికి ప్రయత్నించడం కూడా లోపం.
కానీ, p అనేది ఒక స్థిరాంకం కాదు, అందుకే నేను వేరే వేరియబుల్ కోసం p పాయింట్ చేయగలనని కోరుకుంటే, m ఇక్కడ ఒక వేరియబుల్, ఇది స్థిరమైన వేరియబుల్ (వేరియబుల్)) కాదు.
నేను m ని p పాయింట్‌గా చేయగలను, ఆపై m యొక్క విలువను మార్చడానికి నేను ఈ * p కేటాయించిన 8 ని ఉపయోగించవచ్చు, m ఇప్పుడు 8 అవుతుంది, అది 4 అవుతుంది, ఇప్పుడు 8 అవుతుంది.
ఇప్పుడు మీరు చూస్తే, నాకు స్థిరంగా లేని వేరియబుల్ ఉంటే, పూర్ణాంకానికి 5 తో ప్రారంభించిన పూర్ణాంక రకంగా నిర్వచించబడింది మరియు నాకు ఒక పాయింటర్ ఉంది, అది p అనేది స్థిరమైన పూర్ణాంక విలువ యొక్క రకాన్ని సూచిస్తుంది మరియు నేను ప్రవేశించాను.
P లో n యొక్క చిరునామా.
ఇప్పుడు, సహజంగా 6 నుండి n వరకు m కేటాయింపు చెల్లుతుంది ఎందుకంటే n కూడా స్థిరంగా ఉండదు.
 P కేటాయించిన 6 చెల్లుబాటు అయ్యేది, కానీ నేను అలా చేయటానికి ప్రయత్నిస్తే * p 6 ని కేటాయించారు, ఇది చెల్లుబాటు కాదు, ఎందుకంటే m ఒక స్థిరమైన పూర్ణాంకానికి సూచిస్తుంది.
కాబట్టి చాలా ఆసక్తికరమైన దృశ్యం; నేను ఇక్కడ n ను సూచిస్తూ AP కలిగి ఉన్నాను.
P కి తెలుసు, నేను * P వ్రాస్తే స్థిరంగా ఉంటుందని తెలుసు.
ఈ విలువను మార్చడానికి P ఉపయోగించబడదు, కాని n కూడా స్థిరంగా ఉండదు.
కాబట్టి, n మార్చవచ్చు.
ఇప్పుడు, ఇది చెల్లుతుంది ఎందుకంటే మీరు ఏమి చెప్తున్నారో, మీకు కావాల్సిన దానికంటే ఎక్కువ చెబుతున్నారు, n దాని స్వంతంగా మారగలదని మీరు చెబుతున్నారు.
కాబట్టి, నేను దానిని నేరుగా n గా మార్చినా లేదా పాయింటర్ (పాయింటర్) ద్వారా మార్చినా, అది పట్టింపు లేదు ఎందుకంటే n మారవచ్చు, కాని పాయింటర్ (పాయింటర్) నేను మార్చడానికి పరిమితం చేయబడిందని చెప్పాడు.
మీరు నా గుండా వెళితే విలువను మార్చడానికి నేను అనుమతించను అని పాయింటర్ చెప్పింది.
కాబట్టి, వేరియబుల్ వాస్తవానికి మార్చగల దృష్టాంతం ఇక్కడ ఉంది, కానీ పాయింటర్ దానిని మార్చడానికి మిమ్మల్ని అనుమతించని ఒక వీక్షణను ఇస్తుంది, కానీ నేను నేరుగా వెళితే లేదా స్థిరమైన విలువను సూచించని కొన్ని ఇతర పాయింటర్ (పాయింటర్) కావాలనుకుంటే , అప్పుడు మేము మార్చగలుగుతాము.
చివరగా, మేము రివర్స్ చేయడానికి ప్రయత్నిస్తే, నాకు స్థిరమైన వేరియబుల్ (n) ఉంటే మరియు నేను స్థిరంగా లేని విలువ p కోసం పాయింటర్‌ను ఉపయోగించటానికి ప్రయత్నిస్తే, నేను ఇప్పటికీ అలా చేయలేను.
కాబట్టి, మేము ఇప్పుడు వివరించడానికి ప్రయత్నిస్తే, ఇక్కడ చివరి చివరి కేసు ఉంది, కాబట్టి మేము ఈ కేసు గురించి మాట్లాడుతున్నాము, నాకు n ను సూచించే ఒక కోతి ఉంటే, అది నిరంతరంగా ఉంటుంది మరియు * p మనకు స్థిరంగా లేదు, అప్పుడు లోపం చాలా చెల్లుతుంది, ఎందుకంటే n స్థిరంగా ఉంటుంది.
 P స్థిరంగా లేకపోతే, * p n ను సూచించడానికి ప్రయత్నిస్తుంటే, n యొక్క విలువను మార్చడానికి నేను ఎల్లప్పుడూ * p ని ఇక్కడ ఉపయోగించగలను.
కాబట్టి మనం ఇక్కడ నేర్చుకున్నది ఒక విలువ స్థిరంగా లేనట్లయితే, దాన్ని పొందటానికి, నిరంతరాయంగా సూచించడానికి నేను దానిని ఉపయోగించగలను, కాని నేను దానిని ఆ పాయింటర్ (పాయింటర్) అని పిలుస్తాను.
విలువ స్థిరంగా ఉంటే, స్థిరమైన విలువను సూచించే పాయింటర్‌ను నేను ఉపయోగించలేను. ఈ స్థిరమైన వేరియబుల్ (పాయింటర్) చిరునామాతో ఆ కాన్స్ట్ (పాయింటర్) ను కేటాయించనివ్వండి ఎందుకంటే ఇది ప్రారంభించడానికి అనుమతించబడదు ఎందుకంటే ఇది ఉల్లంఘిస్తుంది స్థిరమైన-నెస్ యొక్క ప్రాథమిక సూత్రం.
తరువాత, మరొక వైపు స్థిరమైన నెస్‌ను చూద్దాం, పాయింటర్ స్థిరంగా ఉంటే? కాబట్టి, మేము ఇక్కడే ఉన్నామని మీరు ఇక్కడ చూస్తే, మేము తారాగణం వ్రాసిన స్థానాన్ని కొద్దిగా మార్చాము.
ఇంతకుముందు ఇక్కడ ఈ స్థిరాంకం వ్రాయబడింది, ఇప్పుడు ఖర్చు స్టార్ గుర్తు తర్వాత వ్రాయబడింది, పాయింటర్ స్థిరంగా ఉందని చెప్తుంది, కానీ అది సూచించే విలువ స్థిరంగా లేదు.
నేను దానిని గీస్తే, p అనేది const మరియు n const కాదు.
కాబట్టి, దీని అర్థం ఏమిటంటే, ఇది n const కాదని నేను సులభంగా వ్రాయగలిగితే, నేను దాని విలువను మార్చగలను, ఎందుకంటే n const కాదు కాబట్టి, నేను దీన్ని చేయటానికి p derence ని ఉపయోగించవచ్చు. ఏడు నుండి * p వరకు కేటాయిస్తుంది, ఇది విలువను మారుస్తుంది యొక్క n.
ఎందుకంటే నేను దేనినీ ఉల్లంఘించడం లేదు, కానీ నేను అలా చేయలేను, p లో నిల్వ చేసిన చిరునామాను నేను మార్చలేను.
నేను ఇకపై p ను క్రొత్త వేరియబుల్ m కి సూచించలేను, ఎందుకంటే పాయింటర్ కూడా స్థిరంగా ఉందని నేను చెప్పాను. ఈ వైపు స్థిరంగా ఉంటుంది. ఇప్పుడు రెండవ వైపు స్థిరంగా ఉంది.
సహజంగానే, మనకు ఇది ఉంటే, పొడిగింపు ద్వారా పాయింటర్ మరియు అది సూచించే డేటా నిరంతరంగా ఉండవచ్చని కూడా మనం జోడించవచ్చు.
కాబట్టి, ఇక్కడ మనం రెండు వైపులా కాస్ట్‌లు వ్రాసే ఒక ఉదాహరణను చూపిస్తున్నాము, అంటే p అనేది నిరంతర డేటాకు పాయింటర్, అంటే p కూడా మరొకదానికి సూచించబడదు. N కాకుండా వేరే వేరియబుల్స్ కోసం తయారు చేయవచ్చు, లేదా చేయలేము n విలువను మార్చడానికి p ని ఉపయోగించండి.
కాబట్టి, ఇవన్నీ ఇప్పుడు లోపం అవుతాయి.
ఇప్పుడు, వాస్తవానికి, మేము సూచించిన డేటా లేదా పాయింటర్‌పై const - ness వ్రాస్తున్నందున, నేను ఎక్కడ const వ్రాయాలి అనేది కొన్నిసార్లు గందరగోళంగా ఉంటుంది మరియు const const keyword ఉంచడం ద్వారా ఏమి జరుగుతుంది.
బొటనవేలు నియమం చాలా సులభం, మీకు ఈ ప్రకటన ఉన్నప్పుడు ప్రకటన అంతటా స్టార్ సింబల్‌లో కనిపిస్తుంది.
మానసికంగా ఒక నిలువు వరుసను గీయండి, తద్వారా మీరు దీన్ని చేయటానికి ప్రయత్నిస్తుంటే const int * p, మొదలైనవి చెబుతున్నారు. ఈ నక్షత్ర చిహ్నం ద్వారా నిలువు వరుసను గీయండి మరియు const కీవర్డ్ ఏ వైపున కనిపిస్తుంది అని చూడండి, ఇది మీ డేటా వైపు మరియు ఇది మీ పాయింటింగ్ వైపు.
కాస్ట్-నెస్ డేటా వైపు ఉంటే, మీరు సూచించేది స్థిరంగా ఉంటుంది.
దీనికి విరుద్ధంగా మీకు int * const p et cetera ఉంటే, అది const పాయింటర్‌లో ఉంటుంది కాబట్టి పాయింటర్ స్థిరంగా ఉంటుంది.
కాబట్టి ఇది ప్రాథమిక బొటనవేలు నియమం, వీటిలో ఏది స్థిరంగా ఉందో మీరు నిర్ణయించవచ్చు.
ఉదాహరణలు క్రింద ఇవ్వబడ్డాయి.
కాబట్టి, మీరు దీన్ని ఉపయోగించవచ్చు మరియు ఇది నేను పనిచేసిన స్ట్రింగ్‌కు ఒక ఉదాహరణ. మీరు దీన్ని జాగ్రత్తగా చదవవచ్చు మరియు స్ట్రింగ్ ఇవ్వబడిందని అర్థం చేసుకోవడానికి ప్రయత్నించవచ్చు మరియు మా వద్ద మీకు స్ట్రింగ్ ఉంటే, మీరు మీరు రెండు మార్గాలను మార్చవచ్చు స్ట్రింగ్‌ను సవరించవచ్చు లేదా మీరు స్ట్రింగ్‌ను మార్చవచ్చు.
ఎగువన ఉన్న కోడ్‌లో మేము స్ట్రింగ్‌ను సవరించడం లేదా మొత్తం స్ట్రింగ్‌ను పూర్తిగా మార్చడం యొక్క ప్రభావాన్ని చూపుతాము.
మీరు ఇలా ఏదైనా చేస్తే, ఇక్కడ స్థిరాంకం ఉంచండి, మీరు ఇక్కడ ఒక కాన్స్ట్ ఉంచినట్లయితే, స్ట్రింగ్ స్థిరంగా మారుతుంది, కాబట్టి మీరు స్ట్రింగ్ చేయవచ్చు) ఏ అక్షరాన్ని మార్చలేరు.
అందువల్ల, మీరు ఇకపై చేయలేని మొదటి గుర్తుకు n వ్రాయగలరని మీరు ఇక్కడ చేయలేరు.
అయితే, మీరు ఈ వైపు ప్రసారం చేస్తే, మీరు ఇప్పుడు స్ట్రింగ్‌లోని ఏదైనా చిహ్నాన్ని మార్చవచ్చు, కానీ మీరు స్ట్రింగ్‌ను మొత్తంగా మార్చలేరు.
ఇక్కడ మీరు స్ట్రింగ్‌ను మార్చవచ్చు.ఇప్పుడు మీరు స్ట్రింగ్‌ను మార్చలేరు ఎందుకంటే పాయింటర్‌ను మార్చడం దీని అర్థం.
మీరు పాయింటర్‌కు ఇరువైపులా ప్రసారం చేస్తే, మీరు వరుసగా నాలుగు అక్షరాలను సూచించే నాలుగు నక్షత్రాల నక్షత్రం ఉంటే, రెండింటినీ సవరించలేకపోతే, మీరు రెండు సవరణలను మరియు పేరు మార్పును రక్షించవచ్చు.
అలాగే మార్చలేరు.
రెండు వైపులా కాస్ట్-నెస్ ఎలా వర్తించబడుతుందో చూపించడానికి ఒక ఉదాహరణ.
అందువల్ల, const - ness యొక్క ప్రాథమిక భావనను మరియు పాయింటర్ల పరంగా const - ness ఎలా వర్తించబడుతుందో చర్చించాము.
inhouse/NPTEL/PreFinal/c++/Telugu/37 basicElectonics_Karnaugh maps-jheob0v0CU4.txt
View file @ 956c0d4e
This source diff could not be displayed because it is too large. You can view the blob instead.
inhouse/NPTEL/PreFinal/c++/Telugu/38 basicElectonics_Digital -to- analog conversion-1-wGAfArijDks.txt
View file @ 956c0d4e
 1.
2. బాసిక్ ఎలెక్త్రొనిక్స్ కు స్వాగతము.
3. ఇప్పుడు మేము అనలాగ్ మరియు డిజిటల్ డొమైన్ మధ్య ఇంటర్ఫేస్ అనే క్రొత్త అంశంతో ప్రారంభిస్తాము, ఇది అనలాగ్ కన్వర్టర్ లేదా D A C తో డిజిటల్ యొక్క ప్రాథమిక కార్యాచరణను పరిశీలిస్తాము.
4. అప్పుడు మేము బైనరీ వెయిటెడ్ రిజిస్టర్లను ఉపయోగించి అమలు చేయబడిన D A C ని చూస్తాము మరియు వివిధ రకాల వడ్డీ కోసం పని చేస్తాము.
5. ఒక ఉదాహరణతో ప్రారంభిద్దాం.
6. ఇప్పుడు మేము అనలాగ్-టు-డిజిటల్ కన్వర్టర్ మరియు డిజిటల్-టు-అనలాగ్ కన్వర్టర్ గురించి చర్చిస్తాము మరియు అలాంటి కన్వర్టర్ వెనుక ఉన్న ప్రేరణతో మనం ఈ కన్వర్టర్ ఎందుకు మొదటి స్థానంలో అవసరమో ప్రారంభిద్దాం.
7. కాబట్టి, ఇక్కడ కొన్ని పాయింట్లు ఉన్నాయి, అసలు సిగ్నల్, థర్మోకపుల్‌తో కొలవబడిన వోల్టేజ్ లేదా కాలక్రమేణా మైక్రోఫోన్ లేదా అనలాగ్ వాల్యూమ్‌తో రికార్డ్ చేయబడిన స్పీచ్ సిగ్నల్. నిరంతరం మారుతూ ఉంటుంది.
8. మరోవైపు, మనం ఇంతకు మునుపు చూసినట్లుగా డిజిటల్ ఫార్మాట్‌లో డిజిటల్ సిగ్నల్ ప్రాసెసింగ్, స్టోరేజ్, కంప్యూటర్ వాడకం, స్ట్రాంగ్ ట్రాన్స్‌మిషన్ మొదలైన అనేక ప్రయోజనాలు ఉన్నాయి.
9. అందువల్ల, అనలాగ్ సిగ్నల్స్ అయిన ఈ నిజమైన సంకేతాలను డిజిటల్ ఆకృతికి మార్చడం అర్ధమే, ఆపై డిజిటల్ ఫార్మాట్ అందించే ఈ లక్షణాలన్నింటినీ సద్వినియోగం చేసుకోండి.
10. ఒక A D C అంటే అనలాగ్-టు-డిజిటల్ కన్వర్టర్‌కు అనుకూలంగా ఉండే A D C అనలాగ్ సిగ్నల్‌ను డిజిటల్ ఆకృతికి మార్చడానికి ఉపయోగించబడుతుంది.
11. డిజిటల్-టు-అనలాగ్‌కు రివర్స్ కన్వర్టర్ కూడా అవసరం, ఉదాహరణకు, ఒక డివిడిలో నిల్వ చేసిన సంగీతాన్ని స్పీకర్‌లో డిజిటల్ ఫార్మాట్‌లో ప్లే చేయాలి.) అనలాగ్ వోల్టేజ్‌గా మార్చాలి, అందువల్ల మేము ఆ సంగీతాన్ని వింటాము మరియు ఈ కన్వర్టర్ DAC చేత చేయబడుతుంది, డిజిటల్ సిగ్నల్‌ను అనలాగ్ ఆకృతిలోకి మార్చడానికి ఉపయోగించే స్టాండ్ (స్టాండ్) నుండి డిజిటల్ నుండి అనలాగ్ కన్వర్టర్ అయిన DAC.
12. డిజిటల్-టు-అనలాగ్ కన్వర్టర్ అయిన DAC యొక్క స్కీమాటిక్ పిక్చర్ ఇక్కడ ఉంది, ఇది డిజిటల్ ఇన్పుట్, ఇది అనలాగ్ అవుట్పుట్, అప్పుడు మనకు భూమికి చిప్ ఉంటుంది మరియు రిఫరెన్స్ వోల్టేజ్.
13. D, N మైనస్ 1 వరకు N బిట్స్ D 0, D 1, D 2 వరకు డిజిటల్ ఇన్పుట్.
14. ఇప్పుడు D A C ఈ బైనరీ సంఖ్య మరియు ఈ రిఫరెన్స్ వోల్టేజ్ విలువలను బట్టి అనలాగ్ వోల్టేజ్ అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుంది.
15. 4 బిట్ D A C కి ఇక్కడ ఒక ఉదాహరణ; అంటే, N ఇక్కడ ఇన్పుట్ S 3, S 2, S 1, S 0 తో ఉంటుంది, ఇది D 3, D 2, D 1, D 0 కు అనుగుణంగా ఉంటుంది.
16. VA కి సమానమైన అవుట్పుట్ వోల్టేజ్ స్థిరమైన k k సార్లు S 3, ఇది 1 లేదా 0 కావచ్చు, 23+ S 2 (2 ప్లస్ 3 ప్లస్ S 2 కు గుణించాలి), ఇది మళ్ళీ 1 లేదా 0 రెట్లు పెరుగుతుంది 22+ S 1 (2 2 కి పెంచండి ప్లస్ ఎస్ 1) సార్లు 21+ ఎస్ 0 (2 పెంచడం 1 ప్లస్ ఎస్ 0) సార్లు 20 (2 కి 0 కి పెంచండి), మరియు సాధారణంగా మనం ఈ సమీకరణాన్ని VA కి సమానంగా వ్రాయవచ్చు K యొక్క మొత్తం 0 నుండి N మైనస్ 1 S k 2K ద్వారా (2 కి K కి పెంచండి).
17. అందువల్ల, ఇక్కడ గమనించవలసిన ముఖ్యమైన విషయం ఏమిటంటే, ప్రతి బిట్ వేరే బరువు (బరువు) పొందుతుంది, అధిక బిట్స్ ఎక్కువ బరువును పొందుతాయి మరియు తక్కువ బిట్స్ తక్కువ బరువును పొందుతాయి. మరియు ఈ స్కేలింగ్ కారకం (కారకం K) ఇక్కడ రిఫరెన్స్ వోల్టేజ్ VR కు అనులోమానుపాతంలో ఉంటుంది. , దాని విలువ DAC ఎలా వర్తించబడుతుందో దానిపై ఆధారపడి ఉంటుంది.+
18. ఇప్పుడు, V A అవుట్పుట్ వోల్టేజ్‌ను డిజిటల్ ఇన్పుట్ యొక్క ఫంక్షన్‌గా ఎలా మారుస్తుందో చూద్దాం, ఇది మేము D A C లేదా రేఖాచిత్రానికి వర్తింపజేస్తాము మరియు N 4 ఉన్న చోట అదే ఉదాహరణను తీసుకుంటాము.
19. కాబట్టి, ఇది 4 బిట్ (ఎ) డి ఎ సి.
20. కాబట్టి, ఇక్కడ మా డిజిటల్ ఇన్పుట్ ఉంది, మొదటి సంఖ్య 0 0 0 0 తరువాత 0 0 0 1, 0 0 1 0 మొదలైనవి 1 1 1 1 వరకు ఉంటాయి. కాబట్టి, ఈ దశాంశం 0, ఈ దశాంశం 1, 2 3, 4 మొదలైనవి 15 వరకు ఉంటుంది, మరియు ఈ అనువర్తిత ఇన్పుట్ ఫలితంగా అవుట్పుట్ V A 0 నుండి కొన్ని గరిష్ట అవుట్పుట్ వోల్టేజ్ వరకు మారుతుంది.
21. మరియు మనకు వివిక్త పాయింట్లు మాత్రమే ఉన్న సరళ రేఖ లేదా వక్రరేఖ లేదని ప్రత్యేకంగా గమనించండి మరియు మా ఇన్పుట్ వివిక్తమైనది మరియు ఈ 16 విలువలు మాత్రమే మరియు ఉదాహరణకు 2 విలువలు (విలువలు), ఉంది ఈ సంఖ్య మరియు ఆ సంఖ్య మధ్య డిజిటల్ ఇన్పుట్ లేదు.
22. కాబట్టి, మేము ఇక్కడ పాయింట్లను పరిశీలిస్తాము మరియు పంక్తులు లేదా వక్రతలు అన్నీ సరైనవి కావు.
23. ఇప్పుడు 2 వరుస అవుట్పుట్ విలువల మధ్య ఈ వ్యత్యాసాన్ని రిజల్యూషన్ సమయం అంటారు.ఇప్పుడు మనం DAC యొక్క బిట్ల సంఖ్య మరియు గరిష్ట అవుట్పుట్ వోల్టేజ్ యొక్క తీర్మానాన్ని సులభంగా తెలుసుకోవచ్చు. ఎందుకంటే ఈ సందర్భంలో 2N-1 ఉన్నాయని మనకు తెలుసు (2 N-1 కి పెంచండి). ఇక్కడ, ఉదాహరణకు, మనకు 2N-1 (2 N-1 కు పెంచండి) ఉంది, ఇది చాలా తక్కువ మరియు అత్యధిక విలువల మధ్య 16 మైనస్ 1 లేదా 15 విభాగాలు ఉన్నాయి.
24. కాబట్టి, ఈ సందర్భంలో గరిష్ట అవుట్పుట్ వోల్టేజ్ 15 ద్వారా విభజించబడినట్లు మేము రిజల్యూషన్ను లెక్కించవచ్చు.
25. ఇప్పుడు మనము D A C అమలు గురించి మాట్లాడుదాం మరియు బైనరీ వెయిటెడ్ రిజిస్టర్లను ఉపయోగించడం మా మొదటి విధానం, ఈ పదం యొక్క అర్థం ఏమిటి? 1 ప్రతిఘటన అయితే, తరువాతి 2 సార్లు, అంటే 2 R తదుపరి 2 సార్లు 2 R అంటే 4 R మరియు తరువాత 8 R మొదలైనవి.
26. ఇప్పుడు ఈ నిర్దిష్ట ఉదాహరణ 4 బిట్ (బిట్) D A C ఇన్పుట్ S 3, S 2, S 1, S 0, కాబట్టి S 3 0 లేదా 1 కావచ్చు, S2 0 లేదా 1 కావచ్చు.
27. అవుట్పుట్ VA ఇక్కడ ఈ op-amp యొక్క అవుట్పుట్, మనకు 4 స్విచ్లు ఉన్నాయి, ఇవి ఇన్పుట్ బిట్స్ S 3, S 2, S 1 ద్వారా నియంత్రించబడతాయి.
28. ఉదాహరణకు, ఈ స్విచ్ S 3 చే నియంత్రించబడుతుంది, S 3 0 అయితే, ఈ నోడ్ A 3 అలాంటి భూమికి అనుసంధానిస్తుంది మరియు S 3 గ్రౌండ్ అయితే A 3 అంటే రిఫరెన్స్ వోల్టేజ్ VR కి అనుసంధానించబడి ఉంటుంది.
29. మరో మాటలో చెప్పాలంటే, ఈ నోడ్ వద్ద వోల్టేజ్ S 3 రెట్లు ఉంటే, S 3 0 అయితే, ఆ వోల్టేజ్ 0 మరియు S 3 1 అయితే, ఆ వోల్టేజ్ VR మరియు ఈ స్విచ్ తో మనం ఇక్కడ చూపించాము S 2 నియంత్రించబడుతుంది మరియు అందువల్ల, ఈ వోల్టేజ్ S 2 రెట్లు VR.
30. ఇది S 1 చే నియంత్రించబడుతుంది.
31. కాబట్టి, ఇది S 1 సార్లు V R మరియు ఇది S 0 సార్లు V R.
32. కాబట్టి, ఇది మా సరళీకృత సర్క్యూట్ మరియు ఇది మా op-amp వేసవి (వేసవి) అని మేము చూశాము మరియు ఇప్పుడు ఇది ఎలా పనిచేస్తుందో చూద్దాం.
33. V మైనస్ మరియు V ప్లస్ సమానమైనవి కాబట్టి, మనకు V మైనస్ 0 కి సమానం మరియు అందువల్ల, ఈ కరెంట్‌ను లెక్కించవచ్చు మరియు ఈ కరెంట్ నేను 0 ప్లస్ I 1 ప్లస్ I 2 ప్లస్ I 3 తప్ప మరొకటి కాదు.
34. I0 ఇది S 0 V R మైనస్ 0 8R చే విభజించబడింది.
35. I1 ఇది S 1 V R మైనస్ 0 ను 4 R చే విభజించబడింది.
36. కాబట్టి, ఇది మాకు ఈ వ్యక్తీకరణను ఇస్తుంది.
37. కాబట్టి ప్రస్తుతము I, S 0 VR / 8 R ప్లస్ S 1 VR / 4 R మొదలైనవి. మరియు ఇప్పుడు మనం చేయగలిగేది ఈ సాధారణ (సాధారణ) VR / 8 R ను తీసుకొని, ఆపై ఈ వ్యక్తీకరణను ఇక్కడ పొందండి. ఇప్పుడు మనం జనరల్ రాశాము దీని కోసం వ్యక్తీకరణ.
38. మా విషయంలో N బిట్స్ 4 కి సమానం.
39. కాబట్టి, మా విషయంలో ఈ 2N-1 (2 N-1 కి పెంచడం) 23 (2 కి 3 కి పెంచండి) ఇది 8 కి సమానం.
40. కాబట్టి, ఇది మనకు లభిస్తుంది మరియు ప్రతి బిట్ వేరే బరువును పొందుతుంది. ఉదాహరణకు, LSB 0 యొక్క బరువు (బరువు) 20 లేదా 1 మరియు మా విషయంలో నాకు MSB 3 ఉంది, ఇది 23 లేదా 8 బరువు కలిగి ఉంటుంది మరియు ఇదే మేము DAC (DAC) నుండి ఆశించాము.
41. చివరగా, అవుట్పుట్ వోల్టేజ్ VA ను మేము కనుగొన్నాము, ఇక్కడ మేము ఆప్ ఆంప్ సర్క్యూట్ గురించి మాట్లాడినప్పుడు ఇంతకుముందు చేసాము - ఈ V మైనస్ 0 వోల్ట్లు మరియు కరెంట్ op amp లోకి వెళ్ళదు. అందువల్ల, ఈ ప్రస్తుత కరెంట్ R f మరియు అందువల్ల, VA ఇది మా అవుట్పుట్ వోల్టేజ్ V o 0 మైనస్ I సార్లు R f మరియు ఇక్కడ మనకు ఉన్నది మైనస్ R f సార్లు I మరియు నేను ఈ వ్యక్తీకరణ నుండి వచ్చింది మరియు అందువల్ల ఇది అవుట్పుట్ వోల్టేజ్ కోసం మనం పొందుతాము.
42. ఒక నిర్దిష్ట ఉదాహరణ తీసుకుందాం, 5 R వోల్ట్లకు సమానమైన V R తో 8-బిట్ (బిట్) D A C ను పరిగణించండి, R యొక్క అతిచిన్న విలువ ఏమిటి? సరఫరా నుండి డ్రా అయిన కరెంట్‌ను 10 మిల్లియాంప్‌కు పరిమితం చేసే నిరోధకత మా సరఫరా VR మరియు ఇది ఈ ప్రవాహాలన్నింటినీ సరఫరా చేస్తుంది మరియు మేము సరఫరా నుండి లాగే మొత్తం కరెంట్, ఇది 10 మిల్లియాంప్‌లకు పరిమితం చేయాలి.
43. ఇప్పుడు ఇది 8 బిట్ (DAC) కాబట్టి, మన నిరోధక విలువలు (విలువ) R, 2 R, 4 R మొదలైన వాటి నుండి వెళ్లి, ఆపై 26 (2 కి 6 కి పెంచండి) R కి పెరుగుతాయి మరియు తుది విలువ 27 (2 పెంచండి to 7) R.
44. లేకపోతే సర్క్యూట్ మనం ఇంతకు ముందు చూసినట్లే.
45. ఇప్పుడు సర్క్యూట్లో ఉన్న మొత్తం అంచు. ఈ స్విచ్ LSB చే S 0 గా నియంత్రించబడుతుంది. ఈ స్విచ్ S 1 చే నియంత్రించబడుతుంది మరియు చివరకు, ఈ స్విచ్) S 7 చే నియంత్రించబడుతుంది, ఇది MSB.
46. ఇప్పుడు మనం ఈ ప్రవాహాలను I 0, I 1 మొదలైనవి I 7 వరకు తీసుకుంటాము.
47. ఇప్పుడు ఈ నోడ్ వర్చువల్ గ్రౌండ్ V మైనస్ మరియు V ప్లస్ లతో సమానంగా ఉంటుంది.
48. అందువల్ల, మనకు 0 వోల్ట్లు ఉన్నాయి. ఇక్కడ ఈ కరెంట్ I 0 ఈ నోడ్‌లోని సంభావ్యత ద్వారా R 0 తో విభజించబడింది. A 0 మైనస్ 0 ఇది 27 (2 కి 7 కి పెంచండి) R మరియు ఈ విధంగా మేము ఈ ఇతర ప్రవాహాలను పొందుతాము. (ప్రవాహాలు ) పొందవచ్చు.
49. S 0 0 అయినప్పుడు, స్విచ్ ఈ స్థితిలో ఉంటుంది. నోడ్ A0 మైదానంలో ఉంది మరియు అందువల్ల, నేను 0 మరొక వైపు 0 గా ఉంటాను. S 0 1 అయితే, స్విచ్ ఆ స్థితిలో ఉంటుంది., ఇక్కడ సంభావ్యత ఉన్నప్పుడు VR మరియు తరువాత మనకు VR కరెంట్ R 0 తో విభజించబడింది.
50. మరో మాటలో చెప్పాలంటే, ఈ రిజిస్టర్ S 0 1 అయితే విద్యుత్ సరఫరా నుండి మాత్రమే విద్యుత్తును గీస్తుంది, అదేవిధంగా ఈ రెసిస్టర్ S 1 1 మరియు విద్యుత్ సరఫరాకు గరిష్ట కరెంట్ ఉంటే విద్యుత్ సరఫరా నుండి విద్యుత్తును తీసుకుంటుంది) సరఫరా చేయడానికి, మేము స్పష్టంగా S 0 కి సమానమైన 1 అవసరం, 1 S 1 కు సమానం, మొదలైనవి S 7 కు సమానమైన 1 వరకు అవసరం.
51. ఈ విధంగా, మేము ఇక్కడ వ్రాసాము.
52. గరిష్ట ఇన్పుట్ 1 1 1 1 1, 1 1 1 1 అయినప్పుడు, ఇన్పుట్ 1 1 1 1, 1 1 1 1 అయినప్పుడు VR నుండి గరిష్ట ప్రస్తుత ప్రవాహం VR నుండి తీసుకోబడుతుంది. అన్ని లోడ్ (లోడ్) A 0 నుండి A 7 ఇది VR కి అనుసంధానించబడి ఉంది.
53. కాబట్టి గరిష్ట కరెంట్ 10 మిల్లియాంప్స్‌కు పరిమితం చేయబడింది, కాబట్టి మేము 10 మిల్లియాంప్స్‌కు సమానం.
54. ఈ రెసిస్టెన్స్ ప్లస్ V R / 2R ద్వారా వచ్చే కరెంట్ తదుపరి నిరోధకత ద్వారా కరెంట్.
55. VR / 27 (2 పెంచడం 7) R వరకు అన్ని మార్గం సరైనది మరియు మేము VR / 27 (2 కి 7 కి పెంచండి) R సాధారణం (సాధారణం) మరియు 20 (2 ను 0 కి పెంచండి) మరియు 21 (2 పెంచడం 1 ) ప్లస్ 22 (2 కి 2 పెంచండి) మొదలైనవి 27 వరకు పొందవచ్చు (2 7 కి పెంచండి) మరియు ఇది బ్రాకెట్ 28-1 (2 రైజ్ 8 మైనస్ 1) గా మారుతుంది, ఇది 256 మైనస్ 1, 27 (2 రైజ్ to 7) కాబట్టి 128, కాబట్టి మేము R ద్వారా 255 రెట్లు VR తో ముగుస్తాము మరియు అది 10 మిల్లియాంప్స్ మించకూడదు మరియు అది మాకు R యొక్క కనీస విలువను ఇస్తుంది.
56. అంటే, VR ను 5 మిల్లియాంప్ నుండి 10 మిల్లియాంప్ నుండి 255/128 తో విభజించి 1 కిలో ఓం (కిలో ఓం) గా తేలింది.
57. ఇప్పుడు, ఈ ఉదాహరణ గోపాలన్ రాసిన ఈ పుస్తకం నుండి తీసుకోబడింది మరియు D A C మరియు A D C గురించి మరెన్నో ఆసక్తికరమైన వివరాలు ఉన్నాయి మరియు చూడటానికి మంచి పుస్తకం.
58. తదుపరి ప్రశ్న, R f కు సమానం అయితే, డెల్టా VA లో VA ఇక్కడ మారే తీర్మానం ఏమిటి.
59. ఇన్‌పుట్‌కు అనుగుణమైన ఎల్‌ఎస్‌బి అన్ని ఇతర ఇన్‌పుట్ బిట్‌లతో 0 నుండి 1 వరకు మారుతుంది.
60. I.
61. కాబట్టి, ఇది VA కోసం మా వ్యక్తీకరణ మరియు ఇది బ్రాకెట్ యొక్క ఇన్పుట్ బైనరీ సంఖ్యతో సరిపోతుంది, ఈ బ్రాకెట్ యొక్క కనీస విలువ ఏమిటి? S 0 0, S 1 0 అయినప్పుడు ఇది జరుగుతుంది.
62. S 7 అన్ని మార్గం 0 కి సమానం.
63. కాబట్టి, అత్యల్ప విలువ 0, ఇది అత్యధికం? S 0 1, S 1 1, మొదలైనవి ఉన్నప్పుడు S7 కు సమానమైన అత్యధిక విలువ.
64. మరియు అది అత్యధిక విలువ 255 లేదా 28-1 (2 8 మైనస్ 1 కి పెంచండి).
65. మరియు మేము రిజల్యూషన్ గురించి మాట్లాడేటప్పుడు, ఈ బ్రాకెట్‌ను 1 కి మార్చడానికి మేము అనుమతిస్తున్నాము మరియు ఈ ఇన్పుట్ LSB వలె అదే డెల్టా (డెల్టా) VA అని చెప్తున్నాము, ఇక్కడ S 0 ఇతర ఇన్పుట్ బిట్లతో 0 నుండి 1 కి మారుతోంది.
66. ఇప్పుడు మీరు రిజల్యూషన్‌ను లెక్కించవచ్చు.
67. అందువల్ల, VA డెల్టా రిజల్యూషన్, దీనిని బ్రాకెట్ 1 తో భర్తీ చేసినప్పుడు, ఇక్కడ పునరుత్పత్తి చేయబడిన ఈ కారకం ద్వారా ఇవ్వబడుతుంది మరియు ఇది 5 వోల్ట్‌లు, ఇది VR (2 8 మైనస్ 1 కి పెంచండి) ఈ సంఖ్య ఇక్కడ చాలాసార్లు Rf / R మరియు, Rf మరియు R సమానంగా ఉంటాయి, కాబట్టి ఇది 0.0391 వోల్ట్లు లేదా 39.1 మిల్లీవోల్ట్లుగా మారుతుంది.
68. తరువాతి ప్రశ్న ఏమిటంటే మాగ్నిట్యూడ్‌లో గరిష్ట అవుట్పుట్ వోల్టేజ్ ఏమిటి, ఇది మా VA మరియు ఇది ప్రతికూలంగా ఉందని గమనించండి మరియు అందుకే మేము మాగ్నిట్యూడ్‌ను ఇక్కడ బ్రాకెట్లలో ఉంచాము మరియు మాగ్నిట్యూడ్ గరిష్టంగా ఉన్నప్పుడు? బ్రాకెట్ గరిష్టంగా మారినప్పుడు ఇది జరుగుతుంది. దీని అర్థం ఈ బిట్స్ అన్నీ 1 కి సమానం.
69. అందువల్ల, ఇన్పుట్ బైనరీ సంఖ్య 1 1 1 1, 1 1 1 1 1 అయినప్పుడు గరిష్ట V A పరిమాణంలో లభిస్తుంది.
70. కాబట్టి, మనం చేయవలసింది ఇప్పుడు ఈ S లన్నింటినీ 1 తో భర్తీ చేసి, ఈ బ్రాకెట్‌ను అంచనా వేయండి మరియు అది మనకు లభిస్తుంది - VR అంటే 5 వోల్ట్‌లు 2 నుండి మైనస్ 1 వరకు పెరుగుతాయి, ఇది 128 Rf మరియు R కి సమానం.
71. కాబట్టి, ఇది ఒకటి మరియు ఈ బ్రాకెట్ అప్పుడు 20 (2 కి 0 కి పెంచండి) ప్లస్ 21 (2 కి 1 కి పెంచండి) 27 నుండి (2 కి 7 కి పెంచండి) పైకి, మరియు మనం అంచనా వేసినప్పుడు మనకు 9.961 వోల్ట్లు లభిస్తాయి.
72. 1 0 1 0 0 1 1 0 0 1 కు అనుగుణమైన అవుట్పుట్ వోల్టేజ్ను కనుగొనడం తదుపరి ఇన్పుట్ బైనరీ సంఖ్య చాలా సులభం, మనకు ఇక్కడ VA ఉంది, మనం చేయాల్సిందల్లా 1 S 7 కు సమానం, 0 S 6 కు సమానం, 1 S 5 కు సమానం, 0 S 4 కు సమానం.
73. మరియు మేము దానిని ఎలా పొందుతాము.
74. కాబట్టి, V A మైనస్ 6.758 వోల్ట్లు అవుతుంది.
75. తదుపరి ప్రశ్న, రెసిస్టర్లు 1 శాతం సహనం కలిగి ఉన్నట్లు పేర్కొనబడితే, ఇన్పుట్ 1 కి అనుగుణంగా మోడ్ (మోడ్) VA యొక్క పరిధి ఏమిటి.
76. 1 1 1 1, 1 1 1 1. ఇప్పుడు మొదట 1 శాతం సహనం ఏమిటో మనకు ఇవ్వండి, ఉదాహరణకు ఈ ప్రతిఘటనను తీసుకుంటుంది, ఇది 1 నామమాత్రపు నామమాత్రపు విలువ అని మాకు చెప్పండి. ఇది k అయితే, దీని అర్థం వాస్తవ విలువ 0.99 సార్లు 1 k నుండి 1.01 సార్లు 1 k మధ్య ఏదైనా కావచ్చు.
77. ఈ ప్రతిఘటన గురించి ఏమిటి? R మరియు R f ఒకటేనని మేము అనుకుంటాము, కాబట్టి R 7 యొక్క నామమాత్ర విలువ కూడా 1 k మరియు అందువల్ల, అసలు విలువ 0.99 k నుండి 1.01 k వరకు మారుతుంది.
78. ఈ ప్రతిఘటన గురించి ఏమిటి? నామమాత్రపు విలువ 26 రెట్లు R; అంటే, 64 సార్లు 1 k లేదా 64 k మరియు దాని వాస్తవ విలువ 64 k సార్లు 0.99 నుండి 64 k సార్లు 1.01 వరకు మారవచ్చు.
79. ఇప్పుడు మేము మా అసలు ప్రశ్నకు తిరిగి వస్తాము మరియు ఈ ఇన్పుట్తో మా స్విచ్లు అన్నీ పై స్థానంలో ఉన్నాయి; దీని అర్థం, A 7 V R కి అనుసంధానించబడి ఉంది, A 1 V R కి అనుసంధానించబడి ఉంది మరియు ఈ ప్రవాహాలన్నీ ఇప్పుడు సున్నా కానివి.
80. ఈ పరిమాణాలలో VA గరిష్టంగా ఉండటానికి, ఈ ప్రవాహాలన్నీ వాటి గరిష్ట విలువలకు తీసుకెళ్లాలి మరియు ఈ ప్రతిఘటనలను వాటి కనీస విలువలకు తీసుకువెళ్ళినప్పుడు ఇది జరుగుతుంది, ఇది షరతు సంఖ్య 1 అంటే, రెండవ షరతు ఏమిటంటే ఈ కరెంట్ ఈ ప్రవాహాలన్నింటికీ అదనంగా ఉంటుంది.
81. ఇప్పుడు, ఈ R f మరియు ఈ R f బార్ గుండా వెళుతుంది. దీని గరిష్ట విలువ కూడా తీసుకోవాలి; దీని అర్థం, R f దాని గరిష్ట విలువను తీసుకోవాలి. 
82. V A max (max) లెక్కించడం సులభం అని మేము కనుగొన్న తర్వాత.
83. కాబట్టి, ప్రస్తుతము I 0, I 1 అయినప్పుడు మోడ్ VA గరిష్టంగా (గరిష్టంగా) ఉంటుంది. వాటి గరిష్ట విలువలను R k 0 తో R k 0 కు సమానంగా భావించండి, ఇది నామమాత్రపు విలువ (నామమాత్ర) విలువ) 1 మైనస్ 0.01 0.99 .
84. కాబట్టి, ప్రతిఘటన ఈ ప్రతిఘటనలు ఈ ప్రవాహాలు ఎలా గరిష్టీకరించబడతాయో వాటి కనీస విలువలకు దారితీస్తాయి.
85. మరియు రెండవ R f గరిష్టంగా R f, ఇది నామమాత్ర విలువలో 1.01 కు సమానం.
86. కాబట్టి, ఈ సందర్భంలో మోడ్ (మోడ్) V A యొక్క గరిష్ట విలువ అప్పుడు V R సార్లు 255/128, ఇది మునుపటి కాలంలో కనుగొనబడిన ఈ నిష్పత్తి R యొక్క గరిష్ట విలువ (విలువ) R; దీని అర్థం, 1.01 ను 0.99 ద్వారా విభజించారు, ఎందుకంటే అవి నామమాత్రపు విలువను కలిగి ఉంటాయి, అవి అవి రద్దు చేయబడతాయి మరియు ఇది మాకు 10.162 వోల్ట్లను ఇస్తుంది.
87. మోడ్ VA యొక్క కనీస విలువ గురించి ఏమిటి? దీనికి విరుద్ధంగా, మేము ఈ సంఖ్యలను వీలైనంత చిన్నదిగా చేయాలనుకుంటున్నాము.
88. కాబట్టి, Rf ను దాని కనీస విలువకు తీసుకెళ్లాలి మరియు ఈ రెసిస్టర్‌లన్నీ వాటి గరిష్ట విలువలను తీసుకోవాలి.
89. కాబట్టి, ఇది 9.764 వోల్ట్ల దిగుబడిని 1.01 ద్వారా విభజించిన సింగిల్ ఫ్యాక్టర్ బార్ 0.99 ను ఇస్తుంది.
90. అందువల్ల, 1 1 1 1, 1 1 1 1 వంటి నిర్దిష్ట ఇన్పుట్ కలయిక కోసం మేము చివరి స్లైడ్‌లో కనుగొన్నట్లుగా, మా ప్రతిఘటనలు సరైనవి కానందున అవుట్పుట్ వోల్టేజ్ చాలా తేడా ఉంటుంది. అవి నాన్జెరో టాలరెన్స్. మరియు మునుపటి ఉదాహరణలో మేము కనుగొన్నాము మాగ్నిట్యూడ్‌లో గరిష్ట VA 10.162 మరియు కనిష్టం 9.764 మరియు రెండింటి మధ్య వ్యత్యాసం 0.4 వోల్ట్‌లు, ఇది చాలా ముఖ్యమైనది, ఎందుకంటే ఇది DAC యొక్క రిజల్యూషన్ కంటే చాలా పెద్దది, ఇది 39 వాస్ మిల్లివోల్ట్.
91. అందువల్ల, ఈ పరిస్థితి స్పష్టంగా ఆమోదయోగ్యం కాదు ఎందుకంటే ఇది తప్పులకు దారితీస్తుంది మరియు ఈ పరిస్థితిని సరిదిద్దడానికి మనం ఏమి చేయవచ్చు? మేము మరింత గట్టి సహనంతో రెసిస్టర్‌లను ఉపయోగించవచ్చు.
92. కాబట్టి, చిన్న సహనాలతో రిజిస్టర్లను ఉపయోగించడం ద్వారా అవుట్పుట్ వోల్టేజ్ వైవిధ్యాన్ని తగ్గించవచ్చు; ఏది ఏమయినప్పటికీ, నిర్మించడం చాలా కష్టం మరియు R 2, 128 సార్లు R I I తో మరియు ప్రతి ఒక్కటి తగినంత చిన్న సహనంతో విభిన్నమైన నిరోధక విలువలను కలిగి ఉంది.
93. కాబట్టి, సాంకేతిక సమస్య ఉంది మరియు అందువల్ల, ఈ మొత్తం డిజైన్‌ను మెరుగుపరచాల్సిన అవసరం ఉంది.
94. R 2 R నిచ్చెన నెట్‌వర్క్ అని పిలవబడే పరిష్కారం, ఈ నెట్‌వర్క్‌లో మనకు 2 నిరోధక విలువలు R మరియు 2 R. మాత్రమే ఉన్నాయి.
95. కాబట్టి, ఈ నెట్‌వర్క్‌లోని అన్ని రిజిస్టర్‌లు R లేదా 2 R గా ఉంటాయి మరియు అందువల్ల డెల్టా సమస్య అవుతుంది.
96. VA నిరోధక విలువలలో తేడాల ద్వారా సమర్థవంతంగా పరిష్కరించబడుతుంది.
97. సంక్షిప్తంగా, మేము డిజిటల్ అనలాగ్ కన్వర్టర్లను చూడటం ప్రారంభించాము, దీనిలో మేము బైనరీ వెయిటెడ్ రెసిస్టర్ విధానాన్ని ఉపయోగించి 8 బిట్‌లను ఉపయోగించాము.) DAC ఉదాహరణగా పరిగణించి వివిధ రకాల ఆసక్తిపై పనిచేశాము.
98. ప్రతిఘటన విలువలలో గణాంక వైవిధ్యం బిట్ల సంఖ్య పెద్దగా ఉన్నప్పుడు ఈ రకమైన D A C ను అనుచితంగా మారుస్తుందని మేము కనుగొన్నాము.
99. తరువాతి తరగతిలో ఈ కష్టాన్ని తగ్గించే R 2 R నిచ్చెన యొక్క విధానాన్ని పరిశీలిస్తాము.
100. తరువాత కలుద్దాం.
101.
 బాసిక్ ఎలెక్త్రొనిక్స్ కు స్వాగతము.
ఇప్పుడు మేము అనలాగ్ మరియు డిజిటల్ డొమైన్ మధ్య ఇంటర్ఫేస్ అనే క్రొత్త అంశంతో ప్రారంభిస్తాము, ఇది అనలాగ్ కన్వర్టర్ లేదా D A C తో డిజిటల్ యొక్క ప్రాథమిక కార్యాచరణను పరిశీలిస్తాము.
అప్పుడు మేము బైనరీ వెయిటెడ్ రిజిస్టర్లను ఉపయోగించి అమలు చేయబడిన D A C ని చూస్తాము మరియు వివిధ రకాల వడ్డీ కోసం పని చేస్తాము.
ఒక ఉదాహరణతో ప్రారంభిద్దాం.
ఇప్పుడు మేము అనలాగ్-టు-డిజిటల్ కన్వర్టర్ మరియు డిజిటల్-టు-అనలాగ్ కన్వర్టర్ గురించి చర్చిస్తాము మరియు అలాంటి కన్వర్టర్ వెనుక ఉన్న ప్రేరణతో మనం ఈ కన్వర్టర్ ఎందుకు మొదటి స్థానంలో అవసరమో ప్రారంభిద్దాం.
కాబట్టి, ఇక్కడ కొన్ని పాయింట్లు ఉన్నాయి, అసలు సిగ్నల్, థర్మోకపుల్‌తో కొలవబడిన వోల్టేజ్ లేదా కాలక్రమేణా మైక్రోఫోన్ లేదా అనలాగ్ వాల్యూమ్‌తో రికార్డ్ చేయబడిన స్పీచ్ సిగ్నల్. నిరంతరం మారుతూ ఉంటుంది.
మరోవైపు, మనం ఇంతకు మునుపు చూసినట్లుగా డిజిటల్ ఫార్మాట్‌లో డిజిటల్ సిగ్నల్ ప్రాసెసింగ్, స్టోరేజ్, కంప్యూటర్ వాడకం, స్ట్రాంగ్ ట్రాన్స్‌మిషన్ మొదలైన అనేక ప్రయోజనాలు ఉన్నాయి.
అందువల్ల, అనలాగ్ సిగ్నల్స్ అయిన ఈ నిజమైన సంకేతాలను డిజిటల్ ఆకృతికి మార్చడం అర్ధమే, ఆపై డిజిటల్ ఫార్మాట్ అందించే ఈ లక్షణాలన్నింటినీ సద్వినియోగం చేసుకోండి.
ఒక A D C అంటే అనలాగ్-టు-డిజిటల్ కన్వర్టర్‌కు అనుకూలంగా ఉండే A D C అనలాగ్ సిగ్నల్‌ను డిజిటల్ ఆకృతికి మార్చడానికి ఉపయోగించబడుతుంది.
డిజిటల్-టు-అనలాగ్‌కు రివర్స్ కన్వర్టర్ కూడా అవసరం, ఉదాహరణకు, ఒక డివిడిలో నిల్వ చేసిన సంగీతాన్ని స్పీకర్‌లో డిజిటల్ ఫార్మాట్‌లో ప్లే చేయాలి.) అనలాగ్ వోల్టేజ్‌గా మార్చాలి, అందువల్ల మేము ఆ సంగీతాన్ని వింటాము మరియు ఈ కన్వర్టర్ DAC చేత చేయబడుతుంది, డిజిటల్ సిగ్నల్‌ను అనలాగ్ ఆకృతిలోకి మార్చడానికి ఉపయోగించే స్టాండ్ (స్టాండ్) నుండి డిజిటల్ నుండి అనలాగ్ కన్వర్టర్ అయిన DAC.
డిజిటల్-టు-అనలాగ్ కన్వర్టర్ అయిన DAC యొక్క స్కీమాటిక్ పిక్చర్ ఇక్కడ ఉంది, ఇది డిజిటల్ ఇన్పుట్, ఇది అనలాగ్ అవుట్పుట్, అప్పుడు మనకు భూమికి చిప్ ఉంటుంది మరియు రిఫరెన్స్ వోల్టేజ్.
D, N మైనస్ 1 వరకు N బిట్స్ D 0, D 1, D 2 వరకు డిజిటల్ ఇన్పుట్.
ఇప్పుడు D A C ఈ బైనరీ సంఖ్య మరియు ఈ రిఫరెన్స్ వోల్టేజ్ విలువలను బట్టి అనలాగ్ వోల్టేజ్ అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుంది.
4 బిట్ D A C కి ఇక్కడ ఒక ఉదాహరణ; అంటే, N ఇక్కడ ఇన్పుట్ S 3, S 2, S 1, S 0 తో ఉంటుంది, ఇది D 3, D 2, D 1, D 0 కు అనుగుణంగా ఉంటుంది.
VA కి సమానమైన అవుట్పుట్ వోల్టేజ్ స్థిరమైన k k సార్లు S 3, ఇది 1 లేదా 0 కావచ్చు, 23+ S 2 (2 ప్లస్ 3 ప్లస్ S 2 కు గుణించాలి), ఇది మళ్ళీ 1 లేదా 0 రెట్లు పెరుగుతుంది 22+ S 1 (2 2 కి పెంచండి ప్లస్ ఎస్ 1) సార్లు 21+ ఎస్ 0 (2 పెంచడం 1 ప్లస్ ఎస్ 0) సార్లు 20 (2 కి 0 కి పెంచండి), మరియు సాధారణంగా మనం ఈ సమీకరణాన్ని VA కి సమానంగా వ్రాయవచ్చు K యొక్క మొత్తం 0 నుండి N మైనస్ 1 S k 2K ద్వారా (2 కి K కి పెంచండి).
అందువల్ల, ఇక్కడ గమనించవలసిన ముఖ్యమైన విషయం ఏమిటంటే, ప్రతి బిట్ వేరే బరువు (బరువు) పొందుతుంది, అధిక బిట్స్ ఎక్కువ బరువును పొందుతాయి మరియు తక్కువ బిట్స్ తక్కువ బరువును పొందుతాయి. మరియు ఈ స్కేలింగ్ కారకం (కారకం K) ఇక్కడ రిఫరెన్స్ వోల్టేజ్ VR కు అనులోమానుపాతంలో ఉంటుంది. , దాని విలువ DAC ఎలా వర్తించబడుతుందో దానిపై ఆధారపడి ఉంటుంది.+
ఇప్పుడు, V A అవుట్పుట్ వోల్టేజ్‌ను డిజిటల్ ఇన్పుట్ యొక్క ఫంక్షన్‌గా ఎలా మారుస్తుందో చూద్దాం, ఇది మేము D A C లేదా రేఖాచిత్రానికి వర్తింపజేస్తాము మరియు N 4 ఉన్న చోట అదే ఉదాహరణను తీసుకుంటాము.
కాబట్టి, ఇది 4 బిట్ (ఎ) డి ఎ సి.
కాబట్టి, ఇక్కడ మా డిజిటల్ ఇన్పుట్ ఉంది, మొదటి సంఖ్య 0 0 0 0 తరువాత 0 0 0 1, 0 0 1 0 మొదలైనవి 1 1 1 1 వరకు ఉంటాయి. కాబట్టి, ఈ దశాంశం 0, ఈ దశాంశం 1, 2 3, 4 మొదలైనవి 15 వరకు ఉంటుంది, మరియు ఈ అనువర్తిత ఇన్పుట్ ఫలితంగా అవుట్పుట్ V A 0 నుండి కొన్ని గరిష్ట అవుట్పుట్ వోల్టేజ్ వరకు మారుతుంది.
మరియు మనకు వివిక్త పాయింట్లు మాత్రమే ఉన్న సరళ రేఖ లేదా వక్రరేఖ లేదని ప్రత్యేకంగా గమనించండి మరియు మా ఇన్పుట్ వివిక్తమైనది మరియు ఈ 16 విలువలు మాత్రమే మరియు ఉదాహరణకు 2 విలువలు (విలువలు), ఉంది ఈ సంఖ్య మరియు ఆ సంఖ్య మధ్య డిజిటల్ ఇన్పుట్ లేదు.
కాబట్టి, మేము ఇక్కడ పాయింట్లను పరిశీలిస్తాము మరియు పంక్తులు లేదా వక్రతలు అన్నీ సరైనవి కావు.
ఇప్పుడు 2 వరుస అవుట్పుట్ విలువల మధ్య ఈ వ్యత్యాసాన్ని రిజల్యూషన్ సమయం అంటారు.ఇప్పుడు మనం DAC యొక్క బిట్ల సంఖ్య మరియు గరిష్ట అవుట్పుట్ వోల్టేజ్ యొక్క తీర్మానాన్ని సులభంగా తెలుసుకోవచ్చు. ఎందుకంటే ఈ సందర్భంలో 2N-1 ఉన్నాయని మనకు తెలుసు (2 N-1 కి పెంచండి). ఇక్కడ, ఉదాహరణకు, మనకు 2N-1 (2 N-1 కు పెంచండి) ఉంది, ఇది చాలా తక్కువ మరియు అత్యధిక విలువల మధ్య 16 మైనస్ 1 లేదా 15 విభాగాలు ఉన్నాయి.
కాబట్టి, ఈ సందర్భంలో గరిష్ట అవుట్పుట్ వోల్టేజ్ 15 ద్వారా విభజించబడినట్లు మేము రిజల్యూషన్ను లెక్కించవచ్చు.
ఇప్పుడు మనము D A C అమలు గురించి మాట్లాడుదాం మరియు బైనరీ వెయిటెడ్ రిజిస్టర్లను ఉపయోగించడం మా మొదటి విధానం, ఈ పదం యొక్క అర్థం ఏమిటి? 1 ప్రతిఘటన అయితే, తరువాతి 2 సార్లు, అంటే 2 R తదుపరి 2 సార్లు 2 R అంటే 4 R మరియు తరువాత 8 R మొదలైనవి.
ఇప్పుడు ఈ నిర్దిష్ట ఉదాహరణ 4 బిట్ (బిట్) D A C ఇన్పుట్ S 3, S 2, S 1, S 0, కాబట్టి S 3 0 లేదా 1 కావచ్చు, S2 0 లేదా 1 కావచ్చు.
అవుట్పుట్ VA ఇక్కడ ఈ op-amp యొక్క అవుట్పుట్, మనకు 4 స్విచ్లు ఉన్నాయి, ఇవి ఇన్పుట్ బిట్స్ S 3, S 2, S 1 ద్వారా నియంత్రించబడతాయి.
ఉదాహరణకు, ఈ స్విచ్ S 3 చే నియంత్రించబడుతుంది, S 3 0 అయితే, ఈ నోడ్ A 3 అలాంటి భూమికి అనుసంధానిస్తుంది మరియు S 3 గ్రౌండ్ అయితే A 3 అంటే రిఫరెన్స్ వోల్టేజ్ VR కి అనుసంధానించబడి ఉంటుంది.
మరో మాటలో చెప్పాలంటే, ఈ నోడ్ వద్ద వోల్టేజ్ S 3 రెట్లు ఉంటే, S 3 0 అయితే, ఆ వోల్టేజ్ 0 మరియు S 3 1 అయితే, ఆ వోల్టేజ్ VR మరియు ఈ స్విచ్ తో మనం ఇక్కడ చూపించాము S 2 నియంత్రించబడుతుంది మరియు అందువల్ల, ఈ వోల్టేజ్ S 2 రెట్లు VR.
ఇది S 1 చే నియంత్రించబడుతుంది.
కాబట్టి, ఇది S 1 సార్లు V R మరియు ఇది S 0 సార్లు V R.
కాబట్టి, ఇది మా సరళీకృత సర్క్యూట్ మరియు ఇది మా op-amp వేసవి (వేసవి) అని మేము చూశాము మరియు ఇప్పుడు ఇది ఎలా పనిచేస్తుందో చూద్దాం.
V మైనస్ మరియు V ప్లస్ సమానమైనవి కాబట్టి, మనకు V మైనస్ 0 కి సమానం మరియు అందువల్ల, ఈ కరెంట్‌ను లెక్కించవచ్చు మరియు ఈ కరెంట్ నేను 0 ప్లస్ I 1 ప్లస్ I 2 ప్లస్ I 3 తప్ప మరొకటి కాదు.
I0 ఇది S 0 V R మైనస్ 0 8R చే విభజించబడింది.
I1 ఇది S 1 V R మైనస్ 0 ను 4 R చే విభజించబడింది.
కాబట్టి, ఇది మాకు ఈ వ్యక్తీకరణను ఇస్తుంది.
కాబట్టి ప్రస్తుతము I, S 0 VR / 8 R ప్లస్ S 1 VR / 4 R మొదలైనవి. మరియు ఇప్పుడు మనం చేయగలిగేది ఈ సాధారణ (సాధారణ) VR / 8 R ను తీసుకొని, ఆపై ఈ వ్యక్తీకరణను ఇక్కడ పొందండి. ఇప్పుడు మనం జనరల్ రాశాము దీని కోసం వ్యక్తీకరణ.
మా విషయంలో N బిట్స్ 4 కి సమానం.
కాబట్టి, మా విషయంలో ఈ 2N-1 (2 N-1 కి పెంచడం) 23 (2 కి 3 కి పెంచండి) ఇది 8 కి సమానం.
కాబట్టి, ఇది మనకు లభిస్తుంది మరియు ప్రతి బిట్ వేరే బరువును పొందుతుంది. ఉదాహరణకు, LSB 0 యొక్క బరువు (బరువు) 20 లేదా 1 మరియు మా విషయంలో నాకు MSB 3 ఉంది, ఇది 23 లేదా 8 బరువు కలిగి ఉంటుంది మరియు ఇదే మేము DAC (DAC) నుండి ఆశించాము.
చివరగా, అవుట్పుట్ వోల్టేజ్ VA ను మేము కనుగొన్నాము, ఇక్కడ మేము ఆప్ ఆంప్ సర్క్యూట్ గురించి మాట్లాడినప్పుడు ఇంతకుముందు చేసాము - ఈ V మైనస్ 0 వోల్ట్లు మరియు కరెంట్ op amp లోకి వెళ్ళదు. అందువల్ల, ఈ ప్రస్తుత కరెంట్ R f మరియు అందువల్ల, VA ఇది మా అవుట్పుట్ వోల్టేజ్ V o 0 మైనస్ I సార్లు R f మరియు ఇక్కడ మనకు ఉన్నది మైనస్ R f సార్లు I మరియు నేను ఈ వ్యక్తీకరణ నుండి వచ్చింది మరియు అందువల్ల ఇది అవుట్పుట్ వోల్టేజ్ కోసం మనం పొందుతాము.
ఒక నిర్దిష్ట ఉదాహరణ తీసుకుందాం, 5 R వోల్ట్లకు సమానమైన V R తో 8-బిట్ (బిట్) D A C ను పరిగణించండి, R యొక్క అతిచిన్న విలువ ఏమిటి? సరఫరా నుండి డ్రా అయిన కరెంట్‌ను 10 మిల్లియాంప్‌కు పరిమితం చేసే నిరోధకత మా సరఫరా VR మరియు ఇది ఈ ప్రవాహాలన్నింటినీ సరఫరా చేస్తుంది మరియు మేము సరఫరా నుండి లాగే మొత్తం కరెంట్, ఇది 10 మిల్లియాంప్‌లకు పరిమితం చేయాలి.
ఇప్పుడు ఇది 8 బిట్ (DAC) కాబట్టి, మన నిరోధక విలువలు (విలువ) R, 2 R, 4 R మొదలైన వాటి నుండి వెళ్లి, ఆపై 26 (2 కి 6 కి పెంచండి) R కి పెరుగుతాయి మరియు తుది విలువ 27 (2 పెంచండి to 7) R.
లేకపోతే సర్క్యూట్ మనం ఇంతకు ముందు చూసినట్లే.
ఇప్పుడు సర్క్యూట్లో ఉన్న మొత్తం అంచు. ఈ స్విచ్ LSB చే S 0 గా నియంత్రించబడుతుంది. ఈ స్విచ్ S 1 చే నియంత్రించబడుతుంది మరియు చివరకు, ఈ స్విచ్) S 7 చే నియంత్రించబడుతుంది, ఇది MSB.
ఇప్పుడు మనం ఈ ప్రవాహాలను I 0, I 1 మొదలైనవి I 7 వరకు తీసుకుంటాము.
ఇప్పుడు ఈ నోడ్ వర్చువల్ గ్రౌండ్ V మైనస్ మరియు V ప్లస్ లతో సమానంగా ఉంటుంది.
అందువల్ల, మనకు 0 వోల్ట్లు ఉన్నాయి. ఇక్కడ ఈ కరెంట్ I 0 ఈ నోడ్‌లోని సంభావ్యత ద్వారా R 0 తో విభజించబడింది. A 0 మైనస్ 0 ఇది 27 (2 కి 7 కి పెంచండి) R మరియు ఈ విధంగా మేము ఈ ఇతర ప్రవాహాలను పొందుతాము. (ప్రవాహాలు ) పొందవచ్చు.
S 0 0 అయినప్పుడు, స్విచ్ ఈ స్థితిలో ఉంటుంది. నోడ్ A0 మైదానంలో ఉంది మరియు అందువల్ల, నేను 0 మరొక వైపు 0 గా ఉంటాను. S 0 1 అయితే, స్విచ్ ఆ స్థితిలో ఉంటుంది., ఇక్కడ సంభావ్యత ఉన్నప్పుడు VR మరియు తరువాత మనకు VR కరెంట్ R 0 తో విభజించబడింది.
మరో మాటలో చెప్పాలంటే, ఈ రిజిస్టర్ S 0 1 అయితే విద్యుత్ సరఫరా నుండి మాత్రమే విద్యుత్తును గీస్తుంది, అదేవిధంగా ఈ రెసిస్టర్ S 1 1 మరియు విద్యుత్ సరఫరాకు గరిష్ట కరెంట్ ఉంటే విద్యుత్ సరఫరా నుండి విద్యుత్తును తీసుకుంటుంది) సరఫరా చేయడానికి, మేము స్పష్టంగా S 0 కి సమానమైన 1 అవసరం, 1 S 1 కు సమానం, మొదలైనవి S 7 కు సమానమైన 1 వరకు అవసరం.
ఈ విధంగా, మేము ఇక్కడ వ్రాసాము.
గరిష్ట ఇన్పుట్ 1 1 1 1 1, 1 1 1 1 అయినప్పుడు, ఇన్పుట్ 1 1 1 1, 1 1 1 1 అయినప్పుడు VR నుండి గరిష్ట ప్రస్తుత ప్రవాహం VR నుండి తీసుకోబడుతుంది. అన్ని లోడ్ (లోడ్) A 0 నుండి A 7 ఇది VR కి అనుసంధానించబడి ఉంది.
కాబట్టి గరిష్ట కరెంట్ 10 మిల్లియాంప్స్‌కు పరిమితం చేయబడింది, కాబట్టి మేము 10 మిల్లియాంప్స్‌కు సమానం.
ఈ రెసిస్టెన్స్ ప్లస్ V R / 2R ద్వారా వచ్చే కరెంట్ తదుపరి నిరోధకత ద్వారా కరెంట్.
VR / 27 (2 పెంచడం 7) R వరకు అన్ని మార్గం సరైనది మరియు మేము VR / 27 (2 కి 7 కి పెంచండి) R సాధారణం (సాధారణం) మరియు 20 (2 ను 0 కి పెంచండి) మరియు 21 (2 పెంచడం 1 ) ప్లస్ 22 (2 కి 2 పెంచండి) మొదలైనవి 27 వరకు పొందవచ్చు (2 7 కి పెంచండి) మరియు ఇది బ్రాకెట్ 28-1 (2 రైజ్ 8 మైనస్ 1) గా మారుతుంది, ఇది 256 మైనస్ 1, 27 (2 రైజ్ to 7) కాబట్టి 128, కాబట్టి మేము R ద్వారా 255 రెట్లు VR తో ముగుస్తాము మరియు అది 10 మిల్లియాంప్స్ మించకూడదు మరియు అది మాకు R యొక్క కనీస విలువను ఇస్తుంది.
అంటే, VR ను 5 మిల్లియాంప్ నుండి 10 మిల్లియాంప్ నుండి 255/128 తో విభజించి 1 కిలో ఓం (కిలో ఓం) గా తేలింది.
ఇప్పుడు, ఈ ఉదాహరణ గోపాలన్ రాసిన ఈ పుస్తకం నుండి తీసుకోబడింది మరియు D A C మరియు A D C గురించి మరెన్నో ఆసక్తికరమైన వివరాలు ఉన్నాయి మరియు చూడటానికి మంచి పుస్తకం.
తదుపరి ప్రశ్న, R f కు సమానం అయితే, డెల్టా VA లో VA ఇక్కడ మారే తీర్మానం ఏమిటి.
ఇన్‌పుట్‌కు అనుగుణమైన ఎల్‌ఎస్‌బి అన్ని ఇతర ఇన్‌పుట్ బిట్‌లతో 0 నుండి 1 వరకు మారుతుంది.
I.
కాబట్టి, ఇది VA కోసం మా వ్యక్తీకరణ మరియు ఇది బ్రాకెట్ యొక్క ఇన్పుట్ బైనరీ సంఖ్యతో సరిపోతుంది, ఈ బ్రాకెట్ యొక్క కనీస విలువ ఏమిటి? S 0 0, S 1 0 అయినప్పుడు ఇది జరుగుతుంది.
S 7 అన్ని మార్గం 0 కి సమానం.
కాబట్టి, అత్యల్ప విలువ 0, ఇది అత్యధికం? S 0 1, S 1 1, మొదలైనవి ఉన్నప్పుడు S7 కు సమానమైన అత్యధిక విలువ.
మరియు అది అత్యధిక విలువ 255 లేదా 28-1 (2 8 మైనస్ 1 కి పెంచండి).
మరియు మేము రిజల్యూషన్ గురించి మాట్లాడేటప్పుడు, ఈ బ్రాకెట్‌ను 1 కి మార్చడానికి మేము అనుమతిస్తున్నాము మరియు ఈ ఇన్పుట్ LSB వలె అదే డెల్టా (డెల్టా) VA అని చెప్తున్నాము, ఇక్కడ S 0 ఇతర ఇన్పుట్ బిట్లతో 0 నుండి 1 కి మారుతోంది.
ఇప్పుడు మీరు రిజల్యూషన్‌ను లెక్కించవచ్చు.
అందువల్ల, VA డెల్టా రిజల్యూషన్, దీనిని బ్రాకెట్ 1 తో భర్తీ చేసినప్పుడు, ఇక్కడ పునరుత్పత్తి చేయబడిన ఈ కారకం ద్వారా ఇవ్వబడుతుంది మరియు ఇది 5 వోల్ట్‌లు, ఇది VR (2 8 మైనస్ 1 కి పెంచండి) ఈ సంఖ్య ఇక్కడ చాలాసార్లు Rf / R మరియు, Rf మరియు R సమానంగా ఉంటాయి, కాబట్టి ఇది 0.0391 వోల్ట్లు లేదా 39.1 మిల్లీవోల్ట్లుగా మారుతుంది.
తరువాతి ప్రశ్న ఏమిటంటే మాగ్నిట్యూడ్‌లో గరిష్ట అవుట్పుట్ వోల్టేజ్ ఏమిటి, ఇది మా VA మరియు ఇది ప్రతికూలంగా ఉందని గమనించండి మరియు అందుకే మేము మాగ్నిట్యూడ్‌ను ఇక్కడ బ్రాకెట్లలో ఉంచాము మరియు మాగ్నిట్యూడ్ గరిష్టంగా ఉన్నప్పుడు? బ్రాకెట్ గరిష్టంగా మారినప్పుడు ఇది జరుగుతుంది. దీని అర్థం ఈ బిట్స్ అన్నీ 1 కి సమానం.
అందువల్ల, ఇన్పుట్ బైనరీ సంఖ్య 1 1 1 1, 1 1 1 1 1 అయినప్పుడు గరిష్ట V A పరిమాణంలో లభిస్తుంది.
కాబట్టి, మనం చేయవలసింది ఇప్పుడు ఈ S లన్నింటినీ 1 తో భర్తీ చేసి, ఈ బ్రాకెట్‌ను అంచనా వేయండి మరియు అది మనకు లభిస్తుంది - VR అంటే 5 వోల్ట్‌లు 2 నుండి మైనస్ 1 వరకు పెరుగుతాయి, ఇది 128 Rf మరియు R కి సమానం.
కాబట్టి, ఇది ఒకటి మరియు ఈ బ్రాకెట్ అప్పుడు 20 (2 కి 0 కి పెంచండి) ప్లస్ 21 (2 కి 1 కి పెంచండి) 27 నుండి (2 కి 7 కి పెంచండి) పైకి, మరియు మనం అంచనా వేసినప్పుడు మనకు 9.961 వోల్ట్లు లభిస్తాయి.
1 0 1 0 0 1 1 0 0 1 కు అనుగుణమైన అవుట్పుట్ వోల్టేజ్ను కనుగొనడం తదుపరి ఇన్పుట్ బైనరీ సంఖ్య చాలా సులభం, మనకు ఇక్కడ VA ఉంది, మనం చేయాల్సిందల్లా 1 S 7 కు సమానం, 0 S 6 కు సమానం, 1 S 5 కు సమానం, 0 S 4 కు సమానం.
మరియు మేము దానిని ఎలా పొందుతాము.
కాబట్టి, V A మైనస్ 6.758 వోల్ట్లు అవుతుంది.
తదుపరి ప్రశ్న, రెసిస్టర్లు 1 శాతం సహనం కలిగి ఉన్నట్లు పేర్కొనబడితే, ఇన్పుట్ 1 కి అనుగుణంగా మోడ్ (మోడ్) VA యొక్క పరిధి ఏమిటి.
1 1 1 1, 1 1 1 1. ఇప్పుడు మొదట 1 శాతం సహనం ఏమిటో మనకు ఇవ్వండి, ఉదాహరణకు ఈ ప్రతిఘటనను తీసుకుంటుంది, ఇది 1 నామమాత్రపు నామమాత్రపు విలువ అని మాకు చెప్పండి. ఇది k అయితే, దీని అర్థం వాస్తవ విలువ 0.99 సార్లు 1 k నుండి 1.01 సార్లు 1 k మధ్య ఏదైనా కావచ్చు.
ఈ ప్రతిఘటన గురించి ఏమిటి? R మరియు R f ఒకటేనని మేము అనుకుంటాము, కాబట్టి R 7 యొక్క నామమాత్ర విలువ కూడా 1 k మరియు అందువల్ల, అసలు విలువ 0.99 k నుండి 1.01 k వరకు మారుతుంది.
ఈ ప్రతిఘటన గురించి ఏమిటి? నామమాత్రపు విలువ 26 రెట్లు R; అంటే, 64 సార్లు 1 k లేదా 64 k మరియు దాని వాస్తవ విలువ 64 k సార్లు 0.99 నుండి 64 k సార్లు 1.01 వరకు మారవచ్చు.
ఇప్పుడు మేము మా అసలు ప్రశ్నకు తిరిగి వస్తాము మరియు ఈ ఇన్పుట్తో మా స్విచ్లు అన్నీ పై స్థానంలో ఉన్నాయి; దీని అర్థం, A 7 V R కి అనుసంధానించబడి ఉంది, A 1 V R కి అనుసంధానించబడి ఉంది మరియు ఈ ప్రవాహాలన్నీ ఇప్పుడు సున్నా కానివి.
ఈ పరిమాణాలలో VA గరిష్టంగా ఉండటానికి, ఈ ప్రవాహాలన్నీ వాటి గరిష్ట విలువలకు తీసుకెళ్లాలి మరియు ఈ ప్రతిఘటనలను వాటి కనీస విలువలకు తీసుకువెళ్ళినప్పుడు ఇది జరుగుతుంది, ఇది షరతు సంఖ్య 1 అంటే, రెండవ షరతు ఏమిటంటే ఈ కరెంట్ ఈ ప్రవాహాలన్నింటికీ అదనంగా ఉంటుంది.
ఇప్పుడు, ఈ R f మరియు ఈ R f బార్ గుండా వెళుతుంది. దీని గరిష్ట విలువ కూడా తీసుకోవాలి; దీని అర్థం, R f దాని గరిష్ట విలువను తీసుకోవాలి. 
V A max (max) లెక్కించడం సులభం అని మేము కనుగొన్న తర్వాత.
కాబట్టి, ప్రస్తుతము I 0, I 1 అయినప్పుడు మోడ్ VA గరిష్టంగా (గరిష్టంగా) ఉంటుంది. వాటి గరిష్ట విలువలను R k 0 తో R k 0 కు సమానంగా భావించండి, ఇది నామమాత్రపు విలువ (నామమాత్ర) విలువ) 1 మైనస్ 0.01 0.99 .
కాబట్టి, ప్రతిఘటన ఈ ప్రతిఘటనలు ఈ ప్రవాహాలు ఎలా గరిష్టీకరించబడతాయో వాటి కనీస విలువలకు దారితీస్తాయి.
మరియు రెండవ R f గరిష్టంగా R f, ఇది నామమాత్ర విలువలో 1.01 కు సమానం.
కాబట్టి, ఈ సందర్భంలో మోడ్ (మోడ్) V A యొక్క గరిష్ట విలువ అప్పుడు V R సార్లు 255/128, ఇది మునుపటి కాలంలో కనుగొనబడిన ఈ నిష్పత్తి R యొక్క గరిష్ట విలువ (విలువ) R; దీని అర్థం, 1.01 ను 0.99 ద్వారా విభజించారు, ఎందుకంటే అవి నామమాత్రపు విలువను కలిగి ఉంటాయి, అవి అవి రద్దు చేయబడతాయి మరియు ఇది మాకు 10.162 వోల్ట్లను ఇస్తుంది.
మోడ్ VA యొక్క కనీస విలువ గురించి ఏమిటి? దీనికి విరుద్ధంగా, మేము ఈ సంఖ్యలను వీలైనంత చిన్నదిగా చేయాలనుకుంటున్నాము.
కాబట్టి, Rf ను దాని కనీస విలువకు తీసుకెళ్లాలి మరియు ఈ రెసిస్టర్‌లన్నీ వాటి గరిష్ట విలువలను తీసుకోవాలి.
కాబట్టి, ఇది 9.764 వోల్ట్ల దిగుబడిని 1.01 ద్వారా విభజించిన సింగిల్ ఫ్యాక్టర్ బార్ 0.99 ను ఇస్తుంది.
అందువల్ల, 1 1 1 1, 1 1 1 1 వంటి నిర్దిష్ట ఇన్పుట్ కలయిక కోసం మేము చివరి స్లైడ్‌లో కనుగొన్నట్లుగా, మా ప్రతిఘటనలు సరైనవి కానందున అవుట్పుట్ వోల్టేజ్ చాలా తేడా ఉంటుంది. అవి నాన్జెరో టాలరెన్స్. మరియు మునుపటి ఉదాహరణలో మేము కనుగొన్నాము మాగ్నిట్యూడ్‌లో గరిష్ట VA 10.162 మరియు కనిష్టం 9.764 మరియు రెండింటి మధ్య వ్యత్యాసం 0.4 వోల్ట్‌లు, ఇది చాలా ముఖ్యమైనది, ఎందుకంటే ఇది DAC యొక్క రిజల్యూషన్ కంటే చాలా పెద్దది, ఇది 39 వాస్ మిల్లివోల్ట్.
అందువల్ల, ఈ పరిస్థితి స్పష్టంగా ఆమోదయోగ్యం కాదు ఎందుకంటే ఇది తప్పులకు దారితీస్తుంది మరియు ఈ పరిస్థితిని సరిదిద్దడానికి మనం ఏమి చేయవచ్చు? మేము మరింత గట్టి సహనంతో రెసిస్టర్‌లను ఉపయోగించవచ్చు.
కాబట్టి, చిన్న సహనాలతో రిజిస్టర్లను ఉపయోగించడం ద్వారా అవుట్పుట్ వోల్టేజ్ వైవిధ్యాన్ని తగ్గించవచ్చు; ఏది ఏమయినప్పటికీ, నిర్మించడం చాలా కష్టం మరియు R 2, 128 సార్లు R I I తో మరియు ప్రతి ఒక్కటి తగినంత చిన్న సహనంతో విభిన్నమైన నిరోధక విలువలను కలిగి ఉంది.
కాబట్టి, సాంకేతిక సమస్య ఉంది మరియు అందువల్ల, ఈ మొత్తం డిజైన్‌ను మెరుగుపరచాల్సిన అవసరం ఉంది.
R 2 R నిచ్చెన నెట్‌వర్క్ అని పిలవబడే పరిష్కారం, ఈ నెట్‌వర్క్‌లో మనకు 2 నిరోధక విలువలు R మరియు 2 R. మాత్రమే ఉన్నాయి.
కాబట్టి, ఈ నెట్‌వర్క్‌లోని అన్ని రిజిస్టర్‌లు R లేదా 2 R గా ఉంటాయి మరియు అందువల్ల డెల్టా సమస్య అవుతుంది.
VA నిరోధక విలువలలో తేడాల ద్వారా సమర్థవంతంగా పరిష్కరించబడుతుంది.
సంక్షిప్తంగా, మేము డిజిటల్ అనలాగ్ కన్వర్టర్లను చూడటం ప్రారంభించాము, దీనిలో మేము బైనరీ వెయిటెడ్ రెసిస్టర్ విధానాన్ని ఉపయోగించి 8 బిట్‌లను ఉపయోగించాము.) DAC ఉదాహరణగా పరిగణించి వివిధ రకాల ఆసక్తిపై పనిచేశాము.
ప్రతిఘటన విలువలలో గణాంక వైవిధ్యం బిట్ల సంఖ్య పెద్దగా ఉన్నప్పుడు ఈ రకమైన D A C ను అనుచితంగా మారుస్తుందని మేము కనుగొన్నాము.
తరువాతి తరగతిలో ఈ కష్టాన్ని తగ్గించే R 2 R నిచ్చెన యొక్క విధానాన్ని పరిశీలిస్తాము.
తరువాత కలుద్దాం.
inhouse/NPTEL/PreFinal/c++/Telugu/39 basicElectonics_PHASORS-2-akTxr5PpiaE.txt
View file @ 956c0d4e
 1. బాసిక్ ఎలెక్త్రొనిక్స్ కు స్వాగతము.
2. గత ఉపాన్యాసము లొ మనుము ఫాసర్లు phasors పరిచయం చేశాము మరియు వాటిని సైనోఇయిడాల్ స్థిరమైన స్థితిలో ఎలా అర్థం చేసుకోవచ్చో చూడవచ్చు.
3. ఈ ఉపన్యాసంలో స్థిరమైన స్థితి ప్రవాహాలు మరియు వోల్టేజ్‌లను అర్థం చేసుకోవడానికి మేము RLC సర్క్యూట్‌లకు ఫేజర్‌లను వర్తింపజేయాలనుకుంటున్నాము.
4. అదనంగా, సైనూసోయిడల్ స్థిరమైన స్థితిలో RLC సర్క్యూట్ల కోసం గరిష్ట విద్యుత్ బదిలీ సిద్ధాంతాన్ని చూస్తాము.
5. కాబట్టి, ప్రారంభిద్దాం.
6. సర్క్యూట్ విశ్లేషణలో ఫాజర్‌ను ఎలా ఉపయోగించవచ్చో చూద్దాం; టైమ్ డొమైన్ KCL మరియు KVL సమీకరణాలు సిగ్మా IK సమాన 0 మరియు సిగ్మా V సమాన 0 ను ఫాజర్ సమీకరణాలుగా వ్రాయవచ్చు, సిగ్మా IK 0 కి సమానం, ఇక్కడ IK ప్రస్తుత దశ మరియు సిగ్మా VK 0 కి సమానం, ఇక్కడ V యొక్క ఫ్రీక్వెన్సీ డొమైన్‌లో వోల్టేజ్ ఫాజర్‌లు ఉన్నాయి .
7. రెసిస్టర్లు, కెపాసిటర్లు మరియు ప్రేరకాలను ఫ్రీక్వెన్సీ డొమైన్‌లో J ద్వారా Z సార్లు I కు సమానంగా వర్ణించవచ్చు, ఇది DC పరిస్థితులలో R కి సమానం.
8. ఒకే తేడా ఏమిటంటే, ఈ సమీకరణం గురించి మాట్లాడేటప్పుడు మనం సంక్లిష్ట సంఖ్యలతో వ్యవహరిస్తున్నాము.
9. ఫ్రీక్వెన్సీ డొమైన్‌లో ఒక స్వతంత్ర సైనూసోయిడల్ మూలం, ఉదాహరణకు, DC మూలం వలె ప్రవర్తిస్తుంది, వోల్టేజ్ మూలం కోసం సైనూసోయిడల్ వోల్టేజ్ మూలం, మేము ఫేజర్ Vs స్థిరంగా ఉందని చెప్పవచ్చు, ఇది సంక్లిష్టమైనది. సంఖ్య.
10. ఆధారిత మూలాల కోసం, t (I) తో సమానమైన టైమ్ డొమైన్ సంబంధం t ను C యొక్క ఫాజర్ సంబంధంలోకి అనువదిస్తుంది, ఫాజర్ (I) ఫ్రీక్వెన్సీ డొమైన్ బీటా టైమ్స్ ఫేజర్‌ను కలిగి ఉంటుంది. (ఫాజర్) I c కి సమానం.
11. అందువల్ల, మనకు ఇక్కడ సంక్లిష్ట సంఖ్యలు ఉన్నాయి తప్ప సమీకరణం చాలా పోలి ఉంటుంది.
12. అందువల్ల, ఈ అన్ని పరిశీలనల నుండి, ఫాసోర్‌లను ఉపయోగించి సైనూసోయిడల్ స్థిరమైన స్థితిలో సర్క్యూట్ విశ్లేషణ స్వతంత్ర మరియు ఆధారిత వనరులు మరియు రెసిస్టర్‌లతో DC సర్క్యూట్‌ల మాదిరిగానే ఉంటుందని మేము నిర్ధారించాము; అందువల్ల, DC సర్క్యూట్ల కోసం మేము పొందిన అన్ని ఫలితాలు సైనూసోయిడల్ స్థిరమైన స్థితి విశ్లేషణకు చెల్లుతాయి, అందువల్ల రెసిస్టర్లు, నోడల్ విశ్లేషణ, మెష్ విశ్లేషణ, థెవెనిన్ మరియు థెవెనిన్ సిద్ధాంతం కోసం సిరీస్ సమాంతర సూత్రాలు. సైనూసోయిడల్ స్థిరమైన స్థితిలో ఒక సర్క్యూట్‌కు నేరుగా వర్తించవచ్చు ; కోర్సు యొక్క పూర్తిగా వేరు, మేము ఇప్పుడు సంక్లిష్ట సంఖ్యలతో వ్యవహరిస్తున్నాము.
13. ఇప్పుడు మనం సైనూసోయిడల్ స్థిరమైన స్థితిలో RL సర్క్యూట్లను పరిశీలిద్దాం; సిరీస్లో R మరియు L ఇక్కడ రెసిస్టర్ R, మనం ఇంతకుముందు చూసినట్లుగా మరియు ప్రేరక యొక్క ఇంపెడెన్స్ j ఒమేగా (ఒమేగా) L.
14. ఇది మా సైనూసోయిడల్ సోర్స్ వోల్టేజ్ V m యాంగిల్ 0, ఇది సమయం V m cos (Cos) ఒమేగా (t) డొమైన్ మరియు ఈ కరెంట్ పట్ల మాకు ఆసక్తి ఉంది.
15. మేము ఫేజర్‌ను ఉపయోగించినప్పుడు, మనం చూసే విధంగా ఇది చాలా సులభమైన గణన అవుతుంది; మనకు DC సోర్స్ DC మూలం ఉందని imagine హించుకుందాం, ఇక్కడ Vs, ఒక రెసిస్టర్ R1 మరియు ఇక్కడ ఒక రెసిస్టర్ R 2, ఆ సందర్భంలో ప్రస్తుతంలో ఏమి జరుగుతుంది? DC కరెంట్ (లు) ఇది V లు R 1 ప్లస్ R 2 తో విభజించబడింది; కాబట్టి మనం V లకు బదులుగా సరిగ్గా అదే సమీకరణాన్ని ఉపయోగించవచ్చు, మనకు ఇప్పుడు V m కోణం 0 అనే ఫాజర్ మూలం ఉంది మరియు R 1 మరియు R 2 కు బదులుగా వాటికి R మరియు j ఒమేగా L ఉన్నాయి, నిరోధకం మరియు ప్రేరక పరిమితులు ఉన్నాయి.
16. కాబట్టి, మనం I (I) ను V m కోణం 0 గా వ్రాయవచ్చు, ఈ మూలాన్ని R ప్లస్ j ఒమేగా (ఒమేగా) L ద్వారా విభజించారు.
17. నేను ఈ ఫాజర్‌ను ప్రస్తుతములో వ్రాయగలను ఎందుకంటే నేను (I) కోణం మైనస్ తీటా, ఇక్కడ నేను m ఈ వ్యక్తీకరణ యొక్క పరిమాణం మరియు ఇది V m మాత్రమే హారం యొక్క పరిమాణం ద్వారా విభజించబడింది, ఇది వర్గమూల R చదరపు మరియు ఒమేగా స్క్వేర్ ఎల్ స్క్వేర్.
18. హారం యొక్క కోణం r ఒమేగా L ద్వారా ఒమేగా L కి విలోమంగా ఉంటుంది మరియు న్యూమరేటర్ యొక్క కోణం 0.
19. కాబట్టి, I (R) యొక్క నికర కోణం ఒమేగా L కు ఎదురుగా ఉన్న మైనస్ టాంజెంట్ (టాన్), ఇది మనం ఇక్కడకు వచ్చే మైనస్ సంకేతం.
20. కాబట్టి, ఇక్కడ తీటా అనేది తీటా (తీటా) ఆర్ చేత ఒమేగా ఎల్ సరసన టాంజెంట్.
21. ప్రస్తుతానికి డొమైన్లో నేను సమానమైన టి యొక్క ఐ కాస్ ఒమేగా టి మైనస్ తీటా (తీటా) కలిగి ఉన్నాను, ఈ వ్యక్తీకరణ మరియు తీటా (తీటా) (తీటా) ద్వారా నేను ఇచ్చాను.
22. ఇప్పుడు మనం కొంత భాగాన్ని, హించుకుంటాము, R 1 ఓంకు సమానం, ఆర్ 1.6 మిల్లీ హెన్రీకి సమానం మరియు ఎఫ్ (ఎఫ్) 50 హెర్ట్జ్కు సమానం అప్పుడు తీటా 26.6 డిగ్రీలు అవుతుంది; మరియు ఇక్కడ సోర్స్ వోల్టేజ్ కోసం ప్లాట్లు ఉన్నాయి మరియు ప్రస్తుత మా సోర్స్ వోల్టేజ్ V m 1.
23. కాబట్టి, ఇది ఒకప్పుడు కాస్ ఒమేగా టి, మరియు ఇది మన ప్రస్తుత చీకటి మరియు ఇప్పుడు ఈ సమీకరణం పరంగా ఈ ప్రస్తుత కేసును అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము.
24. మా I m విలువ సుమారు 0.9 ఆంపియర్లు మరియు అందువల్ల, ప్రస్తుత మైనస్ 0.9 ఆంపియర్ల నుండి 0.9 ఆంపియర్లకు వెళుతుంది.
25. ఇంతకుముందు తీటా 26.6 డిగ్రీలు అని మేము చెప్పినట్లుగా, ఇప్పుడు ఈ విలువను ఈ కేసులో ఎలా జోడించగలం? ఇది ఒక కోణం మరియు ఇది సమయానుకూలంగా ఉంటుంది.
26. కాబట్టి, ఈ కోణాన్ని సమయానికి మార్చడానికి మనం ఏమి చేయవచ్చు; 360 డిగ్రీలు ఒక కాలానికి అనుగుణంగా ఉన్నాయని మాకు తెలుసు, ఈ సందర్భంలో 20 మిల్లీసెకన్లు, ఎందుకంటే 1 కంటే ఎక్కువ 20 మిల్లీసెకన్లు మరియు అందువల్ల, 1.48 మిల్లీసెకన్లు ఉండే కోణంతో సరిపోలడానికి ఈ వాస్తవాన్ని ఉపయోగించవచ్చు.
27. ఇప్పుడు మనం t, I m cos (osga) t (t) మైనస్ తీటాకు సమానం అనే సమీకరణానికి తిరిగి వస్తాము మరియు t యొక్క గరిష్ట స్థాయికి (శిఖరం) ఎప్పుడు వెళ్తాను? అంటే ఒమేగా (ఒమేగా) టి మైనస్ తీటా (తీటా) 0 కి సమానం మరియు సమాధానం ఒమేగా (ఒమేగా) ద్వారా విభజించబడిన తీటా (తీటా) కు సమానమైనప్పుడు, మరియు ఇది సరిగ్గా 1.48 మిల్లీసెకన్లు.
28. కాబట్టి, వోల్టేజ్ దాని గరిష్ట స్థాయికి (పీక్) వెళ్ళినప్పుడు కరెంట్ పీక్ గుండా వెళ్ళదు, కానీ కొంతకాలం తర్వాత అది 1.48 లేదా 1.5 మిల్లీసెకన్ల వద్ద ఉంటుంది, అందుకే ఇది సోర్స్ వోల్టేజ్‌ను తట్టుకుంటుందని మేము చెప్తున్నాము .
29. ఈ మొత్తం గణన ఎంత సులభమో గమనించండి, మేము ఎటువంటి అవకలన సమీకరణాన్ని వ్రాయలేదు, మేము ఈ వ్యక్తీకరణను సిరీస్‌లో 2 రెసిస్టర్‌ల మాదిరిగా ఉపయోగించాము మరియు తరువాత అవసరమైన అన్ని సమాచారాన్ని పొందగలిగాము.
30. కాబట్టి, ఈ విధంగా ఫేజర్‌లు వాస్తవానికి సైనూసోయిడల్ స్థిరమైన స్థితిలో సర్క్యూట్‌ను విశ్లేషించడంలో సహాయపడతాయి.
31. కాబట్టి, ఇక్కడ మీరు సర్క్యూట్‌ను అనుకరించగల సర్క్యూట్ ఫైల్ మరియు కొన్ని భాగాల విలువలను మార్చవచ్చు మరియు ఫలితాలను చూడవచ్చు.
32. ఇప్పుడు ఫేజర్ రేఖాచిత్రాన్ని ఉపయోగించి గ్రాఫికల్ రూపంలో V s ప్లస్ V L కి సమానమైన సంక్లిష్ట విమానంలో KVL సమీకరణాన్ని సూచిద్దాం; మరియు దీన్ని చేయడానికి మనకు V s అవసరం, ఇది V m కోణం 0, మరియు V R, V L, మొదట V R ను చూద్దాం; V R అంటే ఏమిటి? V R I అనేది టైమ్స్ రెసిస్టర్ యొక్క ఇంపెడెన్స్, ఇది R.
33. కాబట్టి, ఇది R సార్లు I కోణం మైనస్ తీటా కోణం, ఎందుకంటే మా I I కోణం మైనస్ తీటా.
34. V L గురించి ఏమిటి? V L I అనేది టైమ్స్ ఇండక్టర్ యొక్క ఇంపెడెన్స్, ఇది j ఒమేగా ఎల్.
35. ఇప్పుడు ఈ J 2 నుండి కోణం PI (Pi) మరియు I I m కోణం మైనస్ తీటా.
36. కాబట్టి, ఈ పరిమాణం ఒమేగా I సార్లు ఎల్ యాంగిల్ మైనస్ తీటా ప్లస్ పిఐ (పై) 2.
37. కాబట్టి, ఇది మా ఫాజర్ రేఖాచిత్రం, ఈ వెక్టర్ V s మరియు V s కోణం 0 రూపంలో ఉంటుంది, కాబట్టి ఇది X (X) X (X) అక్షం, ఇది V యొక్క నిజమైన భాగం ఇది మన VR మరియు తక్కువ VR లోని కోణం కంటే; దీని అర్థం, సవ్యదిశలో తీటా మరియు ఇది మా V L, V L యొక్క కోణం ఏమిటి? ఇది మైనస్ తీటా ప్లస్ పిఐ (పై) బై బై (బై) 2; దీని అర్థం, మేము (తీటా) ద్వారా సవ్యదిశలో వెళ్తాము, ఆపై మనం సవ్యదిశలో 2 (పిఐ) ద్వారా వెళ్తాము, ఇది మనల్ని ఈ కోణానికి తీసుకువస్తుంది మరియు ఇప్పుడు ఈ సమీకరణం V లు VR కి సమానం. ప్లస్ VL తప్పనిసరిగా వెక్టర్ సమీకరణం, మనం VL మరియు VR ను జోడిస్తే మేము V లు పొందుతాము.
38. మేము అప్పుడు సిరీస్ RC సర్క్యూట్‌ను RC సర్క్యూట్‌కు తీసుకువెళతాము మరియు దీనిని మనం చూసిన RL సర్క్యూట్ మాదిరిగానే విశ్లేషించవచ్చు; ఈ సందర్భంలో మనం ఏమి చేయాలి? మేము రెసిస్టర్‌ను దాని ఇంపెడెన్స్‌తో భర్తీ చేస్తాము, దాని కెపాసిటర్ ఇంపెడెన్స్‌తో j ఒమేగా (ఒమేగా) సి 1 పై ఉంటుంది, ఆపై మనం ఈ కరెంట్‌ను V m కోణం 0, J ఒమేగా (ఒమేగా) C గా R ప్లస్ 1 తో విభజించవచ్చు, ఇది నేను m కోణం తీటా అని వ్రాస్తాము, ఇక్కడ నేను ఈ పరిమాణంతో ఇవ్వబడుతుంది, మీరు దీన్ని నిజంగా ధృవీకరించాలి; మరియు తీటా 2 మైనస్ టాంజెంట్ (ఒమేగా) R సి బై పై (పై).
39. ఇప్పుడు ఒమేగాకు ఎదురుగా ఉన్న ఈ టాంజెంట్ (టాన్) Rc 0 నుండి PI (Pi) 2 వరకు మారవచ్చు, కాబట్టి ఈ కోణం ప్రాథమికంగా సానుకూల కోణం.
40. ఆ సమయంలో డొమైన్‌లో మనం కరెంట్‌లో వ్రాస్తాము ఎందుకంటే నేను m కాస్ ఒమేగా టి ప్లస్ తీటా, మరియు ఇప్పుడు మనం కొన్ని భాగాల విలువల కోసం తీటాను లెక్కిస్తాము, R 1. ఓంకు సమానం, సి 5.3 మిల్లీఫ్రాడ్ మరియు ఎఫ్ 50 హెర్ట్జ్కు సమానం.
41. ఈ కలయికకు తీటా 31 డిగ్రీలు మరియు 1.72 మిల్లీసెకన్ల సమయానికి అనుగుణంగా ఉంటుంది.
42. I యొక్క t దాని గరిష్ట స్థాయికి (శిఖరం) వెళ్ళనప్పుడు ఇప్పుడు మనం ఈ ప్రశ్న అడుగుతాము మరియు ఒమేగా (ఒమేగా) t ప్లస్ తీటా 0 కి సమానమైనప్పుడు జరుగుతుంది; దీని అర్థం, t ఒమేగాతో విభజించబడిన మైనస్ తీటాకు సమానం మరియు ఆ సమయం సరిగ్గా 1.72 మిల్లీసెకన్లు.
43. ప్లాట్ పద్ధతిని చూద్దాం; ఈ లైట్ కర్వ్ సోర్స్ వోల్టేజ్ 1 కోణం 0 మరియు ఇది 0 కి సమానమైన దాని శిఖరం (పీక్) గుండా వెళుతుంది ఎందుకంటే కాస్ కాస్ ఫంక్షన్, ఇది డార్క్ కర్వ్ కరెంట్ మరియు ఇది దాని పీక్ (పీక్).) టి ఉన్నప్పుడు వెళుతుంది మేము ఇప్పుడే చర్చించిన మైనస్ 1.72 మిల్లీసెకన్లకు సమానం.
44. మరో మాటలో చెప్పాలంటే, సోర్స్ వోల్టేజ్ దాని శిఖరానికి (పీక్) వెళ్ళే ముందు కరెంట్‌లో గరిష్ట స్థాయికి వెళుతుంది, అందుకే కరెంట్‌లోని మూలం వోల్టేజ్‌కు దారితీస్తుందని మేము చెబుతున్నాము థెటా ఒమేగా సెకన్ల ముందు సోర్స్ వోల్టేజ్ వల్ల సంభవిస్తుంది T (శిఖరం) యొక్క శిఖరం.
45. ఈ సందర్భంలో KVL సమీకరణాన్ని సూచించడానికి ఒక ఫాజర్ రేఖాచిత్రాన్ని గీయండి, ఇది VS VR ప్లస్ VC కి సమానం.
46. వీఆర్ అంటే ఏమిటి? నేను సార్లు R నేను ఎక్కడ కోణాన్ని తీటా చేస్తాను.
47. కాబట్టి, VR నేను R సార్లు నేను యాంగిల్ తీటా. VC గురించి ఏమిటి? I టైమ్స్ కెపాసిటర్ యొక్క V C ఇంపెడెన్స్, ఇది J ఒమేగా (ఒమేగా) C పై 1.
48. ఇప్పుడు ఒకటి కంటే ఎక్కువ j కి సమానమైన j ఉంది, ఇది కోణం మైనస్ PI (Pi) 2 మరియు అందువల్ల, ఒమేగా) C ద్వారా I m సమాన vc ను పొందుతాము, ఇది వ్యాప్తి, మరియు కోణం కోసం మనకు తీటా వస్తుంది) ఆ నేను నుండి వస్తుంది మరియు తరువాత ఈ మైనస్ 2 నుండి ఈ మైనస్ 2 నుండి పిఐ (పై) 2 ఉంటుంది.
49. మన తీటా 0 మరియు pi మధ్య సానుకూల కోణం 2 అని మేము ముందే చెప్పినట్లుగా; ఆ సమాచారంతో మనం ఇప్పుడు ఫాజర్ రేఖాచిత్రాన్ని గీయవచ్చు, ఇది మా VS మరియు ఇది x అక్షం వెంట ఉంది, ఎందుకంటే దీనికి 0 కోణం ఉంటుంది.
50. వీఆర్ గురించి ఏమిటి? Vr సానుకూలంగా ఉన్న కోణ తీటాను మరియు 0 మరియు pi మధ్య 2 ను కనుగొంది.
51. కాబట్టి, Vr పోలి ఉంటుంది; విసి గురించి ఏమిటి? VC లోని తీటా మైనస్ పై కోణం 2.
52. అందువల్ల, మేము తీటా ద్వారా సవ్యదిశలో వెళ్లి 2 నుండి పై వరకు సవ్యదిశలో మారుతాము, అది మనల్ని ఈ కోణానికి తీసుకువస్తుంది.
53. కాబట్టి, ఇది మా VC మరియు ఇప్పుడు వెక్టర్ సమీకరణం VS VR ప్లస్ VC కి సమానమని మనం చూడవచ్చు; ఇది మా వి.ఎస్ అని అందరూ సంతృప్తి చెందారు.
54. కాబట్టి, VR ప్లస్ VC మమ్మల్ని VS కి తీసుకువస్తుంది, కాబట్టి, ఈ సందర్భంలో, ఈ KVL సమీకరణానికి అనుగుణమైన ఫాజర్ రేఖాచిత్రం ఇది.
55. ఇప్పుడు ఇక్కడ చూపిన మరింత క్లిష్టమైన సర్క్యూట్ గురించి పరిశీలిద్దాం.
56. కాబట్టి, మనకు సైనూసోయిడల్ వోల్టేజ్ సోర్స్ 10 యాంగిల్ 0 ఫ్రీక్వెన్సీ 50 హెర్ట్జ్ ఉంది, మరియు మేము ఈ ప్రవాహాలను IS, IC మరియు IL లను కనుగొనాలనుకుంటున్నాము.
57. స్టెప్ నంబర్ వన్ మేము అన్ని భాగాలను వాటి ఇంపెడెన్స్‌గా మారుస్తాము, కాబట్టి ఇది 2 ఓంలలో 2 ఓంలు (వాస్తవానికి) ఉంటుంది; 10 ఓంల నుండి 10 ఓంల వరకు మిల్లీపెడ్ జెడ్ 3 అవుతుంది, ఇక్కడ ఈ Z 3 J ఒమేగా Z వద్ద 1, ఇది మైనస్ 15 నుండి ఎంట్రీ Z 4 వరకు 1.6 ఓంలు (ఓంలు) అవుతుంది. Z4 ఉన్న చోటికి వెళుతుంది. ఒమేగా) 2 pi సార్లు 50 L.
58. కాబట్టి, ఇది J4.07 ఓంలుగా మారుతుంది.
59. ఇప్పుడు తరువాతి దశ ఏమిటంటే, ఈ కలయిక యొక్క సమానమైన ఇంపెడెన్స్‌ను మనం లెక్కించగలము మరియు ఈ సిరీస్ సమాంతర రెసిస్టివ్ కలయిక లాంటిది, మనకు సిరీస్‌లో Z2 మరియు Z4 ఉన్నాయి, ఇది Z3 మరియు Z1 లతో 
60. 72 మిల్లిసెకన్ల milliseconds సమయంతో ఉంటుంది.
61. ఈ దశలన్నింటికీ వెళ్ళడానికి మరియు Z సమానమైన తుది ఫలితాన్ని చేరుకోవడానికి మీరు ఖచ్చితంగా ప్రోత్సహించబడ్డారు, కానీ ఇది మీ కాలిక్యులేటర్‌ను కూడా చూస్తుంది మరియు మీరు మీ కాలిక్యులేటర్‌ను అనుమతించే అవకాశం ఉంది, ఈ గణనను తక్కువ సంఖ్యలో దశల్లో చేయగలుగుతారు .
62. ఇప్పుడు, ముందుకు సాగండి.
63. కాబట్టి, మేము ఈ దశకు చేరుకున్నాము, మీకు Z సమానమైనది. మాకు ఇప్పటికే V. ఉంది.
64. కాబట్టి, ఇప్పుడు, నేను s లను లెక్కించవచ్చు. కాబట్టి, I s ను V S Z సమానమైన, V s 10 కోణం 0 మరియు Z మునుపటి స్లైడ్ నుండి ఈ సంఖ్యకు సమానం, కాబట్టి ఇది 3.58 కోణం 36.8 డిగ్రీ ఆంపియర్. ఇది జరుగుతుంది.
65. నేను కనుగొన్నప్పుడు నేను ప్రస్తుత డివిజన్ సూత్రాన్ని ఉపయోగించి I సి పొందవచ్చు, అంటే నేను సి 2 Z 2 ప్లస్ Z ​​4 కు సమానం Z 2 ప్లస్ Z ​​4 ప్లస్ Z ​​3 సార్లు విభజించబడింది, అంటే నేను సంఖ్యకు మారుతుంది, ఏమిటి IL గురించి? మీరు IL ను 2 విధాలుగా పొందవచ్చు: A I మైనస్ I c మాకు KCL చేత IL ఇస్తుంది లేదా మేము ప్రస్తుత డివిజన్ ఫార్ములా IL ను Z3 ప్లస్ Z3 ప్లస్ Z ​​కి సమానంగా ఉపయోగించవచ్చు. 2 ప్లస్ z 4 రెట్లు, నేను మీకు పొందడానికి IL సంఖ్య అవసరం , మరియు ఇప్పుడు మేము ఈ నోడ్ వద్ద KCL సమీకరణాన్ని వివరించే ఫాజర్ రేఖాచిత్రాన్ని గీస్తాము.
66. ఇక్కడ ఫాజర్ రేఖాచిత్రం మరియు మేము x మరియు y అక్షం కోసం ఒకే స్కేల్‌ని ఉపయోగించామని గమనించండి, ఇది x (x) అక్షం మీద 1 యూనిట్‌ను y (y) అక్షం మీద 1 యూనిట్‌ను సూచించే దూరం.
67. కోణాలు సరిగ్గా ప్రదర్శించబడేలా మేము దీన్ని చేస్తాము; అంటే మనం ఈ పద్ధతిని పాటిస్తే 45 డిగ్రీల కోణం వాస్తవానికి 45 డిగ్రీల కోణంలా కనిపిస్తుంది.
68. సరే ఇప్పుడు ఈ నోడ్‌లో KCL సమీకరణం సంతృప్తికరంగా ఉందో లేదో ధృవీకరిస్తాము.I c ప్లస్ IL (IL) కు సమానమైన సమీకరణం ఏమిటి?
69. మా I (I) 3.58 కోణం 36.08 డిగ్రీలు, ఈ వెక్టర్ మాగ్నిట్యూడ్ 3.58, మరియు ఈ కోణం 36.8 డిగ్రీలు.
70. ఐసి పరిమాణం 3.7.
71. కాబట్టి, నాకన్నా కొంచెం పెద్దది మరియు 44.6 డిగ్రీల కోణం, ఈ కోణం 44.6 డిగ్రీలు.
72. IL ఇది 0.546 మాగ్నిట్యూడ్‌లో చాలా చిన్నది మరియు ప్రతికూల కోణం కలిగి ఉంటుంది, కనీసం 70.6 డిగ్రీలు.
73. కాబట్టి, ఇది మా IL; ఇప్పుడు మనం సి ప్లస్ IL వాస్తవానికి సమానమని చూస్తాము; దీని అర్థం, KCL ధృవీకరించబడింది.
74. సరళ DC సర్క్యూట్ల కోసం గరిష్ట విద్యుత్ బదిలీ సిద్ధాంతాన్ని మేము చూశాము; ఇప్పుడు సైనూసోయిడల్ స్థిరమైన స్థితిలో గరిష్ట విద్యుత్ బదిలీని చూద్దాం.
75. కాబట్టి, ఈ సర్క్యూట్ ద్వారా థెవెనిన్ సమానమైన సర్క్యూట్‌ను ఇక్కడ పరిశీలిద్దాం, అంటే వోల్టేజ్ సోర్స్ V t h సిరీస్‌లో ఇంపెడెన్స్ Z t h; ఈ రెండు కోర్సులు సంక్లిష్ట సంఖ్యలు.
76. ఇప్పుడు మేము సర్క్యూట్కు లోడ్ ఇంపెడెన్స్ను జోడిస్తాము మరియు దాని ఫలితంగా ఒక కరెంట్ ప్రవహిస్తుంది మరియు కరెంట్ లోని ఈ కరెంట్ స్పేసర్ I చే సూచించబడుతుంది.
77. ఈ సర్క్యూట్ 2 Z L నుండి విద్యుత్ బదిలీ గరిష్టంగా ఉన్న పరిస్థితిని మేము కనుగొనాలనుకుంటున్నాము.
78. R L ప్లస్ j x L కి సమానమైన JLL తో ప్రారంభిద్దాం, ఇక్కడ ఇది ZL యొక్క నిజమైన భాగం మరియు ఇది ZL యొక్క inary హాత్మక భాగం మరియు Z t h R t h ప్లస్ j x t h.
79. I I m phi కోణం, నేను ఇక్కడ ఈ ఫాజర్ I యొక్క పరిమాణం మరియు fi దాని కోణం.
80. కాబట్టి, Z సమానమైన Z1 ప్లస్ Z3 సమాంతర Z2 ప్లస్ Z4.
81. ఇప్పుడు, ZL చేత గ్రహించబడిన శక్తి సగం మీటర్ m R RL ఇచ్చిన P కి సమానం, ఇక్కడ I m ఈ ఫేజర్ యొక్క పరిమాణం మరియు RL Z L యొక్క నిజమైన భాగం.
82. ఏమిటి ఇది నేను యొక్క పరిమాణం, మరియు నేను ఏమిటి? V t h ను Z t h మరియు Z L చే విభజించారు.
83. కాబట్టి, ఇక్కడ ఈ వ్యక్తీకరణకు సమానమైన p ను పొందుతాము.
84. ఈ వ్యక్తీకరణను సగం మోడ్ (సగం మోడ్) V t h స్క్వేర్‌గా R t h ప్లస్ R L స్క్వేర్డ్ ప్లస్ X టి హెచ్ ప్లస్ ఎక్స్ ఎల్ స్క్వేర్డ్ మరియు ఆర్ ఎల్ చేత గుణించాలి.
85. ఇప్పుడు ఈ V t h తరగతి ZL నుండి స్వతంత్రంగా ఉంది మరియు మనకు సంబంధించినంతవరకు అది స్థిరంగా ఉంటుంది.
86. కాబట్టి, ఇప్పుడు మనం చేయవలసింది ఈ మొత్తం వ్యక్తీకరణ గరిష్టంగా ఉన్న Z పై పరిస్థితులను కనుగొనడం.
87. ఇప్పుడు, P గరిష్టంగా ఉండటానికి, స్పష్టంగా ఈ హారం కనిష్టంగా ఉండాలి మరియు X వ ప్లస్ XL స్క్వేర్డ్ 0 అయినప్పుడు ఇది జరుగుతుంది, ఎందుకంటే ఇక్కడ ఒక చదరపు ఉంది, ఈ పదాన్ని అతి చిన్న విలువగా తీసుకోవచ్చు. 0 మరియు, అందువల్ల, ఈ రెండవ పదానికి సమానమైన xh తో xh కు సమానమైన x L మైనస్ వ మరియు xl మనకు అదృశ్యమవుతుంది, మరియు మనకు p సమాన rv ప్లస్ rl స్క్వేర్డ్ టైమ్స్ r ను సగం మోడ్ ద్వారా విభజించి V వ చదరపుకి సమానం.
88. కాబట్టి, గరిష్ట విద్యుత్ బదిలీ కోసం మనం ఇప్పుడు ఈ వ్యక్తీకరణను పెంచాలి.
89. మేము దీన్ని ఎలా చేయాలి? మేము RL కు సంబంధించి P ను వేరు చేస్తాము మరియు మేము DPD RL ను 0 తో సమానం చేస్తాము మరియు R R R T T కి సమానమైనప్పుడు P గరిష్టంగా ఉంటుందని కనుగొన్నాము.
90. కాబట్టి, మనకు 2 షరతులు ఉన్నాయి: JL యొక్క inary హాత్మక భాగం X L, ఇది X L యొక్క inary హాత్మక భాగం యొక్క ప్రతికూలానికి సమానంగా ఉండాలి, ఇది X t h మరియు ZL యొక్క వాస్తవ భాగం Z t h యొక్క వాస్తవ భాగానికి సమానంగా ఉండాలి.
91. లోడ్ ZL లో గరిష్ట విద్యుత్ బదిలీ కోసం సంగ్రహంగా చెప్పాలంటే, మనకు RL మరియు XL కు సమానమైన RL అవసరం, ఇది మైనస్ కంటే తక్కువ; దీని అర్థం, మా లోడ్ ఇంపెడెన్స్ థెవెనిన్ సమానమైన ఇంపెడెన్స్ యొక్క సంక్లిష్ట యాదృచ్చికంగా ఉండాలి, ఇది Z T H.
92. కాబట్టి, ZL తప్పనిసరిగా Z వ నక్షత్రానికి సమానంగా ఉండాలి.
93. ఇప్పుడు సైనూసోయిడల్ స్థిరమైన స్థితి కోసం గరిష్ట శక్తి బదిలీ సిద్ధాంతం యొక్క అనువర్తనాన్ని చూద్దాం, ఇది ఆడియో ఇన్పుట్ సిగ్నల్ ద్వారా శక్తినిచ్చే ఆడియో యాంప్లిఫైయర్.
94. కాబట్టి, ఇక్కడ పౌన encies పున్యాల పరిధి 20 Hz నుండి 16 KHz లేదా అంతకంటే ఎక్కువ ఉంటుంది.
95. ఈ ఆడియో యాంప్లిఫైయర్ తరువాత ట్రాన్స్ఫార్మర్ ఉంది మరియు ఈ ట్రాన్స్ఫార్మర్ ఎందుకు అవసరమో త్వరలో వ్యాఖ్యానిస్తాము మరియు చివరకు, మనకు ఈ స్పీకర్ ఉంది.
96. ఈ స్పీకర్ సంక్లిష్ట ఇంపెడెన్స్‌ను కలిగి ఉంటుంది, ఇది ఫ్రీక్వెన్సీతో మారుతుంది, కానీ ఆడియో పరిధిలో దాని నిరోధకత సాధారణంగా 8 ఓంలు (ఓంలు), మరియు దాని inary హాత్మక భాగాన్ని విస్మరించవచ్చు.
97. అందువల్ల, సమానమైన సర్క్యూట్ ఈ సర్క్యూట్ ద్వారా ఇక్కడ ప్రాతినిధ్యం వహిస్తుంది, ఇక్కడ ఈ మూలం ఆడియో యాంప్లిఫైయర్ యొక్క లాభం ద్వారా విస్తరించబడిన ఇన్పుట్ సిగ్నల్ను సూచిస్తుంది మరియు తరువాత ఈ ఒక నిరోధకత ఆడియో యాంప్లిఫైయర్ యొక్క అవుట్పుట్ నిరోధకత, ఆపై మనకు ట్రాన్స్ఫార్మర్ ఒకటి ఉంది. నిష్పత్తి n 1 2, n 2 మరియు చివరకు, ఈ 8 ఓంల నిరోధకత ద్వారా స్పీకర్ ప్రాతినిధ్యం వహిస్తుంది.
98. ఈ సర్క్యూట్ నుండి స్పీకర్‌కు విద్యుత్ బదిలీని పెంచడం మా లక్ష్యం, అందువల్ల మేము ఇన్‌పుట్ సిగ్నల్‌తో పెద్ద శబ్దాన్ని వింటాము.
99. కాబట్టి, సర్క్యూట్‌ను సరళీకృతం చేద్దాం, మేము ఈ ప్రతిఘటనను ట్రాన్స్‌ఫార్మర్ యొక్క మరొక వైపుకు బదిలీ చేయవచ్చు మరియు అది N2 స్క్వేర్డ్ సమయంలో 8 ఓంల ద్వారా N1 అవుతుంది.
100. ఇక్కడ మా నిజమైన సమస్య ప్రకటన, మేము ఈ సర్క్యూట్‌ను చూస్తాము మరియు ఆడియో సిగ్నల్ యొక్క గరిష్ట శక్తి బదిలీని అందించడానికి ట్విస్ట్ నిష్పత్తిని లెక్కిస్తాము; గరిష్ట విద్యుత్ బదిలీ సిద్ధాంతం ఏమిటి? ఇది ZL తప్పనిసరిగా Z t h నక్షత్రానికి సమానంగా ఉండాలని పేర్కొంది మరియు ఈ సందర్భంలో Z t h మరియు ZL యొక్క inary హాత్మక భాగాలు 0, దీని అర్థం నిజమైన భాగం సమానంగా ఉండాలి; దీని అర్థం, మనకు 1 కి సమానమైన N 1by N 2 చదరపు సార్లు 8 ఓంలు (ఓంలు) ఉండాలి.
101. ఇప్పుడు మనం ఈ సమీకరణాన్ని n1 కొరకు n2 ద్వారా పరిష్కరించగలము మరియు ఇది n1 ద్వారా n2 ద్వారా 11 గురించి ఇస్తుంది.
102. అందువల్ల, మేము ఈ అనువాదంతో ట్రాన్స్‌ఫార్మర్‌ను ఎంచుకుంటే, ఆడియో సిగ్నల్ స్పీకర్‌కు గరిష్ట శక్తిని అందిస్తుంది, మరియు ఈ ఇన్‌పుట్ సిగ్నల్‌తో సాధ్యమయ్యే అతి పెద్ద శబ్దాన్ని మేము వింటాము.
103. ముగింపులో, సైనూసోయిడల్ స్థిరమైన స్థితిలో RLC సర్క్యూట్లను విశ్లేషించడానికి ఫాజర్‌లను ఎలా ఉపయోగించాలో చూశాము; కొంతకాలం తర్వాత ఫిల్టర్ సర్క్యూట్‌ను చూసేటప్పుడు ఈ నేపథ్యం చాలా ఉపయోగకరంగా ఉంటుంది.
104. సైనూసోయిడల్ స్థిరమైన స్థితిలో ఆర్‌ఎల్‌సి సర్క్యూట్‌ల కోసం గరిష్ట విద్యుత్ బదిలీ సిద్ధాంతాన్ని కూడా చూశాము.
105. ఆచరణలో చాలా ముఖ్యమైన ఒక ఉదాహరణను మేము పరిగణించాము, అనగా స్పీకర్ నుండి గరిష్ట ఆడియో శక్తిని ఎలా పొందాలో, ఇది ఇప్పుడు ప్రతిదీ.
106. తరువాత కలుద్దాం
 బాసిక్ ఎలెక్త్రొనిక్స్ కు స్వాగతము.
గత ఉపాన్యాసము లొ మనుము ఫాసర్లు phasors పరిచయం చేశాము మరియు వాటిని సైనోఇయిడాల్ స్థిరమైన స్థితిలో ఎలా అర్థం చేసుకోవచ్చో చూడవచ్చు.
ఈ ఉపన్యాసంలో స్థిరమైన స్థితి ప్రవాహాలు మరియు వోల్టేజ్‌లను అర్థం చేసుకోవడానికి మేము RLC సర్క్యూట్‌లకు ఫేజర్‌లను వర్తింపజేయాలనుకుంటున్నాము.
అదనంగా, సైనూసోయిడల్ స్థిరమైన స్థితిలో RLC సర్క్యూట్ల కోసం గరిష్ట విద్యుత్ బదిలీ సిద్ధాంతాన్ని చూస్తాము.
కాబట్టి, ప్రారంభిద్దాం.
సర్క్యూట్ విశ్లేషణలో ఫాజర్‌ను ఎలా ఉపయోగించవచ్చో చూద్దాం; టైమ్ డొమైన్ KCL మరియు KVL సమీకరణాలు సిగ్మా IK సమాన 0 మరియు సిగ్మా V సమాన 0 ను ఫాజర్ సమీకరణాలుగా వ్రాయవచ్చు, సిగ్మా IK 0 కి సమానం, ఇక్కడ IK ప్రస్తుత దశ మరియు సిగ్మా VK 0 కి సమానం, ఇక్కడ V యొక్క ఫ్రీక్వెన్సీ డొమైన్‌లో వోల్టేజ్ ఫాజర్‌లు ఉన్నాయి .
రెసిస్టర్లు, కెపాసిటర్లు మరియు ప్రేరకాలను ఫ్రీక్వెన్సీ డొమైన్‌లో J ద్వారా Z సార్లు I కు సమానంగా వర్ణించవచ్చు, ఇది DC పరిస్థితులలో R కి సమానం.
ఒకే తేడా ఏమిటంటే, ఈ సమీకరణం గురించి మాట్లాడేటప్పుడు మనం సంక్లిష్ట సంఖ్యలతో వ్యవహరిస్తున్నాము.
ఫ్రీక్వెన్సీ డొమైన్‌లో ఒక స్వతంత్ర సైనూసోయిడల్ మూలం, ఉదాహరణకు, DC మూలం వలె ప్రవర్తిస్తుంది, వోల్టేజ్ మూలం కోసం సైనూసోయిడల్ వోల్టేజ్ మూలం, మేము ఫేజర్ Vs స్థిరంగా ఉందని చెప్పవచ్చు, ఇది సంక్లిష్టమైనది. సంఖ్య.
ఆధారిత మూలాల కోసం, t (I) తో సమానమైన టైమ్ డొమైన్ సంబంధం t ను C యొక్క ఫాజర్ సంబంధంలోకి అనువదిస్తుంది, ఫాజర్ (I) ఫ్రీక్వెన్సీ డొమైన్ బీటా టైమ్స్ ఫేజర్‌ను కలిగి ఉంటుంది. (ఫాజర్) I c కి సమానం.
అందువల్ల, మనకు ఇక్కడ సంక్లిష్ట సంఖ్యలు ఉన్నాయి తప్ప సమీకరణం చాలా పోలి ఉంటుంది.
అందువల్ల, ఈ అన్ని పరిశీలనల నుండి, ఫాసోర్‌లను ఉపయోగించి సైనూసోయిడల్ స్థిరమైన స్థితిలో సర్క్యూట్ విశ్లేషణ స్వతంత్ర మరియు ఆధారిత వనరులు మరియు రెసిస్టర్‌లతో DC సర్క్యూట్‌ల మాదిరిగానే ఉంటుందని మేము నిర్ధారించాము; అందువల్ల, DC సర్క్యూట్ల కోసం మేము పొందిన అన్ని ఫలితాలు సైనూసోయిడల్ స్థిరమైన స్థితి విశ్లేషణకు చెల్లుతాయి, అందువల్ల రెసిస్టర్లు, నోడల్ విశ్లేషణ, మెష్ విశ్లేషణ, థెవెనిన్ మరియు థెవెనిన్ సిద్ధాంతం కోసం సిరీస్ సమాంతర సూత్రాలు. సైనూసోయిడల్ స్థిరమైన స్థితిలో ఒక సర్క్యూట్‌కు నేరుగా వర్తించవచ్చు ; కోర్సు యొక్క పూర్తిగా వేరు, మేము ఇప్పుడు సంక్లిష్ట సంఖ్యలతో వ్యవహరిస్తున్నాము.
ఇప్పుడు మనం సైనూసోయిడల్ స్థిరమైన స్థితిలో RL సర్క్యూట్లను పరిశీలిద్దాం; సిరీస్లో R మరియు L ఇక్కడ రెసిస్టర్ R, మనం ఇంతకుముందు చూసినట్లుగా మరియు ప్రేరక యొక్క ఇంపెడెన్స్ j ఒమేగా (ఒమేగా) L.
ఇది మా సైనూసోయిడల్ సోర్స్ వోల్టేజ్ V m యాంగిల్ 0, ఇది సమయం V m cos (Cos) ఒమేగా (t) డొమైన్ మరియు ఈ కరెంట్ పట్ల మాకు ఆసక్తి ఉంది.
మేము ఫేజర్‌ను ఉపయోగించినప్పుడు, మనం చూసే విధంగా ఇది చాలా సులభమైన గణన అవుతుంది; మనకు DC సోర్స్ DC మూలం ఉందని imagine హించుకుందాం, ఇక్కడ Vs, ఒక రెసిస్టర్ R1 మరియు ఇక్కడ ఒక రెసిస్టర్ R 2, ఆ సందర్భంలో ప్రస్తుతంలో ఏమి జరుగుతుంది? DC కరెంట్ (లు) ఇది V లు R 1 ప్లస్ R 2 తో విభజించబడింది; కాబట్టి మనం V లకు బదులుగా సరిగ్గా అదే సమీకరణాన్ని ఉపయోగించవచ్చు, మనకు ఇప్పుడు V m కోణం 0 అనే ఫాజర్ మూలం ఉంది మరియు R 1 మరియు R 2 కు బదులుగా వాటికి R మరియు j ఒమేగా L ఉన్నాయి, నిరోధకం మరియు ప్రేరక పరిమితులు ఉన్నాయి.
కాబట్టి, మనం I (I) ను V m కోణం 0 గా వ్రాయవచ్చు, ఈ మూలాన్ని R ప్లస్ j ఒమేగా (ఒమేగా) L ద్వారా విభజించారు.
నేను ఈ ఫాజర్‌ను ప్రస్తుతములో వ్రాయగలను ఎందుకంటే నేను (I) కోణం మైనస్ తీటా, ఇక్కడ నేను m ఈ వ్యక్తీకరణ యొక్క పరిమాణం మరియు ఇది V m మాత్రమే హారం యొక్క పరిమాణం ద్వారా విభజించబడింది, ఇది వర్గమూల R చదరపు మరియు ఒమేగా స్క్వేర్ ఎల్ స్క్వేర్.
హారం యొక్క కోణం r ఒమేగా L ద్వారా ఒమేగా L కి విలోమంగా ఉంటుంది మరియు న్యూమరేటర్ యొక్క కోణం 0.
కాబట్టి, I (R) యొక్క నికర కోణం ఒమేగా L కు ఎదురుగా ఉన్న మైనస్ టాంజెంట్ (టాన్), ఇది మనం ఇక్కడకు వచ్చే మైనస్ సంకేతం.
కాబట్టి, ఇక్కడ తీటా అనేది తీటా (తీటా) ఆర్ చేత ఒమేగా ఎల్ సరసన టాంజెంట్.
ప్రస్తుతానికి డొమైన్లో నేను సమానమైన టి యొక్క ఐ కాస్ ఒమేగా టి మైనస్ తీటా (తీటా) కలిగి ఉన్నాను, ఈ వ్యక్తీకరణ మరియు తీటా (తీటా) (తీటా) ద్వారా నేను ఇచ్చాను.
ఇప్పుడు మనం కొంత భాగాన్ని, హించుకుంటాము, R 1 ఓంకు సమానం, ఆర్ 1.6 మిల్లీ హెన్రీకి సమానం మరియు ఎఫ్ (ఎఫ్) 50 హెర్ట్జ్కు సమానం అప్పుడు తీటా 26.6 డిగ్రీలు అవుతుంది; మరియు ఇక్కడ సోర్స్ వోల్టేజ్ కోసం ప్లాట్లు ఉన్నాయి మరియు ప్రస్తుత మా సోర్స్ వోల్టేజ్ V m 1.
కాబట్టి, ఇది ఒకప్పుడు కాస్ ఒమేగా టి, మరియు ఇది మన ప్రస్తుత చీకటి మరియు ఇప్పుడు ఈ సమీకరణం పరంగా ఈ ప్రస్తుత కేసును అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము.
మా I m విలువ సుమారు 0.9 ఆంపియర్లు మరియు అందువల్ల, ప్రస్తుత మైనస్ 0.9 ఆంపియర్ల నుండి 0.9 ఆంపియర్లకు వెళుతుంది.
ఇంతకుముందు తీటా 26.6 డిగ్రీలు అని మేము చెప్పినట్లుగా, ఇప్పుడు ఈ విలువను ఈ కేసులో ఎలా జోడించగలం? ఇది ఒక కోణం మరియు ఇది సమయానుకూలంగా ఉంటుంది.
కాబట్టి, ఈ కోణాన్ని సమయానికి మార్చడానికి మనం ఏమి చేయవచ్చు; 360 డిగ్రీలు ఒక కాలానికి అనుగుణంగా ఉన్నాయని మాకు తెలుసు, ఈ సందర్భంలో 20 మిల్లీసెకన్లు, ఎందుకంటే 1 కంటే ఎక్కువ 20 మిల్లీసెకన్లు మరియు అందువల్ల, 1.48 మిల్లీసెకన్లు ఉండే కోణంతో సరిపోలడానికి ఈ వాస్తవాన్ని ఉపయోగించవచ్చు.
ఇప్పుడు మనం t, I m cos (osga) t (t) మైనస్ తీటాకు సమానం అనే సమీకరణానికి తిరిగి వస్తాము మరియు t యొక్క గరిష్ట స్థాయికి (శిఖరం) ఎప్పుడు వెళ్తాను? అంటే ఒమేగా (ఒమేగా) టి మైనస్ తీటా (తీటా) 0 కి సమానం మరియు సమాధానం ఒమేగా (ఒమేగా) ద్వారా విభజించబడిన తీటా (తీటా) కు సమానమైనప్పుడు, మరియు ఇది సరిగ్గా 1.48 మిల్లీసెకన్లు.
కాబట్టి, వోల్టేజ్ దాని గరిష్ట స్థాయికి (పీక్) వెళ్ళినప్పుడు కరెంట్ పీక్ గుండా వెళ్ళదు, కానీ కొంతకాలం తర్వాత అది 1.48 లేదా 1.5 మిల్లీసెకన్ల వద్ద ఉంటుంది, అందుకే ఇది సోర్స్ వోల్టేజ్‌ను తట్టుకుంటుందని మేము చెప్తున్నాము .
ఈ మొత్తం గణన ఎంత సులభమో గమనించండి, మేము ఎటువంటి అవకలన సమీకరణాన్ని వ్రాయలేదు, మేము ఈ వ్యక్తీకరణను సిరీస్‌లో 2 రెసిస్టర్‌ల మాదిరిగా ఉపయోగించాము మరియు తరువాత అవసరమైన అన్ని సమాచారాన్ని పొందగలిగాము.
కాబట్టి, ఈ విధంగా ఫేజర్‌లు వాస్తవానికి సైనూసోయిడల్ స్థిరమైన స్థితిలో సర్క్యూట్‌ను విశ్లేషించడంలో సహాయపడతాయి.
కాబట్టి, ఇక్కడ మీరు సర్క్యూట్‌ను అనుకరించగల సర్క్యూట్ ఫైల్ మరియు కొన్ని భాగాల విలువలను మార్చవచ్చు మరియు ఫలితాలను చూడవచ్చు.
ఇప్పుడు ఫేజర్ రేఖాచిత్రాన్ని ఉపయోగించి గ్రాఫికల్ రూపంలో V s ప్లస్ V L కి సమానమైన సంక్లిష్ట విమానంలో KVL సమీకరణాన్ని సూచిద్దాం; మరియు దీన్ని చేయడానికి మనకు V s అవసరం, ఇది V m కోణం 0, మరియు V R, V L, మొదట V R ను చూద్దాం; V R అంటే ఏమిటి? V R I అనేది టైమ్స్ రెసిస్టర్ యొక్క ఇంపెడెన్స్, ఇది R.
కాబట్టి, ఇది R సార్లు I కోణం మైనస్ తీటా కోణం, ఎందుకంటే మా I I కోణం మైనస్ తీటా.
V L గురించి ఏమిటి? V L I అనేది టైమ్స్ ఇండక్టర్ యొక్క ఇంపెడెన్స్, ఇది j ఒమేగా ఎల్.
ఇప్పుడు ఈ J 2 నుండి కోణం PI (Pi) మరియు I I m కోణం మైనస్ తీటా.
కాబట్టి, ఈ పరిమాణం ఒమేగా I సార్లు ఎల్ యాంగిల్ మైనస్ తీటా ప్లస్ పిఐ (పై) 2.
కాబట్టి, ఇది మా ఫాజర్ రేఖాచిత్రం, ఈ వెక్టర్ V s మరియు V s కోణం 0 రూపంలో ఉంటుంది, కాబట్టి ఇది X (X) X (X) అక్షం, ఇది V యొక్క నిజమైన భాగం ఇది మన VR మరియు తక్కువ VR లోని కోణం కంటే; దీని అర్థం, సవ్యదిశలో తీటా మరియు ఇది మా V L, V L యొక్క కోణం ఏమిటి? ఇది మైనస్ తీటా ప్లస్ పిఐ (పై) బై బై (బై) 2; దీని అర్థం, మేము (తీటా) ద్వారా సవ్యదిశలో వెళ్తాము, ఆపై మనం సవ్యదిశలో 2 (పిఐ) ద్వారా వెళ్తాము, ఇది మనల్ని ఈ కోణానికి తీసుకువస్తుంది మరియు ఇప్పుడు ఈ సమీకరణం V లు VR కి సమానం. ప్లస్ VL తప్పనిసరిగా వెక్టర్ సమీకరణం, మనం VL మరియు VR ను జోడిస్తే మేము V లు పొందుతాము.
మేము అప్పుడు సిరీస్ RC సర్క్యూట్‌ను RC సర్క్యూట్‌కు తీసుకువెళతాము మరియు దీనిని మనం చూసిన RL సర్క్యూట్ మాదిరిగానే విశ్లేషించవచ్చు; ఈ సందర్భంలో మనం ఏమి చేయాలి? మేము రెసిస్టర్‌ను దాని ఇంపెడెన్స్‌తో భర్తీ చేస్తాము, దాని కెపాసిటర్ ఇంపెడెన్స్‌తో j ఒమేగా (ఒమేగా) సి 1 పై ఉంటుంది, ఆపై మనం ఈ కరెంట్‌ను V m కోణం 0, J ఒమేగా (ఒమేగా) C గా R ప్లస్ 1 తో విభజించవచ్చు, ఇది నేను m కోణం తీటా అని వ్రాస్తాము, ఇక్కడ నేను ఈ పరిమాణంతో ఇవ్వబడుతుంది, మీరు దీన్ని నిజంగా ధృవీకరించాలి; మరియు తీటా 2 మైనస్ టాంజెంట్ (ఒమేగా) R సి బై పై (పై).
ఇప్పుడు ఒమేగాకు ఎదురుగా ఉన్న ఈ టాంజెంట్ (టాన్) Rc 0 నుండి PI (Pi) 2 వరకు మారవచ్చు, కాబట్టి ఈ కోణం ప్రాథమికంగా సానుకూల కోణం.
ఆ సమయంలో డొమైన్‌లో మనం కరెంట్‌లో వ్రాస్తాము ఎందుకంటే నేను m కాస్ ఒమేగా టి ప్లస్ తీటా, మరియు ఇప్పుడు మనం కొన్ని భాగాల విలువల కోసం తీటాను లెక్కిస్తాము, R 1. ఓంకు సమానం, సి 5.3 మిల్లీఫ్రాడ్ మరియు ఎఫ్ 50 హెర్ట్జ్కు సమానం.
ఈ కలయికకు తీటా 31 డిగ్రీలు మరియు 1.72 మిల్లీసెకన్ల సమయానికి అనుగుణంగా ఉంటుంది.
I యొక్క t దాని గరిష్ట స్థాయికి (శిఖరం) వెళ్ళనప్పుడు ఇప్పుడు మనం ఈ ప్రశ్న అడుగుతాము మరియు ఒమేగా (ఒమేగా) t ప్లస్ తీటా 0 కి సమానమైనప్పుడు జరుగుతుంది; దీని అర్థం, t ఒమేగాతో విభజించబడిన మైనస్ తీటాకు సమానం మరియు ఆ సమయం సరిగ్గా 1.72 మిల్లీసెకన్లు.
ప్లాట్ పద్ధతిని చూద్దాం; ఈ లైట్ కర్వ్ సోర్స్ వోల్టేజ్ 1 కోణం 0 మరియు ఇది 0 కి సమానమైన దాని శిఖరం (పీక్) గుండా వెళుతుంది ఎందుకంటే కాస్ కాస్ ఫంక్షన్, ఇది డార్క్ కర్వ్ కరెంట్ మరియు ఇది దాని పీక్ (పీక్).) టి ఉన్నప్పుడు వెళుతుంది మేము ఇప్పుడే చర్చించిన మైనస్ 1.72 మిల్లీసెకన్లకు సమానం.
మరో మాటలో చెప్పాలంటే, సోర్స్ వోల్టేజ్ దాని శిఖరానికి (పీక్) వెళ్ళే ముందు కరెంట్‌లో గరిష్ట స్థాయికి వెళుతుంది, అందుకే కరెంట్‌లోని మూలం వోల్టేజ్‌కు దారితీస్తుందని మేము చెబుతున్నాము థెటా ఒమేగా సెకన్ల ముందు సోర్స్ వోల్టేజ్ వల్ల సంభవిస్తుంది T (శిఖరం) యొక్క శిఖరం.
ఈ సందర్భంలో KVL సమీకరణాన్ని సూచించడానికి ఒక ఫాజర్ రేఖాచిత్రాన్ని గీయండి, ఇది VS VR ప్లస్ VC కి సమానం.
వీఆర్ అంటే ఏమిటి? నేను సార్లు R నేను ఎక్కడ కోణాన్ని తీటా చేస్తాను.
కాబట్టి, VR నేను R సార్లు నేను యాంగిల్ తీటా. VC గురించి ఏమిటి? I టైమ్స్ కెపాసిటర్ యొక్క V C ఇంపెడెన్స్, ఇది J ఒమేగా (ఒమేగా) C పై 1.
ఇప్పుడు ఒకటి కంటే ఎక్కువ j కి సమానమైన j ఉంది, ఇది కోణం మైనస్ PI (Pi) 2 మరియు అందువల్ల, ఒమేగా) C ద్వారా I m సమాన vc ను పొందుతాము, ఇది వ్యాప్తి, మరియు కోణం కోసం మనకు తీటా వస్తుంది) ఆ నేను నుండి వస్తుంది మరియు తరువాత ఈ మైనస్ 2 నుండి ఈ మైనస్ 2 నుండి పిఐ (పై) 2 ఉంటుంది.
మన తీటా 0 మరియు pi మధ్య సానుకూల కోణం 2 అని మేము ముందే చెప్పినట్లుగా; ఆ సమాచారంతో మనం ఇప్పుడు ఫాజర్ రేఖాచిత్రాన్ని గీయవచ్చు, ఇది మా VS మరియు ఇది x అక్షం వెంట ఉంది, ఎందుకంటే దీనికి 0 కోణం ఉంటుంది.
వీఆర్ గురించి ఏమిటి? Vr సానుకూలంగా ఉన్న కోణ తీటాను మరియు 0 మరియు pi మధ్య 2 ను కనుగొంది.
కాబట్టి, Vr పోలి ఉంటుంది; విసి గురించి ఏమిటి? VC లోని తీటా మైనస్ పై కోణం 2.
అందువల్ల, మేము తీటా ద్వారా సవ్యదిశలో వెళ్లి 2 నుండి పై వరకు సవ్యదిశలో మారుతాము, అది మనల్ని ఈ కోణానికి తీసుకువస్తుంది.
కాబట్టి, ఇది మా VC మరియు ఇప్పుడు వెక్టర్ సమీకరణం VS VR ప్లస్ VC కి సమానమని మనం చూడవచ్చు; ఇది మా వి.ఎస్ అని అందరూ సంతృప్తి చెందారు.
కాబట్టి, VR ప్లస్ VC మమ్మల్ని VS కి తీసుకువస్తుంది, కాబట్టి, ఈ సందర్భంలో, ఈ KVL సమీకరణానికి అనుగుణమైన ఫాజర్ రేఖాచిత్రం ఇది.
ఇప్పుడు ఇక్కడ చూపిన మరింత క్లిష్టమైన సర్క్యూట్ గురించి పరిశీలిద్దాం.
కాబట్టి, మనకు సైనూసోయిడల్ వోల్టేజ్ సోర్స్ 10 యాంగిల్ 0 ఫ్రీక్వెన్సీ 50 హెర్ట్జ్ ఉంది, మరియు మేము ఈ ప్రవాహాలను IS, IC మరియు IL లను కనుగొనాలనుకుంటున్నాము.
స్టెప్ నంబర్ వన్ మేము అన్ని భాగాలను వాటి ఇంపెడెన్స్‌గా మారుస్తాము, కాబట్టి ఇది 2 ఓంలలో 2 ఓంలు (వాస్తవానికి) ఉంటుంది; 10 ఓంల నుండి 10 ఓంల వరకు మిల్లీపెడ్ జెడ్ 3 అవుతుంది, ఇక్కడ ఈ Z 3 J ఒమేగా Z వద్ద 1, ఇది మైనస్ 15 నుండి ఎంట్రీ Z 4 వరకు 1.6 ఓంలు (ఓంలు) అవుతుంది. Z4 ఉన్న చోటికి వెళుతుంది. ఒమేగా) 2 pi సార్లు 50 L.
కాబట్టి, ఇది J4.07 ఓంలుగా మారుతుంది.
ఇప్పుడు తరువాతి దశ ఏమిటంటే, ఈ కలయిక యొక్క సమానమైన ఇంపెడెన్స్‌ను మనం లెక్కించగలము మరియు ఈ సిరీస్ సమాంతర రెసిస్టివ్ కలయిక లాంటిది, మనకు సిరీస్‌లో Z2 మరియు Z4 ఉన్నాయి, ఇది Z3 మరియు Z1 లతో 
72 మిల్లిసెకన్ల milliseconds సమయంతో ఉంటుంది.
ఈ దశలన్నింటికీ వెళ్ళడానికి మరియు Z సమానమైన తుది ఫలితాన్ని చేరుకోవడానికి మీరు ఖచ్చితంగా ప్రోత్సహించబడ్డారు, కానీ ఇది మీ కాలిక్యులేటర్‌ను కూడా చూస్తుంది మరియు మీరు మీ కాలిక్యులేటర్‌ను అనుమతించే అవకాశం ఉంది, ఈ గణనను తక్కువ సంఖ్యలో దశల్లో చేయగలుగుతారు .
ఇప్పుడు, ముందుకు సాగండి.
కాబట్టి, మేము ఈ దశకు చేరుకున్నాము, మీకు Z సమానమైనది. మాకు ఇప్పటికే V. ఉంది.
కాబట్టి, ఇప్పుడు, నేను s లను లెక్కించవచ్చు. కాబట్టి, I s ను V S Z సమానమైన, V s 10 కోణం 0 మరియు Z మునుపటి స్లైడ్ నుండి ఈ సంఖ్యకు సమానం, కాబట్టి ఇది 3.58 కోణం 36.8 డిగ్రీ ఆంపియర్. ఇది జరుగుతుంది.
నేను కనుగొన్నప్పుడు నేను ప్రస్తుత డివిజన్ సూత్రాన్ని ఉపయోగించి I సి పొందవచ్చు, అంటే నేను సి 2 Z 2 ప్లస్ Z ​​4 కు సమానం Z 2 ప్లస్ Z ​​4 ప్లస్ Z ​​3 సార్లు విభజించబడింది, అంటే నేను సంఖ్యకు మారుతుంది, ఏమిటి IL గురించి? మీరు IL ను 2 విధాలుగా పొందవచ్చు: A I మైనస్ I c మాకు KCL చేత IL ఇస్తుంది లేదా మేము ప్రస్తుత డివిజన్ ఫార్ములా IL ను Z3 ప్లస్ Z3 ప్లస్ Z ​​కి సమానంగా ఉపయోగించవచ్చు. 2 ప్లస్ z 4 రెట్లు, నేను మీకు పొందడానికి IL సంఖ్య అవసరం , మరియు ఇప్పుడు మేము ఈ నోడ్ వద్ద KCL సమీకరణాన్ని వివరించే ఫాజర్ రేఖాచిత్రాన్ని గీస్తాము.
ఇక్కడ ఫాజర్ రేఖాచిత్రం మరియు మేము x మరియు y అక్షం కోసం ఒకే స్కేల్‌ని ఉపయోగించామని గమనించండి, ఇది x (x) అక్షం మీద 1 యూనిట్‌ను y (y) అక్షం మీద 1 యూనిట్‌ను సూచించే దూరం.
కోణాలు సరిగ్గా ప్రదర్శించబడేలా మేము దీన్ని చేస్తాము; అంటే మనం ఈ పద్ధతిని పాటిస్తే 45 డిగ్రీల కోణం వాస్తవానికి 45 డిగ్రీల కోణంలా కనిపిస్తుంది.
సరే ఇప్పుడు ఈ నోడ్‌లో KCL సమీకరణం సంతృప్తికరంగా ఉందో లేదో ధృవీకరిస్తాము.I c ప్లస్ IL (IL) కు సమానమైన సమీకరణం ఏమిటి?
మా I (I) 3.58 కోణం 36.08 డిగ్రీలు, ఈ వెక్టర్ మాగ్నిట్యూడ్ 3.58, మరియు ఈ కోణం 36.8 డిగ్రీలు.
ఐసి పరిమాణం 3.7.
కాబట్టి, నాకన్నా కొంచెం పెద్దది మరియు 44.6 డిగ్రీల కోణం, ఈ కోణం 44.6 డిగ్రీలు.
IL ఇది 0.546 మాగ్నిట్యూడ్‌లో చాలా చిన్నది మరియు ప్రతికూల కోణం కలిగి ఉంటుంది, కనీసం 70.6 డిగ్రీలు.
కాబట్టి, ఇది మా IL; ఇప్పుడు మనం సి ప్లస్ IL వాస్తవానికి సమానమని చూస్తాము; దీని అర్థం, KCL ధృవీకరించబడింది.
సరళ DC సర్క్యూట్ల కోసం గరిష్ట విద్యుత్ బదిలీ సిద్ధాంతాన్ని మేము చూశాము; ఇప్పుడు సైనూసోయిడల్ స్థిరమైన స్థితిలో గరిష్ట విద్యుత్ బదిలీని చూద్దాం.
కాబట్టి, ఈ సర్క్యూట్ ద్వారా థెవెనిన్ సమానమైన సర్క్యూట్‌ను ఇక్కడ పరిశీలిద్దాం, అంటే వోల్టేజ్ సోర్స్ V t h సిరీస్‌లో ఇంపెడెన్స్ Z t h; ఈ రెండు కోర్సులు సంక్లిష్ట సంఖ్యలు.
ఇప్పుడు మేము సర్క్యూట్కు లోడ్ ఇంపెడెన్స్ను జోడిస్తాము మరియు దాని ఫలితంగా ఒక కరెంట్ ప్రవహిస్తుంది మరియు కరెంట్ లోని ఈ కరెంట్ స్పేసర్ I చే సూచించబడుతుంది.
ఈ సర్క్యూట్ 2 Z L నుండి విద్యుత్ బదిలీ గరిష్టంగా ఉన్న పరిస్థితిని మేము కనుగొనాలనుకుంటున్నాము.
R L ప్లస్ j x L కి సమానమైన JLL తో ప్రారంభిద్దాం, ఇక్కడ ఇది ZL యొక్క నిజమైన భాగం మరియు ఇది ZL యొక్క inary హాత్మక భాగం మరియు Z t h R t h ప్లస్ j x t h.
I I m phi కోణం, నేను ఇక్కడ ఈ ఫాజర్ I యొక్క పరిమాణం మరియు fi దాని కోణం.
కాబట్టి, Z సమానమైన Z1 ప్లస్ Z3 సమాంతర Z2 ప్లస్ Z4.
ఇప్పుడు, ZL చేత గ్రహించబడిన శక్తి సగం మీటర్ m R RL ఇచ్చిన P కి సమానం, ఇక్కడ I m ఈ ఫేజర్ యొక్క పరిమాణం మరియు RL Z L యొక్క నిజమైన భాగం.
ఏమిటి ఇది నేను యొక్క పరిమాణం, మరియు నేను ఏమిటి? V t h ను Z t h మరియు Z L చే విభజించారు.
కాబట్టి, ఇక్కడ ఈ వ్యక్తీకరణకు సమానమైన p ను పొందుతాము.
ఈ వ్యక్తీకరణను సగం మోడ్ (సగం మోడ్) V t h స్క్వేర్‌గా R t h ప్లస్ R L స్క్వేర్డ్ ప్లస్ X టి హెచ్ ప్లస్ ఎక్స్ ఎల్ స్క్వేర్డ్ మరియు ఆర్ ఎల్ చేత గుణించాలి.
ఇప్పుడు ఈ V t h తరగతి ZL నుండి స్వతంత్రంగా ఉంది మరియు మనకు సంబంధించినంతవరకు అది స్థిరంగా ఉంటుంది.
కాబట్టి, ఇప్పుడు మనం చేయవలసింది ఈ మొత్తం వ్యక్తీకరణ గరిష్టంగా ఉన్న Z పై పరిస్థితులను కనుగొనడం.
ఇప్పుడు, P గరిష్టంగా ఉండటానికి, స్పష్టంగా ఈ హారం కనిష్టంగా ఉండాలి మరియు X వ ప్లస్ XL స్క్వేర్డ్ 0 అయినప్పుడు ఇది జరుగుతుంది, ఎందుకంటే ఇక్కడ ఒక చదరపు ఉంది, ఈ పదాన్ని అతి చిన్న విలువగా తీసుకోవచ్చు. 0 మరియు, అందువల్ల, ఈ రెండవ పదానికి సమానమైన xh తో xh కు సమానమైన x L మైనస్ వ మరియు xl మనకు అదృశ్యమవుతుంది, మరియు మనకు p సమాన rv ప్లస్ rl స్క్వేర్డ్ టైమ్స్ r ను సగం మోడ్ ద్వారా విభజించి V వ చదరపుకి సమానం.
కాబట్టి, గరిష్ట విద్యుత్ బదిలీ కోసం మనం ఇప్పుడు ఈ వ్యక్తీకరణను పెంచాలి.
మేము దీన్ని ఎలా చేయాలి? మేము RL కు సంబంధించి P ను వేరు చేస్తాము మరియు మేము DPD RL ను 0 తో సమానం చేస్తాము మరియు R R R T T కి సమానమైనప్పుడు P గరిష్టంగా ఉంటుందని కనుగొన్నాము.
కాబట్టి, మనకు 2 షరతులు ఉన్నాయి: JL యొక్క inary హాత్మక భాగం X L, ఇది X L యొక్క inary హాత్మక భాగం యొక్క ప్రతికూలానికి సమానంగా ఉండాలి, ఇది X t h మరియు ZL యొక్క వాస్తవ భాగం Z t h యొక్క వాస్తవ భాగానికి సమానంగా ఉండాలి.
లోడ్ ZL లో గరిష్ట విద్యుత్ బదిలీ కోసం సంగ్రహంగా చెప్పాలంటే, మనకు RL మరియు XL కు సమానమైన RL అవసరం, ఇది మైనస్ కంటే తక్కువ; దీని అర్థం, మా లోడ్ ఇంపెడెన్స్ థెవెనిన్ సమానమైన ఇంపెడెన్స్ యొక్క సంక్లిష్ట యాదృచ్చికంగా ఉండాలి, ఇది Z T H.
కాబట్టి, ZL తప్పనిసరిగా Z వ నక్షత్రానికి సమానంగా ఉండాలి.
ఇప్పుడు సైనూసోయిడల్ స్థిరమైన స్థితి కోసం గరిష్ట శక్తి బదిలీ సిద్ధాంతం యొక్క అనువర్తనాన్ని చూద్దాం, ఇది ఆడియో ఇన్పుట్ సిగ్నల్ ద్వారా శక్తినిచ్చే ఆడియో యాంప్లిఫైయర్.
కాబట్టి, ఇక్కడ పౌన encies పున్యాల పరిధి 20 Hz నుండి 16 KHz లేదా అంతకంటే ఎక్కువ ఉంటుంది.
ఈ ఆడియో యాంప్లిఫైయర్ తరువాత ట్రాన్స్ఫార్మర్ ఉంది మరియు ఈ ట్రాన్స్ఫార్మర్ ఎందుకు అవసరమో త్వరలో వ్యాఖ్యానిస్తాము మరియు చివరకు, మనకు ఈ స్పీకర్ ఉంది.
ఈ స్పీకర్ సంక్లిష్ట ఇంపెడెన్స్‌ను కలిగి ఉంటుంది, ఇది ఫ్రీక్వెన్సీతో మారుతుంది, కానీ ఆడియో పరిధిలో దాని నిరోధకత సాధారణంగా 8 ఓంలు (ఓంలు), మరియు దాని inary హాత్మక భాగాన్ని విస్మరించవచ్చు.
అందువల్ల, సమానమైన సర్క్యూట్ ఈ సర్క్యూట్ ద్వారా ఇక్కడ ప్రాతినిధ్యం వహిస్తుంది, ఇక్కడ ఈ మూలం ఆడియో యాంప్లిఫైయర్ యొక్క లాభం ద్వారా విస్తరించబడిన ఇన్పుట్ సిగ్నల్ను సూచిస్తుంది మరియు తరువాత ఈ ఒక నిరోధకత ఆడియో యాంప్లిఫైయర్ యొక్క అవుట్పుట్ నిరోధకత, ఆపై మనకు ట్రాన్స్ఫార్మర్ ఒకటి ఉంది. నిష్పత్తి n 1 2, n 2 మరియు చివరకు, ఈ 8 ఓంల నిరోధకత ద్వారా స్పీకర్ ప్రాతినిధ్యం వహిస్తుంది.
ఈ సర్క్యూట్ నుండి స్పీకర్‌కు విద్యుత్ బదిలీని పెంచడం మా లక్ష్యం, అందువల్ల మేము ఇన్‌పుట్ సిగ్నల్‌తో పెద్ద శబ్దాన్ని వింటాము.
కాబట్టి, సర్క్యూట్‌ను సరళీకృతం చేద్దాం, మేము ఈ ప్రతిఘటనను ట్రాన్స్‌ఫార్మర్ యొక్క మరొక వైపుకు బదిలీ చేయవచ్చు మరియు అది N2 స్క్వేర్డ్ సమయంలో 8 ఓంల ద్వారా N1 అవుతుంది.
ఇక్కడ మా నిజమైన సమస్య ప్రకటన, మేము ఈ సర్క్యూట్‌ను చూస్తాము మరియు ఆడియో సిగ్నల్ యొక్క గరిష్ట శక్తి బదిలీని అందించడానికి ట్విస్ట్ నిష్పత్తిని లెక్కిస్తాము; గరిష్ట విద్యుత్ బదిలీ సిద్ధాంతం ఏమిటి? ఇది ZL తప్పనిసరిగా Z t h నక్షత్రానికి సమానంగా ఉండాలని పేర్కొంది మరియు ఈ సందర్భంలో Z t h మరియు ZL యొక్క inary హాత్మక భాగాలు 0, దీని అర్థం నిజమైన భాగం సమానంగా ఉండాలి; దీని అర్థం, మనకు 1 కి సమానమైన N 1by N 2 చదరపు సార్లు 8 ఓంలు (ఓంలు) ఉండాలి.
ఇప్పుడు మనం ఈ సమీకరణాన్ని n1 కొరకు n2 ద్వారా పరిష్కరించగలము మరియు ఇది n1 ద్వారా n2 ద్వారా 11 గురించి ఇస్తుంది.
అందువల్ల, మేము ఈ అనువాదంతో ట్రాన్స్‌ఫార్మర్‌ను ఎంచుకుంటే, ఆడియో సిగ్నల్ స్పీకర్‌కు గరిష్ట శక్తిని అందిస్తుంది, మరియు ఈ ఇన్‌పుట్ సిగ్నల్‌తో సాధ్యమయ్యే అతి పెద్ద శబ్దాన్ని మేము వింటాము.
ముగింపులో, సైనూసోయిడల్ స్థిరమైన స్థితిలో RLC సర్క్యూట్లను విశ్లేషించడానికి ఫాజర్‌లను ఎలా ఉపయోగించాలో చూశాము; కొంతకాలం తర్వాత ఫిల్టర్ సర్క్యూట్‌ను చూసేటప్పుడు ఈ నేపథ్యం చాలా ఉపయోగకరంగా ఉంటుంది.
సైనూసోయిడల్ స్థిరమైన స్థితిలో ఆర్‌ఎల్‌సి సర్క్యూట్‌ల కోసం గరిష్ట విద్యుత్ బదిలీ సిద్ధాంతాన్ని కూడా చూశాము.
ఆచరణలో చాలా ముఖ్యమైన ఒక ఉదాహరణను మేము పరిగణించాము, అనగా స్పీకర్ నుండి గరిష్ట ఆడియో శక్తిని ఎలా పొందాలో, ఇది ఇప్పుడు ప్రతిదీ.
తరువాత కలుద్దాం
inhouse/NPTEL/PreFinal/c++/Telugu/40 ProgramminginCplusplus_Sorting and Searching (Lecture 06)-0GWWQoMY5Mk.txt
View file @ 956c0d4e

1. C ++  ప్రోగ్రామింగ్ లో మాడ్యూల్  కు స్వాగతం.
2. ఈ మాడ్యూల్ లో మేము సార్టింగ్ మరియు శోధించడం గురించి చర్చిస్తున్నాము.
3. కాబట్టి, లక్ష్యం ఏమిటంటే  C లో క్రమబద్ధీకరించడం మరియు శోధించడం మరియు C ++ తో వాటిని విరుద్ధంగా ఎలా అమలు చేయాలో తెలుసుకోవడం .
4. ఈ అంశాలు  మేము చర్చించబోతున్నాము .
5. కాబట్టి ప్రారంభించడానికి, మీ అందరికీ సార్టింగ్ తెలుసు, మరియు శ్రేణిలో పూర్ణాంకాల సమితిని క్రమబద్ధీకరించడానికి మీరు సి లో అనేక ప్రోగ్రామ్‌లను వ్రాసి ఉండాలి.
6. ఇక్కడ, బబుల్ సార్ట్ అని పిలువబడే సర్వసాధారణమైన సార్టింగ్ అల్గోరిథం మాత్రమే మనకు ఉంది.
7. మీరు బబుల్ రకాన్ని ఉపయోగించవచ్చు లేదా ఉపయోగించకపోవచ్చు; మీరు వేరే ఎంపిక లేదా చొప్పించే విధమైన చేస్తే, ఇది పూర్తిగా మంచిది.
8. తొలగింపులు ఎలా జరుగుతాయో అనే తర్కంలోకి మేము వెళ్ళడం లేదు.
9. నేను చూపించదలిచినది రెండు నిలువు వరుసల మధ్య; ఎడమవైపు సి ప్రోగ్రామ్, కుడివైపు సి ++ ప్రోగ్రామ్.
10. ఇద్దరూ ఒకే వ్యూహాన్ని, ఒకే అల్గారిథమ్‌ను ఉపయోగించి బబుల్‌ను క్రమబద్ధీకరించడానికి ప్రయత్నిస్తున్నారు; మరియు, వాటి మధ్య మీరు చూడగలిగే ఏకైక తేడా ఏమిటంటే IO హెడర్స్ మరియు STD నేమ్‌స్పేస్‌ల వాడకం.
11. ఇప్పటివరకు మొత్తం అల్గోరిథం సంబంధించినది, కోడ్ సంబంధించినది, శ్రేణులు మరియు పోలికలు సంబంధించినవి, ఇది ఒకటే.
12. కాబట్టి, మనం తీసుకునే మొదటి పాఠం ఏమిటంటే, సి లో వ్రాసిన ఏదైనా సార్టింగ్ కోడ్‌ను సి ++ లో గుర్తించవచ్చు.
13. ఇప్పుడు, నేను స్పష్టం చేయాలనుకుంటున్నాను, నేను సంఖ్యల సమూహాన్ని లేదా తీగల సమితిని క్రమబద్ధీకరించాల్సిన అవసరం ఉంటే, నేను ప్రతిసారీ ఒక సార్టింగ్ ప్రోగ్రామ్‌ను వ్రాస్తాను? నేను అల్గోరిథంలు నేర్చుకోవడానికి ప్రయత్నిస్తున్నప్పుడు లేదా నేను భాషలను నేర్చుకోవడానికి ప్రయత్నిస్తున్నప్పుడు నేను దీన్ని చేస్తాను, కాని తరువాత నేను సంఖ్యల సమితిని క్రమబద్ధీకరించాలనుకుంటే, నేను అల్గోరిథం రాయను బదులుగా, నేను మళ్ళీ ప్రామాణిక లైబ్రరీకి వెళ్లి ప్రామాణిక లైబ్రరీ అందించే వాటిని ఉపయోగించడానికి ప్రయత్నిస్తాను.
14. ఇప్పుడు, మేము ఎడమ కాలమ్ పై దృష్టి పెడతాము, ఇది సి ప్రోగ్రామ్.
15. <stdlib.h> హెడర్‌లో, సి ప్రామాణిక లైబ్రరీలో అందించిన సార్టింగ్ ఫంక్షన్‌ను ఉపయోగిస్తోంది.
16. ఈ ఫంక్షన్‌ను Q సార్టింగ్ అంటారు.
17. ఈ ఫంక్షన్ శీఘ్ర క్రమబద్ధీకరణను అంతర్లీన సార్టింగ్ అల్గోరిథం వలె ఉపయోగిస్తుందనే వాస్తవాన్ని ఈ పేరు ఖచ్చితంగా సూచిస్తుంది.
18. ఇప్పుడు, Q ను సార్ట్ ఫంక్షన్ అని ఎలా పిలుస్తారో గమనించండి.
19. 4 పారామితులు ఉన్నాయని మీరు చూడవచ్చు.
20. కాబట్టి మీరు Q క్రమబద్ధీకరణ ప్రోగ్రామ్‌కు ఏమి చెప్పాలో చూద్దాం, తద్వారా ఇది మీ డేటాను క్రమబద్ధీకరించగలదు.
21. ఖచ్చితంగా, డేటా ఎక్కడ ఉందో మీరు వివరించాలి.
22. కాబట్టి, ఇది కంటైనర్, ఇది ఇక్కడ శ్రేణి డేటా.
23. కాబట్టి, ఇది మొదటి పరామితి.
24. ఇప్పుడు, శ్రేణిలోని ఎన్ని అంశాల అయినా మూలకాల సంఖ్య అవుతుంది; Q ఎలా క్రమబద్ధీకరిస్తుంది, ఎన్ని అంశాలు ఉన్నాయో లేదా వాటిలో ఎన్ని ఉన్నాయో తెలుసుకోండి, వాటిలో ఎన్ని మీరు క్రమబద్ధీకరించాలనుకుంటున్నారు.
25. కాబట్టి, రెండవ పరామితి Q క్రమబద్ధీకరణ మీరు ఎన్ని శ్రేణి అంశాలను క్రమబద్ధీకరించాలనుకుంటున్నారో చెబుతుంది.
26. దీని అర్థం మీరు ఎల్లప్పుడూ ఇండెక్స్ 0 తో ప్రారంభించి, రెండవ పరామితిలో పేర్కొన్నన్ని అంశాలను తీసుకోండి.
27. కాబట్టి, ఇక్కడ రెండవ పరామితి 5, అంటే Q డేటా శ్రేణిని సీరియల్ 0 నుండి ఇండెక్స్ 4 కు క్రమబద్ధీకరించాలి, ఈ సందర్భంలో మొత్తం శ్రేణి (క్రమబద్ధీకరణ). శ్రేణి).
28. మూడవ పరామితి కొంచెం గమ్మత్తైనది, మరియు మూడవ పరామితి ఎందుకు అవసరమో మీకు ఇప్పుడు అర్థం కాలేదు.
29. మూడవ పరామితి దయచేసి ప్రతి మూలకం యొక్క పరిమాణాన్ని బైట్లలో అందించండి.
30. ఇప్పుడు, ఇది పూర్ణాంక శ్రేణి, అంటే ప్రతి మూలకం పూర్ణాంకం (పూర్ణాంకానికి).కాబట్టి, ప్రతి మూలకం యొక్క పరిమాణాన్ని సి లోని సైజుఆఫ్ ఆపరేటర్ ఉపయోగించి లెక్కించవచ్చు, కాబట్టి మీరు సైజ్ఆఫ్ (పూర్ణాంకానికి) ను పేర్కొనండి, ఇది 32 బిట్ సిస్టమ్ కోసం 4 ను దాటిపోతుంది, ఎందుకంటే పూర్ణాంకానికి (పూర్ణాంకానికి), సాధారణంగా పరామితి మూడవదిగా ప్రాతినిధ్యం వహిస్తుంది 32 బిట్స్‌లో 4 బైట్లు.
31. కాబట్టి, ప్రతి మూలకం యొక్క పరిమాణాన్ని సి లోని సైజుఆఫ్ ఆపరేటర్ ఉపయోగించి లెక్కించవచ్చు, కాబట్టి మీరు సైజ్ఆఫ్ (పూర్ణాంకానికి) ను పేర్కొనండి, ఇది 32 బిట్ సిస్టమ్ కోసం 4 ను దాటిపోతుంది, ఎందుకంటే పూర్ణాంకానికి (పూర్ణాంకానికి), సాధారణంగా పరామితి మూడవదిగా ప్రాతినిధ్యం వహిస్తుంది 32 బిట్స్‌లో 4 బైట్లు.
32. మాకు అవసరమైనదాన్ని నిజంగా అర్థం చేసుకోవడం మీకు కష్టంగా ఉండవచ్చు, కాని ప్రాథమిక వాదన ఏమిటంటే, Q శ్రేణికి మీ శ్రేణిలో ఏ రకమైన డేటా ఉందో తెలియదు, మూలకం రకంలో తేడా ఉంటుంది. సంభవించవచ్చు; ఇది నాలుగు రకాల అంశాలను కలిగి ఉంటుంది; ఇది కోణాల రూపం యొక్క అంశాలను కలిగి ఉండవచ్చు; ఇది నిర్మాణ రకం యొక్క అంశాలను కలిగి ఉంటుంది; ఇండెక్స్ చేయబడిన మూలకం యొక్క చిరునామాను పొందిన తరువాత Q (Q) మొదట సూచిక చేయబడిన మూలకాన్ని గుర్తించాలని కనుగొనడం సాధ్యం కాదు.
33. అందువల్ల, మూలకం యొక్క పరిమాణం తెలిస్తే, అది మొదటి మూలకాన్ని పొందడానికి శ్రేణి యొక్క ప్రారంభ చిరునామాకు ఆఫ్‌సెట్‌గా జోడించగలదు.
34. రెండవ మూలకం యొక్క చిరునామాను పొందడానికి మొదటి మూలకం యొక్క స్థానానికి మళ్ళీ అదే పరిమాణంలో పూర్ణాంకాన్ని జోడించవచ్చు.
35. కాబట్టి, మీకు ఈ సమాచారం అవసరమయ్యే అమలు ఇది.
36. కాబట్టి, ఇది మూడవ పరామితి.
37. నాల్గవ పరామితి అత్యంత ఆసక్తికరమైనది.
38. నాల్గవ పరామితి ఫంక్షన్ పాయింటర్.
39. మాడ్యూల్ 1 లో, మేము ఫంక్షన్ పాయింటర్ల గురించి లోతుగా మాట్లాడామని మీరు గుర్తుంచుకుంటారు.
40. మేము దాన్ని మళ్ళీ చేర్చుకున్నాము మరియు మీరు మీ దృష్టిని పైకి కదిలిస్తే, చేర్చండి మరియు ప్రధానంగా ఫంక్షన్ పాయింటర్ నిర్వచించబడిందని మీరు కనుగొంటే, Q (Q) క్రమబద్ధీకరణ (క్రమబద్ధీకరణ).
41. ఇప్పుడు, ఈ తులనాత్మక పని యొక్క పాత్ర ఏమిటి? ఈ పోలిక ఫంక్షన్ 2 విలువలను పోల్చి, ఏది చిన్నది లేదా రెండవది చిన్నదో చెబుతుంది.
42. ఇక్కడ, మనకు పోలిక ఫంక్షన్ చూపబడింది, ఇక్కడ మనం పోలికగా తక్కువగా ఉపయోగిస్తున్నాము.
43. మొదటిది మరొకదాని కంటే చిన్నదిగా ఉంటే, అది నిజం అవుతుంది మరియు లేకపోతే అది తప్పుడుదాన్ని తిరిగి ఇస్తుంది.
44. తులనాత్మక పని యొక్క ప్రాథమిక ఉద్దేశ్యం ఇది.
45. వేరే ఫంక్షన్ (ఫంక్షన్), పాయింటర్ (పాయింటర్) ఫంక్షన్ (ఫంక్షన్) వ్రాసి, ఆ ఫంక్షన్ (ఫంక్షన్) పాయింటర్ (పాయింటర్) ను పాస్ చేయడం వంటి క్లిష్టమైన పనిని నేను ఎందుకు చేయవలసి వచ్చిందో ఇప్పుడు మీరు ఆశ్చర్యపోతున్నారు.
46. Q లైబ్రరీలో క్రమబద్ధీకరించబడినప్పుడు లేదా మీరు ఇప్పుడు Q రకం యొక్క ఫంక్షన్‌ను వ్రాయాలనుకుంటే మరియు ఏ రకమైన మూలకాలను క్రమబద్ధీకరించాలో మీకు చెప్పబడలేదు, కాబట్టి ఎలా పోల్చాలో మీకు ఎలా తెలుసు? ఆ అంశాలు? ఉదాహరణకు, పూర్ణాంకానికి చాలా తేలికగా పోల్చవచ్చు, కాని నేను పూర్ణాంకానికి బదులుగా చెప్పినట్లయితే, నేను ఇప్పుడు మీకు తీగలను ఇస్తే.
47. ఇప్పుడు, తీగల శ్రేణిని సి లో ఎక్కువ లేదా తక్కువ రాయడం తో పోల్చలేము.
48. మేము C ++ స్ట్రింగ్ గురించి మాట్లాడటం లేదు, పోలిక ఆపరేటర్ మీకు ఇప్పటికే తెలుసు.
49. కాబట్టి, సి లో నేను తీగలను పోల్చవలసి వస్తే నా విలువలు వాస్తవానికి అక్షరానికి సూచించబడతాయి, కాని నేను కొన్నింటిని బిగింపు () ఫంక్షన్ (ఫంక్షన్) వాడకంతో పోల్చాను.
50. ఇప్పుడు Q రకాన్ని ఎలా తెలుసుకోవాలి, Q సార్టింగ్ మీరు వాటిని పోల్చడానికి Q ఎలాంటి డేటాను ఇస్తారో తెలియదు, Q సార్టింగ్ కూడా అలాంటి 2 డేటా ఐటెమ్‌లను ఎలా పోల్చాలో తెలియదు.
51. మరియు ఫంక్షన్‌ను Q క్రమబద్ధీకరణతో పోల్చడం మీ బాధ్యత.
52. కాబట్టి మీరు ఈ నాల్గవ పరామితిని కలిగి ఉండాలి, ఇది ఫంక్షన్ పాయింటర్ యొక్క పోలిక.
53. మీరు శీర్షికలో చూస్తే, ఫంక్షన్ పాయింటర్ యొక్క సంతకం మీకు మరింత బాధించేదాన్ని ఇస్తుంది.
54. పారామితులను తెలియని రకం యొక్క స్థిరమైన డేటా కోసం const పాయింటర్లుగా ఉండే const void * గా ప్రకటించడాన్ని మీరు చూడవచ్చు, ఇది ఎందుకు? ఎందుకంటే మళ్ళీ, Q కి సార్టింగ్ ఫంక్షన్ (ఫంక్షన్) పాయింటర్ కోసం సంతకం ఉండకూడదు, ఎందుకంటే దీనికి డేటా ఐటెమ్ రకం తెలియదు.
55. అందువల్ల, ఇవన్నీ మీకు తెలియని కొన్ని రకాల సూచికను కలిగి ఉన్నాయని అనుకుంటాయి మరియు మీకు రకం తెలియదు కాబట్టి, పోలిక ఫంక్షన్ యొక్క రిటర్న్ స్టేట్మెంట్లో మీరు నిజంగా పోల్చాలనుకున్నప్పుడు, మీరు మొదట కంపైలర్కు చెప్పాలి వాస్తవానికి, ఇప్పుడు నేను కలిగి ఉన్నది పూర్ణాంకం.
56. కాబట్టి, మీరు మొదట పాయింటర్ (పాయింటర్) ను పూర్ణాంకానికి (పూర్ణాంకానికి) రద్దు చేస్తారు, ఆపై మీరు పూర్ణాంక విలువను పొందడానికి ఆ పూర్ణాంక పాయింటర్ (పాయింటర్) ను సూచిస్తారు, ఆపై మీరు పూర్ణాంకం యొక్క రెండు పూర్ణాంక విలువలను జోడిస్తారు. పోల్చుకుందాం.
57. అందువల్ల, Q- కత్తిరించడం కోసం ఇంకా చాలా అవసరం.
58. టైప్ సి స్టాండర్డ్ లైబ్రరీలో డిఫాల్ట్ సార్టింగ్ అల్గోరిథం వలె Q (Q) అందుబాటులో ఉన్నప్పటికీ, Q సమాజంలో Q (sort) వాడకం అంతగా ప్రాచుర్యం పొందలేదు.
59. తరచుగా, ప్రజలు తమ సొంత రచనలు రాయడానికి ఇష్టపడతారు; బబుల్ సార్ట్, సెలెక్షన్ సార్ట్ లేదా ఇన్సర్షన్ సార్ట్, సార్ట్, మరియు టైప్ డేటా యొక్క మూలకాలకు వారు క్రమబద్ధీకరించాలనుకునే అంశాలను ఇస్తారు మరియు అదే వాడాలి.
60. ఇప్పుడు కాలమ్ యొక్క కుడి వైపు చూడండి.
61. C ++ దీన్ని చేసే విధానం, IO పరంగా నేను తేడాలు చూడను, మీకు ఇప్పటికే తెలుసు.
62. మీరు చేరిక పరంగా దృష్టి పెట్టాలి, మేము అల్గోరిథం అని పిలువబడే మరొక C ++ ప్రామాణిక లైబ్రరీ హెడర్‌ను చేర్చుతాము, ఇది చాలా ఆసక్తికరంగా ఉంటుంది.
63. అల్గోరిథం అనేది మీ ప్రోగ్రామ్‌లలో మీరు తరచుగా ఉపయోగించాల్సిన చాలా అల్గోరిథం కోడ్‌ను కలిగి ఉన్న హెడర్.
64. కాబట్టి, అల్గోరిథం ఒక భాగం, క్రమబద్ధీకరణ అల్గోరిథం కలిగి ఉంటుంది.
65. కాబట్టి, మీరు C లో C లో క్రమబద్ధీకరించేది, అల్గోరిథంలో ఈ భాగాన్ని C ++ లో క్రమబద్ధీకరించడం అంటారు.
66. మేము మళ్ళీ అదే డేటాను క్రమబద్ధీకరిస్తున్నాము; మేము మళ్ళీ అదే క్రమంలో క్రమబద్ధీకరిస్తున్నాము.
67. క్రమబద్ధీకరించడానికి నేను ఏమి పేర్కొనాలి, పారామితులను చూద్దాం.
68. ఖచ్చితంగా, నేను కంటైనర్ లాగా కంటైనర్లో ఏమి చేసాను.
69. రెండవది నేను మొదటి నుండి ఎన్ని అంశాలు ఉన్నాయో చెప్పాలి, ఇక్కడ మనం దానిని కొద్దిగా భిన్నంగా పేర్కొంటాము.
70. Q క్రమబద్ధీకరణలో, మేము మూలకాల సంఖ్యను మాత్రమే పేర్కొన్నాము; ఇక్కడ మనం ధ్యానం చేసిన తర్వాత మొదటి మూలకానికి పాయింటర్‌ను పాస్ చేస్తాము.
71. కాబట్టి, మేము `డేటా + 5 'ను పాస్ చేస్తాము, అంటే మనం పాయింటర్‌ను 5 మూలకాల సూచికకు పంపుతాము, అంటే మనం క్రమబద్ధీకరించాలనుకుంటున్న శ్రేణి యొక్క భాగానికి వెలుపల ఉంది.
72. మరో మాటలో చెప్పాలంటే, డేటాతో ప్రారంభమయ్యే 5 అంశాలను మీరు క్రమబద్ధీకరిస్తారా? మేము ఈ వివరాలను తరువాత చూస్తాము, దీనిని C ++ లో పరిమితి అంటారు.
73. మూడవ పరామితి ఒక విధమైన Q గా అవసరం లేదు, ఎందుకంటే మీరు ఇప్పటికే చూసినట్లుగా, C ++ కంపైలర్ రకం ఆధారంగా వస్తువులను కత్తిరించగలదు.
74. కాబట్టి టైప్ చేయండి, డేటా ఇంటెంట్ (పూర్ణాంకానికి) టైప్ అర్రే అని తెలుసు.
75. కాబట్టి, మూలకాలు అవకలన రకంగా ఉంటాయి.
76. కాబట్టి, మీరు పరామితిగా Int (int) పరిమాణాన్ని విడిగా పేర్కొనవలసిన అవసరం లేదు.
77. విధమైన మూడవ పరామితి మీరు పోలిక అల్గోరిథం ఇవ్వాల్సిన విధమైన నాల్గవ పరామితికి సమానంగా ఉంటుంది.
78. ఇది ఖచ్చితంగా తీసివేయబడదు, ఎందుకంటే మీ పోలిక వ్యూహం మీ వద్ద ఉన్న డేటాను బట్టి మారుతుంది.
79. కానీ, ఇది చాలా ముఖ్యం, మీరు మళ్ళీ మీ దృష్టిని C ++ విభాగంలో ఈ పోలిక ఫంక్షన్ నిర్వచించిన చోటికి మార్చినట్లయితే.
80. కాస్ట్ శూన్యమైన * రకం లేదా వ్యక్తీకరణ యొక్క పారామితులను ఉపయోగించి, కాస్టింగ్ మరియు డి-రిఫరెన్సింగ్‌ను పూర్తిగా చేసే సి లో మీకు సంక్లిష్టత లేదు.
81. ఇప్పుడు, మీరు ఒక సాధారణ ఫంక్షన్, int i, int j విషయంలో డిక్లేర్ చేసినట్లే పారామితులను డిక్లేర్ చేయవచ్చు మరియు బదులుగా మీరు పోల్చండి, తులనాత్మక వాదన ఏదైనా మనం ఇక్కడ వ్రాస్తాము.
82. ఇది సాధారణ పోలిక ఫంక్షన్ లాగా ఉంటుంది మరియు ఇది పాయింటర్; ఫంక్షన్ పేరు మూడవ పరామితిగా ఇవ్వబడుతుంది.
83. మీరు దీన్ని C ++ లో చేయవచ్చు, ఎందుకంటే C ++ లో ఇలాంటి లక్షణాలు చాలా ఉన్నాయి, వీటిని మేము క్రమంగా మీకు పరిచయం చేస్తాము.
84. కాబట్టి, సి లో ఇది ఎందుకు సాధ్యం కాలేదని మీరు అర్థం చేసుకుంటారు, కాని సి ++ లో సార్టింగ్ ఫంక్షన్ ఇప్పటికే తెలియని దానితో పోల్చదగిన ఫంక్షన్‌ను వ్రాయడం సాధ్యమవుతుంది, కాని అప్పుడు కూడా దానిని గ్రహించగలుగుతారు.
85. కాబట్టి, ప్రామాణిక లైబ్రరీ నుండి క్రమబద్ధీకరించబడిన ప్రోగ్రామ్‌ను ఉపయోగించడం చాలా సొగసైనది మరియు సమర్థవంతమైనది.
86. మరియు ఫలితం ఏమిటంటే, C ++ ప్రోగ్రామర్లు వాస్తవానికి వారి స్వంత క్రమబద్ధీకరించిన ప్రోగ్రామ్‌లను వ్రాస్తున్నప్పుడు, వారు ఇక్కడ ఇచ్చిన రకాన్ని ఉపయోగిస్తారు.
87. గమనించడానికి చిన్న సూక్ష్మ నైపుణ్యాలు ఉన్నాయి; సార్టింగ్ దిశ యొక్క సమావేశం, ఇది తగ్గుతున్న క్రమం లేదా పెరుగుతున్న ఆర్డర్ Q అయినా, క్రమబద్ధీకరణ అమలు మరియు క్రమబద్ధీకరణ అమలు మధ్య మారుతూ ఉంటుంది.
88. కాబట్టి, మీరు వ్రాసిన రెండు తులనాత్మక ఫంక్షన్లపై మీరు మళ్ళీ దృష్టి పెడితే, సి లో మనం నిజం కంటే తక్కువగా ఉపయోగించామని, సి ++ లో మనం నిజం కంటే ఎక్కువ ఇచ్చామని మీరు కనుగొంటారు. ఎందుకంటే రెండు సందర్భాల్లోనూ మనం కోరుకుంటున్నాము అవరోహణ క్రమంలో చేయాలి.
89. కాబట్టి, ఇది సి ++ క్రమంలో ఉన్న సమావేశానికి సంబంధించిన విషయం.
90. ఈ విధమైన రకం యొక్క మరొక వెర్షన్ ఇది.
91. ఇక్కడ, మీరు సార్ట్ ఫంక్షన్ యొక్క కాల్ వద్ద ప్రత్యేకంగా చూస్తే, మొదటి రెండు పారామితులు ఉన్నాయని మీరు చూస్తారు, కానీ మూడవ పరామితి లేదు, ఇక్కడ తులనాత్మక ఫంక్షన్ అందించబడలేదు.
92. ఇది సి ++ ప్రామాణిక లైబ్రరీ మిమ్మల్ని అనుమతించే షార్ట్ కట్; మీరు C ++ యొక్క అంతర్నిర్మిత రకాలను కలిగి ఉన్న C ++ రకాలను క్రమబద్ధీకరించడానికి ప్రయత్నిస్తుంటే, తులనాత్మక ఫంక్షన్‌ను అందించడం ఐచ్ఛికం.
93. పోలిక ఫంక్షన్‌ను అందించడం అవసరం లేదు మరియు మీరు దానిని అందించకపోతే, అప్రమేయంగా సార్టింగ్ ఆరోహణ క్రమంలో జరుగుతుంది.
94. మీరు ఇంకా ఈ శ్రేణిని అవరోహణ క్రమంలో క్రమబద్ధీకరించాలనుకుంటే, మీరు మళ్ళీ ఒక తులనాత్మక ఫంక్షన్‌ను అందించాల్సి ఉంటుంది ఎందుకంటే మీ పోలిక యొక్క దిశ, అంటే మొదటి పారామితి (పరామితి) రెండవదానికంటే ఎక్కువ. నిజం లేదా లేకపోతే, సార్టింగ్ మధ్య తేడా ఉంటుంది సార్టింగ్ మరియు అవరోహణ సార్టింగ్.
95. తరువాత, మేము బైనరీ శోధనకు వెళ్తాము.
96. మనందరికీ తెలిసినట్లుగా, బైనరీ శోధన అనేది ప్రోగ్రామింగ్‌లో తరచుగా ఉపయోగించే అల్గోరిథం, ఇది మూలకాల శ్రేణిని ఇస్తుంది, ఇవి ఇప్పటికే క్రమబద్ధీకరించబడ్డాయి.
97. ఒక బైనరీ శోధన ఆ శ్రేణిలో ఇచ్చిన కీ ఉందో లేదో తెలుసుకోవచ్చు, అలా అయితే, శ్రేణిలోని ఆ మూలకం యొక్క స్థానం ఏమిటో కూడా చెప్పగలదు. ఇది, సాధారణ శోధన విధానం, ఇది అత్యంత సమర్థవంతమైనది.
98. మరియు, సి మరియు సి ++ రెండూ ప్రామాణిక లైబ్రరీలలో బైనరీ శోధనలు చేయటానికి యంత్రాంగాలు.
99. C లో, ఇది మళ్ళీ <stdlib.h> లో లభిస్తుంది.
100. ఇది బి సెర్చ్ అనే ఫంక్షన్.
101. C ++ లో, ఇది మళ్ళీ కాంపోనెంట్ అల్గోరిథంతో లభిస్తుంది మరియు దీనిని బైనరీ అండర్ స్కోర్ సెర్చ్ అంటారు.
102. మేము ఆ 'bsearch' చూస్తే; ఎడమ చేతి వైపు సి ఎలా ఉపయోగించబడుతుంది, అప్పుడు మొదటి పరామితి ఒక కీ.
103. కీ దాని చిరునామాగా పాస్ చేయబడాలి, కాబట్టి మీరు పాస్ & కీ.
104. దీన్ని చేయడానికి ఒక కారణం ఏమిటంటే, మీరు దీన్ని చేయవలసి ఉంది, ఎందుకంటే మళ్ళీ, మీకు శ్రేణిలో ఉన్న మూలకాల రకం మీకు తెలియదు, అందువల్ల మీరు వెతకాలని కోరుకునే కీ రకం. హుహ్.
105. కాబట్టి, కీ రకం మీకు సాధారణంగా తెలియదు.
106. అందువల్ల, మీరు దానితో 'bsearch' రాయలేరు.
107. కాబట్టి మీరు మళ్ళీ పాయింటర్‌ను పూర్ణాంకానికి (పూర్ణాంకానికి) ఉపయోగించవచ్చనే వాస్తవాన్ని ఉపయోగించుకోండి మరియు పాయింటర్ శూన్యంగా ఉండాలని భావిస్తారు.
108. కాబట్టి, bsearch శూన్యమైన మొదటి పరామితిని ఉపయోగిస్తుంది *.
109. అందుకే మీరు దీనికి చిరునామా ఇవ్వాలి.
110. రెండవ పరామితి మీరు కనుగొనాలనుకుంటున్న శ్రేణి, వాస్తవానికి ఇది క్రమబద్ధీకరించబడాలి.
111. మూడవ పరామితి మూలకాల సంఖ్య.
112. ఇది Q సార్ట్ లాగా చాలా అందంగా ఉంటుంది.
113. నాల్గవ పరామితి ప్రతి మూలకం యొక్క పరిమాణం మరియు ఐదవ పరామితి పోలిక ఫంక్షన్ యొక్క పనితీరుకు పాయింటర్.
114. గమనించదగ్గ విషయం ఏమిటంటే, బైనరీ శోధనను క్రమబద్ధీకరించడానికి విరుద్ధంగా మూడు విధాలుగా నిర్ణయించవలసి ఉంది, ఇక్కడ మీరు తెలుసుకోవలసినది తక్కువ లేదా కాదా అనేది తెలుసుకోవాలి, కానీ బైనరీ శోధనలో, ఇది శ్రేణిలో ఒక నిర్దిష్ట మూలకం కోసం వెతుకుతోంది , ఇది 3 అవకాశాలతో వ్యవహరించాలి.
115. ఒకటి, అతను చూస్తున్న మూలకం, వాస్తవానికి కీకి సమానంగా ఉంటుంది, కాబట్టి మీరు శోధనతో పూర్తి చేస్తారు.
116. కాబట్టి, మీరు ఏమీ చేయనవసరం లేదు, మీరు శ్రేణి యొక్క స్థానం యొక్క సూచిక విలువను తిరిగి ఇస్తారు.
117. రెండవది, దాని కంటే తక్కువగా ఉండవచ్చు.
118. మీరు మీ శ్రేణిని ఆరోహణ క్రమంలో కలిగి ఉంటే మరియు మీ విలువ మీరు చూస్తున్న మూలకం కంటే తక్కువగా ఉంటే, అప్పుడు మీ కీ మీరు చూస్తున్న మూలకం కంటే తక్కువగా ఉంటుంది, మీకు కావాలి అని మీకు తెలుసు ఈ భాగం శ్రేణిలో చూడాలి .
119. మరియు మూడవ సందర్భంలో, మీరు శ్రేణి యొక్క కుడి వైపు చూడాలి.
120. కాబట్టి, మీ తులనాత్మక ఫంక్షన్ మూడు విధాలుగా పనిచేయాలి, మనకు సి స్ట్రింగ్ (. స్ట్రింగ్) .h ప్రామాణిక లైబ్రరీలో ఉన్న strcmp () లాగా.
121. బట్టి ఇక్కడ ఎగువన, మైనస్ 1, 0 లేదా ప్లస్ 1 తో మేము వ్యవహరిస్తున్న అటువంటి తులనాత్మక ఫంక్షన్ కోసం మీరు ఎలా వ్రాయవచ్చో చూపిస్తాను.
122. మరియు, పారామితులను శూన్యమైన * పాయింటర్ (లు) గా ఉపయోగించడం మరియు వాటిని ప్రసారం చేయడం, వాటిని డీఫరెన్సింగ్ చేయడం, Q (Q) విషయంలో మేము చేసినట్లుగా, అన్ని సూక్ష్మ నైపుణ్యాలు కూడా ఈ సందర్భంలో చేర్చబడతాయి.
123. దీని కోసం, C ++ ఫారమ్ చూడండి.
124. అల్గోరిథం భాగం నుండి బైనరీ _ సెర్చ్ () ఫంక్షన్ మొదటి పరామితిని కంటైనర్‌గా తీసుకుంటుంది, ఇది డేటా, రెండవ పరామితి పారామితి పరిధి ముగింపు.
125. మనం చూసినట్లుగా ఇది చాలా ఉంది.
126. మరియు ఇది మూడవ పరామితిని తీసుకుంటుంది, ఇది కీ.
127. మరియు ఇక్కడ, నేను ఒక ఉదాహరణను చూపిస్తున్నాను, ఇక్కడ తులనాత్మక ఫంక్షన్ స్పష్టంగా అందించబడలేదు, ఎందుకంటే నేను ఇప్పటికే అలాంటి సందర్భంలో చర్చించినట్లుగా, మీరు కంపైలర్‌లో నిర్మించిన రకం యొక్క మూలకాల కోసం శోధిస్తుంటే, పోలిక ఎలా ఉందో మాకు ఇప్పటికే తెలుసు పూర్తి.
128. కాబట్టి, పోలిక కోసం మీరు ఫంక్షన్ పాయింటర్‌ను స్పష్టంగా ఉంచాల్సిన అవసరం లేదు.
129. మరియు, దీనితో, బైనరీ శోధన ఉంటుంది.
130. మీరు రెండింటినీ పోల్చి చూస్తే, మీరు C ++ లో బైనరీ శోధనను సులభంగా ఉపయోగించవచ్చు.
131. వాడకం సౌలభ్యం కంటే చాలా ఎక్కువ ఉంది, బైనరీ శోధన చాలా తరచుగా C ++ లో ఉపయోగించబడుతుంది మరియు ఎవరూ ఏ రకమైన డేటా కంటైనర్ కోసం బైనరీ సెర్చ్ ప్రోగ్రామ్‌ను వ్రాయరు.ఒకరికి ఉంది.
132. ప్రత్యేకించి, ఈ అల్గోరిథం లైబ్రరీలో ఇది చాలా ఆసక్తికరమైన లైబ్రరీ, ఎందుకంటే ఇది ఏమిటంటే, మీరు సి ++ ఉపయోగిస్తుంటే, మేము మీకు సాధారణ అల్గోరిథంల సమితిని ఇస్తాము.
133. అందువల్ల, అల్గోరిథం లైబ్రరీ నుండి మరింత శోధనను ఎలా ఉపయోగించవచ్చో మనం చూశాము.
134. మూలకాలను ప్రత్యామ్నాయం చేయడం, మూలకాల క్రమాన్ని తిప్పడం వంటివి ఇంకా చాలా ఉన్నాయి.
135. కాబట్టి, ఇవి తిరగడానికి, కోడ్‌ను మార్చడానికి ఉదాహరణలు.
136. మేము వాటి ద్వారా దశలవారీగా నడవము.
137. ఇప్పటికి, దాన్ని అర్థం చేసుకోవడానికి ఏమి ఉపయోగించాలో మీకు తెలిసి ఉండాలి.
138. దయచేసి ఈ అల్గోరిథంల వివరాల కోసం మాన్యువల్ లేదా పుస్తకాన్ని చూడండి మరియు వాటిని ఉపయోగించడం ప్రారంభించండి.
139. అల్గోరిథం లైబ్రరీలను ఉపయోగించడం వల్ల C ++ లో విషయాలు రాయడం చాలా సులభం అని మీరు కనుగొంటారు, ఎందుకంటే చాలా సాధారణ అల్గోరిథంలు ఇప్పటికే అందుబాటులో ఉన్నాయి మరియు ఉపయోగించడానికి చాలా సులభం.
140. ఈ మాడ్యూల్‌లో, సి ++ లో ప్రాథమిక సార్టింగ్ మరియు సెర్చ్ ఎలా మెరుగ్గా మరియు మెరుగ్గా చేయవచ్చో మేము చూపించాము మరియు సి అని మేము ప్రత్యేకంగా వివరిస్తాము, సి కాకుండా మన స్వంత సార్టింగ్ కోడ్ మరియు సెర్చ్ కోడ్‌ను సి ++ లో తరచుగా వ్రాస్తాము.
141. అలా చేయడానికి ఎటువంటి కారణం ఉండదు.
142. మేము ఏ రకమైన కంటైనర్ మరియు డేటా ఉపయోగిస్తున్నా, విలీనం, స్వాప్, డిలీట్, ఇవన్నీ భిన్నంగా మనం ఉపయోగించాల్సిన అనేక ఇతర అల్గోరిథంలకు కూడా ఇది నిజమని మేము చూపిస్తాము.
143. మరియు, ఈ అల్గోరిథమిక్ భాగాలను అధ్యయనం చేయడానికి మరియు వాటిని ఉపయోగించడం ప్రారంభించడానికి నేను మిమ్మల్ని ప్రోత్సహిస్తాను.
144. ఆపై మొత్తం యొక్క అందం ఉంది, మీరు నిజంగా చాలా C + గురించి తెలుసుకోవలసిన అవసరం లేదు, ఎందుకంటే మీరు వాటిని ఉపయోగించగలగాలి, ఎందుకంటే వాటిని ఉపయోగించడం వారి రూపకల్పన మరియు వారు చేసే విధానంతో చాలా సౌకర్యంగా ఉంటుంది వ్యవస్థీకృతమై ఉంది మరియు మీరు మాన్యువల్ నుండి అధ్యయనం చేయవచ్చు మరియు వాటిని ఉపయోగించడం ప్రారంభించవచ్చు.
145.
 C ++  ప్రోగ్రామింగ్ లో మాడ్యూల్  కు స్వాగతం.
ఈ మాడ్యూల్ లో మేము సార్టింగ్ మరియు శోధించడం గురించి చర్చిస్తున్నాము.
కాబట్టి, లక్ష్యం ఏమిటంటే  C లో క్రమబద్ధీకరించడం మరియు శోధించడం మరియు C ++ తో వాటిని విరుద్ధంగా ఎలా అమలు చేయాలో తెలుసుకోవడం .
ఈ అంశాలు  మేము చర్చించబోతున్నాము .
కాబట్టి ప్రారంభించడానికి, మీ అందరికీ సార్టింగ్ తెలుసు, మరియు శ్రేణిలో పూర్ణాంకాల సమితిని క్రమబద్ధీకరించడానికి మీరు సి లో అనేక ప్రోగ్రామ్‌లను వ్రాసి ఉండాలి.
ఇక్కడ, బబుల్ సార్ట్ అని పిలువబడే సర్వసాధారణమైన సార్టింగ్ అల్గోరిథం మాత్రమే మనకు ఉంది.
మీరు బబుల్ రకాన్ని ఉపయోగించవచ్చు లేదా ఉపయోగించకపోవచ్చు; మీరు వేరే ఎంపిక లేదా చొప్పించే విధమైన చేస్తే, ఇది పూర్తిగా మంచిది.
తొలగింపులు ఎలా జరుగుతాయో అనే తర్కంలోకి మేము వెళ్ళడం లేదు.
నేను చూపించదలిచినది రెండు నిలువు వరుసల మధ్య; ఎడమవైపు సి ప్రోగ్రామ్, కుడివైపు సి ++ ప్రోగ్రామ్.
ఇద్దరూ ఒకే వ్యూహాన్ని, ఒకే అల్గారిథమ్‌ను ఉపయోగించి బబుల్‌ను క్రమబద్ధీకరించడానికి ప్రయత్నిస్తున్నారు; మరియు, వాటి మధ్య మీరు చూడగలిగే ఏకైక తేడా ఏమిటంటే IO హెడర్స్ మరియు STD నేమ్‌స్పేస్‌ల వాడకం.
ఇప్పటివరకు మొత్తం అల్గోరిథం సంబంధించినది, కోడ్ సంబంధించినది, శ్రేణులు మరియు పోలికలు సంబంధించినవి, ఇది ఒకటే.
కాబట్టి, మనం తీసుకునే మొదటి పాఠం ఏమిటంటే, సి లో వ్రాసిన ఏదైనా సార్టింగ్ కోడ్‌ను సి ++ లో గుర్తించవచ్చు.
ఇప్పుడు, నేను స్పష్టం చేయాలనుకుంటున్నాను, నేను సంఖ్యల సమూహాన్ని లేదా తీగల సమితిని క్రమబద్ధీకరించాల్సిన అవసరం ఉంటే, నేను ప్రతిసారీ ఒక సార్టింగ్ ప్రోగ్రామ్‌ను వ్రాస్తాను? నేను అల్గోరిథంలు నేర్చుకోవడానికి ప్రయత్నిస్తున్నప్పుడు లేదా నేను భాషలను నేర్చుకోవడానికి ప్రయత్నిస్తున్నప్పుడు నేను దీన్ని చేస్తాను, కాని తరువాత నేను సంఖ్యల సమితిని క్రమబద్ధీకరించాలనుకుంటే, నేను అల్గోరిథం రాయను బదులుగా, నేను మళ్ళీ ప్రామాణిక లైబ్రరీకి వెళ్లి ప్రామాణిక లైబ్రరీ అందించే వాటిని ఉపయోగించడానికి ప్రయత్నిస్తాను.
ఇప్పుడు, మేము ఎడమ కాలమ్ పై దృష్టి పెడతాము, ఇది సి ప్రోగ్రామ్.
<stdlib.h> హెడర్‌లో, సి ప్రామాణిక లైబ్రరీలో అందించిన సార్టింగ్ ఫంక్షన్‌ను ఉపయోగిస్తోంది.
ఈ ఫంక్షన్‌ను Q సార్టింగ్ అంటారు.
ఈ ఫంక్షన్ శీఘ్ర క్రమబద్ధీకరణను అంతర్లీన సార్టింగ్ అల్గోరిథం వలె ఉపయోగిస్తుందనే వాస్తవాన్ని ఈ పేరు ఖచ్చితంగా సూచిస్తుంది.
ఇప్పుడు, Q ను సార్ట్ ఫంక్షన్ అని ఎలా పిలుస్తారో గమనించండి.
4 పారామితులు ఉన్నాయని మీరు చూడవచ్చు.
కాబట్టి మీరు Q క్రమబద్ధీకరణ ప్రోగ్రామ్‌కు ఏమి చెప్పాలో చూద్దాం, తద్వారా ఇది మీ డేటాను క్రమబద్ధీకరించగలదు.
ఖచ్చితంగా, డేటా ఎక్కడ ఉందో మీరు వివరించాలి.
కాబట్టి, ఇది కంటైనర్, ఇది ఇక్కడ శ్రేణి డేటా.
కాబట్టి, ఇది మొదటి పరామితి.
ఇప్పుడు, శ్రేణిలోని ఎన్ని అంశాల అయినా మూలకాల సంఖ్య అవుతుంది; Q ఎలా క్రమబద్ధీకరిస్తుంది, ఎన్ని అంశాలు ఉన్నాయో లేదా వాటిలో ఎన్ని ఉన్నాయో తెలుసుకోండి, వాటిలో ఎన్ని మీరు క్రమబద్ధీకరించాలనుకుంటున్నారు.
కాబట్టి, రెండవ పరామితి Q క్రమబద్ధీకరణ మీరు ఎన్ని శ్రేణి అంశాలను క్రమబద్ధీకరించాలనుకుంటున్నారో చెబుతుంది.
దీని అర్థం మీరు ఎల్లప్పుడూ ఇండెక్స్ 0 తో ప్రారంభించి, రెండవ పరామితిలో పేర్కొన్నన్ని అంశాలను తీసుకోండి.
కాబట్టి, ఇక్కడ రెండవ పరామితి 5, అంటే Q డేటా శ్రేణిని సీరియల్ 0 నుండి ఇండెక్స్ 4 కు క్రమబద్ధీకరించాలి, ఈ సందర్భంలో మొత్తం శ్రేణి (క్రమబద్ధీకరణ). శ్రేణి).
మూడవ పరామితి కొంచెం గమ్మత్తైనది, మరియు మూడవ పరామితి ఎందుకు అవసరమో మీకు ఇప్పుడు అర్థం కాలేదు.
మూడవ పరామితి దయచేసి ప్రతి మూలకం యొక్క పరిమాణాన్ని బైట్లలో అందించండి.
ఇప్పుడు, ఇది పూర్ణాంక శ్రేణి, అంటే ప్రతి మూలకం పూర్ణాంకం (పూర్ణాంకానికి).కాబట్టి, ప్రతి మూలకం యొక్క పరిమాణాన్ని సి లోని సైజుఆఫ్ ఆపరేటర్ ఉపయోగించి లెక్కించవచ్చు, కాబట్టి మీరు సైజ్ఆఫ్ (పూర్ణాంకానికి) ను పేర్కొనండి, ఇది 32 బిట్ సిస్టమ్ కోసం 4 ను దాటిపోతుంది, ఎందుకంటే పూర్ణాంకానికి (పూర్ణాంకానికి), సాధారణంగా పరామితి మూడవదిగా ప్రాతినిధ్యం వహిస్తుంది 32 బిట్స్‌లో 4 బైట్లు.
కాబట్టి, ప్రతి మూలకం యొక్క పరిమాణాన్ని సి లోని సైజుఆఫ్ ఆపరేటర్ ఉపయోగించి లెక్కించవచ్చు, కాబట్టి మీరు సైజ్ఆఫ్ (పూర్ణాంకానికి) ను పేర్కొనండి, ఇది 32 బిట్ సిస్టమ్ కోసం 4 ను దాటిపోతుంది, ఎందుకంటే పూర్ణాంకానికి (పూర్ణాంకానికి), సాధారణంగా పరామితి మూడవదిగా ప్రాతినిధ్యం వహిస్తుంది 32 బిట్స్‌లో 4 బైట్లు.
మాకు అవసరమైనదాన్ని నిజంగా అర్థం చేసుకోవడం మీకు కష్టంగా ఉండవచ్చు, కాని ప్రాథమిక వాదన ఏమిటంటే, Q శ్రేణికి మీ శ్రేణిలో ఏ రకమైన డేటా ఉందో తెలియదు, మూలకం రకంలో తేడా ఉంటుంది. సంభవించవచ్చు; ఇది నాలుగు రకాల అంశాలను కలిగి ఉంటుంది; ఇది కోణాల రూపం యొక్క అంశాలను కలిగి ఉండవచ్చు; ఇది నిర్మాణ రకం యొక్క అంశాలను కలిగి ఉంటుంది; ఇండెక్స్ చేయబడిన మూలకం యొక్క చిరునామాను పొందిన తరువాత Q (Q) మొదట సూచిక చేయబడిన మూలకాన్ని గుర్తించాలని కనుగొనడం సాధ్యం కాదు.
అందువల్ల, మూలకం యొక్క పరిమాణం తెలిస్తే, అది మొదటి మూలకాన్ని పొందడానికి శ్రేణి యొక్క ప్రారంభ చిరునామాకు ఆఫ్‌సెట్‌గా జోడించగలదు.
రెండవ మూలకం యొక్క చిరునామాను పొందడానికి మొదటి మూలకం యొక్క స్థానానికి మళ్ళీ అదే పరిమాణంలో పూర్ణాంకాన్ని జోడించవచ్చు.
కాబట్టి, మీకు ఈ సమాచారం అవసరమయ్యే అమలు ఇది.
కాబట్టి, ఇది మూడవ పరామితి.
నాల్గవ పరామితి అత్యంత ఆసక్తికరమైనది.
నాల్గవ పరామితి ఫంక్షన్ పాయింటర్.
మాడ్యూల్ 1 లో, మేము ఫంక్షన్ పాయింటర్ల గురించి లోతుగా మాట్లాడామని మీరు గుర్తుంచుకుంటారు.
మేము దాన్ని మళ్ళీ చేర్చుకున్నాము మరియు మీరు మీ దృష్టిని పైకి కదిలిస్తే, చేర్చండి మరియు ప్రధానంగా ఫంక్షన్ పాయింటర్ నిర్వచించబడిందని మీరు కనుగొంటే, Q (Q) క్రమబద్ధీకరణ (క్రమబద్ధీకరణ).
ఇప్పుడు, ఈ తులనాత్మక పని యొక్క పాత్ర ఏమిటి? ఈ పోలిక ఫంక్షన్ 2 విలువలను పోల్చి, ఏది చిన్నది లేదా రెండవది చిన్నదో చెబుతుంది.
ఇక్కడ, మనకు పోలిక ఫంక్షన్ చూపబడింది, ఇక్కడ మనం పోలికగా తక్కువగా ఉపయోగిస్తున్నాము.
మొదటిది మరొకదాని కంటే చిన్నదిగా ఉంటే, అది నిజం అవుతుంది మరియు లేకపోతే అది తప్పుడుదాన్ని తిరిగి ఇస్తుంది.
తులనాత్మక పని యొక్క ప్రాథమిక ఉద్దేశ్యం ఇది.
వేరే ఫంక్షన్ (ఫంక్షన్), పాయింటర్ (పాయింటర్) ఫంక్షన్ (ఫంక్షన్) వ్రాసి, ఆ ఫంక్షన్ (ఫంక్షన్) పాయింటర్ (పాయింటర్) ను పాస్ చేయడం వంటి క్లిష్టమైన పనిని నేను ఎందుకు చేయవలసి వచ్చిందో ఇప్పుడు మీరు ఆశ్చర్యపోతున్నారు.
Q లైబ్రరీలో క్రమబద్ధీకరించబడినప్పుడు లేదా మీరు ఇప్పుడు Q రకం యొక్క ఫంక్షన్‌ను వ్రాయాలనుకుంటే మరియు ఏ రకమైన మూలకాలను క్రమబద్ధీకరించాలో మీకు చెప్పబడలేదు, కాబట్టి ఎలా పోల్చాలో మీకు ఎలా తెలుసు? ఆ అంశాలు? ఉదాహరణకు, పూర్ణాంకానికి చాలా తేలికగా పోల్చవచ్చు, కాని నేను పూర్ణాంకానికి బదులుగా చెప్పినట్లయితే, నేను ఇప్పుడు మీకు తీగలను ఇస్తే.
ఇప్పుడు, తీగల శ్రేణిని సి లో ఎక్కువ లేదా తక్కువ రాయడం తో పోల్చలేము.
మేము C ++ స్ట్రింగ్ గురించి మాట్లాడటం లేదు, పోలిక ఆపరేటర్ మీకు ఇప్పటికే తెలుసు.
కాబట్టి, సి లో నేను తీగలను పోల్చవలసి వస్తే నా విలువలు వాస్తవానికి అక్షరానికి సూచించబడతాయి, కాని నేను కొన్నింటిని బిగింపు () ఫంక్షన్ (ఫంక్షన్) వాడకంతో పోల్చాను.
ఇప్పుడు Q రకాన్ని ఎలా తెలుసుకోవాలి, Q సార్టింగ్ మీరు వాటిని పోల్చడానికి Q ఎలాంటి డేటాను ఇస్తారో తెలియదు, Q సార్టింగ్ కూడా అలాంటి 2 డేటా ఐటెమ్‌లను ఎలా పోల్చాలో తెలియదు.
మరియు ఫంక్షన్‌ను Q క్రమబద్ధీకరణతో పోల్చడం మీ బాధ్యత.
కాబట్టి మీరు ఈ నాల్గవ పరామితిని కలిగి ఉండాలి, ఇది ఫంక్షన్ పాయింటర్ యొక్క పోలిక.
మీరు శీర్షికలో చూస్తే, ఫంక్షన్ పాయింటర్ యొక్క సంతకం మీకు మరింత బాధించేదాన్ని ఇస్తుంది.
పారామితులను తెలియని రకం యొక్క స్థిరమైన డేటా కోసం const పాయింటర్లుగా ఉండే const void * గా ప్రకటించడాన్ని మీరు చూడవచ్చు, ఇది ఎందుకు? ఎందుకంటే మళ్ళీ, Q కి సార్టింగ్ ఫంక్షన్ (ఫంక్షన్) పాయింటర్ కోసం సంతకం ఉండకూడదు, ఎందుకంటే దీనికి డేటా ఐటెమ్ రకం తెలియదు.
అందువల్ల, ఇవన్నీ మీకు తెలియని కొన్ని రకాల సూచికను కలిగి ఉన్నాయని అనుకుంటాయి మరియు మీకు రకం తెలియదు కాబట్టి, పోలిక ఫంక్షన్ యొక్క రిటర్న్ స్టేట్మెంట్లో మీరు నిజంగా పోల్చాలనుకున్నప్పుడు, మీరు మొదట కంపైలర్కు చెప్పాలి వాస్తవానికి, ఇప్పుడు నేను కలిగి ఉన్నది పూర్ణాంకం.
కాబట్టి, మీరు మొదట పాయింటర్ (పాయింటర్) ను పూర్ణాంకానికి (పూర్ణాంకానికి) రద్దు చేస్తారు, ఆపై మీరు పూర్ణాంక విలువను పొందడానికి ఆ పూర్ణాంక పాయింటర్ (పాయింటర్) ను సూచిస్తారు, ఆపై మీరు పూర్ణాంకం యొక్క రెండు పూర్ణాంక విలువలను జోడిస్తారు. పోల్చుకుందాం.
అందువల్ల, Q- కత్తిరించడం కోసం ఇంకా చాలా అవసరం.
టైప్ సి స్టాండర్డ్ లైబ్రరీలో డిఫాల్ట్ సార్టింగ్ అల్గోరిథం వలె Q (Q) అందుబాటులో ఉన్నప్పటికీ, Q సమాజంలో Q (sort) వాడకం అంతగా ప్రాచుర్యం పొందలేదు.
తరచుగా, ప్రజలు తమ సొంత రచనలు రాయడానికి ఇష్టపడతారు; బబుల్ సార్ట్, సెలెక్షన్ సార్ట్ లేదా ఇన్సర్షన్ సార్ట్, సార్ట్, మరియు టైప్ డేటా యొక్క మూలకాలకు వారు క్రమబద్ధీకరించాలనుకునే అంశాలను ఇస్తారు మరియు అదే వాడాలి.
ఇప్పుడు కాలమ్ యొక్క కుడి వైపు చూడండి.
C ++ దీన్ని చేసే విధానం, IO పరంగా నేను తేడాలు చూడను, మీకు ఇప్పటికే తెలుసు.
మీరు చేరిక పరంగా దృష్టి పెట్టాలి, మేము అల్గోరిథం అని పిలువబడే మరొక C ++ ప్రామాణిక లైబ్రరీ హెడర్‌ను చేర్చుతాము, ఇది చాలా ఆసక్తికరంగా ఉంటుంది.
అల్గోరిథం అనేది మీ ప్రోగ్రామ్‌లలో మీరు తరచుగా ఉపయోగించాల్సిన చాలా అల్గోరిథం కోడ్‌ను కలిగి ఉన్న హెడర్.
కాబట్టి, అల్గోరిథం ఒక భాగం, క్రమబద్ధీకరణ అల్గోరిథం కలిగి ఉంటుంది.
కాబట్టి, మీరు C లో C లో క్రమబద్ధీకరించేది, అల్గోరిథంలో ఈ భాగాన్ని C ++ లో క్రమబద్ధీకరించడం అంటారు.
మేము మళ్ళీ అదే డేటాను క్రమబద్ధీకరిస్తున్నాము; మేము మళ్ళీ అదే క్రమంలో క్రమబద్ధీకరిస్తున్నాము.
క్రమబద్ధీకరించడానికి నేను ఏమి పేర్కొనాలి, పారామితులను చూద్దాం.
ఖచ్చితంగా, నేను కంటైనర్ లాగా కంటైనర్లో ఏమి చేసాను.
రెండవది నేను మొదటి నుండి ఎన్ని అంశాలు ఉన్నాయో చెప్పాలి, ఇక్కడ మనం దానిని కొద్దిగా భిన్నంగా పేర్కొంటాము.
Q క్రమబద్ధీకరణలో, మేము మూలకాల సంఖ్యను మాత్రమే పేర్కొన్నాము; ఇక్కడ మనం ధ్యానం చేసిన తర్వాత మొదటి మూలకానికి పాయింటర్‌ను పాస్ చేస్తాము.
కాబట్టి, మేము `డేటా + 5 'ను పాస్ చేస్తాము, అంటే మనం పాయింటర్‌ను 5 మూలకాల సూచికకు పంపుతాము, అంటే మనం క్రమబద్ధీకరించాలనుకుంటున్న శ్రేణి యొక్క భాగానికి వెలుపల ఉంది.
మరో మాటలో చెప్పాలంటే, డేటాతో ప్రారంభమయ్యే 5 అంశాలను మీరు క్రమబద్ధీకరిస్తారా? మేము ఈ వివరాలను తరువాత చూస్తాము, దీనిని C ++ లో పరిమితి అంటారు.
మూడవ పరామితి ఒక విధమైన Q గా అవసరం లేదు, ఎందుకంటే మీరు ఇప్పటికే చూసినట్లుగా, C ++ కంపైలర్ రకం ఆధారంగా వస్తువులను కత్తిరించగలదు.
కాబట్టి టైప్ చేయండి, డేటా ఇంటెంట్ (పూర్ణాంకానికి) టైప్ అర్రే అని తెలుసు.
కాబట్టి, మూలకాలు అవకలన రకంగా ఉంటాయి.
కాబట్టి, మీరు పరామితిగా Int (int) పరిమాణాన్ని విడిగా పేర్కొనవలసిన అవసరం లేదు.
విధమైన మూడవ పరామితి మీరు పోలిక అల్గోరిథం ఇవ్వాల్సిన విధమైన నాల్గవ పరామితికి సమానంగా ఉంటుంది.
ఇది ఖచ్చితంగా తీసివేయబడదు, ఎందుకంటే మీ పోలిక వ్యూహం మీ వద్ద ఉన్న డేటాను బట్టి మారుతుంది.
కానీ, ఇది చాలా ముఖ్యం, మీరు మళ్ళీ మీ దృష్టిని C ++ విభాగంలో ఈ పోలిక ఫంక్షన్ నిర్వచించిన చోటికి మార్చినట్లయితే.
కాస్ట్ శూన్యమైన * రకం లేదా వ్యక్తీకరణ యొక్క పారామితులను ఉపయోగించి, కాస్టింగ్ మరియు డి-రిఫరెన్సింగ్‌ను పూర్తిగా చేసే సి లో మీకు సంక్లిష్టత లేదు.
ఇప్పుడు, మీరు ఒక సాధారణ ఫంక్షన్, int i, int j విషయంలో డిక్లేర్ చేసినట్లే పారామితులను డిక్లేర్ చేయవచ్చు మరియు బదులుగా మీరు పోల్చండి, తులనాత్మక వాదన ఏదైనా మనం ఇక్కడ వ్రాస్తాము.
ఇది సాధారణ పోలిక ఫంక్షన్ లాగా ఉంటుంది మరియు ఇది పాయింటర్; ఫంక్షన్ పేరు మూడవ పరామితిగా ఇవ్వబడుతుంది.
మీరు దీన్ని C ++ లో చేయవచ్చు, ఎందుకంటే C ++ లో ఇలాంటి లక్షణాలు చాలా ఉన్నాయి, వీటిని మేము క్రమంగా మీకు పరిచయం చేస్తాము.
కాబట్టి, సి లో ఇది ఎందుకు సాధ్యం కాలేదని మీరు అర్థం చేసుకుంటారు, కాని సి ++ లో సార్టింగ్ ఫంక్షన్ ఇప్పటికే తెలియని దానితో పోల్చదగిన ఫంక్షన్‌ను వ్రాయడం సాధ్యమవుతుంది, కాని అప్పుడు కూడా దానిని గ్రహించగలుగుతారు.
కాబట్టి, ప్రామాణిక లైబ్రరీ నుండి క్రమబద్ధీకరించబడిన ప్రోగ్రామ్‌ను ఉపయోగించడం చాలా సొగసైనది మరియు సమర్థవంతమైనది.
మరియు ఫలితం ఏమిటంటే, C ++ ప్రోగ్రామర్లు వాస్తవానికి వారి స్వంత క్రమబద్ధీకరించిన ప్రోగ్రామ్‌లను వ్రాస్తున్నప్పుడు, వారు ఇక్కడ ఇచ్చిన రకాన్ని ఉపయోగిస్తారు.
గమనించడానికి చిన్న సూక్ష్మ నైపుణ్యాలు ఉన్నాయి; సార్టింగ్ దిశ యొక్క సమావేశం, ఇది తగ్గుతున్న క్రమం లేదా పెరుగుతున్న ఆర్డర్ Q అయినా, క్రమబద్ధీకరణ అమలు మరియు క్రమబద్ధీకరణ అమలు మధ్య మారుతూ ఉంటుంది.
కాబట్టి, మీరు వ్రాసిన రెండు తులనాత్మక ఫంక్షన్లపై మీరు మళ్ళీ దృష్టి పెడితే, సి లో మనం నిజం కంటే తక్కువగా ఉపయోగించామని, సి ++ లో మనం నిజం కంటే ఎక్కువ ఇచ్చామని మీరు కనుగొంటారు. ఎందుకంటే రెండు సందర్భాల్లోనూ మనం కోరుకుంటున్నాము అవరోహణ క్రమంలో చేయాలి.
కాబట్టి, ఇది సి ++ క్రమంలో ఉన్న సమావేశానికి సంబంధించిన విషయం.
ఈ విధమైన రకం యొక్క మరొక వెర్షన్ ఇది.
ఇక్కడ, మీరు సార్ట్ ఫంక్షన్ యొక్క కాల్ వద్ద ప్రత్యేకంగా చూస్తే, మొదటి రెండు పారామితులు ఉన్నాయని మీరు చూస్తారు, కానీ మూడవ పరామితి లేదు, ఇక్కడ తులనాత్మక ఫంక్షన్ అందించబడలేదు.
ఇది సి ++ ప్రామాణిక లైబ్రరీ మిమ్మల్ని అనుమతించే షార్ట్ కట్; మీరు C ++ యొక్క అంతర్నిర్మిత రకాలను కలిగి ఉన్న C ++ రకాలను క్రమబద్ధీకరించడానికి ప్రయత్నిస్తుంటే, తులనాత్మక ఫంక్షన్‌ను అందించడం ఐచ్ఛికం.
పోలిక ఫంక్షన్‌ను అందించడం అవసరం లేదు మరియు మీరు దానిని అందించకపోతే, అప్రమేయంగా సార్టింగ్ ఆరోహణ క్రమంలో జరుగుతుంది.
మీరు ఇంకా ఈ శ్రేణిని అవరోహణ క్రమంలో క్రమబద్ధీకరించాలనుకుంటే, మీరు మళ్ళీ ఒక తులనాత్మక ఫంక్షన్‌ను అందించాల్సి ఉంటుంది ఎందుకంటే మీ పోలిక యొక్క దిశ, అంటే మొదటి పారామితి (పరామితి) రెండవదానికంటే ఎక్కువ. నిజం లేదా లేకపోతే, సార్టింగ్ మధ్య తేడా ఉంటుంది సార్టింగ్ మరియు అవరోహణ సార్టింగ్.
తరువాత, మేము బైనరీ శోధనకు వెళ్తాము.
మనందరికీ తెలిసినట్లుగా, బైనరీ శోధన అనేది ప్రోగ్రామింగ్‌లో తరచుగా ఉపయోగించే అల్గోరిథం, ఇది మూలకాల శ్రేణిని ఇస్తుంది, ఇవి ఇప్పటికే క్రమబద్ధీకరించబడ్డాయి.
ఒక బైనరీ శోధన ఆ శ్రేణిలో ఇచ్చిన కీ ఉందో లేదో తెలుసుకోవచ్చు, అలా అయితే, శ్రేణిలోని ఆ మూలకం యొక్క స్థానం ఏమిటో కూడా చెప్పగలదు. ఇది, సాధారణ శోధన విధానం, ఇది అత్యంత సమర్థవంతమైనది.
మరియు, సి మరియు సి ++ రెండూ ప్రామాణిక లైబ్రరీలలో బైనరీ శోధనలు చేయటానికి యంత్రాంగాలు.
C లో, ఇది మళ్ళీ <stdlib.h> లో లభిస్తుంది.
ఇది బి సెర్చ్ అనే ఫంక్షన్.
C ++ లో, ఇది మళ్ళీ కాంపోనెంట్ అల్గోరిథంతో లభిస్తుంది మరియు దీనిని బైనరీ అండర్ స్కోర్ సెర్చ్ అంటారు.
మేము ఆ 'bsearch' చూస్తే; ఎడమ చేతి వైపు సి ఎలా ఉపయోగించబడుతుంది, అప్పుడు మొదటి పరామితి ఒక కీ.
కీ దాని చిరునామాగా పాస్ చేయబడాలి, కాబట్టి మీరు పాస్ & కీ.
దీన్ని చేయడానికి ఒక కారణం ఏమిటంటే, మీరు దీన్ని చేయవలసి ఉంది, ఎందుకంటే మళ్ళీ, మీకు శ్రేణిలో ఉన్న మూలకాల రకం మీకు తెలియదు, అందువల్ల మీరు వెతకాలని కోరుకునే కీ రకం. హుహ్.
కాబట్టి, కీ రకం మీకు సాధారణంగా తెలియదు.
అందువల్ల, మీరు దానితో 'bsearch' రాయలేరు.
కాబట్టి మీరు మళ్ళీ పాయింటర్‌ను పూర్ణాంకానికి (పూర్ణాంకానికి) ఉపయోగించవచ్చనే వాస్తవాన్ని ఉపయోగించుకోండి మరియు పాయింటర్ శూన్యంగా ఉండాలని భావిస్తారు.
కాబట్టి, bsearch శూన్యమైన మొదటి పరామితిని ఉపయోగిస్తుంది *.
అందుకే మీరు దీనికి చిరునామా ఇవ్వాలి.
రెండవ పరామితి మీరు కనుగొనాలనుకుంటున్న శ్రేణి, వాస్తవానికి ఇది క్రమబద్ధీకరించబడాలి.
మూడవ పరామితి మూలకాల సంఖ్య.
ఇది Q సార్ట్ లాగా చాలా అందంగా ఉంటుంది.
నాల్గవ పరామితి ప్రతి మూలకం యొక్క పరిమాణం మరియు ఐదవ పరామితి పోలిక ఫంక్షన్ యొక్క పనితీరుకు పాయింటర్.
గమనించదగ్గ విషయం ఏమిటంటే, బైనరీ శోధనను క్రమబద్ధీకరించడానికి విరుద్ధంగా మూడు విధాలుగా నిర్ణయించవలసి ఉంది, ఇక్కడ మీరు తెలుసుకోవలసినది తక్కువ లేదా కాదా అనేది తెలుసుకోవాలి, కానీ బైనరీ శోధనలో, ఇది శ్రేణిలో ఒక నిర్దిష్ట మూలకం కోసం వెతుకుతోంది , ఇది 3 అవకాశాలతో వ్యవహరించాలి.
ఒకటి, అతను చూస్తున్న మూలకం, వాస్తవానికి కీకి సమానంగా ఉంటుంది, కాబట్టి మీరు శోధనతో పూర్తి చేస్తారు.
కాబట్టి, మీరు ఏమీ చేయనవసరం లేదు, మీరు శ్రేణి యొక్క స్థానం యొక్క సూచిక విలువను తిరిగి ఇస్తారు.
రెండవది, దాని కంటే తక్కువగా ఉండవచ్చు.
మీరు మీ శ్రేణిని ఆరోహణ క్రమంలో కలిగి ఉంటే మరియు మీ విలువ మీరు చూస్తున్న మూలకం కంటే తక్కువగా ఉంటే, అప్పుడు మీ కీ మీరు చూస్తున్న మూలకం కంటే తక్కువగా ఉంటుంది, మీకు కావాలి అని మీకు తెలుసు ఈ భాగం శ్రేణిలో చూడాలి .
మరియు మూడవ సందర్భంలో, మీరు శ్రేణి యొక్క కుడి వైపు చూడాలి.
కాబట్టి, మీ తులనాత్మక ఫంక్షన్ మూడు విధాలుగా పనిచేయాలి, మనకు సి స్ట్రింగ్ (. స్ట్రింగ్) .h ప్రామాణిక లైబ్రరీలో ఉన్న strcmp () లాగా.
బట్టి ఇక్కడ ఎగువన, మైనస్ 1, 0 లేదా ప్లస్ 1 తో మేము వ్యవహరిస్తున్న అటువంటి తులనాత్మక ఫంక్షన్ కోసం మీరు ఎలా వ్రాయవచ్చో చూపిస్తాను.
మరియు, పారామితులను శూన్యమైన * పాయింటర్ (లు) గా ఉపయోగించడం మరియు వాటిని ప్రసారం చేయడం, వాటిని డీఫరెన్సింగ్ చేయడం, Q (Q) విషయంలో మేము చేసినట్లుగా, అన్ని సూక్ష్మ నైపుణ్యాలు కూడా ఈ సందర్భంలో చేర్చబడతాయి.
దీని కోసం, C ++ ఫారమ్ చూడండి.
అల్గోరిథం భాగం నుండి బైనరీ _ సెర్చ్ () ఫంక్షన్ మొదటి పరామితిని కంటైనర్‌గా తీసుకుంటుంది, ఇది డేటా, రెండవ పరామితి పారామితి పరిధి ముగింపు.
మనం చూసినట్లుగా ఇది చాలా ఉంది.
మరియు ఇది మూడవ పరామితిని తీసుకుంటుంది, ఇది కీ.
మరియు ఇక్కడ, నేను ఒక ఉదాహరణను చూపిస్తున్నాను, ఇక్కడ తులనాత్మక ఫంక్షన్ స్పష్టంగా అందించబడలేదు, ఎందుకంటే నేను ఇప్పటికే అలాంటి సందర్భంలో చర్చించినట్లుగా, మీరు కంపైలర్‌లో నిర్మించిన రకం యొక్క మూలకాల కోసం శోధిస్తుంటే, పోలిక ఎలా ఉందో మాకు ఇప్పటికే తెలుసు పూర్తి.
కాబట్టి, పోలిక కోసం మీరు ఫంక్షన్ పాయింటర్‌ను స్పష్టంగా ఉంచాల్సిన అవసరం లేదు.
మరియు, దీనితో, బైనరీ శోధన ఉంటుంది.
మీరు రెండింటినీ పోల్చి చూస్తే, మీరు C ++ లో బైనరీ శోధనను సులభంగా ఉపయోగించవచ్చు.
వాడకం సౌలభ్యం కంటే చాలా ఎక్కువ ఉంది, బైనరీ శోధన చాలా తరచుగా C ++ లో ఉపయోగించబడుతుంది మరియు ఎవరూ ఏ రకమైన డేటా కంటైనర్ కోసం బైనరీ సెర్చ్ ప్రోగ్రామ్‌ను వ్రాయరు.ఒకరికి ఉంది.
ప్రత్యేకించి, ఈ అల్గోరిథం లైబ్రరీలో ఇది చాలా ఆసక్తికరమైన లైబ్రరీ, ఎందుకంటే ఇది ఏమిటంటే, మీరు సి ++ ఉపయోగిస్తుంటే, మేము మీకు సాధారణ అల్గోరిథంల సమితిని ఇస్తాము.
అందువల్ల, అల్గోరిథం లైబ్రరీ నుండి మరింత శోధనను ఎలా ఉపయోగించవచ్చో మనం చూశాము.
మూలకాలను ప్రత్యామ్నాయం చేయడం, మూలకాల క్రమాన్ని తిప్పడం వంటివి ఇంకా చాలా ఉన్నాయి.
కాబట్టి, ఇవి తిరగడానికి, కోడ్‌ను మార్చడానికి ఉదాహరణలు.
మేము వాటి ద్వారా దశలవారీగా నడవము.
ఇప్పటికి, దాన్ని అర్థం చేసుకోవడానికి ఏమి ఉపయోగించాలో మీకు తెలిసి ఉండాలి.
దయచేసి ఈ అల్గోరిథంల వివరాల కోసం మాన్యువల్ లేదా పుస్తకాన్ని చూడండి మరియు వాటిని ఉపయోగించడం ప్రారంభించండి.
అల్గోరిథం లైబ్రరీలను ఉపయోగించడం వల్ల C ++ లో విషయాలు రాయడం చాలా సులభం అని మీరు కనుగొంటారు, ఎందుకంటే చాలా సాధారణ అల్గోరిథంలు ఇప్పటికే అందుబాటులో ఉన్నాయి మరియు ఉపయోగించడానికి చాలా సులభం.
ఈ మాడ్యూల్‌లో, సి ++ లో ప్రాథమిక సార్టింగ్ మరియు సెర్చ్ ఎలా మెరుగ్గా మరియు మెరుగ్గా చేయవచ్చో మేము చూపించాము మరియు సి అని మేము ప్రత్యేకంగా వివరిస్తాము, సి కాకుండా మన స్వంత సార్టింగ్ కోడ్ మరియు సెర్చ్ కోడ్‌ను సి ++ లో తరచుగా వ్రాస్తాము.
అలా చేయడానికి ఎటువంటి కారణం ఉండదు.
మేము ఏ రకమైన కంటైనర్ మరియు డేటా ఉపయోగిస్తున్నా, విలీనం, స్వాప్, డిలీట్, ఇవన్నీ భిన్నంగా మనం ఉపయోగించాల్సిన అనేక ఇతర అల్గోరిథంలకు కూడా ఇది నిజమని మేము చూపిస్తాము.
మరియు, ఈ అల్గోరిథమిక్ భాగాలను అధ్యయనం చేయడానికి మరియు వాటిని ఉపయోగించడం ప్రారంభించడానికి నేను మిమ్మల్ని ప్రోత్సహిస్తాను.
ఆపై మొత్తం యొక్క అందం ఉంది, మీరు నిజంగా చాలా C + గురించి తెలుసుకోవలసిన అవసరం లేదు, ఎందుకంటే మీరు వాటిని ఉపయోగించగలగాలి, ఎందుకంటే వాటిని ఉపయోగించడం వారి రూపకల్పన మరియు వారు చేసే విధానంతో చాలా సౌకర్యంగా ఉంటుంది వ్యవస్థీకృతమై ఉంది మరియు మీరు మాన్యువల్ నుండి అధ్యయనం చేయవచ్చు మరియు వాటిని ఉపయోగించడం ప్రారంభించవచ్చు.
inhouse/NPTEL/PreFinal/c++/Telugu/41 ProgramminginCplusplus_Classes and Objects (Contd.) (Lecture 20)-urux5ZxeO3k.txt
View file @ 956c0d4e
 1. C ++ లో ప్రోగ్రామింగ్ యొక్క మాడ్యూల్ 11 యొక్క పార్ట్ -2 కు స్వాగతం.
2. ఈ మాడ్యూల్ యొక్క మొదటి భాగంలో, తరగతుల యొక్క ప్రాథమిక భావనలను మరియు తరగతుల ఉదాహరణలను వస్తువులుగా చూశాము.
3. మేము అర్థం చేసుకున్నాము, డేటా సభ్యులు మరియు పద్ధతులు ఏమిటి.
4. మేము ముఖ్యంగా సంక్లిష్ట సంఖ్యల యొక్క మూడు ఉదాహరణలను చర్చించాము; చుక్కలు మరియు స్టాక్‌తో దీర్ఘచతురస్ర వస్తువులు.
5. ఒక వస్తువును గుర్తించడానికి "ఈ" పాయింటర్‌ను కూడా మేము అర్థం చేసుకున్నాము.
6. మిగిలిన భాగంలో మనం వస్తువు యొక్క స్థితిగా పిలువబడే వాటిని క్లుప్తంగా చర్చిస్తాము.
7. ఇది C ++ సందర్భాలలో ఆబ్జెక్ట్-ఓరియెంటెడ్ మోడల్ వర్తించే విధానం నుండి ఉద్భవించింది.
8. ఒక వస్తువు యొక్క స్థానం దాని అన్ని డేటా సభ్యుల మిశ్రమ విలువ ద్వారా నిర్ణయించబడుతుంది అని మేము చెప్తాము.
9. సరళమైన మాటలలో, మనం సంక్లిష్టమైన ఉదాహరణకి తిరిగి వెళుతున్నామని చెప్పండి.
10. కాబట్టి, ఈ డేటా భాగం ఖచ్చితంగా ఒకే విధంగా ఉంటుంది, ప్రదర్శన ప్రయోజనాల కోసం మాకు కొన్ని అదనపు పద్ధతులు ఉన్నాయి.
11. కాబట్టి, ఈ డేటా సభ్యులను ఏమని పిలుస్తారు? వారు నా వద్ద ఒక సంక్లిష్ట సంఖ్య ఉంటే, నేను దానిని తీయగలిగితే, అది ఒక సంక్లిష్ట సంఖ్య, దానికి 're (re)' భాగం మరియు తరువాత 'im' భాగం ఉంటుంది.
12. కాబట్టి, ఇది సంక్లిష్ట సంఖ్య.
13. కాబట్టి, సి 1 ను 4.2, 5.3 గా నిర్వచించామని నేను చెబితే, అది సి 1 అని చెప్పగలను మరియు అది 4.2 మరియు ఇది 5.3.
14. కాబట్టి, రాష్ట్ర భావన, ఇది రెట్టింపు విలువ అని మేము చెప్తాము; దీనికి డబుల్ విలువ కూడా ఉంది.
15. కాబట్టి, నేను మళ్ళీ విలువగా ఏదైనా డబుల్ విలువను కలిగి ఉండగలనని నాకు తెలుసు.
16. అదేవిధంగా, నేను ఏదైనా డబుల్ విలువను im విలువగా ఉంచగలను.
17. అందువల్ల, నేను తిరిగి ప్రవేశించగలిగే ప్రతి జత డబుల్ విలువలు వేరే సంక్లిష్ట సంఖ్యను తెలియజేస్తాయి.
18. కాబట్టి, నేను సి 1 ని మార్చుకుంటే, నేను ఈ విలువను మార్చుకుంటే లేదా నేను ఈ విలువను మార్చుకుంటే లేదా నేను రెండు విలువలను మార్చుకుంటే.
19. కాబట్టి, సి 1 వేరే రాష్ట్రాన్ని సంపాదించిందని మేము చెబుతాము.
20. ఒక వస్తువు యొక్క డేటా సభ్యుడు ఒక నిర్దిష్ట విలువల కలయికను నిర్వహిస్తున్నంత కాలం, అది ఒక స్థితిలో ఉందని మరియు డేటా సభ్యుల్లో ఎవరైనా దాని విలువను మార్చిన వెంటనే, అది వేరే స్థితిలో ఉందని మేము చెప్తాము.
21. అందువల్ల, చివరికి, ప్రోగ్రామింగ్‌లో, వస్తువు ఏ స్థితిలో ఉందో నిర్ణయించడం మరియు పద్ధతుల వాడకంతో, తదుపరి స్థితిలో కనుగొనగల వస్తువు.
22. ఈ కదలికలన్నింటినీ మేము తరువాత చూస్తాము, కానీ ఇది మీకు చూపించడానికి మాత్రమే, లోతుగా ఉన్న రాష్ట్ర భావన ఏమిటి? మేము ఇక్కడ నాలుగు పద్ధతులను మాత్రమే ఉపయోగిస్తున్నట్లు చూపించడానికి, వాటిని దగ్గరగా చూడండి, get_re; సాధారణంగా, భాగం తిరిగి రాబడిని చదువుతుంది.
23. కాబట్టి, c1 4.2, 5.3 మరియు నేను c1.get_re ను ఇన్వోక్ చేస్తే, నేను స్పష్టంగా 4.2 పొందుతాను.
24. అదేవిధంగా, నేను get_im చేస్తే, అది నాకు 5.3 తిరిగి ఇస్తుంది మరియు మిగిలిన రెండు సెట్ చేయబడతాయి.
25. కాబట్టి, ప్రాథమికంగా నేను set_re పద్ధతిలో మళ్ళీ ఒక విలువను దాటితే, అది ఆ విలువను నేను set_re అని పిలిచిన వస్తువు యొక్క re_ భాగంలో సెట్ చేస్తుంది.
26. అందువల్ల, వీటిని సాధారణంగా సెట్ పద్ధతి అని పిలుస్తారు, మేము వాటిని మరింత సూచిస్తాము.
27. కాబట్టి, దీనితో, నేను దానిలోకి వెళ్ళగలనని హంకరాయ చెబితే మనం చూస్తామా? కాబట్టి, ఇది ప్రారంభమైనది, ఇది 4.2, 5.3 తో ప్రారంభించబడింది.
28. అందువల్ల, సి యొక్క స్థితి 1, 4.2, 5.3, ఎందుకంటే ఇద్దరు డేటా సభ్యులు ఉన్నారు.ఒక జత సంఖ్యల పరంగా రెట్టింపు పరంగా రాష్ట్రం ఇక్కడ నిర్వచించబడింది.
29. అప్పుడు, నేను c.set_re (6.4) చేస్తే, 4.2 6.4 కి మారుతుంది.
30. కాబట్టి, నాకు కొత్త రాష్ట్రం రెండు ఉంది, ఇది 6.4, 5.3 ఇక్కడ ఉంది, అంటే 2 రాష్ట్రం.
31. ఇప్పుడు, మేము c.get_re ను ఇన్వోక్ చేద్దాం అనుకుందాం, ఇది ప్రాథమికంగా ఇప్పుడు c, ఇది c ఆబ్జెక్ట్ యొక్క పున component భాగాన్ని 6.4 చదువుతుంది.
32. కాబట్టి, ఇది 6.4 ను తిరిగి ఇస్తుంది, కానీ వస్తువు యొక్క re లేదా i భాగాలలో ఎటువంటి మార్పు లేదని మీరు గమనించవచ్చు.
33. అందువల్ల, రాష్ట్రంలో ఎటువంటి మార్పు లేదని మీరు నిర్ధారిస్తారు, కాబట్టి ఇది రాష్ట్ర 2 లో కొనసాగుతుంది.
34. నేను set_im (7.8) చేస్తే, సహజంగానే నా స్థితి మారుతుంది ఎందుకంటే ఇప్పుడు వస్తువు సృష్టించబడుతుంది (6.4,7.8).
35. కాబట్టి, ఒక వస్తువుపై వేర్వేరు కార్యకలాపాలు జరిగే విధంగా, ఇది వేర్వేరు రాష్ట్రాల గుండా వెళుతుంది మరియు డేటా సభ్యుడు ఒక విధంగా ఆబ్జెక్ట్ యొక్క స్థానం మిస్ అవుతుందని మేము ఎల్లప్పుడూ చెబుతాము.
36. ఇది ఒక దీర్ఘచతురస్రాన్ని చూపించే ఉదాహరణ, ఇది మూలలో బిందువులు మరియు మేము కార్నర్ పాయింట్ల యొక్క వేర్వేరు కోఆర్డినేట్‌లను మార్చాము లేదా మేము నిష్పత్తిని లెక్కిస్తాము, వస్తువు యొక్క స్థానం ఎలా మారుతుందో చూపిస్తాము.
37. స్టాక్‌పై మరో ఉదాహరణ ఉంది.
38. కాబట్టి, మేము స్టాక్లో ఏమి కలిగి ఉన్నాము? మాకు డేటా శ్రేణి మరియు సూచించిన శీర్షికలు ఉన్నాయి.
39. అందువల్ల, రాష్ట్రం మొత్తం శ్రేణిని కలిగి ఉంటుంది.
40. కాబట్టి, డేటా శ్రేణి శ్రేణి పరిమాణం 5 అయితే, దీనికి అన్ని అక్షరాలను సూచించే 5 టుపుల్ ఉంటుంది, ఈ డేటా శ్రేణిలోని మరొక భాగం శీర్షం, ఇది శీర్ష విలువ.
41. కాబట్టి, ఇవన్నీ కలిసి నాకు ఒక రాష్ట్రాన్ని ఇస్తాయి మరియు ఇవన్నీ ప్రశ్న గుర్తులు ఎందుకంటే ప్రారంభంలో ఏమీ చేయలేదు.
42. అందువల్ల, వస్తువు ఏ స్థితిలో ఉందో నాకు తెలియదు.
43. కానీ, నేను ఎగువన ప్రారంభించిన వెంటనే, అది మైనస్ 1 అవుతుంది.
44. కాబట్టి, నేను కొంత స్థితిని పొందుతున్నాను, కాని నేను B ని నెట్టే శ్రేణి యొక్క స్థితి ఏమిటో నాకు ఇంకా తెలియదు.
45. కాబట్టి, మొదటి అక్షరం అవుతుంది, అది 0 కి పెరుగుతుంది, నా స్థానం మారుతుంది, నేను ఈ మార్పును 'B' 'A' కి నెట్టివేస్తాను.
46. నేను ఖాళీగా తనిఖీ చేసినప్పుడు, అది ఖాళీగా లేదు మరియు అది నాకు తప్పుడు తిరిగి ఇస్తుంది మరియు ఇది ఎగువ శ్రేణిని మార్చదు.
47. కాబట్టి, రాష్ట్రంలో మార్పు లేదు.
48. కాబట్టి, మీరు దానిని అనుసరించడానికి కొనసాగితే, పుష్ మరియు పాప్ యొక్క ఆపరేషన్‌తో, మేము వాస్తవానికి రాష్ట్రాన్ని మారుస్తున్నామని మీరు చూస్తారు, అయితే ఎగువ మరియు ఖాళీతో మేము రాష్ట్రాన్ని మార్చము మరియు ఒక స్టాక్‌ను ఏ సమయంలోనైనా వివరించవచ్చు.
49. దాని శ్రేణి యొక్క స్థానం మరియు టాప్ మార్కర్ యొక్క స్థానం పరంగా.
50. కాబట్టి, మీరు రాష్ట్రాల గురించి తరచుగా విన్నారు.
51. అందువల్ల, మేము ముందుకు వెళ్ళేటప్పుడు ఇది రాష్ట్రానికి ప్రాథమిక అర్ధం, మేము వస్తువుపై ప్రవర్తన గురించి మరింత చర్చిస్తాము.
52. అందువల్ల, మాడ్యూల్ 11 ను దీనితో మూసివేస్తాము.
53. మాడ్యూల్ 11 లో, మేము ఈ క్రింది వాటిని కవర్ చేసాము, దీనిలో డేటా సభ్యులు మరియు పద్ధతులతో తరగతి యొక్క ప్రాథమిక భావనను మేము అర్థం చేసుకున్నాము.
54. కాంప్లెక్స్ యొక్క నేమ్‌స్పేస్‌లో గుణాలు లేదా డేటా సభ్యుల పేరు పెట్టవచ్చని మేము చూశాము.
55. కాబట్టి, మళ్ళీ, re_ అండర్ స్కోర్ పేరు వాస్తవానికి సంక్లిష్టమైనది :: re మరియు మొదలైనవి.
56. ఈ పద్ధతి క్యాంపస్ పేరు స్థలంలో కూడా ఇదే విధంగా పేరు పెట్టబడింది.
57. కాబట్టి, ఒక పద్ధతి ప్రమాణానికి కాంప్లెక్స్ :: ప్రమాణం () అనే పేరు ఉంది.
58. వస్తువులు తరగతుల ఇన్‌స్టాంటియేషన్స్ మరియు అవి వేగవంతం అయినప్పుడు ప్రారంభించబడతాయి, అక్షం డాట్ ఆపరేటర్ యొక్క ఉపయోగాన్ని సూచించడానికి ఉపయోగించబడుతుంది మరియు ప్రత్యేకమైన "ఈ" పాయింటర్‌ను కలిగి ఉంటుంది, ఇది ప్రతి వస్తువును దాని స్వంత చిరునామా ద్వారా గుర్తిస్తుంది, దీనిని ఉపయోగించవచ్చు వివిధ మార్గాలు. 
 C ++ లో ప్రోగ్రామింగ్ యొక్క మాడ్యూల్ 11 యొక్క పార్ట్ -2 కు స్వాగతం.
ఈ మాడ్యూల్ యొక్క మొదటి భాగంలో, తరగతుల యొక్క ప్రాథమిక భావనలను మరియు తరగతుల ఉదాహరణలను వస్తువులుగా చూశాము.
మేము అర్థం చేసుకున్నాము, డేటా సభ్యులు మరియు పద్ధతులు ఏమిటి.
మేము ముఖ్యంగా సంక్లిష్ట సంఖ్యల యొక్క మూడు ఉదాహరణలను చర్చించాము; చుక్కలు మరియు స్టాక్‌తో దీర్ఘచతురస్ర వస్తువులు.
ఒక వస్తువును గుర్తించడానికి "ఈ" పాయింటర్‌ను కూడా మేము అర్థం చేసుకున్నాము.
మిగిలిన భాగంలో మనం వస్తువు యొక్క స్థితిగా పిలువబడే వాటిని క్లుప్తంగా చర్చిస్తాము.
ఇది C ++ సందర్భాలలో ఆబ్జెక్ట్-ఓరియెంటెడ్ మోడల్ వర్తించే విధానం నుండి ఉద్భవించింది.
ఒక వస్తువు యొక్క స్థానం దాని అన్ని డేటా సభ్యుల మిశ్రమ విలువ ద్వారా నిర్ణయించబడుతుంది అని మేము చెప్తాము.
సరళమైన మాటలలో, మనం సంక్లిష్టమైన ఉదాహరణకి తిరిగి వెళుతున్నామని చెప్పండి.
కాబట్టి, ఈ డేటా భాగం ఖచ్చితంగా ఒకే విధంగా ఉంటుంది, ప్రదర్శన ప్రయోజనాల కోసం మాకు కొన్ని అదనపు పద్ధతులు ఉన్నాయి.
కాబట్టి, ఈ డేటా సభ్యులను ఏమని పిలుస్తారు? వారు నా వద్ద ఒక సంక్లిష్ట సంఖ్య ఉంటే, నేను దానిని తీయగలిగితే, అది ఒక సంక్లిష్ట సంఖ్య, దానికి 're (re)' భాగం మరియు తరువాత 'im' భాగం ఉంటుంది.
కాబట్టి, ఇది సంక్లిష్ట సంఖ్య.
కాబట్టి, సి 1 ను 4.2, 5.3 గా నిర్వచించామని నేను చెబితే, అది సి 1 అని చెప్పగలను మరియు అది 4.2 మరియు ఇది 5.3.
కాబట్టి, రాష్ట్ర భావన, ఇది రెట్టింపు విలువ అని మేము చెప్తాము; దీనికి డబుల్ విలువ కూడా ఉంది.
కాబట్టి, నేను మళ్ళీ విలువగా ఏదైనా డబుల్ విలువను కలిగి ఉండగలనని నాకు తెలుసు.
అదేవిధంగా, నేను ఏదైనా డబుల్ విలువను im విలువగా ఉంచగలను.
అందువల్ల, నేను తిరిగి ప్రవేశించగలిగే ప్రతి జత డబుల్ విలువలు వేరే సంక్లిష్ట సంఖ్యను తెలియజేస్తాయి.
కాబట్టి, నేను సి 1 ని మార్చుకుంటే, నేను ఈ విలువను మార్చుకుంటే లేదా నేను ఈ విలువను మార్చుకుంటే లేదా నేను రెండు విలువలను మార్చుకుంటే.
కాబట్టి, సి 1 వేరే రాష్ట్రాన్ని సంపాదించిందని మేము చెబుతాము.
ఒక వస్తువు యొక్క డేటా సభ్యుడు ఒక నిర్దిష్ట విలువల కలయికను నిర్వహిస్తున్నంత కాలం, అది ఒక స్థితిలో ఉందని మరియు డేటా సభ్యుల్లో ఎవరైనా దాని విలువను మార్చిన వెంటనే, అది వేరే స్థితిలో ఉందని మేము చెప్తాము.
అందువల్ల, చివరికి, ప్రోగ్రామింగ్‌లో, వస్తువు ఏ స్థితిలో ఉందో నిర్ణయించడం మరియు పద్ధతుల వాడకంతో, తదుపరి స్థితిలో కనుగొనగల వస్తువు.
ఈ కదలికలన్నింటినీ మేము తరువాత చూస్తాము, కానీ ఇది మీకు చూపించడానికి మాత్రమే, లోతుగా ఉన్న రాష్ట్ర భావన ఏమిటి? మేము ఇక్కడ నాలుగు పద్ధతులను మాత్రమే ఉపయోగిస్తున్నట్లు చూపించడానికి, వాటిని దగ్గరగా చూడండి, get_re; సాధారణంగా, భాగం తిరిగి రాబడిని చదువుతుంది.
కాబట్టి, c1 4.2, 5.3 మరియు నేను c1.get_re ను ఇన్వోక్ చేస్తే, నేను స్పష్టంగా 4.2 పొందుతాను.
అదేవిధంగా, నేను get_im చేస్తే, అది నాకు 5.3 తిరిగి ఇస్తుంది మరియు మిగిలిన రెండు సెట్ చేయబడతాయి.
కాబట్టి, ప్రాథమికంగా నేను set_re పద్ధతిలో మళ్ళీ ఒక విలువను దాటితే, అది ఆ విలువను నేను set_re అని పిలిచిన వస్తువు యొక్క re_ భాగంలో సెట్ చేస్తుంది.
అందువల్ల, వీటిని సాధారణంగా సెట్ పద్ధతి అని పిలుస్తారు, మేము వాటిని మరింత సూచిస్తాము.
కాబట్టి, దీనితో, నేను దానిలోకి వెళ్ళగలనని హంకరాయ చెబితే మనం చూస్తామా? కాబట్టి, ఇది ప్రారంభమైనది, ఇది 4.2, 5.3 తో ప్రారంభించబడింది.
అందువల్ల, సి యొక్క స్థితి 1, 4.2, 5.3, ఎందుకంటే ఇద్దరు డేటా సభ్యులు ఉన్నారు.ఒక జత సంఖ్యల పరంగా రెట్టింపు పరంగా రాష్ట్రం ఇక్కడ నిర్వచించబడింది.
అప్పుడు, నేను c.set_re (6.4) చేస్తే, 4.2 6.4 కి మారుతుంది.
కాబట్టి, నాకు కొత్త రాష్ట్రం రెండు ఉంది, ఇది 6.4, 5.3 ఇక్కడ ఉంది, అంటే 2 రాష్ట్రం.
ఇప్పుడు, మేము c.get_re ను ఇన్వోక్ చేద్దాం అనుకుందాం, ఇది ప్రాథమికంగా ఇప్పుడు c, ఇది c ఆబ్జెక్ట్ యొక్క పున component భాగాన్ని 6.4 చదువుతుంది.
కాబట్టి, ఇది 6.4 ను తిరిగి ఇస్తుంది, కానీ వస్తువు యొక్క re లేదా i భాగాలలో ఎటువంటి మార్పు లేదని మీరు గమనించవచ్చు.
అందువల్ల, రాష్ట్రంలో ఎటువంటి మార్పు లేదని మీరు నిర్ధారిస్తారు, కాబట్టి ఇది రాష్ట్ర 2 లో కొనసాగుతుంది.
నేను set_im (7.8) చేస్తే, సహజంగానే నా స్థితి మారుతుంది ఎందుకంటే ఇప్పుడు వస్తువు సృష్టించబడుతుంది (6.4,7.8).
కాబట్టి, ఒక వస్తువుపై వేర్వేరు కార్యకలాపాలు జరిగే విధంగా, ఇది వేర్వేరు రాష్ట్రాల గుండా వెళుతుంది మరియు డేటా సభ్యుడు ఒక విధంగా ఆబ్జెక్ట్ యొక్క స్థానం మిస్ అవుతుందని మేము ఎల్లప్పుడూ చెబుతాము.
ఇది ఒక దీర్ఘచతురస్రాన్ని చూపించే ఉదాహరణ, ఇది మూలలో బిందువులు మరియు మేము కార్నర్ పాయింట్ల యొక్క వేర్వేరు కోఆర్డినేట్‌లను మార్చాము లేదా మేము నిష్పత్తిని లెక్కిస్తాము, వస్తువు యొక్క స్థానం ఎలా మారుతుందో చూపిస్తాము.
స్టాక్‌పై మరో ఉదాహరణ ఉంది.
కాబట్టి, మేము స్టాక్లో ఏమి కలిగి ఉన్నాము? మాకు డేటా శ్రేణి మరియు సూచించిన శీర్షికలు ఉన్నాయి.
అందువల్ల, రాష్ట్రం మొత్తం శ్రేణిని కలిగి ఉంటుంది.
కాబట్టి, డేటా శ్రేణి శ్రేణి పరిమాణం 5 అయితే, దీనికి అన్ని అక్షరాలను సూచించే 5 టుపుల్ ఉంటుంది, ఈ డేటా శ్రేణిలోని మరొక భాగం శీర్షం, ఇది శీర్ష విలువ.
కాబట్టి, ఇవన్నీ కలిసి నాకు ఒక రాష్ట్రాన్ని ఇస్తాయి మరియు ఇవన్నీ ప్రశ్న గుర్తులు ఎందుకంటే ప్రారంభంలో ఏమీ చేయలేదు.
అందువల్ల, వస్తువు ఏ స్థితిలో ఉందో నాకు తెలియదు.
కానీ, నేను ఎగువన ప్రారంభించిన వెంటనే, అది మైనస్ 1 అవుతుంది.
కాబట్టి, నేను కొంత స్థితిని పొందుతున్నాను, కాని నేను B ని నెట్టే శ్రేణి యొక్క స్థితి ఏమిటో నాకు ఇంకా తెలియదు.
కాబట్టి, మొదటి అక్షరం అవుతుంది, అది 0 కి పెరుగుతుంది, నా స్థానం మారుతుంది, నేను ఈ మార్పును 'B' 'A' కి నెట్టివేస్తాను.
నేను ఖాళీగా తనిఖీ చేసినప్పుడు, అది ఖాళీగా లేదు మరియు అది నాకు తప్పుడు తిరిగి ఇస్తుంది మరియు ఇది ఎగువ శ్రేణిని మార్చదు.
కాబట్టి, రాష్ట్రంలో మార్పు లేదు.
కాబట్టి, మీరు దానిని అనుసరించడానికి కొనసాగితే, పుష్ మరియు పాప్ యొక్క ఆపరేషన్‌తో, మేము వాస్తవానికి రాష్ట్రాన్ని మారుస్తున్నామని మీరు చూస్తారు, అయితే ఎగువ మరియు ఖాళీతో మేము రాష్ట్రాన్ని మార్చము మరియు ఒక స్టాక్‌ను ఏ సమయంలోనైనా వివరించవచ్చు.
దాని శ్రేణి యొక్క స్థానం మరియు టాప్ మార్కర్ యొక్క స్థానం పరంగా.
కాబట్టి, మీరు రాష్ట్రాల గురించి తరచుగా విన్నారు.
అందువల్ల, మేము ముందుకు వెళ్ళేటప్పుడు ఇది రాష్ట్రానికి ప్రాథమిక అర్ధం, మేము వస్తువుపై ప్రవర్తన గురించి మరింత చర్చిస్తాము.
అందువల్ల, మాడ్యూల్ 11 ను దీనితో మూసివేస్తాము.
మాడ్యూల్ 11 లో, మేము ఈ క్రింది వాటిని కవర్ చేసాము, దీనిలో డేటా సభ్యులు మరియు పద్ధతులతో తరగతి యొక్క ప్రాథమిక భావనను మేము అర్థం చేసుకున్నాము.
కాంప్లెక్స్ యొక్క నేమ్‌స్పేస్‌లో గుణాలు లేదా డేటా సభ్యుల పేరు పెట్టవచ్చని మేము చూశాము.
కాబట్టి, మళ్ళీ, re_ అండర్ స్కోర్ పేరు వాస్తవానికి సంక్లిష్టమైనది :: re మరియు మొదలైనవి.
ఈ పద్ధతి క్యాంపస్ పేరు స్థలంలో కూడా ఇదే విధంగా పేరు పెట్టబడింది.
కాబట్టి, ఒక పద్ధతి ప్రమాణానికి కాంప్లెక్స్ :: ప్రమాణం () అనే పేరు ఉంది.
వస్తువులు తరగతుల ఇన్‌స్టాంటియేషన్స్ మరియు అవి వేగవంతం అయినప్పుడు ప్రారంభించబడతాయి, అక్షం డాట్ ఆపరేటర్ యొక్క ఉపయోగాన్ని సూచించడానికి ఉపయోగించబడుతుంది మరియు ప్రత్యేకమైన "ఈ" పాయింటర్‌ను కలిగి ఉంటుంది, ఇది ప్రతి వస్తువును దాని స్వంత చిరునామా ద్వారా గుర్తిస్తుంది, దీనిని ఉపయోగించవచ్చు వివిధ మార్గాలు. 
inhouse/NPTEL/PreFinal/c++/Telugu/44. ProgramminginCplusplus_Const-ness (Contd.) (Lecture 30)-_8-su7gHFvo.txt
View file @ 956c0d4e
 1. C ++ లో ప్రోగ్రామింగ్ యొక్క మాడ్యూల్ 15 కు స్వాగతం.
2. మేము కాన్స్ట్-నెస్ గురించి చర్చిస్తున్నాము, మేము నిరంతర వస్తువులను ప్రవేశపెట్టాము; స్టాటిక్ ఆబ్జెక్ట్ యొక్క ఈ పాయింటర్ దాని రకానికి ఎలా మారుతుందో మేము చూశాము ఎందుకంటే ఇది ఇప్పుడు స్థిరమైన వస్తువును సూచించే నిరంతర పాయింటర్ అవుతుంది.
3. మేము ఒక సాధారణ లేదా స్థిర-కాని సభ్యుల ఫంక్షన్‌ను ప్రారంభించలేమని ఒక స్టాటిక్ ఆబ్జెక్ట్‌తో చూశాము మరియు నిరంతర సభ్యుల ఫంక్షన్ యొక్క భావనను ప్రవేశపెట్టాము, దీనిలో ఈ రకమైన పాయింటర్ (పాయింటర్)), ఇది స్టాటిక్ కు స్థిరమైన పాయింటర్ ఆబ్జెక్ట్ మరియు స్థిరమైన సభ్యుల ఫంక్షన్‌ను ఉపయోగించి మనం చూశాము, స్థిరమైన వస్తువును ఎలా రక్షించగలం మరియు ఇప్పటికీ డేటా (డేటా) సభ్యుల విలువను చదవడానికి లేదా యాక్సెస్ చేయడానికి సభ్యుల ఫంక్షన్‌ను ఆహ్వానించగలదు మరియు ఒక తరగతిలో ఉన్నప్పుడు, సభ్యుల ఫంక్షన్ ఏ వస్తువును మార్చడం లేదు, కనుక ఇది స్థిరంగా ఉండాలి.
4. వాస్తవానికి, ఒక సభ్యుడు ఫంక్షన్ యొక్క కొంత భాగాన్ని మార్చాలనుకుంటే, అప్పుడు డేటా సభ్యులలో ఎవరూ అది కాన్స్ట్ మెంబర్ ఫంక్షన్ కాకూడదు మరియు తప్పనిసరిగా మీకు లోపం ఇస్తుంది; సహజంగానే, ఆ సభ్యుల విధులు const వస్తువులతో ప్రారంభించబడవు.
5. స్థిరమైన డేటా సభ్యుడిని ఉపయోగించి వస్తువు యొక్క భాగాన్ని ఎంపిక చేసుకోవచ్చని కూడా మేము చూశాము మరియు కాన్స్ట్ డేటా సభ్యులను ఏ సభ్యుల ఫంక్షన్ ద్వారా భర్తీ చేయలేమని మరియు వాటిని ప్రారంభించాల్సిన అవసరం ఉందని మేము చూశాము, వారు ఆ సమయంలో ప్రారంభించాలి క్రెడిట్ కార్డ్ యొక్క సృష్టి మరియు ఉదాహరణ, క్లాస్ ఎడిషన్‌ను రూపొందించడానికి కాన్స్ట్ (కాన్స్ట్) డేటా సభ్యులను ఎలా ఉపయోగించవచ్చో మేము చూపించాము, ఇక్కడ తెలిసిన సవరించగలిగే డేటా, వారు సాధారణ డేటా లేదా సూచించిన రకం డేటా అయినా ఉపయోగించవచ్చు. అప్లికేషన్ ఏదైనా నుండి రక్షించబడుతుంది మార్పులు.
6. ఇప్పుడు మనం ముందుకు వెళ్లి మరొక ఫీచర్ గురించి మాట్లాడుతాము, ఇది మ్యూటబుల్ డేటా మెంబర్ అని పిలువబడే మరొక సెలెక్టివ్ కాన్-నెస్ ఫీచర్.
7. మ్యూటబుల్ - మ్యూటబుల్ అనే భావన కాన్-నెస్ అనే భావనతో దగ్గరి సంబంధం కలిగి ఉంటుంది.
8. నిరంతర డేటా సభ్యుడు వేరియబుల్ కాదని మనకు తెలుసు, వస్తువు స్థిరంగా లేనప్పుడు కూడా ఇది మేము నేర్చుకున్నాము.
9. మరోవైపు, స్థూల డేటా సభ్యుడు వేరియబుల్ వస్తువు.
10. కాబట్టి, వేరియబుల్ కాని స్టాటిక్ ఆబ్జెక్ట్ ఆ స్థిరమైన వస్తువులో ఏమీ మార్చబడదు, కాని నేను క్లాస్ యొక్క డేటా సభ్యుడిని వేరియబుల్ గా నిర్వచించినట్లయితే, ఆ తరగతి యొక్క వస్తువు స్థిరంగా ఉండాలని నిర్వచించినప్పుడు కూడా నిర్దిష్ట డేటా సభ్యుడిని మార్చవచ్చు మరియు పేరు మ్యుటేషన్ యొక్క మూలం. మీకు తెలిసినట్లుగా మ్యుటేషన్ అంటే మార్పు, కాబట్టి వేరియబుల్ అంటే వేరియబుల్ డేటా (డేటా) ఒక సభ్యుడు.
11. ఇప్పుడు, పరస్పర డేటా సభ్యులు ఎందుకు ఉన్నారనే దానిపై ఒక ముఖ్యమైన కారణం మరియు నిర్దిష్ట ఉద్దేశ్యం ఉంది.
12. ఒక మ్యూటబుల్ కీ పదం అందించబడింది లేదా సి ++ యొక్క బిట్‌వైస్ కాన్-నెస్‌కు వ్యతిరేకంగా తార్కిక కాన్-నెస్‌కు మద్దతు ఇవ్వడానికి మ్యూట్ ఫీచర్ అందించబడుతుంది, అంటే నేను వస్తువును కాన్స్టాంట్‌గా ప్రకటిస్తున్నాను; ఈ వస్తువు స్థిరంగా ఉంటే నేను దానిలో ఏమీ మార్చలేనని చెప్తున్నాను.
13. అందులో ఏమీ మార్చలేకపోతే; దీని అర్థం, ప్రారంభించిన సమయంలో ఒక నిర్దిష్ట వస్తువుకు ఏ నమూనా లభించినా, ఆ బిట్ నమూనాలో ఎటువంటి మార్పు ఎప్పుడూ సాధ్యం కాదు, కానీ తరచూ దానితో పనిచేయడం కొంచెం కష్టమవుతుంది, నాకు ఒక భావన ఉంది నిరంతరాయంగా , కానీ దాని అమలుకు అదనపు ఫీల్డ్‌లు, అదనపు పారామితులు, నిజంగా స్థిరంగా లేని అదనపు డేటా సభ్యులు అవసరం కావచ్చు, కాబట్టి మేము దానిని పరిశీలిస్తాము.
14. ఈ సమయంలో, డేటా సభ్యుల విషయంలో మాత్రమే పరివర్తనం చెందుతుందని మీరు గమనించవచ్చు, మీకు మరొక సాధారణ వేరియబుల్ ఉంటే, మీరు దానిని వేరియబుల్ గా ప్రకటించలేరు మరియు ఏదైనా రిఫరెన్స్ డేటా (డేటా) స్టాటిక్. డేటా సభ్యుడు వాస్తవానికి మీరు ఇంకా స్టాటిక్ చేయలేదు డేటా సభ్యుడు, మేము తదుపరి మాడ్యూల్ గురించి మాట్లాడుతాము లేదా స్థిరమైన డేటా సభ్యులను పరివర్తనం చెందినట్లు ప్రకటించవచ్చు.
15. అతి ముఖ్యమైన భాగం ఏమిటంటే, డేటా సభ్యుడు పరివర్తన చెందినట్లు ప్రకటించబడితే, దానిని నిరంతర సభ్యుల ఫంక్షన్‌గా మార్చడం చట్టబద్ధం.
16. స్థిరమైన సభ్యుల ఫంక్షన్ ఏ డేటా సభ్యుడిని మార్చలేమని మేము చూశాము, కాని డేటా సభ్యుడు వేరియబుల్ అయితే, అది ఇప్పటికీ దానిని మార్చగలదు, ఎందుకంటే మీరు చెబుతున్నది వేరియబుల్ అంటే విషయాలు స్థిరంగా ఉన్నప్పుడు కూడా మార్చవచ్చు.
17. కాబట్టి, ఒక ఉదాహరణ చూద్దాం.
18. కాబట్టి, ఇక్కడ నేను ఒక డేటా సభ్యుడిని పరిచయం చేసాను, ఇది వేరియబుల్, కాబట్టి మీరు మాక్రోను వ్రాస్తున్నట్లుగా వాక్యనిర్మాణాన్ని పోలి ఉండేలా వ్రాస్తారు మరియు అప్పుడు మనకు స్థిరమైన వస్తువు (ఆబ్జెక్ట్) ఉంది) ప్రకటించింది, ఇప్పుడు మనకు ఒక పద్ధతి ఉంది, మనకు ఉంది నిర్వచించిన పద్ధతి.
19. ఇప్పుడు మేము నాన్ మ్యూటబుల్ కు సెట్టింగ్ భిన్నంగా ఉంటుంది, గేట్ ఒక కాన్స్ట్ మెంబర్ ఫంక్షన్, సెట్ ఒక కాని కాన్స్ట్ మెంబర్ ఫంక్షన్.
20. కాబట్టి, దీని అర్థం ఏమిటంటే, నా కాన్స్ట్ ఆబ్జెక్ట్ ఉంటే, నేను దాన్ని పొందగలను, నేను దానిని సెట్ చేయలేను ఎందుకంటే స్థిరమైన వస్తువు నాన్-స్టాటిక్ సభ్యుడిని ప్రారంభించదు.
21. ఇప్పుడు మార్చగల భాగాన్ని చూడండి, ఇక్కడ ఈ రెండు సభ్యుల విధులు కాన్స్టాంట్‌గా ప్రకటించబడ్డాయి, కాబట్టి ఈ రెండింటినీ స్టాటిక్ ఆబ్జెక్ట్ ద్వారా ప్రారంభించవచ్చు.
22. ఇప్పుడు ఈ ఫంక్షన్; సెట్ ఫంక్షన్ సభ్యుడిని మార్చడానికి ప్రయత్నిస్తుంది, ఈ ప్రత్యేక సభ్యుడు మ్యుటబుల్ కాకపోతే, ఇది సంకలన లోపం, అది సాధ్యం కాదు, కానీ ఈ సభ్యుడు, డేటా సభ్యుడు వేరియబుల్ కాబట్టి, మార్పు అవసరం .
23. అందువల్ల, ఇది కాన్స్ట్ మెంబర్ ఫంక్షన్ అయినప్పటికీ, ఇది డేటా సభ్యుడిని సవరించగలదు, ఇది మ్యూటబుల్ డేటా సభ్యునిగా ఉండటానికి ప్రాథమిక ఫలితం, కాబట్టి ఇది లక్షణం యొక్క ప్రాథమిక ప్రవర్తన.
24. ఇప్పుడు దానిని ఎలా ఉపయోగించాలో, ఎలా ఉపయోగించాలో ఉపయోగించడానికి ప్రయత్నించండి.
25. కాబట్టి, స్థిరమైన వస్తువు యొక్క బిట్‌లను ఏమీ మార్చలేమని నేను సి ++ మోడల్‌లో సున్నితమైన బిట్ స్థిరాంకానికి చెబుతున్నప్పుడు, కానీ చాలా ముఖ్యమైనది ఏమిటంటే నాకు ఒక కాన్సెప్ట్ ఉంది. ఇది తార్కికంగా స్థిరంగా ఉంది, నేను మోడల్ చేయడానికి ప్రయత్నిస్తున్నాను కొన్ని స్థిర, భావన.
26. అందువల్ల, ఇది కొంతమంది డేటా సభ్యుల పరంగా వివరించబడింది, కానీ నేను కొన్ని లెక్కలు చేయాలనుకున్నప్పుడు; అదే తరగతిలో నాకు మరికొన్ని డేటా సభ్యులు కావాలి, నేను లెక్కకు మద్దతు ఇస్తున్నాను.
27. ఇప్పుడు నేను వస్తువును స్థిరంగా చేస్తే, అన్ని బిట్స్ నిరంతరంగా ఉన్నందున అవి ఖచ్చితంగా అన్నింటినీ మార్చలేవు, అంటే కేవలం గణనకు మద్దతు ఇస్తున్న వేరియబుల్ సర్రోగేట్ డేటా సభ్యులు అని పిలవబడేవారు కూడా కాదు కాబట్టి నేను వ్రాయలేను కోడ్.
28. ఈ సమస్య చుట్టూ పనిచేయడానికి మ్యూటబుల్ అందించబడింది, కాబట్టి మ్యూటబుల్‌ను ఉపయోగించడం లేదా సమర్థవంతంగా ఉపయోగించడం, మేము ప్రాథమికంగా ఉపయోగిస్తాము; దయచేసి ఈ రెండు అంశాలను గుర్తుంచుకోవడానికి ప్రయత్నించండి, మేము ఉపయోగించడానికి ప్రయత్నిస్తాము; తార్కికంగా స్థిరమైన భావన కోసం చూడండి, ఇది ప్రోగ్రామింగ్ ముగింపు కోసం మాత్రమే కాదు. తార్కికంగా స్థిరంగా ఉండే ఒక భావన ఉండాలి మరియు ఆ భావనను అమలు చేయడానికి, మాకు కొంతమంది డేటా సభ్యులు కావాలి. ఆ భావనకు దూరంగా ఉండాలి, మాత్రమే వ్రాయబడుతుంది అవసరమైన గణన, ఇది చాలా స్పష్టంగా అనిపించదని నేను ఖచ్చితంగా అనుకుంటున్నాను, కాబట్టి నేను ఒక ఉదాహరణ తీసుకోవాలి.
29. మేము తరువాత టాప్ నోట్స్ చదువుతాము; మొదట మనం ఏమి చేస్తున్నామో అర్థం చేసుకుందాం.
30. మేము తరగతి గణిత వస్తువును నిర్వచిస్తున్నాము మరియు అలా చేయాలనేది నా ఉద్దేశం.
31. ఈ నమూనా విషయంలో, నా ఉద్దేశ్యం మఠం వస్తువు, నేను స్టాటిక్ ఆబ్జెక్ట్ ఇవ్వాలి, ఇది పై, మనందరికీ పై 3.14159 తెలుసు.
32. కాబట్టి, నాకు కావలసినది ఏమిటంటే, నేను ఒక వస్తువును సృష్టించినప్పుడల్లా నేను ఈ తరగతి యొక్క స్టాటిక్ ఆబ్జెక్ట్‌ని సృష్టిస్తాను, నేను స్టాటిక్ కాని వస్తువును సృష్టించను.
33. అందువల్ల, నేను దానిని నిర్మిస్తాను మరియు నేను ఈ పద్ధతిని పై (పై) ను వర్తింపజేస్తే, అది నాకు పై (పై) విలువను ఇవ్వాలి.
34. ఇప్పుడు మనం పై విలువను ఎందుకు పొందాలి, పై (పై) ఒక అతీంద్రియ సంఖ్య అని మీకు తెలిసిన అల్గోరిథం, కాబట్టి నేను దానిని అణిచివేయలేను, ఇది ఉజ్జాయింపు. పొడవైన గొలుసు, పొడవాటి తోక ఉంది ఉజ్జాయింపు.
35. కాబట్టి, ఒక అల్గోరిథం వలె, PI ను లెక్కించడానికి మంచి అల్గోరిథంలు ఉన్నాయని నేను నిరూపించాను, కానీ ఇది చాలా నెమ్మదిగా అల్గోరిథంతో జరుగుతుంది.
36. అందువల్ల, నేను ఈ మో డాట్ పిని ప్రారంభిస్తే; మో అనేది ఒక వస్తువు, కాబట్టి నేను మో డాట్ పై (పై) చేస్తే దాన్ని స్టాటిక్ మెంబర్ ఫంక్షన్ అని పిలుస్తారు. దీనిని స్టాటిక్ ఆబ్జెక్ట్ అని పిలుస్తారు, ఈ అల్గోరిథం అమలు చేస్తుంది మరియు నాకు పై విలువను ఇస్తుంది.
37. ఇప్పుడు, ఇది చాలా నెమ్మదిగా ఉన్నందున, ఇది చాలా నెమ్మదిగా ఉంటుంది, నేను కొన్ని కాషింగ్ చేయాలనుకుంటున్నాను, అంటే పై (పై) స్థిరంగా ఉందని నాకు తెలుసు; భావన స్థిరంగా ఉంటుంది.
38. కాబట్టి, నేను ఒకసారి లెక్కించినట్లయితే, రెండవసారి నేను లెక్కించినప్పుడు నాకు అదే విలువ లభిస్తుంది, అందుకే నేను మళ్ళీ ఎందుకు లెక్కించాలి, కాబట్టి నేను దానిని లెక్కించాను లేదా నేను లెక్కించలేదా అని గుర్తుంచుకోవాలి.
39. అందువల్ల, నేను దానిని మొదటిసారి లెక్కించినప్పుడు, తదుపరిసారి నేను అదే లెక్కించిన విలువను ఉపయోగించాలి, కాబట్టి నేను అందులో ఇద్దరు డేటా సభ్యులను ఉపయోగిస్తాను, ఒకటి పై (పై) విలువ; ప్రారంభంలో నాకు తెలియని విలువ, నేను దానిని కన్స్ట్రక్టర్‌లో ఉంచలేను ఎందుకంటే విలువ ఏమిటో నాకు తెలియదు, దానిని లెక్కించాలి.
40. ఎవరైనా పై (పై) విలువను ఉపయోగించాలనుకుంటే తప్ప నేను ఆ గణన చేయను ఎందుకంటే నేను చెప్పినట్లుగా చాలా సమయం పడుతుంది మరియు పై (పి) ను మొదటిసారి ఉపయోగించినప్పుడు ఈ సభ్యుల ఫంక్షన్ (ఫంక్షన్) అని పిలుస్తారు.
41. ఇప్పుడు, నేను మరొక డేటా సభ్యుడు పై కాష్‌ను నిర్వహిస్తున్నాను, ఇది బూల్ ఫ్లాగ్, ఇది పై (పై) లెక్కించబడిందా లేదా లెక్కించబడలేదా అని గుర్తుంచుకుంటుంది.
42. అందువల్ల, ఆ జెండా మొదట్లో వస్తువు యొక్క కన్స్ట్రక్టర్‌లో తప్పుగా సెట్ చేయబడింది, కనుక ఇది లెక్కించబడలేదని చెబుతుంది.
43. కాబట్టి, ఇప్పుడు నేను పై (పై) అని పిలిస్తే, ఈ చెక్ పై (పై) లెక్కించబడదని చెబుతుంది, ఇది పూర్తి గణన అవుతుంది, డేటా (డేటా) సభ్యుడు పై (పై) లో విలువ నవీకరించబడుతుంది మరియు వెంటనే నేను పునరావృతం పూర్తి చేస్తాను, నేను బయటకు వచ్చి p కాష్‌ను నిజం అని జోడిస్తాను.
44. అందువల్ల, భవిష్యత్తులో ఎప్పుడు అది డేటా సభ్యుడు పి; సభ్యుల ఫంక్షన్ (పై) ను మళ్ళీ పిలిచినప్పుడు, అది నిజం అవుతుంది.అందువల్ల, ఇది పూర్తిగా దాటవేయబడుతుంది మరియు నేను చేయగలను; ఇది అవుతుంది, ఇది అందుకున్న ఫంక్షన్ లాగా ప్రవర్తిస్తుంది, ఇది కేవలం పై అవుతుంది, కాబట్టి ఇది ఒక్కసారి మాత్రమే అమలు చేయబడిందని మరియు అనేకసార్లు ఉపయోగించబడుతుందని నిర్ధారిస్తుంది.
45. కాబట్టి మీరు దీన్ని ఎలా చేయగలరో చూద్దాం, మనకు అవసరమైన మొదటి విషయం ఏమిటంటే, ఈ వస్తువు స్థిరంగా ఉండాలి అని చెప్పాలి ఎందుకంటే పై (పై) స్థిరంగా ఉండకూడదు.
46. కాబట్టి నిరంతర భావన పై, కాబట్టి అది నా ప్రాథమిక అవసరం, ఇది నిరంతరంగా ఉండాలి.
47. ఇప్పుడు అది స్థిరంగా ఉంటే, ఈ ఇద్దరు డేటా సభ్యుల నుండి ఈ డేటా సభ్యులను మార్చలేరు; ఉదాహరణకు, కాష్ చేసిన డేటా సభ్యుడు కాష్ చేసిన డేటా సభ్యుల భావనలో భాగం కాదని ఈ డేటా సభ్యులు పేర్కొన్నారు.
48. పై యొక్క విలువను గుర్తించడం నిరంతర భావన కాదు. భావన యొక్క కొనసాగింపు పై (పై) విలువలో ఉంటుంది.
49. కాబట్టి, పై (పై) కాష్ అవసరం ఎందుకంటే నేను లెక్కించాలనుకుంటున్నాను, ఇది పై (పై); విలువను సవరించాల్సిన అవసరం ఉంది, ఎందుకంటే నేను ప్రారంభించేటప్పుడు ఆ విలువ ఏమిటో నాకు తెలియదు.
50. కాబట్టి, ఈ డేటా సభ్యులు ప్రాథమికంగా భావన అమలుకు మద్దతు ఇస్తున్నారు, కాబట్టి మీరు తీసుకుంటే; నాకు స్థిరమైన వస్తువు ఉంటుంది అప్పుడు మో; మో తప్పు అవుతుంది మరియు తక్కువ తెలివితేటలు స్థిరంగా మారినవి ఏమీ మార్చబడవు, కాబట్టి ఈ మొత్తం వ్యూహం పనిచేయదు.
51. అందువల్ల, నేను ఈ ఇద్దరు డేటా సభ్యులను మార్చాను (సమయం చూడండి: 14:12). వస్తువు స్థిరంగా ఉన్నప్పటికీ, భావన స్థిరంగా ఉంటుంది, కానీ అమలులో నాకు కొంతమంది డేటా సభ్యులు కావాలి, అవి నిరంతరం ఉండవలసిన అవసరం లేదు మరియు ఇది కలిగి ఉండాలి కాన్స్టెన్స్ యొక్క భావాన్ని లాజికల్ కాన్-నెస్ అంటారు.
52. కాబట్టి, మీరు బిట్ నమూనాను చూస్తే; బిట్ సరళి మారుతోంది, కానీ మీరు ప్రాతినిధ్యం వహించాలనుకున్నది పై యొక్క ప్రాథమిక భావన, ఇది స్థిరంగా సంరక్షించబడుతుంది.
53. కాబట్టి, ఈ పద్ధతిలో మ్యుటేషన్ చాలా నిర్దిష్టమైన ఉద్దేశ్యాన్ని కలిగి ఉంది మరియు నా జ్ఞానం మేరకు ఒక నిర్దిష్ట కేసు, బహుశా పరివర్తన చెందిన ఏకైక సందర్భం.
54. కాబట్టి, ఇప్పుడు, మీరు ప్రారంభ వ్యాఖ్యలను చదవవచ్చు, ఇది ఒక తరగతి స్థిరమైన భావనను సూచించినప్పుడు సాధారణంగా ఉపయోగించబడుతుంది మరియు ఇది మొదట విలువను లెక్కిస్తుంది మరియు భవిష్యత్తు ఉపయోగం కోసం ఫలితాన్ని క్యాష్ చేస్తుంది.
55. కాబట్టి, వేరియబుల్‌పై చర్చను పూర్తి చేయడానికి, ఎప్పుడు మ్యూటబుల్ ఉపయోగించకూడదో నేను ఒక ఉదాహరణను ప్రదర్శించాలనుకుంటున్నాను, ఎందుకంటే ఇది చాలా సుష్ట భావన అని మీకు తెలుసు.
56. నేను స్థిరమైన వస్తువులో డేటా సభ్యులను స్థిరంగా చేయగలను మరియు చాలా సుష్ట భావన అయిన స్టాటిక్ ఆబ్జెక్ట్‌లో డేటా సభ్యులను స్థిరంగా చేయగలను.
57. అందువల్ల, విద్యార్థులు వాటిని పరిపూరకరమైన భావనకు సమానంగా ఉపయోగించడంలో తప్పు చేస్తున్నారని నేను తరచుగా గమనించాను, కాని ఇది నిజం కాదు.
58. అందువల్ల, నేను ఉద్యోగి తరగతి, ఉద్యోగి పేరు, ఐడి మరియు జీతం యొక్క ఉదాహరణను చూపించవలసి ఉంది.
59. కాబట్టి, నేను సరే అని చెప్తున్నాను, ఉద్యోగులు ఒకసారి సృష్టించారు. ఇది ఉద్యోగుల మార్పు సాధ్యం కాని సంస్థ అని చెప్పండి, కాబట్టి ఒకసారి ఉద్యోగులు స్థిరమైన వస్తువుగా ఉంటే, వారు మారరు. వెళ్ళవచ్చు.
60. అందువల్ల, మేము ఉద్యోగిని వ్రాసే అప్లికేషన్ స్థిరంగా ఉంటుంది, కానీ ఉద్యోగుల జీతం మారుతుంది, ఉద్యోగులకు పదోన్నతి అవసరం, వారికి పదోన్నతి అవసరం, అప్పుడు వారికి మంచి జీతం లభిస్తుంది మరియు ఉద్యోగి నిరంతరాయంగా ఉంటే, అది కాదు జాన్ నిరంతరాయంగా ఉంటే సాధ్యమవుతుంది, కాబట్టి నేను దానిని నిరంతర సభ్యుల పనిగా చేస్తాను.
61. ఇది నిరంతర సభ్యుల ఫంక్షన్ అయితే, అది కూడా లోపం ఎందుకంటే నిరంతర సభ్యుల ఫంక్షన్ డేటా సభ్యుడిని మార్చదు; కాబట్టి పని చేయడానికి నేను మ్యూటబుల్ ఉంచుతాను, ఈ కోడ్ కంపైల్ చేయబడుతుంది, ఈ కోడ్ రన్ అవుతుంది, ఈ కోడ్ ఫలితాలను ఇస్తుంది, సి ++ (సింటాక్స్) యొక్క వాక్యనిర్మాణానికి సంబంధించినంతవరకు ఏమీ తప్పు లేదు, కానీ ఇప్పటివరకు డిజైన్, కాన్సెప్ట్ చేర్చబడింది లేదా ఇతరులు ఇప్పటివరకు ఆ కోడ్ నుండి ఏమి అర్థం చేసుకుంటారు, ఇది ఒక విపత్తు.
62. ఇది నిరంతర భావనలను ప్రత్యేకంగా మోడల్ చేయడానికి పరిచయం చేయబడినందున ఇది విపత్తు, ఉద్యోగులు నిరంతర భావనలు కాకూడదు, అవి నిరంతర భావనలు అయితే వారి జీతం కూడా నిరంతరంగా ఉంటుంది, జీతం కూడా ఉంటుంది. వేరియబుల్ కాకూడదు ఎందుకంటే ఇది ఒక భాగం మరియు భాగం ఉద్యోగి.
63. అందువల్ల, ఉద్యోగులు నిరంతరాయంగా ఉండనవసరం లేనందున వాటిని స్థిరంగా లేనివిగా చేస్తారని మేము ఇంతకుముందు చూపించినట్లుగా దీనిని మోడల్ చేయాలి; అవి సంభావితంగా స్థిరంగా ఉండవు, కానీ పేరు మరియు ఐడి అయిన ఉద్యోగి కోసం మార్చలేని డేటా సభ్యులను స్థిరంగా చేయండి మరియు వేరియబుల్ డేటా సభ్యుడు స్టాటిక్ కాని డేటా సభ్యుడు. మీరు దీన్ని సాధారణంగా ప్రోత్సహించే విధంగా సృష్టించండి, బూస్ట్ ఇకపై నిరంతర సభ్యుల పని కాదు మరియు అందువల్ల అవసరమైన విధంగా జీతం మార్పులు చేయవచ్చు.
64. అందువల్ల, మీరు ఈ రెండు భాగాల రూపకల్పనను జాగ్రత్తగా అధ్యయనం చేస్తే; సంబంధిత భాగాలు మరియు సంబంధిత ఉపయోగం రెండూ కోడ్ వారీగా పని చేస్తాయి, కాని కాన్సెప్ట్ వారీగా ఇది సరికాని డిజైన్, ఇది చేయకూడదు మరియు సాధారణ తరగతిని రూపొందించడానికి ఇది సరైన మార్గం, మీకు నిరంతర భావనలు ఉంటే మాత్రమే. మీరు చూపించాలనుకుంటే ఇది సహజ స్థిరాంకం లేదా ఇతర రకాల నిరంతర భావనలు అయినా, మీరు వాటిని సవరించగలిగేలా చేయడానికి మీ అమలు రకం డేటా సభ్యులలో ఒకదాన్ని ఉపయోగించాలి.
65. కాబట్టి, దీనితో మనం ప్రస్తుత మాడ్యూల్ చివరికి వస్తాము.
66. ఇక్కడ మేము C ++ లో Const-ness ను అధ్యయనం చేసాము, C ++ లో మేము Const-ness యొక్క మూడు రూపాలను చూశాము, ఆబ్జెక్ట్ పూర్తిగా స్థిరంగా ఉంటుంది మరియు వస్తువు స్థిరంగా ఉంటే, అది నిరంతర సభ్యుల విధులను మాత్రమే అమలు చేయగలదు.
67. అందువల్ల, స్థిరమైన సభ్యుల ఫంక్షన్లు వస్తువును మార్చలేవని మేము చూశాము, కాని స్థిరమైన వస్తువు (ఆబ్జెక్ట్) కూడా స్థిరమైన సభ్యుల ఫంక్షన్లను ప్రారంభించగలదు మరియు మేము ఉద్యోగి యొక్క ID వంటి వస్తువును ఎంచుకుంటే మీరు చేయాలనుకుంటే, అతను ఒక విద్యార్థి యొక్క రోల్ సంఖ్య.
68. ; అప్పుడు మేము సంబంధిత డేటా సభ్యుని సభ్యుడిని స్థిరంగా చేయవచ్చు, తరువాత నిరంతర సభ్యుల ఫంక్షన్ (ఫంక్షన్) లేదా నాన్-స్టేషనరీ మెంబర్ ఫంక్షన్ (ఫంక్షన్), వాటిలో ఏవీ స్థిరమైన డేటా సభ్యుడిని మార్చలేవు.
69. సి ++ డిఫాల్ట్‌గా కాస్ట్ వాడకంలో బిట్ వారీగా ఉండే కాన్-నెస్‌కు మద్దతు ఇస్తుందని మేము చూశాము, కాని తార్కిక కాన్-నెస్ సాధించడానికి ఒక పరివర్తన చెందిన డేటా సభ్యుడిని ఉపయోగించడం సాధ్యమవుతుంది, ఇది మనకు తార్కికంగా స్థిరమైన కాన్-నెస్ భావనను కలిగి ఉంటుంది మేము C ++ లోని పరివర్తన చెందిన డేటా సభ్యుడిని ఉపయోగించి కోడ్ చేయవచ్చు.
70.
 C ++ లో ప్రోగ్రామింగ్ యొక్క మాడ్యూల్ 15 కు స్వాగతం.
మేము కాన్స్ట్-నెస్ గురించి చర్చిస్తున్నాము, మేము నిరంతర వస్తువులను ప్రవేశపెట్టాము; స్టాటిక్ ఆబ్జెక్ట్ యొక్క ఈ పాయింటర్ దాని రకానికి ఎలా మారుతుందో మేము చూశాము ఎందుకంటే ఇది ఇప్పుడు స్థిరమైన వస్తువును సూచించే నిరంతర పాయింటర్ అవుతుంది.
మేము ఒక సాధారణ లేదా స్థిర-కాని సభ్యుల ఫంక్షన్‌ను ప్రారంభించలేమని ఒక స్టాటిక్ ఆబ్జెక్ట్‌తో చూశాము మరియు నిరంతర సభ్యుల ఫంక్షన్ యొక్క భావనను ప్రవేశపెట్టాము, దీనిలో ఈ రకమైన పాయింటర్ (పాయింటర్)), ఇది స్టాటిక్ కు స్థిరమైన పాయింటర్ ఆబ్జెక్ట్ మరియు స్థిరమైన సభ్యుల ఫంక్షన్‌ను ఉపయోగించి మనం చూశాము, స్థిరమైన వస్తువును ఎలా రక్షించగలం మరియు ఇప్పటికీ డేటా (డేటా) సభ్యుల విలువను చదవడానికి లేదా యాక్సెస్ చేయడానికి సభ్యుల ఫంక్షన్‌ను ఆహ్వానించగలదు మరియు ఒక తరగతిలో ఉన్నప్పుడు, సభ్యుల ఫంక్షన్ ఏ వస్తువును మార్చడం లేదు, కనుక ఇది స్థిరంగా ఉండాలి.
వాస్తవానికి, ఒక సభ్యుడు ఫంక్షన్ యొక్క కొంత భాగాన్ని మార్చాలనుకుంటే, అప్పుడు డేటా సభ్యులలో ఎవరూ అది కాన్స్ట్ మెంబర్ ఫంక్షన్ కాకూడదు మరియు తప్పనిసరిగా మీకు లోపం ఇస్తుంది; సహజంగానే, ఆ సభ్యుల విధులు const వస్తువులతో ప్రారంభించబడవు.
స్థిరమైన డేటా సభ్యుడిని ఉపయోగించి వస్తువు యొక్క భాగాన్ని ఎంపిక చేసుకోవచ్చని కూడా మేము చూశాము మరియు కాన్స్ట్ డేటా సభ్యులను ఏ సభ్యుల ఫంక్షన్ ద్వారా భర్తీ చేయలేమని మరియు వాటిని ప్రారంభించాల్సిన అవసరం ఉందని మేము చూశాము, వారు ఆ సమయంలో ప్రారంభించాలి క్రెడిట్ కార్డ్ యొక్క సృష్టి మరియు ఉదాహరణ, క్లాస్ ఎడిషన్‌ను రూపొందించడానికి కాన్స్ట్ (కాన్స్ట్) డేటా సభ్యులను ఎలా ఉపయోగించవచ్చో మేము చూపించాము, ఇక్కడ తెలిసిన సవరించగలిగే డేటా, వారు సాధారణ డేటా లేదా సూచించిన రకం డేటా అయినా ఉపయోగించవచ్చు. అప్లికేషన్ ఏదైనా నుండి రక్షించబడుతుంది మార్పులు.
ఇప్పుడు మనం ముందుకు వెళ్లి మరొక ఫీచర్ గురించి మాట్లాడుతాము, ఇది మ్యూటబుల్ డేటా మెంబర్ అని పిలువబడే మరొక సెలెక్టివ్ కాన్-నెస్ ఫీచర్.
మ్యూటబుల్ - మ్యూటబుల్ అనే భావన కాన్-నెస్ అనే భావనతో దగ్గరి సంబంధం కలిగి ఉంటుంది.
నిరంతర డేటా సభ్యుడు వేరియబుల్ కాదని మనకు తెలుసు, వస్తువు స్థిరంగా లేనప్పుడు కూడా ఇది మేము నేర్చుకున్నాము.
మరోవైపు, స్థూల డేటా సభ్యుడు వేరియబుల్ వస్తువు.
కాబట్టి, వేరియబుల్ కాని స్టాటిక్ ఆబ్జెక్ట్ ఆ స్థిరమైన వస్తువులో ఏమీ మార్చబడదు, కాని నేను క్లాస్ యొక్క డేటా సభ్యుడిని వేరియబుల్ గా నిర్వచించినట్లయితే, ఆ తరగతి యొక్క వస్తువు స్థిరంగా ఉండాలని నిర్వచించినప్పుడు కూడా నిర్దిష్ట డేటా సభ్యుడిని మార్చవచ్చు మరియు పేరు మ్యుటేషన్ యొక్క మూలం. మీకు తెలిసినట్లుగా మ్యుటేషన్ అంటే మార్పు, కాబట్టి వేరియబుల్ అంటే వేరియబుల్ డేటా (డేటా) ఒక సభ్యుడు.
ఇప్పుడు, పరస్పర డేటా సభ్యులు ఎందుకు ఉన్నారనే దానిపై ఒక ముఖ్యమైన కారణం మరియు నిర్దిష్ట ఉద్దేశ్యం ఉంది.
ఒక మ్యూటబుల్ కీ పదం అందించబడింది లేదా సి ++ యొక్క బిట్‌వైస్ కాన్-నెస్‌కు వ్యతిరేకంగా తార్కిక కాన్-నెస్‌కు మద్దతు ఇవ్వడానికి మ్యూట్ ఫీచర్ అందించబడుతుంది, అంటే నేను వస్తువును కాన్స్టాంట్‌గా ప్రకటిస్తున్నాను; ఈ వస్తువు స్థిరంగా ఉంటే నేను దానిలో ఏమీ మార్చలేనని చెప్తున్నాను.
అందులో ఏమీ మార్చలేకపోతే; దీని అర్థం, ప్రారంభించిన సమయంలో ఒక నిర్దిష్ట వస్తువుకు ఏ నమూనా లభించినా, ఆ బిట్ నమూనాలో ఎటువంటి మార్పు ఎప్పుడూ సాధ్యం కాదు, కానీ తరచూ దానితో పనిచేయడం కొంచెం కష్టమవుతుంది, నాకు ఒక భావన ఉంది నిరంతరాయంగా , కానీ దాని అమలుకు అదనపు ఫీల్డ్‌లు, అదనపు పారామితులు, నిజంగా స్థిరంగా లేని అదనపు డేటా సభ్యులు అవసరం కావచ్చు, కాబట్టి మేము దానిని పరిశీలిస్తాము.
ఈ సమయంలో, డేటా సభ్యుల విషయంలో మాత్రమే పరివర్తనం చెందుతుందని మీరు గమనించవచ్చు, మీకు మరొక సాధారణ వేరియబుల్ ఉంటే, మీరు దానిని వేరియబుల్ గా ప్రకటించలేరు మరియు ఏదైనా రిఫరెన్స్ డేటా (డేటా) స్టాటిక్. డేటా సభ్యుడు వాస్తవానికి మీరు ఇంకా స్టాటిక్ చేయలేదు డేటా సభ్యుడు, మేము తదుపరి మాడ్యూల్ గురించి మాట్లాడుతాము లేదా స్థిరమైన డేటా సభ్యులను పరివర్తనం చెందినట్లు ప్రకటించవచ్చు.
అతి ముఖ్యమైన భాగం ఏమిటంటే, డేటా సభ్యుడు పరివర్తన చెందినట్లు ప్రకటించబడితే, దానిని నిరంతర సభ్యుల ఫంక్షన్‌గా మార్చడం చట్టబద్ధం.
స్థిరమైన సభ్యుల ఫంక్షన్ ఏ డేటా సభ్యుడిని మార్చలేమని మేము చూశాము, కాని డేటా సభ్యుడు వేరియబుల్ అయితే, అది ఇప్పటికీ దానిని మార్చగలదు, ఎందుకంటే మీరు చెబుతున్నది వేరియబుల్ అంటే విషయాలు స్థిరంగా ఉన్నప్పుడు కూడా మార్చవచ్చు.
కాబట్టి, ఒక ఉదాహరణ చూద్దాం.
కాబట్టి, ఇక్కడ నేను ఒక డేటా సభ్యుడిని పరిచయం చేసాను, ఇది వేరియబుల్, కాబట్టి మీరు మాక్రోను వ్రాస్తున్నట్లుగా వాక్యనిర్మాణాన్ని పోలి ఉండేలా వ్రాస్తారు మరియు అప్పుడు మనకు స్థిరమైన వస్తువు (ఆబ్జెక్ట్) ఉంది) ప్రకటించింది, ఇప్పుడు మనకు ఒక పద్ధతి ఉంది, మనకు ఉంది నిర్వచించిన పద్ధతి.
ఇప్పుడు మేము నాన్ మ్యూటబుల్ కు సెట్టింగ్ భిన్నంగా ఉంటుంది, గేట్ ఒక కాన్స్ట్ మెంబర్ ఫంక్షన్, సెట్ ఒక కాని కాన్స్ట్ మెంబర్ ఫంక్షన్.
కాబట్టి, దీని అర్థం ఏమిటంటే, నా కాన్స్ట్ ఆబ్జెక్ట్ ఉంటే, నేను దాన్ని పొందగలను, నేను దానిని సెట్ చేయలేను ఎందుకంటే స్థిరమైన వస్తువు నాన్-స్టాటిక్ సభ్యుడిని ప్రారంభించదు.
ఇప్పుడు మార్చగల భాగాన్ని చూడండి, ఇక్కడ ఈ రెండు సభ్యుల విధులు కాన్స్టాంట్‌గా ప్రకటించబడ్డాయి, కాబట్టి ఈ రెండింటినీ స్టాటిక్ ఆబ్జెక్ట్ ద్వారా ప్రారంభించవచ్చు.
ఇప్పుడు ఈ ఫంక్షన్; సెట్ ఫంక్షన్ సభ్యుడిని మార్చడానికి ప్రయత్నిస్తుంది, ఈ ప్రత్యేక సభ్యుడు మ్యుటబుల్ కాకపోతే, ఇది సంకలన లోపం, అది సాధ్యం కాదు, కానీ ఈ సభ్యుడు, డేటా సభ్యుడు వేరియబుల్ కాబట్టి, మార్పు అవసరం .
అందువల్ల, ఇది కాన్స్ట్ మెంబర్ ఫంక్షన్ అయినప్పటికీ, ఇది డేటా సభ్యుడిని సవరించగలదు, ఇది మ్యూటబుల్ డేటా సభ్యునిగా ఉండటానికి ప్రాథమిక ఫలితం, కాబట్టి ఇది లక్షణం యొక్క ప్రాథమిక ప్రవర్తన.
ఇప్పుడు దానిని ఎలా ఉపయోగించాలో, ఎలా ఉపయోగించాలో ఉపయోగించడానికి ప్రయత్నించండి.
కాబట్టి, స్థిరమైన వస్తువు యొక్క బిట్‌లను ఏమీ మార్చలేమని నేను సి ++ మోడల్‌లో సున్నితమైన బిట్ స్థిరాంకానికి చెబుతున్నప్పుడు, కానీ చాలా ముఖ్యమైనది ఏమిటంటే నాకు ఒక కాన్సెప్ట్ ఉంది. ఇది తార్కికంగా స్థిరంగా ఉంది, నేను మోడల్ చేయడానికి ప్రయత్నిస్తున్నాను కొన్ని స్థిర, భావన.
అందువల్ల, ఇది కొంతమంది డేటా సభ్యుల పరంగా వివరించబడింది, కానీ నేను కొన్ని లెక్కలు చేయాలనుకున్నప్పుడు; అదే తరగతిలో నాకు మరికొన్ని డేటా సభ్యులు కావాలి, నేను లెక్కకు మద్దతు ఇస్తున్నాను.
ఇప్పుడు నేను వస్తువును స్థిరంగా చేస్తే, అన్ని బిట్స్ నిరంతరంగా ఉన్నందున అవి ఖచ్చితంగా అన్నింటినీ మార్చలేవు, అంటే కేవలం గణనకు మద్దతు ఇస్తున్న వేరియబుల్ సర్రోగేట్ డేటా సభ్యులు అని పిలవబడేవారు కూడా కాదు కాబట్టి నేను వ్రాయలేను కోడ్.
ఈ సమస్య చుట్టూ పనిచేయడానికి మ్యూటబుల్ అందించబడింది, కాబట్టి మ్యూటబుల్‌ను ఉపయోగించడం లేదా సమర్థవంతంగా ఉపయోగించడం, మేము ప్రాథమికంగా ఉపయోగిస్తాము; దయచేసి ఈ రెండు అంశాలను గుర్తుంచుకోవడానికి ప్రయత్నించండి, మేము ఉపయోగించడానికి ప్రయత్నిస్తాము; తార్కికంగా స్థిరమైన భావన కోసం చూడండి, ఇది ప్రోగ్రామింగ్ ముగింపు కోసం మాత్రమే కాదు. తార్కికంగా స్థిరంగా ఉండే ఒక భావన ఉండాలి మరియు ఆ భావనను అమలు చేయడానికి, మాకు కొంతమంది డేటా సభ్యులు కావాలి. ఆ భావనకు దూరంగా ఉండాలి, మాత్రమే వ్రాయబడుతుంది అవసరమైన గణన, ఇది చాలా స్పష్టంగా అనిపించదని నేను ఖచ్చితంగా అనుకుంటున్నాను, కాబట్టి నేను ఒక ఉదాహరణ తీసుకోవాలి.
మేము తరువాత టాప్ నోట్స్ చదువుతాము; మొదట మనం ఏమి చేస్తున్నామో అర్థం చేసుకుందాం.
మేము తరగతి గణిత వస్తువును నిర్వచిస్తున్నాము మరియు అలా చేయాలనేది నా ఉద్దేశం.
ఈ నమూనా విషయంలో, నా ఉద్దేశ్యం మఠం వస్తువు, నేను స్టాటిక్ ఆబ్జెక్ట్ ఇవ్వాలి, ఇది పై, మనందరికీ పై 3.14159 తెలుసు.
కాబట్టి, నాకు కావలసినది ఏమిటంటే, నేను ఒక వస్తువును సృష్టించినప్పుడల్లా నేను ఈ తరగతి యొక్క స్టాటిక్ ఆబ్జెక్ట్‌ని సృష్టిస్తాను, నేను స్టాటిక్ కాని వస్తువును సృష్టించను.
అందువల్ల, నేను దానిని నిర్మిస్తాను మరియు నేను ఈ పద్ధతిని పై (పై) ను వర్తింపజేస్తే, అది నాకు పై (పై) విలువను ఇవ్వాలి.
ఇప్పుడు మనం పై విలువను ఎందుకు పొందాలి, పై (పై) ఒక అతీంద్రియ సంఖ్య అని మీకు తెలిసిన అల్గోరిథం, కాబట్టి నేను దానిని అణిచివేయలేను, ఇది ఉజ్జాయింపు. పొడవైన గొలుసు, పొడవాటి తోక ఉంది ఉజ్జాయింపు.
కాబట్టి, ఒక అల్గోరిథం వలె, PI ను లెక్కించడానికి మంచి అల్గోరిథంలు ఉన్నాయని నేను నిరూపించాను, కానీ ఇది చాలా నెమ్మదిగా అల్గోరిథంతో జరుగుతుంది.
అందువల్ల, నేను ఈ మో డాట్ పిని ప్రారంభిస్తే; మో అనేది ఒక వస్తువు, కాబట్టి నేను మో డాట్ పై (పై) చేస్తే దాన్ని స్టాటిక్ మెంబర్ ఫంక్షన్ అని పిలుస్తారు. దీనిని స్టాటిక్ ఆబ్జెక్ట్ అని పిలుస్తారు, ఈ అల్గోరిథం అమలు చేస్తుంది మరియు నాకు పై విలువను ఇస్తుంది.
ఇప్పుడు, ఇది చాలా నెమ్మదిగా ఉన్నందున, ఇది చాలా నెమ్మదిగా ఉంటుంది, నేను కొన్ని కాషింగ్ చేయాలనుకుంటున్నాను, అంటే పై (పై) స్థిరంగా ఉందని నాకు తెలుసు; భావన స్థిరంగా ఉంటుంది.
కాబట్టి, నేను ఒకసారి లెక్కించినట్లయితే, రెండవసారి నేను లెక్కించినప్పుడు నాకు అదే విలువ లభిస్తుంది, అందుకే నేను మళ్ళీ ఎందుకు లెక్కించాలి, కాబట్టి నేను దానిని లెక్కించాను లేదా నేను లెక్కించలేదా అని గుర్తుంచుకోవాలి.
అందువల్ల, నేను దానిని మొదటిసారి లెక్కించినప్పుడు, తదుపరిసారి నేను అదే లెక్కించిన విలువను ఉపయోగించాలి, కాబట్టి నేను అందులో ఇద్దరు డేటా సభ్యులను ఉపయోగిస్తాను, ఒకటి పై (పై) విలువ; ప్రారంభంలో నాకు తెలియని విలువ, నేను దానిని కన్స్ట్రక్టర్‌లో ఉంచలేను ఎందుకంటే విలువ ఏమిటో నాకు తెలియదు, దానిని లెక్కించాలి.
ఎవరైనా పై (పై) విలువను ఉపయోగించాలనుకుంటే తప్ప నేను ఆ గణన చేయను ఎందుకంటే నేను చెప్పినట్లుగా చాలా సమయం పడుతుంది మరియు పై (పి) ను మొదటిసారి ఉపయోగించినప్పుడు ఈ సభ్యుల ఫంక్షన్ (ఫంక్షన్) అని పిలుస్తారు.
ఇప్పుడు, నేను మరొక డేటా సభ్యుడు పై కాష్‌ను నిర్వహిస్తున్నాను, ఇది బూల్ ఫ్లాగ్, ఇది పై (పై) లెక్కించబడిందా లేదా లెక్కించబడలేదా అని గుర్తుంచుకుంటుంది.
అందువల్ల, ఆ జెండా మొదట్లో వస్తువు యొక్క కన్స్ట్రక్టర్‌లో తప్పుగా సెట్ చేయబడింది, కనుక ఇది లెక్కించబడలేదని చెబుతుంది.
కాబట్టి, ఇప్పుడు నేను పై (పై) అని పిలిస్తే, ఈ చెక్ పై (పై) లెక్కించబడదని చెబుతుంది, ఇది పూర్తి గణన అవుతుంది, డేటా (డేటా) సభ్యుడు పై (పై) లో విలువ నవీకరించబడుతుంది మరియు వెంటనే నేను పునరావృతం పూర్తి చేస్తాను, నేను బయటకు వచ్చి p కాష్‌ను నిజం అని జోడిస్తాను.
అందువల్ల, భవిష్యత్తులో ఎప్పుడు అది డేటా సభ్యుడు పి; సభ్యుల ఫంక్షన్ (పై) ను మళ్ళీ పిలిచినప్పుడు, అది నిజం అవుతుంది.అందువల్ల, ఇది పూర్తిగా దాటవేయబడుతుంది మరియు నేను చేయగలను; ఇది అవుతుంది, ఇది అందుకున్న ఫంక్షన్ లాగా ప్రవర్తిస్తుంది, ఇది కేవలం పై అవుతుంది, కాబట్టి ఇది ఒక్కసారి మాత్రమే అమలు చేయబడిందని మరియు అనేకసార్లు ఉపయోగించబడుతుందని నిర్ధారిస్తుంది.
కాబట్టి మీరు దీన్ని ఎలా చేయగలరో చూద్దాం, మనకు అవసరమైన మొదటి విషయం ఏమిటంటే, ఈ వస్తువు స్థిరంగా ఉండాలి అని చెప్పాలి ఎందుకంటే పై (పై) స్థిరంగా ఉండకూడదు.
కాబట్టి నిరంతర భావన పై, కాబట్టి అది నా ప్రాథమిక అవసరం, ఇది నిరంతరంగా ఉండాలి.
ఇప్పుడు అది స్థిరంగా ఉంటే, ఈ ఇద్దరు డేటా సభ్యుల నుండి ఈ డేటా సభ్యులను మార్చలేరు; ఉదాహరణకు, కాష్ చేసిన డేటా సభ్యుడు కాష్ చేసిన డేటా సభ్యుల భావనలో భాగం కాదని ఈ డేటా సభ్యులు పేర్కొన్నారు.
పై యొక్క విలువను గుర్తించడం నిరంతర భావన కాదు. భావన యొక్క కొనసాగింపు పై (పై) విలువలో ఉంటుంది.
కాబట్టి, పై (పై) కాష్ అవసరం ఎందుకంటే నేను లెక్కించాలనుకుంటున్నాను, ఇది పై (పై); విలువను సవరించాల్సిన అవసరం ఉంది, ఎందుకంటే నేను ప్రారంభించేటప్పుడు ఆ విలువ ఏమిటో నాకు తెలియదు.
కాబట్టి, ఈ డేటా సభ్యులు ప్రాథమికంగా భావన అమలుకు మద్దతు ఇస్తున్నారు, కాబట్టి మీరు తీసుకుంటే; నాకు స్థిరమైన వస్తువు ఉంటుంది అప్పుడు మో; మో తప్పు అవుతుంది మరియు తక్కువ తెలివితేటలు స్థిరంగా మారినవి ఏమీ మార్చబడవు, కాబట్టి ఈ మొత్తం వ్యూహం పనిచేయదు.
అందువల్ల, నేను ఈ ఇద్దరు డేటా సభ్యులను మార్చాను (సమయం చూడండి: 14:12). వస్తువు స్థిరంగా ఉన్నప్పటికీ, భావన స్థిరంగా ఉంటుంది, కానీ అమలులో నాకు కొంతమంది డేటా సభ్యులు కావాలి, అవి నిరంతరం ఉండవలసిన అవసరం లేదు మరియు ఇది కలిగి ఉండాలి కాన్స్టెన్స్ యొక్క భావాన్ని లాజికల్ కాన్-నెస్ అంటారు.
కాబట్టి, మీరు బిట్ నమూనాను చూస్తే; బిట్ సరళి మారుతోంది, కానీ మీరు ప్రాతినిధ్యం వహించాలనుకున్నది పై యొక్క ప్రాథమిక భావన, ఇది స్థిరంగా సంరక్షించబడుతుంది.
కాబట్టి, ఈ పద్ధతిలో మ్యుటేషన్ చాలా నిర్దిష్టమైన ఉద్దేశ్యాన్ని కలిగి ఉంది మరియు నా జ్ఞానం మేరకు ఒక నిర్దిష్ట కేసు, బహుశా పరివర్తన చెందిన ఏకైక సందర్భం.
కాబట్టి, ఇప్పుడు, మీరు ప్రారంభ వ్యాఖ్యలను చదవవచ్చు, ఇది ఒక తరగతి స్థిరమైన భావనను సూచించినప్పుడు సాధారణంగా ఉపయోగించబడుతుంది మరియు ఇది మొదట విలువను లెక్కిస్తుంది మరియు భవిష్యత్తు ఉపయోగం కోసం ఫలితాన్ని క్యాష్ చేస్తుంది.
కాబట్టి, వేరియబుల్‌పై చర్చను పూర్తి చేయడానికి, ఎప్పుడు మ్యూటబుల్ ఉపయోగించకూడదో నేను ఒక ఉదాహరణను ప్రదర్శించాలనుకుంటున్నాను, ఎందుకంటే ఇది చాలా సుష్ట భావన అని మీకు తెలుసు.
నేను స్థిరమైన వస్తువులో డేటా సభ్యులను స్థిరంగా చేయగలను మరియు చాలా సుష్ట భావన అయిన స్టాటిక్ ఆబ్జెక్ట్‌లో డేటా సభ్యులను స్థిరంగా చేయగలను.
అందువల్ల, విద్యార్థులు వాటిని పరిపూరకరమైన భావనకు సమానంగా ఉపయోగించడంలో తప్పు చేస్తున్నారని నేను తరచుగా గమనించాను, కాని ఇది నిజం కాదు.
అందువల్ల, నేను ఉద్యోగి తరగతి, ఉద్యోగి పేరు, ఐడి మరియు జీతం యొక్క ఉదాహరణను చూపించవలసి ఉంది.
కాబట్టి, నేను సరే అని చెప్తున్నాను, ఉద్యోగులు ఒకసారి సృష్టించారు. ఇది ఉద్యోగుల మార్పు సాధ్యం కాని సంస్థ అని చెప్పండి, కాబట్టి ఒకసారి ఉద్యోగులు స్థిరమైన వస్తువుగా ఉంటే, వారు మారరు. వెళ్ళవచ్చు.
అందువల్ల, మేము ఉద్యోగిని వ్రాసే అప్లికేషన్ స్థిరంగా ఉంటుంది, కానీ ఉద్యోగుల జీతం మారుతుంది, ఉద్యోగులకు పదోన్నతి అవసరం, వారికి పదోన్నతి అవసరం, అప్పుడు వారికి మంచి జీతం లభిస్తుంది మరియు ఉద్యోగి నిరంతరాయంగా ఉంటే, అది కాదు జాన్ నిరంతరాయంగా ఉంటే సాధ్యమవుతుంది, కాబట్టి నేను దానిని నిరంతర సభ్యుల పనిగా చేస్తాను.
ఇది నిరంతర సభ్యుల ఫంక్షన్ అయితే, అది కూడా లోపం ఎందుకంటే నిరంతర సభ్యుల ఫంక్షన్ డేటా సభ్యుడిని మార్చదు; కాబట్టి పని చేయడానికి నేను మ్యూటబుల్ ఉంచుతాను, ఈ కోడ్ కంపైల్ చేయబడుతుంది, ఈ కోడ్ రన్ అవుతుంది, ఈ కోడ్ ఫలితాలను ఇస్తుంది, సి ++ (సింటాక్స్) యొక్క వాక్యనిర్మాణానికి సంబంధించినంతవరకు ఏమీ తప్పు లేదు, కానీ ఇప్పటివరకు డిజైన్, కాన్సెప్ట్ చేర్చబడింది లేదా ఇతరులు ఇప్పటివరకు ఆ కోడ్ నుండి ఏమి అర్థం చేసుకుంటారు, ఇది ఒక విపత్తు.
ఇది నిరంతర భావనలను ప్రత్యేకంగా మోడల్ చేయడానికి పరిచయం చేయబడినందున ఇది విపత్తు, ఉద్యోగులు నిరంతర భావనలు కాకూడదు, అవి నిరంతర భావనలు అయితే వారి జీతం కూడా నిరంతరంగా ఉంటుంది, జీతం కూడా ఉంటుంది. వేరియబుల్ కాకూడదు ఎందుకంటే ఇది ఒక భాగం మరియు భాగం ఉద్యోగి.
అందువల్ల, ఉద్యోగులు నిరంతరాయంగా ఉండనవసరం లేనందున వాటిని స్థిరంగా లేనివిగా చేస్తారని మేము ఇంతకుముందు చూపించినట్లుగా దీనిని మోడల్ చేయాలి; అవి సంభావితంగా స్థిరంగా ఉండవు, కానీ పేరు మరియు ఐడి అయిన ఉద్యోగి కోసం మార్చలేని డేటా సభ్యులను స్థిరంగా చేయండి మరియు వేరియబుల్ డేటా సభ్యుడు స్టాటిక్ కాని డేటా సభ్యుడు. మీరు దీన్ని సాధారణంగా ప్రోత్సహించే విధంగా సృష్టించండి, బూస్ట్ ఇకపై నిరంతర సభ్యుల పని కాదు మరియు అందువల్ల అవసరమైన విధంగా జీతం మార్పులు చేయవచ్చు.
అందువల్ల, మీరు ఈ రెండు భాగాల రూపకల్పనను జాగ్రత్తగా అధ్యయనం చేస్తే; సంబంధిత భాగాలు మరియు సంబంధిత ఉపయోగం రెండూ కోడ్ వారీగా పని చేస్తాయి, కాని కాన్సెప్ట్ వారీగా ఇది సరికాని డిజైన్, ఇది చేయకూడదు మరియు సాధారణ తరగతిని రూపొందించడానికి ఇది సరైన మార్గం, మీకు నిరంతర భావనలు ఉంటే మాత్రమే. మీరు చూపించాలనుకుంటే ఇది సహజ స్థిరాంకం లేదా ఇతర రకాల నిరంతర భావనలు అయినా, మీరు వాటిని సవరించగలిగేలా చేయడానికి మీ అమలు రకం డేటా సభ్యులలో ఒకదాన్ని ఉపయోగించాలి.
కాబట్టి, దీనితో మనం ప్రస్తుత మాడ్యూల్ చివరికి వస్తాము.
ఇక్కడ మేము C ++ లో Const-ness ను అధ్యయనం చేసాము, C ++ లో మేము Const-ness యొక్క మూడు రూపాలను చూశాము, ఆబ్జెక్ట్ పూర్తిగా స్థిరంగా ఉంటుంది మరియు వస్తువు స్థిరంగా ఉంటే, అది నిరంతర సభ్యుల విధులను మాత్రమే అమలు చేయగలదు.
అందువల్ల, స్థిరమైన సభ్యుల ఫంక్షన్లు వస్తువును మార్చలేవని మేము చూశాము, కాని స్థిరమైన వస్తువు (ఆబ్జెక్ట్) కూడా స్థిరమైన సభ్యుల ఫంక్షన్లను ప్రారంభించగలదు మరియు మేము ఉద్యోగి యొక్క ID వంటి వస్తువును ఎంచుకుంటే మీరు చేయాలనుకుంటే, అతను ఒక విద్యార్థి యొక్క రోల్ సంఖ్య.
; అప్పుడు మేము సంబంధిత డేటా సభ్యుని సభ్యుడిని స్థిరంగా చేయవచ్చు, తరువాత నిరంతర సభ్యుల ఫంక్షన్ (ఫంక్షన్) లేదా నాన్-స్టేషనరీ మెంబర్ ఫంక్షన్ (ఫంక్షన్), వాటిలో ఏవీ స్థిరమైన డేటా సభ్యుడిని మార్చలేవు.
సి ++ డిఫాల్ట్‌గా కాస్ట్ వాడకంలో బిట్ వారీగా ఉండే కాన్-నెస్‌కు మద్దతు ఇస్తుందని మేము చూశాము, కాని తార్కిక కాన్-నెస్ సాధించడానికి ఒక పరివర్తన చెందిన డేటా సభ్యుడిని ఉపయోగించడం సాధ్యమవుతుంది, ఇది మనకు తార్కికంగా స్థిరమైన కాన్-నెస్ భావనను కలిగి ఉంటుంది మేము C ++ లోని పరివర్తన చెందిన డేటా సభ్యుడిని ఉపయోగించి కోడ్ చేయవచ్చు.
inhouse/NPTEL/PreFinal/c++/Telugu/45 ProgramminginCplusplus_Overloading Operator for User Defined TypesPart - I (Lecture 33)-Z30jsw8r7bY.txt
View file @ 956c0d4e
 1.
2. ప్రోగ్రామింగ్ ఇన్ సి ++ మోడ్యూల్ 18 కు స్వాగతం.
3. ముందుగా ఆపరేటర్లు ఓవర్లోడింగ్ గురించి మాట్లాడ్దాము.
4. C ++ లోని ఆపరేటర్లు, వాటిలో ఎక్కువ భాగం యూజర్ ఓవర్‌లోడ్ చేయగల సంబంధిత ఆపరేటర్ ఫంక్షన్లతో సంబంధం కలిగి ఉండవచ్చని మేము చర్చించాము.
5. ఈ మాడ్యూల్‌లో మరియు తరువాతి వాటిలో, వినియోగదారు నిర్వచించిన రకాలు కోసం ఆపరేటర్ ఓవర్‌లోడ్‌ను లోతుగా పరిశీలిస్తాము.ఇది లింక్డ్ డిస్కషన్.
6. కాబట్టి, ఇది ఈ చర్చలో పార్ట్ -1 అవుతుంది.
7. వినియోగదారు నిర్వచించిన రకాల కోసం ఆపరేటర్లను ఓవర్లోడ్ ఎలా చేయాలో అర్థం చేసుకోవడానికి మేము ప్రయత్నిస్తాము.
8. మరియు ఈ మాడ్యూల్‌లో గ్లోబల్ ఫంక్షన్లు మరియు సభ్యుల ఫంక్షన్లను ఉపయోగించి ఓవర్‌లోడింగ్ యొక్క అంశాలను మేము అన్వేషిస్తాము.
9. ఎప్పటిలాగే మీ స్క్రీన్ యొక్క ఎడమ వైపున అవుట్లైన్ అందుబాటులో ఉంటుంది.
10. ఇప్పుడు, ఆపరేటర్ ఓవర్‌లోడింగ్ గురించి చర్చించటానికి ముందు, ఆపరేటర్‌ను ఎందుకు ఓవర్‌లోడ్ చేయాలనుకుంటున్నామో త్వరగా క్లుప్తీకరిస్తాను.
11. నేను మొదటి రెండు మాడ్యూళ్ళను సూచించాలనుకుంటున్నాను; మాడ్యూల్ 9, ఇక్కడ నిర్మాణాత్మక రకాల కోసం ఓవర్‌లోడింగ్ ఆపరేటర్ + గురించి చర్చించాము, స్ట్రింగ్ స్ట్రక్చర్ కోసం ఆపరేటర్ + ఓవర్‌లోడ్ అయిందని చూపించడానికి లెక్కించిన రకాలు, అంటే నక్షత్రాల సంగ్రహణ.
12. అదేవిధంగా, మేము ఎనుమ్ రకాల కోసం నిర్దిష్ట ఓవర్‌లోడ్‌లను గమనించాము.
13. తరువాత మాడ్యూల్ 14 లో, మేము ఆ ఆపరేటర్ గురించి మాట్లాడాము, అసైన్‌మెంట్ ఆపరేటర్ కోసం ఓవర్‌లోడింగ్‌ను కాపీ చేయడానికి సరైన సెమాంటిక్స్ను నిర్వచించాము, ముఖ్యంగా లోతైన మరియు నిస్సారమైన కాపీయింగ్ సందర్భంలో. ముఖ్యమైనవి.
14. సాధారణంగా, అదే ప్రయోజనం యొక్క ఆపరేటర్లు మరియు విధులు మనకు తెలిసినట్లుగా, వ్యత్యాసం ఏమిటంటే ఆపరేటర్‌కు చాలా కాంపాక్ట్ సంజ్ఞామానం ఉంటుంది, ఇది సాధారణంగా ఇన్ఫిక్స్.
15. అందువల్ల, కాంపాక్ట్ వ్యక్తీకరణ సందర్భంలో చాలా విభిన్నమైన సంక్లిష్ట ఫంక్షన్ల కలయికను వ్రాయడం సాధ్యమవుతుంది; సరైన కార్యాచరణ కోసం తగిన ఆపరేటర్‌ను నేను నిర్వచించగలిగితే మనం చేయాలనుకుంటున్నాము.
16. అందువల్ల, అంతర్నిర్మిత రకాలు కోసం అవి అప్రమేయంగా లభిస్తాయి, కొన్ని ఆపరేటర్లు పాయింటర్ రకాలు కోసం కూడా అందుబాటులో ఉన్నాయి.
17. కాబట్టి, నేను నిర్వచించబోయే రకం కోసం ఆపరేటర్లను ఓవర్‌లోడ్ చేయగలిగితే; ఇది వినియోగదారు నిర్వచించిన రకం; ఆపరేటర్లను రకాలుగా నిర్మించటానికి నిర్వచించబడిన విధంగా.
18. వినియోగదారు నిర్వచించిన రకం కోసం, మేము వ్యక్తీకరణను కూడా వ్రాయగలము, వాస్తవానికి మనం నిర్మిస్తున్న నిర్దిష్ట వినియోగదారు-నిర్వచించిన రకం లేదా UDT ఆధారంగా పూర్తి బీజగణితాన్ని నిర్మించవచ్చు.
19. అందువల్ల, ఇక్కడ నేను ఇప్పుడే ప్రస్తావించాను మరియు ఏమి చేయవచ్చనే దానిపై చాలా క్లుప్త రూపురేఖలు ఇవ్వడానికి ప్రయత్నించాను.
20. ఉదాహరణకు, C ++ కి సంక్లిష్ట రకం లేదు.
21. ఇది డబుల్ రకాన్ని కలిగి ఉంది, కానీ సంక్లిష్టమైన రకం కాదు.
22. కానీ ఆపరేటర్ ఓవర్‌లోడింగ్ ఉపయోగించి, మేము ఆపరేటర్ + ను ఇలా నిర్వచించవచ్చు; సంక్లిష్ట సంఖ్యలు జతచేస్తాయని మేము చెప్పగలం, ఇది సంక్లిష్ట సంఖ్యల వ్యవకలనం, సంక్లిష్ట సంఖ్యల గుణకారం, సంక్లిష్ట సంఖ్యల విభజన.
23. ఇవన్నీ సంబంధిత ఆపరేటర్ల పరంగా నిర్వచించబడతాయి మరియు కొన్ని, సంక్లిష్ట కంజుగేట్ల కోసం శోధించడం వంటి సంక్లిష్ట రకానికి ప్రత్యేకమైనవి.
24. మేము '!' ఆపరేటర్‌ను ఉపయోగించవచ్చు. ఆశ్చర్యార్థక ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడం అంటే '!' ఆపరేషన్ ఒక రకమైన నిరాకరణ.
25. కాబట్టి, సంక్లిష్ట సంయోగం ఆ ఆపరేటర్‌ను నిర్లక్ష్యం చేయడం వంటిది.
26. అదేవిధంగా, మనకు వేర్వేరు రకాలు ఉండవచ్చు, మాతృక యొక్క విలోమంతో సహా బీజగణితంతో సహా అన్ని మాత్రికలకు ఆపరేటర్‌ను కలిగి ఉన్న మాతృక రకాలను కలిగి ఉండవచ్చు, మేము యూనియన్, తేడా, సూపర్‌సెట్, ఉపసమితి సంబంధం మరియు మొదలైన రకాలను సెట్ చేయవచ్చు .
27. అందువల్ల, ఇవన్నీ మరియు మీరు సృష్టించడానికి యుడిటిగా నిర్వచించదలిచిన అన్ని రకాలు, మీరు ఆపరేటర్ ఓవర్‌లోడింగ్ ఉపయోగించి పూర్తి రకాన్ని సృష్టించవచ్చు.
28. మరియు ముఖ్యంగా, IO పరంగా, ఆపరేటర్ అవుట్పుట్ మరియు ఆపరేటర్ ఇన్పుట్ స్ట్రీమింగ్ పరంగా మేము చాలా కాంపాక్ట్ IO చేయవచ్చు.
29. ఆ ఆపరేటర్లను చాలా కాంపాక్ట్ IO నిర్మాణాలను అందించడానికి UDT కోసం ఓవర్‌లోడ్ చేయవచ్చు.
30. మరియు నేను ప్రస్తావించాలనుకుంటున్నాను, కానీ ఇది కొంతవరకు ముందంజలో ఉంది.
31. స్మార్ట్ పాయింటర్ యొక్క C ++ లోని కొన్ని మంచి నమూనాలు ఆపరేటర్ ఓవర్‌లోడింగ్ కోసం చాలా ముఖ్యమైనవి.
32. అందువల్ల, మంచి వినియోగదారు-నిర్వచించిన రకాన్ని సృష్టించడానికి ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడం ఒక ముఖ్యమైన అవసరం.
33. కాబట్టి, మేము ఇప్పుడు ముందుకు సాగాలి.ఇది మాడ్యూల్ 9 నుండి శీఘ్ర రీక్యాప్, ప్రతి ఆపరేటర్ కోసం, మేము నిర్వచించగల ఆపరేటర్ ఫంక్షన్ ఉందని మేము చూశాము.
34. మరియు ఆ ఆపరేటర్ ఫంక్షన్ ఖచ్చితంగా ఆపరేటర్ + 'వంటి సంతకాన్ని కలిగి ఉంటుంది.
35. ఈ సందర్భంలో, మేము దీనిని చూశాము; నేను ఇక్కడ ఎక్కువ సమయం వృథా చేయను.
36. ఇది మీ మనస్సులో జరిగితే మళ్ళీ గుర్తుంచుకోండి.
37. ఇప్పుడు ఈ ఆపరేటర్ సభ్యులే కాని ఫంక్షన్ కావచ్చు.
38. అందుకని ఇది సార్వత్రిక ఫంక్షన్ కావచ్చు మరియు ఫ్రెండ్ ఫంక్షన్లు కూడా ఉన్నాయని మాకు తెలుసు.
39. కాబట్టి, ఆపరేటర్ ఫంక్షన్ గ్లోబల్ ఫంక్షన్ లేదా ఫ్రెండ్ ఫంక్షన్ అయితే, ఇది ఇలా అనిపించవచ్చు, ఇది నా రకానికి చెందిన రెండు వస్తువులను కనెక్ట్ చేయడానికి గ్లోబల్ ఆపరేటర్ (). ఆపరేటర్) ఫంక్షన్ కూడా ఇది నా రకం.
40. అదేవిధంగా, ఒకరికి - అది స్నేహితుడైతే, అది ఏదోలా కనిపిస్తుంది, ఒకే తేడా ఏమిటంటే ఫ్రెండ్ కీవర్డ్ రావడం.
41. అదేవిధంగా, బైనరీ ఆపరేటర్ల కోసం గ్లోబల్ ఆపరేటర్ల కోసం గ్లోబల్ లేదా ఫ్రెండ్ ఫంక్షన్లను కలిగి ఉండవచ్చు.
42. కాబట్టి, మీరు దీన్ని యూనిటరీ ఆపరేటర్ల కోసం కలిగి ఉండవచ్చు.
43. మేము ఉపసర్గ ఆపరేటర్ మరియు పోస్ట్ఫిక్స్ ఆపరేటర్ కోసం ఒక నిర్దిష్ట ఆపరేటర్ కావచ్చు.
44. మనకు ఉపసర్గ ఆపరేటర్ మరియు ఆపరేటర్ ఉండవచ్చు.
45. ఇది కాకుండా, మేము ఆపరేటర్ ఫంక్షన్లను కూడా కలిగి ఉండవచ్చు, అవి ప్రాథమికంగా సభ్యుల ఫంక్షన్లు.
46. కాబట్టి, ఇది సభ్యుల ఫంక్షన్ అయితే ఆపరేటర్ ఫంక్షన్ ఇలా కనిపిస్తుంది.
47. ఇక్కడ గమనించవలసిన ముఖ్య విషయం ఏమిటంటే `+ 'బైనరీ ఆపరేటర్, కాబట్టి దీనికి రెండు ఒపెరాండ్స్ అవసరం.
48. కానీ ఇక్కడ మీరు, ఆపరేటర్ + కోసం ఒక పరామితిని మాత్రమే చూస్తారు, ఎందుకంటే ఇది ఆపరేటర్ ఫంక్షన్, సభ్యుల ఫంక్షన్ మొదటి ఆపరేటర్ లేదా ఎడమ చేతి వైపు ఉంటుంది. ఆపరేటర్ యొక్క ఎడమ ఆపరేటర్ (ఆపరేటర్) మీకు ఒక వస్తువు ఆపరేటర్ ఫంక్షన్‌ను ఆహ్వానిస్తున్నారు.
49. కాబట్టి, నాకు ఏదైనా సభ్యుల పని ఉందో మీకు తెలిసినట్లుగా, ఇక్కడ నేను ఈ సభ్యుడికి కనిపించను.
50. కాబట్టి, ఈ అదృశ్య పాయింటర్ వాస్తవానికి నా మొదటి ఒపెరాండ్ ఇదేనని లేదా నా వద్ద ఉన్న ప్రస్తుత వస్తువు ఎల్లప్పుడూ ఎడమ ఒపెరాండ్‌గా ఉంటుందని మరియు కుడి ఒపెరాండ్ ఇక్కడ దాటిందని అర్థం.
51. కాబట్టి, సభ్యుల ఫంక్షన్ విషయంలో, ఇది గ్లోబల్ లేదా ఫ్రెండ్ ఫంక్షన్ నుండి తేడా.
52. యునరీ ఆపరేటర్లను కూడా నిర్వచించవచ్చు, ఒక విధంగా, సహజంగా, యూనిరీ ఆపరేటర్లకు ఒపెరాండ్ ఉండదు, ఎందుకంటే వారికి ఒకటి మాత్రమే ఉంది మరియు మీరు దానిని వర్తించే అంశం ఇది.
53. ఇది పోస్ట్‌ఫిక్స్‌డ్ ఆపరేటర్ అయితే, మనకు ఒక రకమైన పూర్ణాంకానికి ఉంటుంది, ఇది వాస్తవానికి ఒపెరాండ్ కాదా? కానీ అదనపు రకం సంతకం పూర్ణాంకం అంటే పోస్ట్‌ఫిక్స్ ఆపరేటర్.
54. అందువల్ల, ఇది ప్రిఫిక్స్ ఆపరేటర్ల మధ్య తేడాను గుర్తించడానికి ఉపయోగించబడుతుంది, ఇది మరొక పోస్ట్ఫిక్స్ ఆపరేటర్, ఎందుకంటే ఈ రెండింటిని '++' అని పిలుస్తారు.
55. కాబట్టి, సంతకం జాబితాలోని ఈ అదనపు రకం ఆపరేటర్ ఏ ఉపసర్గ అని నిర్దేశిస్తుంది, ఇది పోస్ట్‌ఫిక్స్ ఆపరేటర్.
56. కాబట్టి, ఇవి ఆపరేటర్ ఫంక్షన్లను నిర్వచించి వాటిని ఓవర్‌లోడ్ చేయగల వివిధ ఎంపికలు.
57. అందువల్ల, నేను మిమ్మల్ని త్వరగా మాడ్యూల్ 9 కు సూచిస్తాను.
58. ఎక్కడ, ఆపరేటర్ల కోసం మేము ఏమి చేయగలమో అనే నియమాల సారాంశాన్ని చూశాము.
59. మేము ఆపరేటర్ల యొక్క ప్రాధమిక లక్షణాలను మార్చలేము మరియు ఓవర్‌లోడ్ చేయగల ఆపరేటర్ల యొక్క స్థిర జాబితా ఉంది. ఓవర్‌లోడ్ చేయలేని కొన్ని ఆపరేటర్లు ఉన్నారు, కొన్ని ఓవర్‌లోడ్ చేయకూడదు, మేము మాడ్యూల్) 9 దీన్ని లోతుగా చర్చిస్తాము, కాబట్టి నేను దానిని వదిలివేస్తుంది.
60. ఇప్పుడు నీలిరంగులో హైలైట్ చేయబడిన రెండు పాయింట్లు అదనపువి, ఒకటి ఆబ్జెక్ట్‌ను ప్రారంభించడం ద్వారా ఆమోదించబడిన సభ్యుల ఫంక్షన్ కోసం, నేను ఇప్పుడే వివరించాను మరియు ఇది ఎడమ ఒపెరాండ్‌గా ఉంది, కాబట్టి సరైన ఒపెరాండ్ మాత్రమే స్పష్టంగా ప్రస్తావించబడింది.
61. గ్లోబల్ ఫంక్షన్ లేదా ఫ్రెండ్ ఫంక్షన్ విషయంలో, రెండు ఒపెరాండ్‌లు స్పష్టంగా పేర్కొనబడ్డాయి.
62. కాబట్టి, ఇది ఆపరేటర్ యొక్క ఓవర్లోడ్ యొక్క మూలం.
63. కాబట్టి, ఇప్పుడు దీనితో మనం ఇంతకుముందు చూసిన కొన్ని కోడ్‌లను పరిశీలిద్దాం, అవి గ్లోబల్ ఫంక్షన్‌ను ఉపయోగించి ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ప్రయత్నిస్తాయి.
64. అందువల్ల, నేను ఒక సాధారణ సంక్లిష్ట తరగతిని కలిగి ఉన్నాను.
65. కాబట్టి, ఈ సభ్యులు ఇద్దరూ బహిరంగంగా అందుబాటులో ఉన్నారని మరియు ఈ సంక్లిష్ట నిర్మాణం కోసం మేము ఆపరేటర్ + ఆపరేటర్‌ను వ్రాశాము, ఇది ప్రాథమికంగా నిజమైన మరియు inary హాత్మక భాగాల భాగం యొక్క తెలివైన చేరిక.
66. ఈ వ్యక్తీకరణలో d1 ఒక సంక్లిష్టమని మనం ఉపయోగిస్తే, d2 మరింత క్లిష్టంగా ఉండటం వలన మనం d1 + d2 ను వ్రాయవచ్చు.
67. అంటే రెండు సంక్లిష్ట సంఖ్యలను జతచేయడం, వాస్తవానికి ఈ ఆపరేటర్, మేము ఈ ఫంక్షన్‌ను ఆపరేషన్లుగా అమలు చేస్తాము మరియు ఆ ఫలితం d కి కేటాయించబడుతుంది.
68. కాబట్టి, మంచిది.
69. దీన్ని అర్థం చేసుకోవడంలో మీకు పెద్దగా ఇబ్బంది ఉండదని నేను ఖచ్చితంగా అనుకుంటున్నాను.
70. కుడి వైపున మీకు మరొక ఉదాహరణ ఉంది, ఇక్కడ మేము ఇక్కడ ఒక సి స్ట్రింగ్‌ను చుట్టడానికి ఒక నిర్మాణాన్ని ఉపయోగిస్తున్నాము మరియు ఆ నిర్మాణం యొక్క రకాన్ని బట్టి, స్ట్రింగ్ స్ట్రక్చర్ రకాన్ని బట్టి, మేము స్ట్రింగ్ కోసం ఆపరేటర్ '+' ను పునర్నిర్వచించాము మరియు ఓవర్‌లోడ్ చేసాము.
71. ఈ విధంగా, ఇక్కడ ఇవ్వబడిన రెండు తీగలను మొదటి పేరు మరియు చివరి పేరు కోసం వ్యక్తీకరణలను జోడించవచ్చు, ఇవి వాస్తవానికి ఈ ఫంక్షన్‌లోకి వెళ్లి ఒకదాన్ని చేస్తాయి.
72. అందువల్ల, ఒక రకాన్ని బట్టి మనకు ఒకే ఆపరేటర్ + ఉంటుంది. కొన్ని సందర్భాల్లో ఇది సంక్లిష్ట సంఖ్యలకు అదనంగా ఉంటుంది, కొన్ని సందర్భాల్లో దీని అర్థం తీగల కలయిక మరియు మొదలైనవి.
73. ఇది చాలా సులభం మరియు దీని కోసం, మేము ఇక్కడ గ్లోబల్ ఫంక్షన్లను ఉపయోగించాము.
74. ఇప్పుడు సహజంగా, మీరు గ్లోబల్ ఫంక్షన్‌ను ఉపయోగిస్తుంటే, ఇది ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ సిస్టమ్‌లో ఇది సరసమైన విషయం కాదని మాకు తెలుసు, ఎందుకంటే గ్లోబల్ టాస్క్, కానీ సహజంగానే వారు డేటాతో పనిచేయాలి ముఖ్యంగా సంక్లిష్ట యొక్క నిజమైన మరియు inary హాత్మక భాగం సభ్యులు అవసరమయ్యే సంఖ్యను బహిరంగపరచాలి మరియు డేటా సభ్యులు నిజంగా ప్రైవేట్‌గా ఉండాలి అనే సూత్రాన్ని మేము పునరుద్ఘాటించాము.
75. కాబట్టి మనం వాటిని ప్రైవేట్‌గా చేసుకోవాలి.
76. తరగతికి మద్దతు ఇచ్చే ప్రత్యేక కార్యకలాపాలు మాత్రమే పబ్లిక్‌గా ఉండాలి.
77. ఇప్పుడు మనం ఇలా చేస్తే, సహజంగా దీనితో మనం ఆపరేటర్ + ను నేరుగా వ్రాయలేము, ఆపరేటర్ + ను గ్లోబల్ ఫంక్షన్ గా నేరుగా ఓవర్రైడ్ చేయవచ్చు, ఎందుకంటే ఈ గ్లోబల్ ఫంక్షన్ ప్రైవేట్ డేటా సభ్యులను యాక్సెస్ చేయదు.
78. కాబట్టి, ఈ పని చేయడానికి, మేము భాగాలకు సెట్ ఫంక్షన్ల సమూహాన్ని జోడించాలి.
79. నేను నిజమైన భాగాన్ని ఎక్కడ చదవగలను, నేను inary హాత్మక భాగాన్ని చదవగలను, అక్కడ నేను నిజమైన భాగాన్ని వ్రాయగలను, inary హాత్మక భాగాన్ని వ్రాయగలను.
80. అందువల్ల, ఈ పద్ధతుల సమితిని ఉపయోగించి ఆపరేటర్ + కోసం గ్లోబల్ ఆపరేటర్ ఓవర్‌లోడింగ్‌ను వ్రాయవచ్చు.
81. ఇది బాగా పనిచేస్తుంది ఇది పని చేస్తుంది మరియు మేము డేటా సభ్యులను ప్రైవేట్‌గా చేయగలుగుతాము, కాని ఇది మెరుగైన పరిష్కారాన్ని అందించదని పేర్కొంది.
82. ఎందుకంటే, గ్లోబల్ ఫంక్షన్‌ను అమలు చేయడానికి, మేము ఇవన్నీ నిర్వచించిన ఫంక్షన్‌కు కేటాయించాల్సి వచ్చింది.
83. మీ అంతర్గత డేటాను బాహ్య ప్రపంచానికి బహిర్గతం చేయడానికి మీరు నిజంగా అందించే సెట్ సెట్ ఫంక్షన్లు.
84. ఎందుకంటే, మంచి వ్యక్తులు నేరుగా డేటా సభ్యులను ఉపయోగించలేరు, కాని ఆపరేటర్ + సెట్‌ను ఉపయోగించుకోవచ్చు మరియు నిజమైన మరియు ఊహాత్మక భాగాలను పొందవచ్చు కాబట్టి, ఏదైనా బాహ్య ఫంక్షన్‌ను బాహ్య తరగతిగా కూడా ఉపయోగించవచ్చు.
85. కాబట్టి, ఒక విధంగా, ఈ పరిష్కారం మనకు ఉన్న ఒక రకమైన ఎన్కప్సులేషన్.
86. అందువల్ల, గ్లోబల్ ఫంక్షన్లతో మనకు తెలుసు, మనం ఎన్కప్సులేషన్ను సంరక్షించలేము.
87. మేము చూసే తదుపరి ఎంపిక ప్రాథమికంగా సభ్యుల విధులను ఉపయోగించడం మరియు ఇలాంటి పనులు చేయడం.
88. ఆపరేటర్ ఇప్పుడు సభ్యుల ఫంక్షన్‌గా ఓవర్‌లోడ్ అయిందని ఇప్పుడు పరిశీలిద్దాం.
89. కాబట్టి, అది తరగతి లోపలికి వెళ్లిందని మీరు చూడవచ్చు.
90. నా డేటా సభ్యులు ఇప్పటికీ ప్రైవేట్‌గా ఉన్నారు మరియు ఇది తరగతి లోపలికి తరలించబడినందున, దీనికి ఒకే పరామితి ఉంది, ఇది కుడి వైపున ఉన్న పరామితి.
91. మరియు ఎడమ వైపు పరామితి వస్తువుగా ఉంటుంది.
92. కాబట్టి, నేను ఎడ్‌ను జోడించాలనుకున్నప్పుడు, c.re తో తిరిగి జోడించండి.
93. ఎక్కడ, సి అనేది కుడి చేతి ఒపెరాండ్ మరియు మీకు తెలిసినట్లుగా, ఈ పద్ధతి వర్తించే ప్రస్తుత వస్తువు యొక్క వాస్తవ భాగాన్ని సూచిస్తుంది, ఇది ఎడమ చేతి వైపున పనిచేసేది.
94. కాబట్టి, మీరు సి 1 + సి 2 వ్రాసినట్లే, మేము సి 1 + సి 2 వ్రాసేటప్పుడు, ఇది సి 1 `కండక్టర్ + 'సి 2 కు సమానమని సంజ్ఞామానం సూచిస్తుంది.
95. కాబట్టి, అంటే సి 2 కుడి చేతి ఒపెరాండ్, అది సి అవుతుంది మరియు సి 1 ప్రస్తుత నక్షత్రం.
96. అందుకే మనం మళ్ళీ చర్చిస్తున్నప్పుడు మనం నిజంగా c1 యొక్క వాస్తవ భాగాన్ని సూచిస్తున్నాము, నేను c.re ని సూచిస్తున్నప్పుడు మేము c2 యొక్క వాస్తవ భాగాన్ని సూచిస్తున్నాము మరియు ఈ విధంగా ఈ గణన కొనసాగుతుంది.
97. మేము రక్షించదలిచిన ఎన్‌క్యాప్సులేషన్‌ను రక్షించడం ఒక ప్రయోజనం అని మీకు అదే సమాధానం ఇచ్చే ఖచ్చితంగా ఇదే పరిష్కారం మీకు ఇస్తుంది.
98. కాబట్టి, మేము దానితో చాలా తేలికగా పని చేయవచ్చు మరియు సభ్యుల ఫంక్షన్లను ఉపయోగించి మంచి ఆపరేటర్ ఓవర్‌లోడింగ్ చేయవచ్చు.
99. ఇప్పుడు, మీరు చాలా మందికి బైనరీ ఆపరేటర్‌ను చూపించినట్లే, ఇతర ఆపరేటర్లను ఓవర్‌లోడ్ చేయవచ్చు.
100. ఉదాహరణకు, మీరు మాడ్యూల్ 14 లో గుర్తుచేసుకుంటే, కాపీ చేసే ఎంపికలలో మేము వివిధ అవకాశాలను చర్చించినప్పుడు, ఆపరేటర్ అసైన్‌మెంట్ కాపీ కాపీ ఆపరేటర్ అని మేము చూపించాము.
101. ఇది ఓవర్‌లోడ్ చేయగలదా అనే దాని గురించి మేము మాట్లాడుతున్నాము మరియు ఈ మొత్తం ఉదాహరణను చేయడానికి సురక్షితమైన మార్గం వాస్తవానికి మీ సూచన కోసం మాడ్యూల్ 14 నుండి మళ్ళీ ప్రతిరూపం అవుతుందని చూపబడింది.
102. కాబట్టి, కాపీ అసైన్‌మెంట్ ఆపరేటర్ కోసం ఓవర్‌లోడింగ్ ఎలా పనిచేస్తుందో మేము ఇప్పటికే చూశాము మరియు అది కూడా ఇక్కడ ఉంది మరియు ఈ ఓవర్‌లోడింగ్ చాలా ముఖ్యమైనదని మేము గుర్తించాము ఎందుకంటే మీరు కంపైలర్‌ను ఓవర్‌లోడ్ చేసే వరకు ఉచిత కాపీ కేటాయింపు కేవలం నిస్సార కాపీ.
103. కాబట్టి, పాయింటర్ వేరియబుల్స్ సమక్షంలో మీకు తప్పు సెమాంటిక్స్ ఇవ్వవచ్చు మరియు మీరు ఓవర్‌లోడ్ చేసి, కాపీ అసైన్‌మెంట్ ఆపరేటర్‌ను లోతుగా కాపీ చేయాల్సి ఉంటుంది.
104. ఇప్పుడు నీలిరంగు రంగుతో పాటు, మీరు వినియోగదారులను కొత్త ఆపరేటర్లుగా చేస్తే, మీరు ఏ అదనపు అంశాలను పరిగణనలోకి తీసుకోవాలో చూపించాను.
105. మీరు కన్స్ట్రక్టర్ కొంతమంది డైనమిక్ కేటాయించిన పాయింటర్ సభ్యుల కోసం కొత్త ఆపరేటర్‌ను ఉపయోగిస్తారు.
106. అందువల్ల, మీరు కంపైలర్ అయినప్పుడు ఆపరేటర్ క్రొత్తదాన్ని ఉపయోగిస్తున్నారు, అప్పుడు మీ ఆపరేటర్ (ఆపరేటర్) = తప్పనిసరిగా ఓవర్‌లోడ్ చేయాలి.
107. ఎందుకంటే అప్పుడు నిస్సార కాపీ మరియు లోతైన కాపీ మధ్య నిర్ణయించే స్థానం మీకు ఉంటుంది.
108. అదే సమయంలో కాపీ కన్స్ట్రక్టర్ నిర్వచించాల్సిన అవసరం ఉంటే, సాధారణంగా ఒక కాపీ = ఆపరేటర్ నిర్వచించబడాలి; అలాగే మరియు దీనికి విరుద్ధంగా.
109. కాబట్టి, మీరు తరగతులను రూపకల్పన చేసినప్పుడు, దయచేసి ఈ విషయాన్ని గుర్తుంచుకోండి ఎందుకంటే కాపీ '=' ఆపరేటర్ చాలా ముఖ్యమైన ఆపరేటర్, ఇది ఓవర్‌లోడ్ కావాలి.
110. మా కోసం మాత్రమే వెళుతున్నప్పుడు, ఎక్రీ ఆపరేటర్లను ఒకే కారణంతో ఓవర్‌లోడ్ చేయవచ్చు, నేను వాటిని ఇక్కడ చేర్చాను, ఎకరీ ఆపరేటర్లు రెండు రకాల ఉపసర్గ మరియు పోస్ట్‌ఫిక్స్ కావచ్చు.
111. కాబట్టి, ఇది ఉపసర్గ ఆపరేటర్ మరియు ఇది పోస్ట్ఫిక్స్ ఆపరేటర్.
112. పోస్ట్‌ఫిక్స్ ఆపరేటర్ (ఆపరేటర్) సంతకంలో అదనపు రకం ద్వారా నియమించబడిందని నేను ఇప్పటికే ప్రస్తావించాను, కాని ఇది కేవలం ప్లేస్‌హోల్డర్ మాత్రమే, ఇది కంపైలర్ ఉపసర్గ మరియు పోస్ట్‌ఫిక్స్ ఆపరేటర్ మధ్య పరిష్కరించడానికి ఉపయోగిస్తుంది. దీన్ని పూర్తి చేస్తారు.
113. వాస్తవానికి, మీరు రెండవ పరామితిని నాన్-ఆపరేటర్‌కు పంపాలని ఆశించరు, ఎందుకంటే యూనిరీ ఆపరేటర్ ఇప్పటికే తరగతి నుండి వర్తించే పరామితిని కలిగి ఉంది.ఇది ఇదే లేదా ఇదే.
114. ఇప్పుడు, మీరు అమలు మరియు తిరిగి రకాలను చూస్తున్నట్లయితే.
115. నేను మీపై కొంచెం హైలైట్ చేయాలనుకుంటున్నాను.
116. అందువల్ల, ఇది ఉపసర్గ పెరుగుదల అయితే, మనకు తెలిసినది ఏమిటంటే అది మొదట ఇంక్రిమెంట్ చేసి వస్తువును తిరిగి ఇస్తుంది.
117. ఉపసర్గ ఆపరేటర్ తప్పనిసరిగా ఆహ్వానం సంభవించిన అదే వస్తువును తిరిగి ఇవ్వాలి.
118. కాబట్టి, అదే వస్తువు తిరిగి రావాలని మరియు సహజంగా తిరిగి ఉండాలి, ఇది ప్రాథమికంగా అదే వస్తువును తిరిగి ఇస్తుంది.
119. మరియు దీనికి ముందు ఆపరేషన్ యొక్క గజిబిజి ఇప్పటికే జరిగింది.
120. మరోవైపు, మీరు పోస్ట్ ఇంక్రిమెంట్ ఆపరేటర్‌ను చూస్తే, అవును మీరు పొందాలి అంటే ఆపరేటర్ ఇప్పటికే పనిచేశారు, పోస్ట్ ఇంక్రిమెంట్ ఫలితం అసలు ధర.
121. ఆపరేటర్ రాకముందు మీకు ఉన్న అసలు ధర, మీరు ఆ రాబడి విలువను పొందుతారు, ఆపై అంశం పెరుగుతుంది.
122. కాబట్టి, ఇది తరువాత జరుగుతుంది.
123. కాబట్టి, మీరు వస్తువును పెంచుతారు కాబట్టి వస్తువు పెరుగుతుంటే ఈ ఆపరేషన్ తర్వాత ఏదో ఒకవిధంగా పెరుగుతుంది.
124. తిరిగి వచ్చిన విలువ అసలు యొక్క కాపీ అయి ఉండాలి, ఎందుకంటే అసలు అంశం ఆపరేటర్ నుండి తిరిగి వచ్చిన వెంటనే మారబోతోంది.
125. కాబట్టి, ఇప్పుడు మీరు దానిని తాత్కాలిక రిటర్న్ సందర్భంలో కాపీ చేయవలసి ఉంది మరియు మీరు తాత్కాలికమైనదాన్ని తిరిగి ఇస్తున్నందున, మీ రిటర్న్ రకాన్ని ఇప్పటికే తిరిగి ఇవ్వవలసి ఉంటుందని మీరు ఇప్పటికే చర్చించినందున, ఈ రిటర్న్ రిఫరెన్స్ ద్వారా సాధ్యం కాదు.
126. కాబట్టి, పోస్ట్ ఆపరేటర్ సందర్భంలో, మీ రిటర్న్ రకం ధర రకం ద్వారా వ్రాయబడుతుంది.
127. అందువల్ల, నేను ఈ వివరణలను ఇక్కడ వ్రాశాను, మీరు దీనిపై సిద్ధమవుతున్నప్పుడు మీరు వాటిని సూచించాల్సిన అవసరం ఉంది మరియు ఈ విధంగా మీరు ఉన్ని ఆపరేటర్లను ఓవర్లోడ్ చేయవచ్చు.
128. ఇంకొక విషయం ఏమిటంటే, ఓవర్‌లోడింగ్ విషయంలో నేను ఒకరిని మాత్రమే కాకుండా అనేక ఇతర ఆపరేటర్లను కూడా హైలైట్ చేయాలనుకుంటున్నాను; ఈ ఆపరేటర్ ఏకపక్ష ఇంక్రిమెంట్ ఆపరేటర్, మాజీ ఇంక్రిమెంట్ ఆపరేటర్ అని uming హిస్తూ, ఒక నాన్-ఆపరేటర్ మాత్రమే మీకు చూపిస్తాను.
129. కానీ మీరు కలిగి ఉన్న కార్యాచరణ ఇంక్రిమెంట్ ఫంక్షన్ అని అవసరం లేదు.
130. ఇది కొన్ని ఇతర కార్యాచరణలు కావచ్చు, ఇక్కడ మాదిరిగా, నేను ఈ ఆపరేటర్‌ను పిలిస్తే నా డేటా ప్రాంతం రెట్టింపు అవుతుందని నేను చూపిస్తున్నాను, కాని ముఖ్యమైనది ఏమిటంటే ఆపరేటర్ యొక్క అసలు సెమాంటిక్స్ అది మీరు వర్తింపజేసిన వస్తువును తిరిగి ఇస్తుంది.
131. కాబట్టి, ఇది అదే విధంగా ఉంటుంది, ఇది అలాగే ఉంటుంది, కానీ వాస్తవ కార్యాచరణ భిన్నంగా ఉండవచ్చు.
132. పోస్ట్ ఆపరేటర్ కోసం అదే పరిస్థితి ఉంది మరియు నేను మీ డేటాను మూడు ద్వారా విభజించిన కొన్ని విభిన్న కార్యాచరణలను అందించాను.
133. ఇది పట్టింపు లేదు, మీకు కావలసినది ఉంచవచ్చు.
134. కానీ ఆ మూల నుండి మీరు అసలు వస్తువును తాత్కాలికంగా మరియు ఆ విలువ నుండి తిరిగి రావడం ద్వారా తాత్కాలికంగా కాపీ చేయాల్సిన అవసరం ఉంది, ఎందుకంటే పోస్ట్ ఆపరేటర్ పోస్ట్ లీడర్‌షిప్ ఆపరేటర్ షాల్ మరియు ఈ పరిశీలనలు.
135. కాబట్టి, ప్రీ ఇంక్రిమెంట్, ప్రీ ఇంక్రిమెంట్ ఆపరేటర్ లేదా మీ వద్ద ఉన్న అన్ని ఇతర గ్యారీ ఆపరేటర్లు మరియు బైనరీ ఆపరేటర్లకు ఇది ఒకే విధంగా ఉంటుంది.
136. ఈ మాడ్యూల్‌లో, వినియోగదారు నిర్వచించిన రకాలు కోసం ఆపరేటర్ ఓవర్‌లోడింగ్‌ను పరిచయం చేసాము.
137. ఆపరేటర్లను ఓవర్లోడ్ చేయడం ఎందుకు ముఖ్యమో మేము వివరించాము మరియు గ్లోబల్ ఫంక్షన్లు మరియు క్లాసుల సభ్యుల ఫంక్షన్లను ఉపయోగించి ఆపరేటర్ల ఓవర్లోడ్ యొక్క మూలాన్ని వివరించాము. పద్ధతి వివరించబడింది.
138. ఈ ప్రక్రియలో, ఓవర్‌లోడ్ కోసం మీరు ఫ్రెండ్ ఫంక్షన్‌ను ఉపయోగించవచ్చని కూడా మేము చూశాము, ఇది మేము తదుపరి మాడ్యూల్‌లో చేస్తాము.
139. ఈ మాడ్యూల్‌లో, మొత్తం బైనరీ మరియు బైనరీయేతర ఆపరేటర్లకు ఓవర్‌లోడింగ్ యొక్క ప్రాథమిక సెమాంటిక్స్ యొక్క రూపురేఖలు ఉన్నాయి.
140.
 ప్రోగ్రామింగ్ ఇన్ సి ++ మోడ్యూల్ 18 కు స్వాగతం.
ముందుగా ఆపరేటర్లు ఓవర్లోడింగ్ గురించి మాట్లాడ్దాము.
C ++ లోని ఆపరేటర్లు, వాటిలో ఎక్కువ భాగం యూజర్ ఓవర్‌లోడ్ చేయగల సంబంధిత ఆపరేటర్ ఫంక్షన్లతో సంబంధం కలిగి ఉండవచ్చని మేము చర్చించాము.
ఈ మాడ్యూల్‌లో మరియు తరువాతి వాటిలో, వినియోగదారు నిర్వచించిన రకాలు కోసం ఆపరేటర్ ఓవర్‌లోడ్‌ను లోతుగా పరిశీలిస్తాము.ఇది లింక్డ్ డిస్కషన్.
కాబట్టి, ఇది ఈ చర్చలో పార్ట్ -1 అవుతుంది.
వినియోగదారు నిర్వచించిన రకాల కోసం ఆపరేటర్లను ఓవర్లోడ్ ఎలా చేయాలో అర్థం చేసుకోవడానికి మేము ప్రయత్నిస్తాము.
మరియు ఈ మాడ్యూల్‌లో గ్లోబల్ ఫంక్షన్లు మరియు సభ్యుల ఫంక్షన్లను ఉపయోగించి ఓవర్‌లోడింగ్ యొక్క అంశాలను మేము అన్వేషిస్తాము.
ఎప్పటిలాగే మీ స్క్రీన్ యొక్క ఎడమ వైపున అవుట్లైన్ అందుబాటులో ఉంటుంది.
ఇప్పుడు, ఆపరేటర్ ఓవర్‌లోడింగ్ గురించి చర్చించటానికి ముందు, ఆపరేటర్‌ను ఎందుకు ఓవర్‌లోడ్ చేయాలనుకుంటున్నామో త్వరగా క్లుప్తీకరిస్తాను.
నేను మొదటి రెండు మాడ్యూళ్ళను సూచించాలనుకుంటున్నాను; మాడ్యూల్ 9, ఇక్కడ నిర్మాణాత్మక రకాల కోసం ఓవర్‌లోడింగ్ ఆపరేటర్ + గురించి చర్చించాము, స్ట్రింగ్ స్ట్రక్చర్ కోసం ఆపరేటర్ + ఓవర్‌లోడ్ అయిందని చూపించడానికి లెక్కించిన రకాలు, అంటే నక్షత్రాల సంగ్రహణ.
అదేవిధంగా, మేము ఎనుమ్ రకాల కోసం నిర్దిష్ట ఓవర్‌లోడ్‌లను గమనించాము.
తరువాత మాడ్యూల్ 14 లో, మేము ఆ ఆపరేటర్ గురించి మాట్లాడాము, అసైన్‌మెంట్ ఆపరేటర్ కోసం ఓవర్‌లోడింగ్‌ను కాపీ చేయడానికి సరైన సెమాంటిక్స్ను నిర్వచించాము, ముఖ్యంగా లోతైన మరియు నిస్సారమైన కాపీయింగ్ సందర్భంలో. ముఖ్యమైనవి.
సాధారణంగా, అదే ప్రయోజనం యొక్క ఆపరేటర్లు మరియు విధులు మనకు తెలిసినట్లుగా, వ్యత్యాసం ఏమిటంటే ఆపరేటర్‌కు చాలా కాంపాక్ట్ సంజ్ఞామానం ఉంటుంది, ఇది సాధారణంగా ఇన్ఫిక్స్.
అందువల్ల, కాంపాక్ట్ వ్యక్తీకరణ సందర్భంలో చాలా విభిన్నమైన సంక్లిష్ట ఫంక్షన్ల కలయికను వ్రాయడం సాధ్యమవుతుంది; సరైన కార్యాచరణ కోసం తగిన ఆపరేటర్‌ను నేను నిర్వచించగలిగితే మనం చేయాలనుకుంటున్నాము.
అందువల్ల, అంతర్నిర్మిత రకాలు కోసం అవి అప్రమేయంగా లభిస్తాయి, కొన్ని ఆపరేటర్లు పాయింటర్ రకాలు కోసం కూడా అందుబాటులో ఉన్నాయి.
కాబట్టి, నేను నిర్వచించబోయే రకం కోసం ఆపరేటర్లను ఓవర్‌లోడ్ చేయగలిగితే; ఇది వినియోగదారు నిర్వచించిన రకం; ఆపరేటర్లను రకాలుగా నిర్మించటానికి నిర్వచించబడిన విధంగా.
వినియోగదారు నిర్వచించిన రకం కోసం, మేము వ్యక్తీకరణను కూడా వ్రాయగలము, వాస్తవానికి మనం నిర్మిస్తున్న నిర్దిష్ట వినియోగదారు-నిర్వచించిన రకం లేదా UDT ఆధారంగా పూర్తి బీజగణితాన్ని నిర్మించవచ్చు.
అందువల్ల, ఇక్కడ నేను ఇప్పుడే ప్రస్తావించాను మరియు ఏమి చేయవచ్చనే దానిపై చాలా క్లుప్త రూపురేఖలు ఇవ్వడానికి ప్రయత్నించాను.
ఉదాహరణకు, C ++ కి సంక్లిష్ట రకం లేదు.
ఇది డబుల్ రకాన్ని కలిగి ఉంది, కానీ సంక్లిష్టమైన రకం కాదు.
కానీ ఆపరేటర్ ఓవర్‌లోడింగ్ ఉపయోగించి, మేము ఆపరేటర్ + ను ఇలా నిర్వచించవచ్చు; సంక్లిష్ట సంఖ్యలు జతచేస్తాయని మేము చెప్పగలం, ఇది సంక్లిష్ట సంఖ్యల వ్యవకలనం, సంక్లిష్ట సంఖ్యల గుణకారం, సంక్లిష్ట సంఖ్యల విభజన.
ఇవన్నీ సంబంధిత ఆపరేటర్ల పరంగా నిర్వచించబడతాయి మరియు కొన్ని, సంక్లిష్ట కంజుగేట్ల కోసం శోధించడం వంటి సంక్లిష్ట రకానికి ప్రత్యేకమైనవి.
మేము '!' ఆపరేటర్‌ను ఉపయోగించవచ్చు. ఆశ్చర్యార్థక ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడం అంటే '!' ఆపరేషన్ ఒక రకమైన నిరాకరణ.
కాబట్టి, సంక్లిష్ట సంయోగం ఆ ఆపరేటర్‌ను నిర్లక్ష్యం చేయడం వంటిది.
అదేవిధంగా, మనకు వేర్వేరు రకాలు ఉండవచ్చు, మాతృక యొక్క విలోమంతో సహా బీజగణితంతో సహా అన్ని మాత్రికలకు ఆపరేటర్‌ను కలిగి ఉన్న మాతృక రకాలను కలిగి ఉండవచ్చు, మేము యూనియన్, తేడా, సూపర్‌సెట్, ఉపసమితి సంబంధం మరియు మొదలైన రకాలను సెట్ చేయవచ్చు .
అందువల్ల, ఇవన్నీ మరియు మీరు సృష్టించడానికి యుడిటిగా నిర్వచించదలిచిన అన్ని రకాలు, మీరు ఆపరేటర్ ఓవర్‌లోడింగ్ ఉపయోగించి పూర్తి రకాన్ని సృష్టించవచ్చు.
మరియు ముఖ్యంగా, IO పరంగా, ఆపరేటర్ అవుట్పుట్ మరియు ఆపరేటర్ ఇన్పుట్ స్ట్రీమింగ్ పరంగా మేము చాలా కాంపాక్ట్ IO చేయవచ్చు.
ఆ ఆపరేటర్లను చాలా కాంపాక్ట్ IO నిర్మాణాలను అందించడానికి UDT కోసం ఓవర్‌లోడ్ చేయవచ్చు.
మరియు నేను ప్రస్తావించాలనుకుంటున్నాను, కానీ ఇది కొంతవరకు ముందంజలో ఉంది.
స్మార్ట్ పాయింటర్ యొక్క C ++ లోని కొన్ని మంచి నమూనాలు ఆపరేటర్ ఓవర్‌లోడింగ్ కోసం చాలా ముఖ్యమైనవి.
అందువల్ల, మంచి వినియోగదారు-నిర్వచించిన రకాన్ని సృష్టించడానికి ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడం ఒక ముఖ్యమైన అవసరం.
కాబట్టి, మేము ఇప్పుడు ముందుకు సాగాలి.ఇది మాడ్యూల్ 9 నుండి శీఘ్ర రీక్యాప్, ప్రతి ఆపరేటర్ కోసం, మేము నిర్వచించగల ఆపరేటర్ ఫంక్షన్ ఉందని మేము చూశాము.
మరియు ఆ ఆపరేటర్ ఫంక్షన్ ఖచ్చితంగా ఆపరేటర్ + 'వంటి సంతకాన్ని కలిగి ఉంటుంది.
ఈ సందర్భంలో, మేము దీనిని చూశాము; నేను ఇక్కడ ఎక్కువ సమయం వృథా చేయను.
ఇది మీ మనస్సులో జరిగితే మళ్ళీ గుర్తుంచుకోండి.
ఇప్పుడు ఈ ఆపరేటర్ సభ్యులే కాని ఫంక్షన్ కావచ్చు.
అందుకని ఇది సార్వత్రిక ఫంక్షన్ కావచ్చు మరియు ఫ్రెండ్ ఫంక్షన్లు కూడా ఉన్నాయని మాకు తెలుసు.
కాబట్టి, ఆపరేటర్ ఫంక్షన్ గ్లోబల్ ఫంక్షన్ లేదా ఫ్రెండ్ ఫంక్షన్ అయితే, ఇది ఇలా అనిపించవచ్చు, ఇది నా రకానికి చెందిన రెండు వస్తువులను కనెక్ట్ చేయడానికి గ్లోబల్ ఆపరేటర్ (). ఆపరేటర్) ఫంక్షన్ కూడా ఇది నా రకం.
అదేవిధంగా, ఒకరికి - అది స్నేహితుడైతే, అది ఏదోలా కనిపిస్తుంది, ఒకే తేడా ఏమిటంటే ఫ్రెండ్ కీవర్డ్ రావడం.
అదేవిధంగా, బైనరీ ఆపరేటర్ల కోసం గ్లోబల్ ఆపరేటర్ల కోసం గ్లోబల్ లేదా ఫ్రెండ్ ఫంక్షన్లను కలిగి ఉండవచ్చు.
కాబట్టి, మీరు దీన్ని యూనిటరీ ఆపరేటర్ల కోసం కలిగి ఉండవచ్చు.
మేము ఉపసర్గ ఆపరేటర్ మరియు పోస్ట్ఫిక్స్ ఆపరేటర్ కోసం ఒక నిర్దిష్ట ఆపరేటర్ కావచ్చు.
మనకు ఉపసర్గ ఆపరేటర్ మరియు ఆపరేటర్ ఉండవచ్చు.
ఇది కాకుండా, మేము ఆపరేటర్ ఫంక్షన్లను కూడా కలిగి ఉండవచ్చు, అవి ప్రాథమికంగా సభ్యుల ఫంక్షన్లు.
కాబట్టి, ఇది సభ్యుల ఫంక్షన్ అయితే ఆపరేటర్ ఫంక్షన్ ఇలా కనిపిస్తుంది.
ఇక్కడ గమనించవలసిన ముఖ్య విషయం ఏమిటంటే `+ 'బైనరీ ఆపరేటర్, కాబట్టి దీనికి రెండు ఒపెరాండ్స్ అవసరం.
కానీ ఇక్కడ మీరు, ఆపరేటర్ + కోసం ఒక పరామితిని మాత్రమే చూస్తారు, ఎందుకంటే ఇది ఆపరేటర్ ఫంక్షన్, సభ్యుల ఫంక్షన్ మొదటి ఆపరేటర్ లేదా ఎడమ చేతి వైపు ఉంటుంది. ఆపరేటర్ యొక్క ఎడమ ఆపరేటర్ (ఆపరేటర్) మీకు ఒక వస్తువు ఆపరేటర్ ఫంక్షన్‌ను ఆహ్వానిస్తున్నారు.
కాబట్టి, నాకు ఏదైనా సభ్యుల పని ఉందో మీకు తెలిసినట్లుగా, ఇక్కడ నేను ఈ సభ్యుడికి కనిపించను.
కాబట్టి, ఈ అదృశ్య పాయింటర్ వాస్తవానికి నా మొదటి ఒపెరాండ్ ఇదేనని లేదా నా వద్ద ఉన్న ప్రస్తుత వస్తువు ఎల్లప్పుడూ ఎడమ ఒపెరాండ్‌గా ఉంటుందని మరియు కుడి ఒపెరాండ్ ఇక్కడ దాటిందని అర్థం.
కాబట్టి, సభ్యుల ఫంక్షన్ విషయంలో, ఇది గ్లోబల్ లేదా ఫ్రెండ్ ఫంక్షన్ నుండి తేడా.
యునరీ ఆపరేటర్లను కూడా నిర్వచించవచ్చు, ఒక విధంగా, సహజంగా, యూనిరీ ఆపరేటర్లకు ఒపెరాండ్ ఉండదు, ఎందుకంటే వారికి ఒకటి మాత్రమే ఉంది మరియు మీరు దానిని వర్తించే అంశం ఇది.
ఇది పోస్ట్‌ఫిక్స్‌డ్ ఆపరేటర్ అయితే, మనకు ఒక రకమైన పూర్ణాంకానికి ఉంటుంది, ఇది వాస్తవానికి ఒపెరాండ్ కాదా? కానీ అదనపు రకం సంతకం పూర్ణాంకం అంటే పోస్ట్‌ఫిక్స్ ఆపరేటర్.
అందువల్ల, ఇది ప్రిఫిక్స్ ఆపరేటర్ల మధ్య తేడాను గుర్తించడానికి ఉపయోగించబడుతుంది, ఇది మరొక పోస్ట్ఫిక్స్ ఆపరేటర్, ఎందుకంటే ఈ రెండింటిని '++' అని పిలుస్తారు.
కాబట్టి, సంతకం జాబితాలోని ఈ అదనపు రకం ఆపరేటర్ ఏ ఉపసర్గ అని నిర్దేశిస్తుంది, ఇది పోస్ట్‌ఫిక్స్ ఆపరేటర్.
కాబట్టి, ఇవి ఆపరేటర్ ఫంక్షన్లను నిర్వచించి వాటిని ఓవర్‌లోడ్ చేయగల వివిధ ఎంపికలు.
అందువల్ల, నేను మిమ్మల్ని త్వరగా మాడ్యూల్ 9 కు సూచిస్తాను.
ఎక్కడ, ఆపరేటర్ల కోసం మేము ఏమి చేయగలమో అనే నియమాల సారాంశాన్ని చూశాము.
మేము ఆపరేటర్ల యొక్క ప్రాధమిక లక్షణాలను మార్చలేము మరియు ఓవర్‌లోడ్ చేయగల ఆపరేటర్ల యొక్క స్థిర జాబితా ఉంది. ఓవర్‌లోడ్ చేయలేని కొన్ని ఆపరేటర్లు ఉన్నారు, కొన్ని ఓవర్‌లోడ్ చేయకూడదు, మేము మాడ్యూల్) 9 దీన్ని లోతుగా చర్చిస్తాము, కాబట్టి నేను దానిని వదిలివేస్తుంది.
ఇప్పుడు నీలిరంగులో హైలైట్ చేయబడిన రెండు పాయింట్లు అదనపువి, ఒకటి ఆబ్జెక్ట్‌ను ప్రారంభించడం ద్వారా ఆమోదించబడిన సభ్యుల ఫంక్షన్ కోసం, నేను ఇప్పుడే వివరించాను మరియు ఇది ఎడమ ఒపెరాండ్‌గా ఉంది, కాబట్టి సరైన ఒపెరాండ్ మాత్రమే స్పష్టంగా ప్రస్తావించబడింది.
గ్లోబల్ ఫంక్షన్ లేదా ఫ్రెండ్ ఫంక్షన్ విషయంలో, రెండు ఒపెరాండ్‌లు స్పష్టంగా పేర్కొనబడ్డాయి.
కాబట్టి, ఇది ఆపరేటర్ యొక్క ఓవర్లోడ్ యొక్క మూలం.
కాబట్టి, ఇప్పుడు దీనితో మనం ఇంతకుముందు చూసిన కొన్ని కోడ్‌లను పరిశీలిద్దాం, అవి గ్లోబల్ ఫంక్షన్‌ను ఉపయోగించి ఆపరేటర్‌ను ఓవర్‌లోడ్ చేయడానికి ప్రయత్నిస్తాయి.
అందువల్ల, నేను ఒక సాధారణ సంక్లిష్ట తరగతిని కలిగి ఉన్నాను.
కాబట్టి, ఈ సభ్యులు ఇద్దరూ బహిరంగంగా అందుబాటులో ఉన్నారని మరియు ఈ సంక్లిష్ట నిర్మాణం కోసం మేము ఆపరేటర్ + ఆపరేటర్‌ను వ్రాశాము, ఇది ప్రాథమికంగా నిజమైన మరియు inary హాత్మక భాగాల భాగం యొక్క తెలివైన చేరిక.
ఈ వ్యక్తీకరణలో d1 ఒక సంక్లిష్టమని మనం ఉపయోగిస్తే, d2 మరింత క్లిష్టంగా ఉండటం వలన మనం d1 + d2 ను వ్రాయవచ్చు.
అంటే రెండు సంక్లిష్ట సంఖ్యలను జతచేయడం, వాస్తవానికి ఈ ఆపరేటర్, మేము ఈ ఫంక్షన్‌ను ఆపరేషన్లుగా అమలు చేస్తాము మరియు ఆ ఫలితం d కి కేటాయించబడుతుంది.
కాబట్టి, మంచిది.
దీన్ని అర్థం చేసుకోవడంలో మీకు పెద్దగా ఇబ్బంది ఉండదని నేను ఖచ్చితంగా అనుకుంటున్నాను.
కుడి వైపున మీకు మరొక ఉదాహరణ ఉంది, ఇక్కడ మేము ఇక్కడ ఒక సి స్ట్రింగ్‌ను చుట్టడానికి ఒక నిర్మాణాన్ని ఉపయోగిస్తున్నాము మరియు ఆ నిర్మాణం యొక్క రకాన్ని బట్టి, స్ట్రింగ్ స్ట్రక్చర్ రకాన్ని బట్టి, మేము స్ట్రింగ్ కోసం ఆపరేటర్ '+' ను పునర్నిర్వచించాము మరియు ఓవర్‌లోడ్ చేసాము.
ఈ విధంగా, ఇక్కడ ఇవ్వబడిన రెండు తీగలను మొదటి పేరు మరియు చివరి పేరు కోసం వ్యక్తీకరణలను జోడించవచ్చు, ఇవి వాస్తవానికి ఈ ఫంక్షన్‌లోకి వెళ్లి ఒకదాన్ని చేస్తాయి.
అందువల్ల, ఒక రకాన్ని బట్టి మనకు ఒకే ఆపరేటర్ + ఉంటుంది. కొన్ని సందర్భాల్లో ఇది సంక్లిష్ట సంఖ్యలకు అదనంగా ఉంటుంది, కొన్ని సందర్భాల్లో దీని అర్థం తీగల కలయిక మరియు మొదలైనవి.
ఇది చాలా సులభం మరియు దీని కోసం, మేము ఇక్కడ గ్లోబల్ ఫంక్షన్లను ఉపయోగించాము.
ఇప్పుడు సహజంగా, మీరు గ్లోబల్ ఫంక్షన్‌ను ఉపయోగిస్తుంటే, ఇది ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ సిస్టమ్‌లో ఇది సరసమైన విషయం కాదని మాకు తెలుసు, ఎందుకంటే గ్లోబల్ టాస్క్, కానీ సహజంగానే వారు డేటాతో పనిచేయాలి ముఖ్యంగా సంక్లిష్ట యొక్క నిజమైన మరియు inary హాత్మక భాగం సభ్యులు అవసరమయ్యే సంఖ్యను బహిరంగపరచాలి మరియు డేటా సభ్యులు నిజంగా ప్రైవేట్‌గా ఉండాలి అనే సూత్రాన్ని మేము పునరుద్ఘాటించాము.
కాబట్టి మనం వాటిని ప్రైవేట్‌గా చేసుకోవాలి.
తరగతికి మద్దతు ఇచ్చే ప్రత్యేక కార్యకలాపాలు మాత్రమే పబ్లిక్‌గా ఉండాలి.
ఇప్పుడు మనం ఇలా చేస్తే, సహజంగా దీనితో మనం ఆపరేటర్ + ను నేరుగా వ్రాయలేము, ఆపరేటర్ + ను గ్లోబల్ ఫంక్షన్ గా నేరుగా ఓవర్రైడ్ చేయవచ్చు, ఎందుకంటే ఈ గ్లోబల్ ఫంక్షన్ ప్రైవేట్ డేటా సభ్యులను యాక్సెస్ చేయదు.
కాబట్టి, ఈ పని చేయడానికి, మేము భాగాలకు సెట్ ఫంక్షన్ల సమూహాన్ని జోడించాలి.
నేను నిజమైన భాగాన్ని ఎక్కడ చదవగలను, నేను inary హాత్మక భాగాన్ని చదవగలను, అక్కడ నేను నిజమైన భాగాన్ని వ్రాయగలను, inary హాత్మక భాగాన్ని వ్రాయగలను.
అందువల్ల, ఈ పద్ధతుల సమితిని ఉపయోగించి ఆపరేటర్ + కోసం గ్లోబల్ ఆపరేటర్ ఓవర్‌లోడింగ్‌ను వ్రాయవచ్చు.
ఇది బాగా పనిచేస్తుంది ఇది పని చేస్తుంది మరియు మేము డేటా సభ్యులను ప్రైవేట్‌గా చేయగలుగుతాము, కాని ఇది మెరుగైన పరిష్కారాన్ని అందించదని పేర్కొంది.
ఎందుకంటే, గ్లోబల్ ఫంక్షన్‌ను అమలు చేయడానికి, మేము ఇవన్నీ నిర్వచించిన ఫంక్షన్‌కు కేటాయించాల్సి వచ్చింది.
మీ అంతర్గత డేటాను బాహ్య ప్రపంచానికి బహిర్గతం చేయడానికి మీరు నిజంగా అందించే సెట్ సెట్ ఫంక్షన్లు.
ఎందుకంటే, మంచి వ్యక్తులు నేరుగా డేటా సభ్యులను ఉపయోగించలేరు, కాని ఆపరేటర్ + సెట్‌ను ఉపయోగించుకోవచ్చు మరియు నిజమైన మరియు ఊహాత్మక భాగాలను పొందవచ్చు కాబట్టి, ఏదైనా బాహ్య ఫంక్షన్‌ను బాహ్య తరగతిగా కూడా ఉపయోగించవచ్చు.
కాబట్టి, ఒక విధంగా, ఈ పరిష్కారం మనకు ఉన్న ఒక రకమైన ఎన్కప్సులేషన్.
అందువల్ల, గ్లోబల్ ఫంక్షన్లతో మనకు తెలుసు, మనం ఎన్కప్సులేషన్ను సంరక్షించలేము.
మేము చూసే తదుపరి ఎంపిక ప్రాథమికంగా సభ్యుల విధులను ఉపయోగించడం మరియు ఇలాంటి పనులు చేయడం.
ఆపరేటర్ ఇప్పుడు సభ్యుల ఫంక్షన్‌గా ఓవర్‌లోడ్ అయిందని ఇప్పుడు పరిశీలిద్దాం.
కాబట్టి, అది తరగతి లోపలికి వెళ్లిందని మీరు చూడవచ్చు.
నా డేటా సభ్యులు ఇప్పటికీ ప్రైవేట్‌గా ఉన్నారు మరియు ఇది తరగతి లోపలికి తరలించబడినందున, దీనికి ఒకే పరామితి ఉంది, ఇది కుడి వైపున ఉన్న పరామితి.
మరియు ఎడమ వైపు పరామితి వస్తువుగా ఉంటుంది.
కాబట్టి, నేను ఎడ్‌ను జోడించాలనుకున్నప్పుడు, c.re తో తిరిగి జోడించండి.
ఎక్కడ, సి అనేది కుడి చేతి ఒపెరాండ్ మరియు మీకు తెలిసినట్లుగా, ఈ పద్ధతి వర్తించే ప్రస్తుత వస్తువు యొక్క వాస్తవ భాగాన్ని సూచిస్తుంది, ఇది ఎడమ చేతి వైపున పనిచేసేది.
కాబట్టి, మీరు సి 1 + సి 2 వ్రాసినట్లే, మేము సి 1 + సి 2 వ్రాసేటప్పుడు, ఇది సి 1 `కండక్టర్ + 'సి 2 కు సమానమని సంజ్ఞామానం సూచిస్తుంది.
కాబట్టి, అంటే సి 2 కుడి చేతి ఒపెరాండ్, అది సి అవుతుంది మరియు సి 1 ప్రస్తుత నక్షత్రం.
అందుకే మనం మళ్ళీ చర్చిస్తున్నప్పుడు మనం నిజంగా c1 యొక్క వాస్తవ భాగాన్ని సూచిస్తున్నాము, నేను c.re ని సూచిస్తున్నప్పుడు మేము c2 యొక్క వాస్తవ భాగాన్ని సూచిస్తున్నాము మరియు ఈ విధంగా ఈ గణన కొనసాగుతుంది.
మేము రక్షించదలిచిన ఎన్‌క్యాప్సులేషన్‌ను రక్షించడం ఒక ప్రయోజనం అని మీకు అదే సమాధానం ఇచ్చే ఖచ్చితంగా ఇదే పరిష్కారం మీకు ఇస్తుంది.
కాబట్టి, మేము దానితో చాలా తేలికగా పని చేయవచ్చు మరియు సభ్యుల ఫంక్షన్లను ఉపయోగించి మంచి ఆపరేటర్ ఓవర్‌లోడింగ్ చేయవచ్చు.
ఇప్పుడు, మీరు చాలా మందికి బైనరీ ఆపరేటర్‌ను చూపించినట్లే, ఇతర ఆపరేటర్లను ఓవర్‌లోడ్ చేయవచ్చు.
ఉదాహరణకు, మీరు మాడ్యూల్ 14 లో గుర్తుచేసుకుంటే, కాపీ చేసే ఎంపికలలో మేము వివిధ అవకాశాలను చర్చించినప్పుడు, ఆపరేటర్ అసైన్‌మెంట్ కాపీ కాపీ ఆపరేటర్ అని మేము చూపించాము.
ఇది ఓవర్‌లోడ్ చేయగలదా అనే దాని గురించి మేము మాట్లాడుతున్నాము మరియు ఈ మొత్తం ఉదాహరణను చేయడానికి సురక్షితమైన మార్గం వాస్తవానికి మీ సూచన కోసం మాడ్యూల్ 14 నుండి మళ్ళీ ప్రతిరూపం అవుతుందని చూపబడింది.
కాబట్టి, కాపీ అసైన్‌మెంట్ ఆపరేటర్ కోసం ఓవర్‌లోడింగ్ ఎలా పనిచేస్తుందో మేము ఇప్పటికే చూశాము మరియు అది కూడా ఇక్కడ ఉంది మరియు ఈ ఓవర్‌లోడింగ్ చాలా ముఖ్యమైనదని మేము గుర్తించాము ఎందుకంటే మీరు కంపైలర్‌ను ఓవర్‌లోడ్ చేసే వరకు ఉచిత కాపీ కేటాయింపు కేవలం నిస్సార కాపీ.
కాబట్టి, పాయింటర్ వేరియబుల్స్ సమక్షంలో మీకు తప్పు సెమాంటిక్స్ ఇవ్వవచ్చు మరియు మీరు ఓవర్‌లోడ్ చేసి, కాపీ అసైన్‌మెంట్ ఆపరేటర్‌ను లోతుగా కాపీ చేయాల్సి ఉంటుంది.
ఇప్పుడు నీలిరంగు రంగుతో పాటు, మీరు వినియోగదారులను కొత్త ఆపరేటర్లుగా చేస్తే, మీరు ఏ అదనపు అంశాలను పరిగణనలోకి తీసుకోవాలో చూపించాను.
మీరు కన్స్ట్రక్టర్ కొంతమంది డైనమిక్ కేటాయించిన పాయింటర్ సభ్యుల కోసం కొత్త ఆపరేటర్‌ను ఉపయోగిస్తారు.
అందువల్ల, మీరు కంపైలర్ అయినప్పుడు ఆపరేటర్ క్రొత్తదాన్ని ఉపయోగిస్తున్నారు, అప్పుడు మీ ఆపరేటర్ (ఆపరేటర్) = తప్పనిసరిగా ఓవర్‌లోడ్ చేయాలి.
ఎందుకంటే అప్పుడు నిస్సార కాపీ మరియు లోతైన కాపీ మధ్య నిర్ణయించే స్థానం మీకు ఉంటుంది.
అదే సమయంలో కాపీ కన్స్ట్రక్టర్ నిర్వచించాల్సిన అవసరం ఉంటే, సాధారణంగా ఒక కాపీ = ఆపరేటర్ నిర్వచించబడాలి; అలాగే మరియు దీనికి విరుద్ధంగా.
కాబట్టి, మీరు తరగతులను రూపకల్పన చేసినప్పుడు, దయచేసి ఈ విషయాన్ని గుర్తుంచుకోండి ఎందుకంటే కాపీ '=' ఆపరేటర్ చాలా ముఖ్యమైన ఆపరేటర్, ఇది ఓవర్‌లోడ్ కావాలి.
మా కోసం మాత్రమే వెళుతున్నప్పుడు, ఎక్రీ ఆపరేటర్లను ఒకే కారణంతో ఓవర్‌లోడ్ చేయవచ్చు, నేను వాటిని ఇక్కడ చేర్చాను, ఎకరీ ఆపరేటర్లు రెండు రకాల ఉపసర్గ మరియు పోస్ట్‌ఫిక్స్ కావచ్చు.
కాబట్టి, ఇది ఉపసర్గ ఆపరేటర్ మరియు ఇది పోస్ట్ఫిక్స్ ఆపరేటర్.
పోస్ట్‌ఫిక్స్ ఆపరేటర్ (ఆపరేటర్) సంతకంలో అదనపు రకం ద్వారా నియమించబడిందని నేను ఇప్పటికే ప్రస్తావించాను, కాని ఇది కేవలం ప్లేస్‌హోల్డర్ మాత్రమే, ఇది కంపైలర్ ఉపసర్గ మరియు పోస్ట్‌ఫిక్స్ ఆపరేటర్ మధ్య పరిష్కరించడానికి ఉపయోగిస్తుంది. దీన్ని పూర్తి చేస్తారు.
వాస్తవానికి, మీరు రెండవ పరామితిని నాన్-ఆపరేటర్‌కు పంపాలని ఆశించరు, ఎందుకంటే యూనిరీ ఆపరేటర్ ఇప్పటికే తరగతి నుండి వర్తించే పరామితిని కలిగి ఉంది.ఇది ఇదే లేదా ఇదే.
ఇప్పుడు, మీరు అమలు మరియు తిరిగి రకాలను చూస్తున్నట్లయితే.
నేను మీపై కొంచెం హైలైట్ చేయాలనుకుంటున్నాను.
అందువల్ల, ఇది ఉపసర్గ పెరుగుదల అయితే, మనకు తెలిసినది ఏమిటంటే అది మొదట ఇంక్రిమెంట్ చేసి వస్తువును తిరిగి ఇస్తుంది.
ఉపసర్గ ఆపరేటర్ తప్పనిసరిగా ఆహ్వానం సంభవించిన అదే వస్తువును తిరిగి ఇవ్వాలి.
కాబట్టి, అదే వస్తువు తిరిగి రావాలని మరియు సహజంగా తిరిగి ఉండాలి, ఇది ప్రాథమికంగా అదే వస్తువును తిరిగి ఇస్తుంది.
మరియు దీనికి ముందు ఆపరేషన్ యొక్క గజిబిజి ఇప్పటికే జరిగింది.
మరోవైపు, మీరు పోస్ట్ ఇంక్రిమెంట్ ఆపరేటర్‌ను చూస్తే, అవును మీరు పొందాలి అంటే ఆపరేటర్ ఇప్పటికే పనిచేశారు, పోస్ట్ ఇంక్రిమెంట్ ఫలితం అసలు ధర.
ఆపరేటర్ రాకముందు మీకు ఉన్న అసలు ధర, మీరు ఆ రాబడి విలువను పొందుతారు, ఆపై అంశం పెరుగుతుంది.
కాబట్టి, ఇది తరువాత జరుగుతుంది.
కాబట్టి, మీరు వస్తువును పెంచుతారు కాబట్టి వస్తువు పెరుగుతుంటే ఈ ఆపరేషన్ తర్వాత ఏదో ఒకవిధంగా పెరుగుతుంది.
తిరిగి వచ్చిన విలువ అసలు యొక్క కాపీ అయి ఉండాలి, ఎందుకంటే అసలు అంశం ఆపరేటర్ నుండి తిరిగి వచ్చిన వెంటనే మారబోతోంది.
కాబట్టి, ఇప్పుడు మీరు దానిని తాత్కాలిక రిటర్న్ సందర్భంలో కాపీ చేయవలసి ఉంది మరియు మీరు తాత్కాలికమైనదాన్ని తిరిగి ఇస్తున్నందున, మీ రిటర్న్ రకాన్ని ఇప్పటికే తిరిగి ఇవ్వవలసి ఉంటుందని మీరు ఇప్పటికే చర్చించినందున, ఈ రిటర్న్ రిఫరెన్స్ ద్వారా సాధ్యం కాదు.
కాబట్టి, పోస్ట్ ఆపరేటర్ సందర్భంలో, మీ రిటర్న్ రకం ధర రకం ద్వారా వ్రాయబడుతుంది.
అందువల్ల, నేను ఈ వివరణలను ఇక్కడ వ్రాశాను, మీరు దీనిపై సిద్ధమవుతున్నప్పుడు మీరు వాటిని సూచించాల్సిన అవసరం ఉంది మరియు ఈ విధంగా మీరు ఉన్ని ఆపరేటర్లను ఓవర్లోడ్ చేయవచ్చు.
ఇంకొక విషయం ఏమిటంటే, ఓవర్‌లోడింగ్ విషయంలో నేను ఒకరిని మాత్రమే కాకుండా అనేక ఇతర ఆపరేటర్లను కూడా హైలైట్ చేయాలనుకుంటున్నాను; ఈ ఆపరేటర్ ఏకపక్ష ఇంక్రిమెంట్ ఆపరేటర్, మాజీ ఇంక్రిమెంట్ ఆపరేటర్ అని uming హిస్తూ, ఒక నాన్-ఆపరేటర్ మాత్రమే మీకు చూపిస్తాను.
కానీ మీరు కలిగి ఉన్న కార్యాచరణ ఇంక్రిమెంట్ ఫంక్షన్ అని అవసరం లేదు.
ఇది కొన్ని ఇతర కార్యాచరణలు కావచ్చు, ఇక్కడ మాదిరిగా, నేను ఈ ఆపరేటర్‌ను పిలిస్తే నా డేటా ప్రాంతం రెట్టింపు అవుతుందని నేను చూపిస్తున్నాను, కాని ముఖ్యమైనది ఏమిటంటే ఆపరేటర్ యొక్క అసలు సెమాంటిక్స్ అది మీరు వర్తింపజేసిన వస్తువును తిరిగి ఇస్తుంది.
కాబట్టి, ఇది అదే విధంగా ఉంటుంది, ఇది అలాగే ఉంటుంది, కానీ వాస్తవ కార్యాచరణ భిన్నంగా ఉండవచ్చు.
పోస్ట్ ఆపరేటర్ కోసం అదే పరిస్థితి ఉంది మరియు నేను మీ డేటాను మూడు ద్వారా విభజించిన కొన్ని విభిన్న కార్యాచరణలను అందించాను.
ఇది పట్టింపు లేదు, మీకు కావలసినది ఉంచవచ్చు.
కానీ ఆ మూల నుండి మీరు అసలు వస్తువును తాత్కాలికంగా మరియు ఆ విలువ నుండి తిరిగి రావడం ద్వారా తాత్కాలికంగా కాపీ చేయాల్సిన అవసరం ఉంది, ఎందుకంటే పోస్ట్ ఆపరేటర్ పోస్ట్ లీడర్‌షిప్ ఆపరేటర్ షాల్ మరియు ఈ పరిశీలనలు.
కాబట్టి, ప్రీ ఇంక్రిమెంట్, ప్రీ ఇంక్రిమెంట్ ఆపరేటర్ లేదా మీ వద్ద ఉన్న అన్ని ఇతర గ్యారీ ఆపరేటర్లు మరియు బైనరీ ఆపరేటర్లకు ఇది ఒకే విధంగా ఉంటుంది.
ఈ మాడ్యూల్‌లో, వినియోగదారు నిర్వచించిన రకాలు కోసం ఆపరేటర్ ఓవర్‌లోడింగ్‌ను పరిచయం చేసాము.
ఆపరేటర్లను ఓవర్లోడ్ చేయడం ఎందుకు ముఖ్యమో మేము వివరించాము మరియు గ్లోబల్ ఫంక్షన్లు మరియు క్లాసుల సభ్యుల ఫంక్షన్లను ఉపయోగించి ఆపరేటర్ల ఓవర్లోడ్ యొక్క మూలాన్ని వివరించాము. పద్ధతి వివరించబడింది.
ఈ ప్రక్రియలో, ఓవర్‌లోడ్ కోసం మీరు ఫ్రెండ్ ఫంక్షన్‌ను ఉపయోగించవచ్చని కూడా మేము చూశాము, ఇది మేము తదుపరి మాడ్యూల్‌లో చేస్తాము.
ఈ మాడ్యూల్‌లో, మొత్తం బైనరీ మరియు బైనరీయేతర ఆపరేటర్లకు ఓవర్‌లోడింగ్ యొక్క ప్రాథమిక సెమాంటిక్స్ యొక్క రూపురేఖలు ఉన్నాయి.
inhouse/NPTEL/PreFinal/c++/Telugu/49 ProgramminginCplusplus_Recap of C (Lecture 01)-KG4hjVDw-p8.txt
View file @ 956c0d4e
 1. C ++ ప్రోగ్రామింగ్  కు స్వాగతం.
2. ఇది 20-గంటల కోర్సు అవుతుంది, ఇక్కడ మేము C ++ ప్రోగ్రామింగ్ భాష యొక్క వివిధ అంశాల గురించి మాట్లాడుతాము మరియు ఇది సహజంగా 40 గుణకాలుగా విభజించబడుతుంది, మీరు ఒకదాని తరువాత ఒకటి అధ్యయనం చేస్తారు.
3. సంక్లిష్ట సాఫ్ట్‌వేర్ వ్యవస్థల రూపకల్పన మరియు అమలులో C ++ ప్రోగ్రామింగ్ భాషను ఎలా ఉపయోగించాలో నేర్పడం ఈ కోర్సు యొక్క ప్రధాన ఒత్తిడి.
4. సి ++ ఒక ఆబ్జెక్ట్ ఓరియెంటెడ్ లేదా ఆబ్జెక్ట్ బేస్డ్ ప్రోగ్రామింగ్ లాంగ్వేజ్ అని మీ అందరికీ తెలుస్తుంది మరియు మీకు సి లాంగ్వేజ్ తెలుసని నేను అంగీకరిస్తున్నాను, మీకు చాలా లోతుగా తెలియకపోవచ్చు, కాని మీకు సి లాంగ్వేజ్ గురించి సాధారణ జ్ఞానం ఉంది కాబట్టి, మేము అక్కడ నుండి ప్రారంభిస్తాము, మాడ్యూల్ 1 లో, సి ప్రోగ్రామింగ్ యొక్క విభిన్న నిర్దిష్ట అంశాలను ఉపయోగించడం గురించి మనం మళ్ళీ మాట్లాడుతాము.
5. అవసరమైతే మీరు ఆ భావనలను పున it సమీక్షించగలరని మరియు మేము C ++ భాషలోకి లోతుగా వెళ్ళే ముందు, మీరు అన్ని C ప్రోగ్రామింగ్ అవసరాలను తెలుసుకోగలరని నిర్ధారించుకోవడానికి ఇది మాత్రమే. | ఎందుకంటే సి భాష సి ++ యొక్క స్థానిక భాష.
6. కాబట్టి, మేము మొదట సి భాష యొక్క పునరావృతంతో ప్రారంభిస్తాము. అందువల్ల, సి భాష మరియు ప్రోగ్రామింగ్ అంశాలకు అదనంగా సి స్టాండర్డ్ లైబ్రరీని పరిశీలిస్తాము, ప్రత్యేకించి వివిధ అంశాలను తిరిగి నేర్చుకోవడం కోసం.
7. సి ప్రోగ్రామ్ యొక్క నిర్మాణం, సి ప్రోగ్రామ్ను ఎలా సాధ్యం చేయాలో మేము క్లుప్తంగా చర్చిస్తాము.
8. ఇప్పటివరకు, మీరు 1 లేదా 2 ఫంక్షన్‌ను ఉపయోగించి ఒకే ఫైల్‌కు సూచనగా కోడ్‌ను వ్రాశారు.
9. వాటిలో ఒకటి ప్రధానంగా ఉండాలి (ఫంక్షన్). మీకు తెలిసినట్లుగా, ప్రోగ్రామ్‌లను ఎలా బాగా వ్రాయవచ్చో మేము చూస్తాము మరియు దీనితో మనకు C ++ ప్రోగ్రామింగ్ భాషకు పునాది ఉంటుంది.
10. మాడ్యూల్ డిజైన్ సందర్భంలో చేయవలసిన వివిధ అంశాలు ఇవి.
11. ప్రదర్శనగా, మేము మీ స్క్రీన్ యొక్క ఎడమ వైపుకు వెళ్తాము, మీరు ఈ రూపురేఖను చూస్తారు మరియు మేము ఏ ప్రత్యేక అంశం గురించి మాట్లాడుతున్నామో అది హైలైట్ అవుతుంది.
12. కాబట్టి, ఇది మొదటి కార్యక్రమం "హలో వరల్డ్", మీరందరూ అధ్యయనం చేశారని నేను ఖచ్చితంగా అనుకుంటున్నాను.
13. ఇది కెర్నింగ్ మరియు రిట్చీల ప్రసిద్ధ పుస్తకంలోని ప్రారంభ కార్యక్రమం.
14. టెర్మినల్‌లో "హలో వరల్డ్" ను ప్రింట్ చేయడానికి మేము <stdio> లైబ్రరీ నుండి 'printf' ను ఉపయోగిస్తాము, ఇది అధికారికంగా <stdio> అవుట్ ఫైల్.
15. ప్రధాన విధి ఏమిటంటే మీరు ఎక్కడ చూడగలరు, అక్కడ ఎక్సిక్యూషన్ మొదలవుతుంది. అప్పుడు మీరు ఈ స్ట్రింగ్‌ను ప్రింట్ చేసి '\ n' ను ప్రింట్ చేయండి, అంటే మీరు ప్రాథమికంగా, మేము తదుపరి పంక్తికి వెళ్తాము, అంటే కొత్త పంక్తి.
16. సి లో అనేక రకాల డేటా రకాలు ఉన్నాయి; కెర్ (చార్), క్యారెక్టర్ అని పిలుస్తారు, మొత్తం సంఖ్యలకు పూర్ణాంకం (పూర్ణాంకానికి), ఫ్లోట్ మరియు డబుల్; ఫ్లోటింగ్ పాయింట్లు సంఖ్యల కోసం.
17. ఇప్పుడు, ఇక్కడ మీరు సాధారణంగా ఉపయోగించే C ను C89 అని పిలుస్తారు, C89 C యొక్క మొదటి ప్రమాణం (స్టాండర్డ్) ANSI చే సృష్టించబడింది, ప్రామాణీకరణ సంస్థ మరియు తరువాత 99 లో, మరొక ప్రమాణం విడుదల చేయబడింది, దీనిని C99 అని పిలుస్తారు, కాబట్టి నేడు చాలా కంపైలర్లు C99 ప్రమాణాన్ని అనుసరిస్తున్నారు.
18. C99 కూడా అనుసరిస్తుందని మేము ఆశిస్తున్నాము.
19. కాబట్టి, మేము C గురించి మాట్లాడేటప్పుడు, C99 లో కొన్ని విషయాలు భిన్నంగా ఉంటే హైలైట్ చేయడానికి ప్రయత్నిస్తాము.
20. కాబట్టి, మీరు చూడగలిగినట్లుగా, డేటా రకం పరంగా, క్రొత్త డేటా రకం బూల్ ఉంది, ఇది C99 కు జోడించబడింది.
21. C89 లో, మీరు ఇప్పటికీ బూలియన్ విలువలను కలిగి ఉండవచ్చు, ఇది పూర్ణాంక విలువను బట్టి నిజం (నిజం) లేదా తప్పుడు (తప్పుడు) కావచ్చు.
22. అది 0 అయితే అది అబద్ధం (తప్పుడు); లేకపోతే అది నిజం.
23. కానీ C99 లో, వేరే రకం బూల్ ఉంది.
24. మీకు తెలిసిన ప్రతి డేటా రకం (డేటాటైప్), ఈ అంతర్నిర్మిత డేటా రకాల పరిమాణం (పరిమాణం) బైట్‌లలో ఇవ్వబడుతుంది మరియు దాన్ని పొందడానికి మీరు `సైజ్‌ఆఫ్ 'ఆపరేటర్‌ను ఉపయోగిస్తారు. చేయవచ్చు.
25. మీరు కొన్ని సింబాలిక్ పేర్లు ఇవ్వబడిన పూర్ణాంక విలువలు అయిన గణన రకాలను నిర్వచించవచ్చు.
26. సి లోని ఇతర డేటా రకాలు శూన్యాలు.
27. శూన్యమైన (శూన్యమైన డేటాటైప్) ఉపయోగం చాలా ఆసక్తికరంగా ఉంటుంది మరియు మేము C ++ కి వెళ్ళినప్పుడు, శూన్యత (శూన్యత) యొక్క వివిధ ఉపయోగాలను చూస్తాము.
28. మీరు డేటాటైప్ ఉపయోగించాల్సిన అవసరం వచ్చినప్పుడు, మీరు శూన్యతను ఉపయోగించవచ్చు, కానీ ఇది నిజంగా డేటాటైప్ కాదు.
29. ఇది ఇలా ఉంటుంది, మనం అంకగణితం చేసినప్పుడు మనకు 0 ఉంటుంది. నేను x కి 0 ని జోడించగలను మరియు అది x ని మార్చదు.
30. అందువల్ల, ప్రతి వ్యవస్థకు 0 అవసరమని మేము చెప్పినట్లు. కాబట్టి, శూన్యత అనేది ఒక రకమైన వ్యవస్థ, ఎందుకంటే మనం C ++ లో ఎక్కువగా చూస్తాము.
31. ఈ అంతర్నిర్మిత రకం ఆధారంగా, శ్రేణి, నిర్మాణం, యూనియన్ మరియు పాయింటర్‌కు మద్దతు ఇచ్చే వివిధ ఉత్పన్న రకాలు ఉన్నాయి. మేము సాధారణంగా పిలువబడే ఫంక్షన్లను కలిగి ఉండవచ్చు. సి లో స్ట్రింగ్ ఈ రోజుల్లో సి స్ట్రింగ్ అని పిలుస్తారు.
32. నిజం స్ట్రింగ్ C లో డేటాటైప్ కాకపోతే, మీరు C ++ కి వెళ్ళినప్పుడు మీకు బాగా అర్థం అవుతుంది.
33. సి స్ట్రింగ్ వాస్తవానికి ఫంక్షన్ యొక్క హెడర్ సేకరణ, ఇది సి లో తీగలను మార్చటానికి అనుమతిస్తుంది.
34. చివరగా, డేటాటైప్‌లను వాటి పరిమాణం కోసం సవరించవచ్చు, అవి సంతకం చేయబడతాయి లేదా సంతకం చేయబడవు మరియు ఈ 4 రకాల మాడిఫైయర్‌లను సి లో ఉపయోగిస్తారు. ఇప్పుడు మనం సి వేరియబుల్‌కి వెళ్తాము, వాటి పేర్లు ఆల్ఫా (ఆల్ఫాబేట్స్) తో ప్రారంభమయ్యే కొన్ని మార్గాల్లో నిర్వచించబడతాయి లేదా అండర్ స్కోర్: '_') ఆపై ఆల్ఫా-న్యూమరిక్ విస్తరించబడతాయి.
35. వేర్వేరు వేరియబుల్ పేర్లకు ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి, ఒకే అక్షరాలతో లేదా 1-2 అక్షరాలతో వేరియబుల్ పేరు పెట్టడం చాలా సౌకర్యంగా ఉన్నప్పుడు, కొంత అర్ధం ఉన్న వేరియబుల్ పేర్లను ఉపయోగించడం ఇంకా మంచిది. హుహ్.
36. అందువల్ల, మేము పాత్రను 'ఎండ్ఆఫ్ సెషన్' అని పిలుస్తున్నాము, మీరు దానిని 'సి', లేదా 'డి' లేదా 'ఎ' అని పిలవవచ్చు, కాని వేరియబుల్ అంటే ఏమిటో అర్థం చేసుకోవడానికి దీనికి పేరు పెట్టడం మంచిది.
37. ఇక్కడ ప్రకటించినట్లుగా, ధృవీకరించదగిన డిక్లరేషన్లు ప్రకటించినప్పుడు, వేరియబుల్ కూడా ప్రారంభించబడుతుంది.
38. ఆ ప్రారంభ ఐచ్ఛికం.
39. కాబట్టి, int i 10 తో ప్రారంభించబడిందని మేము చెప్పినప్పుడు ..
40. దీని అర్థం `i 'అనేది పూర్ణాంక రకం వేరియబుల్, ఇది క్షీణతతో 10 ప్రారంభ విలువలను కలిగి ఉంటుంది.
41. అందువల్ల, మీరు ప్రారంభించకపోతే, ఇది ప్రారంభించని వేరియబుల్, దీని ప్రారంభ విలువ తెలియదు.
42. వాస్తవానికి, మేము ప్రకటించే మరియు నిర్వచించే అన్ని వేరియబుల్స్ను ప్రారంభించడం చాలా మంచిది.
43. సి అనేక అక్షరాస్యతలను కలిగి ఉంది, ఇవి అంతర్నిర్మిత రకం యొక్క స్థిర విలువలు, మీరు ఒక నిర్దిష్ట లిట్రల్‌ను ఎలా వ్రాస్తారనే దానిపై ఆధారపడి, ఆ లిట్రల్ రకం పరిష్కరించబడుతుంది.
44. ఉదాహరణకు, మీరు అంకెల శ్రేణిని మాత్రమే కలిగి ఉంటే అది దశాంశ రకం పూర్ణాంకం అవుతుంది, కానీ మీరు 0 తో ఉపసర్గ చేస్తే, అది అష్ట రకానికి చెందినదని భావించబడుతుంది, దీని ఆధారం 8.
45. మీరు దీన్ని 0x తో ఉపసర్గ చేస్తే, అది హెక్సాడెసిమల్ లిట్రల్‌గా పరిగణించబడుతుంది.
46. చార్ రకం లిట్రల్ "లోపల వ్రాయబడింది, స్ట్రింగ్ రకం లిట్రల్" "లోపల వ్రాయబడింది. C99 తో, const రకానికి ఒక పరిచయం ఉంది, అవి ఖరీదైనవి మరియు మేము C ++ చేసేటప్పుడు మరింత లోతుగా చర్చిస్తాము.
47. అందువల్ల, C89 లో లిట్రల్ ఫిక్స్‌డ్ విలువలు ఉన్నాయి, కానీ C99 లో, అవి కాంటెంట్ టైప్ డేటాగా పరిగణించబడతాయి.
48. కాబట్టి, C99 లోని '212' ను తారాగణం వలె పరిగణిస్తారు.
49. సి లో చాలా మంది ఆపరేటర్లు ఉన్నారు, వారిలో చాలా మందికి మీకు పరిచయం ఉంటుంది.
50. బైనరీ ఆపరేటర్ వంటివి; సంకలనం (+), వ్యవకలనం (-), గుణకారం (*).
51. నిరాకరణ వలె, అనామక ఆప్టర్లు ఉన్నారు.
52. ?:. వంటి టెర్నరీ ఆపరేషన్లు కూడా ఉన్నాయి.
53. ప్రతి ఆపరేటర్‌కు 1, 2 లేదా 3 కావచ్చు ఓప్రాండ్‌పై ఆధారపడి ఉండే ఒక నిర్దిష్ట ధర్మం ఉంది. ఒక వ్యక్తీకరణలో, ఆపరేటర్లు వారి ప్రాధాన్యత క్రమం ప్రకారం మదింపు చేయబడతారు.
54. కొంతమంది ఆపరేటర్లకు అధిక ప్రాధాన్యత ఉంది, కొన్ని తక్కువ ప్రాధాన్యత కలిగి ఉంటాయి.
55. కాబట్టి, అదే వ్యక్తీకరణకు గుణకారం (*) అలాగే అదనంగా (+) ఉంటే గుణకారం (*) మొదట చేయవలసి ఉంటుందని మనకు తెలుసు.
56. అదేవిధంగా, ఒక వ్యక్తీకరణకు ఒకటి కంటే ఎక్కువ ఆపరేటర్లు ఉంటే, వారి మూల్యాంకనం యొక్క క్రమం అసోసియేటివిటీపై ఆధారపడి ఉంటుంది మరియు కొన్ని ఆపరేటర్‌కు కుడి నుండి ఎడమకు, కొన్ని ఆపరేటర్‌కు ఎడమ నుండి కుడికి ఉంటాయి.
57. అందువల్ల, ఇక్కడ నేను భిన్నమైన ఉదాహరణలు చూపించాను.
58. ఇది మీ సూచన కోసం మాత్రమే, మీకు ఇది ఖచ్చితంగా తెలుసు.
59. మీరు దీన్ని చేయకపోతే, దయచేసి దాన్ని బాగా అర్థం చేసుకోవడానికి వచనాన్ని చూడండి.
60. ఇప్పుడు, సి లోని తదుపరి భావన వ్యక్తీకరణ.
61. నాకు వేరియబుల్స్ ఉన్నాయి మరియు నాకు ఆపరేటర్ ఉంది.
62. నేను అక్షరాలను కలిగి ఉన్నాను, దానితో నేను వ్యక్తీకరణలను సృష్టించగలను.
63. కాబట్టి, వ్యక్తీకరణ ప్రతి లిట్రల్ ఒక వ్యక్తీకరణ అని పునరావృత రూపం చెప్పే విధంగా నిర్వచించబడింది.
64. నేను 5 సంఖ్యను చెబితే, అది ఒక వ్యక్తీకరణ.
65. ప్రతి వేరియబుల్ ఒక వ్యక్తీకరణ మరియు నాకు రెండు వ్యక్తీకరణలు ఉంటే మరియు వాటిని బైనరీ ఆపరేటర్‌కు కనెక్ట్ చేస్తే అది కొత్త వ్యక్తీకరణ అవుతుంది.
66. అదేవిధంగా, నేను యూనిరీ ఆపరేటర్, టెర్నరీ ఆపరేటర్ మొదలైనవాటిని కలిగి ఉంటాను.
67. ఏదైనా ఫంక్షన్ అని పిలువబడినప్పుడు అది ఒక వ్యక్తీకరణ.
68. కాబట్టి, ప్రాథమిక విషయం ఏమిటంటే వ్యక్తీకరణకు విలువ ఉండాలి; సికి వ్యక్తీకరణ అని పిలువబడే దేనికైనా విలువ ఉంటుంది.అందువల్ల, ఇక్కడ ఇవ్వబడిన వేరియబుల్స్ కోసం వేర్వేరు ఉదాహరణలు ఇవ్వవచ్చు మరియు విభిన్న వ్యక్తీకరణలు క్రింద ఇవ్వబడ్డాయి.
69. ఇప్పుడు, సి వ్యక్తీకరణను కలిగి ఉండకూడదు.
70. కాబట్టి, వ్యక్తీకరణ ఒక ప్రకటనగా ఉండాలి.
71. కాబట్టి, మీరు కలిగి ఉన్న సరళమైన లేదా చిన్న ప్రకటనను శూన్య ప్రకటన అని పిలుస్తారు, ఇది సెమికోలన్ ';'
72. లేకపోతే, మీకు వ్యక్తీకరణ ఉంటే, మీరు దానిని సెమికోలన్‌తో ముగించవచ్చు మరియు మీరు దానిని సెమికోలన్‌తో ముగించిన తర్వాత అది ఒక స్టేట్‌మెంట్ అవుతుంది.
73. కాబట్టి, మీరు ఈ క్రింది ఉదాహరణను పరిశీలిస్తే, 'i + j' వ్యక్తీకరణ ప్రకటనకు వ్యక్తీకరణ ఉంది, ఎందుకంటే 'i' మరియు 'j' వేరియబుల్ మరియు + ఒక ఆపరేటర్ వారితో చేరడం. అంటే, మీరు `i + j; ఇది ఒక ప్రకటన అవుతుంది.
74. ఇది స్వతంత్రంగా ఎక్కడైనా జరగవచ్చు, ఫంక్షన్ కాల్స్ మరియు అసైన్‌మెంట్‌ల కోసం ఇలాంటి ఉదాహరణలు చూపించబడ్డాయి.
75. వ్యక్తీకరణ ప్రకటనతో పాటు, సికి అనేక నియంత్రణ ప్రకటనలు లేదా నియంత్రణ నిర్మాణాలు ఉన్నాయి, ఇవి ప్రాథమికంగా ప్రోగ్రామ్‌లో నియంత్రణ ప్రవాహాన్ని నిర్వహించడానికి అనుమతిస్తాయి.
76. దీని కోసం, సెలక్షన్ స్టేట్మెంట్ మరియు లూప్ స్టేట్మెంట్ మొదలైనవి ఉన్నాయి.
77. మేము తరువాతి స్లైడ్‌లో వాటి గురించి కొంచెం ఎక్కువ చూస్తాము మరియు ఒకదాని తరువాత ఒకటిగా సమూహపరచవలసిన అనేక స్టేట్‌మెంట్‌లు ఉంటే, ఆపై మేము వంకర కలుపులను '{}' ఉపయోగిస్తాము).
78. ఇది ఒక బ్లాక్‌గా మారిందని, అలాంటి స్టేట్‌మెంట్‌ను కాంపౌండ్ స్టేట్‌మెంట్ అంటారు.
79. అందువల్ల, స్టేట్మెంట్ యొక్క మొత్తం విభాగం ఒక సంకలనం, ఇది మీరు క్రింద ఒక ఉదాహరణను చూడవచ్చు.
80. ఇప్పుడు, సి ప్రోగ్రామ్ యొక్క ప్రధాన ప్రాంతం అయిన నియంత్రణ నిర్మాణాల గురించి మాట్లాడుదాం, ఇది ప్రోగ్రామ్ యొక్క అమలు ఎలా జరుగుతుందో ప్రాథమికంగా మీకు తెలియజేస్తుంది.
81. ఒక స్టేట్మెంట్ ఎగ్జిక్యూట్ చేసిన తరువాత, ఏ ఇతర స్టేట్మెంట్ ఎగ్జిక్యూట్ అవుతుంది, దీన్ని నియంత్రించడానికి మాకు వేర్వేరు పద్ధతులు ఉన్నాయి.
82. అప్రమేయంగా సి ప్రోగ్రామ్‌లోని నియంత్రణ పతనం ద్వారా వస్తుంది, అంటే ఒక స్టేట్‌మెంట్ ఎగ్జిక్యూట్ అయిన తర్వాత, తదుపరి స్టేట్‌మెంట్ వెంటనే అమలు అవుతుంది, కాని నియంత్రణ ప్రవాహం ద్వారా దాన్ని మార్చవచ్చు.
83. కాబట్టి, మొదటి రకం నియంత్రణ ప్రవాహం 'if' లేదా 'if-else' అనే ఎంపిక ప్రకటన. ఉదాహరణలో, (a <b) నిజమైతే, మీరు ఆ సమ్మేళనం ప్రకటనను అనుసరిస్తున్నారు.
84. సమ్మేళనం స్టేట్మెంట్ ఏమి చెబుతుందో మీరు సులభంగా అర్థం చేసుకోవచ్చు, దీనిలో మీరు మూడవ వేరియబుల్ ఉపయోగించి 'a' మరియు 'b' విలువను మార్చుకుంటారు.
85. మీరు తరువాతి ఉదాహరణను పరిశీలిస్తే, అది 'if-else' రకం స్టేట్మెంట్ చూపిస్తుంది, ఇక్కడ 'if (x <5)' యొక్క షరతు నిజమైతే అది ఒక స్టేట్మెంట్, లేకపోతే షరతు ఉంటే తప్పు ఒకటి ఉంటే మరింత ప్రకటన.
86. తప్పుడు భాగానికి సమ్మేళనం స్టేట్మెంట్ ఉందని మీరు చూడవచ్చు, అయితే ఇది నిజం, ఇది ఒకే ప్రకటన, ఇది అనేక విధాలుగా చేయవచ్చు.
87. మీరు వేరియబుల్ యొక్క విలువను వివిధ మార్గాల్లో ఉపయోగించవచ్చు.
88. స్విచ్-కేసులో మీరు జాబితా చేయబడిన కేసులో దేనినైనా తీసుకుంటే, మేము వేరియబుల్ 'i' ను ఉపయోగించాము మరియు మీరు మారేది వేరియబుల్ విలువపై ఆధారపడి ఉంటుంది. కాబట్టి, i యొక్క విలువ 1 అయితే, కేసు 1 ఎంచుకోబడుతుంది, దీని ద్వారా 'x' 6 అవుతుంది. మొత్తం సందర్భంలో i యొక్క విలువ లేకపోతే, మనకు డిఫాల్ట్ కేసు ఉంది, అది అమలు అవుతుంది.
89. స్విచ్‌లో మేము చూపించిన 'కేసు' వంటి స్టేట్‌మెంట్‌లను లేబుల్ స్టేట్‌మెంట్‌లు అని కూడా పిలుస్తారు ఎందుకంటే వాటికి లేబుల్ ఉంది.
90. expression ఆదేశాలతో పాటుగా, C లో అనేక  నియంత్రణ ఆదేశాలు (Control Statements) లేదా నియంత్రణ నిర్మాణాలు ఉన్నాయి, ఇవి ప్రాధమికంగా  ప్రోగ్రామ్లో నియంత్రణ ప్రవాహాన్ని నియంత్రిస్తాయి.
91. అప్పుడు మనకు పునరావృత ప్రకటనలు ఉన్నాయి, ఇక్కడ మీరు వీటిని సాధారణంగా లూప్ స్టేట్మెంట్స్ అని పిలుస్తారు, ఇక్కడ మీరు మూడు భాగాలను కలిగి ఉన్న 'ఫర్' లూప్ కలిగి ఉండవచ్చు.
92. ప్రారంభ భాగం 'i' 0 కి కేటాయించబడుతుంది, ఇది ప్రారంభంలో జరుగుతుంది.
93. ప్రతిసారి లూప్ నియంత్రించబడే రెండవ కండిషన్ భాగం మరియు మీరు లూప్‌లో కొనసాగితే పరిస్థితి నిజం. మరియు ప్రాథమికంగా 'ఫర్' స్టేట్‌మెంట్‌ను అనుసరించే ఒక శరీరం, ఇది లూప్‌లో భాగంగా అమలు చేయబడిన సూచనలు లేదా స్టేట్‌మెంట్‌ల క్రమం మరియు లూప్ స్టేట్‌మెంట్ ముగింపుకు దారితీసే '++ i'.
94. అదేవిధంగా, మనకు 'while' లూప్ మరియు 'do-while' లూప్ ఉన్నాయి. చివరి రకం నియంత్రణ ప్రకటన కోసం 'వెళ్ళు', 'కొనసాగించు', 'విచ్ఛిన్నం' మరియు 'తిరిగి'.
95. మీకు తెలిసినట్లుగా, మీరు 'వెళ్ళండి' ఉపయోగించవద్దని సి సూచిస్తుంది, కాబట్టి, మేము 'వెళ్ళు' యొక్క ఉదాహరణను చూపించడం లేదు.+
96. మీరు సి ప్రోగ్రామ్‌ను చక్కగా డిజైన్ చేస్తే మీకు 'వెళ్ళండి' ఉపయోగించడానికి ఎటువంటి కారణం ఉండదు.
97. అందువల్ల, మీ నియంత్రణ ప్రవాహాన్ని సాధించడానికి వేర్వేరు లూప్ లేదా స్విచ్ స్టేట్‌మెంట్‌లతో 'కొనసాగించు' మరియు 'విచ్ఛిన్నం' మాత్రమే ఉపయోగించడానికి ప్రయత్నించండి, కానీ ఫంక్షన్ నుండి తిరిగి రావడానికి మీకు 'తిరిగి' అవసరం.
98. కాబట్టి, నాలుగు రకాల నియంత్రణ నిర్మాణాలు ఉన్నాయి.
99. ఈ మాడ్యూల్‌లో మేము ఇప్పటివరకు చూశాము, సి ప్రోగ్రామ్ యొక్క ప్రాథమిక భాగాలు ఏమిటి, మీరు IO ఎలా చేస్తారు, డేటా రకాన్ని ఉపయోగించి వేరియబుల్‌ను ఎలా నిర్వచించాలి? మీరు వాటిని ఎలా ప్రారంభించాలి? ఆపరేటర్లను ఉపయోగించి వాటిని వ్యక్తీకరణలుగా ఎలా చేయాలి? ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని నియంత్రించడానికి వ్యక్తీకరణను స్టేట్‌మెంట్ మరియు విభిన్న కంట్రోల్ ఫ్లో స్టేట్‌మెంట్‌గా ఎలా మార్చాలి? కాబట్టి దీనితో, మేము ఈ భాగాన్ని ముగించాము మరియు ఆ తరువాత ఉత్పన్నమైన రకాలు మరియు సి లో వాటి ఉపయోగం గురించి మాట్లాడుతాము
100. .
 C ++ ప్రోగ్రామింగ్  కు స్వాగతం.
ఇది 20-గంటల కోర్సు అవుతుంది, ఇక్కడ మేము C ++ ప్రోగ్రామింగ్ భాష యొక్క వివిధ అంశాల గురించి మాట్లాడుతాము మరియు ఇది సహజంగా 40 గుణకాలుగా విభజించబడుతుంది, మీరు ఒకదాని తరువాత ఒకటి అధ్యయనం చేస్తారు.
సంక్లిష్ట సాఫ్ట్‌వేర్ వ్యవస్థల రూపకల్పన మరియు అమలులో C ++ ప్రోగ్రామింగ్ భాషను ఎలా ఉపయోగించాలో నేర్పడం ఈ కోర్సు యొక్క ప్రధాన ఒత్తిడి.
సి ++ ఒక ఆబ్జెక్ట్ ఓరియెంటెడ్ లేదా ఆబ్జెక్ట్ బేస్డ్ ప్రోగ్రామింగ్ లాంగ్వేజ్ అని మీ అందరికీ తెలుస్తుంది మరియు మీకు సి లాంగ్వేజ్ తెలుసని నేను అంగీకరిస్తున్నాను, మీకు చాలా లోతుగా తెలియకపోవచ్చు, కాని మీకు సి లాంగ్వేజ్ గురించి సాధారణ జ్ఞానం ఉంది కాబట్టి, మేము అక్కడ నుండి ప్రారంభిస్తాము, మాడ్యూల్ 1 లో, సి ప్రోగ్రామింగ్ యొక్క విభిన్న నిర్దిష్ట అంశాలను ఉపయోగించడం గురించి మనం మళ్ళీ మాట్లాడుతాము.
అవసరమైతే మీరు ఆ భావనలను పున it సమీక్షించగలరని మరియు మేము C ++ భాషలోకి లోతుగా వెళ్ళే ముందు, మీరు అన్ని C ప్రోగ్రామింగ్ అవసరాలను తెలుసుకోగలరని నిర్ధారించుకోవడానికి ఇది మాత్రమే. | ఎందుకంటే సి భాష సి ++ యొక్క స్థానిక భాష.
కాబట్టి, మేము మొదట సి భాష యొక్క పునరావృతంతో ప్రారంభిస్తాము. అందువల్ల, సి భాష మరియు ప్రోగ్రామింగ్ అంశాలకు అదనంగా సి స్టాండర్డ్ లైబ్రరీని పరిశీలిస్తాము, ప్రత్యేకించి వివిధ అంశాలను తిరిగి నేర్చుకోవడం కోసం.
సి ప్రోగ్రామ్ యొక్క నిర్మాణం, సి ప్రోగ్రామ్ను ఎలా సాధ్యం చేయాలో మేము క్లుప్తంగా చర్చిస్తాము.
ఇప్పటివరకు, మీరు 1 లేదా 2 ఫంక్షన్‌ను ఉపయోగించి ఒకే ఫైల్‌కు సూచనగా కోడ్‌ను వ్రాశారు.
వాటిలో ఒకటి ప్రధానంగా ఉండాలి (ఫంక్షన్). మీకు తెలిసినట్లుగా, ప్రోగ్రామ్‌లను ఎలా బాగా వ్రాయవచ్చో మేము చూస్తాము మరియు దీనితో మనకు C ++ ప్రోగ్రామింగ్ భాషకు పునాది ఉంటుంది.
మాడ్యూల్ డిజైన్ సందర్భంలో చేయవలసిన వివిధ అంశాలు ఇవి.
ప్రదర్శనగా, మేము మీ స్క్రీన్ యొక్క ఎడమ వైపుకు వెళ్తాము, మీరు ఈ రూపురేఖను చూస్తారు మరియు మేము ఏ ప్రత్యేక అంశం గురించి మాట్లాడుతున్నామో అది హైలైట్ అవుతుంది.
కాబట్టి, ఇది మొదటి కార్యక్రమం "హలో వరల్డ్", మీరందరూ అధ్యయనం చేశారని నేను ఖచ్చితంగా అనుకుంటున్నాను.
ఇది కెర్నింగ్ మరియు రిట్చీల ప్రసిద్ధ పుస్తకంలోని ప్రారంభ కార్యక్రమం.
టెర్మినల్‌లో "హలో వరల్డ్" ను ప్రింట్ చేయడానికి మేము <stdio> లైబ్రరీ నుండి 'printf' ను ఉపయోగిస్తాము, ఇది అధికారికంగా <stdio> అవుట్ ఫైల్.
ప్రధాన విధి ఏమిటంటే మీరు ఎక్కడ చూడగలరు, అక్కడ ఎక్సిక్యూషన్ మొదలవుతుంది. అప్పుడు మీరు ఈ స్ట్రింగ్‌ను ప్రింట్ చేసి '\ n' ను ప్రింట్ చేయండి, అంటే మీరు ప్రాథమికంగా, మేము తదుపరి పంక్తికి వెళ్తాము, అంటే కొత్త పంక్తి.
సి లో అనేక రకాల డేటా రకాలు ఉన్నాయి; కెర్ (చార్), క్యారెక్టర్ అని పిలుస్తారు, మొత్తం సంఖ్యలకు పూర్ణాంకం (పూర్ణాంకానికి), ఫ్లోట్ మరియు డబుల్; ఫ్లోటింగ్ పాయింట్లు సంఖ్యల కోసం.
ఇప్పుడు, ఇక్కడ మీరు సాధారణంగా ఉపయోగించే C ను C89 అని పిలుస్తారు, C89 C యొక్క మొదటి ప్రమాణం (స్టాండర్డ్) ANSI చే సృష్టించబడింది, ప్రామాణీకరణ సంస్థ మరియు తరువాత 99 లో, మరొక ప్రమాణం విడుదల చేయబడింది, దీనిని C99 అని పిలుస్తారు, కాబట్టి నేడు చాలా కంపైలర్లు C99 ప్రమాణాన్ని అనుసరిస్తున్నారు.
C99 కూడా అనుసరిస్తుందని మేము ఆశిస్తున్నాము.
కాబట్టి, మేము C గురించి మాట్లాడేటప్పుడు, C99 లో కొన్ని విషయాలు భిన్నంగా ఉంటే హైలైట్ చేయడానికి ప్రయత్నిస్తాము.
కాబట్టి, మీరు చూడగలిగినట్లుగా, డేటా రకం పరంగా, క్రొత్త డేటా రకం బూల్ ఉంది, ఇది C99 కు జోడించబడింది.
C89 లో, మీరు ఇప్పటికీ బూలియన్ విలువలను కలిగి ఉండవచ్చు, ఇది పూర్ణాంక విలువను బట్టి నిజం (నిజం) లేదా తప్పుడు (తప్పుడు) కావచ్చు.
అది 0 అయితే అది అబద్ధం (తప్పుడు); లేకపోతే అది నిజం.
కానీ C99 లో, వేరే రకం బూల్ ఉంది.
మీకు తెలిసిన ప్రతి డేటా రకం (డేటాటైప్), ఈ అంతర్నిర్మిత డేటా రకాల పరిమాణం (పరిమాణం) బైట్‌లలో ఇవ్వబడుతుంది మరియు దాన్ని పొందడానికి మీరు `సైజ్‌ఆఫ్ 'ఆపరేటర్‌ను ఉపయోగిస్తారు. చేయవచ్చు.
మీరు కొన్ని సింబాలిక్ పేర్లు ఇవ్వబడిన పూర్ణాంక విలువలు అయిన గణన రకాలను నిర్వచించవచ్చు.
సి లోని ఇతర డేటా రకాలు శూన్యాలు.
శూన్యమైన (శూన్యమైన డేటాటైప్) ఉపయోగం చాలా ఆసక్తికరంగా ఉంటుంది మరియు మేము C ++ కి వెళ్ళినప్పుడు, శూన్యత (శూన్యత) యొక్క వివిధ ఉపయోగాలను చూస్తాము.
మీరు డేటాటైప్ ఉపయోగించాల్సిన అవసరం వచ్చినప్పుడు, మీరు శూన్యతను ఉపయోగించవచ్చు, కానీ ఇది నిజంగా డేటాటైప్ కాదు.
ఇది ఇలా ఉంటుంది, మనం అంకగణితం చేసినప్పుడు మనకు 0 ఉంటుంది. నేను x కి 0 ని జోడించగలను మరియు అది x ని మార్చదు.
అందువల్ల, ప్రతి వ్యవస్థకు 0 అవసరమని మేము చెప్పినట్లు. కాబట్టి, శూన్యత అనేది ఒక రకమైన వ్యవస్థ, ఎందుకంటే మనం C ++ లో ఎక్కువగా చూస్తాము.
ఈ అంతర్నిర్మిత రకం ఆధారంగా, శ్రేణి, నిర్మాణం, యూనియన్ మరియు పాయింటర్‌కు మద్దతు ఇచ్చే వివిధ ఉత్పన్న రకాలు ఉన్నాయి. మేము సాధారణంగా పిలువబడే ఫంక్షన్లను కలిగి ఉండవచ్చు. సి లో స్ట్రింగ్ ఈ రోజుల్లో సి స్ట్రింగ్ అని పిలుస్తారు.
నిజం స్ట్రింగ్ C లో డేటాటైప్ కాకపోతే, మీరు C ++ కి వెళ్ళినప్పుడు మీకు బాగా అర్థం అవుతుంది.
సి స్ట్రింగ్ వాస్తవానికి ఫంక్షన్ యొక్క హెడర్ సేకరణ, ఇది సి లో తీగలను మార్చటానికి అనుమతిస్తుంది.
చివరగా, డేటాటైప్‌లను వాటి పరిమాణం కోసం సవరించవచ్చు, అవి సంతకం చేయబడతాయి లేదా సంతకం చేయబడవు మరియు ఈ 4 రకాల మాడిఫైయర్‌లను సి లో ఉపయోగిస్తారు. ఇప్పుడు మనం సి వేరియబుల్‌కి వెళ్తాము, వాటి పేర్లు ఆల్ఫా (ఆల్ఫాబేట్స్) తో ప్రారంభమయ్యే కొన్ని మార్గాల్లో నిర్వచించబడతాయి లేదా అండర్ స్కోర్: '_') ఆపై ఆల్ఫా-న్యూమరిక్ విస్తరించబడతాయి.
వేర్వేరు వేరియబుల్ పేర్లకు ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి, ఒకే అక్షరాలతో లేదా 1-2 అక్షరాలతో వేరియబుల్ పేరు పెట్టడం చాలా సౌకర్యంగా ఉన్నప్పుడు, కొంత అర్ధం ఉన్న వేరియబుల్ పేర్లను ఉపయోగించడం ఇంకా మంచిది. హుహ్.
అందువల్ల, మేము పాత్రను 'ఎండ్ఆఫ్ సెషన్' అని పిలుస్తున్నాము, మీరు దానిని 'సి', లేదా 'డి' లేదా 'ఎ' అని పిలవవచ్చు, కాని వేరియబుల్ అంటే ఏమిటో అర్థం చేసుకోవడానికి దీనికి పేరు పెట్టడం మంచిది.
ఇక్కడ ప్రకటించినట్లుగా, ధృవీకరించదగిన డిక్లరేషన్లు ప్రకటించినప్పుడు, వేరియబుల్ కూడా ప్రారంభించబడుతుంది.
ఆ ప్రారంభ ఐచ్ఛికం.
కాబట్టి, int i 10 తో ప్రారంభించబడిందని మేము చెప్పినప్పుడు ..
దీని అర్థం `i 'అనేది పూర్ణాంక రకం వేరియబుల్, ఇది క్షీణతతో 10 ప్రారంభ విలువలను కలిగి ఉంటుంది.
అందువల్ల, మీరు ప్రారంభించకపోతే, ఇది ప్రారంభించని వేరియబుల్, దీని ప్రారంభ విలువ తెలియదు.
వాస్తవానికి, మేము ప్రకటించే మరియు నిర్వచించే అన్ని వేరియబుల్స్ను ప్రారంభించడం చాలా మంచిది.
సి అనేక అక్షరాస్యతలను కలిగి ఉంది, ఇవి అంతర్నిర్మిత రకం యొక్క స్థిర విలువలు, మీరు ఒక నిర్దిష్ట లిట్రల్‌ను ఎలా వ్రాస్తారనే దానిపై ఆధారపడి, ఆ లిట్రల్ రకం పరిష్కరించబడుతుంది.
ఉదాహరణకు, మీరు అంకెల శ్రేణిని మాత్రమే కలిగి ఉంటే అది దశాంశ రకం పూర్ణాంకం అవుతుంది, కానీ మీరు 0 తో ఉపసర్గ చేస్తే, అది అష్ట రకానికి చెందినదని భావించబడుతుంది, దీని ఆధారం 8.
మీరు దీన్ని 0x తో ఉపసర్గ చేస్తే, అది హెక్సాడెసిమల్ లిట్రల్‌గా పరిగణించబడుతుంది.
చార్ రకం లిట్రల్ "లోపల వ్రాయబడింది, స్ట్రింగ్ రకం లిట్రల్" "లోపల వ్రాయబడింది. C99 తో, const రకానికి ఒక పరిచయం ఉంది, అవి ఖరీదైనవి మరియు మేము C ++ చేసేటప్పుడు మరింత లోతుగా చర్చిస్తాము.
అందువల్ల, C89 లో లిట్రల్ ఫిక్స్‌డ్ విలువలు ఉన్నాయి, కానీ C99 లో, అవి కాంటెంట్ టైప్ డేటాగా పరిగణించబడతాయి.
కాబట్టి, C99 లోని '212' ను తారాగణం వలె పరిగణిస్తారు.
సి లో చాలా మంది ఆపరేటర్లు ఉన్నారు, వారిలో చాలా మందికి మీకు పరిచయం ఉంటుంది.
బైనరీ ఆపరేటర్ వంటివి; సంకలనం (+), వ్యవకలనం (-), గుణకారం (*).
నిరాకరణ వలె, అనామక ఆప్టర్లు ఉన్నారు.
?:. వంటి టెర్నరీ ఆపరేషన్లు కూడా ఉన్నాయి.
ప్రతి ఆపరేటర్‌కు 1, 2 లేదా 3 కావచ్చు ఓప్రాండ్‌పై ఆధారపడి ఉండే ఒక నిర్దిష్ట ధర్మం ఉంది. ఒక వ్యక్తీకరణలో, ఆపరేటర్లు వారి ప్రాధాన్యత క్రమం ప్రకారం మదింపు చేయబడతారు.
కొంతమంది ఆపరేటర్లకు అధిక ప్రాధాన్యత ఉంది, కొన్ని తక్కువ ప్రాధాన్యత కలిగి ఉంటాయి.
కాబట్టి, అదే వ్యక్తీకరణకు గుణకారం (*) అలాగే అదనంగా (+) ఉంటే గుణకారం (*) మొదట చేయవలసి ఉంటుందని మనకు తెలుసు.
అదేవిధంగా, ఒక వ్యక్తీకరణకు ఒకటి కంటే ఎక్కువ ఆపరేటర్లు ఉంటే, వారి మూల్యాంకనం యొక్క క్రమం అసోసియేటివిటీపై ఆధారపడి ఉంటుంది మరియు కొన్ని ఆపరేటర్‌కు కుడి నుండి ఎడమకు, కొన్ని ఆపరేటర్‌కు ఎడమ నుండి కుడికి ఉంటాయి.
అందువల్ల, ఇక్కడ నేను భిన్నమైన ఉదాహరణలు చూపించాను.
ఇది మీ సూచన కోసం మాత్రమే, మీకు ఇది ఖచ్చితంగా తెలుసు.
మీరు దీన్ని చేయకపోతే, దయచేసి దాన్ని బాగా అర్థం చేసుకోవడానికి వచనాన్ని చూడండి.
ఇప్పుడు, సి లోని తదుపరి భావన వ్యక్తీకరణ.
నాకు వేరియబుల్స్ ఉన్నాయి మరియు నాకు ఆపరేటర్ ఉంది.
నేను అక్షరాలను కలిగి ఉన్నాను, దానితో నేను వ్యక్తీకరణలను సృష్టించగలను.
కాబట్టి, వ్యక్తీకరణ ప్రతి లిట్రల్ ఒక వ్యక్తీకరణ అని పునరావృత రూపం చెప్పే విధంగా నిర్వచించబడింది.
నేను 5 సంఖ్యను చెబితే, అది ఒక వ్యక్తీకరణ.
ప్రతి వేరియబుల్ ఒక వ్యక్తీకరణ మరియు నాకు రెండు వ్యక్తీకరణలు ఉంటే మరియు వాటిని బైనరీ ఆపరేటర్‌కు కనెక్ట్ చేస్తే అది కొత్త వ్యక్తీకరణ అవుతుంది.
అదేవిధంగా, నేను యూనిరీ ఆపరేటర్, టెర్నరీ ఆపరేటర్ మొదలైనవాటిని కలిగి ఉంటాను.
ఏదైనా ఫంక్షన్ అని పిలువబడినప్పుడు అది ఒక వ్యక్తీకరణ.
కాబట్టి, ప్రాథమిక విషయం ఏమిటంటే వ్యక్తీకరణకు విలువ ఉండాలి; సికి వ్యక్తీకరణ అని పిలువబడే దేనికైనా విలువ ఉంటుంది.అందువల్ల, ఇక్కడ ఇవ్వబడిన వేరియబుల్స్ కోసం వేర్వేరు ఉదాహరణలు ఇవ్వవచ్చు మరియు విభిన్న వ్యక్తీకరణలు క్రింద ఇవ్వబడ్డాయి.
ఇప్పుడు, సి వ్యక్తీకరణను కలిగి ఉండకూడదు.
కాబట్టి, వ్యక్తీకరణ ఒక ప్రకటనగా ఉండాలి.
కాబట్టి, మీరు కలిగి ఉన్న సరళమైన లేదా చిన్న ప్రకటనను శూన్య ప్రకటన అని పిలుస్తారు, ఇది సెమికోలన్ ';'
లేకపోతే, మీకు వ్యక్తీకరణ ఉంటే, మీరు దానిని సెమికోలన్‌తో ముగించవచ్చు మరియు మీరు దానిని సెమికోలన్‌తో ముగించిన తర్వాత అది ఒక స్టేట్‌మెంట్ అవుతుంది.
కాబట్టి, మీరు ఈ క్రింది ఉదాహరణను పరిశీలిస్తే, 'i + j' వ్యక్తీకరణ ప్రకటనకు వ్యక్తీకరణ ఉంది, ఎందుకంటే 'i' మరియు 'j' వేరియబుల్ మరియు + ఒక ఆపరేటర్ వారితో చేరడం. అంటే, మీరు `i + j; ఇది ఒక ప్రకటన అవుతుంది.
ఇది స్వతంత్రంగా ఎక్కడైనా జరగవచ్చు, ఫంక్షన్ కాల్స్ మరియు అసైన్‌మెంట్‌ల కోసం ఇలాంటి ఉదాహరణలు చూపించబడ్డాయి.
వ్యక్తీకరణ ప్రకటనతో పాటు, సికి అనేక నియంత్రణ ప్రకటనలు లేదా నియంత్రణ నిర్మాణాలు ఉన్నాయి, ఇవి ప్రాథమికంగా ప్రోగ్రామ్‌లో నియంత్రణ ప్రవాహాన్ని నిర్వహించడానికి అనుమతిస్తాయి.
దీని కోసం, సెలక్షన్ స్టేట్మెంట్ మరియు లూప్ స్టేట్మెంట్ మొదలైనవి ఉన్నాయి.
మేము తరువాతి స్లైడ్‌లో వాటి గురించి కొంచెం ఎక్కువ చూస్తాము మరియు ఒకదాని తరువాత ఒకటిగా సమూహపరచవలసిన అనేక స్టేట్‌మెంట్‌లు ఉంటే, ఆపై మేము వంకర కలుపులను '{}' ఉపయోగిస్తాము).
ఇది ఒక బ్లాక్‌గా మారిందని, అలాంటి స్టేట్‌మెంట్‌ను కాంపౌండ్ స్టేట్‌మెంట్ అంటారు.
అందువల్ల, స్టేట్మెంట్ యొక్క మొత్తం విభాగం ఒక సంకలనం, ఇది మీరు క్రింద ఒక ఉదాహరణను చూడవచ్చు.
ఇప్పుడు, సి ప్రోగ్రామ్ యొక్క ప్రధాన ప్రాంతం అయిన నియంత్రణ నిర్మాణాల గురించి మాట్లాడుదాం, ఇది ప్రోగ్రామ్ యొక్క అమలు ఎలా జరుగుతుందో ప్రాథమికంగా మీకు తెలియజేస్తుంది.
ఒక స్టేట్మెంట్ ఎగ్జిక్యూట్ చేసిన తరువాత, ఏ ఇతర స్టేట్మెంట్ ఎగ్జిక్యూట్ అవుతుంది, దీన్ని నియంత్రించడానికి మాకు వేర్వేరు పద్ధతులు ఉన్నాయి.
అప్రమేయంగా సి ప్రోగ్రామ్‌లోని నియంత్రణ పతనం ద్వారా వస్తుంది, అంటే ఒక స్టేట్‌మెంట్ ఎగ్జిక్యూట్ అయిన తర్వాత, తదుపరి స్టేట్‌మెంట్ వెంటనే అమలు అవుతుంది, కాని నియంత్రణ ప్రవాహం ద్వారా దాన్ని మార్చవచ్చు.
కాబట్టి, మొదటి రకం నియంత్రణ ప్రవాహం 'if' లేదా 'if-else' అనే ఎంపిక ప్రకటన. ఉదాహరణలో, (a <b) నిజమైతే, మీరు ఆ సమ్మేళనం ప్రకటనను అనుసరిస్తున్నారు.
సమ్మేళనం స్టేట్మెంట్ ఏమి చెబుతుందో మీరు సులభంగా అర్థం చేసుకోవచ్చు, దీనిలో మీరు మూడవ వేరియబుల్ ఉపయోగించి 'a' మరియు 'b' విలువను మార్చుకుంటారు.
మీరు తరువాతి ఉదాహరణను పరిశీలిస్తే, అది 'if-else' రకం స్టేట్మెంట్ చూపిస్తుంది, ఇక్కడ 'if (x <5)' యొక్క షరతు నిజమైతే అది ఒక స్టేట్మెంట్, లేకపోతే షరతు ఉంటే తప్పు ఒకటి ఉంటే మరింత ప్రకటన.
తప్పుడు భాగానికి సమ్మేళనం స్టేట్మెంట్ ఉందని మీరు చూడవచ్చు, అయితే ఇది నిజం, ఇది ఒకే ప్రకటన, ఇది అనేక విధాలుగా చేయవచ్చు.
మీరు వేరియబుల్ యొక్క విలువను వివిధ మార్గాల్లో ఉపయోగించవచ్చు.
స్విచ్-కేసులో మీరు జాబితా చేయబడిన కేసులో దేనినైనా తీసుకుంటే, మేము వేరియబుల్ 'i' ను ఉపయోగించాము మరియు మీరు మారేది వేరియబుల్ విలువపై ఆధారపడి ఉంటుంది. కాబట్టి, i యొక్క విలువ 1 అయితే, కేసు 1 ఎంచుకోబడుతుంది, దీని ద్వారా 'x' 6 అవుతుంది. మొత్తం సందర్భంలో i యొక్క విలువ లేకపోతే, మనకు డిఫాల్ట్ కేసు ఉంది, అది అమలు అవుతుంది.
స్విచ్‌లో మేము చూపించిన 'కేసు' వంటి స్టేట్‌మెంట్‌లను లేబుల్ స్టేట్‌మెంట్‌లు అని కూడా పిలుస్తారు ఎందుకంటే వాటికి లేబుల్ ఉంది.
expression ఆదేశాలతో పాటుగా, C లో అనేక  నియంత్రణ ఆదేశాలు (Control Statements) లేదా నియంత్రణ నిర్మాణాలు ఉన్నాయి, ఇవి ప్రాధమికంగా  ప్రోగ్రామ్లో నియంత్రణ ప్రవాహాన్ని నియంత్రిస్తాయి.
అప్పుడు మనకు పునరావృత ప్రకటనలు ఉన్నాయి, ఇక్కడ మీరు వీటిని సాధారణంగా లూప్ స్టేట్మెంట్స్ అని పిలుస్తారు, ఇక్కడ మీరు మూడు భాగాలను కలిగి ఉన్న 'ఫర్' లూప్ కలిగి ఉండవచ్చు.
ప్రారంభ భాగం 'i' 0 కి కేటాయించబడుతుంది, ఇది ప్రారంభంలో జరుగుతుంది.
ప్రతిసారి లూప్ నియంత్రించబడే రెండవ కండిషన్ భాగం మరియు మీరు లూప్‌లో కొనసాగితే పరిస్థితి నిజం. మరియు ప్రాథమికంగా 'ఫర్' స్టేట్‌మెంట్‌ను అనుసరించే ఒక శరీరం, ఇది లూప్‌లో భాగంగా అమలు చేయబడిన సూచనలు లేదా స్టేట్‌మెంట్‌ల క్రమం మరియు లూప్ స్టేట్‌మెంట్ ముగింపుకు దారితీసే '++ i'.
అదేవిధంగా, మనకు 'while' లూప్ మరియు 'do-while' లూప్ ఉన్నాయి. చివరి రకం నియంత్రణ ప్రకటన కోసం 'వెళ్ళు', 'కొనసాగించు', 'విచ్ఛిన్నం' మరియు 'తిరిగి'.
మీకు తెలిసినట్లుగా, మీరు 'వెళ్ళండి' ఉపయోగించవద్దని సి సూచిస్తుంది, కాబట్టి, మేము 'వెళ్ళు' యొక్క ఉదాహరణను చూపించడం లేదు.+
మీరు సి ప్రోగ్రామ్‌ను చక్కగా డిజైన్ చేస్తే మీకు 'వెళ్ళండి' ఉపయోగించడానికి ఎటువంటి కారణం ఉండదు.
అందువల్ల, మీ నియంత్రణ ప్రవాహాన్ని సాధించడానికి వేర్వేరు లూప్ లేదా స్విచ్ స్టేట్‌మెంట్‌లతో 'కొనసాగించు' మరియు 'విచ్ఛిన్నం' మాత్రమే ఉపయోగించడానికి ప్రయత్నించండి, కానీ ఫంక్షన్ నుండి తిరిగి రావడానికి మీకు 'తిరిగి' అవసరం.
కాబట్టి, నాలుగు రకాల నియంత్రణ నిర్మాణాలు ఉన్నాయి.
ఈ మాడ్యూల్‌లో మేము ఇప్పటివరకు చూశాము, సి ప్రోగ్రామ్ యొక్క ప్రాథమిక భాగాలు ఏమిటి, మీరు IO ఎలా చేస్తారు, డేటా రకాన్ని ఉపయోగించి వేరియబుల్‌ను ఎలా నిర్వచించాలి? మీరు వాటిని ఎలా ప్రారంభించాలి? ఆపరేటర్లను ఉపయోగించి వాటిని వ్యక్తీకరణలుగా ఎలా చేయాలి? ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని నియంత్రించడానికి వ్యక్తీకరణను స్టేట్‌మెంట్ మరియు విభిన్న కంట్రోల్ ఫ్లో స్టేట్‌మెంట్‌గా ఎలా మార్చాలి? కాబట్టి దీనితో, మేము ఈ భాగాన్ని ముగించాము మరియు ఆ తరువాత ఉత్పన్నమైన రకాలు మరియు సి లో వాటి ఉపయోగం గురించి మాట్లాడుతాము
.
inhouse/NPTEL/PreFinal/c++/Telugu/50 ProgramminginCplusplus_Arrays and Strings (Lecture 05)-3ZgDx-0oGQQ.txt
View file @ 956c0d4e
 1. C ++  ప్రోగ్రామింగ్ లో మాడ్యూల్ 3 కు స్వాగతం.
2. ఈ మాడ్యూల్ లో శ్రేణుల మరియు స్ట్రింగ్స్ గురించి చర్చిస్తాము.
3. సి ప్రోగ్రామ్ మరియు సి ++ ప్రోగ్రామ్ మధ్య ప్రాథమిక తేడాలు ఏమిటో మాడ్యూల్ 2 లో చూశాము.
4. మేము అదే గమనికను కొనసాగిస్తాము.
5. ఈ మాడ్యూల్‌లో, శ్రేణుల వాడకాన్ని అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము, ముఖ్యంగా సి మరియు సి ++ లలో.
6. సి ++ లో మేము వెక్టర్ అని పిలువబడే ఒక ప్రాథమిక భావనను ప్రవేశపెడతాము, ఇది శ్రేణుల వలె ఉంటుంది, కానీ చాలా శక్తివంతమైనది మరియు సి లో స్ట్రింగ్ ఎలా ఉపయోగించాలో చూడటానికి ప్రయత్నిస్తాము మరియు దీనికి విరుద్ధంగా సి ++ లో స్ట్రింగ్ రకం ఎలా పనిచేస్తుందో చూడటానికి ప్రయత్నిస్తాము.
7. కాబట్టి, ఇవి మనం కవర్ చేసే అంశాలు.
8. ప్రారంభించడానికి, మేము రెండు ప్రోగ్రామ్‌లను ఒకేసారి చూపించాము, రెండూ.
9. IO హెడర్‌లో తేడా తప్ప అవి సరిగ్గా ఒకే విధంగా ఉంటాయి.
10. కాబట్టి, C వలె శ్రేణి యొక్క ప్రాథమిక ఉపయోగం C ++ లో సరిగ్గా అదే సంజ్ఞామానం మరియు అదే అర్థంతో ఉపయోగించవచ్చు.
11. కాబట్టి, మొదటి సందేశం ఆరెస్ (శ్రేణులు) ను మీరు C ++ లో ఉపయోగించినట్లే C ++ లో ఉపయోగించవచ్చు.
12. నాకు తెలుసు
13. అందువల్ల, మేము ఇక్కడ వేర్వేరు శ్రేణి మూలకాల కోసం కొన్ని విలువలను పేర్కొంటున్నాము మరియు వాటిని ముద్రించాము, printf ను ఉపయోగించడం లేదా కౌట్ ఉపయోగించడం మాత్రమే తేడా.
14.
15. ఇప్పుడు, సి లోని ప్రధాన సమస్యలలో ఒకటి, మీరందరూ ఎదుర్కొన్న శ్రేణులను (శ్రేణులను) ఉపయోగించడం పరంగా, నేను సి లో శ్రేణి (శ్రేణి) ను ఉపయోగించాలనుకున్నప్పుడు, నేను తెలుసుకోవాలి; నేను శ్రేణి యొక్క పరిమాణాన్ని పేర్కొనాలి, అనగా ప్రోగ్రామ్ లేదా ప్రోగ్రామ్ రాసే సమయంలో, శ్రేణిలో ఇప్పటికే ఉన్న గరిష్ట సంఖ్యల సంఖ్య. సంకలనం సమయంలో నిర్దిష్టంగా ఉండండి.
16. అందువల్ల, నాకు పరిమాణం తెలియకపోతే, నేను అమలు చేసే ఏ సందర్భంలోనైనా ప్రోగ్రామ్‌లో నడుస్తున్న దానికంటే ఎక్కువగా ఉండే పరిమాణాన్ని నేను అందించాలి.
17. ఈ పరిస్థితిని నిర్వహించడానికి ఖచ్చితంగా రెండు మార్గాలు ఉన్నాయి.
18. ఒకటి, నేను నిర్వచించాను, పెద్ద శ్రేణిని ప్రకటించాను మరియు అది చేయవచ్చు; ఇది హార్డ్ కోడెడ్ కావచ్చు, ప్రోగ్రామ్‌లో పరిమాణం హార్డ్ కోడ్ చేయవచ్చు లేదా మానిఫెస్ట్ స్థిరాంకం మరియు ఇతర కేసును ఉపయోగించి ఆకారాన్ని కొంతవరకు మృదువుగా కోడ్ చేయవచ్చు. సి ప్రోగ్రామింగ్‌లో మీరు ఇంతకు ముందు చూసిన, మీరు మాలోక్‌ను ఉపయోగిస్తారు డైనమిక్‌గా స్థలాన్ని కేటాయించండి మరియు రన్ టైమ్‌లో శ్రేణిని కేటాయించండి, ఆపై మీరు దాన్ని ఉపయోగిస్తారు మరియు మీరు malloc ఉపయోగిస్తే దాన్ని ఉపయోగిస్తున్నప్పుడు, మీరు ఆ శ్రేణిని ఉపయోగించినప్పుడు దాన్ని ఖాళీ చేయడాన్ని కూడా గుర్తుంచుకోవాలి.
19. కాబట్టి, మనం సి నుండి సి ++ కి ఎలా వలసపోతామో చూద్దాం.
20. కాబట్టి, ఇది ఎడమ వైపున సి ఉదాహరణను మాత్రమే చూపుతోంది.
21. మేము హార్డ్ కాలమ్ యొక్క పరిమాణాన్ని కుడి కాలమ్‌కు కోడ్ చేస్తాము, ఇది మేము అదే పని చేస్తున్నాము, ఇప్పుడు మీకు మానిఫెస్ట్ స్థిరమైన MAX ఉంది, దీనికి 100 విలువ ఇవ్వబడింది మరియు మేము ఆ MAX ఉపయోగిస్తున్నాము.
22. మానిఫెస్ట్ స్థిరాంకాలను ఉపయోగించడం యొక్క ప్రయోజనం 10 వేర్వేరు శ్రేణుల వరకు ఉంటుంది, పరిమాణం 100 వరకు పేర్కొనబడుతుంది.
23. ఇప్పుడు, నేను వారందరికీ హార్డ్ కోడ్ ఇస్తే మరియు కొంత సమయం తరువాత నేను ఆ పరిమాణాలన్నింటినీ 100 నుండి 1000 కి మార్చవలసి వస్తే, 10 ప్రదేశాలలో నేను వెళ్లి వాటిని సవరించాల్సి ఉంటుంది మరియు నేను అవన్నీ చేయాలనుకుంటున్నాను , కానీ నేను హాష్‌ను నిర్వచించినట్లయితే లేదా మానిఫెస్ట్ స్థిరాంకాన్ని ఉపయోగిస్తే, నేను ఒక ప్రదేశానికి మాత్రమే మార్పులు చేయగలను, నిర్వచనాలను MAX 100 నుండి 1000 కి మార్చగలను మరియు అవన్నీ మారుతాయి.
24. అందువల్ల, సి మెరుగైన ప్రోగ్రామింగ్ ప్రాక్టీస్‌ను కలిగి ఉంది, దీనిలో మానిఫెస్ట్ స్థిరంగా ఉపయోగిస్తుంది మరియు హార్డ్ కోడ్ విలువను కాదు, మీకు ఇది ఇప్పటికే తెలుసు.
25. ఇప్పుడు, మీరు కుడి కాలమ్‌లో సి మరియు సి ++ ల మధ్య ఒకే స్థానాన్ని చూపిస్తారు, ఇప్పుడు మీకు సి ++ ప్రోగ్రామ్ ఉంది.
26. ఖచ్చితంగా, హాష్‌ను శ్రేణి పరిమాణం, MAX శ్రేణి పరిమాణం MAX అని 100 గా నిర్వచించవచ్చు, కాని మనం ఇక్కడ చూపించేది ప్రధాన శీర్షిక తర్వాత ఉన్న పంక్తిపై కేంద్రీకృతమై ఉంది.
27. మేము వెక్టర్‌ను కార్నర్ బ్రాకెట్ Int (int) లో వ్రాస్తున్నాము, ఆపై శ్రేణి పేరు మరియు బ్రాకెట్లలో, మేము మాక్స్ పరిమాణాన్ని చూపుతాము.
28. వెక్టర్ అనేది సి ++ కు కొత్త పరిచయం.
29. ఇది అవ్యక్త రకం కాదు; దయచేసి దీన్ని అంతర్నిర్మిత రకంగా పరిగణించవద్దు.
30. ఇది సి ++ ప్రామాణిక లైబ్రరీ అందించిన విషయం.
31. కాబట్టి, మీరు మీ దృష్టిని # జాబితాలో అగ్రస్థానానికి తరలిస్తే, మీరు # ను కనుగొంటారు, # జ్ఞానం ఉంది.
32. కాబట్టి, ప్రామాణిక లైబ్రరీ హెడర్ ఒక వెక్టర్, ఇది వెక్టర్ రకానికి అవసరమైన అన్ని డిక్లరేషన్ నిర్వచనాలను కలిగి ఉంటుంది మరియు మీరు దీన్ని ఈ విధంగా ఉపయోగించవచ్చు; దీని అర్థం అన్ని సందర్భాల్లో వెక్టర్‌కు వెక్టర్ ఇష్టపడేది.
33. కాబట్టి, మీరు 'ఫర్' లూప్‌లోనే దృష్టి పెట్టండి, శ్రేణి మూలకాలు ఎలా ప్రాప్యత చేయబడుతున్నాయో మీరు చూస్తారు.
34. ఎడమ వైపున, ఇది బాగా తెలిసిన అర్రే Int arr [MAX].
35. మేము దానిని కుడి వైపున arr [i] గా వ్రాస్తాము, ఇది శ్రేణి మూలకాలను యాక్సెస్ చేయడానికి అదే ఇండెక్సింగ్ సంజ్ఞామానాన్ని ఉపయోగించే వెక్టర్.
36. కాబట్టి, యాక్సెస్ సంజ్ఞామానం పరంగా వెక్టర్ యాక్సెస్ ఒకటే మరియు ఇది సాంప్రదాయ శ్రేణితో చదవడం లేదా వ్రాయడం ఉపయోగించడం యొక్క ఫలితం, కానీ దాని పరిమాణం కంపైల్ సమయంలో తప్పనిసరిగా నిర్ణయించబడదు.
37. ఇప్పుడు, ఈ ఉదాహరణలో స్థిరమైన ప్రారంభ పరిమాణం MAX తో వెక్టర్ ఎలా ఉపయోగించాలో చూపించాము.
38. కాబట్టి, మేము వెక్టర్ అని చెప్పినప్పుడు మరియు కార్నర్ బ్రాకెట్ Int (int) లోపల, మూలలో బ్రాకెట్‌లో, శ్రేణితో తయారైన మూలకం యొక్క రకాన్ని మేము అందిస్తున్నాము, దీనిని మేము C. అని పిలుస్తాము. ఇది మూలలో బ్రాకెట్లలోని వెక్టర్‌గా మరియు చదరపు బ్రాకెట్లలోని గరిష్ట పరిమాణంగా మేము ఇక్కడ అందించేది, మేము దానిని పారామితిగా అర్ర్ పాస్ తర్వాత పేరు పెడతాము.
39. కాబట్టి, ఇది కేవలం గుర్తించదగిన వ్యత్యాసం, ఇప్పుడే దీనిని వ్రాయడం, శ్రేణులను ప్రకటించడం యొక్క ప్రత్యేక సంజ్ఞామానం వలె అంగీకరించండి మరియు మీరు మిగిలిన ప్రోగ్రామ్‌ను మరచిపోగలరని మీరు పూర్తి చేసిన తర్వాత, మీరు ప్రత్యేకంగా మీరు వెక్టర్‌ను ఉపయోగించవచ్చు వాటిని శ్రేణులుగా ఉపయోగించడం కొనసాగించవచ్చు.
40. ఇప్పుడు దానితో, మీరు ఎక్కడ ప్రయోజనం పొందుతారో మీకు చూపిస్తాను.
41. ఇప్పుడు, శ్రేణి ఎంత పెద్దదిగా ఉంటుందో మీకు తెలియని ఏకపక్ష-పరిమాణ శ్రేణులను ఉపయోగించే మరొక విధానంపై మేము దృష్టి కేంద్రీకరించాము, ప్రోగ్రామ్ (ప్రోగ్రామ్) వినియోగదారు అమలు చేసినప్పుడు మాత్రమే మీకు తెలుస్తుంది.
42. కాబట్టి, వినియోగదారు బహుశా శ్రేణి యొక్క పరిమాణాన్ని, వినియోగదారు కోరుకునే మూలకాల సంఖ్యను అందిస్తారు.
43. కాబట్టి, సి ప్రోగ్రామ్‌లో, మొదట మనం వినియోగదారుని అడుగుతున్న ఎడమ వైపు చూడండి; ఎన్ని అంశాలు ఉన్నాయి, మరియు వినియోగదారు గణన విలువను అందిస్తుంది మరియు మీరు దీన్ని సి లో చేయవలసి వస్తే, అది చూపిన విధంగా మాలోక్ ఉపయోగించి శ్రేణి (శ్రేణి) ను డైనమిక్‌గా కేటాయించాలి మరియు అదే ముందుకు సాగండి.
44. వాస్తవానికి మీరు మాలోక్‌లో చాలా క్లిష్టమైన రూపాన్ని వ్రాయవలసి ఉంటుంది, ఎందుకంటే మీకు ఎంత మెమరీ అవసరమో మీరు నిజంగా చెప్పాల్సిన అవసరం ఉంది, మాలోక్ (మాలోక్) మీకు శూన్యమైన స్టార్ పాయింటర్ (పాయింటర్) ను తిరిగి ఇస్తుంది. ) నక్షత్రం.
45. సి ప్రోగ్రామింగ్ యొక్క అన్ని సూక్ష్మ నైపుణ్యాలు ఉన్నాయి; ఇప్పుడు అదే మార్గాన్ని మీ దృష్టిని కుడి వైపుకు మార్చండి.
46. ఇప్పుడు, మేము వేరియబుల్ ను డిక్లేర్ చేస్తున్నాము, ఎందుకంటే వేరియబుల్ యొక్క వెక్టర్ అర్ర్ మరియు మేము ఇంతకు ముందు చూపించిన వాటికి భిన్నంగా, దయచేసి గమనించండి, మేము ఏ MAX పరిమాణాన్ని దాటము.
47. కాబట్టి, మేము MAX పరిమాణాన్ని దాటకపోతే, మనకు డిఫాల్ట్ పరిమాణం యొక్క వెక్టర్ లభిస్తుంది, C ++ ప్రామాణిక లైబ్రరీలో కొన్ని డిఫాల్ట్ పరిమాణాలు పరిష్కరించబడవు, కానీ కొన్ని డిఫాల్ట్ సైజు శ్రేణి ఉంటుంది, కానీ మేము అనుసరిస్తున్న పంక్తి సంజ్ఞామానం మీకు తెలియనిదాన్ని రాయండి.
48. మేము arr.resize () ను వ్రాస్తున్నాము, దీనిని వెక్టర్ రకం యొక్క సభ్యుల ఫంక్షన్ ఆకారంగా పిలుస్తాము.
49. ఇది ఏమిటంటే, ఈ పున ize పరిమాణం ఫంక్షన్‌లో, మనం వేరియబుల్ కౌంట్ గుండా వెళుతున్నప్పుడు ఒక విలువను దాటితే, వెక్టర్ మూలకాల సంఖ్య సంఖ్యను పున ize పరిమాణం చేస్తుంది.
50. కాబట్టి, వెక్టర్ సృష్టించబడిన డిఫాల్ట్ పరిమాణం 10 అని అనుకుందాం, మరియు ఇప్పుడు రన్ టైమ్‌లో యూజర్‌కు ఇన్పుట్ కోసం 100 లెక్కింపు ఇవ్వబడుతుంది, వచ్చినప్పుడు. .Rize () పూర్తయితే విలువ 100 గా దాటిపోతుంది మరియు వెక్టర్ అసలు పది మూలకాల నుండి వంద మూలకాలకు మారుతుంది.
51. కాబట్టి, ఆకారం వెక్టర్ సంఖ్యకు లేదా ఆ మూలకం యొక్క వెక్టర్ ఆస్తిగా చాలా సులభంగా ఉపయోగించబడుతుంది.
52. కాబట్టి, దీనితో మీరు ఈ మల్లాక్‌ను ఉపయోగించడం నుండి బయటపడతారు మరియు సంక్లిష్ట అవగాహన మరియు ఆ స్థలాన్ని ఖాళీ చేయడానికి దాన్ని గుర్తుంచుకోండి.
53. మేము వెక్టర్‌ను ఉపయోగించుకోవచ్చు మరియు సి ++ ప్రోగ్రామ్ (ప్రోగ్రామ్) లో శ్రేణులను ఉపయోగించే వాటిని ఉపయోగించుకోవచ్చు ఎందుకంటే వెక్టర్ కంటైనర్‌లోని అదే యంత్రాంగం కంటే చాలా ఎక్కువ. సౌకర్యవంతమైన మరియు కాంపాక్ట్.
54. తరువాత, మీరు ఎలా ఉన్నారో తీసుకుందాం, వైర్ హ్యాండిల్ చూడండి; మొత్తం సంఖ్యలు మరియు తేలియాడే పాయింట్ సంఖ్యల మధ్య వ్యత్యాసం ఉన్న 2 సంఖ్యా రకాలు కాకుండా, మనకు అవసరమయ్యే తదుపరి విస్తృతంగా ఉపయోగించబడే మరియు అవసరమైన రకం లేదా విలువ మన తీగలేనని ముందుగానే తెలుస్తుంది) మనం ఎక్కడ మాట్లాడుతున్నామో దానితో వ్యవహరించాల్సిన అవసరం ఉంది అక్షరాల క్రమం గురించి, మరియు మన దగ్గర ఉన్నదాని గురించి; మేము సి లో పనిచేస్తుంటే, ఇప్పుడు మనకు సి స్ట్రింగ్ ఉంది.
55. సి స్ట్రింగ్ వలె డిఫాల్ట్ రకాన్ని కలిగి లేదు, కానీ దీనికి స్ట్రింగ్.హెచ్ ప్రామాణిక లైబ్రరీ హెడర్ ఉంది, ఇది స్ట్రెలెన్, స్ట్రెలెన్, స్ట్ర్క్పి, స్ట్ర్కాట్ మొదలైన అనేక రకాల స్ట్రింగ్ ఫంక్షన్లను అనుమతిస్తుంది (ఫంక్షన్) మరియు దానితో సి స్ట్రింగ్ ( స్ట్రింగ్) కేవలం అక్షరాల శ్రేణి, ఇది NULL చేత ముగించబడిందని మేము చెబుతున్నాము, అంటే మీరు శ్రేణిని ఎడమ నుండి కుడికి మార్చినట్లయితే స్కాన్ చేసేటప్పుడు, మీరు మొదట శూన్య అక్షరాల వద్దకు వచ్చే వరకు మీకు స్ట్రింగ్ ఉందని భావిస్తూనే ఉంటారు. ASCII విలువ 0 ఉన్న అక్షరాలు; దయచేసి ఈ NULL తరువాత శ్రేణిలో, ఇంకా చాలా ఇతర అక్షరాలు మిగిలి ఉండవచ్చు, కానీ అవి స్ట్రింగ్‌లో భాగంగా పరిగణించబడవు.
56. ఇప్పుడు, ఈ సమావేశంతో మనం స్ట్రింగ్ (స్ట్రింగ్) నుండి స్ట్రింగ్ (స్ట్రింగ్) ఫంక్షన్ ఉపయోగిస్తే.
57. H హెడర్ అప్పుడు మీరు అందరికీ తెలిసినందున మీరు వివిధ రకాల స్ట్రింగ్ ఆపరేషన్లను పొందగలుగుతారు.
58. దీనికి విరుద్ధంగా, C ++ ఇప్పుడు C ++ ప్రామాణిక లైబ్రరీలో స్ట్రింగ్ రకాన్ని పరిచయం చేసింది.
59. మేము వెక్టర్ గురించి మాట్లాడేటప్పుడు ఇదే.
60. కాబట్టి, స్ట్రింగ్ కూడా అంతర్నిర్మిత రకం కాదు, కానీ ఇది ప్రామాణిక లైబ్రరీ ద్వారా జతచేయబడిన రకం మరియు మీరు C ++ ప్రామాణిక లైబ్రరీ యొక్క స్ట్రింగ్‌ను స్ట్రింగ్ చేయడానికి స్ట్రింగ్ పొందాలి. హెడర్ ఉపయోగించాలి మరియు అది అదనపు వ్యక్తీకరణగా స్ట్రింగ్‌ను వ్రాయడం మరియు ఘనీభవించడం వంటి కొన్ని అద్భుతమైన ప్రవర్తనలను కలిగి ఉంది.
61. అందువల్ల, మేము వాటిని వివరిస్తాము.
62. సి ప్రోగ్రామ్ మరియు సి ++ ప్రోగ్రామ్ మధ్య సరళమైన సమాంతరం ఉంది.
63. ఈ ప్రోగ్రామ్ హలో వరల్డ్ ప్రోగ్రామ్‌లో నిర్వచించబడిన రెండు తీగలతో మొదలవుతుంది మరియు మొదటి స్ట్రింగ్ తర్వాత రెండవ స్ట్రింగ్‌ను మార్చాలనుకుంటున్నాము.
64. అందువల్ల, మేము వాటిని మొదటి స్ట్రింగ్ తరువాత రెండవ స్ట్రింగ్ తో మాత్రమే అనుసరించాలనుకుంటున్నాము మరియు ఒక చిన్న స్ట్రింగ్ ను సృష్టించండి.
65. కాబట్టి, మీరు సి లో చేయవలసి వస్తే, ఎడమ వైపున మీరు ఏమి చేయాలో చూడవచ్చు, అప్పుడు మీకు శ్రేణి అవసరం, చిన్న స్ట్రింగ్ (స్ట్రింగ్) కలిగి ఉండటానికి, మాకు ఇది అవసరం (స్ట్రింగ్) , మీరు మొదట స్ట్రింగ్ (స్ట్రింగ్) ను str1 str కు కాపీ చేసి, ఆపై మీరు ఇప్పటికే str2 ను కాపీ చేసారు.
66. కాబట్టి, అది ఆ తర్వాతే వస్తుంది, కాబట్టి మొదట హలో ఆ తర్వాత ఖాళీగా str కు కాపీ చేయబడుతుంది మరియు తరువాత ప్రపంచానికి సంక్షిప్త స్ట్రాచీ (strcpy) మరియు strcat రచనలు లభిస్తాయి మరియు మీరు దానిని ముద్రించవచ్చు.
67. దీనికి విరుద్ధంగా, C ++ లో మీకు స్ట్రింగ్ హెడర్‌లో స్ట్రింగ్ రకం ఉంది.
68. అందువల్ల, మీరు స్ట్రింగ్ హెడర్‌లను కలిగి ఉంటారు, మీరు వాటిని ఇకపై ప్రకటించరు, ఎందుకంటే మీరు వాటిని స్ట్రింగ్ (స్ట్రింగ్) గా ప్రకటిస్తారు, ఇది ఆ హెడర్‌లో ఇచ్చిన రకం పేరు; దయచేసి ఈ పేరు అన్ని తక్కువ సందర్భాల్లో ఉందని గమనించండి, ఆపై మీకు స్ట్రింగ్ వేరియబుల్, పేరు str1 ఉంది మరియు మీరు దానిని స్థిరమైన స్ట్రింగ్ (హలో) ఖాళీ లేదా ప్రపంచంతో ప్రారంభించండి.
69. చాలా ఆసక్తికరమైన విషయాలు ఏమిటంటే, మీరు దానిని కుదించవలసి వచ్చినప్పుడు మీరు నిజంగా మొదటి స్ట్రింగ్‌ను కాపీ చేసి, ఆపై స్థిరత్వం చేయనవసరం లేదు, నేను str1 కు str2 ని జోడిస్తున్నానని మీరు చెప్పగలరు.
70. కాబట్టి, మేము str1 + str2 అని చెప్తాము, కాబట్టి నాకు వేరియబుల్ x 3 విలువ ఉంటే చాలా ఇష్టం, వేరియబుల్ y యొక్క విలువ 5.
71. I x ప్లస్ y అంటే 3 ప్లస్ 5, అంటే 8.
72. అందువల్ల ఇది పూర్ణాంకం.
73. ఇది స్ట్రింగ్ రకానికి స్ట్రింగ్ (స్ట్రింగ్) ను జోడించడం మాదిరిగానే ఉంటుంది, ఇది ఒక సంగ్రహణ ఆపరేషన్ అవుతుంది మరియు మేము C ++ లో అద్భుతమైన శక్తిని చూస్తాము, ఇది ఆపరేటర్లను మీరు వివరించాలనుకున్నదానిని మీ స్వంత మార్గంలో నిర్వచించటానికి మిమ్మల్ని అనుమతిస్తుంది.
74. ఉదాహరణకు, మీరు దీర్ఘచతురస్రాల కోసం బీజగణితం రాయడానికి దీనిని ఉపయోగించవచ్చు, మీకు రెండు దీర్ఘచతురస్రాలు ఉండవచ్చు, మీకు ఒక దీర్ఘచతురస్ర రకం ఉంటే మరియు మీరు ఒక దీర్ఘచతురస్రాన్ని ప్రాథమికంగా చేయడానికి రెండు దీర్ఘచతురస్రాల మొత్తాన్ని నిర్వచించవచ్చు.కాబట్టి ఈ దీర్ఘచతురస్రం యొక్క యూనియన్ ఏర్పడుతుంది ఈ దీర్ఘచతురస్రాలు మరియు మొదలైన రెండు పెద్ద దీర్ఘచతురస్రాలను కలిగి ఉంటుంది.
75. కాబట్టి, స్ట్రింగ్ పరంగా, ఈ లక్షణం C ++ లో లభిస్తుంది, కాబట్టి తీగలతో వ్యవహరించడం చాలా సులభం అవుతుంది.
76. C లో ప్రత్యేకంగా గమనించండి, C లో, ఫలిత పరిమాణం ఏమిటో మీరు నిజంగా తెలుసుకోవాలి? కాబట్టి, మీరు మళ్ళీ వేరియబుల్ str కోసం ఒక శ్రేణిని విస్తృతంగా నిర్వచించవచ్చు ఎందుకంటే ఇది str పరిమాణంలో సరిపోకపోతే స్ట్రాపీ, స్ట్రాకాట్ తరువాత C ++ లో విఫలమవుతుంది.
77. మీరు దీన్ని చేసినప్పుడు, మీరు వీటిలో దేనినీ ఇబ్బంది పెట్టవలసిన అవసరం లేదు. వేరియబుల్ స్ట్రింగ్‌ను ఒక రకమైన స్ట్రింగ్‌గా ప్రకటించండి మరియు మీరు దాన్ని str1 + str2 యొక్క గణనతో ప్రారంభించండి.
78. పైలర్ పరిమాణాన్ని స్వయంచాలకంగా నిర్వహించడానికి భయపడుతుంది మరియు మీకు ఏకకాలంలో ఉండేంత పెద్ద స్ట్రింగ్ ఇస్తుంది.
79. కాబట్టి, తీగలను నిర్వహించడం చాలా సులభం.
80. అలాగే, వైర్లను కనెక్ట్ చేయడం లేదా వైర్ల సంగ్రహణ కోసం అదనపు ఆపరేటర్లను ఉపయోగించడం వంటివి నిజంగా ముగియవు, మీరు అనేక ఇతర ఆపరేషన్లు చేయవచ్చు.
81. స్తవానికి, మీకు సి స్టాండర్డ్ లైబ్రరీలో ఉన్న స్ట్రింగ్ డాట్ హెచ్ ఫంక్షన్ అవసరం లేదు మరియు మీరు స్ట్రింగ్ (స్ట్రింగ్) కాపీ చేసే స్థానంలో అసైన్‌మెంట్‌లను ఉపయోగించవచ్చు, అన్ని తులనాత్మక ఆపరేటర్లు మీరు ఉపయోగించగలది స్ట్రింగ్‌ను ఉపయోగించటానికి బదులుగా కనీసం సమానమైన దానికంటే ఎక్కువ.
82. స్టాంప్‌ను ఉపయోగించడం చాలా క్లిష్టమైన పని అని మాకు తెలుసు; ఇది రెండు తీగలను తీసుకుంటుంది; కార్డ్ స్టాక్ పాయింటర్లు మరియు రెండు స్ట్రింగ్‌లు మీకు -1 లేదా 0 గా ఉండే విలువను ఇస్తాయి లేదా +1 కావచ్చు, ఏ స్ట్రింగ్ పెద్దది లేదా సమానంగా ఉంటుందో దానిపై ఆధారపడి ఉంటుంది. తీగలను సమానంగా ఉంటే సంభవిస్తుంది.
83. ఇప్పుడు, మీరు C ++ లో స్ట్రింగ్ రకంతో లేరు, మీరు వీటిలో దేనినైనా పొందాల్సిన అవసరం లేదు.
84. మీరు పూర్ణాంకాలు లేదా తేలియాడే పాయింట్ సంఖ్యలను పోల్చిన విధంగానే పోలిక ఆపరేటర్లను ఉపయోగించవచ్చు మరియు తీగలను పోల్చవచ్చు.
85. కాబట్టి, ఇది సి ++ యొక్క చాలా బలమైన లక్షణం మరియు ఇది చాలా అనుకూలమైన పద్ధతి, ముఖ్యంగా స్ట్రింగ్ కోసం.
86. అందువల్ల, సి ++ గురించి లోతైన అవగాహన లేకుండా, మీరు స్ట్రింగ్ మాత్రమే ఉపయోగించడం ప్రారంభించవచ్చు మరియు మీ అన్ని ప్రోగ్రామ్‌లను తెలివిగా మరియు సులభంగా వ్రాయవచ్చు.
87. ఈ మాడ్యూల్‌లో మనం చూపించాము - మనం శ్రేణులతో ఎలా పని చేయవచ్చు, వెక్టర్ వాస్తవానికి శ్రేణులను వేరియబుల్ పరిమాణానికి ఎలా సులభతరం చేస్తుంది మరియు స్ట్రింగ్ రకాలను ఉపయోగిస్తుంది C ++ లో తీగలను చాలా సులభంగా ఎలా నిర్వహించాలి.
88. ప్రామాణిక లైబ్రరీ.
 C ++  ప్రోగ్రామింగ్ లో మాడ్యూల్ 3 కు స్వాగతం.
ఈ మాడ్యూల్ లో శ్రేణుల మరియు స్ట్రింగ్స్ గురించి చర్చిస్తాము.
సి ప్రోగ్రామ్ మరియు సి ++ ప్రోగ్రామ్ మధ్య ప్రాథమిక తేడాలు ఏమిటో మాడ్యూల్ 2 లో చూశాము.
మేము అదే గమనికను కొనసాగిస్తాము.
ఈ మాడ్యూల్‌లో, శ్రేణుల వాడకాన్ని అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము, ముఖ్యంగా సి మరియు సి ++ లలో.
సి ++ లో మేము వెక్టర్ అని పిలువబడే ఒక ప్రాథమిక భావనను ప్రవేశపెడతాము, ఇది శ్రేణుల వలె ఉంటుంది, కానీ చాలా శక్తివంతమైనది మరియు సి లో స్ట్రింగ్ ఎలా ఉపయోగించాలో చూడటానికి ప్రయత్నిస్తాము మరియు దీనికి విరుద్ధంగా సి ++ లో స్ట్రింగ్ రకం ఎలా పనిచేస్తుందో చూడటానికి ప్రయత్నిస్తాము.
కాబట్టి, ఇవి మనం కవర్ చేసే అంశాలు.
ప్రారంభించడానికి, మేము రెండు ప్రోగ్రామ్‌లను ఒకేసారి చూపించాము, రెండూ.
IO హెడర్‌లో తేడా తప్ప అవి సరిగ్గా ఒకే విధంగా ఉంటాయి.
కాబట్టి, C వలె శ్రేణి యొక్క ప్రాథమిక ఉపయోగం C ++ లో సరిగ్గా అదే సంజ్ఞామానం మరియు అదే అర్థంతో ఉపయోగించవచ్చు.
కాబట్టి, మొదటి సందేశం ఆరెస్ (శ్రేణులు) ను మీరు C ++ లో ఉపయోగించినట్లే C ++ లో ఉపయోగించవచ్చు.
నాకు తెలుసు
అందువల్ల, మేము ఇక్కడ వేర్వేరు శ్రేణి మూలకాల కోసం కొన్ని విలువలను పేర్కొంటున్నాము మరియు వాటిని ముద్రించాము, printf ను ఉపయోగించడం లేదా కౌట్ ఉపయోగించడం మాత్రమే తేడా.
ఇప్పుడు, సి లోని ప్రధాన సమస్యలలో ఒకటి, మీరందరూ ఎదుర్కొన్న శ్రేణులను (శ్రేణులను) ఉపయోగించడం పరంగా, నేను సి లో శ్రేణి (శ్రేణి) ను ఉపయోగించాలనుకున్నప్పుడు, నేను తెలుసుకోవాలి; నేను శ్రేణి యొక్క పరిమాణాన్ని పేర్కొనాలి, అనగా ప్రోగ్రామ్ లేదా ప్రోగ్రామ్ రాసే సమయంలో, శ్రేణిలో ఇప్పటికే ఉన్న గరిష్ట సంఖ్యల సంఖ్య. సంకలనం సమయంలో నిర్దిష్టంగా ఉండండి.
అందువల్ల, నాకు పరిమాణం తెలియకపోతే, నేను అమలు చేసే ఏ సందర్భంలోనైనా ప్రోగ్రామ్‌లో నడుస్తున్న దానికంటే ఎక్కువగా ఉండే పరిమాణాన్ని నేను అందించాలి.
ఈ పరిస్థితిని నిర్వహించడానికి ఖచ్చితంగా రెండు మార్గాలు ఉన్నాయి.
ఒకటి, నేను నిర్వచించాను, పెద్ద శ్రేణిని ప్రకటించాను మరియు అది చేయవచ్చు; ఇది హార్డ్ కోడెడ్ కావచ్చు, ప్రోగ్రామ్‌లో పరిమాణం హార్డ్ కోడ్ చేయవచ్చు లేదా మానిఫెస్ట్ స్థిరాంకం మరియు ఇతర కేసును ఉపయోగించి ఆకారాన్ని కొంతవరకు మృదువుగా కోడ్ చేయవచ్చు. సి ప్రోగ్రామింగ్‌లో మీరు ఇంతకు ముందు చూసిన, మీరు మాలోక్‌ను ఉపయోగిస్తారు డైనమిక్‌గా స్థలాన్ని కేటాయించండి మరియు రన్ టైమ్‌లో శ్రేణిని కేటాయించండి, ఆపై మీరు దాన్ని ఉపయోగిస్తారు మరియు మీరు malloc ఉపయోగిస్తే దాన్ని ఉపయోగిస్తున్నప్పుడు, మీరు ఆ శ్రేణిని ఉపయోగించినప్పుడు దాన్ని ఖాళీ చేయడాన్ని కూడా గుర్తుంచుకోవాలి.
కాబట్టి, మనం సి నుండి సి ++ కి ఎలా వలసపోతామో చూద్దాం.
కాబట్టి, ఇది ఎడమ వైపున సి ఉదాహరణను మాత్రమే చూపుతోంది.
మేము హార్డ్ కాలమ్ యొక్క పరిమాణాన్ని కుడి కాలమ్‌కు కోడ్ చేస్తాము, ఇది మేము అదే పని చేస్తున్నాము, ఇప్పుడు మీకు మానిఫెస్ట్ స్థిరమైన MAX ఉంది, దీనికి 100 విలువ ఇవ్వబడింది మరియు మేము ఆ MAX ఉపయోగిస్తున్నాము.
మానిఫెస్ట్ స్థిరాంకాలను ఉపయోగించడం యొక్క ప్రయోజనం 10 వేర్వేరు శ్రేణుల వరకు ఉంటుంది, పరిమాణం 100 వరకు పేర్కొనబడుతుంది.
ఇప్పుడు, నేను వారందరికీ హార్డ్ కోడ్ ఇస్తే మరియు కొంత సమయం తరువాత నేను ఆ పరిమాణాలన్నింటినీ 100 నుండి 1000 కి మార్చవలసి వస్తే, 10 ప్రదేశాలలో నేను వెళ్లి వాటిని సవరించాల్సి ఉంటుంది మరియు నేను అవన్నీ చేయాలనుకుంటున్నాను , కానీ నేను హాష్‌ను నిర్వచించినట్లయితే లేదా మానిఫెస్ట్ స్థిరాంకాన్ని ఉపయోగిస్తే, నేను ఒక ప్రదేశానికి మాత్రమే మార్పులు చేయగలను, నిర్వచనాలను MAX 100 నుండి 1000 కి మార్చగలను మరియు అవన్నీ మారుతాయి.
అందువల్ల, సి మెరుగైన ప్రోగ్రామింగ్ ప్రాక్టీస్‌ను కలిగి ఉంది, దీనిలో మానిఫెస్ట్ స్థిరంగా ఉపయోగిస్తుంది మరియు హార్డ్ కోడ్ విలువను కాదు, మీకు ఇది ఇప్పటికే తెలుసు.
ఇప్పుడు, మీరు కుడి కాలమ్‌లో సి మరియు సి ++ ల మధ్య ఒకే స్థానాన్ని చూపిస్తారు, ఇప్పుడు మీకు సి ++ ప్రోగ్రామ్ ఉంది.
ఖచ్చితంగా, హాష్‌ను శ్రేణి పరిమాణం, MAX శ్రేణి పరిమాణం MAX అని 100 గా నిర్వచించవచ్చు, కాని మనం ఇక్కడ చూపించేది ప్రధాన శీర్షిక తర్వాత ఉన్న పంక్తిపై కేంద్రీకృతమై ఉంది.
మేము వెక్టర్‌ను కార్నర్ బ్రాకెట్ Int (int) లో వ్రాస్తున్నాము, ఆపై శ్రేణి పేరు మరియు బ్రాకెట్లలో, మేము మాక్స్ పరిమాణాన్ని చూపుతాము.
వెక్టర్ అనేది సి ++ కు కొత్త పరిచయం.
ఇది అవ్యక్త రకం కాదు; దయచేసి దీన్ని అంతర్నిర్మిత రకంగా పరిగణించవద్దు.
ఇది సి ++ ప్రామాణిక లైబ్రరీ అందించిన విషయం.
కాబట్టి, మీరు మీ దృష్టిని # జాబితాలో అగ్రస్థానానికి తరలిస్తే, మీరు # ను కనుగొంటారు, # జ్ఞానం ఉంది.
కాబట్టి, ప్రామాణిక లైబ్రరీ హెడర్ ఒక వెక్టర్, ఇది వెక్టర్ రకానికి అవసరమైన అన్ని డిక్లరేషన్ నిర్వచనాలను కలిగి ఉంటుంది మరియు మీరు దీన్ని ఈ విధంగా ఉపయోగించవచ్చు; దీని అర్థం అన్ని సందర్భాల్లో వెక్టర్‌కు వెక్టర్ ఇష్టపడేది.
కాబట్టి, మీరు 'ఫర్' లూప్‌లోనే దృష్టి పెట్టండి, శ్రేణి మూలకాలు ఎలా ప్రాప్యత చేయబడుతున్నాయో మీరు చూస్తారు.
ఎడమ వైపున, ఇది బాగా తెలిసిన అర్రే Int arr [MAX].
మేము దానిని కుడి వైపున arr [i] గా వ్రాస్తాము, ఇది శ్రేణి మూలకాలను యాక్సెస్ చేయడానికి అదే ఇండెక్సింగ్ సంజ్ఞామానాన్ని ఉపయోగించే వెక్టర్.
కాబట్టి, యాక్సెస్ సంజ్ఞామానం పరంగా వెక్టర్ యాక్సెస్ ఒకటే మరియు ఇది సాంప్రదాయ శ్రేణితో చదవడం లేదా వ్రాయడం ఉపయోగించడం యొక్క ఫలితం, కానీ దాని పరిమాణం కంపైల్ సమయంలో తప్పనిసరిగా నిర్ణయించబడదు.
ఇప్పుడు, ఈ ఉదాహరణలో స్థిరమైన ప్రారంభ పరిమాణం MAX తో వెక్టర్ ఎలా ఉపయోగించాలో చూపించాము.
కాబట్టి, మేము వెక్టర్ అని చెప్పినప్పుడు మరియు కార్నర్ బ్రాకెట్ Int (int) లోపల, మూలలో బ్రాకెట్‌లో, శ్రేణితో తయారైన మూలకం యొక్క రకాన్ని మేము అందిస్తున్నాము, దీనిని మేము C. అని పిలుస్తాము. ఇది మూలలో బ్రాకెట్లలోని వెక్టర్‌గా మరియు చదరపు బ్రాకెట్లలోని గరిష్ట పరిమాణంగా మేము ఇక్కడ అందించేది, మేము దానిని పారామితిగా అర్ర్ పాస్ తర్వాత పేరు పెడతాము.
కాబట్టి, ఇది కేవలం గుర్తించదగిన వ్యత్యాసం, ఇప్పుడే దీనిని వ్రాయడం, శ్రేణులను ప్రకటించడం యొక్క ప్రత్యేక సంజ్ఞామానం వలె అంగీకరించండి మరియు మీరు మిగిలిన ప్రోగ్రామ్‌ను మరచిపోగలరని మీరు పూర్తి చేసిన తర్వాత, మీరు ప్రత్యేకంగా మీరు వెక్టర్‌ను ఉపయోగించవచ్చు వాటిని శ్రేణులుగా ఉపయోగించడం కొనసాగించవచ్చు.
ఇప్పుడు దానితో, మీరు ఎక్కడ ప్రయోజనం పొందుతారో మీకు చూపిస్తాను.
ఇప్పుడు, శ్రేణి ఎంత పెద్దదిగా ఉంటుందో మీకు తెలియని ఏకపక్ష-పరిమాణ శ్రేణులను ఉపయోగించే మరొక విధానంపై మేము దృష్టి కేంద్రీకరించాము, ప్రోగ్రామ్ (ప్రోగ్రామ్) వినియోగదారు అమలు చేసినప్పుడు మాత్రమే మీకు తెలుస్తుంది.
కాబట్టి, వినియోగదారు బహుశా శ్రేణి యొక్క పరిమాణాన్ని, వినియోగదారు కోరుకునే మూలకాల సంఖ్యను అందిస్తారు.
కాబట్టి, సి ప్రోగ్రామ్‌లో, మొదట మనం వినియోగదారుని అడుగుతున్న ఎడమ వైపు చూడండి; ఎన్ని అంశాలు ఉన్నాయి, మరియు వినియోగదారు గణన విలువను అందిస్తుంది మరియు మీరు దీన్ని సి లో చేయవలసి వస్తే, అది చూపిన విధంగా మాలోక్ ఉపయోగించి శ్రేణి (శ్రేణి) ను డైనమిక్‌గా కేటాయించాలి మరియు అదే ముందుకు సాగండి.
వాస్తవానికి మీరు మాలోక్‌లో చాలా క్లిష్టమైన రూపాన్ని వ్రాయవలసి ఉంటుంది, ఎందుకంటే మీకు ఎంత మెమరీ అవసరమో మీరు నిజంగా చెప్పాల్సిన అవసరం ఉంది, మాలోక్ (మాలోక్) మీకు శూన్యమైన స్టార్ పాయింటర్ (పాయింటర్) ను తిరిగి ఇస్తుంది. ) నక్షత్రం.
సి ప్రోగ్రామింగ్ యొక్క అన్ని సూక్ష్మ నైపుణ్యాలు ఉన్నాయి; ఇప్పుడు అదే మార్గాన్ని మీ దృష్టిని కుడి వైపుకు మార్చండి.
ఇప్పుడు, మేము వేరియబుల్ ను డిక్లేర్ చేస్తున్నాము, ఎందుకంటే వేరియబుల్ యొక్క వెక్టర్ అర్ర్ మరియు మేము ఇంతకు ముందు చూపించిన వాటికి భిన్నంగా, దయచేసి గమనించండి, మేము ఏ MAX పరిమాణాన్ని దాటము.
కాబట్టి, మేము MAX పరిమాణాన్ని దాటకపోతే, మనకు డిఫాల్ట్ పరిమాణం యొక్క వెక్టర్ లభిస్తుంది, C ++ ప్రామాణిక లైబ్రరీలో కొన్ని డిఫాల్ట్ పరిమాణాలు పరిష్కరించబడవు, కానీ కొన్ని డిఫాల్ట్ సైజు శ్రేణి ఉంటుంది, కానీ మేము అనుసరిస్తున్న పంక్తి సంజ్ఞామానం మీకు తెలియనిదాన్ని రాయండి.
మేము arr.resize () ను వ్రాస్తున్నాము, దీనిని వెక్టర్ రకం యొక్క సభ్యుల ఫంక్షన్ ఆకారంగా పిలుస్తాము.
ఇది ఏమిటంటే, ఈ పున ize పరిమాణం ఫంక్షన్‌లో, మనం వేరియబుల్ కౌంట్ గుండా వెళుతున్నప్పుడు ఒక విలువను దాటితే, వెక్టర్ మూలకాల సంఖ్య సంఖ్యను పున ize పరిమాణం చేస్తుంది.
కాబట్టి, వెక్టర్ సృష్టించబడిన డిఫాల్ట్ పరిమాణం 10 అని అనుకుందాం, మరియు ఇప్పుడు రన్ టైమ్‌లో యూజర్‌కు ఇన్పుట్ కోసం 100 లెక్కింపు ఇవ్వబడుతుంది, వచ్చినప్పుడు. .Rize () పూర్తయితే విలువ 100 గా దాటిపోతుంది మరియు వెక్టర్ అసలు పది మూలకాల నుండి వంద మూలకాలకు మారుతుంది.
కాబట్టి, ఆకారం వెక్టర్ సంఖ్యకు లేదా ఆ మూలకం యొక్క వెక్టర్ ఆస్తిగా చాలా సులభంగా ఉపయోగించబడుతుంది.
కాబట్టి, దీనితో మీరు ఈ మల్లాక్‌ను ఉపయోగించడం నుండి బయటపడతారు మరియు సంక్లిష్ట అవగాహన మరియు ఆ స్థలాన్ని ఖాళీ చేయడానికి దాన్ని గుర్తుంచుకోండి.
మేము వెక్టర్‌ను ఉపయోగించుకోవచ్చు మరియు సి ++ ప్రోగ్రామ్ (ప్రోగ్రామ్) లో శ్రేణులను ఉపయోగించే వాటిని ఉపయోగించుకోవచ్చు ఎందుకంటే వెక్టర్ కంటైనర్‌లోని అదే యంత్రాంగం కంటే చాలా ఎక్కువ. సౌకర్యవంతమైన మరియు కాంపాక్ట్.
తరువాత, మీరు ఎలా ఉన్నారో తీసుకుందాం, వైర్ హ్యాండిల్ చూడండి; మొత్తం సంఖ్యలు మరియు తేలియాడే పాయింట్ సంఖ్యల మధ్య వ్యత్యాసం ఉన్న 2 సంఖ్యా రకాలు కాకుండా, మనకు అవసరమయ్యే తదుపరి విస్తృతంగా ఉపయోగించబడే మరియు అవసరమైన రకం లేదా విలువ మన తీగలేనని ముందుగానే తెలుస్తుంది) మనం ఎక్కడ మాట్లాడుతున్నామో దానితో వ్యవహరించాల్సిన అవసరం ఉంది అక్షరాల క్రమం గురించి, మరియు మన దగ్గర ఉన్నదాని గురించి; మేము సి లో పనిచేస్తుంటే, ఇప్పుడు మనకు సి స్ట్రింగ్ ఉంది.
సి స్ట్రింగ్ వలె డిఫాల్ట్ రకాన్ని కలిగి లేదు, కానీ దీనికి స్ట్రింగ్.హెచ్ ప్రామాణిక లైబ్రరీ హెడర్ ఉంది, ఇది స్ట్రెలెన్, స్ట్రెలెన్, స్ట్ర్క్పి, స్ట్ర్కాట్ మొదలైన అనేక రకాల స్ట్రింగ్ ఫంక్షన్లను అనుమతిస్తుంది (ఫంక్షన్) మరియు దానితో సి స్ట్రింగ్ ( స్ట్రింగ్) కేవలం అక్షరాల శ్రేణి, ఇది NULL చేత ముగించబడిందని మేము చెబుతున్నాము, అంటే మీరు శ్రేణిని ఎడమ నుండి కుడికి మార్చినట్లయితే స్కాన్ చేసేటప్పుడు, మీరు మొదట శూన్య అక్షరాల వద్దకు వచ్చే వరకు మీకు స్ట్రింగ్ ఉందని భావిస్తూనే ఉంటారు. ASCII విలువ 0 ఉన్న అక్షరాలు; దయచేసి ఈ NULL తరువాత శ్రేణిలో, ఇంకా చాలా ఇతర అక్షరాలు మిగిలి ఉండవచ్చు, కానీ అవి స్ట్రింగ్‌లో భాగంగా పరిగణించబడవు.
ఇప్పుడు, ఈ సమావేశంతో మనం స్ట్రింగ్ (స్ట్రింగ్) నుండి స్ట్రింగ్ (స్ట్రింగ్) ఫంక్షన్ ఉపయోగిస్తే.
H హెడర్ అప్పుడు మీరు అందరికీ తెలిసినందున మీరు వివిధ రకాల స్ట్రింగ్ ఆపరేషన్లను పొందగలుగుతారు.
దీనికి విరుద్ధంగా, C ++ ఇప్పుడు C ++ ప్రామాణిక లైబ్రరీలో స్ట్రింగ్ రకాన్ని పరిచయం చేసింది.
మేము వెక్టర్ గురించి మాట్లాడేటప్పుడు ఇదే.
కాబట్టి, స్ట్రింగ్ కూడా అంతర్నిర్మిత రకం కాదు, కానీ ఇది ప్రామాణిక లైబ్రరీ ద్వారా జతచేయబడిన రకం మరియు మీరు C ++ ప్రామాణిక లైబ్రరీ యొక్క స్ట్రింగ్‌ను స్ట్రింగ్ చేయడానికి స్ట్రింగ్ పొందాలి. హెడర్ ఉపయోగించాలి మరియు అది అదనపు వ్యక్తీకరణగా స్ట్రింగ్‌ను వ్రాయడం మరియు ఘనీభవించడం వంటి కొన్ని అద్భుతమైన ప్రవర్తనలను కలిగి ఉంది.
అందువల్ల, మేము వాటిని వివరిస్తాము.
సి ప్రోగ్రామ్ మరియు సి ++ ప్రోగ్రామ్ మధ్య సరళమైన సమాంతరం ఉంది.
ఈ ప్రోగ్రామ్ హలో వరల్డ్ ప్రోగ్రామ్‌లో నిర్వచించబడిన రెండు తీగలతో మొదలవుతుంది మరియు మొదటి స్ట్రింగ్ తర్వాత రెండవ స్ట్రింగ్‌ను మార్చాలనుకుంటున్నాము.
అందువల్ల, మేము వాటిని మొదటి స్ట్రింగ్ తరువాత రెండవ స్ట్రింగ్ తో మాత్రమే అనుసరించాలనుకుంటున్నాము మరియు ఒక చిన్న స్ట్రింగ్ ను సృష్టించండి.
కాబట్టి, మీరు సి లో చేయవలసి వస్తే, ఎడమ వైపున మీరు ఏమి చేయాలో చూడవచ్చు, అప్పుడు మీకు శ్రేణి అవసరం, చిన్న స్ట్రింగ్ (స్ట్రింగ్) కలిగి ఉండటానికి, మాకు ఇది అవసరం (స్ట్రింగ్) , మీరు మొదట స్ట్రింగ్ (స్ట్రింగ్) ను str1 str కు కాపీ చేసి, ఆపై మీరు ఇప్పటికే str2 ను కాపీ చేసారు.
కాబట్టి, అది ఆ తర్వాతే వస్తుంది, కాబట్టి మొదట హలో ఆ తర్వాత ఖాళీగా str కు కాపీ చేయబడుతుంది మరియు తరువాత ప్రపంచానికి సంక్షిప్త స్ట్రాచీ (strcpy) మరియు strcat రచనలు లభిస్తాయి మరియు మీరు దానిని ముద్రించవచ్చు.
దీనికి విరుద్ధంగా, C ++ లో మీకు స్ట్రింగ్ హెడర్‌లో స్ట్రింగ్ రకం ఉంది.
అందువల్ల, మీరు స్ట్రింగ్ హెడర్‌లను కలిగి ఉంటారు, మీరు వాటిని ఇకపై ప్రకటించరు, ఎందుకంటే మీరు వాటిని స్ట్రింగ్ (స్ట్రింగ్) గా ప్రకటిస్తారు, ఇది ఆ హెడర్‌లో ఇచ్చిన రకం పేరు; దయచేసి ఈ పేరు అన్ని తక్కువ సందర్భాల్లో ఉందని గమనించండి, ఆపై మీకు స్ట్రింగ్ వేరియబుల్, పేరు str1 ఉంది మరియు మీరు దానిని స్థిరమైన స్ట్రింగ్ (హలో) ఖాళీ లేదా ప్రపంచంతో ప్రారంభించండి.
చాలా ఆసక్తికరమైన విషయాలు ఏమిటంటే, మీరు దానిని కుదించవలసి వచ్చినప్పుడు మీరు నిజంగా మొదటి స్ట్రింగ్‌ను కాపీ చేసి, ఆపై స్థిరత్వం చేయనవసరం లేదు, నేను str1 కు str2 ని జోడిస్తున్నానని మీరు చెప్పగలరు.
కాబట్టి, మేము str1 + str2 అని చెప్తాము, కాబట్టి నాకు వేరియబుల్ x 3 విలువ ఉంటే చాలా ఇష్టం, వేరియబుల్ y యొక్క విలువ 5.
I x ప్లస్ y అంటే 3 ప్లస్ 5, అంటే 8.
అందువల్ల ఇది పూర్ణాంకం.
ఇది స్ట్రింగ్ రకానికి స్ట్రింగ్ (స్ట్రింగ్) ను జోడించడం మాదిరిగానే ఉంటుంది, ఇది ఒక సంగ్రహణ ఆపరేషన్ అవుతుంది మరియు మేము C ++ లో అద్భుతమైన శక్తిని చూస్తాము, ఇది ఆపరేటర్లను మీరు వివరించాలనుకున్నదానిని మీ స్వంత మార్గంలో నిర్వచించటానికి మిమ్మల్ని అనుమతిస్తుంది.
ఉదాహరణకు, మీరు దీర్ఘచతురస్రాల కోసం బీజగణితం రాయడానికి దీనిని ఉపయోగించవచ్చు, మీకు రెండు దీర్ఘచతురస్రాలు ఉండవచ్చు, మీకు ఒక దీర్ఘచతురస్ర రకం ఉంటే మరియు మీరు ఒక దీర్ఘచతురస్రాన్ని ప్రాథమికంగా చేయడానికి రెండు దీర్ఘచతురస్రాల మొత్తాన్ని నిర్వచించవచ్చు.కాబట్టి ఈ దీర్ఘచతురస్రం యొక్క యూనియన్ ఏర్పడుతుంది ఈ దీర్ఘచతురస్రాలు మరియు మొదలైన రెండు పెద్ద దీర్ఘచతురస్రాలను కలిగి ఉంటుంది.
కాబట్టి, స్ట్రింగ్ పరంగా, ఈ లక్షణం C ++ లో లభిస్తుంది, కాబట్టి తీగలతో వ్యవహరించడం చాలా సులభం అవుతుంది.
C లో ప్రత్యేకంగా గమనించండి, C లో, ఫలిత పరిమాణం ఏమిటో మీరు నిజంగా తెలుసుకోవాలి? కాబట్టి, మీరు మళ్ళీ వేరియబుల్ str కోసం ఒక శ్రేణిని విస్తృతంగా నిర్వచించవచ్చు ఎందుకంటే ఇది str పరిమాణంలో సరిపోకపోతే స్ట్రాపీ, స్ట్రాకాట్ తరువాత C ++ లో విఫలమవుతుంది.
మీరు దీన్ని చేసినప్పుడు, మీరు వీటిలో దేనినీ ఇబ్బంది పెట్టవలసిన అవసరం లేదు. వేరియబుల్ స్ట్రింగ్‌ను ఒక రకమైన స్ట్రింగ్‌గా ప్రకటించండి మరియు మీరు దాన్ని str1 + str2 యొక్క గణనతో ప్రారంభించండి.
పైలర్ పరిమాణాన్ని స్వయంచాలకంగా నిర్వహించడానికి భయపడుతుంది మరియు మీకు ఏకకాలంలో ఉండేంత పెద్ద స్ట్రింగ్ ఇస్తుంది.
కాబట్టి, తీగలను నిర్వహించడం చాలా సులభం.
అలాగే, వైర్లను కనెక్ట్ చేయడం లేదా వైర్ల సంగ్రహణ కోసం అదనపు ఆపరేటర్లను ఉపయోగించడం వంటివి నిజంగా ముగియవు, మీరు అనేక ఇతర ఆపరేషన్లు చేయవచ్చు.
స్తవానికి, మీకు సి స్టాండర్డ్ లైబ్రరీలో ఉన్న స్ట్రింగ్ డాట్ హెచ్ ఫంక్షన్ అవసరం లేదు మరియు మీరు స్ట్రింగ్ (స్ట్రింగ్) కాపీ చేసే స్థానంలో అసైన్‌మెంట్‌లను ఉపయోగించవచ్చు, అన్ని తులనాత్మక ఆపరేటర్లు మీరు ఉపయోగించగలది స్ట్రింగ్‌ను ఉపయోగించటానికి బదులుగా కనీసం సమానమైన దానికంటే ఎక్కువ.
స్టాంప్‌ను ఉపయోగించడం చాలా క్లిష్టమైన పని అని మాకు తెలుసు; ఇది రెండు తీగలను తీసుకుంటుంది; కార్డ్ స్టాక్ పాయింటర్లు మరియు రెండు స్ట్రింగ్‌లు మీకు -1 లేదా 0 గా ఉండే విలువను ఇస్తాయి లేదా +1 కావచ్చు, ఏ స్ట్రింగ్ పెద్దది లేదా సమానంగా ఉంటుందో దానిపై ఆధారపడి ఉంటుంది. తీగలను సమానంగా ఉంటే సంభవిస్తుంది.
ఇప్పుడు, మీరు C ++ లో స్ట్రింగ్ రకంతో లేరు, మీరు వీటిలో దేనినైనా పొందాల్సిన అవసరం లేదు.
మీరు పూర్ణాంకాలు లేదా తేలియాడే పాయింట్ సంఖ్యలను పోల్చిన విధంగానే పోలిక ఆపరేటర్లను ఉపయోగించవచ్చు మరియు తీగలను పోల్చవచ్చు.
కాబట్టి, ఇది సి ++ యొక్క చాలా బలమైన లక్షణం మరియు ఇది చాలా అనుకూలమైన పద్ధతి, ముఖ్యంగా స్ట్రింగ్ కోసం.
అందువల్ల, సి ++ గురించి లోతైన అవగాహన లేకుండా, మీరు స్ట్రింగ్ మాత్రమే ఉపయోగించడం ప్రారంభించవచ్చు మరియు మీ అన్ని ప్రోగ్రామ్‌లను తెలివిగా మరియు సులభంగా వ్రాయవచ్చు.
ఈ మాడ్యూల్‌లో మనం చూపించాము - మనం శ్రేణులతో ఎలా పని చేయవచ్చు, వెక్టర్ వాస్తవానికి శ్రేణులను వేరియబుల్ పరిమాణానికి ఎలా సులభతరం చేస్తుంది మరియు స్ట్రింగ్ రకాలను ఉపయోగిస్తుంది C ++ లో తీగలను చాలా సులభంగా ఎలా నిర్వహించాలి.
ప్రామాణిక లైబ్రరీ.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment