C++లో డేటా రకం మార్పిడి:
టైప్ కాస్టింగ్ అనేది డేటా రకాన్ని కొన్ని ఇతర డేటా రకానికి మార్చే ప్రక్రియ. C++ ప్రోగ్రామింగ్ భాషలో రెండు రకాల కాస్టింగ్ లేదా టైప్ కన్వర్షన్ ఉన్నాయి: అవ్యక్త మరియు స్పష్టమైన కాస్టింగ్. స్వయంచాలక రకం మార్పిడి అనేది అవ్యక్త టైప్‌కాస్టింగ్‌కు మరొక పేరు. ఇది నిజ-సమయ సంకలనం సమయంలో కంపైలర్ ద్వారా నిర్వహించబడుతుంది మరియు వినియోగదారు ఇన్‌పుట్ లేదా చర్య అవసరం లేదు. వ్యక్తీకరణలో రెండు రకాల డేటా రకాలు ఉన్నప్పుడు, ఈ రకమైన కాస్టింగ్ జరుగుతుంది. ఉదాహరణకి:
ఇచ్చిన కోడ్‌లో, చివరి పంక్తి వ్యక్తీకరణలో పూర్ణాంకం వేరియబుల్ మరియు అక్షర వేరియబుల్ చొప్పించబడిందని మరియు పూర్ణాంక వేరియబుల్ “i” విలువ మార్చబడిందని మనం చూడవచ్చు. “a”కి సమానమైన ASCII సంఖ్య అక్షర విలువగా మార్చబడుతుంది మరియు ఈ స్టేట్‌మెంట్‌లోని వేరియబుల్ “i” యొక్క పూర్ణాంక విలువకు జోడించబడుతుంది. వేరియబుల్ “i” విలువ ముద్రించబడితే, ఫలితం ఈ రెండు విలువల మొత్తం అవుతుంది. కంపైలర్ స్వయంచాలకంగా అక్షర వేరియబుల్ యొక్క డేటా రకాన్ని పూర్ణాంక డేటా రకానికి మారుస్తుంది, దానిని కుడి వైపున ఉన్న వర్ణమాల యొక్క ASCII ప్రామాణిక విలువకు మారుస్తుంది, ఇది రన్ టైమ్‌లో అవ్యక్త లేదా స్వయంచాలక రకం మార్పిడికి గొప్ప ఉదాహరణ.
ఇప్పుడు, స్పష్టమైన రకం కాస్టింగ్ లేదా టైప్ కన్వర్షన్ విషయానికి వస్తే, ఇది స్వయంచాలక ప్రక్రియ కాదు; వినియోగదారు తప్పనిసరిగా వేరియబుల్ యొక్క డేటా రకాన్ని కోడ్‌లోని మరొక రకమైన వేరియబుల్‌గా మాన్యువల్‌గా మార్చాలి. డేటా రకాలు సాధారణంగా వాటి మెమరీ స్థలం మరియు అవి కలిగి ఉండే సమాచారం ఆధారంగా ఒక సోపానక్రమంలో అమర్చబడి ఉంటాయి. కాబట్టి, ఏదైనా సమాచారాన్ని నిల్వ చేయడానికి తక్కువ ఆర్డర్ డేటా రకాన్ని ఉపయోగించినప్పుడు కానీ అధిక-ఆర్డర్ డేటా రకంగా మార్చవలసి ఉంటుంది, తద్వారా సమాచార నష్టాన్ని తగ్గించవచ్చు మరియు మరింత ఎక్కువ సమాచారాన్ని నిల్వ చేయవచ్చు, స్పష్టమైన రకం కాస్టింగ్ లేదా టైప్ మార్పిడి సాధారణంగా జరుగుతుంది. పూర్తి. ఉదాహరణకు, పూర్ణాంకాల రకం వేరియబుల్ దశాంశ బిందువు తర్వాత విలువలను నిల్వ చేయలేనందున, మేము పూర్ణాంక వేరియబుల్‌లను ఉపయోగించడం కొనసాగిస్తే కొంత సమాచారాన్ని కోల్పోవచ్చు. ఈ నష్టాన్ని నివారించడానికి, మేము పూర్ణాంక వేరియబుల్‌ను ఫ్లోట్ వేరియబుల్‌గా మారుస్తాము, దశాంశ పాయింట్ల తర్వాత విలువలను సేవ్ చేస్తాము మరియు సమాచార నష్టాన్ని నివారిస్తాము. C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో స్పష్టమైన రకం మార్పిడిని రెండు మార్గాలలో ఒకదానిలో చేయవచ్చు: అసైన్‌మెంట్ ద్వారా లేదా తారాగణం ఆపరేటర్‌ని ఉపయోగించడం ద్వారా. అసైన్‌మెంట్ కన్వర్షన్ కోడ్ ఎక్స్‌ప్రెషన్‌లో జరుగుతుంది మరియు ఈ ఎక్స్‌ప్రెషన్ కోసం సింటాక్స్ క్రింద అందించబడింది.
# “(డేటా రకం) వ్యక్తీకరణ”
పై కోడ్‌లో, మేము తప్పనిసరిగా బ్రాకెట్‌లో చెల్లుబాటు అయ్యే డేటా రకాన్ని ఉంచాలి మరియు బ్రాకెట్ తర్వాత, బ్రాకెట్‌లో వ్రాసిన డేటా రకంగా మనం సవరించాలనుకునే వేరియబుల్ లేదా వ్యక్తీకరణను తప్పనిసరిగా వ్రాయాలి.
ఇప్పుడు మేము C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో తారాగణం ఆపరేటర్లు చేసిన మార్పిడి రకాన్ని పరిశీలిస్తాము. Cast ఆపరేటర్లను unary ఆపరేటర్లు అని కూడా పిలుస్తారు, ఇది వేరియబుల్ దాని డేటా రకాన్ని ఇప్పటికే ఉన్న దాని నుండి మరొకదానికి మార్చడానికి బలవంతం చేస్తుంది. నాలుగు రకాల కాస్టింగ్ కాస్ట్ ఆపరేటర్లు ఉన్నాయి: స్టాటిక్ కాస్ట్, డైనమిక్ కాస్ట్, కాన్స్ట్ కాస్ట్ మరియు రీ-ఇంటర్‌ప్రెట్ కాస్ట్.
C++లో డైనమిక్ కాస్టింగ్:
C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో డైనమిక్ కాస్టింగ్ అనేది RTTI(రన్ టైమ్ టైప్ ఐడెంటిఫికేషన్) అనే కాన్సెప్ట్‌పై ఆధారపడి ఉంటుంది. RTTI అనేది C/C++, Ada మరియు Object Pascal వంటి అనేక ప్రోగ్రామింగ్ భాషలలో ఉన్న ఒక ఫంక్షన్. రన్-టైమ్ టైప్ ఐడెంటిఫికేషన్ లేదా ఇన్ఫర్మేషన్ అనేది ప్రోగ్రామ్ యొక్క రన్ టైమ్‌లో ఆబ్జెక్ట్ యొక్క డేటా రకం వివరాలకు సంబంధించిన సమాచారాన్ని గుర్తించి, సంగ్రహించే ఒక ఫంక్షన్. ఈ ఫంక్షన్ 'టైపీడ్' ఫంక్షన్ లేదా డైనమిక్ టైప్ కాస్టింగ్ వంటి టైప్ కాస్టింగ్ పద్ధతులకు సురక్షితమైన మార్గాన్ని అందిస్తుంది. ఇది రన్ టైమ్‌లో డేటా రకం సమాచారాన్ని గుర్తిస్తుంది మరియు ఆపరేటర్లు ప్లేలో ఉన్నప్పుడు డేటా రకాన్ని మార్చడంలో సహాయపడుతుంది.
రన్-టైమ్ సేఫ్ డౌన్ కాస్టింగ్ కోసం డైనమిక్ కాస్టింగ్ ఎక్కువగా C++లో ఉపయోగించబడుతుంది. డైనమిక్ తారాగణంతో పని చేయడానికి, బేస్ క్లాస్ తప్పనిసరిగా 1 వర్చువల్ ఫంక్షన్‌ని కలిగి ఉండాలి. డైనమిక్ తారాగణం పాలిమార్ఫిక్ బేస్ క్లాస్‌లతో మాత్రమే పని చేస్తుంది, ఎందుకంటే ఇది సురక్షితమైన డౌన్ కాస్టింగ్‌ని నిర్ణయించడానికి ఈ సమాచారాన్ని ఉపయోగిస్తుంది. డైనమిక్ కాస్ట్ ఆపరేటర్ డైనమిక్ కాస్టింగ్ చేస్తాడు. డైనమిక్ కాస్టింగ్‌కు సంబంధించిన కాన్సెప్ట్‌ల గురించి ఇప్పుడు మనకు తెలుసు, మనం అమలు భాగం వైపు వెళ్ళవచ్చు. క్రింద వ్రాయబడిన C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో డైనమిక్ కాస్టింగ్‌ని ఉపయోగించడం కోసం ముందుగా సింటాక్స్‌ను చూద్దాం:
# “డైనమిక్_కాస్ట్ <కొత్త_రకం>(వ్యక్తీకరణ)”పై వ్యక్తీకరణలో, మొదటి భాగం ఆపరేటర్ పేరును వివరిస్తుంది; యాంగిల్ బ్రాకెట్లలో, మన వ్యక్తీకరణను మార్చడానికి అవసరమైన డేటా రకం పేరును వ్రాస్తాము మరియు రౌండ్ బ్రాకెట్లలో, మనం మార్చాలనుకుంటున్న వేరియబుల్ లేదా ఆబ్జెక్ట్ పేరును వ్రాస్తాము.
ఇప్పుడు డైనమిక్ కాస్ట్ ఆపరేటర్‌ను ఎలా ఉపయోగించాలో మరియు డేటా రకాల వేరియబుల్స్‌ను మార్చడానికి పారామితులను ఎలా పూరించాలో మాకు తెలుసు, డేటా రకాలైన వేరియబుల్‌లను మార్చడానికి మేము దానిని ఉపయోగించవచ్చు.
ఉబుంటు 20.04లో డైనమిక్ కాస్ట్ పద్ధతిని ఉపయోగించడం:
ఈ భావనను అమలు చేయడానికి, వారసత్వం ద్వారా తరగతి వస్తువులను మార్చడానికి మేము అనేక తరగతులను ఉపయోగించాలి. కాబట్టి, ముందుగా దీన్ని చేయడానికి, ఉబుంటు ఎన్విరాన్మెంట్‌లోని C++ ప్రోగ్రామ్ ఫైల్ “.cpp” పొడిగింపుతో నిల్వ చేయబడిందని మనం ముందుగా తెలుసుకోవాలి, కాబట్టి ఈ ఫైల్‌ను మా డెస్క్‌టాప్‌లో సృష్టించడానికి, టెర్మినల్‌ను తెరిచి, దానిపై “cd డెస్క్‌టాప్” అని టైప్ చేయండి. కమాండ్ లైన్, ఆపై ఎంటర్ నొక్కండి మరియు “.cpp” పొడిగింపుతో ఫైల్‌ను సృష్టించడానికి “టచ్ ఫైల్ పేరు .cpp” అని టైప్ చేయండి. ఇప్పుడు మనం ఆ ఫైల్‌లో బేస్ క్లాస్ మరియు 2 డెరైవ్డ్ క్లాస్‌లను క్రియేట్ చేయడానికి ఒక కోడ్‌ను వ్రాస్తాము మరియు డ్రైవర్ కోడ్‌లో, మేము డైనమిక్ కాస్ట్ ఆపరేటర్‌ని ఉపయోగిస్తాము.
సేవ్ బటన్‌ను క్లిక్ చేసిన తర్వాత ఫైల్ నుండి నిష్క్రమించండి. టెర్మినల్‌కు తిరిగి వెళ్లి, మీ ఫైల్ పేరు మరియు “.cpp” పొడిగింపుతో “g++” ఆదేశాన్ని ఉపయోగించి ఫైల్‌ను రూపొందించండి. ఈ ఆదేశాన్ని ఉపయోగించి “.out” పొడిగింపుతో ఫైల్ సృష్టించబడుతుంది. మీరు ఇప్పుడు ఆ ఫైల్‌ని “./” ఎంటర్ చేసి మీ “.out” ఎక్స్‌టెన్షన్‌ని నమోదు చేయడం ద్వారా రన్ చేయవచ్చు.
ఈ ప్రోగ్రామ్‌లో, బేస్ క్లాస్ పాయింటర్ ఉత్పన్నమైన క్లాస్ 1 ఆబ్జెక్ట్‌లను (d1) స్టోర్ చేస్తుంది. డైనమిక్ కాస్టింగ్ బేస్ క్లాస్, పాయింటర్ డెరైవ్డ్ 1 ఆబ్జెక్ట్‌ని అలాగే ఉంచింది మరియు దానిని డెరైవ్డ్ క్లాస్ 1కి కేటాయించింది, ఇది చెల్లుబాటు అయ్యే డైనమిక్ కాస్టింగ్‌ను అందించింది.
ముగింపు :
ఈ కథనం C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో ఉపయోగించే టైప్ కాస్టింగ్ పద్ధతిని మాకు నేర్పింది. కాస్టింగ్ రకం కూడా వివరంగా చర్చించబడింది మరియు మేము C++ ప్రోగ్రామింగ్‌లో ఇటువంటి పద్ధతులను ఎందుకు ఉపయోగిస్తాము అనే దానిపై మేము దృష్టి సారించాము. సమాచారాన్ని పొందడం మరియు RTTI అని పిలువబడే సరైన మార్పిడి కోసం ధృవీకరించడం ద్వారా వేరియబుల్ యొక్క డేటా రకాన్ని మార్చడంలో సహాయపడే సహాయక ఫంక్షన్ గురించి మేము చర్చించాము. ఉబుంటు 20.04 వాతావరణంలో C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లోని వ్యక్తీకరణలో డైనమిక్ కాస్ట్ ఆపరేటర్‌ని ఉపయోగించడం ద్వారా మేము డైనమిక్ కాస్టింగ్ భావనను కూడా అమలు చేసాము.