C++ అనేది చాలా సులభమైన మరియు సులభంగా నేర్చుకోగల భాష ఎందుకంటే ఇది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్, ఇది ప్రోగ్రామ్‌లను నిర్వచించిన నిర్మాణంతో అందిస్తుంది మరియు అదే ప్రోగ్రామ్‌లో కోడ్ రీడబిలిటీని అనుమతిస్తుంది.
పరిచయం
స్ట్రింగ్ అనేది C++ యొక్క డేటాటైప్‌లలో ఒకటి మరియు ఇది అక్షరాలు అని పిలువబడే బహుళ మూలకాల సమాహారం. C++ స్ట్రింగ్ చేసే అనేక ఫంక్షనాలిటీలు ఉన్నాయి, కానీ ఇక్కడ మనకు కొన్ని ఫంక్షన్‌లు ఉన్నాయి, అవి Stold(), stof(), మరియు stod(). ఈ స్ట్రింగ్ ఫంక్షన్‌లు స్ట్రింగ్ విలువను ఇతర డేటాటైప్‌లుగా అన్వయించడానికి లేదా మార్చడానికి ఉపయోగించే అదే కార్యాచరణలను కలిగి ఉంటాయి. ఇప్పుడు, ఈ ఫంక్షనాలిటీలు ఎలా పని చేస్తాయో చూద్దాం.
Std::std
స్ట్రింగ్ ఫంక్షన్ std::stold() అంటే స్ట్రింగ్ విలువను పొడవైన డబుల్‌గా మార్చడం.
వాక్యనిర్మాణం
మొదట, మేము 'లాంగ్ డబుల్' అనే కీవర్డ్‌ను వ్రాస్తాము, ఇది మేము విలువను పొడవైన డబుల్‌గా మారుస్తున్నట్లు చూపుతుంది. ఆ తర్వాత, మనం నిర్వహించాలనుకుంటున్న స్ట్రింగ్ మెథడ్ పేరును వ్రాస్తాము. ఈ సందర్భంలో అది స్టాల్డ్ () ఆపై ఫంక్షన్ బ్రాకెట్లలో, మేము పారామితులను పాస్ చేస్తాము.
పారామితులు
str: మనం లాంగ్ డబుల్‌గా మార్చాలనుకుంటున్న ఇన్‌పుట్ స్ట్రింగ్ విలువ.
పోస్: మొదటి మార్చబడని అక్షర సూచికను ఉంచడానికి ఉపయోగించే పూర్ణాంకం యొక్క చిరునామా.
రిటర్న్ విలువ
ప్రతిఫలంగా, ఇన్‌పుట్ స్ట్రింగ్‌ను మార్చడం ద్వారా మనం పొడవైన డబుల్ టైప్‌లో విలువను పొందుతాము.
ఉదాహరణ
Stold() ఫంక్షన్ యొక్క మొదటి ఉదాహరణను అమలు చేయడం ప్రారంభిద్దాం. ముందుగా, మన ప్రోగ్రామ్‌ను వ్రాయడానికి మరియు అమలు చేయడానికి మనకు C++ కంపైలర్ అవసరం.
C++ ప్రోగ్రామ్‌లో, మేము మొదట హెడర్ ఫైల్‌లను చేర్చుతాము, తద్వారా మేము కోడ్‌ను పదేపదే వ్రాయడాన్ని నివారించవచ్చు మరియు ప్రోగ్రామ్‌ను ఖచ్చితమైన మరియు దృష్టి కేంద్రీకరించడం ద్వారా నిర్వహించవచ్చు. మొదట, మేము '#' గుర్తును వ్రాస్తాము, అది హెడర్ ఫైల్‌ను లోడ్ చేయడానికి కంపైలర్‌ను నిర్దేశిస్తుంది. అప్పుడు, మేము ప్రిప్రాసెసర్ డైరెక్టివ్ 'ఇన్క్లూడ్' వ్రాస్తాము, ఇది అసలు ప్రోగ్రామ్ యొక్క సంకలనానికి ముందు హెడర్ ఫైల్‌ను ప్రాసెస్ చేయమని కంపైలర్‌కు చెప్పడానికి ఉపయోగించబడుతుంది. అప్పుడు మేము హెడర్ ఫైల్ పేరు 'iostream', C++లో ప్రామాణిక ఇన్‌పుట్-అవుట్‌పుట్ ఫంక్షన్‌ని వ్రాస్తాము. ప్రోగ్రామ్‌లో “#include
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ స్ట్రింగ్ = '1.0545' ;
కోట్ << 'ఇన్‌పుట్ స్ట్రింగ్ విలువ:' << str << ' \n ' ;
పొడవు రెట్టింపు a = మొండితనం ( str ) ;
కోట్ << 'ఫలితం దీర్ఘ డబుల్ విలువ:' << a << ' \n ' ;
తిరిగి 0 ;
}
హెడర్ ఫైల్‌ను వ్రాసిన తర్వాత, ప్రోగ్రామ్ యొక్క అసలు లైన్ కోడ్ రాయడం ప్రారంభిద్దాం. మొదట, మేము ప్రధాన () ఫంక్షన్ వ్రాస్తాము. C++లో, ప్రతి ప్రోగ్రామ్‌లో ప్రధాన() ఫంక్షన్ ఉంటుంది మరియు ప్రోగ్రామ్ మెయిన్() ఫంక్షన్‌తో ప్రారంభమవుతుంది. C++ ప్రోగ్రామ్ అమలు చేయబడినప్పుడు, ప్రధాన() ఫంక్షన్ తక్షణ అమలు నియంత్రణను పొందుతుంది. అప్పుడు, మేము వేరియబుల్ “str”ని ప్రకటించాము, దీని డేటాటైప్ “స్ట్రింగ్” మరియు ఆపై మేము “1.0545” అయిన “str”కి విలువను కేటాయించాము. వినియోగదారు స్క్రీన్‌పై విలువను ముద్రించడానికి, మేము “కౌట్” పద్ధతిని ఉపయోగించాము మరియు దానిలోని “str” వేరియబుల్‌ను పాస్ చేసాము. మీరు “కౌట్” పద్ధతి ముగింపులో చూసినట్లుగా, మేము “\n” ఫార్మాట్ స్పెసిఫైయర్‌ని ఉపయోగించాము, తద్వారా మేము ప్రోగ్రామ్ యొక్క తదుపరి కొత్త లైన్‌కి వెళ్లవచ్చు.
మేము అమలు చేయబోయే స్ట్రింగ్ ఫంక్షన్‌ను వ్రాస్తాము, అది Stold() ఫంక్షన్. ముందుగా, మేము ఇన్‌పుట్ స్ట్రింగ్”1.0545”ని మార్చాలనుకుంటున్న డేటాటైప్ పేరు “లాంగ్ డబుల్”ని వ్రాస్తాము. అప్పుడు, మేము పొడవైన డబుల్ స్ట్రింగ్‌ను నిల్వ చేయాలనుకుంటున్న కొత్త వేరియబుల్ “a”ని ప్రకటిస్తాము. అప్పుడు, మేము stold() ఫంక్షన్‌ని పిలిచి, ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్‌గా “str”ని పాస్ చేసాము మరియు “కౌట్” పద్ధతిని ఉపయోగించి దీన్ని ముద్రించాము.
పైన అమలు చేయబడిన ప్రోగ్రామ్ యొక్క కావలసిన అవుట్‌పుట్ ఇక్కడ ఉంది:
Std:: పదార్ధం
స్ట్రింగ్ ఫంక్షన్ std::stof() అంటే స్ట్రింగ్ విలువను ఫ్లోటింగ్ పాయింట్ నంబర్‌గా మార్చడం.
వాక్యనిర్మాణం
ముందుగా, మేము విలువను ఫ్లోట్ డేటాటైప్‌గా మారుస్తున్నట్లు చూపే “ఫ్లోట్” అనే కీవర్డ్‌ని వ్రాస్తాము. ఆపై, మనం చేయాలనుకుంటున్న స్ట్రింగ్ మెథడ్ పేరును వ్రాస్తాము, ఇది స్టోఫ్() ఫంక్షన్. అప్పుడు, ఫంక్షన్ బ్రాకెట్లలో, మేము పారామితులను పాస్ చేస్తాము.
పారామితులు
str: మనం లాంగ్ డబుల్‌గా మార్చాలనుకుంటున్న ఇన్‌పుట్ స్ట్రింగ్ విలువ.
idx: పద్ధతి ఈ పాయింటర్ ద్వారా సూచించబడిన పరిమాణం-t వస్తువు యొక్క విలువను పూర్ణాంక విలువ తర్వాత వచ్చే strలోని మూలకానికి సెట్ చేస్తుంది. ప్రత్యామ్నాయంగా, ఈ ఎంపిక శూన్య పాయింటర్ కావచ్చు, ఈ సందర్భంలో ఇది ఉపయోగించబడదు.
రిటర్న్ విలువ
ప్రతిఫలంగా, ఇన్‌పుట్ స్ట్రింగ్‌ను మార్చడం ద్వారా ఫ్లోటింగ్ పాయింట్ నంబర్ రకంలో విలువను పొందుతాము.
ఉదాహరణ
స్ట్రింగ్ విలువను ఫ్లోట్ టైప్‌గా అన్వయించడానికి ఉపయోగించే స్ట్రింగ్ ఫంక్షన్ stof() యొక్క మరొక ఉదాహరణ ఇక్కడ ఉంది. ఉదాహరణను వివరించడం ద్వారా ప్రారంభిద్దాం, మేము ఈ ప్రోగ్రామ్‌లో అమలు చేయబోయే ఫంక్షన్‌ల కోసం ఫంక్షన్-సంబంధిత హెడర్ ఫైల్‌లను ఎల్లప్పుడూ ముందుగా చేర్చుతాము. ఇక్కడ మనం “#include
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ వాల్ = '2541' ;
కోట్ << 'ఇన్‌పుట్ స్ట్రింగ్ విలువ:' << విలువ << ' \n ' ;
తేలుతుంది res = దుమ్ము ( విలువ ) + 1000,576 ;
కోట్ << 'ఫలితం ఫ్లోట్ విలువ:' << res << ' \n ' ;
తిరిగి 0 ;
}
దీని తరువాత, మేము ప్రధాన () ఫంక్షన్‌ను వ్రాస్తాము, దీనిలో మేము కంపైల్ చేయదలిచిన ప్రోగ్రామ్ యొక్క వాస్తవ కోడ్ లైన్‌ను అమలు చేస్తాము. ప్రధాన() ఫంక్షన్ బాడీలో, మేము టైప్ స్ట్రింగ్ యొక్క “val” అనే వేరియబుల్‌ని ప్రకటించాము మరియు “2541” విలువను “val”కి కేటాయించాము. అప్పుడు, మేము దానిని 'కౌట్' పద్ధతిని ఉపయోగించి ముద్రించాము. మరియు మేము 'stof()' అనే స్ట్రింగ్ ఫంక్షన్‌ను అమలు చేసాము. మొదట, మేము స్ట్రింగ్‌ను మార్చాలనుకుంటున్న డేటాటైప్ పేరు “ఫ్లోట్” ను వ్రాస్తాము మరియు దానిలో ఫంక్షన్ విలువను నిల్వ చేయడానికి ఉపయోగించే మరొక వేరియబుల్ “res” ఉంది. మేము “stof()” ఫంక్షన్‌ని వ్రాసాము, దానిలోని స్ట్రింగ్ వేరియబుల్ “val”ని పాస్ చేసాము మరియు మేము దానిలో ఒక విలువను కూడా జోడించాము. మేము దానిని 'కౌట్' పద్ధతిని ఉపయోగించి ముద్రించాము మరియు చివరికి 0ని ప్రధాన ఫంక్షన్‌కి తిరిగి ఇచ్చాము.
పైన వివరించిన దృష్టాంతం యొక్క అవుట్‌పుట్ చూద్దాం:
Std:: నిలబడ్డ()
స్ట్రింగ్ ఫంక్షన్ std::stod() అంటే స్ట్రింగ్ విలువను డబుల్ టైప్‌గా మార్చడం.
వాక్యనిర్మాణం
మొదట, మేము విలువను డబుల్ డేటాటైప్‌గా మారుస్తున్నట్లు చూపే “డబుల్” అనే కీవర్డ్‌ని వ్రాస్తాము. ఆపై, మేము స్ట్రింగ్ మెథడ్ పేరును వ్రాస్తాము, ఇది స్టాడ్ () ఫంక్షన్, ఆపై ఫంక్షన్ బ్రాకెట్లలో, మేము పారామితులను పాస్ చేస్తాము.
పారామితులు
str: మనం లాంగ్ డబుల్‌గా మార్చాలనుకుంటున్న ఇన్‌పుట్ స్ట్రింగ్ విలువ.
పోస్: మొదటి మార్చబడని అక్షర సూచికను ఉంచడానికి ఉపయోగించే పూర్ణాంకం యొక్క చిరునామా.
రిటర్న్ విలువ
ప్రతిఫలంగా, ఇన్‌పుట్ స్ట్రింగ్‌ను మార్చడం ద్వారా మేము విలువను డబుల్ టైప్‌లో పొందుతాము.
ఉదాహరణ
స్ట్రింగ్ ఫంక్షన్ స్టాడ్() యొక్క ఉదాహరణ ఇక్కడ ఉంది, ఇది స్ట్రింగ్‌ను డబుల్ టైప్‌గా మార్చడానికి ఉపయోగించబడుతుంది. దిగువ-స్నిప్పెట్ కోడ్‌లో ముందుగా, మేము హెడర్ ఫైల్‌లను చేర్చుతాము. ఆపై మనం అందులో “నేమ్‌స్పేస్ std” అని వ్రాస్తాము.
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ x = '835621' ;
కోట్ << 'ఇన్‌పుట్ స్ట్రింగ్ విలువ:' << x << ' \n ' ;
రెట్టింపు తో = నిలబడ్డాడు ( x ) + 2.10 ;
కోట్ << 'ఫలితం డబుల్ విలువ:' << తో << ' \n ' ;
తిరిగి 0 ;
}
మెయిన్() ఫంక్షన్‌లో ముందుగా, మేము “x” అయిన స్ట్రింగ్ టైప్ వేరియబుల్‌ని డిక్లేర్ చేస్తాము మరియు దానికి విలువను కేటాయిస్తాము, తద్వారా మనం స్టోడ్() ఫంక్షన్‌ను నిర్వహించగలము. అప్పుడు, మేము ఇచ్చిన స్ట్రింగ్ “x”ని అన్వయించాలనుకుంటున్న “డబుల్” టైప్ నేమ్‌ను వ్రాస్తాము, ఆపై మేము కొత్త డబుల్ వేరియబుల్ “z”ని ప్రకటించాము మరియు దానిలో స్టోడ్() ఫంక్షన్‌ను నిల్వ చేస్తాము. Stod() ఫంక్షన్‌లో, మేము దానిలోని “x” స్ట్రింగ్‌ను పాస్ చేసాము మరియు దానిలో “2.10” విలువను జోడించాము. ప్రోగ్రామ్ యొక్క అవుట్‌పుట్‌ని చూద్దాం మరియు మనకు ఏమి లభిస్తుందో చూద్దాం:
ముగింపు
ఈ ఆర్టికల్‌లో, C++లో స్ట్రింగ్ అంటే ఏమిటి మరియు C++లో స్ట్రింగ్ ఫంక్షన్‌ను ఎలా అమలు చేయాలో తెలుసుకున్నాము. అప్పుడు మేము stold(), stof(), మరియు stod() ఫంక్షన్‌లను విడిగా వివరించాము, తద్వారా వినియోగదారుకు ఎటువంటి గందరగోళం ఉండదు.