సి ++ లో టైప్ కన్వర్షన్‌ను ఉత్తమంగా ఎలా అమలు చేయాలి?

ఈ వ్యాసం టైప్ కన్వర్షన్ ఇన్ అనే మరో ఆసక్తికరమైన అంశాన్ని మీకు పరిచయం చేస్తుంది సి ++ మరియు వివరణాత్మక ఆచరణాత్మక ప్రదర్శనతో దాన్ని అనుసరించండి. ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి,

• C ++ లో మార్పిడి టైప్ చేయండి
• అవ్యక్త రకం మార్పిడి
• స్పష్టమైన రకం మార్పిడి
• అసైన్‌మెంట్ ద్వారా మార్చడం
• కాస్ట్ ఆపరేటర్ ఉపయోగించి మార్పిడి

కాబట్టి అప్పుడు ప్రారంభిద్దాం,

C ++ లో మార్పిడి టైప్ చేయండి

రకం మార్పిడి అనేది ఒక రకం నుండి మరొక రకానికి మార్చడాన్ని సూచిస్తుంది. టైప్ మార్పిడి వెనుక ఉన్న ప్రధాన ఆలోచన ఏమిటంటే, ఒక రకం యొక్క వేరియబుల్‌ను మరొక రకానికి చెందిన వేరియబుల్‌తో అనుకూలంగా మార్చడం. ఉదాహరణకు, రెండు వేరియబుల్స్ మొత్తాన్ని కనుగొనడానికి, ఒకటి Int రకం & మరొకటి ఫ్లోట్ రకం. కాబట్టి, మొత్తాన్ని కనుగొనడానికి ఫ్లోట్ రకాన్ని చేయడానికి మీరు కాస్ట్ ఇంట్ వేరియబుల్ ను ఫ్లోట్ చేయడానికి టైప్ చేయాలి. ఈ బ్లాగులో సి ++ లో టైప్ కన్వర్షన్ ఎలా చేయాలో నేర్చుకుంటాము.

C ++ లో, రెండు రకాల రకం మార్పిడి ఉన్నాయి, అనగా అవ్యక్త రకం మార్పిడి & స్పష్టమైన రకం మార్పిడి.

అవ్యక్త రకం మార్పిడి

అవ్యక్త రకం మార్పిడి లేదా ఆటోమేటిక్ రకం మార్పిడి కంపైలర్ చేత స్వంతంగా చేయబడుతుంది. ఒక రకం నుండి మరొక రకానికి టైప్‌కాస్ట్ చేయడానికి వినియోగదారుకు బాహ్య ట్రిగ్గర్ అవసరం లేదు.

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

ఆటోమేటిక్ టైప్ కన్వర్షన్ యొక్క క్రమం క్రింద ఉంది. రకం మార్పిడి కోసం అతి చిన్న నుండి అతిపెద్ద డేటా రకాన్ని కూడా మీరు చెప్పవచ్చు.

bool -> char -> short int -> int -> సంతకం చేయని int -> long -> సంతకం చేయని -> long long -> float -> double -> long double

సంతకం చేసిన రకాన్ని అవ్యక్తంగా సంతకం చేయని రకానికి మార్చినప్పుడు సంకేతాలు కోల్పోవచ్చు మరియు ఎక్కువ కాలం అవ్యక్తంగా ఫ్లోట్‌గా మార్చబడినప్పుడు ఓవర్‌ఫ్లో సంభవిస్తుంది.

C ++ లో అవ్యక్త రకం మార్పిడి ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి ఇప్పుడు ఒక ఉదాహరణ చూద్దాం.

ఉదాహరణ

# నేమ్‌స్పేస్‌ను ఉపయోగించండి // int1 అవ్యక్తంగా ఫ్లోట్ ఫ్లోట్ flt1 = int1 + 2.7 cout గా మార్చబడుతుంది<< 'int1 = ' << int1 << endl << 'char1 = ' << char1 << endl << 'flt1 = ' << flt1 << endl return 0 }

అవుట్పుట్

int1 = 199

చార్ 1 = సి

flt1 = 201.7

C ++ వ్యాసంలో ఈ రకమైన మార్పిడిలో తదుపరిది,

స్పష్టమైన రకం మార్పిడి

స్పష్టమైన రకం మార్పిడి లేదా రకం కాస్టింగ్ అనేది వినియోగదారు నిర్వచించిన రకం మార్పిడి. స్పష్టమైన రకం మార్పిడిలో, వినియోగదారు ఒక రకమైన వేరియబుల్‌ను మరొక రకంగా మారుస్తాడు. స్పష్టమైన రకం మార్పిడి C ++ లో రెండు విధాలుగా చేయవచ్చు:

• అసైన్‌మెంట్ ద్వారా మార్చడం
• కాస్ట్ ఆపరేటర్ ఉపయోగించి మార్పిడి

