C++-språket gir mange datatyper å jobbe med som 'int', 'float', 'char', 'double', 'long double', etc. 'double' datatypen brukes for tallene som inneholder desimaltegn oppover til '15' eller for eksponentielle verdier. Den kan bære dobbelt så mye informasjon og data som en float som kalles en dobbel datatype. Størrelsen er omtrent '8 byte', noe som dobler flytedatatypen.
Vi kan møte utfordringer mens vi jobber med den 'doble' datatypen. Vi kan ikke skrive ut den doble datatypen direkte, så vi kan bruke noen teknikker for å skrive ut hele verdien av den 'doble' datatypen. Vi kan bruke 'setpercision()'-metoden mens vi jobber med den doble datatypen som inneholder desimaltegn. I det andre tilfellet med den doble datatypen som har eksponentielle verdier, kan vi bruke de 'faste' eller 'vitenskapelige' formatene. Her vil vi diskutere utskrift av doble datatyper uten å bruke noen teknikk og ved å bruke alle tre metodene i denne veiledningen.
Eksempel 1:
C++-koden er her som 'iostream'-headerfilen er inkludert, da vi må jobbe med funksjonene som er deklarert i denne headerfilen. Deretter plasserer vi 'navneområde std' slik at vi ikke trenger å legge til søkeordet 'std' med funksjonene våre separat. Deretter påkaller vi funksjonen her som er 'main()'-funksjonen. I det følgende erklærer vi en 'dobbel' variabel med navnet 'var_a' og tildeler en desimalverdi til denne variabelen. Nå ønsker vi å vise denne doble verdien, så vi bruker 'cout' for å plassere denne variabelen der vi lagrer den doble verdien. Deretter legger vi til 'retur 0'.
Kode 1:
#includeved hjelp av navneområde std ;
int hoved- ( tomrom ) {
dobbelt var_a = 7,9765455419016 ;
cout << 'Den doble verdien vi plasserte her = ' << var_a ;
komme tilbake 0 ;
}
Produksjon:
Merk nå her i dette resultatet at det ikke skriver ut den fullstendige doble verdien som vi satte inn i koden vår. Så dette er problemet vi står overfor når vi jobber med den doble datatypen i C++-programmering.
Eksempel 2:
I dette eksemplet vil vi bruke den aritmetiske operasjonen på desimalverdiene og deretter vise resultatet som en dobbel datatypeverdi. Vi legger først til 'bits/stdc++.h'-headerfilen som inkluderer alle standardbibliotekene. Deretter påkaller vi 'main()' etter å ha brukt 'navneområdet std'. Variabelen 'a' er deklarert her med 'dobbel' datatypen og tilordner deretter '1.0/5000' til denne variabelen. Nå bruker den denne delingsoperasjonen på dataene og lagrer resultatet i 'a'-variabelen for den 'doble' datatypen. Deretter viser vi resultatet som er lagret i 'a' ved å bruke 'cout'.
Kode 2:
#includeved hjelp av navneområde std ;
int hoved- ( tomrom ) {
dobbelt en = 1.0 / 5000 ;
cout << 'Min doble verdi er' << en ;
komme tilbake 0 ;
}
Produksjon:
Her er resultatet av den gitte doble datatypeverdien. Vi kan enkelt bruke de matematiske operasjonene på verdiene som returnerer det doble datatyperesultatet og vise dem i C++-koden vår.
Eksempel 3: Bruk av Setprecision()-metoden
Her vil vi bruke 'setprecision'-metoden. Vi inkluderer to overskriftsfiler: 'iosteam' og 'bits/stdc++.h'. 'Navneområdet std' blir deretter lagt til, noe som sparer oss fra å måtte inkludere nøkkelordet 'std' med hver av funksjonene våre individuelt. Funksjonen 'main()' kalles da under denne. Variabelen 'var_a' er nå deklarert med den 'doble' datatypen som har en verdi som inneholder et desimaltegn.
Siden vi ønsker å vise hele tallet, bruker vi 'setprecision()'-funksjonen i 'cout'-setningen. Vi sender '15' som parameter for denne funksjonen. Denne metoden hjelper deg med å angi antall verdier for desimaltegn i denne doble datatypeverdien. Presisjonen som vi angir her er '15'. Så den viser '15' tall med desimalverdien. Deretter legger vi 'var_a' i denne 'cout' etter å ha brukt 'setprecision()'-metoden for å skrive ut denne 'doble' datatypeverdien.
Kode 3:
#include#include
ved hjelp av navneområde std ;
int hoved- ( tomrom ) {
dobbelt var_a = 7,9765455419016 ;
cout << settpresisjon ( femten ) << 'Den doble verdien vi plasserte her = ' << var_a ;
komme tilbake 0 ;
}
Produksjon:
Her kan vi se at den fullstendige verdien som vi skrev inn i koden vises. Dette er fordi vi brukte «setprecision()»-funksjonen i koden vår og satte presisjonstallet til «15».
Eksempel 4:
'iomanip' og 'iostream' er de to overskriftsfilene. 'iomanip' brukes fordi 'setprecision()'-funksjonen er deklarert i denne overskriftsfilen. Deretter settes 'std'-navnerommet inn og påkaller 'main()'. Den første variabelen av 'dobbel' datatypen som er deklarert her er 'dbl_1' og den andre variabelnavnet er 'dbl_2'. Vi tildeler forskjellige verdier til begge variablene som inneholder desimaltegn. Nå bruker vi samme presisjonstall for begge verdiene ved å bruke 'setpercision()'-funksjonen og sende '12' her.
Nå er presisjonstallet for begge verdiene satt til '12' som betyr at disse verdiene viser '12' verdier. Vi bruker denne 'setprecision()'-funksjonen etter å ha plassert 'cout'-funksjonen. Under dette skriver vi ut begge verdiene av 'dobbel' datatypen med 'cout'.
Kode 4:
#include#include
ved hjelp av navneområde std ;
int hoved- ( ) {
dobbelt dbl_1 = 9,92362738239293 ;
dobbelt dbl_2 = 6.68986442623803 ;
cout << settpresisjon ( 12 ) ;
cout << 'Dobbelt Type nummer 1 = ' << dbl_1 << endl ;
cout << 'Dobbelt type nummer 2 = ' << dbl_2 << endl ;
komme tilbake 0 ;
}
Produksjon:
Vi legger kanskje merke til at den viser 12 verdier og ignorerer alle andre verdier for denne 'doble' datatypeverdien fordi vi angir presisjonsverdien i koden vår.
Eksempel 5:
Her erklærer vi tre variabler: 'new_d1', 'new_d2' og 'new_d3'. Datatypen for alle tre verdiene er 'dobbel'. Vi tildeler også verdiene til alle disse variablene. Nå ønsker vi å sette forskjellige presisjonsverdier for alle tre variablene. Vi setter '15' for den første variabelverdien ved å sende '15' som parameteren til 'setprecision()'-funksjonen inne i 'cout'. Etter dette setter vi '10' som presisjonsverdien til den andre variabelens verdi og setter '6' som presisjonstallet for denne tredje verdien.
Kode 5:
#include#include
ved hjelp av navneområde std ;
int hoved- ( ) {
dobbelt ny_d1 = 16.6393469106198566 ;
dobbelt ny_d2 = 4.01640810861469 ;
dobbelt ny_d3 = 9,95340810645660 ;
cout << 'Dobbelt typenummer med presisjon 15 = ' << settpresisjon ( femten ) << ny_d1 << endl ;
cout << 'Dobbelt typenummer med presisjon 10 = ' << settpresisjon ( 10 ) << ny_d2 << endl ;
cout << 'Dobbelt typenummer med presisjon 6 = ' << settpresisjon ( 6 ) << ny_d3 << endl ;
komme tilbake 0 ;
}
Produksjon:
Alle tre verdiene er forskjellige her siden vi justerer de forskjellige presisjonsverdiene for dem alle. Den første verdien inneholder '15'-tall siden vi satte presisjonsverdien til '15'. Den andre verdien inneholder '10' tall på grunn av presisjonsverdien '10', og den tredje verdien viser '6' tall her siden presisjonsverdien er justert til '6' i koden.
Eksempel 6:
Vi initialiserer fire variabler her: to initialiseres med desimalverdiene og de to andre initialiseres med eksponentielle verdier. Etter dette bruker vi det 'faste' formatet på alle fire variablene ved å plassere dem inne i 'cout'. Under dette bruker vi det 'vitenskapelige' formatet på disse variablene separat ved å plassere dem i 'cout' etter å ha brukt søkeordet 'vitenskapelig'.
Kode 6:
#include#include
ved hjelp av navneområde std ;
int hoved- ( ) {
dobbelt min_dbl_1 = 7,7637208968554 ;
dobbelt min_eks_1 = 776e+2 ;
dobbelt min_dbl_2 = 4.6422657897086 ;
dobbelt min_eks_2 = 464e+2 ;
cout << 'Ved å bruke det faste søkeordet' << endl ;
cout << 'Første dobbelttypenummer = ' << fikset << min_dbl_1 << endl ;
cout << 'Andre dobbelttypenummer = ' << fikset << min_eks_1 << endl ;
cout << 'Tredje dobbelttypenummer = ' << fikset << min_dbl_2 << endl ;
cout << 'Fjerde dobbelttypenummer = ' << fikset << min_eks_2 << endl ;
cout << endl ;
cout << 'Ved å bruke det vitenskapelige nøkkelordet:' << endl ;
cout << 'Første dobbelttypenummer = ' << vitenskapelig << min_dbl_1 << endl ;
cout << 'Andre dobbelttypenummer = ' << vitenskapelig << min_eks_1 << endl ;
cout << 'Tredje dobbelttypenummer = ' << vitenskapelig << min_dbl_2 << endl ;
cout << 'Fjerde dobbelttypenummer = ' << vitenskapelig << min_eks_2 << endl ;
komme tilbake 0 ;
}
Produksjon:
Dette resultatet viser utdata etter bruk av de 'faste' og 'vitenskapelige' formatene på de 'doble' datatypeverdiene. Det 'faste' formatet brukes på de fire første verdiene. På de siste fire verdiene brukes det 'vitenskapelige' formatet og viser resultatet her.
Konklusjon
Konseptet 'utskrift dobbel' datatype er diskutert i detalj her. Vi utforsket de forskjellige teknikkene for å skrive ut den 'doble' datatypen i C++-programmering. Vi demonstrerte de tre forskjellige teknikkene som hjelper oss med å skrive ut de 'doble' datatypeverdiene; disse er 'setprecision()', 'fixed' og 'scientific'. Vi har grundig utforsket alle teknikkene i denne veiledningen.