Tizedes pontosság beállítása C nyelven

Ez a cikk megmutatja, hogyan állíthatja be a decimális pontosságot a C programozási nyelvben. Először meghatározzuk a pontosságot, majd több példát is megvizsgálunk, hogy bemutassuk, hogyan állíthatjuk be a decimális pontosságot a C programozásban.

Tizedes pontosság C-ban

Az egész típusú változót általában a teljes szám, az úszó típusú változót pedig a valós számok és tört részek megtartására használják, például 2.449561 vagy -1.0587. A pontosság meghatározza a valós számok pontosságát, és pont (.) szimbólum. A valós számok pontosságát vagy pontosságát a tizedesjegy utáni számjegyek száma jelzi. Tehát a pontosság az úszószám tizedespontja után említett számjegyek számát jelenti. Például a 2. szám.A 449561 pontossága hat és -1.A 058-as pontossága három.

Az IEEE-754 egypontos lebegőpontos ábrázolása szerint összesen 32 bit tárolja a valós számot. A 32 bit közül a legjelentősebb bitet használjuk előjelbitként, a következő 8 bitet használjuk exponensként, és a következő 23 bitet használjuk törtként.

Az IEEE-754 kettős pontosságú lebegőpontos ábrázolása esetén összesen 64 bit van a valós szám tárolására. A 64 bit közül a legjelentősebb bitet használjuk előjelbitként, a következő 11 bitet használjuk kitevőként, és a következő 52 bitet használjuk töredékként.

A valós számok nyomtatásakor azonban meg kell adni a valós szám pontosságát (más szóval pontosságát). Ha a pontosság nincs megadva, akkor az alapértelmezett pontosságot vesszük figyelembe, azaz.e., hat tizedesjegy a tizedesjegy után. A következő példákban megmutatjuk, hogyan kell megadni a pontosságot, amikor lebegőpontos számokat nyomtatunk a C programozási nyelvre.

Példák

Most, hogy alaposan megértette a pontosságot, nézzünk meg néhány példát:

1. Alapértelmezett pontosság az úszóhoz
2. Alapértelmezett pontosság a kettősnél
3. Állítsa be az úszó pontosságát
4. Állítsa be a dupla pontosságot

1. példa: Alapértelmezett pontosság az úszóhoz

Ez a példa azt mutatja, hogy az alapértelmezett pontosság a tizedesjegy után hat jegyre van állítva. Inicializáltunk egy úszó változót a 2 értékkel.7 és kinyomtatta, anélkül, hogy kifejezetten megadta volna a pontosságot.

Ebben az esetben az alapértelmezett precíziós beállítás biztosítja, hogy a tizedesjegy után hat számjegyet nyomtassanak.

#include
int main ()

úszó f = 2.7;
printf ("\ nA f =% f \ n értéke, f);
printf ("Az úszó mérete =% ld \ n", sizeof (úszó));
visszatér 0;

2. példa: Alapértelmezett pontosság a dupla esetén

Ebben a példában látni fogja, hogy az alapértelmezett pontosság hatjegyűre van állítva a tizedespont után a kettős típusú változóknál. Inicializáltunk egy kettős változót, azaz.e., d, 2 értékkel.7, és a pontosság megadása nélkül kinyomtatta. Ebben az esetben az alapértelmezett precíziós beállítás biztosítja a tizedesjegy utáni hat számjegy kinyomtatását.

#include
int main ()

dupla d = 2.7;
printf ("\ nA d értéke =% lf \ n", d);
printf ("A dupla mérete =% ld \ n", sizeof (dupla));
visszatér 0;

3. példa: Állítsa be az úszás pontosságát

Most megmutatjuk, hogyan állíthatja be az úszóértékek pontosságát. Inicializáltunk egy úszó változót, azaz.e., f, 2 értékkel.7, és különféle pontosságú beállításokkal nyomtatta ki. Amikor megemlítjük a „% 0.4f ”a printf utasításban, ez azt jelzi, hogy érdekel minket négy számjegy tizedesjegy utáni nyomtatása.

#include
int main ()

úszó f = 2.7;
/ * állítsa be az úszóváltozó pontosságát * /
printf ("\ nf értéke (pontosság = 0.1) =% 0.1f \ n ", f);
printf ("\ nf értéke (pontosság = 0.2) =% 0.2f \ n ", f);
printf ("\ nf értéke (pontosság = 0.3) =% 0.3f \ n ", f);
printf ("\ n f értéke (pontosság = 0.4) =% 0.4f \ n ", f);
printf ("\ n f értéke (pontosság = 0.22) =% 0.22f \ n ", f);
printf ("\ nf értéke (pontosság = 0.23) =% 0.23f \ n ", f);
printf ("\ nf értéke (pontosság = 0.24) =% 0.24f \ n ", f);
printf ("\ nf értéke (pontosság = 0.25) =% 0.25f \ n ", f);
printf ("\ nf értéke (pontosság = 0.40) =% 0.40f \ n ", f);
printf ("Az úszó mérete =% ld \ n", sizeof (úszó));
visszatér 0;

4. példa: Állítsa be a Precision pontot a Double értékre

Ebben a példában meglátjuk, hogyan állíthatjuk be a pontosságot a kettős értékekhez. Inicializáltunk egy kettős változót, azaz.e., d, 2 értékkel.7, és különféle pontosságú beállításokkal nyomtatta ki. Amikor megemlítjük a „% 0.52f ”a printf utasításban, ez azt jelzi, hogy érdekel minket 52 számjegy tizedesjegy utáni nyomtatása.

#include
int main ()

úszó f = 2.7;
/ * állítsa be az úszóváltozó pontosságát * /
printf ("\ nf értéke (pontosság = 0.1) =% 0.1f \ n ", f);
printf ("\ nf értéke (pontosság = 0.2) =% 0.2f \ n ", f);
printf ("\ nf értéke (pontosság = 0.3) =% 0.3f \ n ", f);
printf ("\ nf értéke (pontosság = 0.4) =% 0.4f \ n ", f);
printf ("\ n f értéke (pontosság = 0.22) =% 0.22f \ n ", f);
printf ("\ nf értéke (pontosság = 0.23) =% 0.23f \ n ", f);
printf ("\ nf értéke (pontosság = 0.24) =% 0.24f \ n ", f);
printf ("\ n f értéke (pontosság = 0.25) =% 0.25f \ n ", f);
printf ("\ nf értéke (pontosság = 0.40) =% 0.40f \ n ", f);
printf ("Az úszó mérete =% ld \ n", sizeof (úszó));
visszatér 0;

Következtetés

A pontosság nagyon fontos tényező a valós szám megfelelő pontossággal történő ábrázolásához. A c programozási nyelv biztosítja a valós szám pontosságának vagy pontosságának ellenőrzésére szolgáló mechanizmust. A valós szám tényleges pontosságát azonban nem tudjuk megváltoztatni. Például a 32 bites egypontos lebegőpontos szám törtrészét 23 bit képviseli, és ez fix; ezt nem tudjuk megváltoztatni egy adott rendszerre. Csak a valós szám kívánt pontosságának beállításával tudjuk eldönteni, hogy mekkora pontosságot akarunk. Ha nagyobb pontosságra van szükségünk, akkor mindig használhatjuk a 64 bites kettős pontosságú lebegőpontos számot.