c как да конвертирате int в float


Отговор 1:

Първо, ако не-дробната част на поплавък е представима като int, съществува неявно преобразуване, което „закръглява към нула“ (т.е. изпуска дробното):

int r (float f) { int резултат = f;връщане на резултат; // Можете просто да напишете "return f;" вместо.}

Имайте предвид, че ако int не може да представи резултата, „поведението е недефинирано“ (което означава, че вашата програма има право да прави каквото и да е, що се отнася до стандарта).

Ако това не е закръгляването, което искате, има няколко стандартни библиотечни функции, декларирани в това може да свърши работа. Първо по-опростените:

  • ceilf / floorf закръгляват съответно нагоре или надолу. Резултатът все още е плаващ, можете да използвате неявното преобразуване, описано по-горе, за да получите int.
  • roundf, който се закръглява до най-близката целочислена стойност, с изключение на това, че случаят .5 се закръглява от нула (така 1.5F се закръглява до 2.0F, но -3.5F се закръглява до -4.0F).
  • lroundf и llroundf, които са подобни на roundf, но съответно дават дълъг или дълъг дълъг резултат. Ако теоретичният резултат не може да бъде представен от типа резултат, действителният резултат е неуточнен (т.е. може да бъде „каквато и да е“ стойност от този тип). errno може да бъде зададено на EDOM или ERANGE.
  • truncf, което е подобно на неявното преобразуване, описано по-горе, с изключение на това, че резултатът все още е плаващ.

Има допълнителни функции за закръгляване (също в ), чието поведение на закръгляване се определя от „текуща посока на закръгляване“, установена чрез повикване към fesetround (функция, декларирана в , заглавка, която се занимава с различни настройки в „среда с плаваща запетая“). Аргументът на тази функция трябва да бъде стойността на един от стандартните макроси FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO или FE_UPWARD, но всеки от тези макроси може да е недефиниран, ако съответният режим на закръгляване е недостъпен. Можете да извлечете текущия режим на закръгляване с fegetround (). Функциите, които отчитат това, са:

  • nearbyintf и rintf, които приличат на roundf, с изключение на това, че случаят .5 следва текущата посока на закръгляване (и rintf може да предизвика изключение с плаваща запетая, което показва „неточен“ резултат).
  • lrintf и llrintf, които са подобни на nearbyintf, но съответно дават дълъг или дълъг дълъг резултат. Ако теоретичният резултат не може да бъде представен от типа резултат, действителният резултат е неуточнен (т.е. може да бъде „каквато и да е“ стойност от този тип). errno може да бъде зададено на EDOM или ERANGE.

Отговор 2:

Най-простият начин е int x = (int) (f + 0,5); Това работи през повечето време за положителни числа. за отрицателни числа можете да извадите 0,5. или

Дефинирайте функция на абсолютна стойност и кръгла функция:

#define ABS (X) ((X> = 0)? X: - (x))#def КРЪГЪЛ (X) (X> = 0)? (int) (X + 0.5): (int) - (ABS (X) +0.5)int x = КРЪГЪЛ (f);

Алгоритмична

Алгоритмичният начин за математическо закръгляване е: 1. Решете колко десетични знака да вземете като значими (n) 2. Разделете числото на 10 ^ {- n}. (m) 3. Вземете най-близкия резултат от цялото число. (кръгла плувка до място 1). (q) 4. Умножете m * q, за да получите закръгленото число. (z) 5. преобразуване в цяло число: Ако дробната част е> 0,5, отсечете дробната част и добавете 1. иначе пресечете дробната част.

Защо да го направя? Тъй като по подразбиране за C е закръгляването на дробната част, независимо колко близо е до 1. Така че трябва да разделите числото на малка сума, за да вземете предвид значимите цифри. чрез закръгляване на междинния резултат ще се погрижите за грешки в закръгляването.

Обикновено за: положителни числа: ако числото вдясно от десетичната запетая (мястото на десетите) е> = 5 закръглено до следващата по-висока цифра, в противен случай се отсече. отрицателни числа: ако числото вдясно от десетичната запетая (мястото на десетите) е <= 5 отсече, в противен случай закръглете надолу до следващата отрицателна цифра. Това се грижи за случая на ръба на точно .5 положителни или отрицателни.

/ * примери, добри и лоши * /int x;плуват f, m, n, p, z; // добре f = -13,486;п = .01; // две местаm = f / n; // m = -1348,6m = таван (m); // m = -1348,0z = m / n; // z = -13,48x = (int) z; // x = -13// добреf = 0,501; п = 0,1; // едно мястоm = f / n; // m = 5.01m = таван (m); // m = 6,0z = m / n; // z = .6x = (int) z; // x = 1// лошо f = 13,486;n = таван (f); // n = 14.000// лошоf = -13,486;n = етаж f (f); // n = -14.000// лошо поради несъответствияf = 0,50; n = таван (f); // n = 1.0n = етаж f (f); // n = 0.0f = -0,50; n = таван (f); // n = 0.0n = етаж f (f); // n = -1,0// все още не е добре f = 0,50;п = 0,1; // 1 мястоm = f / n; // m = 5,0m = таван (m); // m = 5,0z = m / n; // z = 0,5x = (int) z; // x = 0 не е толкова добре// опитайте 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

Отговор 3:

Можете да го направите, като използвате кастинг на тип. Синтаксисът е-

Пример:

плувка x;

х = 3,14;

int y;

y = (int) x;

printf („% d“, y);

Изход:

3

Какво всъщност се случи? Ще го обясня, като направя известна аналогия.

Помислете за кофа, напълно пълна с вода. А сега да предположим, че имате халба. Кой е максимумът вода, който можете да извадите от кофата? Отговор - Чаша.

Тук кофата е float (4 байта), а халбата е int (2 байта). Типовото леене е процесът на пълнене и водата (данните) се губи при това.

Надявам се това да помогне;)


