c hvordan man konverterer int til float


Svar 1:

For det første, hvis den ikke-fraktionerede del af en float kan repræsenteres som en int, eksisterer der en implicit konvertering, der "afrunder mod nul" (dvs. falder brønden):

int r (flyde f) { int resultat = f;returresultat // Du kan bare skrive "return f;" i stedet.}

Bemærk, at hvis int ikke kan repræsentere resultatet, er “adfærd udefineret” (hvilket betyder, at dit program har lov til at gøre noget, hvad standarden angår).

Hvis det ikke er den afrunding, du vil have, er der erklæret et antal standardbiblioteksfunktioner i det kan gøre tricket. Først de enklere:

  • loft / gulvf runde henholdsvis op eller ned. Resultatet er stadig flydende, du kan bruge den implicitte konvertering beskrevet ovenfor for at få en int.
  • roundf, der afrunder til nærmeste heltal, bortset fra at .5-sagen afrundes væk fra nul (så 1.5F afrundes til 2.0F, men -3.5F afrundes til -4.0F).
  • lroundf og llroundf, der ligner roundf, men producerer henholdsvis et langt eller langt langt resultat. Hvis det teoretiske resultat ikke kan repræsenteres af resultattypen, er det faktiske resultat uspecificeret (dvs. det kan være "uanset" værdi af den type). errno kan være indstillet til EDOM eller ERANGE.
  • truncf, der svarer til den implicitte konvertering beskrevet ovenfor, bortset fra at resultatet stadig er en float.

Der er yderligere afrundingsfunktioner (også i ) hvis afrundingsadfærd bestemmes af en "aktuel afrundingsretning", der er oprettet ved et kald til fesetround (en funktion erklæret i , en header, der beskæftiger sig med en række indstillinger i "floating-point-miljøet"). Argumentet for denne funktion skal være værdien af ​​en af ​​standardmakroerne FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO eller FE_UPWARD, men enhver af disse makroer kan være udefineret, hvis den tilsvarende afrundingstilstand ikke er tilgængelig. Du kan hente den aktuelle afrundingstilstand med fegetround (). De funktioner, der tager højde for det, er:

  • nearbyintf og rintf, som er som roundf bortset fra, at .5-sagen følger den aktuelle afrundingsretning (og rintf kan hæve en undtagelse med flydende punkt, der indikerer et "inexakt" resultat).
  • lrintf og llrintf, der ligner nearbyintf, men producerer henholdsvis et langt eller langt langt resultat. Hvis det teoretiske resultat ikke kan repræsenteres af resultattypen, er det faktiske resultat uspecificeret (dvs. det kan være "uanset" værdi af den type). errno kan være indstillet til EDOM eller ERANGE.

Svar 2:

Den enkleste måde er int x = (int) (f + 0,5); Dette fungerer det meste af tiden for positive tal. for negative tal kan du trække 0,5. eller

Definer en absolut værdifunktion og en rund funktion:

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

Algoritmisk

Den algoritmiske måde at afrunde matematisk på er: 1. Beslut, hvor mange decimaler der skal tages som signifikante (n) 2. Del tallet med 10 ^ {- n}. (m) 3. Tag det nærmeste heltal-resultat. (rund flyde til 1 sted). (q) 4. Multiplicer m * q for at få det afrundede tal. (z) 5. konverter til heltal: Hvis brøkdelen er> 0,5, trunkeres brøkdelen og tilføjes 1. ellers afkortes brøkdelen.

Hvorfor gøre dette? Fordi standard for C er at afrunde den brøkdel, uanset hvor tæt den er på 1. Så du er nødt til at dividere antallet med en lille mængde for at tage højde for de betydende cifre. ved at afrunde det mellemliggende resultat vil du tage dig af afrundingsfejl.

Generelt for: positive tal: hvis tallet til højre for decimalet (tiendedelen) er> = 5 rundes op til det næste højere ciffer, ellers afkortes det. negative tal: hvis tallet til højre for decimalet (tiendedelen) er <= 5 afkortet, ellers afrundes til det næste negative ciffer. Dette tager sig af edge case på nøjagtigt .5 positive eller negative.

/ * eksempler, gode og dårlige * /int x;flyde f, m, n, p, z; // godt f = -13,486;n = .01; // to stederm = f / n; // m = -1348,6m = loft (m); // m = -1348.0z = m / n; // z = -13,48x = (int) z; // x = -13// godtf = 0,501; n = 0,1; // et stedm = f / n; // m = 5,01m = loft (m); // m = 6,0z = m / n; // z = .6x = (int) z; // x = 1// dårligt f = 13,486;n = loft (f); // n = 14.000// dårligtf = -13,486;n = gulvf (f); // n = -14.000// dårligt på grund af uoverensstemmelserf = 0,50; n = loft (f); // n = 1.0n = gulvf (f); // n = 0,0f = -0,50; n = loft (f); // n = 0,0n = gulvf (f); // n = -1,0// stadig ikke godt f = 0,50;n = 0,1; // 1 pladsm = f / n; // m = 5,0m = loft (m); // m = 5,0z = m / n; // z = 0,5x = (int) z; // x = 0 ikke så god// prøv roundf f = 0,5;m = rundf (f); // m = 1.0p = roundf (-f) // m = -1.0f = -0,5;m = rundf (f); // m = -1,0p = roundf (-f) // m = 1.0

Svar 3:

Du kan gøre det ved hjælp af type casting. Syntaksen er-

Eksempel:

flyde x;

x = 3,14;

int y;

y = (int) x;

printf (“% d”, y);

Produktion:

3

Hvad skete der virkelig? Jeg forklarer det ved at tage en berømt analogi.

Tænk på en spand helt fyldt med vand. Antag nu, at du har et krus. Hvad er det maksimale vand, du kan tage ud af spanden? Svar - Et krus.

Her er spanden flydende (4 bytes), og kruset er int (2 bytes). Type støbning er processen med at fylde, og vand (data) går tabt, mens man gør det.

Håber dette hjælper;)


