Eksempel 1:
I denne C++-kode er 'iostream'- og 'cmath'-headerfilerne inkluderet. 'iostream'-headerfilen skal udføre input\output-operationerne ved at bruge cin\cout-funktionerne, da disse funktioner er defineret i 'iostream'-headerfilen. 'cmath'-headerfilen tilføjes her for at udføre de matematiske operationer på dataene. 'Namespace std' er placeret foran. Derefter tilføjes driverkoden, som er 'main()'. Herunder bruger vi 'num' med datatypen 'float'. Værdien af 'num', som vi indstiller her, er '4,6'.
Derefter tilføjer vi funktionen 'cout()', der udskriver de data, vi indtastede i den. Først viser vi det flydende nummer, som vi tidligere initialiserede. Derefter bruger vi 'floor()'-funktionen og sender 'num' som argumentet for denne 'floor()'-funktion. Vi udskriver også resultatet efter at have anvendt funktionen 'floor()'.
Kode 1:
#include
#include
ved brug af navneområde std ;
int vigtigste ( )
{
flyde på en = 4.6 ;
cout << 'Nummeret er' << på en << endl ;
cout << 'Etagen i dette nummer er:' << etage ( på en ) << endl ;
Vend tilbage 0 ;
}
Produktion:
I denne udgang er tallet '4.6'. Men når vi anvender 'floor()'-metoden, giver det resultatet '4'. Dette viser, at metoden 'floor()' returnerer et tal, der er mindre end eller lig med det givne tal.
Eksempel 2:
Her inkluderer vi to header-filer med navnet 'iostream' og 'cmath'. Derefter placerer vi 'navneområde std' og erklærer funktionen 'main()'. Herefter erklærer vi fire variable med 'float' datatype. Disse variabler hedder 'num_1', 'num_2', 'num_3' og 'num_4'. Vi tildeler '4.9' til 'num_1', '-6.4' til 'num_2', '5.1' til 'num_3' og '8' til 'num_4'. Derefter anvender vi 'floor()'-funktionen på 'num_1'-variablen og udskriver værdien såvel som det resultat, vi fik efter at have anvendt 'floor()'-funktionen på dette tal. På samme måde udskriver vi alle værdier og resultatet af disse værdier, som vi fik fra funktionen 'floor()' ved at placere dem i denne funktion som dens argument.
Kode 2:
#include#include
ved brug af navneområde std ;
int vigtigste ( )
{
flyde num_1, num_2, num_3, num_4 ;
nummer_1 = 4.9 ;
nummer_2 = - 6.4 ;
nummer_3 = 5.1 ;
num_4 = 8 ;
cout << 'Det første tal er' << nummer_1 << ' og dens etage er ' << etage ( nummer_1 ) << endl ;
cout << 'Det andet nummer er' << nummer_2 << ' og dens etage er ' << etage ( nummer_2 ) << endl ;
cout << 'Det tredje tal er' << nummer_3 << ' og dens etage er ' << etage ( nummer_3 ) << endl ;
cout << 'Det fjerde nummer er' << num_4 << ' og dens etage er ' << etage ( num_4 ) << endl ;
Vend tilbage 0 ;
}
Produktion:
Værdien '4.9' returnerer '4' efter anvendelse af funktionen 'gulv()'. Derefter sætter vi '-6.4' i denne 'gulv()'-funktion, og den returnerer '-7' som vist i det følgende. Resultatet af nummer '5.1' er '5' efter anvendelse af 'floor()'-metoden. Det samme resultat vises, da '8' returnerer '8' som bundværdien:
Eksempel 3:
Her anvender vi funktionen 'floor()' på heltalsværdierne. Først initialiserer vi heltalsvariablerne kaldet 'værdi_1' og 'værdi_2'. 'værdi_1' initialiseres med '5', og 'værdi_2' initialiseres med '-8'. Efter dette placerer vi 'cout', hvor vi tilføjer 'floor()'-funktionen, hvori vi sender 'value_1' i den første 'cout'-sætning. I den næste 'cout' bruger vi 'floor()', hvor vi sender 'value_2' som parameter. Nu anvender den funktionen 'gulv()' på disse værdier og udskriver dem på skærmen.
Kode 3:
#include#include
ved brug af navneområde std ;
int vigtigste ( )
{
int værdi_1, værdi_2 ;
værdi_1 = 5 ;
værdi_2 = - 8 ;
cout << 'Det første heltal er' << værdi_1 << ' og dens etage er ' << etage ( værdi_1 ) << endl ;
cout << 'Det andet heltal er' << værdi_2 << ' og dens etage er ' << etage ( værdi_2 ) << endl ;
Vend tilbage 0 ;
}
Produktion:
Dette resultat viser, at værdien af '5' giver '5' efter beregning af 'floor()'-funktionen og '-8' giver '-8' som værdien efter anvendelse af 'floor()'-funktionen.
Eksempel 4:
Her anvender vi funktionen 'floor()' på værdierne af den 'dobbelte' datatype. Vi inkluderer også 'iomanip'-header-filen her, som hjælper med at bruge funktionen 'setprecision()', da denne funktion er erklæret i denne header-fil. Så skal vi bruge denne funktion i vores kode. Nu initialiserer vi variablerne 'd_1', 'd_2' og 'd_3' med værdierne. Så har vi 'cout', hvori vi skriver 'setprecision()', som hjælper med at få den nøjagtige værdi af et 'dobbelt' datatypenummer med det nødvendige antal decimaler. Vi sender '10' her som dens parameter. Derefter udskriver vi værdierne, anvender funktionen 'floor()' på disse værdier og udskriver dem.
Kode 4:
#include#inkluder
#include
ved brug af navneområde std ;
int vigtigste ( )
{
dobbelt d_1 = 4,99986399 , d_2 = - 6,9612499 , d_3 = 9,00320 , d_4 = 3.000.000 ;
cout << sætpræcision ( 10 ) << 'Den første dobbelte værdi er' << d_1 << ' & etage er: ' << etage ( d_1 ) << endl ;
cout << indstille præcision ( 10 ) << 'Den anden dobbeltværdi er' << d_2 << ' & etage er: ' << etage ( d_2 ) << endl ;
cout << sætpræcision ( 10 ) << 'Den tredje dobbeltværdi er' << d_3 << ' & etage er: ' << etage ( d_3 ) << endl ;
cout << sætpræcision ( 10 ) << 'Den fjerde dobbeltværdi er' << d_4 << ' & etage er: ' << etage ( d_4 ) << endl ;
Vend tilbage 0 ;
}
Produktion:
Værdierne, som vi får efter at have beregnet funktionen 'floor()' vises her. Vi anvendte funktionen 'floor()' på de dobbelte datatypeværdier i denne kode:
Eksempel 5:
Efter at have inkluderet alle tre header-filer her, placerer vi 'namespace std' og 'main()'. Herefter indsættes en værdi på '-0.000' i funktionen 'gulv()' som parameter. Vi bruger også 'cout()'. Derefter placerer vi 'INFINITY' som parameteren for 'floor()'-funktionen. Herunder tilføjer vi '-INFINITY' til 'floor()'-funktionens parameter. Til sidst indsætter vi 'NAN' som parameter. Alle disse 'floor()'-funktioner bruges i 'cout'-sætningen.
Kode 5:
#include#inkluder
#include
ved brug af navneområde std ;
int vigtigste ( )
{
cout << 'Værdien er -0.000 og gulvet er' << etage ( - 0.000 ) << endl ;
cout << 'Værdien er INFINITY og gulvet er' << etage ( UENDELIGHED ) << endl ;
cout << 'Værdien er -INFINITY og gulvet er' << etage ( - UENDELIGHED ) << endl ;
cout << 'Værdien er NaN og gulvet er' << etage ( I ) << endl ;
Vend tilbage 0 ;
}
Produktion:
Værdien af '-0,000' returnerer '-0' efter at have udført funktionen 'gulv()'. 'INFINITY' og '-INFINITY' returnerer henholdsvis 'inf' og '-inf', efter at have udført funktionen 'floor()'. 'NAN' returnerer også 'nan' efter at have udført funktionen 'floor()'.
Konklusion
'floor()'-funktionen i C++-programmering diskuteres grundigt her. Vi forklarede, at funktionen 'floor()' returnerer den værdi, der er mindre end eller lig med det tal, der er givet til denne funktion som parameter. Vi anvendte denne funktion på heltal, flydende og dobbeltdata-typede tal i denne øvelse. Alle eksempler diskuteres her i detaljer.