C++ rint() ఫంక్షన్

ఈరోజు, C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో పూర్ణాంకాల విలువను చుట్టుముట్టే ముఖ్యమైన ఫంక్షన్‌లలో ఒకదానిని మేము అధ్యయనం చేస్తాము. మేము ఈ రౌండింగ్ పద్ధతిని ఎలా అమలు చేయాలో నేర్చుకుంటాము. అయితే, అంతకు ముందు, C++ యొక్క ప్రాథమికాలను శీఘ్రంగా పరిశీలిద్దాం, తద్వారా వినియోగదారుకు రెండవ ఆలోచన ఉండదు.

C++ అనేది ప్రోగ్రామింగ్ యొక్క విధానపరమైన మరియు సులభంగా అర్థం చేసుకోగలిగే ఆబ్జెక్ట్-ఓరియెంటెడ్ లాంగ్వేజ్, ఇది ప్రోగ్రామ్‌లను అదే ప్రోగ్రామ్‌లో మూల్యాంకనం చేయడానికి కోడ్‌ని అనుమతించే స్పష్టమైన నిర్మాణాన్ని అందిస్తుంది. కానీ కొన్నిసార్లు, మేము పరిష్కరించాలనుకుంటున్న సంక్లిష్ట సమస్య ఉంది. దాని కోసం, సంక్లిష్ట సమస్యను చిన్న భాగాలుగా విభజించడానికి మేము C++లో బహుళ ఫంక్షన్‌లను ఉపయోగిస్తాము, అవి మన ప్రోగ్రామ్‌లో ఉపయోగించిన ఫంక్షన్‌లు. మరియు ఈ రోజు, మేము ముఖ్యమైన ఫంక్షన్లలో ఒకదానిని అధ్యయనం చేస్తున్నాము, ఇది C++లో రింట్() ఫంక్షన్.

పరిచయం

C++లో, rint() ఫంక్షన్ అనేది ముందే నిర్వచించబడిన ఫంక్షన్, ఇది విలువను సమీప పూర్ణాంకం విలువలోకి పూర్తి చేస్తుంది. ఇన్‌పుట్ విలువను పూర్తి చేయడానికి, మేము ప్రస్తుత రౌండింగ్ మోడ్‌ని ఉపయోగిస్తాము, ఇది fesetround() మోడ్. rint() ఫంక్షన్ గురించి మరింత స్పష్టంగా అర్థం చేసుకోవడానికి మరియు తెలుసుకోవడానికి, లోతుగా తీయండి మరియు C++లో ఈ ఫంక్షన్‌ని ఎలా అమలు చేస్తామో చూద్దాం.

వాక్యనిర్మాణం

C++లో rint() ఫంక్షన్ యొక్క వ్రాత శైలి మరియు అమలును అర్థం చేసుకుందాం. మొదట, మేము rint() ఫంక్షన్ యొక్క రిటర్న్ రకాన్ని వ్రాస్తాము. rint() ఫంక్షన్ బ్రాకెట్లలో, మేము ఇన్‌పుట్ వేరియబుల్ యొక్క డేటా రకాన్ని వ్రాస్తాము మరియు ఇన్‌పుట్ పరామితిని పాస్ చేస్తాము, తద్వారా ఇన్‌పుట్ విలువను గుండ్రని పూర్ణాంక రకంలోకి పొందుతాము.

పరామితి

ఇన్‌పుట్_వేరియబుల్: దానిలో ఏదైనా విలువను కలిగి ఉన్న ఏదైనా వేరియబుల్ పేరు కావచ్చు. ఉదాహరణకు, మనకు x పరామితి ఉంది, దానిని మనం పూర్తి చేయాలనుకుంటున్నాము.

లోపాలు మరియు మినహాయింపులు

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

రిటర్న్ విలువ

ప్రతిఫలంగా, మేము ఇన్‌పుట్ విలువ యొక్క గుండ్రని పూర్ణాంకం రకం విలువను పొందుతాము.

ఉదాహరణ 01

మనము C++లో వ్రాసే rint() ఫంక్షన్ యొక్క మా మొదటి మరియు సరళమైన ఉదాహరణను అమలు చేయడం ప్రారంభిద్దాం. rint() ఫంక్షన్‌ని అమలు చేయడానికి మనకు C++ కంపైలర్ అవసరం. కంపైలర్‌ని తెరిచి, కోడ్ రాయడం ప్రారంభించండి.

