c jak převést int na float


Odpověď 1:

Za prvé, pokud je nefrakční část floatu reprezentovatelná jako int, existuje implicitní převod, který „zaokrouhluje na nulu“ (tj. Upustí zlomek):

int r (float f) { int výsledek = f;vrátit výsledek; // Stačí napsat „return f;“ namísto.}

Všimněte si, že pokud int nemůže představovat výsledek, „chování je nedefinováno“ (což znamená, že váš program může dělat cokoli, co se standardu týká).

Pokud to není zaokrouhlení, které chcete, existuje řada standardních knihovních funkcí deklarovaných v to může stačit. Nejprve jednodušší:

  • ceilf / floorf zaokrouhlit nahoru, respektive dolů. Výsledkem je stále float, můžete použít implicitní převod popsaný výše a získat int.
  • Roundf, který se zaokrouhlí na nejbližší celočíselnou hodnotu, kromě toho, že případ .5 je zaokrouhlen od nuly (takže 1,5 F je zaokrouhleno na 2,0 F, ale -3,5 F je zaokrouhleno na -4,0 F).
  • lroundf a llroundf, které jsou podobné roundf, ale vytvářejí dlouhý nebo dlouhý dlouhý výsledek. Pokud nelze teoretický výsledek reprezentovat typem výsledku, skutečný výsledek není specifikován (tj. Může to být „jakákoli“ hodnota daného typu). errno může být nastaveno na EDOM nebo ERANGE.
  • truncf, který je podobný implicitní převodu popsané výše, s výjimkou, že výsledek je stále float.

Existují další funkce zaokrouhlování (také v ) jehož chování zaokrouhlování je určeno „aktuálním směrem zaokrouhlování“ stanoveným voláním fesetround (funkce deklarovaná v , hlavička, která se zabývá řadou nastavení v „prostředí s plovoucí desetinnou čárkou“). Argumentem této funkce musí být hodnota jednoho ze standardních maker FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO nebo FE_UPWARD, ale některá z těchto maker může být nedefinována, pokud není k dispozici odpovídající režim zaokrouhlování. Aktuální režim zaokrouhlování můžete načíst pomocí fegetround (). Funkce, které to berou v úvahu, jsou:

  • nearbyintf a rintf, které jsou jako roundf kromě toho, že případ .5 sleduje aktuální směr zaokrouhlování (a rintf může vyvolat výjimku s plovoucí desetinnou čárkou označující „nepřesný“ výsledek).
  • lrintf a llrintf, které jsou podobné nearintint, ale vytvářejí dlouhý, respektive dlouhý dlouhý výsledek. Pokud nelze teoretický výsledek reprezentovat typem výsledku, skutečný výsledek není specifikován (tj. Může to být „jakákoli“ hodnota daného typu). errno může být nastaveno na EDOM nebo ERANGE.

Odpověď 2:

Nejjednodušší způsob je int x = (int) (f + 0,5); To většinou funguje u kladných čísel. pro záporná čísla můžete odečíst 0,5. nebo

Definujte funkci absolutní hodnoty a funkci zaokrouhlení:

#define ABS (X) ((X> = 0)? X: - (x))#def ROUND (X) (X> = 0)? (int) (X + 0,5): (int) - (ABS (X) +0,5)int x = ROUND (f);

Algoritmický

Algoritmický způsob matematického zaokrouhlování je: 1. Rozhodněte, kolik desetinných míst bude považovat za významné (n) 2. Vydělte číslo 10 ^ {- n}. (m) 3. Vezměte výsledek nejbližšího celého čísla. (kulatý plovák na 1 místo). (q) 4. Vynásobte m * q a získejte zaokrouhlené číslo. (z) 5. převést na celé číslo: Pokud je zlomková část> 0,5, zkraťte zkrácenou část a přidejte 1. jinak zkraťte zlomkovou část.

Proč? Protože výchozím nastavením pro C je zaokrouhlování zlomkové části dolů, bez ohledu na to, jak blízko je k 1. Takže musíte číslo vydělit malým množstvím, abyste zohlednili významné číslice. zaokrouhlením přechodného výsledku se postaráte o chyby zaokrouhlování.

Obecně pro: kladná čísla: pokud je číslo napravo od desetinné čárky (desáté místo)> = 5 zaokrouhleno nahoru na další vyšší číslici, jinak zkrátit. záporná čísla: pokud je číslo napravo od desetinné čárky (desáté místo) <= 5 zkráceno, jinak zaokrouhleno dolů na další zápornou číslici. To se postará o okrajový případ přesně 0,5 kladného nebo záporného.

/ * příklady, dobré a špatné * /int x;float f, m, n, p, z; // dobrý f = -13,486;n = 0,01; // dvě místam = f / n; // m = -1348,6m = ceilf (m); // m = -1348,0z = m / n; // z = -13,48x = (int) z; // x = -13// dobrýf = 0,501; n = 0,1; // jedno místom = f / n; // m = 5,01m = ceilf (m); // m = 6,0z = m / n; // z = .6x = (int) z; // x = 1// špatné f = 13,486;n = ceilf (f); // n = 14 000// špatnéf = -13,486;n = floorf (f); // n = -14 000// špatné kvůli nesrovnalostemf = 0,50; n = ceilf (f); // n = 1,0n = floorf (f); // n = 0,0f = -0,50; n = ceilf (f); // n = 0,0n = floorf (f); // n = -1,0// stále nic dobrého f = 0,50;n = 0,1; // 1 místom = f / n; // m = 5,0m = ceilf (m); // m = 5,0z = m / n; // z = 0,5x = (int) z; // x = 0 není tak dobrý// vyzkoušet roundf f = 0,5;m = roundf (f); // m = 1,0p = roundf (-f) // m = -1,0f = -0,5;m = roundf (f); // m = -1,0p = roundf (-f) // m = 1,0

Odpověď 3:

Můžete to udělat pomocí odlévání typu. Syntaxe je-

Příklad:

float x;

x = 3,14;

int y;

y = (int) x;

printf („% d“, y);

Výstup:

3

Co se skutečně stalo? Vysvětlím to slavnou analogií.

Vzpomeňte si na kbelík zcela naplněný vodou. Předpokládejme, že máte hrnek. Jakou maximální vodu můžete z kbelíku vytáhnout? Odpověď - Hrnek.

Zde je kbelík float (4 bajty) a hrnek je int (2 bajty). Odlévání typu je proces plnění a při tom dochází ke ztrátě vody (dat).

Snad to pomůže;)


