C++ అనేది అధిక-పనితీరు గల అప్లికేషన్‌ల అభివృద్ధి కోసం ఉపయోగించే అత్యంత ప్రజాదరణ పొందిన మరియు పురాతన ప్రోగ్రామింగ్ భాషలలో ఒకటి. ఇది అత్యంత నిపుణులైన ప్రోగ్రామర్లు మరియు అనుభవం లేని డెవలపర్‌లలో ఉపయోగించబడుతుంది. ఇది ప్రధానంగా గేమ్ డెవలప్‌మెంట్‌లో ఉపయోగించబడుతుంది మరియు ఆపరేటింగ్ సిస్టమ్‌లను అభివృద్ధి చేయడానికి అనువైన ఎంపిక. C++ భాషలో కోడ్‌ను వ్రాసేటప్పుడు, మీరు డేటాను ఒక రకం నుండి మరొక రకానికి మార్చడం చూడవచ్చు. ఈ వ్యాసంలో, మీరు స్ట్రింగ్‌ను పొడవైన పూర్ణాంకంగా మార్చడం నేర్చుకుంటారు. స్ట్రింగ్‌ను ఏదైనా ఇతర ఫార్మాట్‌లోకి మార్చడం చాలా కష్టం. అయినప్పటికీ, C++ ప్రోగ్రామింగ్ లాంగ్వేజ్ స్ట్రింగ్‌లను పూర్ణాంకాలుగా మార్చడానికి త్వరిత మరియు సమర్థవంతమైన మార్గాన్ని అందిస్తుంది.
C++లో stol ఫంక్షన్
Stol అనేది std లైబ్రరీలో అందించబడిన C++ అంతర్నిర్మిత ఫంక్షన్. ఇది తీగలను దీర్ఘ పూర్ణాంక సంఖ్యలుగా మారుస్తుంది. ఇది స్ట్రింగ్ కంటెంట్‌ను పేర్కొన్న బేస్ యొక్క పూర్ణాంక సంఖ్యగా మారుస్తుంది మరియు దీర్ఘ పూర్ణాంక విలువను అందిస్తుంది. ఇది మూడు పారామితులను తీసుకుంటుంది, ఒకటి ఇన్‌పుట్ స్ట్రింగ్, రెండవది ఆబ్జెక్ట్ పారామీటర్ మరియు మూడవది సంఖ్యా ఆధారం. స్టోల్ ఫంక్షన్ యొక్క సింటాక్స్ క్రింద ఇవ్వబడింది, చూడండి:
ఫంక్షన్ stol మూడు పారామితులను తీసుకుంటుంది: input_string, పరిమాణం మరియు బేస్. 'input_string' అనేది దీర్ఘ పూర్ణాంక సంఖ్యగా మార్చాల్సిన ఇన్‌పుట్ స్ట్రింగ్‌ను సూచిస్తుంది.
'పరిమాణం' పరామితి పరిమాణం_t రకం వస్తువును సూచిస్తుంది, ఇది సంఖ్యా విలువ తర్వాత ఇన్‌పుట్ స్ట్రింగ్‌లో తదుపరి అక్షర స్థానాన్ని కలిగి ఉంటుంది. ఉపయోగించాల్సిన అవసరం లేకుంటే అది శూన్య పాయింటర్ కావచ్చు.
మూడవ పరామితి, “బేస్” పరామితి స్ట్రింగ్‌ను అర్థం చేసుకోవలసిన ఆధారాన్ని సూచిస్తుంది. ఉదాహరణకు, “2” బేస్ ఇచ్చినట్లయితే, స్ట్రింగ్ పూర్ణాంకం బేస్ 2 సంఖ్యగా అన్వయించబడుతుంది. బేస్ పరామితి యొక్క డిఫాల్ట్ విలువ 10 మరియు 0 అందించబడితే, ఆ క్రమంలోని ఫార్మాట్ ద్వారా బేస్ విలువ నిర్ణయించబడుతుంది. స్టోల్ ఫంక్షన్ ఇచ్చిన స్ట్రింగ్ యొక్క పూర్ణాంక విలువను సూచించే దీర్ఘ పూర్ణాంక సంఖ్యను అందిస్తుంది.
ఇప్పుడు, C++లో స్టోల్ ఫంక్షన్ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి కొన్ని ఉదాహరణలను అన్వేషిద్దాం.
ఉదాహరణ # 1
ఈ ఉదాహరణలో, స్టోల్ ఫంక్షన్ వాటిని దశాంశ మరియు హెక్సాడెసిమల్ పూర్ణాంక సంఖ్యలుగా ఎలా మారుస్తుందో తనిఖీ చేయడానికి మేము దశాంశ మరియు హెక్సాడెసిమల్ స్ట్రింగ్‌లను అందిస్తాము.
“dec = 123456789” అనేది దశాంశ స్ట్రింగ్ మరియు stol ఫంక్షన్ stol(dec,&size)ని ఉపయోగించి దీర్ఘ పూర్ణాంకంగా మార్చబడుతుంది. ఫంక్షన్‌లో బేస్ ఇన్‌పుట్ పారామీటర్‌గా అందించబడలేదని గమనించండి, ఫలితంగా స్ట్రింగ్‌ను దశాంశ సంఖ్యగా మార్చడానికి డిఫాల్ట్ బేస్ 10ని ఉపయోగిస్తుంది. అయినప్పటికీ, స్ట్రింగ్‌ను హెక్సాడెసిమల్ సంఖ్య నుండి దశాంశ సంఖ్యకు మార్చడం కోసం, ఆధారం 16 ఇన్‌పుట్ పారామితి stol(hex, nullptr, 16)గా అందించబడుతుంది. మనకు తెలిసినట్లుగా, 16 ఆధారం హెక్సాడెసిమల్ సంఖ్యను సూచిస్తుంది.
##
#
int ప్రధాన ( )
{
std :: స్ట్రింగ్ డిసెంబర్ = '123456789' ;
std :: స్ట్రింగ్ హెక్స్ = 'a2bf3c' ;
std :: స్ట్రింగ్ :: పరిమాణ రకము పరిమాణం ;
పొడవు లిడెక్ = std :: పట్టిక ( డిసెంబర్, & పరిమాణం ) ;
పొడవు లిహెక్స్ = std :: పట్టిక ( హెక్స్, nullptr , 16 ) ;
std :: కోట్ << 'ఇన్‌పుట్ దశాంశ స్ట్రింగ్' << డిసెంబర్ << 'దీర్ఘ పూర్ణాంకానికి మార్చబడింది' << లిడెక్ << ' \n ' ;
std :: కోట్ << 'ఇన్‌పుట్ హెక్సాడెసిమల్ స్ట్రింగ్' << హెక్స్ << 'దీర్ఘ పూర్ణాంకానికి మార్చబడింది' << లిహెక్స్ << ' \n ' ;
తిరిగి 0 ;
}
ఇక్కడ క్రింది అవుట్‌పుట్ ఉంది. దశాంశ స్ట్రింగ్ “123456789” “123456789” దశాంశ దీర్ఘ పూర్ణాంకానికి మార్చబడిందని గమనించండి. హెక్సాడెసిమల్ స్ట్రింగ్ “a2bf3c” “10665788” హెక్సాడెసిమల్ సంఖ్యగా మార్చబడింది. స్టోల్ ఫంక్షన్ ద్వారా మార్పిడి ఎలా జరుగుతుందో తెలుసుకోవడానికి మీరు అనుసరించాల్సిన అవసరమైన దశలు ఇక్కడ ఉన్నాయి:
( A2BF3C ) ₁₆ = ( 10 × 16 ⁵ ) + ( రెండు × 16 ⁴ ) + ( పదకొండు × 16 ³ ) + ( పదిహేను × 16 ² ) + ( 3 × 16 ¹ ) + ( 12 × 16 ⁰ ) = ( 10665788 ) ₁₀ 
ఉదాహరణ # 2
ఈ ఉదాహరణలో, మేము స్టోల్ ఫంక్షన్‌ని ఉపయోగించి బైనరీ సంఖ్యను మారుస్తాము. దిగువ కోడ్‌ని చూద్దాం మరియు కోడ్ యొక్క పనిని అర్థం చేసుకుందాం. “1010110110” ఇన్‌పుట్ స్ట్రింగ్‌గా ఇవ్వబడింది మరియు బైనరీ ఆకృతిలో సంఖ్యను సూచించే ఇన్‌పుట్ బేస్ పారామితి stol(బిన్,&సైజ్, 2)గా బేస్ 2 అందించబడింది. స్టోల్ ఫంక్షన్ ఈ దశలను అనుసరించడం ద్వారా బైనరీ సంఖ్యను దశాంశ సంఖ్యగా మారుస్తుంది:
( 1010110110 ) ₂ = ( 1 × రెండు ⁹ ) + ( 0 × రెండు ⁸ ) + ( 1 × రెండు ⁷ ) + ( 0 × రెండు ⁶ ) + ( 1 × రెండు ⁵ ) + ( 1 × రెండు ⁴ ) + ( 0 × రెండు ³ ) + ( 1 × రెండు ² ) + ( 1 × రెండు ¹ ) + ( 0 × రెండు ⁰ ) = ( 694 ) ₁₀ ##
#
int ప్రధాన ( )
{
std :: స్ట్రింగ్ డబ్బా = '1010110110' ;
std :: స్ట్రింగ్ :: పరిమాణ రకము పరిమాణం ;
పొడవు లిబిన్ = std :: పట్టిక ( డబ్బా, & పరిమాణం, రెండు ) ;
std :: కోట్ << 'ఇన్‌పుట్ బైనరీ స్ట్రింగ్' << డబ్బా << 'దీర్ఘ పూర్ణాంకానికి మార్చబడింది' << లిబిన్ << ' \n ' ;
తిరిగి 0 ;
}
సాధారణ బైనరీ నుండి దశాంశ మార్పిడి ప్రక్రియ వలె స్టోల్ ఫంక్షన్ అదే ఫలితాన్ని అందించిందని మీరు చూడగలరు.
ఉదాహరణ # 3
ఈ ఉదాహరణలో, చెల్లని ఇన్‌పుట్‌తో స్టోల్ ఫంక్షన్‌ని పరీక్షిస్తే ఏమి జరుగుతుందో మనం చూడబోతున్నాం. స్టోల్ ఫంక్షన్‌కు బహుళ అక్షరాల స్ట్రింగ్ అందించబడుతుంది మరియు 0 మూల విలువగా అందించబడుతుంది, తద్వారా ఫంక్షన్ స్ట్రింగ్ యొక్క ఆధారాన్ని స్వయంచాలకంగా నిర్ణయిస్తుంది. ఇక్కడ కోడ్ ఉంది:
అక్షరాల సమితి ఇన్‌పుట్ స్ట్రింగ్‌గా అందించబడుతుంది, ఇది ఏ మూల విలువల ద్వారా నిర్ణయించబడదు, అంటే 10, 16, 2, మొదలైనవి. కాబట్టి ఫంక్షన్ లోపం విలువను అందిస్తుంది.
##
#
int ప్రధాన ( )
{
std :: స్ట్రింగ్ chr = 'abcdefgh' ;
std :: స్ట్రింగ్ :: పరిమాణ రకము పరిమాణం ;
పొడవు str = std :: పట్టిక ( chr, nullptr , 0 ) ;
std :: కోట్ << 'ఇన్‌పుట్ క్యారెక్టర్ స్ట్రింగ్' << chr << 'దీర్ఘ పూర్ణాంకానికి మార్చబడింది' << str << ' \n ' ;
తిరిగి 0 ;
}
దిగువ అవుట్‌పుట్ చూడండి. కంపైలర్ 'invalid_argument' మినహాయింపును పెంచిందని గమనించండి, ఎందుకంటే ఫంక్షన్ ఏ మూల విలువతోనూ నిర్ణయించబడని స్ట్రింగ్‌లను అందించదు.
ఉదాహరణ # 4
ఈ ఉదాహరణలో, మేము stol() ఫంక్షన్ ఫలితాన్ని చూడటానికి చెల్లుబాటు అయ్యే మరియు చెల్లని ఇన్‌పుట్ కలయికను అందిస్తాము.
ఇన్‌పుట్ స్ట్రింగ్ చెల్లుబాటు అయ్యే మరియు చెల్లని అక్షరాల కలయిక, “123xf25”. “0” isg ఇన్‌పుట్ బేస్‌గా అందించబడుతుంది, తద్వారా ఫంక్షన్ అక్షరాల రకం ఆధారంగా ఇన్‌పుట్ స్ట్రింగ్ యొక్క ఆధారాన్ని స్వయంచాలకంగా నిర్ణయిస్తుంది.
##
#
int ప్రధాన ( )
{
std :: స్ట్రింగ్ chr = '123xf25' ;
std :: స్ట్రింగ్ :: పరిమాణ రకము పరిమాణం ;
పొడవు str = std :: పట్టిక ( chr, nullptr , 0 ) ;
std :: కోట్ << 'ఇన్‌పుట్ స్ట్రింగ్' << chr << 'దీర్ఘ పూర్ణాంకానికి మార్చబడింది' << str << ' \n ' ;
తిరిగి 0 ;
}
చెల్లుబాటు అయ్యే మరియు చెల్లని ఇన్‌పుట్ కలయికతో స్టోల్ ఫంక్షన్ యొక్క పనిని చూపే అవుట్‌పుట్ ఇక్కడ ఉంది:
ఫంక్షన్ “123”ను దశాంశ సంఖ్య “123”గా మార్చిందని మరియు చెల్లని ఇన్‌పుట్ “x”ని అందుకున్నందున మిగిలిన స్ట్రింగ్‌ను విస్మరించిందని గమనించండి. 'x' అక్షరం తర్వాత స్ట్రింగ్ స్టోల్ ఫంక్షన్ ద్వారా మార్చబడదు, స్ట్రింగ్ యొక్క మొదటి అక్షరాలను మాత్రమే దీర్ఘ పూర్ణాంకానికి అందిస్తుంది.
ముగింపు
ఈ పోస్ట్‌లో, మేము C++ ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క స్టోల్ ఫంక్షన్‌ను అన్వేషించాము. కొన్ని ఉపయోగకరమైన మరియు సరళమైన ఉదాహరణల సహాయంతో, వివిధ రకాల ఇన్‌పుట్‌లతో స్టోల్ ఫంక్షన్ ఎలా పనిచేస్తుందో మేము తెలుసుకున్నాము. స్టోల్ ఫంక్షన్ మూడు పారామితులను తీసుకుంటుంది, మార్చవలసిన ఇన్‌పుట్ స్ట్రింగ్, స్ట్రింగ్‌లోని ఫంక్షన్ యొక్క స్థానాన్ని సూచించే సైజు పరామితి మరియు ఇన్‌పుట్ స్ట్రింగ్ యొక్క ఆధారాన్ని సూచించే మూల విలువ. ఇది ఇన్‌పుట్ స్ట్రింగ్ యొక్క పొడవైన పూర్ణాంక విలువను అందిస్తుంది.