C++లో డేటా రకాలను ఎలా మార్చాలి
C++లో, డేటా రకాలను మార్చడానికి రెండు మార్గాలు ఉన్నాయి:
అవ్యక్త రకం మార్పిడి
C++ కోడ్ కంపైలర్ ద్వారా ముందే నిర్వచించబడిన నియమాల ప్రకారం, వినియోగదారు నుండి ఎటువంటి బాహ్య ట్రిగ్గర్ అవసరం లేకుండా స్వయంచాలకంగా కంపైలర్ ద్వారా నిర్వహించబడే రకం మార్పిడిని అవ్యక్త రకం మార్పిడి అంటారు. ఈ రకమైన మార్పిడి సాధారణంగా ప్రోగ్రామ్‌లో ఒకటి కంటే ఎక్కువ డేటా రకాలు ఉన్నప్పుడు జరుగుతుంది మరియు డేటా రకం వ్యక్తీకరణ ఈ వ్యక్తీకరణలో ఉన్న వేరియబుల్ యొక్క డేటా రకంతో సరిపోలడం లేదు.
మార్పిడి సమయంలో డేటా నష్టాన్ని నివారించడానికి, కంపైలర్ డిఫాల్ట్‌గా తక్కువ ఖచ్చితమైన డేటా రకాన్ని అధిక ఖచ్చితత్వంతో కూడిన డేటా రకంతో మారుస్తుంది. ఉదాహరణకు, డేటా నష్టాన్ని నిరోధించడానికి ఫ్లోట్‌ను పూర్ణాంకంగా మార్చడం కంటే ఇది పూర్ణాంకాన్ని ఫ్లోట్‌గా మారుస్తుంది. దీనినే ప్రమోషన్ అంటారు. వివిధ డేటా రకాల కోసం ప్రాధాన్యత రేఖాచిత్రం క్రిందిది.
రకం మార్పిడి కోసం ఆర్డర్
రకం మార్పిడికి సరైన క్రమం ఇలా ఇవ్వబడింది:
బూల్ -- > చార్ -- > చిన్న పూర్ణం -- > int -- > సంతకం చేయని పూర్తి -- > దీర్ఘ -- > సంతకం చేయని కాలం -- > చాలా కాలం -- > ఫ్లోట్ -- > డబుల్ -- > దీర్ఘ డబుల్
డేటా నష్టాన్ని నిరోధించడానికి తక్కువ ఖచ్చితత్వ రకం వేరియబుల్ హై ప్రెసిషన్ డేటా రకానికి మార్చబడుతుంది.
ఉదాహరణ 1
ఈ ఉదాహరణలో, అవ్యక్త రకం మార్పిడిని ఉపయోగించి వివిధ డేటా రకాల వేరియబుల్‌పై అదనంగా నిర్వహించబడుతుంది.
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int సంఖ్య = 100 ;
చార్ పాత్ర = 'సి' ;
కోట్ << '100 + 'సి' = ' << సంఖ్య + పాత్ర << endl ;
తేలుతుంది విలువ = సంఖ్య + 'c' ;
కోట్ << 'ఫ్లోట్ వాల్ (100 + 'సి') = ' << విలువ << endl ;
int ఉంది = 7890 ;
పొడవు కాదు = ఉంది ;
కోట్ << 'var_int =' << కాదు ;
తిరిగి 0 ;
}
ఇక్కడ ASCII పట్టిక నుండి పూర్ణాంకం మరియు అక్షరం మరియు ఫ్లోట్ సంఖ్య మరియు అక్షరం 'c' జోడించబడ్డాయి. పూర్ణాంకం మూడవ విభాగంలో సుదీర్ఘ డేటా రకంగా ఉంచబడుతుంది మరియు డేటా రకాలు దాని ముందే నిర్వచించిన నియమాల ఆధారంగా కంపైలర్ ద్వారా మార్చబడతాయి.
100 మరియు 'C' మొత్తం 167ను అందిస్తుంది, ఎందుకంటే 'C' సంఖ్యలలో 67కి సమానం మరియు 100+'c' 199ని అందిస్తుంది, చిన్న అక్షరం 'c' 99కి సమానం. Int వేరియబుల్ సుదీర్ఘ డేటా రకంలో నిల్వ చేయబడుతుంది.
ఉదాహరణ 2
ఈ ఉదాహరణలో, విభజన ఆపరేషన్ చేయడానికి D అక్షరం ఫ్లోట్‌గా మార్చబడుతుంది.
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
చార్ x = 'డి' ;
తేలుతుంది ఫ్లోట్_వర్ ;
ఫ్లోట్_వర్ = తేలుతుంది ( x ) / 'c' ;
// పూర్ణాంకాన్ని స్పష్టంగా ఫ్లోట్‌గా మార్చడం.
కోట్ << 'float_var విలువ:' << ఫ్లోట్_వర్ << endl ;
తిరిగి 0 ;
}
ఇన్‌పుట్ విలువ క్యారెక్టర్ D రూపంలో ఉంటుంది, ఇది ఫ్లోట్ డేటా రకంలో నిల్వ చేయబడుతుంది మరియు C అక్షరంతో విభజించబడింది. ఈ అక్షరాలు సంఖ్యా విలువలుగా మార్చబడతాయి మరియు వాటిపై విభజన ఆపరేషన్ చేయబడుతుంది, ఫ్లోట్‌లో విలువను తిరిగి ఇస్తుంది.
స్పష్టమైన రకం మార్పిడి
వినియోగదారు తప్పనిసరిగా C++ యొక్క స్పష్టమైన రకం మార్పిడితో డేటా రకాన్ని మాన్యువల్‌గా మార్చాలి, దీనిని తరచుగా టైప్ కాస్టింగ్ అని పిలుస్తారు. అవ్యక్త రకం మార్పిడిని నివారించడానికి ఈ రకమైన కాస్టింగ్ చేయబడుతుంది. C++లో స్పష్టమైన రకం కాస్టింగ్‌ని నిర్వహించడానికి రెండు పద్ధతులు ఉన్నాయి:
- అసైన్‌మెంట్ ఆపరేటర్‌ని ఉపయోగించి మార్పిడి
- Cast ఆపరేటర్‌ని ఉపయోగించి మార్పిడి
C++లో అసైన్‌మెంట్ ఆపరేటర్‌ని ఉపయోగించి మార్పిడిని టైప్ చేయండి
అసైన్‌మెంట్ ఆపరేటర్‌ని ఉపయోగించి టైప్ మార్పిడి బలవంతంగా చేయబడుతుంది, అంటే ఒక డేటా రకం మరొకదానికి మాన్యువల్‌గా మార్చబడుతుంది. ఇది అసైన్‌మెంట్ ఆపరేటర్ “=”ని ఉపయోగించడం ద్వారా సాధించబడుతుంది, ఇది కుడి చేతి ఆపరేటర్ విలువను దాని ఎడమ వైపున ఉన్న వేరియబుల్‌కు కేటాయిస్తుంది.
ఉదాహరణ
ఈ ప్రోగ్రామ్ టైప్ కాస్టింగ్ ఉపయోగించి సర్కిల్ యొక్క వైశాల్యాన్ని గణిస్తుంది.
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
int వ్యాసార్థం ;
కోట్ <> వ్యాసార్థం ;
తేలుతుంది ప్రాంతం = M_PI * వ్యాసార్థం * వ్యాసార్థం ;
కోట్ << 'వ్యాసార్థంతో వృత్తం యొక్క ప్రాంతం' << వ్యాసార్థం << ' = ' << ప్రాంతం ;
}
పూర్ణాంక డేటా రకంలో వ్యాసార్థం విలువను కలిగి ఉండే ప్రాంతానికి ఫ్లోట్ విలువను కేటాయించడానికి అసైన్‌మెంట్ ఆపరేటర్ ఉపయోగించబడుతుంది.
సర్కిల్ యొక్క వైశాల్యం ఫ్లోట్ డేటా రకంలో అందించబడుతుంది, అయితే వ్యాసార్థం పూర్ణాంక డేటాటైప్‌లో ఇన్‌పుట్ చేయబడుతుంది. అందువలన, అసైన్‌మెంట్ ఆపరేటర్‌ని ఉపయోగించి టైప్ కాస్టింగ్ ద్వారా వేరియబుల్ డేటా రకం మార్చబడుతుంది.
C++లో Cast ఆపరేటర్‌ని ఉపయోగించి మార్పిడిని టైప్ చేయండి
తారాగణం ఆపరేటర్‌ని ఉపయోగించడం ద్వారా రకం మార్పిడి జరుగుతుంది, ఇది ప్రోగ్రామ్ యొక్క అవసరాలకు అనుగుణంగా ఒక డేటా రకాన్ని మరొక రకంగా మార్చడానికి బలవంతం చేస్తుంది.
నలుగురు వేర్వేరు తారాగణం ఆపరేటర్లు ఉన్నారు:
- స్టాటిక్_కాస్ట్
- const_cast
- డైనమిక్_కాస్ట్
- పునర్విమర్శ_కాస్ట్
1: స్టాటిక్_కాస్ట్
స్టాటిక్_కాస్ట్ అనేది కాస్టింగ్ ఆపరేటర్, ఇది ఫ్లోట్‌లు మరియు క్యారెక్టర్‌లను స్పష్టంగా పూర్ణాంకాలుగా మార్చడానికి ఉపయోగించబడుతుంది. ఇది అత్యంత ప్రాథమిక తారాగణం ఆపరేటర్. ఇది ప్రకృతిలో సారూప్యమైన డేటా రకాలను ప్రసారం చేయగలదు. ఇది పాయింటర్‌లను ఒక ఫారమ్ నుండి మరొక ఫారమ్‌కు మార్చగలదు, కాబట్టి ఇది మెమరీ నిర్వహణ కోసం కూడా ఉపయోగించవచ్చు.
వాక్యనిర్మాణం
స్టాటిక్_కాస్ట్ ( వ్యక్తీకరణ ) ఉదాహరణ
ఈ ప్రోగ్రామ్ స్టాటిక్_కాస్ట్ ఉపయోగించి డబుల్ వేరియబుల్‌ను పూర్ణాంక డేటా రకంగా మార్చడానికి రూపొందించబడింది. ఇది అవుట్‌పుట్‌లోని ఏదైనా దశాంశ భాగాన్ని కట్ చేస్తుంది.
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
// వేరియబుల్‌ని ప్రకటించండి
రెట్టింపు p ;
p = 2,905 * 1,235 * 24,675 ;
తేలుతుంది ఫలితం ;
కోట్ << 'స్టాటిక్ కాస్ట్‌ని ఉపయోగించే ముందు:' << endl ;
కోట్ << 'p విలువ =' << p << endl ;
// డేటా రకాన్ని మార్చడానికి స్టాటిక్_కాస్ట్‌ని ఉపయోగించండి
ఫలితం = స్టాటిక్_కాస్ట్ ( p ) ;
కోట్ << 'స్టాటిక్ కాస్ట్‌ని ఉపయోగించిన తర్వాత:' << endl ;
కోట్ << 'ఫలితం విలువ =' << ఫలితం << endl ;
తిరిగి 0 ;
}
ప్రారంభంలో, డబుల్ వేరియబుల్ p ఒకదానికొకటి గుణించబడిన విలువలతో లోడ్ చేయబడుతుంది మరియు ఫలితంగా నిల్వ చేయబడుతుంది. ఫలితం స్టాటిక్_కాస్ట్ ఆపరేటర్‌కు ముందు మరియు అనుసరించిన ఫలితాన్ని కలిగి ఉంది:
స్టాటిక్_కాస్ట్ ఆపరేటర్‌ని ఉపయోగించే ముందు, ఫలితం దశాంశ బిందువులలో ప్రదర్శించబడుతుంది, అయితే ఈ ఆపరేటర్‌ని ఉపయోగించిన తర్వాత అది పూర్ణాంక డేటా రకంలో ప్రదర్శించబడుతుంది.
2: const_cast
ఒక వస్తువు యొక్క స్థిరమైన విలువను స్థిరం కాని రకానికి మార్చడానికి const_cast ఆపరేటర్ ఉపయోగించబడుతుంది. స్థిరమైన వస్తువు ప్రకటించబడిన చోట ఇది ఉపయోగించబడుతుంది మరియు మనం దాని విలువను అప్పుడప్పుడు మార్చవలసి ఉంటుంది.
వాక్యనిర్మాణం
const_cast ( వ్యక్తీకరణ ) ఉదాహరణ
ఈ ఉదాహరణలో, స్థిరమైన క్వాలిఫైయర్‌ను తాత్కాలికంగా తీసివేయడానికి const_cast ఆపరేటర్ ఉపయోగించబడుతుంది మరియు అవసరానికి అనుగుణంగా వేరియబుల్‌లో మార్పులు చేయడానికి అనుమతిస్తుంది:
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
స్థిరంగా int x = 70 ;
స్థిరంగా int * మరియు = & x ;
కోట్ << 'పాత విలువ' << * మరియు << ' \n ' ;
int * తో = const_cast ( మరియు ) ;
* తో = 90 ;
కోట్ << 'కొత్త విలువ' << * మరియు ;
తిరిగి 0 ;
}
స్థిరమైన క్వాలిఫైయర్ పూర్ణాంక వేరియబుల్ xకి కేటాయించబడింది, అంటే ఈ వేరియబుల్ నేరుగా సవరించబడదు. ఆ తర్వాత xని యాక్సెస్ చేయడానికి పాయింటర్ అయిన int *y ఉపయోగించబడుతుంది, కానీ ఇప్పటికీ అది మార్చబడదు మరియు దాని అసలు విలువ కౌట్ ఉపయోగించి ప్రదర్శించబడుతుంది. const_cast ఆపరేటర్‌ని ఉపయోగించి, స్థిరంగా లేని పాయింటర్ z సృష్టించబడుతుంది, ఇది సవరించగలిగేలా x విలువను యాక్సెస్ చేయడానికి ఉపయోగించబడుతుంది. ఇది zకి కేటాయించిన విలువను 90తో మారుస్తుంది, ఇది పరోక్షంగా xలో విలువను మారుస్తుంది.
ప్రారంభంలో, స్థిరమైన వేరియబుల్ x విలువ 70, ఇది const_cast ఆపరేటర్‌ని ఉపయోగించడం ద్వారా సవరించబడుతుంది, ఇది 90 అవుతుంది.
3: డైనమిక్_కాస్ట్
వారసత్వం యొక్క సోపానక్రమంతో, ఇది టైప్-సేఫ్ డౌన్‌కాస్ట్‌గా కూడా సూచించబడుతుంది. డౌన్ కాస్టింగ్ అనేది ఒక సూచన లేదా పాయింటర్‌ను బేస్ క్లాస్ రిఫరెన్స్ లేదా పాయింటర్ నుండి ఉత్పన్నమైన తరగతికి మార్చే ప్రక్రియ.
వాక్యనిర్మాణం
డైనమిక్_కాస్ట్ ( వ్యక్తీకరణ ) ఉదాహరణ
ఈ ఉదాహరణలో, డైనమిక్_కాస్ట్ ఆపరేటర్ పాలిమార్ఫిక్ క్లాస్ రకాన్ని తనిఖీ చేయడానికి ఉపయోగించబడుతుంది మరియు ఇది బేస్ మరియు డెరైవ్డ్ క్లాస్ మెంబర్‌లకు యాక్సెస్‌ను అనుమతిస్తుంది.
# <మినహాయింపు> చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి TBase
{
ప్రజా :
తేలుతుంది బేస్_గ్రా = 9.81 ;
వర్చువల్ శూన్యం డమ్మీ ( )
{
} ;
} ;
తరగతి T ఉత్పన్నం చేయబడింది : ప్రజా TBase
{
ప్రజా :
int స్థానిక_గ్రా = 9.78 ;
} ;
int ప్రధాన ( )
{
TBase * బేస్ = కొత్త T ఉత్పన్నం చేయబడింది ;
T ఉత్పన్నం చేయబడింది * ఉద్భవించింది ;
ఉద్భవించింది = డైనమిక్_కాస్ట్ ( బేస్ ) ;
కోట్ < బేస్_గ్రా << endl ;
కోట్ < స్థానిక_గ్రా << endl ;
getchar ( ) ;
తిరిగి 0 ;
}
రెండు తరగతులు బేస్ మరియు డెరైవ్డ్ తరగతులుగా నిర్వచించబడ్డాయి. TBase* రకం యొక్క పాయింటర్ బేస్ సృష్టించబడుతుంది మరియు TDerived రకం యొక్క డైనమిక్‌గా కేటాయించబడిన వస్తువుకు కేటాయించబడుతుంది. పాలీమార్ఫిజం యొక్క ఈ సందర్భంలో ఉత్పన్నమైన తరగతి వస్తువును బేస్ క్లాస్ పాయింటర్‌కు కేటాయించవచ్చు. TDerived యొక్క చెల్లుబాటు అయ్యే వస్తువును పాయింటర్ యాక్సెస్ చేస్తుందో లేదో dynamic_cast తనిఖీ చేస్తుంది, తారాగణం విజయవంతమైన ఫలితాన్ని పొందినట్లయితే, ఉత్పన్నమైన తరగతి చెల్లుబాటు అయ్యే ఫలితాన్ని పొందుతుంది లేకుంటే అది శూన్య విలువను అందిస్తుంది.
4: రీఇంటర్ప్రెట్_కాస్ట్
reinterpret_cast ఒక డేటా రకం యొక్క పాయింటర్‌ను వేరొక డేటా రకం యొక్క పాయింటర్‌గా మారుస్తుంది. పాయింటర్‌ల డేటా రకాలు ఒకేలా ఉన్నాయో కాదో ఇది తనిఖీ చేయదు. ఈ కాస్టింగ్ ఆపరేటర్‌ని జాగ్రత్తగా ఉపయోగించాలి మరియు నిర్వహించాలి.
ఉదాహరణ
ఈ దృష్టాంతంలో, ఒక డేటా రకం యొక్క పాయింటర్ రీఇంటర్ప్రెట్_కాస్ట్ ఉపయోగించి మరొక డేటా రకం యొక్క పాయింటర్‌గా రీఇంటర్ప్రెట్ చేయబడింది:
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
int * q = కొత్త int ( 70 ) ;
చార్ * చ = పునర్విమర్శ_కాస్ట్ ( q ) ;
కోట్ << * q << endl ;
కోట్ << * చ << endl ;
కోట్ << q << endl ;
కోట్ << చ << endl ;
తిరిగి 0 ;
}
ప్రారంభంలో, పూర్ణాంకం 70 విలువతో కేటాయించబడుతుంది. పాయింటర్ q ఈ డైనమిక్‌గా కేటాయించబడిన పూర్ణాంకాన్ని సూచిస్తుంది. రీఇంటర్ప్రెట్_కాస్ట్ పాయింటర్ qని అక్షర పాయింటర్ ch వలె తిరిగి అర్థం చేసుకోవడానికి ఉపయోగించబడుతుంది, అంటే వాస్తవానికి qకి కేటాయించిన మెమరీ ఇప్పుడు అది అక్షరంగా పరిగణించబడుతుంది. కౌట్ ఆదేశాన్ని ఉపయోగించి, ఇది q మరియు chలకు కేటాయించిన విలువను ముద్రిస్తుంది. ch అక్షర పాయింటర్‌గా పరిగణించబడినందున, అది అక్షర విలువను అందిస్తుంది.
ఇది *ch ఉపయోగించి ch కు సూచించిన విలువను ముద్రిస్తుంది. అయినప్పటికీ, ch అక్షర పాయింటర్‌గా పరిగణించబడుతుంది కాబట్టి, ఈ పంక్తి మెమరీని అక్షరంగా అర్థం చేసుకుంటుంది. ఇది ch ఉపయోగించి పాయింటర్ chలో నిల్వ చేయబడిన మెమరీ చిరునామాను ముద్రిస్తుంది. ఇది q వలె అదే మెమరీ చిరునామా ఎందుకంటే ఇది అదే మెమరీకి పునర్విమర్శ మాత్రమే.
ప్రారంభంలో, పూర్ణాంకం 70ని నిల్వ చేస్తుంది. తరువాత, ఇది పాయింటర్ q మరియు పాయింటర్ ch మధ్య మార్చబడుతుంది. 2 మరియు 4 అవుట్‌పుట్‌లు ఒకే విధంగా ఉంటాయి, ఎందుకంటే రెండవ విలువ reinterpret_castని ఉపయోగించి మళ్లీ అర్థం చేసుకోవచ్చు.
గమనిక : ఈ తారాగణం ఆపరేటర్‌ని పోర్టబుల్ కాని ఉత్పత్తిగా చేసేంత వరకు మరియు ఎక్కువ అవసరం లేని వరకు ఉపయోగించకూడదని సూచించబడింది.
ముగింపు
ఒక వేరియబుల్ యొక్క డేటా రకాన్ని మరొకదానికి మార్చే ప్రక్రియను C++లో టైప్ కన్వర్షన్ లేదా టైప్ కాస్టింగ్ అంటారు. వివిధ డేటా రకాల వేరియబుల్స్‌పై వాటి డేటా రకాలను ఒకదానికొకటి అనుకూలంగా మార్చడం ద్వారా గణిత కార్యకలాపాలను నిర్వహించడానికి ఇది జరుగుతుంది. టైప్ కన్వర్షన్ కోడ్‌ని ఆప్టిమైజ్ చేస్తుంది. C++లో అవ్యక్త మరియు స్పష్టమైన రకం మార్పిడులు ఉన్నాయి. అవ్యక్త రకం మార్పిడి ముందుగా నిర్వచించిన నియమాలను ఉపయోగించి కంపైలర్ ద్వారా నిర్వహించబడుతుంది, అయితే స్పష్టమైన రకం మార్పిడిని ప్రోగ్రామర్ అసైన్‌మెంట్ ఆపరేటర్లు మరియు తారాగణం ఆపరేటర్‌లను ఉపయోగించి నిర్వహిస్తారు.