ఉదాహరణ 1:
ఈ C++ కోడ్‌లో, “iostream” మరియు “cmath” హెడర్ ఫైల్‌లు చేర్చబడ్డాయి. 'iostream' హెడర్ ఫైల్ అనేది 'iostream' హెడర్ ఫైల్‌లో ఈ విధులు నిర్వచించబడినందున cin\cout ఫంక్షన్‌లను ఉపయోగించడం ద్వారా ఇన్‌పుట్\అవుట్‌పుట్ ఆపరేషన్‌లను నిర్వహించడం. డేటాపై గణిత కార్యకలాపాలను నిర్వహించడానికి “cmath” హెడర్ ఫైల్ ఇక్కడ జోడించబడింది. 'నేమ్‌స్పేస్ std' ముందు ఉంచబడింది. అప్పుడు, డ్రైవర్ కోడ్ జోడించబడుతుంది, ఇది 'ప్రధాన ()'. దీని క్రింద, మేము 'ఫ్లోట్' డేటా రకంతో 'num'ని ఉపయోగిస్తాము. మనం ఇక్కడ సెట్ చేసిన “సంఖ్య” విలువ “4.6”.
అప్పుడు, మేము అందులో నమోదు చేసిన డేటాను ప్రింట్ చేసే “కౌట్()” ఫంక్షన్‌ను జోడిస్తాము. ముందుగా, మనం గతంలో ప్రారంభించిన ఫ్లోట్ నంబర్‌ను ప్రదర్శిస్తాము. అప్పుడు, మేము “floor()” ఫంక్షన్‌ని ఉపయోగించుకుంటాము మరియు ఈ “floor()” ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్‌గా “num”ని పాస్ చేస్తాము. మేము 'ఫ్లోర్ ()' ఫంక్షన్‌ను వర్తింపజేసిన తర్వాత ఫలితాన్ని కూడా ముద్రిస్తాము.
కోడ్ 1:
#include
#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
తేలుతుంది ఒకదానిపై = 4.6 ;
కోట్ << 'సంఖ్య ఇది' << ఒకదానిపై << endl ;
కోట్ << 'ఈ సంఖ్య యొక్క అంతస్తు:' << అంతస్తు ( ఒకదానిపై ) << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ అవుట్‌పుట్‌లో, సంఖ్య “4.6”. కానీ మేము 'ఫ్లోర్ ()' పద్ధతిని వర్తింపజేసినప్పుడు, అది '4' ఫలితాన్ని ఇస్తుంది. ఇది “floor()” పద్ధతి అందించిన సంఖ్య కంటే తక్కువ లేదా సమానమైన సంఖ్యను అందిస్తుంది.
ఉదాహరణ 2:
ఇక్కడ, మేము 'iostream' మరియు 'cmath' అనే రెండు హెడర్ ఫైల్‌లను చేర్చాము. అప్పుడు, మేము 'namespace std'ని ఉంచాము మరియు 'main()' ఫంక్షన్‌ని ప్రకటిస్తాము. దీని తరువాత, మేము 'ఫ్లోట్' డేటా రకంతో నాలుగు వేరియబుల్స్ డిక్లేర్ చేస్తాము. ఈ వేరియబుల్స్‌కు “num_1”, “num_2”, “num_3” మరియు “num_4” అని పేరు పెట్టారు. మేము “4.9”ని “num_1”కి, “-6.4”ని “num_2”కి, “5.1”ని “num_3”కి మరియు “8”ని “num_4”కి కేటాయిస్తాము. అప్పుడు, మేము “num_1” వేరియబుల్‌పై “floor()” ఫంక్షన్‌ని వర్తింపజేస్తాము మరియు ఈ నంబర్‌పై “floor()” ఫంక్షన్‌ని వర్తింపజేసిన తర్వాత మనకు లభించిన ఫలితాన్ని అలాగే విలువను ప్రింట్ చేస్తాము. అదే విధంగా, మేము 'ఫ్లోర్()' ఫంక్షన్ నుండి పొందిన అన్ని విలువలను మరియు ఈ విలువలను దాని వాదనగా ఈ ఫంక్షన్‌లో ఉంచడం ద్వారా వాటిని ముద్రిస్తాము.
కోడ్ 2:
#include#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
తేలుతుంది num_1, num_2, num_3, num_4 ;
సంఖ్య_1 = 4.9 ;
సంఖ్య_2 = - 6.4 ;
సంఖ్య_3 = 5.1 ;
సంఖ్య_4 = 8 ;
కోట్ << 'మొదటి సంఖ్య' << సంఖ్య_1 << 'మరియు దాని అంతస్తు ' << అంతస్తు ( సంఖ్య_1 ) << endl ;
కోట్ << 'రెండవ సంఖ్య' << సంఖ్య_2 << 'మరియు దాని అంతస్తు ' << అంతస్తు ( సంఖ్య_2 ) << endl ;
కోట్ << 'మూడవ సంఖ్య' << సంఖ్య_3 << 'మరియు దాని అంతస్తు ' << అంతస్తు ( సంఖ్య_3 ) << endl ;
కోట్ << 'నాల్గవ సంఖ్య' << సంఖ్య_4 << 'మరియు దాని అంతస్తు ' << అంతస్తు ( సంఖ్య_4 ) << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
“ఫ్లోర్()” ఫంక్షన్‌ని వర్తింపజేసిన తర్వాత “4.9” విలువ “4”ని అందిస్తుంది. అప్పుడు, మేము ఈ “ఫ్లోర్()” ఫంక్షన్‌లో “-6.4”ని ఉంచాము మరియు ఇది క్రింది చూపిన విధంగా “-7”ని అందిస్తుంది. 'ఫ్లోర్()' పద్ధతిని వర్తింపజేసిన తర్వాత '5.1' సంఖ్య యొక్క ఫలితం '5'. అదే ఫలితం ఫ్లోర్ విలువగా “8” రిటర్న్స్ “8”గా చూపబడింది:
ఉదాహరణ 3:
ఇక్కడ, మేము పూర్ణాంక విలువలపై “ఫ్లోర్()” ఫంక్షన్‌ను వర్తింపజేస్తాము. ముందుగా, మేము 'value_1' మరియు 'value_2' పేరుతో పూర్ణాంక వేరియబుల్స్‌ని ప్రారంభిస్తాము. “value_1” “5”తో ప్రారంభించబడింది మరియు “value_2” “-8”తో ప్రారంభించబడింది. దీని తరువాత, మేము 'కౌట్' ను ఉంచుతాము, ఇక్కడ మేము 'ఫ్లోర్ ()' ఫంక్షన్‌ను జోడిస్తాము, దీనిలో మేము మొదటి 'కౌట్' స్టేట్‌మెంట్‌లో 'విలువ_1'ని పాస్ చేస్తాము. తదుపరి “కౌట్”లో, మేము “ఫ్లోర్()”ని ఉపయోగిస్తాము, ఇక్కడ మనం “విలువ_2”ని పారామీటర్‌గా పాస్ చేస్తాము. ఇప్పుడు, ఇది ఈ విలువలపై “ఫ్లోర్()” ఫంక్షన్‌ను వర్తింపజేస్తుంది మరియు వాటిని స్క్రీన్‌పై ప్రింట్ చేస్తుంది.
కోడ్ 3:
#include#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
int విలువ_1, విలువ_2 ;
విలువ_1 = 5 ;
విలువ_2 = - 8 ;
కోట్ << 'మొదటి పూర్ణాంకం సంఖ్య' << విలువ_1 << 'మరియు దాని అంతస్తు ' << అంతస్తు ( విలువ_1 ) << endl ;
కోట్ << 'రెండవ పూర్ణాంకం సంఖ్య' << విలువ_2 << 'మరియు దాని అంతస్తు ' << అంతస్తు ( విలువ_2 ) << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఫలితం “ఫ్లోర్()” ఫంక్షన్‌ను కంప్యూట్ చేసిన తర్వాత “5” విలువ “5” ఇస్తుందని మరియు “ఫ్లోర్()” ఫంక్షన్‌ను వర్తింపజేసిన తర్వాత “-8” విలువగా “-8” ఇస్తుందని చూపిస్తుంది.
ఉదాహరణ 4:
ఇక్కడ, మేము 'డబుల్' డేటా రకం విలువలకు 'ఫ్లోర్()' ఫంక్షన్‌ని వర్తింపజేస్తాము. మేము ఇక్కడ “iomanip” హెడర్ ఫైల్‌ని కూడా చేర్చాము, ఇది “setprecision()” ఫంక్షన్‌ని ఉపయోగించడంలో సహాయపడుతుంది, ఈ ఫంక్షన్ ఈ హెడర్ ఫైల్‌లో ప్రకటించబడింది. అప్పుడు, మన కోడ్‌లో ఈ ఫంక్షన్‌ని ఉపయోగించాలి. ఇప్పుడు, మేము విలువలతో “d_1”, “d_2” మరియు “d_3” వేరియబుల్‌లను ప్రారంభిస్తాము. ఆ తర్వాత, మనకు “సెట్‌ప్రెసిషన్()” అని టైప్ చేసే “కౌట్” ఉంది, ఇది అవసరమైన దశాంశ స్థానాల సంఖ్యతో “డబుల్” డేటా రకం సంఖ్య యొక్క ఖచ్చితమైన విలువను పొందడంలో సహాయపడుతుంది. మేము ఇక్కడ '10'ని దాని పరామితిగా పాస్ చేస్తాము. అప్పుడు, మేము విలువలను ప్రింట్ చేస్తాము, ఈ విలువలకు 'ఫ్లోర్ ()' ఫంక్షన్‌ను వర్తింపజేసి, వాటిని ప్రింట్ చేస్తాము.
కోడ్ 4:
#include#include
#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
రెట్టింపు d_1 = 4.99986399 , d_2 = - 6.9612499 , d_3 = 9.00320 , d_4 = 3,000000 ;
కోట్ << నిర్దుష్టత ( 10 ) << 'మొదటి డబుల్ విలువ' << d_1 << ' & ఫ్లోర్ ఉంది: ' << అంతస్తు ( d_1 ) << endl ;
కోట్ << నిర్దుష్టత ( 10 ) << 'రెండవ డబుల్ విలువ' << d_2 << ' & ఫ్లోర్ ఉంది: ' << అంతస్తు ( d_2 ) << endl ;
కోట్ << నిర్దుష్టత ( 10 ) << 'మూడవ డబుల్ విలువ' << d_3 << ' & ఫ్లోర్ ఉంది: ' << అంతస్తు ( d_3 ) << endl ;
కోట్ << నిర్దుష్టత ( 10 ) << 'నాల్గవ డబుల్ విలువ' << d_4 << ' & ఫ్లోర్ ఉంది: ' << అంతస్తు ( d_4 ) << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
“floor()” ఫంక్షన్‌ని కంప్యూట్ చేసిన తర్వాత మనకు లభించే విలువలు ఇక్కడ ప్రదర్శించబడతాయి. మేము ఈ కోడ్‌లోని డబుల్ డేటా రకం విలువలకు “ఫ్లోర్()” ఫంక్షన్‌ని వర్తింపజేసాము:
ఉదాహరణ 5:
ఇక్కడ మూడు హెడర్ ఫైల్‌లను చేర్చిన తర్వాత, మేము “namespace std” మరియు “main()”ని ఉంచుతాము. దీని తరువాత, '-0.000' విలువ 'ఫ్లోర్()' ఫంక్షన్‌లో పరామితిగా చేర్చబడుతుంది. మేము 'cout()'ని కూడా ఉపయోగిస్తాము. అప్పుడు, మేము 'ఫ్లోర్ ()' ఫంక్షన్ యొక్క పరామితిగా 'INFINITY'ని ఉంచుతాము. దీని క్రింద, మేము 'ఫ్లోర్()' ఫంక్షన్ పరామితిలో '-INFINITY'ని జోడిస్తాము. ముగింపులో, మేము దాని పరామితిగా 'NAN'ని ఇన్సర్ట్ చేస్తాము. ఈ 'ఫ్లోర్()' ఫంక్షన్లన్నీ 'కౌట్' స్టేట్‌మెంట్ లోపల ఉపయోగించబడతాయి.
కోడ్ 5:
#include#include
#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
కోట్ << 'విలువ -0.000 మరియు ఫ్లోర్' << అంతస్తు ( - 0.000 ) << endl ;
కోట్ << 'విలువ అనంతం మరియు అంతస్తు' << అంతస్తు ( అనంతం ) << endl ;
కోట్ << 'విలువ -ఇన్ఫినిటీ మరియు ఫ్లోర్' << అంతస్తు ( - అనంతం ) << endl ;
కోట్ << 'విలువ NaN మరియు ఫ్లోర్' << అంతస్తు ( IN ) << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
'-0.000' విలువ 'ఫ్లోర్()' ఫంక్షన్ చేసిన తర్వాత '-0'ని అందిస్తుంది. “floor()” ఫంక్షన్ చేసిన తర్వాత “INFINITY” మరియు “-INFINITY” వరుసగా “inf” మరియు “-inf”ని అందిస్తాయి. అలాగే, “NAN” “floor()” ఫంక్షన్ చేసిన తర్వాత “nan”ని అందిస్తుంది.
ముగింపు
C++ ప్రోగ్రామింగ్‌లోని “floor()” ఫంక్షన్ ఇక్కడ పూర్తిగా చర్చించబడింది. “ఫ్లోర్()” ఫంక్షన్ ఆ ఫంక్షన్‌కి పారామీటర్‌గా ఇవ్వబడిన సంఖ్య కంటే తక్కువ లేదా సమానమైన విలువను అందిస్తుంది అని మేము వివరించాము. మేము ఈ ట్యుటోరియల్‌లో పూర్ణాంకాలు, ఫ్లోట్‌లు మరియు డబుల్-డేటా-టైప్ చేసిన నంబర్‌లపై ఈ ఫంక్షన్‌ని వర్తింపజేసాము. అన్ని ఉదాహరణలు ఇక్కడ వివరంగా చర్చించబడ్డాయి.