Отговор 4:

Всяко число с плувка не може да бъде преобразувано в цяло число. но цяло число може да бъде преобразувано в плаващо с помощта на неговия формат

спецификатор

показано в примера по-долу, поплавък може да бъде прехвърлен в променлива от цял ​​тип. след като стойността се предаде в целочислена променлива, тя се преобразува в плуваща стойност.

#include

празно число (int e)

{

printf ("% d", e);

}

int main ()

{

поплавък c = 9,0000;

число (c);

}

в горния пример сме предали float стойност на целочислена променлива. изходът на горната програма ще бъде 9.


Отговор 5:

Има няколко подхода за закръгляване. Разгледайте тези библиотечни функции, които са достъпни от C99:

  • roundf, който връща плувка, която е интегралната стойност, най-близка до аргумента, с половината случаи, закръглени от нула.
  • floorf, който се закръгля надолу, връщайки най-голямата интегрална стойност, която не е по-голяма от аргумента.
  • ceilf, който се закръгля нагоре, връщайки най-малката интегрална стойност, която не е по-малка от аргумента.
  • nearbyintf, който закръглява до интегрална стойност, използвайки посоката на закръгляване, посочена от fegetround (която връща стойност, която показва режима на закръгляване, както е посочено в текущата среда с плаваща запетая.)

Всяка от тези функции получава аргумент с плувка и връща резултат с плувка, който след това можете да предадете на int.


Отговор 6:

Функцията round () в math.h ще работи. Следното трябва да се компилира и да работи добре (въпреки че всъщност не съм го компилирал):

#include / * Импортирайте прототипа за round () от math.h * двоен кръг (двоен); * /#include int main () { плувка i = 5,4, j = 5,6; / * Всяко от следните имплицитно хвърля поплавъка да се удвои * за параметъра и след това двойният резултат може да бъде безопасно* хвърляне към int без загуба на точност. Разбира се, вие * може да искате да използвате long вместо int, но това ще зависи * за очаквания диапазон. * /int ii = (int) кръг (i); / * Ужасни имена на променливи, но това е само пример. * / int jj = (int) кръг (j);/ * Сега отпечатайте стойностите. * / printf ("кръг от% f е% f, който също е% d \ n", i, кръг (i), ii); printf ("кръг от% f е% f, който също е% d \ n", j, round (j), jj); връщане 0;}

Примерът е модифициран от:

C - кръгла () функция

.


Отговор 7:

За преобразуване на плаващо число в цяло число трябва да използвате леене на тип (Typecasting или преобразуване на тип е метод за промяна на обект от един тип данни в друг).

#include void main () { плувка var1 = 3.141592653589793238; int var2;var2 = (int) var1; // typecasting (преобразуване на float в цяло число) printf ("Цяла стойност:% d", var2);}

Изход


Отговор 8:

Отговор: (int)

Можете просто да използвате cast (int), за да конвертирате float в цяло число.

Като този

your_variable = (int) your_variable

Каква е функцията на (int)?

Той казва на компилатора, че искате да третирате стойността, върната от malloc, като указател към цяло число.


Отговор 9:
плувка a = 2,33;int b = (int) a;printf ("% d", b);

Резултатът ще бъде: 2


Отговор 10:

Автоматично леене на тип се извършва, когато,

  • двата вида са съвместими
  • целевият тип е по-голям от типа източник

Пример:

публичен клас Тест{ публична статична void main (String [] args) { int i = 100; дълъг l = i; // не се изисква изрично леене на типплувка f = l; // не се изисква изрично леене на тип System.out.println ("Int стойност" + i); System.out.println ("Дълга стойност" + l); System.out.println ("Float value" + f); } }

Изход:

Int стойност 100Дълга стойност 100Плаваща стойност 100.0

Отговор 11:

Е, можете да използвате 2 функции, „floor ()“ и „ceil ()“, за да преобразувате плаваща стойност в цяло число. Пример: -

плувка a = 3,5;

int b = етаж (a); // това ще зададе „b“ на 3

int b = таван (a); // това ще зададе „b“ на 4