Exempel 1:
I denna C++-kod ingår rubrikfilerna 'iostream' och 'cmath'. 'iostream'-huvudfilen är att utföra input\output-operationerna genom att använda cin\cout-funktionerna eftersom dessa funktioner är definierade i 'iostream'-huvudfilen. 'cmath'-huvudfilen läggs till här för att utföra de matematiska operationerna på data. 'Namespace std' placeras före. Sedan läggs drivrutinskoden till som är 'main()'. Under detta använder vi 'num' med datatypen 'flytande'. Värdet på 'num' som vi ställer in här är '4,6'.
Sedan lägger vi till funktionen 'cout()' som skriver ut data som vi skrev in i den. Först visar vi flytnumret som vi tidigare initierat. Sedan använder vi funktionen 'floor()' och skickar 'num' som argumentet för denna 'floor()'-funktion. Vi skriver också ut resultatet efter att ha tillämpat funktionen 'floor()'.
Kod 1:
#inkludera
#include
använder sig av namnutrymme std ;
int huvud ( )
{
flyta på ett = 4.6 ;
cout << 'Numret är' << på ett << endl ;
cout << 'Botten för detta nummer är:' << golv ( på ett ) << endl ;
lämna tillbaka 0 ;
}
Produktion:
I denna utgång är siffran '4.6'. Men när vi använder metoden 'floor()' ger det resultatet '4'. Detta visar att metoden 'floor()' returnerar ett tal som är mindre än eller lika med det givna talet.
Exempel 2:
Här inkluderar vi två rubrikfiler som heter 'iostream' och 'cmath'. Sedan placerar vi 'namespace std' och deklarerar funktionen 'main()'. Efter detta deklarerar vi fyra variabler med 'flytande' datatyp. Dessa variabler heter 'num_1', 'num_2', 'num_3' och 'num_4'. Vi tilldelar '4.9' till 'num_1', '-6.4' till 'num_2', '5.1' till 'num_3' och '8' till 'num_4'. Sedan tillämpar vi funktionen 'floor()' på variabeln 'num_1' och skriver ut värdet såväl som resultatet som vi fick efter att ha tillämpat funktionen 'floor()' på detta nummer. På samma sätt skriver vi ut alla värden och resultatet av dessa värden som vi fick från funktionen 'floor()' genom att placera dem i denna funktion som dess argument.
Kod 2:
#inkludera#include
använder sig av namnutrymme std ;
int huvud ( )
{
flyta num_1, num_2, num_3, num_4 ;
num_1 = 4.9 ;
num_2 = - 6.4 ;
num_3 = 5.1 ;
num_4 = 8 ;
cout << 'Första numret är' << num_1 << ' och dess våning är ' << golv ( num_1 ) << endl ;
cout << 'Det andra numret är' << num_2 << ' och dess våning är ' << golv ( num_2 ) << endl ;
cout << 'Den tredje siffran är' << num_3 << ' och dess våning är ' << golv ( num_3 ) << endl ;
cout << 'Det fjärde numret är' << num_4 << ' och dess våning är ' << golv ( num_4 ) << endl ;
lämna tillbaka 0 ;
}
Produktion:
Värdet '4.9' returnerar '4' efter att ha tillämpat funktionen 'floor()'. Sedan lägger vi '-6.4' i denna 'floor()'-funktion och den returnerar '-7' som visas i följande. Resultatet av nummer '5.1' är '5' efter att ha tillämpat metoden 'floor()'. Samma resultat visas när '8' returnerar '8' som golvvärde:
Exempel 3:
Här tillämpar vi funktionen 'floor()' på heltalsvärdena. Först initierar vi heltalsvariablerna med namnet 'värde_1' och 'värde_2'. 'value_1' initieras med '5' och 'value_2' initieras med '-8'. Efter detta placerar vi 'cout' där vi lägger till 'floor()'-funktionen där vi skickar 'value_1' i den första 'cout'-satsen. I nästa 'cout' använder vi 'floor()' där vi skickar 'value_2' som parameter. Nu tillämpar den funktionen 'floor()' på dessa värden och skriver ut dem på skärmen.
Kod 3:
#inkludera#include
använder sig av namnutrymme std ;
int huvud ( )
{
int värde_1, värde_2 ;
värde_1 = 5 ;
värde_2 = - 8 ;
cout << 'Det första heltalstalet är' << värde_1 << ' och dess våning är ' << golv ( värde_1 ) << endl ;
cout << 'Det andra heltalstalet är' << värde_2 << ' och dess våning är ' << golv ( värde_2 ) << endl ;
lämna tillbaka 0 ;
}
Produktion:
Detta resultat visar att värdet på '5' ger '5' efter beräkning av 'floor()'-funktionen och '-8' ger '-8' som värdet efter att ha tillämpat 'floor()'-funktionen.
Exempel 4:
Här tillämpar vi funktionen 'floor()' på värdena för datatypen 'dubbel'. Vi inkluderar också 'iomanip'-huvudfilen här som hjälper till att använda 'setprecision()'-funktionen eftersom denna funktion deklareras i den här rubrikfilen. Sedan måste vi använda den här funktionen i vår kod. Nu initierar vi variablerna 'd_1', 'd_2' och 'd_3' med värdena. Sedan har vi 'cout' där vi skriver 'setprecision()' som hjälper till att få det exakta värdet av ett 'dubbelt' datatypnummer med det antal decimaler som krävs. Vi skickar '10' här som dess parameter. Sedan skriver vi ut värdena, tillämpar funktionen 'floor()' på dessa värden och skriver ut dem.
Kod 4:
#inkludera#inkludera
#include
använder sig av namnutrymme std ;
int huvud ( )
{
dubbel d_1 = 4,99986399 , d_2 = - 6,9612499 , d_3 = 9,00320 , d_4 = 3 000 000 ;
cout << inställningsprecision ( 10 ) << 'Det första dubbla värdet är' << d_1 << ' & våningen är: ' << golv ( d_1 ) << endl ;
cout << inställningsprecision ( 10 ) << 'Det andra dubbla värdet är' << d_2 << ' & våningen är: ' << golv ( d_2 ) << endl ;
cout << inställningsprecision ( 10 ) << 'Det tredje dubbla värdet är' << d_3 << ' & våningen är: ' << golv ( d_3 ) << endl ;
cout << inställningsprecision ( 10 ) << 'Det fjärde dubbelvärdet är' << d_4 << ' & våningen är: ' << golv ( d_4 ) << endl ;
lämna tillbaka 0 ;
}
Produktion:
Värdena som vi får efter att ha beräknat funktionen 'floor()' visas här. Vi tillämpade funktionen 'floor()' på de dubbla datatypvärdena i den här koden:
Exempel 5:
Efter att ha inkluderat alla tre rubrikfilerna här placerar vi 'namespace std' och 'main()'. Efter detta infogas ett värde på '-0,000' i 'floor()'-funktionen som parameter. Vi använder 'cout()' också. Sedan placerar vi 'INFINITY' som parametern för funktionen 'floor()'. Under detta lägger vi till '-INFINITY' i 'floor()'-funktionens parameter. I slutet infogar vi 'NAN' som parameter. Alla dessa 'floor()'-funktioner används i 'cout'-satsen.
Kod 5:
#inkludera#inkludera
#include
använder sig av namnutrymme std ;
int huvud ( )
{
cout << 'Värdet är -0,000 och golvet är' << golv ( - 0,000 ) << endl ;
cout << 'Värdet är INFINITY och golvet är' << golv ( OÄNDLIGHET ) << endl ;
cout << 'Värdet är -INFINITY och golvet är' << golv ( - OÄNDLIGHET ) << endl ;
cout << 'Värdet är NaN och golvet är' << golv ( I ) << endl ;
lämna tillbaka 0 ;
}
Produktion:
Värdet på '-0,000' returnerar '-0' efter att ha utfört funktionen 'floor()'. 'INFINITY' och '-INFINITY' returnerar 'inf' respektive '-inf', efter att ha utfört 'floor()'-funktionen. Dessutom returnerar 'NAN' 'nan' efter att ha utfört funktionen 'floor()'.
Slutsats
Funktionen 'floor()' i C++-programmering diskuteras här ingående. Vi förklarade att funktionen 'floor()' returnerar värdet som är mindre än eller lika med talet som ges till den funktionen som parameter. Vi tillämpade den här funktionen på heltal, flytande tal och dubbeldatatypade tal i den här handledningen. Alla exempel diskuteras här i detalj.