Odpověď 4:

Jakékoli číslo float nelze převést na celé číslo. ale celé číslo lze převést na float pomocí jeho formátu

specifikátor. jako

v níže uvedeném příkladu lze float předat do proměnné typu integer. po předání hodnoty do celočíselné proměnné se převede na float hodnotu.

#zahrnout

neplatné číslo (int e)

{

printf ("% d", e);

}

int main ()

{

float c = 9,0000;

číslo (c);

}

ve výše uvedeném příkladu jsme předali float hodnotu celočíselné proměnné. výstup výše uvedeného programu bude 9.


Odpověď 5:

Existuje několik přístupů k zaokrouhlování. Podívejte se na tyto funkce knihovny, které jsou k dispozici od C99:

  • roundf, který vrací float, který je integrální hodnotou nejblíže argumentu, přičemž případy v polovině jsou zaokrouhleny od nuly.
  • floorf, který se zaokrouhluje dolů a vrací největší celočíselnou hodnotu, která není větší než argument.
  • ceilf, který se zaokrouhluje nahoru a vrací nejmenší celočíselnou hodnotu, která není menší než argument.
  • nearbyintf, který zaokrouhluje na integrální hodnotu pomocí směru zaokrouhlování určeného fegetround (který vrací hodnotu, která označuje režim směru zaokrouhlování, jak je specifikováno v aktuálním prostředí s plovoucí desetinnou čárkou.)

Každá z těchto funkcí obdrží argument float a vrátí výsledek float, který pak můžete vrhnout na int.


Odpověď 6:

Funkce round () v math.h bude fungovat. Následující by mělo být kompilováno a fungovat dobře (i když jsem to ve skutečnosti nezkompiloval):

#zahrnout / * Importujte prototyp pro round () z math.h * dvojité kolo (dvojité); * /#zahrnout int main () { float i = 5,4, j = 5,6; / * Každá z následujících implicitně vrhá float na dvojnásobek * pro parametr a potom může být dvojitý výsledek bezpečně* cast na int bez ztráty přesnosti. Samozřejmě ty * může chtít použít long místo int, ale to by záleželo * na očekávaný rozsah. * /int ii = (int) kolo (i); / * Hrozné názvy proměnných, ale je to jen příklad. * / int jj = (int) kolo (j);/ * Nyní vytiskněte hodnoty. * / printf ("kolo% f je% f, což je také% d \ n", i, kolo (i), ii); printf ("kolo% f je% f, což je také% d \ n", j, kolo (j), jj); návrat 0;}

Příklad je upraven z:

C - funkce round ()

.


Odpověď 7:

Pro převod čísla float na celé číslo musíte použít přetypování typu (Typecasting neboli převod typu je metoda změny entity z jednoho datového typu na jiný).

#zahrnout void main () { float var1 = 3,141592653589793238; int var2;var2 = (int) var1; // psaní na typ (převod floatu na celé číslo) printf ("Hodnota celého čísla:% d", var2);}

Výstup


Odpověď 8:

Odpověď: (int)

Můžete jednoduše použít cast (int) k převodu float na celé číslo.

Takhle

your_variable = (int) your_variable

Jaká je funkce (int)?

Říká kompilátoru, že chcete s hodnotou vrácenou malloc zacházet jako s ukazatelem na celé číslo.


Odpověď 9:
float a = 2,33;int b = (int) a;printf ("% d", b);

Výstup bude: 2


Odpověď 10:

Automatické odlévání typu probíhá, když

  • oba typy jsou kompatibilní
  • cílový typ je větší než typ zdroje

Příklad:

test veřejné třídy{ public static void main (String [] args) { int i = 100; dlouhé l = i; // není nutné žádné explicitní přetypování typufloat f = l; // není nutné žádné explicitní přetypování typu System.out.println ("Int hodnota" + i); System.out.println ("Dlouhá hodnota" + l); System.out.println ("Plovoucí hodnota" + f); } }

Výstup :

Int hodnota 100Dlouhá hodnota 100Plovoucí hodnota 100,0

Odpověď 11:

Můžete použít 2 funkce, „floor ()“ a „ceil ()“ k převodu plovoucí hodnoty na celé číslo. Příklad:-

float a = 3,5;

int b = podlaha (a); // toto nastaví „b“ na 3

int b = strop (a); // toto nastaví „b“ na 4