Idag ska vi studera en av de viktiga funktionerna för att avrunda heltalsvärdet i programmeringsspråket C++. Vi kommer att lära oss hur vi ska implementera denna avrundningsmetod. Men innan det, låt oss ta en snabb titt på grunderna i C++ så att ingen annan tanke lämnas för användaren.
C++ är ett procedurmässigt och lättförståeligt objektorienterat programmeringsspråk som erbjuder program en tydlig struktur som gör att kod kan utvärderas inom samma program. Men ibland finns det ett komplext problem som vi vill lösa. För det använder vi flera funktioner i C++ för att dela upp det komplexa problemet i mindre bitar, vilket är de funktioner vi använde i vårt program. Och idag studerar vi en av de viktiga funktionerna, som är rint()-funktionen i C++.
Introduktion
I C++ är rint()-funktionen den fördefinierade funktionen som avrundar värdet till närmaste heltalsvärde. För att avrunda inmatningsvärdet använder vi det aktuella avrundningsläget, vilket är fesetround()-läget. För att förstå och lära oss mer tydligt om rint()-funktionen, låt oss gräva djupt och se hur vi kommer att implementera den här funktionen i C++.
Syntax
Låt oss förstå skrivstilen och implementeringen av rint()-funktionen i C++. Först kommer vi att skriva returtypen för rint()-funktionen. I funktionsparenteserna rint() kommer vi att skriva datatypen för indatavariabeln och skicka in parametern i den så att vi får ingångsvärdet till den avrundade heltalstypen.
Parameter
Indatavariabel: kan vara valfritt variabelnamn som innehåller vilket värde som helst. Vi har till exempel en parameter x som vi vill runda av.
Fel och undantag
Om vi skickar parametern 0 och infinite, får vi i gengäld det ursprungliga ingångsvärdet. Och om funktionens utdata ligger utanför de acceptabla parametrarna för returtypen kan ett domänfel ha uppstått.
Returvärde
I gengäld får vi det avrundade heltalstypvärdet för ingångsvärdet.
Exempel 01
Låt oss börja implementera vårt allra första och enklaste exempel på rint()-funktionen, som vi kommer att skriva i C++. Vi behöver en C++-kompilator för att implementera rint()-funktionen. Öppna kompilatorn och börja skriva koden.
I C++-programmet inkluderar vi först de grundläggande biblioteken relaterade till vårt program. Dessa bibliotek är de fördefinierade biblioteken i C++. Vi behöver bara skriva en enda rad kod för att inkludera dessa bibliotek istället för att skriva hundratals rader för att skapa biblioteket. För att inkludera filen skriver vi först '#'-tecknet som informerar kompilatorn att ladda huvudfilen, termen 'inkludera' består av rubrikfilen i programmet, och 'iostream' indikerar att data tas emot från användaren och visas det till användaren.
Vi har också införlivat den andra rubrikfilen med prefixet '#include
#inkludera
använder namnutrymme std;
int main ( )
{
flyta X = 9.1 , och = 0,9 ;
cout << 'Värdet på X efter avrundning: ' << springer ( X ) << endl;
cout << 'Värdet på Y efter avrundning: ' << springer ( Y ) ;
lämna tillbaka 0 ;
}
Sedan börjar vi skriva funktionen main() eftersom här. Vi kommer att skriva själva kodraden eller implementera funktionen vi vill implementera. I funktionsparenteserna main() har vi deklarerat de två variablerna med namnet 'X och Y' av typen float och tilldelat dem olika värden. Sedan kommer vi att anropa den avrundningsfunktion som vi vill utföra, vilket är funktionen rint(). Vi anropar funktionen genom att först skriva funktionens namn, vilket är funktionen rint() och sedan indatavariabeln 'X' i den. Och sedan kommer vi att skriva ut dem genom att skriva cout()-metoden och skicka funktionen. Vi har gjort samma sak för variabeln 'Y'. Och i slutändan kommer vi att returnera 0 till main()-funktionen och stänga parentesen.
Här har vi den önskade utgången, vilket är värdet på 'X' är 9, och värdet på 'Y' är 1 i heltalstyp.
Exempel 02
Låt oss nu gå vidare till det andra exemplet på rint()-funktionen i C++-språket. I det här exemplet har vi använt metoden aktuellt läge, vilket är läget fesetround(). Metoden fesetround() skapar den 'nuvarande avrundningsriktningen' i rint()-funktionen som riktar inmatningsvärdet uppåt, nedåt, närmaste ton och mot nollriktningen.
#include#include
#inkludera
använder namnutrymme std;
int main ( )
{
dubbelt X;
cout << 'Ange inmatningsvärdet för X är: ' ;
äter >> X;
cout << ' \n Avrundning till närmaste heltal av X(' << X << '): ' << springer ( X ) << endl;
festomgång ( FE_UPWARD ) ;
cout << 'Avrunda X(' << X << ') uppåt: ' << springer ( X ) << endl;
festomgång ( FE_DOWNWARD ) ;
cout << 'Avrunda X(' << X << ') nedåt: ' << springer ( X ) << endl;
lämna tillbaka 0 ;
}
Vi har inkluderat några grundläggande bibliotek relaterade till de funktioner vi kommer att implementera i programmet. Den första rubrikfilen är '#include
Sedan anropar vi funktionen main() och börjar skriva själva kodraden. Först kommer vi att deklarera variabeln 'X' av typen double, och sedan får vi värdet från användaren genom att använda cin()-metoden i C++ och sedan skriva ut den med cout()-metoden. Därefter kommer vi att anropa rint()-funktionen för att skriva ut det närmaste avrundade värdet på 'X' genom cout()-metoden.
Nu har vi använt metoden fesetround() för att skriva ut värdena i riktningar uppåt och nedåt. För det, anrop fesetround()-funktionen och skriv 'FE_UPWARD' med versaler inom funktionsparenteser och skriv ut den genom att skicka funktionen rint() i cout()-metoden. Sedan skriver vi ut värdena i riktning nedåt, så skriv metoden fesetround() och skicka 'FE_DOWNWARD' med versaler och skriv rint()-funktionen i cout()-metoden. Och till slut, returnera 0 till main()-funktionen och stäng parenteserna.
Låt oss se resultatet av föregående exempel:
Slutsats
I den här artikeln har vi lärt oss om funktionernas roll i C++, och vi täckte vårt huvudämne, vilket är rint()-funktionen i C++. Vi har lärt oss hur rint()-funktionen fungerar i C++ och hur vi får det avrundade heltalsvärdet genom att använda metoden fesetround() . Vi har också implementerat några exempel i den detaljerade förklaringen av varje kodrad så att användaren enkelt kan förstå exemplen.