Svar 4:

Ethvert float-nummer kan ikke konverteres til heltal. men et heltal kan konverteres til float ved hjælp af dets format

specifikator. som

vist i nedenstående eksempel kan en float overføres til en heltalstypevariabel. efter at værdien sendes til en heltalsvariabel konverteres den til en floatværdi.

#omfatte

tomrum (int e)

{

printf ("% d", e);

}

int main ()

{

flyde c = 9,0000;

num (c);

}

i ovenstående eksempel har vi videregivet floatværdi til heltalsvariabel. output fra ovenstående program vil være 9.


Svar 5:

Der er flere tilgange til afrunding. Se på disse biblioteksfunktioner, som har været tilgængelige siden C99:

  • roundf, som returnerer en float, der er den integrale værdi, der er tættest på argumentet, med halvvejs tilfælde afrundet fra nul.
  • floorf, som afrunder nedad og returnerer den største integrale værdi, der ikke er større end argumentet.
  • ceilf, der afrunder opad og returnerer den mindste integrale værdi, der ikke er mindre end argumentet.
  • nearbyintf, der afrunder til en integreret værdi ved hjælp af den afrundingsretning, der er angivet af fegetround (som returnerer en værdi, der angiver afrundingsretningstilstanden som specificeret i det aktuelle flydende punktmiljø.)

Hver af disse funktioner modtager et float-argument og returnerer et float-resultat, som du derefter kan kaste til int.


Svar 6:

Funktionen runde () i matematik.h fungerer. Følgende skulle kompilere og fungere fint (selvom jeg faktisk ikke kompilerede det):

#omfatte / * Importer prototypen til runde () fra math.h * dobbelt runde (dobbelt) * /#omfatte int main () { flyde i = 5,4, j = 5,6; / * Hvert af de følgende kaster implicit float til dobbelt * for parameteren og derefter kan dobbeltresultatet være sikkert* cast til int uden tab af præcision. Selvfølgelig dig * ønsker måske at bruge lang i stedet for int, men det afhænger * på dit forventede interval. * /int ii = (int) runde (i); / * Horrid variabelnavne, men det er bare et eksempel. * / int jj = (int) runde (j);/ * Udskriv nu værdierne. * / printf ("runde af% f er% f, som også er% d \ n", i, runde (i), ii); printf ("runde af% f er% f, som også er% d \ n", j, runde (j), jj); returnere 0;}

Eksemplet er modificeret fra:

C - runde () funktion

.


Svar 7:

For at konvertere et float-nummer til et heltal, skal du bruge type casting (Typecasting eller typekonvertering er en metode til at ændre en enhed fra en datatype til en anden).

#omfatte ugyldig hoved () { flyde var1 = 3.141592653589793238; int var2;var2 = (int) var1; // typecasting (konvertering af float til heltal) printf ("Heltalsværdi:% d", var2);}

Produktion


Svar 8:

Svar: (int)

Du kan blot bruge cast (int) til at konvertere float til heltal.

Sådan her

din_variable = (int) din_variable

Hvad det er funktionen af ​​(int)?

Det fortæller kompilatoren, at du vil behandle den værdi, der returneres af malloc, som en markør til et heltal.


Svar 9:
flyde a = 2,33;int b = (int) a;printf ("% d", b);

Output vil være: 2


Svar 10:

Automatisk støbning af typen finder sted, når,

  • de to typer er kompatible
  • måltypen er større end kildetypen

Eksempel:

offentlig klassetest{ offentlig statisk ugyldig hoved (String [] args) { int i = 100; lang l = i; // ingen eksplicit type casting krævesflyde f = l; // ingen eksplicit type casting kræves System.out.println ("Int-værdi" + i); System.out.println ("Lang værdi" + l); System.out.println ("Flydeværdi" + f); } }

Output:

Int-værdi 100Lang værdi 100Flydningsværdi 100,0

Svar 11:

Nå, du kan bruge 2 funktioner, "gulv ()" og "loft ()" til at konvertere en flydeværdi til heltal. Eksempel:-

flyde a = 3,5;

int b = etage (a); // dette vil sætte “b” til 3

int b = loft (a); // dette vil sætte “b” til 4