ఉదాహరణ 1: “వైల్” లూప్‌ని ఉపయోగించి బైనరీ నుండి దశాంశ ప్రోగ్రామ్
సంఖ్యను బైనరీ నుండి దశాంశానికి మార్చడానికి మేము క్రింది ప్రోగ్రామ్‌ని కలిగి ఉన్నాము. ప్రోగ్రామ్‌లో, బైనరీని దశాంశానికి మార్చడానికి మేము “వేళ” లూప్‌ను ఉపయోగిస్తాము.
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ConversionOfBin ( పొడవు పొడవు ) ;
int ప్రధాన ( ) {
పొడవు పొడవు ఒకదానిపై ;
కోట్ << 'బైనరీ సంఖ్య అవసరం:' ;
ఆహారపు >> ఒకదానిపై ;
కోట్ << ఒకదానిపై << 'బైనరీలో =' << ConversionOfBin ( ఒకదానిపై ) << 'దశాంశంలో' ;
తిరిగి 0 ;
}
int ConversionOfBin ( పొడవు పొడవు ఒకదానిపై ) {
int కాబట్టి = 0 , x = 0 , మిగిలినవి ;
అయితే ( ఒకదానిపై ! = 0 ) {
మిగిలినవి = ఒకదానిపై % 10 ;
ఒకదానిపై / = 10 ;
డిసెంబర్ + = మిగిలినవి * పావు ( 2 , x ) ;
++ x ;
}
తిరిగి కాబట్టి ;
}
ఇక్కడ, మేము ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్‌ల కోసం “iostream” హెడర్ ఫైల్‌ని మరియు ప్రోగ్రామ్‌లోని గణిత ఫంక్షన్‌ను ఉపయోగించుకోవడానికి “cmath”ని నిర్వచించాము. ఆ తర్వాత, 'లాంగ్ లాంగ్' రకం పరామితి పాస్ అయిన చోట ConversionOfBin() ఫంక్షన్‌ని మేము నిర్వచిస్తాము. తరువాత, ప్రోగ్రామ్‌ను అమలు చేయడానికి మనకు ప్రధాన() ఫంక్షన్ కాల్ ఉంది. మేము మెయిన్() ఫంక్షన్ లోపల “num” అని పిలువబడే పొడవైన ఇంటర్ టైప్ వేరియబుల్‌ని ప్రకటిస్తాము.
దీని తరువాత, ConversionOfBin() ఫంక్షన్ ఇన్‌పుట్ బైనరీ సంఖ్యను దశాంశ సంఖ్యగా మారుస్తుంది. దీని కోసం, డ్రైవర్ కోడ్ తర్వాత ConversionOfBin() ఫంక్షన్ యొక్క నిర్వచనం మాకు ఉంది. ConversionOfBin() ఫంక్షన్ బైనరీ సంఖ్యను కలిగి ఉన్న “num” వేరియబుల్‌తో పాస్ చేయబడింది. అప్పుడు, “num”లోని బైనరీ సంఖ్యను దశాంశ విలువకు మార్చడానికి “while” లూప్‌ని పిలుస్తాము. దీనికి ముందు, మేము '0' విలువతో 'deci', 'x,' మరియు 'మిగిలిన' వేరియబుల్స్‌ను ప్రారంభిస్తాము.
'వేళ' లూప్‌లో, బైనరీ సంఖ్య యొక్క కుడివైపున ఉన్న విలువను సూచించడానికి విభజన ఆపరేషన్ నిర్వహించబడుతుంది. విభజన ఫలితాలు 'మిగిలినవి' వేరియబుల్‌లో నిల్వ చేయబడతాయి. అప్పుడు, మేము మిగిలిన ఫలితాలను మరియు శక్తి ఫలితాలను “deci” వేరియబుల్‌లో జోడిస్తాము. “x” వేరియబుల్ 2 యొక్క క్రియాశీల శక్తిని మూల్యాంకనం చేస్తూనే ఉంటుంది.
పేర్కొన్న బైనరీ సంఖ్యలను దశాంశ విలువలకు మార్చడం యొక్క ఫలితాలు C++ కన్సోల్‌లో సాధించబడతాయి:
ఉదాహరణ 2: “ఫర్” లూప్‌ని ఉపయోగించి బైనరీ నుండి దశాంశ ప్రోగ్రామ్
బైనరీ నుండి దశాంశానికి పరివర్తన 'వేళ' లూప్ ఉపయోగించి సాధించబడింది. అయినప్పటికీ, బైనరీ బిట్‌లను దశాంశ సంఖ్యగా మార్చడానికి మనం “ఫర్” లూప్ పద్ధతిని కూడా ఉపయోగించవచ్చు.
#
#
int ప్రధాన ( ) {
std :: స్ట్రింగ్ డబ్బా ;
std :: కోట్ << 'ఇన్‌పుట్ బైనరీ సంఖ్య:' ;
std :: ఆహారపు >> డబ్బా ;
int డిసెంబర్ = 0 ;
int ఆధారం = 1 ;
కోసం ( int a = డబ్బా. పొడవు ( ) - 1 ; a >= 0 ; a -- ) {
ఉంటే ( డబ్బా [ a ] == '1' ) {
డిసెంబర్ + = ఆధారం ;
}
ఆధారం * = 2 ;
}
std :: కోట్ << 'దశాంశంలో ఫలితాలు:' << డిసెంబర్ << std :: endl ;
తిరిగి 0 ;
}
ఇక్కడ, మేము ప్రధాన() ఫంక్షన్ ప్రోగ్రామ్‌తో ప్రారంభిస్తాము, ఇక్కడ మేము “std::string” వేరియబుల్‌ను కలిగి ఉన్నాము, ఇది వినియోగదారు ప్రాంప్ట్‌లో బైనరీ నంబర్ ఇన్‌పుట్‌ను నిల్వ చేయడానికి “బిన్”. ప్రారంభంలో, ప్రాంప్ట్ “కౌట్” స్టేట్‌మెంట్‌ను ఉపయోగించి బైనరీ నంబర్‌ను ఇన్‌పుట్ చేయమని వినియోగదారుని అడుగుతుంది. అప్పుడు, “cin” ఆదేశం ఆ బైనరీ సంఖ్యను చదువుతుంది. ఆ తర్వాత, మేము దశాంశ సమానతను పొందడానికి “0” విలువతో “dec” వేరియబుల్‌ని మరియు “1” విలువతో “baseIs” వేరియబుల్‌ని ప్రారంభిస్తాము.
అప్పుడు, మేము పేర్కొన్న బైనరీ యొక్క ప్రతి సంఖ్యపై కుడి నుండి ఎడమకు లూప్ చేసే 'ఫర్' లూప్ అని పిలుస్తాము. లూప్‌లో, బైనరీ సంఖ్య 1 కాదా అని ధృవీకరించడానికి మనకు “if” షరతు ఉంది. అది 1 అయితే, దశాంశ విలువ “dec” వేరియబుల్‌కు జోడించబడుతుంది. 'baseIs' వేరియబుల్ ప్రతి పునరావృతంలో 1తో గుణించబడే 2 శక్తిని కలిగి ఉంటుంది.
బైనరీ సంఖ్య యొక్క విలువ మరియు దాని దశాంశ విలువగా మార్చడం ప్రాంప్ట్ స్క్రీన్‌పై చూపబడుతుంది:
ఉదాహరణ 3: బైనరీ స్ట్రింగ్ నుండి దశాంశానికి ప్రోగ్రామ్
బైనరీ స్ట్రింగ్ విలువ ఇప్పుడు దాని విలువను దశాంశ విలువగా మార్చడానికి నిర్వచించబడింది. బైనరీ స్ట్రింగ్ విలువను దశాంశ విలువగా మార్చడానికి క్రింది అమలు చేయబడుతుంది:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int binToDec ( స్ట్రింగ్ వాల్ )
{
స్ట్రింగ్ విలువ = విలువ ;
int దశాంశ_విలువ = 0 ;
int ఆధార_విలువ = 1 ;
int మాత్రమే = విలువ. పొడవు ( ) ;
కోసం ( int m = మాత్రమే - 1 ; m >= 0 ; m -- ) {
ఉంటే ( విలువ [ m ] == '1' )
దశాంశ_విలువ + = ఆధార_విలువ ;
ఆధార_విలువ = ఆధార_విలువ * 2 ;
}
తిరిగి దశాంశ_విలువ ;
}
int ప్రధాన ( )
{
స్ట్రింగ్ వాల్ = '11100101' ;
కోట్ << binToDec ( విలువ ) << endl ;
}
ఇక్కడ, బైనరీ అంకెలను దశాంశ విలువలుగా మార్చడానికి మేము BinToDec() ఫంక్షన్‌ని సృష్టించడం ప్రారంభిస్తాము. BinToDec() ఫంక్షన్ స్ట్రింగ్ రకం యొక్క “val” ఆర్గ్యుమెంట్‌ని తీసుకుంటుంది. BinToDec() ఫంక్షన్‌లో, మేము 'val' వేరియబుల్‌తో 'value' వేరియబుల్‌ని ప్రారంభిస్తాము, ఇది 'val' వేరియబుల్ యొక్క విలువ 'value' వేరియబుల్‌లో నిల్వ చేయబడుతుందని సూచిస్తుంది. అప్పుడు, మేము కొత్త వేరియబుల్, “decimal_value”ని ప్రకటిస్తాము, ఇది 0 విలువతో కేటాయించబడుతుంది.
అదేవిధంగా, “base_value” వేరియబుల్ సెట్ చేయబడింది మరియు 1 విలువతో ప్రారంభించబడుతుంది. తర్వాత, బైనరీ సంఖ్య యొక్క పొడవును పొందడానికి పొడవు() ఫంక్షన్‌ని పిలిచే “len” వేరియబుల్‌ని మేము నిర్వచించాము. వేరియబుల్ ప్రారంభించిన తర్వాత, మనకు 'ఫర్' లూప్ పునరావృతం ఉంటుంది. 'ఫర్' లూప్ ప్రతి బైనరీ సంఖ్య అంకెను కుడి నుండి ఎడమకు పునరావృతం చేస్తుంది.
ఆ తర్వాత, మనకు ప్రధాన() ఫంక్షన్ ఉంటుంది, ఇక్కడ బైనరీ సంఖ్య “val” వేరియబుల్‌కు స్ట్రింగ్ విలువగా పేర్కొనబడుతుంది, ఇది మేము “cout” కమాండ్‌తో BinToDec(val) ఫంక్షన్‌ని పిలుస్తున్నందున దశాంశ విలువగా మార్చబడుతుంది.
స్ట్రింగ్-టైప్ బైనరీ విలువ ఇప్పుడు కింది వాటిలో ప్రదర్శించబడిన విధంగా దశాంశ విలువగా మార్చబడింది:
ఉదాహరణ 4: బిట్‌సెట్ క్లాస్‌ని ఉపయోగించి బైనరీ నుండి దశాంశ ప్రోగ్రామ్
అదనంగా, ప్రోగ్రామ్‌లోని C ++ యొక్క “బిట్‌సెట్” తరగతిని నిర్వచించడం ద్వారా బైనరీ సంఖ్యను దశాంశ సంఖ్యగా మార్చవచ్చు. ఇది మార్పిడి ప్రక్రియ చాలా సరళంగా ఉండే ఫంక్షన్‌లను అందిస్తుంది.
##
int ప్రధాన ( ) {
std :: స్ట్రింగ్ బైనరీఐలు ;
std :: కోట్ << 'దయచేసి బైనరీ సంఖ్యను అందించండి:' ;
std :: ఆహారపు >> బైనరీఐలు ;
std :: బిట్‌సెట్ < 64 > బైనరీ ( బైనరీఐలు ) ;
సంతకం చేయలేదు పొడవు దశాంశసంఖ్య = బైనరీ. చాలా పొడవుగా ( ) ;
std :: కోట్ << 'దశాంశ సంఖ్య:' << దశాంశసంఖ్య << std :: endl ;
తిరిగి 0 ;
}
ఇక్కడ, బైనరీ విలువలతో పనిచేసేటప్పుడు చాలా సహాయకారిగా ఉండే హెడర్‌లో C++ యొక్క “బిట్‌సెట్” లైబ్రరీని సెట్ చేసాము. దీని తర్వాత, మేము 'binaryIs' వేరియబుల్‌ని ప్రకటించడానికి 'std:: string'ని ఉపయోగించే ప్రధాన() ఫంక్షన్ డెఫినిషన్‌ని కలిగి ఉంటాము. 'binaryIs' వేరియబుల్ స్ట్రింగ్‌లో బైనరీ విలువను నిల్వ చేస్తుంది. తరువాత, వినియోగదారు ప్రాంప్ట్‌లో బైనరీ సంఖ్యను జోడించమని మేము వినియోగదారుని అడుగుతాము మరియు అది “cin” ఆదేశం ద్వారా చదవబడుతుంది. దీని తరువాత, మేము బిట్‌ల పరిమాణాన్ని సర్దుబాటు చేస్తాము, అది 64 బిట్స్ పూర్ణాంకం కావచ్చు. అప్పుడు, to_ulong() ఫంక్షన్ “బిట్‌సెట్” క్లాస్ నుండి “దశాంశ సంఖ్య” వేరియబుల్‌లోకి పిలువబడుతుంది. to_ulong() ఫంక్షన్ బిట్‌ల సెట్‌ను సంతకం చేయని పొడవైన డేటా రకానికి మారుస్తుంది. చివరగా, వినియోగదారు ఇచ్చిన బైనరీ విలువ యొక్క దశాంశ విలువను ముద్రించడానికి మేము 'cout' ఆదేశాన్ని ఉపయోగిస్తాము.
వినియోగదారు అందించిన బైనరీ విలువ ఇప్పుడు దశాంశ విలువగా మార్చబడింది:
ముగింపు
ముగింపులో, బైనరీ విలువను దశాంశ విలువగా మార్చే పద్ధతులను మేము కవర్ చేసాము. బైనరీని దశాంశానికి మార్చడానికి మేము “ఫర్” లూప్, “వైల్” లూప్ మరియు బిట్‌సెట్ క్లాస్ విధానాలను ఉపయోగించాము. ఈ విధానాలు బైనరీ సంఖ్యలను దశాంశ వ్యవస్థలుగా మారుస్తాయి, ఇది చదవడం మరియు గ్రహణశక్తిని సులభతరం చేస్తుంది.