Voorbeeld 01:
We hebben dus het bestand “new.cc” geopend met de “nano” -instructie. Dit bestand wordt gemaakt met behulp van de “touch” -query van de shell. Het bestand wordt nu als leeg bestand in de nano-editor gestart. We hebben bovenaan het input-output “iostream” headerbestand toegevoegd. De “iomanip”-bibliotheek is toegevoegd om de setprecision()-methode van onze code te gebruiken. Hierna gebruikten we de standaard naamruimte “std” om er zeker van te zijn dat we de standaardmanier van code en syntaxis gebruikten. De algehele code is uitgevoerd binnen de main()-functie van C++-code. Hiervoor wordt geen andere door de gebruiker gedefinieerde functie gebruikt.
Binnen de functie main() hebben we een variabele van het dubbele type “v” geïnitialiseerd met een dubbele waarde. De eerste standaardinstructie “cout” geeft de werkelijke dubbele variabelewaarde “v” op de shell weer zonder enige update. Hierna hebben we acht cout-instructies gebruikt om in elk de methode setprecision() te gebruiken. Dit is om de setprecision() elke keer op de “v”-variabele toe te passen. U moet begrijpen dat de instelprecisie alleen werkt op de waarde groter dan of gelijk aan 5. Als de drijvende-kommawaarde groter is dan 5, wordt de waarde ervoor verhoogd.
Setprecision() op de eerste drijvende komma rondt bijvoorbeeld “5” af na het punt, en de waarde “4” wordt geconverteerd naar 5. Op dezelfde manier kan de tweede drijvende komma waarde “2” niet worden afgerond, de De 3e drijvende-kommawaarde “7” converteert de waarde “2” naar “3”, de 4e drijvende-kommawaarde “4” kan niet worden afgerond en de 5e drijvende-kommawaarde “9” converteert de waarde “4 ” tot 5 ervoor. Op het punt “0” wordt de waarde “4” geconverteerd naar 5. De negatieve setprecision() doet niets anders dan de volledige werkelijke waarde weergeven. Alle waarden bij drijvende komma 0 tot 5 en -1, -2 worden weergegeven na het toepassen van de setprecision():
Het is tijd om de setprecision C++-code te compileren en uit te voeren met de g++-compilatiequery en de uitvoeringsquery './a.out'. De uitvoer laat zien dat de eerste setprecision(1) 4 naar 5 converteert. De setprecision(2) deed niets en geeft “4.5” weer. De setprecision(3) verhoogde de waarde van “4.52” naar “4.53”. De setprecision(4) doet niets met de waarde “4.527”. De setprecision(5) verhoogt de waarde van “4.5274” naar “4.5275”. De setprecision(0) verhoogde de waarde naar 5. De setprecision(-1) en setprecision(-2) deden niets, zoals hieronder weergegeven:
$ g++ nieuw.cc$. / a.uit
Voorbeeld 02:
Laten we eens naar een ander voorbeeld kijken. De code is vergelijkbaar met het bovenstaande voorbeeld, met alleen een verandering in de cout-instructies. De eerste cout toont de oorspronkelijke waarden, terwijl de volgende twee het resultaat van setprecision() op drijvende komma 1 en 5 tonen. De laatste cout toont het resultaat van de setprecision() methode op drijvende komma 9, die fysiek niet beschikbaar is. De resultaten met drijvende komma 1 en 5 zijn redelijk te verwachten, maar we kunnen niets zeggen over drijvende komma 9. Laten we gewoon het bestand uitvoeren en controleren wat de uitvoer van deze code zal zijn:
#include#include
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
dubbele in = 4,52749 ;
uit << 'Waarde vóór ingestelde precisie: ' << in << ' \N ' ;
uit << precisie instellen ( 1 ) << 'Val op 1: ' << in << ' \N ' ;
uit << precisie instellen ( 5 ) << 'Val om 5: ' << in << ' \N ' ;
uit << precisie instellen ( 9 ) << 'Val om 9: ' << in << ' \N ' ;
opbrengst 0 ;
}
Na het compileren en uitvoeren van deze code hebben we de voor de hand liggende resultaten voor de setprecisie op locaties 1 en 3 van de drijvende-kommawaarde “4.52749”. Het resultaat van instelprecisie 9 toont de werkelijke waarde van dubbele variabele “v”. Dit kan te wijten zijn aan het feit dat de waarde voor locatie 9 niet vaststaat:
$ g++ nieuw.cc$. / a.uit
Laten we de code opnieuw bijwerken om de waarden van een variabele “v” te corrigeren. Dus nadat de eerste setprecision() cout-instructie werd toegepast op de eerste locatie van de variabele, hebben we de vaste variabele in cout gebruikt:
#include#include
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
dubbele in = 4,52749 ;
uit << 'Waarde vóór ingestelde precisie: ' << in << ' \N ' ;
uit << precisie instellen ( 1 ) << 'Val op 1: ' << in << ' \N ' ;
uit << vast ;
uit << precisie instellen ( 5 ) << 'Val om 5: ' << in << ' \N ' ;
uit << precisie instellen ( 9 ) << 'Val om 9: ' << in << ' \N ' ;
opbrengst 0 ;
}
Na het compileren en uitvoeren van deze bijgewerkte code hebben we het vaste resultaat van setprecision op locatie 9 van een variabele “v”, dat wil zeggen 4.527490000:
$ g++ nieuw.cc$. / a.uit
Conclusie:
Ten slotte ging het allemaal om het gebruik van de setprecision()-methode in C++-code om de waarde van een dubbele variabele af te ronden en weer te geven. We hebben ook vaste variabelen in de code en hun voordelen uitgelegd. Bovendien hebben we twee belangrijke voorbeelden geïmplementeerd om het concept van ingestelde precisie in C++ uit te leggen. We hopen dat je dit artikel nuttig vond. Bekijk andere Linux Hint-artikelen voor meer tips en tutorials.