C++-språket tillhandahåller många datatyper att arbeta med som 'int', 'float', 'char', 'double', 'long double', etc. Datatypen 'dubbel' används för siffror som innehåller decimaler uppåt till '15' eller för exponentialvärdena. Den kan bära dubbelt så mycket information och data som en float som kallas en dubbel datatyp. Dess storlek är ungefär '8 byte', vilket fördubblar datatypen flytande.
Vi kan möta utmaningar när vi arbetar med den 'dubbla' datatypen. Vi kan inte skriva ut den dubbla datatypen direkt, så vi kan använda vissa tekniker för att skriva ut hela värdet för den 'dubbla' datatypen. Vi kan använda metoden 'setpercision()' när vi arbetar med den dubbla datatypen som innehåller decimaler. I det andra fallet med den dubbla datatypen som har exponentiella värden kan vi använda de 'fasta' eller 'vetenskapliga' formaten. Här kommer vi att diskutera utskrift av dubbla datatyper utan att använda någon teknik och genom att använda alla tre metoderna i den här guiden.
Exempel 1:
C++-koden är här i vilken 'iostream'-huvudfilen ingår eftersom vi måste arbeta med funktionerna som deklareras i denna rubrikfil. Sedan placerar vi 'namespace std' så att vi inte behöver lägga till nyckelordet 'std' med våra funktioner separat. Sedan anropar vi funktionen här som är funktionen 'main()'. I det följande deklarerar vi en 'dubbel' variabel med namnet 'var_a' och tilldelar denna variabel ett decimalkomma. Nu vill vi visa detta dubbla värde, så vi använder 'cout' för att placera denna variabel där vi lagrar det dubbla värdet. Sedan lägger vi till 'retur 0'.
Kod 1:
#includeanvänder sig av namnutrymme std ;
int huvud ( tomhet ) {
dubbel var_a = 7,9765455419016 ;
cout << 'Det dubbla värdet vi placerade här = ' << var_a ;
lämna tillbaka 0 ;
}
Produktion:
Notera nu här i det här resultatet att det inte skriver ut det fullständiga dubbla värdet som vi infogade i vår kod. Så det här är problemet som vi står inför när vi arbetar med den dubbla datatypen i C++-programmering.
Exempel 2:
I det här exemplet kommer vi att tillämpa den aritmetiska operationen på decimalvärdena och sedan visa resultatet som ett dubbelt datatypvärde. Vi lägger först till rubrikfilen 'bits/stdc++.h' som innehåller alla standardbibliotek. Sedan anropar vi 'main()' efter att ha använt 'namespace std'. Variabeln 'a' deklareras här med datatypen 'dubbel' och tilldelar sedan '1.0/5000' till denna variabel. Nu tillämpar den denna divisionsoperation på data och lagrar resultatet i variabeln 'a' av datatypen 'dubbel'. Sedan visar vi resultatet som är lagrat i 'a' med hjälp av 'cout'.
Kod 2:
#includeanvänder sig av namnutrymme std ;
int huvud ( tomhet ) {
dubbel a = 1.0 / 5 000 ;
cout << 'Mitt dubbla värde är' << a ;
lämna tillbaka 0 ;
}
Produktion:
Här är resultatet av det givna dubbla datatypvärdet. Vi kan enkelt tillämpa de matematiska operationerna på värdena som returnerar resultatet av dubbeldatatyp och visa dem i vår C++-kod.
Exempel 3: Använda Setprecision()-metoden
Här kommer vi att tillämpa metoden 'setprecision'. Vi inkluderar två huvudfiler: 'iosteam' och 'bits/stdc++.h'. 'Namespace std' läggs sedan till vilket gör att vi slipper inkludera nyckelordet 'std' med var och en av våra funktioner individuellt. Funktionen 'main()' anropas sedan under denna. Variabeln 'var_a' deklareras nu med datatypen 'dubbel' som har ett värde som innehåller en decimalpunkt.
Eftersom vi vill visa hela numret använder vi funktionen 'setprecision()' i 'cout'-satsen. Vi skickar '15' som parameter för denna funktion. Denna metod hjälper till att ställa in antalet värden för decimalkomma i detta dubbla datatypvärde. Precisionen som vi anger här är '15'. Så, den visar '15' siffror för decimalkommavärdet. Sedan lägger vi 'var_a' i denna 'cout' efter att ha använt metoden 'setprecision()' för att skriva ut detta 'dubbla' datatypvärde.
Kod 3:
#include#include
använder sig av namnutrymme std ;
int huvud ( tomhet ) {
dubbel var_a = 7,9765455419016 ;
cout << inställningsprecision ( femton ) << 'Det dubbla värdet vi placerade här = ' << var_a ;
lämna tillbaka 0 ;
}
Produktion:
Här kan vi se att det fullständiga värdet som vi angav i koden visas. Detta beror på att vi använde funktionen 'setprecision()' i vår kod och satte precisionsnumret till '15'.
Exempel 4:
'iomanip' och 'iostream' är de två huvudfilerna. 'iomanip' används eftersom funktionen 'setprecision()' deklareras i denna rubrikfil. Sedan infogas 'std'-namnrymden och anropar 'main()'. Den första variabeln av datatypen 'dubbel' som deklareras här är 'dbl_1' och den andra variabelns namn är 'dbl_2'. Vi tilldelar olika värden till båda variablerna som innehåller decimaler. Nu tillämpar vi samma precisionsnummer för båda värdena genom att använda funktionen 'setpercision()' och skicka '12' här.
Nu är precisionsnumret för båda värdena satt till '12' vilket betyder att dessa värden visar '12' värden. Vi använder denna 'setprecision()'-funktion efter att ha placerat 'cout'-funktionen. Nedanför detta skriver vi ut båda värdena av 'dubbel' datatyp med 'cout'.
Kod 4:
#inkludera#include
använder sig av namnutrymme std ;
int huvud ( ) {
dubbel dbl_1 = 9,92362738239293 ;
dubbel dbl_2 = 6.68986442623803 ;
cout << inställningsprecision ( 12 ) ;
cout << 'Dubbel typ nummer 1 = ' << dbl_1 << endl ;
cout << 'Dubbel typ nummer 2 = ' << dbl_2 << endl ;
lämna tillbaka 0 ;
}
Produktion:
Vi kanske märker att den visar 12 värden och ignorerar alla andra värden för detta 'dubbla' datatypvärde eftersom vi ställer in precisionsvärdet i vår kod.
Exempel 5:
Här deklarerar vi tre variabler: 'new_d1', 'new_d2' och 'new_d3'. Datatypen för alla tre värden är 'dubbel'. Vi tilldelar också värdena till alla dessa variabler. Nu vill vi ställa in olika precisionsvärden för alla tre variablerna. Vi ställer in '15' för det första variabelvärdet genom att skicka '15' som parameter för funktionen 'setprecision()' i 'cout'. Efter detta ställer vi in '10' som precisionsvärdet för den andra variabelns värde och ställer in '6' som precisionsnumret för detta tredje värde.
Kod 5:
#inkludera#include
använder sig av namnutrymme std ;
int huvud ( ) {
dubbel ny_d1 = 16.6393469106198566 ;
dubbel new_d2 = 4,01640810861469 ;
dubbel new_d3 = 9,95340810645660 ;
cout << 'Dubbel typnummer med precision 15 = ' << inställningsprecision ( femton ) << ny_d1 << endl ;
cout << 'Dubbel typnummer med precision 10 = ' << inställningsprecision ( 10 ) << new_d2 << endl ;
cout << 'Dubbel typnummer med precision 6 = ' << inställningsprecision ( 6 ) << new_d3 << endl ;
lämna tillbaka 0 ;
}
Produktion:
Alla tre värdena är olika här eftersom vi justerar de olika precisionsvärdena för dem alla. Det första värdet innehåller '15'-siffror eftersom vi ställer in precisionsvärdet till '15'. Det andra värdet innehåller '10'-siffror på grund av precisionsvärdet '10', och det tredje värdet visar '6'-siffror här eftersom dess precisionsvärde är justerat till '6' i koden.
Exempel 6:
Vi initierar fyra variabler här: två initieras med decimalvärden och de andra två initieras med exponentiella värden. Efter detta tillämpar vi det 'fasta' formatet på alla fyra variablerna genom att placera dem inuti 'cout'. Nedanför detta använder vi det 'vetenskapliga' formatet på dessa variabler separat genom att placera dem i 'cout' efter att ha använt nyckelordet 'vetenskapligt'.
Kod 6:
#inkludera#include
använder sig av namnutrymme std ;
int huvud ( ) {
dubbel min_dbl_1 = 7,7637208968554 ;
dubbel mitt_ex_1 = 776e+2 ;
dubbel min_dbl_2 = 4,6422657897086 ;
dubbel mitt_ex_2 = 464e+2 ;
cout << 'Genom att använda det fasta sökordet' << endl ;
cout << 'Första dubbeltypnummer = ' << fast << min_dbl_1 << endl ;
cout << 'Andra dubbeltypsnummer = ' << fast << mitt_ex_1 << endl ;
cout << 'Tredje dubbeltypsnummer = ' << fast << min_dbl_2 << endl ;
cout << 'Fjärde dubbeltypnummer = ' << fast << mitt_ex_2 << endl ;
cout << endl ;
cout << 'Genom att använda det vetenskapliga nyckelordet:' << endl ;
cout << 'Första dubbeltypnummer = ' << vetenskaplig << min_dbl_1 << endl ;
cout << 'Andra dubbeltypsnummer = ' << vetenskaplig << mitt_ex_1 << endl ;
cout << 'Tredje dubbeltypsnummer = ' << vetenskaplig << min_dbl_2 << endl ;
cout << 'Fjärde dubbeltypnummer = ' << vetenskaplig << mitt_ex_2 << endl ;
lämna tillbaka 0 ;
}
Produktion:
Detta resultat visar resultatet efter att ha tillämpat de 'fasta' och 'vetenskapliga' formaten på de 'dubbla' datatypvärdena. Det 'fasta' formatet tillämpas på de fyra första värdena. På de fyra sista värdena tillämpas det ”vetenskapliga” formatet och visar resultatet här.
Slutsats
Konceptet att 'skriva ut dubbel' datatyp diskuteras i detalj här. Vi utforskade de olika teknikerna för att skriva ut den 'dubbla' datatypen i C++-programmering. Vi visade de tre olika teknikerna som hjälper oss att skriva ut de 'dubbla' datatypvärdena; dessa är 'setprecision()', 'fixed' och 'scientific'. Vi har noggrant utforskat alla tekniker i den här guiden.