C++ ప్రోగ్రామ్‌లో, మేము మొదట మా ప్రోగ్రామ్‌కు సంబంధించిన ప్రాథమిక లైబ్రరీలను చేర్చుతాము. ఈ లైబ్రరీలు C++ యొక్క ముందే నిర్వచించబడిన లైబ్రరీలు. లైబ్రరీని తయారు చేయడానికి వందలాది పంక్తులు రాయడానికి బదులుగా ఈ లైబ్రరీలను చేర్చడానికి మేము ఒకే లైన్ కోడ్ రాయాలి. ఫైల్‌ను చేర్చడానికి, మేము మొదట హెడర్ ఫైల్‌ను లోడ్ చేయమని కంపైలర్‌కు తెలియజేసే “#” గుర్తును వ్రాస్తాము, “ఇన్‌క్లూడ్” అనే పదం ప్రోగ్రామ్‌లోని హెడర్ ఫైల్‌ను కలిగి ఉంటుంది మరియు “iostream” వినియోగదారు నుండి డేటాను స్వీకరించడం మరియు ప్రదర్శించడాన్ని సూచిస్తుంది. అది వినియోగదారునికి.

మేము '#include ' ఉపసర్గతో రెండవ హెడర్ ఫైల్‌ను కూడా చేర్చాము, తద్వారా ఇది గణిత ఫంక్షన్ అయినందున మేము రౌండ్ ఫంక్షన్‌ను నిర్వహించగలము. అందుకే మేము 'cmath' లైబ్రరీని ఉపయోగించాము. మొత్తం ప్రోగ్రామ్‌లో ఒకే సందర్భాన్ని ఉపయోగించకుండా తరగతులు, ఫంక్షన్‌లు మరియు వేరియబుల్‌లను ఉంచడానికి, మేము తదుపరి “నేమ్‌స్పేస్ stdని ఉపయోగించడం” ఆదేశాన్ని ఉపయోగించాము.

అప్పుడు మనం ప్రధాన() ఫంక్షన్ రాయడం ప్రారంభిస్తాము ఎందుకంటే ఇక్కడ. మేము కోడ్ యొక్క అసలు లైన్‌ను వ్రాస్తాము లేదా మేము అమలు చేయాలనుకుంటున్న ఫంక్షన్‌ను అమలు చేస్తాము. మెయిన్() ఫంక్షన్ బ్రాకెట్లలో, మేము ఫ్లోట్ టైప్ యొక్క “X మరియు Y” అనే రెండు వేరియబుల్స్‌ని డిక్లేర్ చేసాము మరియు వాటికి వేర్వేరు విలువలను కేటాయించాము. అప్పుడు మనం నిర్వహించాలనుకుంటున్న రౌండ్-ఆఫ్ ఫంక్షన్‌ని పిలుస్తాము, ఇది rint() ఫంక్షన్. మేము మొదట ఫంక్షన్ పేరును వ్రాయడం ద్వారా ఫంక్షన్‌ని పిలుస్తాము, ఇది rint() ఫంక్షన్, ఆపై ఇన్‌పుట్ వేరియబుల్ “X”. ఆపై, మేము కౌట్ () పద్ధతిని వ్రాసి ఫంక్షన్‌ను పాస్ చేయడం ద్వారా వాటిని ప్రింట్ చేస్తాము. వేరియబుల్ 'Y' కోసం మేము అదే చేసాము. మరియు చివరికి, మేము ప్రధాన () ఫంక్షన్‌కు 0ని తిరిగి ఇస్తాము మరియు బ్రాకెట్‌ను మూసివేస్తాము.

ఇక్కడ, మనకు కావలసిన అవుట్‌పుట్ ఉంది, ఇది “X” విలువ 9 మరియు పూర్ణాంకాల రకంలో “Y” విలువ 1.

ఉదాహరణ 02

