C++ భాష 'int', 'float', 'char', 'double', 'long double' మొదలైన వాటితో పని చేయడానికి అనేక డేటా రకాలను అందిస్తుంది. దశాంశ పాయింట్లను కలిగి ఉన్న సంఖ్యల కోసం 'డబుల్' డేటా రకం ఉపయోగించబడుతుంది '15' లేదా ఘాతాంక విలువలకు. ఇది డబుల్ డేటా రకం అని పిలువబడే ఫ్లోట్ కంటే రెండు రెట్లు ఎక్కువ సమాచారం మరియు డేటాను తీసుకువెళుతుంది. దీని పరిమాణం దాదాపు “8 బైట్లు”, ఫ్లోట్ డేటా రకాన్ని రెట్టింపు చేస్తుంది.
'డబుల్' డేటా రకంతో పని చేస్తున్నప్పుడు మేము సవాళ్లను ఎదుర్కోవచ్చు. మేము డబుల్ డేటా రకాన్ని నేరుగా ప్రింట్ చేయలేము, కాబట్టి 'డబుల్' డేటా రకం యొక్క పూర్తి విలువను ముద్రించడానికి మేము కొన్ని పద్ధతులను ఉపయోగించవచ్చు. దశాంశ బిందువులను కలిగి ఉన్న డబుల్ డేటా రకంతో పని చేస్తున్నప్పుడు మనం “సెట్పెర్సిషన్()” పద్ధతిని ఉపయోగించుకోవచ్చు. ఘాతాంక విలువలను కలిగి ఉన్న డబుల్ డేటా రకం యొక్క ఇతర సందర్భంలో, మేము 'ఫిక్స్‌డ్' లేదా 'సైంటిఫిక్' ఫార్మాట్‌లను ఉపయోగించుకోవచ్చు. ఇక్కడ, మేము ఎటువంటి సాంకేతికతను ఉపయోగించకుండా మరియు ఈ గైడ్‌లో మూడు పద్ధతులను ఉపయోగించడం ద్వారా డబుల్ డేటా రకాలను ముద్రించడం గురించి చర్చిస్తాము.
ఉదాహరణ 1:
ఈ హెడర్ ఫైల్‌లో డిక్లేర్ చేయబడిన ఫంక్షన్‌లతో మనం పని చేయాల్సి ఉన్నందున “iostream” హెడర్ ఫైల్ చేర్చబడిన C++ కోడ్ ఇక్కడ ఉంది. అప్పుడు, మేము 'నేమ్‌స్పేస్ std'ని ఉంచుతాము కాబట్టి మన ఫంక్షన్‌లతో 'std' కీవర్డ్‌ని విడిగా జోడించాల్సిన అవసరం లేదు. అప్పుడు, మేము ఇక్కడ 'ప్రధాన ()' ఫంక్షన్ అయిన ఫంక్షన్‌ను అమలు చేస్తాము. కింది వాటిలో, మేము “var_a” పేరుతో “డబుల్” వేరియబుల్‌ని ప్రకటిస్తాము మరియు ఈ వేరియబుల్‌కి దశాంశ బిందువు విలువను కేటాయిస్తాము. ఇప్పుడు, మేము ఈ డబుల్ విలువను ప్రదర్శించాలనుకుంటున్నాము, కాబట్టి మేము డబుల్ విలువను నిల్వ చేసే చోట ఈ వేరియబుల్‌ను ఉంచడానికి “కౌట్” ను ఉపయోగిస్తాము. అప్పుడు, మేము 'రిటర్న్ 0' జోడిస్తాము.
కోడ్ 1:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( శూన్యం ) {
రెట్టింపు var_a = 7.9765455419016 ;
కోట్ << 'మేము ఇక్కడ ఉంచిన డబుల్ విలువ =' << var_a ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇప్పుడు, ఈ ఫలితంలో మనం మా కోడ్‌లో చొప్పించిన పూర్తి డబుల్ విలువను ఇది ప్రింట్ చేయదని ఇక్కడ గమనించండి. కాబట్టి, C++ ప్రోగ్రామింగ్‌లో డబుల్ డేటా రకంతో పని చేస్తున్నప్పుడు మనం ఎదుర్కొనే సమస్య ఇది.
ఉదాహరణ 2:
ఈ ఉదాహరణలో, మేము దశాంశ బిందువు విలువలకు అంకగణిత చర్యను వర్తింపజేస్తాము మరియు ఫలితాన్ని డబుల్ డేటా రకం విలువగా ప్రదర్శిస్తాము. మేము మొదట అన్ని ప్రామాణిక లైబ్రరీలను కలిగి ఉన్న “bits/stdc++.h” హెడర్ ఫైల్‌ను జోడిస్తాము. అప్పుడు, మేము “నేమ్‌స్పేస్ std”ని ఉపయోగించిన తర్వాత “main()”ని అమలు చేస్తాము. “a” వేరియబుల్ ఇక్కడ “డబుల్” డేటా రకంతో ప్రకటించబడింది మరియు ఈ వేరియబుల్‌కు “1.0/5000” కేటాయించండి. ఇప్పుడు, ఇది ఈ విభజన ఆపరేషన్‌ను డేటాకు వర్తింపజేస్తుంది మరియు ఫలితాన్ని “డబుల్” డేటా రకం యొక్క “a” వేరియబుల్‌లో నిల్వ చేస్తుంది. అప్పుడు, మేము 'cout'ని ఉపయోగించి 'a'లో నిల్వ చేయబడిన ఫలితాన్ని ప్రదర్శిస్తాము.
కోడ్ 2:
#includeఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( శూన్యం ) {
రెట్టింపు a = 1.0 / 5000 ;
కోట్ << 'నా రెట్టింపు విలువ' << a ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇచ్చిన డబుల్ డేటా రకం విలువ యొక్క ఫలితం ఇక్కడ ఉంది. మేము డబుల్ డేటా రకం ఫలితాన్ని అందించే విలువలపై గణిత కార్యకలాపాలను సులభంగా వర్తింపజేస్తాము మరియు వాటిని మా C++ కోడ్‌లో ప్రదర్శిస్తాము.
ఉదాహరణ 3: Setprecision() పద్ధతిని ఉపయోగించడం
ఇక్కడ, మేము 'సెట్‌ప్రెసిషన్' పద్ధతిని వర్తింపజేస్తాము. మేము రెండు హెడర్ ఫైల్‌లను చేర్చుతాము: “iosteam” మరియు “bits/stdc++.h”. “నేమ్‌స్పేస్ std” జోడించబడుతుంది, ఇది మన ప్రతి ఫంక్షన్‌తో వ్యక్తిగతంగా “std” కీవర్డ్‌ని చేర్చకుండా కాపాడుతుంది. “main()” ఫంక్షన్‌ని దీని క్రింద అంటారు. “var_a” వేరియబుల్ ఇప్పుడు దశాంశ బిందువును కలిగి ఉన్న విలువను కలిగి ఉన్న “డబుల్” డేటా రకంతో ప్రకటించబడింది.
మేము పూర్తి సంఖ్యను ప్రదర్శించాలనుకుంటున్నాము కాబట్టి, మేము 'కౌట్' స్టేట్‌మెంట్‌లో 'సెట్‌ప్రెసిషన్()' ఫంక్షన్‌ని ఉపయోగిస్తాము. మేము ఈ ఫంక్షన్ యొక్క పరామితిగా '15'ని పాస్ చేస్తాము. ఈ డబుల్ డేటా రకం విలువలో దశాంశ బిందువు యొక్క విలువల సంఖ్యను సెట్ చేయడంలో ఈ పద్ధతి సహాయపడుతుంది. మేము ఇక్కడ సెట్ చేసిన ఖచ్చితత్వం “15”. కాబట్టి, ఇది దశాంశ బిందువు విలువ యొక్క '15' సంఖ్యలను ప్రదర్శిస్తుంది. అప్పుడు, ఈ “డబుల్” డేటా రకం విలువను ప్రింట్ చేయడానికి “setprecision()” పద్ధతిని ఉపయోగించిన తర్వాత మేము ఈ “cout”లో “var_a”ని ఉంచాము.
కోడ్ 3:
##include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( శూన్యం ) {
రెట్టింపు var_a = 7.9765455419016 ;
కోట్ << నిర్దుష్టత ( పదిహేను ) << 'మేము ఇక్కడ ఉంచిన డబుల్ విలువ =' << var_a ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, మనం కోడ్‌లో నమోదు చేసిన పూర్తి విలువ ప్రదర్శించబడుతుందని మనం చూడవచ్చు. ఎందుకంటే మేము మా కోడ్‌లోని “setprecision()” ఫంక్షన్‌ని ఉపయోగించాము మరియు ఖచ్చితమైన సంఖ్యను “15”కి సెట్ చేసాము.
ఉదాహరణ 4:
“iomanip” మరియు “iostream” అనేవి రెండు హెడర్ ఫైల్‌లు. ఈ హెడర్ ఫైల్‌లో “setprecision()” ఫంక్షన్ ప్రకటించబడినందున “iomanip” ఉపయోగించబడుతుంది. అప్పుడు, 'std' నేమ్‌స్పేస్ చొప్పించబడింది మరియు 'ప్రధాన()'ని ప్రేరేపిస్తుంది. ఇక్కడ ప్రకటించబడిన “డబుల్” డేటా రకం యొక్క మొదటి వేరియబుల్ “dbl_1” మరియు రెండవ వేరియబుల్ పేరు “dbl_2”. మేము వాటిలో దశాంశ బిందువులను కలిగి ఉన్న రెండు వేరియబుల్స్‌కు వేర్వేరు విలువలను కేటాయిస్తాము. ఇప్పుడు, మేము “setpercision()” ఫంక్షన్‌ని ఉపయోగించడం ద్వారా మరియు ఇక్కడ “12”ని పాస్ చేయడం ద్వారా రెండు విలువలకు ఒకే ఖచ్చితమైన సంఖ్యను వర్తింపజేస్తాము.
ఇప్పుడు, రెండు విలువలకు సంబంధించిన ఖచ్చితమైన సంఖ్య “12”కి సెట్ చేయబడింది, అంటే ఈ విలువలు “12” విలువలను ప్రదర్శిస్తాయి. “కౌట్” ఫంక్షన్‌ని ఉంచిన తర్వాత మేము ఈ “సెట్‌ప్రెసిషన్()” ఫంక్షన్‌ని ఉపయోగిస్తాము. దీని క్రింద, మేము 'డబుల్' డేటా రకం యొక్క రెండు విలువలను 'కౌట్'తో ముద్రిస్తాము.
కోడ్ 4:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
రెట్టింపు dbl_1 = 9.92362738239293 ;
రెట్టింపు dbl_2 = 6.68986442623803 ;
కోట్ << నిర్దుష్టత ( 12 ) ;
కోట్ << 'డబుల్ టైప్ నంబర్ 1 =' << dbl_1 << endl ;
కోట్ << 'డబుల్ టైప్ నంబర్ 2 =' << dbl_2 << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇది 12 విలువలను చూపుతుందని మరియు ఈ “డబుల్” డేటా రకం విలువ యొక్క అన్ని ఇతర విలువలను విస్మరించడాన్ని మేము గమనించవచ్చు ఎందుకంటే మేము మా కోడ్‌లో ఖచ్చితమైన విలువను సెట్ చేసాము.
ఉదాహరణ 5:
ఇక్కడ, మేము మూడు వేరియబుల్‌లను ప్రకటిస్తాము: “new_d1”, “new_d2” మరియు “new_d3”. మూడు విలువల డేటా రకం 'డబుల్'. మేము ఈ అన్ని వేరియబుల్స్‌కు విలువలను కూడా కేటాయిస్తాము. ఇప్పుడు, మేము మూడు వేరియబుల్స్ కోసం వేర్వేరు ఖచ్చితమైన విలువలను సెట్ చేయాలనుకుంటున్నాము. 'cout' లోపల 'setprecision()' ఫంక్షన్ యొక్క పరామితిగా '15'ని పాస్ చేయడం ద్వారా మేము మొదటి వేరియబుల్ విలువ కోసం '15'ని సెట్ చేస్తాము. దీని తరువాత, మేము రెండవ వేరియబుల్ విలువ యొక్క ఖచ్చితమైన విలువగా '10'ని సెట్ చేస్తాము మరియు ఈ మూడవ విలువకు '6'ని ఖచ్చితమైన సంఖ్యగా సెట్ చేస్తాము.
కోడ్ 5:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
రెట్టింపు కొత్త_d1 = 16.6393469106198566 ;
రెట్టింపు కొత్త_d2 = 4.01640810861469 ;
రెట్టింపు కొత్త_d3 = 9.95340810645660 ;
కోట్ << 'ఖచ్చితత్వంతో డబుల్ టైప్ నంబర్ 15 =' << నిర్దుష్టత ( పదిహేను ) << కొత్త_d1 << endl ;
కోట్ << 'ఖచ్చితత్వంతో డబుల్ టైప్ నంబర్ 10 =' << నిర్దుష్టత ( 10 ) << కొత్త_d2 << endl ;
కోట్ << 'ఖచ్చితత్వంతో డబుల్ టైప్ నంబర్ 6 =' << నిర్దుష్టత ( 6 ) << కొత్త_d3 << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము అన్నింటికీ వేర్వేరు ఖచ్చితత్వ విలువలను సర్దుబాటు చేస్తాము కాబట్టి మూడు విలువలు ఇక్కడ విభిన్నంగా ఉంటాయి. మేము ఖచ్చితమైన విలువను '15'కి సెట్ చేసినందున మొదటి విలువ '15' సంఖ్యలను కలిగి ఉంది. '10' యొక్క ఖచ్చితత్వ విలువ కారణంగా రెండవ విలువ '10' సంఖ్యలను కలిగి ఉంది మరియు మూడవ విలువ కోడ్‌లో దాని ఖచ్చితత్వ విలువ '6'కి సర్దుబాటు చేయబడినందున ఇక్కడ '6' సంఖ్యలను ప్రదర్శిస్తుంది.
ఉదాహరణ 6:
మేము ఇక్కడ నాలుగు వేరియబుల్స్ ప్రారంభించాము: రెండు దశాంశ బిందువు విలువలతో ప్రారంభించబడ్డాయి మరియు మిగిలిన రెండు ఘాతాంక విలువలతో ప్రారంభించబడతాయి. దీని తరువాత, మేము 'కౌట్' లోపల వాటిని ఉంచడం ద్వారా నాలుగు వేరియబుల్స్లో 'స్థిరమైన' ఆకృతిని వర్తింపజేస్తాము. దీని క్రింద, “శాస్త్రీయ” కీవర్డ్‌ని ఉపయోగించిన తర్వాత “కౌట్” లోపల వాటిని ఉంచడం ద్వారా మేము ఈ వేరియబుల్‌లపై “శాస్త్రీయ” ఆకృతిని విడిగా ఉపయోగిస్తాము.
కోడ్ 6:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
రెట్టింపు my_dbl_1 = 7.7637208968554 ;
రెట్టింపు my_ex_1 = 776e+2 ;
రెట్టింపు my_dbl_2 = 4.6422657897086 ;
రెట్టింపు my_ex_2 = 464e+2 ;
కోట్ << 'స్థిరమైన కీవర్డ్‌ని ఉపయోగించడం ద్వారా' << endl ;
కోట్ << 'మొదటి డబుల్ టైప్ నంబర్ =' << స్థిర << my_dbl_1 << endl ;
కోట్ << 'రెండవ డబుల్ టైప్ నంబర్ =' << స్థిర << my_ex_1 << endl ;
కోట్ << 'మూడవ డబుల్ టైప్ నంబర్ =' << స్థిర << my_dbl_2 << endl ;
కోట్ << 'నాల్గవ డబుల్ టైప్ నంబర్ =' << స్థిర << my_ex_2 << endl ;
కోట్ << endl ;
కోట్ << 'శాస్త్రీయ కీవర్డ్‌ని ఉపయోగించడం ద్వారా:' << endl ;
కోట్ << 'మొదటి డబుల్ టైప్ నంబర్ =' << శాస్త్రీయ << my_dbl_1 << endl ;
కోట్ << 'రెండవ డబుల్ టైప్ నంబర్ =' << శాస్త్రీయ << my_ex_1 << endl ;
కోట్ << 'మూడవ డబుల్ టైప్ నంబర్ =' << శాస్త్రీయ << my_dbl_2 << endl ;
కోట్ << 'నాల్గవ డబుల్ టైప్ నంబర్ =' << శాస్త్రీయ << my_ex_2 << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఫలితం 'డబుల్' డేటా రకం విలువలపై 'ఫిక్స్‌డ్' మరియు 'సైంటిఫిక్' ఫార్మాట్‌లను వర్తింపజేసిన తర్వాత అవుట్‌పుట్‌ను చూపుతుంది. మొదటి నాలుగు విలువలపై 'స్థిరమైన' ఆకృతి వర్తించబడుతుంది. చివరి నాలుగు విలువలపై, “శాస్త్రీయ” ఆకృతి వర్తించబడుతుంది మరియు ఫలితాన్ని ఇక్కడ ప్రదర్శిస్తుంది.
ముగింపు
'ప్రింటింగ్ డబుల్' డేటా రకం భావన ఇక్కడ వివరంగా చర్చించబడింది. మేము C++ ప్రోగ్రామింగ్‌లో “డబుల్” డేటా రకాన్ని ముద్రించడానికి వివిధ పద్ధతులను అన్వేషించాము. 'డబుల్' డేటా రకం విలువలను ముద్రించడంలో మాకు సహాయపడే మూడు విభిన్న పద్ధతులను మేము ప్రదర్శించాము; అవి “సెట్‌ప్రెసిషన్()”, “ఫిక్స్‌డ్” మరియు “సైంటిఫిక్”. మేము ఈ గైడ్‌లోని అన్ని టెక్నిక్‌లను పూర్తిగా అన్వేషించాము.