ఇప్పుడు స్పష్టమైన రకాన్ని ఒక రకాన్ని మరొక రకానికి ప్రసారం చేయడానికి చూద్దాం.

అసైన్‌మెంట్ ద్వారా మార్చడం

ఈ రకమైన మార్పిడిలో అవసరమైన రకాన్ని కుండలీకరణాల్లో వ్యక్తీకరణ ముందు స్పష్టంగా నిర్వచించారు. స్పష్టమైన రకం కాస్టింగ్‌లో డేటా నష్టం జరుగుతుంది. ఇది బలవంతపు కాస్టింగ్‌గా పరిగణించబడుతుంది. ఒక ఉదాహరణ చూద్దాం.

ఉదాహరణ

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {double dbl1 = 8.9 // డబుల్ నుండి int int res = (int) dbl1 + 1 cout కు స్పష్టమైన మార్పిడి<< 'Result = ' << res return 0 }

అవుట్పుట్

ఫలితం = 9

జావాలో ఒక ప్రోగ్రామ్‌ను ఎలా ముగించాలి

C ++ వ్యాసంలో ఈ రకమైన మార్పిడిలో తదుపరిది,

కాస్ట్ ఆపరేటర్ ఉపయోగించి మార్పిడి

కాస్ట్ ఆపరేటర్ అనేది ఒక డేటా రకాన్ని మరొక డేటా రకంగా మార్చడానికి బలవంతం చేసే ఒక అనారి ఆపరేటర్. సి ++ లో నాలుగు రకాల కాస్టింగ్ ఉన్నాయి, అనగా స్టాటిక్ కాస్ట్, డైనమిక్ కాస్ట్, కాన్స్ట్ కాస్ట్ మరియు రీఇన్టెర్ప్రెస్ట్ కాస్ట్.

• స్టాటిక్ కాస్ట్ - ఇది ఉపయోగించగల సరళమైన తారాగణం. ఇది అప్‌కాస్ట్‌లు చేయడమే కాదు, డౌన్‌కాస్ట్‌లు కూడా చేస్తుంది. ఇది కంపైల్ టైమ్ కాస్ట్. మార్చబడిన వస్తువు గమ్యం రకం యొక్క పూర్తి వస్తువు అని హామీ ఇవ్వడానికి రన్‌టైమ్‌లో తనిఖీలు నిర్వహించబడవు.
• డైనమిక్ తారాగణం - రకం మార్పిడి ఫలితం గమ్యం పాయింటర్ రకం యొక్క చెల్లుబాటు అయ్యే, పూర్తి వస్తువుకు సూచిస్తుంది.
• కాన్స్ట్ కాస్ట్ - వస్తువు స్థిరంగా లేదా స్థిరంగా ఉండాల్సిన అవసరం ఉందా అని తారుమారు చేస్తుంది. ఇది స్థిరంగా సెట్ చేయాల్సిన అవసరం ఉందని లేదా తొలగించబడాలని నిర్ధారిస్తుంది.
• తారాగణాన్ని తిరిగి అర్థం చేసుకోండి - సంబంధం లేని తరగతుల నుండి కూడా ఏదైనా పాయింటర్ రకాన్ని ఇతర పాయింటర్ రకానికి మారుస్తుంది. పాయింటర్ సూచించిన పాయింటర్ రకం మరియు డేటా ఒకేలా ఉందో లేదో ఇది తనిఖీ చేయదు.

స్టాటిక్ కాస్ట్ యొక్క ఉదాహరణను చూద్దాం,

ఉదాహరణ

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () cast float flt = 30.11 // కాస్ట్ ఆపరేటర్‌ను ఉపయోగించి int int1 = static_cast (flt) cout< 
 అవుట్పుట్ 
30
ఇది సి ++ లో టైప్ కన్వర్షన్ పై ఈ వ్యాసం చివర మనలను తీసుకువస్తుంది.మీరు ఈ సమాచార మరియు సహాయకారిని కనుగొన్నారని నేను నమ్ముతున్నాను, ఇలాంటి అంశాలపై మరిన్ని ట్యుటోరియల్స్ కోసం వేచి ఉండండి.మీరు మా శిక్షణా కార్యక్రమాన్ని కూడా తనిఖీ చేయవచ్చుj క్వెరీపై దాని వివిధ అనువర్తనాలతో పాటు లోతైన జ్ఞానాన్ని పొందండి, మీరు చేయవచ్చు   24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో ప్రత్యక్ష ఆన్‌లైన్ శిక్షణ కోసం.
 మాకు ప్రశ్న ఉందా? ఈ వ్యాసం యొక్క వ్యాఖ్యల విభాగంలో వాటిని పేర్కొనండి మరియు మేము మీ వద్దకు తిరిగి వస్తాము.