ఉదాహరణ 01:
కాబట్టి, మేము 'nano' సూచనతో 'new.cc' ఫైల్‌ని తెరిచాము. షెల్ యొక్క “టచ్” ప్రశ్నను ఉపయోగించి ఈ ఫైల్ సృష్టించబడింది. ఫైల్ ఇప్పుడు నానో ఎడిటర్‌లో ఖాళీ ఫైల్‌గా ప్రారంభించబడింది. మేము ఎగువన ఇన్‌పుట్-అవుట్‌పుట్ “iostream” హెడర్ ఫైల్‌ను జోడించాము. మా కోడ్ సెట్‌ప్రెసిషన్() పద్ధతిని ఉపయోగించడానికి “iomanip” లైబ్రరీ జోడించబడింది. దీని తర్వాత, మేము ప్రామాణిక నేమ్‌స్పేస్ “std”ని ఉపయోగించాము, మేము కోడ్ మరియు సింటాక్స్ యొక్క ప్రామాణిక మార్గాన్ని ఉపయోగిస్తున్నామని నిర్ధారించుకోవడానికి. C++ కోడ్ యొక్క ప్రధాన() ఫంక్షన్‌లో మొత్తం కోడ్ అమలు చేయబడింది. ఈ ప్రయోజనం కోసం ఏ ఇతర వినియోగదారు నిర్వచించిన ఫంక్షన్ ఉపయోగించబడదు.
ప్రధాన() ఫంక్షన్‌లో, మేము డబుల్ విలువతో డబుల్ టైప్ వేరియబుల్ “v”ని ప్రారంభించాము. మొదటి “కౌట్” స్టాండర్డ్ స్టేట్‌మెంట్ ఎటువంటి అప్‌డేట్ లేకుండా షెల్‌పై అసలు డబుల్ వేరియబుల్ విలువ “v”ని ప్రదర్శిస్తుంది. దీని తర్వాత, ప్రతిదానిలో setprecision() పద్ధతిని ఉపయోగించుకోవడానికి మేము 8 cout స్టేట్‌మెంట్‌లను ఉపయోగించాము. ఇది ప్రతిసారి 'v' వేరియబుల్ యొక్క ప్రతి ఫ్లోటింగ్ పాయింట్‌పై సెట్‌ప్రెసిషన్()ని వర్తింపజేయడం. సెట్‌ప్రెసిషన్ 5 కంటే ఎక్కువ లేదా సమానమైన విలువపై మాత్రమే పని చేస్తుందని మీరు అర్థం చేసుకోవాలి. ఫ్లోటింగ్ పాయింట్ విలువ 5 కంటే పెద్దగా ఉంటే, అది దాని ముందు విలువను పెంచుతుంది.
ఉదాహరణకు, 1వ ఫ్లోటింగ్ పాయింట్ వద్ద సెట్‌ప్రెసిషన్() పాయింట్ తర్వాత “5”ని పూర్తి చేస్తుంది మరియు “4” విలువ 5కి మార్చబడుతుంది. అదేవిధంగా, 2వ ఫ్లోటింగ్ పాయింట్ విలువ “2”ని రౌండ్ చేయడం సాధ్యం కాదు, 3వ ఫ్లోటింగ్ పాయింట్ విలువ “7” విలువ “2”ని “3”కి మారుస్తుంది, 4వ ఫ్లోటింగ్ పాయింట్ విలువ “4”ని రౌండ్ చేయడం సాధ్యం కాదు మరియు 5వ ఫ్లోటింగ్ పాయింట్ విలువ “9” విలువ “4ని మారుస్తుంది. ” దాని ముందు 5కి. “0” పాయింట్ వద్ద “4” విలువను 5కి మారుస్తుంది. ప్రతికూల సెట్‌ప్రెసిషన్() మొత్తం వాస్తవ విలువను ప్రదర్శించడం తప్ప మరేమీ చేయదు. ఫ్లోటింగ్ పాయింట్లు 0 నుండి 5 మరియు -1, -2 వద్ద ఉన్న అన్ని విలువలు సెట్‌ప్రెసిషన్()ని వర్తింపజేసిన తర్వాత ప్రదర్శించబడతాయి.
ఇది g++ కంపైలేషన్ క్వెరీ మరియు “./a.out” ఎగ్జిక్యూషన్ క్వెరీతో సెట్‌ప్రెసిషన్ C++ కోడ్‌ని కంపైల్ చేయడానికి మరియు రన్ చేయడానికి సమయం ఆసన్నమైంది. మొదటి సెట్‌ప్రెసిషన్(1) 4 నుండి 5ని మారుస్తుందని అవుట్‌పుట్ చూపిస్తుంది. సెట్‌ప్రెసిషన్(2) ఏమీ చేయలేదు మరియు “4.5”ని ప్రదర్శిస్తుంది. సెట్‌ప్రెసిషన్(3) విలువను “4.52” నుండి “4.53”కి పెంచింది. సెట్‌ప్రెసిషన్(4) విలువ “4.527”కి ఏమీ చేయదు. సెట్‌ప్రెసిషన్(5) విలువను “4.5274” నుండి “4.5275”కి పెంచుతుంది. సెట్‌ప్రెసిషన్(0) విలువను 5కి పెంచింది. సెట్‌ప్రెసిషన్(-1) మరియు సెట్‌ప్రెసిషన్(-2) క్రింద చూపిన విధంగా ఏమీ చేయలేదు:
$ g++ new.cc$. / a.out
ఉదాహరణ 02:
మరొక ఉదాహరణను పరిశీలిద్దాం. కోడ్ పైన పేర్కొన్న ఉదాహరణకి సారూప్యంగా ఉంటుంది, దాని కౌట్ స్టేట్‌మెంట్‌లలో మాత్రమే మార్పు ఉంటుంది. మొదటి కౌట్ అసలు విలువలను చూపుతుంది, అయితే తదుపరి రెండు ఫ్లోటింగ్ పాయింట్లు 1 మరియు 5 వద్ద సెట్‌ప్రెసిషన్() ఫలితాన్ని చూపుతాయి. చివరి కౌట్ భౌతికంగా అందుబాటులో లేని ఫ్లోటింగ్ పాయింట్ 9 వద్ద సెట్‌ప్రెసిషన్() పద్ధతి యొక్క ఫలితాన్ని ప్రదర్శిస్తుంది. 1 మరియు 5 ఫ్లోటింగ్-పాయింట్ ఫలితాలు చాలా అంచనా వేయబడ్డాయి, కానీ మేము ఫ్లోటింగ్ పాయింట్ 9 గురించి ఏమీ చెప్పలేము. ఫైల్‌ని అమలు చేసి, ఈ కోడ్ అవుట్‌పుట్ ఎలా ఉంటుందో చూద్దాం:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
రెట్టింపు లో = 4.52749 ;
కోట్ << 'నిశ్చయతకు ముందు విలువ :' << లో << ' \n ' ;
కోట్ << నిర్దుష్టత ( 1 ) << 'వాల్ ఎట్ 1:' << లో << ' \n ' ;
కోట్ << నిర్దుష్టత ( 5 ) << 'వాల్యూమ్ ఎట్ 5:' << లో << ' \n ' ;
కోట్ << నిర్దుష్టత ( 9 ) << 'వాల్ ఎట్ 9:' << లో << ' \n ' ;
తిరిగి 0 ;
}
ఈ కోడ్‌ని సంకలనం చేసి అమలు చేసిన తర్వాత, ఫ్లోటింగ్ పాయింట్ విలువ “4.52749” 1 మరియు 3 స్థానాలపై సెట్‌ప్రెసిషన్ కోసం మాకు స్పష్టమైన ఫలితాలు ఉన్నాయి. సెట్‌ప్రెసిషన్ 9 ఫలితం డబుల్ వేరియబుల్ “v” యొక్క వాస్తవ విలువను చూపుతుంది. లొకేషన్ 9కి సంబంధించిన విలువ స్థిరంగా లేకపోవడమే దీనికి కారణం కావచ్చు:
$ g++ new.cc$. / a.out
వేరియబుల్ “v” విలువలను సరిచేయడానికి కోడ్‌ని మళ్లీ అప్‌డేట్ చేద్దాం. కాబట్టి, వేరియబుల్ యొక్క 1వ స్థానంలో వర్తింపజేసిన మొదటి సెట్‌ప్రెసిషన్() కౌట్ స్టేట్‌మెంట్ తర్వాత, మేము కౌట్‌లో ఫిక్స్‌డ్ వేరియబుల్‌ని ఉపయోగించాము:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
రెట్టింపు లో = 4.52749 ;
కోట్ << 'నిశ్చయతకు ముందు విలువ :' << లో << ' \n ' ;
కోట్ << నిర్దుష్టత ( 1 ) << 'వాల్ ఎట్ 1:' << లో << ' \n ' ;
కోట్ << స్థిర ;
కోట్ << నిర్దుష్టత ( 5 ) << 'వాల్యూమ్ ఎట్ 5:' << లో << ' \n ' ;
కోట్ << నిర్దుష్టత ( 9 ) << 'వాల్ ఎట్ 9:' << లో << ' \n ' ;
తిరిగి 0 ;
}
ఈ అప్‌డేట్ చేయబడిన కోడ్‌ని కంపైల్ చేసి, అమలు చేసిన తర్వాత, వేరియబుల్ “v” యొక్క లొకేషన్ 9లో సెట్‌ప్రెసిషన్ యొక్క స్థిర ఫలితాన్ని మేము కలిగి ఉన్నాము, అంటే, 4.527490000:
$ g++ new.cc$. / a.out
ముగింపు:
చివరగా, డబుల్ వేరియబుల్ యొక్క విలువను రౌండ్ ఆఫ్ చేయడానికి మరియు ప్రదర్శించడానికి C++ కోడ్‌లోని setprecision() పద్ధతిని ఉపయోగించడం గురించి ఇదంతా జరిగింది. మేము కోడ్‌లోని స్థిర వేరియబుల్స్ మరియు వాటి ప్రయోజనాలను కూడా వివరించాము. అదనంగా, మేము C++లో సెట్ ప్రెసిషన్ భావనను వివరించడానికి రెండు ముఖ్యమైన ఉదాహరణలను అమలు చేసాము. ఈ కథనం మీకు ఉపయోగకరంగా ఉందని మేము ఆశిస్తున్నాము. మరిన్ని చిట్కాలు మరియు ట్యుటోరియల్‌ల కోసం ఇతర Linux సూచన కథనాలను చూడండి.