ఇప్పుడు, C++ భాషలో rint() ఫంక్షన్ యొక్క రెండవ ఉదాహరణకి వెళ్దాం. ఈ ఉదాహరణలో, మేము ప్రస్తుత మోడ్ పద్ధతిని ఉపయోగించాము, ఇది fesetround() మోడ్. fesetround() పద్ధతి ఇన్‌పుట్ విలువను పైకి, క్రిందికి, టోనరెస్ట్ మరియు సున్నా దిశకు మళ్లించే రింట్() ఫంక్షన్‌లో “ప్రస్తుత రౌండింగ్ దిశ”ని సృష్టిస్తుంది.

మేము ప్రోగ్రామ్‌లో అమలు చేసే ఫంక్షన్‌లకు సంబంధించిన కొన్ని ప్రాథమిక లైబ్రరీలను చేర్చాము. డేటాను ఇన్‌పుట్ చేయడానికి మరియు అవుట్‌పుట్ చేయడానికి మొదటి హెడర్ ఫైల్ “#include ”. రెండవ హెడర్ ఫైల్ “#include ” ఎందుకంటే rint() ఫంక్షన్ ఒక గణిత ఫంక్షన్ మరియు మూడవ హెడర్ ఫైల్ “#include ” కాబట్టి మనం మన ప్రోగ్రామ్‌లో fesetround() ఫంక్షన్‌ని ఉపయోగించవచ్చు. అప్పుడు మేము ప్రీప్రాసెసర్ డైరెక్టివ్ “namespace std”ని చేర్చాము.

అప్పుడు మేము ప్రధాన () ఫంక్షన్‌ని పిలుస్తాము మరియు కోడ్ యొక్క అసలు పంక్తిని వ్రాయడం ప్రారంభిస్తాము. మొదట, మేము డబుల్ టైప్ యొక్క వేరియబుల్ “X”ని ప్రకటిస్తాము, ఆపై C++ యొక్క cin() పద్ధతిని ఉపయోగించి వినియోగదారు నుండి విలువను పొందుతాము మరియు దానిని cout() పద్ధతిని ఉపయోగించి ప్రింట్ చేస్తాము. తరువాత, మేము cout() పద్ధతి ద్వారా 'X' యొక్క సమీప గుండ్రని విలువను ప్రింట్ చేయడానికి rint() ఫంక్షన్‌ని పిలుస్తాము.

ఇప్పుడు, మేము విలువలను పైకి మరియు క్రిందికి ముద్రించడానికి fesetround() పద్ధతిని ఉపయోగించాము. దాని కోసం, fesetround() ఫంక్షన్‌కు కాల్ చేసి, ఫంక్షన్ బ్రాకెట్లలో క్యాపిటల్ లెటర్స్‌లో “FE_UPWARD” అని వ్రాసి, cout() పద్ధతిలో rint() ఫంక్షన్‌ని పాస్ చేయడం ద్వారా ప్రింట్ చేయండి. అప్పుడు మేము విలువలను క్రింది దిశలో ప్రింట్ చేస్తాము కాబట్టి fesetround() పద్ధతిని వ్రాసి, పెద్ద అక్షరాలతో “FE_DOWNWARD”ని పాస్ చేయండి మరియు cout() పద్ధతిలో rint() ఫంక్షన్‌ను వ్రాయండి. మరియు చివరికి, ప్రధాన() ఫంక్షన్‌కు 0ని తిరిగి ఇవ్వండి మరియు బ్రాకెట్‌లను మూసివేయండి.

మునుపటి ఉదాహరణ యొక్క అవుట్‌పుట్ చూద్దాం:

ముగింపు

ఈ వ్యాసంలో, మేము C++లో ఫంక్షన్ల పాత్ర గురించి తెలుసుకున్నాము మరియు మేము మా ప్రధాన అంశాన్ని కవర్ చేసాము, ఇది C++లో రింట్() ఫంక్షన్. C++లో rint() ఫంక్షన్ ఎలా పనిచేస్తుందో మరియు fesetround() పద్ధతిని ఉపయోగించి గుండ్రని పూర్ణాంకం విలువను ఎలా పొందాలో తెలుసుకున్నాము. మేము కోడ్ యొక్క ప్రతి లైన్ యొక్క వివరణాత్మక వివరణలో కొన్ని ఉదాహరణలను కూడా అమలు చేసాము, తద్వారా వినియోగదారు ఉదాహరణలను సులభంగా అర్థం చేసుకోగలరు.