c comment convertir int en float


Réponse 1:

Premièrement, si la partie non fractionnaire d'un flottant est représentable comme un entier, une conversion implicite qui «arrondit vers zéro» (c'est-à-dire supprime la fraction) existe:

int r (float f) { résultat int = f;résultat de retour; // Vous pouvez simplement écrire "return f;" au lieu.}

Notez que si int ne peut pas représenter le résultat, «le comportement n'est pas défini» (ce qui signifie que votre programme est autorisé à faire quoi que ce soit en ce qui concerne le standard).

Si ce n'est pas l'arrondi souhaité, il existe un certain nombre de fonctions de bibliothèque standard déclarées dans cela peut faire l'affaire. D'abord les plus simples:

  • ceilf / floorf arrondis respectivement vers le haut ou vers le bas. Le résultat est toujours flottant, vous pouvez utiliser la conversion implicite décrite ci-dessus pour obtenir un int.
  • roundf, qui arrondit à la valeur entière la plus proche, sauf que la casse .5 est arrondie à l'écart de zéro (donc 1,5F est arrondi à 2,0F, mais -3,5F est arrondi à -4,0F).
  • lroundf et llroundf, qui sont similaires à roundf, mais produisent respectivement un résultat long ou long long. Si le résultat théorique ne peut pas être représenté par le type de résultat, le résultat réel n'est pas spécifié (c'est-à-dire qu'il peut s'agir de «n'importe quelle» valeur de ce type). errno peut être réglé sur EDOM ou ERANGE.
  • truncf, qui est similaire à la conversion implicite décrite ci-dessus, sauf que le résultat est toujours un float.

Il existe des fonctions d'arrondi supplémentaires (également ) dont le comportement d'arrondi est déterminé par une «direction d'arrondi courante» établie par un appel à fesetround (une fonction déclarée dans , un en-tête qui traite une variété de paramètres dans «l'environnement en virgule flottante»). L'argument de cette fonction doit être la valeur de l'une des macros standard FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO ou FE_UPWARD, mais l'une de ces macros peut être indéfinie si le mode d'arrondi correspondant n'est pas disponible. Vous pouvez récupérer le mode d'arrondi actuel avec fegetround (). Les fonctions qui en tiennent compte sont:

  • nearintf et rintf, qui sont comme roundf sauf que le cas .5 suit la direction d'arrondi actuelle (et rintf peut lever une exception à virgule flottante indiquant un résultat «inexact»).
  • lrintf et llrintf, qui sont similaires à nearintf, mais produisent respectivement un résultat long ou long long. Si le résultat théorique ne peut pas être représenté par le type de résultat, le résultat réel n'est pas spécifié (c'est-à-dire qu'il peut s'agir de «n'importe quelle» valeur de ce type). errno peut être réglé sur EDOM ou ERANGE.

Réponse 2:

Le moyen le plus simple est int x = (int) (f + 0,5); Cela fonctionne la plupart du temps pour les nombres positifs. pour les nombres négatifs, vous pouvez soustraire 0,5. ou

Définissez une fonction valeur absolue et une fonction arrondie:

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

Algorithmique

La manière algorithmique d'arrondir mathématiquement est la suivante: 1. Décidez du nombre de décimales à prendre comme significatif (n) 2. Divisez le nombre par 10 ^ {- n}. (m) 3. Prenez le résultat du nombre entier le plus proche. (rond du flotteur à la place de 1). (q) 4. Multipliez m * q pour obtenir le nombre arrondi. (z) 5. convertir en entier: si la partie fractionnaire est> 0,5, tronquer la partie fractionnaire et ajouter 1. sinon tronquer la partie fractionnaire.

Pourquoi faire ceci? Parce que la valeur par défaut pour C est d'arrondir la partie fractionnaire, quelle que soit sa proximité à 1. Vous devez donc diviser le nombre par une petite quantité pour prendre en compte les chiffres significatifs. en arrondissant le résultat intermédiaire, vous vous occuperez des erreurs d'arrondi.

Généralement pour: nombres positifs: si le nombre à droite de la décimale (la dixième place) est> = 5 arrondi au chiffre supérieur suivant, sinon tronquer. nombres négatifs: si le nombre à droite de la décimale (la dixième place) est <= 5 tronqué, sinon arrondissez au chiffre négatif suivant. Cela prend en charge le cas de bord d'exactement 0,5 positif ou négatif.

/ * exemples, bons et mauvais * /int x;float f, m, n, p, z; // bien f = -13,486;n = 0,01; // deux placesm = f / n; // m = -1348,6m = ceilf (m); // m = -1348,0z = m / n; // z = -13,48x = (entier) z; // x = -13// bienf = 0,501; n = 0,1; // une placem = f / n; // m = 5,01m = ceilf (m); // m = 6,0z = m / n; // z = 0,6x = (entier) z; // x = 1// mauvais f = 13,486;n = ceilf (f); // n = 14 000// mauvaisf = -13,486;n = plancherf (f); // n = -14 000// mauvais à cause d'incohérencesf = 0,50; n = ceilf (f); // n = 1,0n = plancherf (f); // n = 0,0f = -0,50; n = ceilf (f); // n = 0,0n = plancherf (f); // n = -1,0// toujours pas bon f = 0,50;n = 0,1; // 1 placem = f / n; // m = 5,0m = ceilf (m); // m = 5,0z = m / n; // z = 0,5x = (entier) z; // x = 0 pas si bon// essayez 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

Réponse 3:

Vous pouvez le faire en utilisant la conversion de type. La syntaxe est-

Exemple:

float x;

x = 3,14;

int y;

y = (entier) x;

printf («% d», y);

Production:

3

Que s'est-il vraiment passé? Je vais l'expliquer en prenant une analogie célèbre.

Pensez à un seau complètement rempli d'eau. Supposons maintenant que vous ayez une tasse. Quelle est la quantité maximale d'eau que vous pouvez retirer du seau? Réponse - Une tasse.

Ici, le seau est float (4 octets) et le mug est int (2 octets). Le moulage de type est le processus de remplissage, et l'eau (données) est perdue en le faisant.

J'espère que cela t'aides;)


Réponse 4:

Tout nombre flottant ne peut pas être converti en entier. mais un entier peut être converti en float en utilisant son format

spécificateur.

montré dans l'exemple ci-dessous, un flottant peut être passé dans une variable de type entier .Une fois que la valeur est passée dans une variable entière, elle est convertie en valeur flottante.

#comprendre

void num (int e)

{

printf ("% d", e);

}

int main()

{

flotteur c = 9,0000;

num (c);

}

dans l'exemple ci-dessus, nous avons passé une valeur flottante à une variable entière. la sortie du programme ci-dessus sera 9.


Réponse 5:

Il existe plusieurs méthodes d'arrondi. Jetez un œil à ces fonctions de bibliothèque, disponibles depuis C99:

  • roundf, qui renvoie un flottant qui est la valeur intégrale la plus proche de l'argument, avec des cas à mi-chemin arrondis à partir de zéro.
  • floorf, qui arrondit vers le bas, renvoyant la plus grande valeur intégrale qui n'est pas supérieure à l'argument.
  • ceilf, qui arrondit vers le haut, renvoyant la plus petite valeur intégrale qui n'est pas inférieure à l'argument.
  • nearintf, qui arrondit à une valeur intégrale, en utilisant la direction d'arrondi spécifiée par fegetround (qui renvoie une valeur qui indique le mode de direction d'arrondi, comme spécifié dans l'environnement en virgule flottante actuel.)

Chacune de ces fonctions reçoit un argument float et renvoie un résultat float, que vous pouvez ensuite convertir en int.


Réponse 6:

La fonction round () dans math.h fonctionnera. Ce qui suit devrait compiler et fonctionner très bien (bien que je ne l'ai pas réellement compilé):

#comprendre / * Importez le prototype pour round () depuis math.h * double tour (double); * /#comprendre int main() { float i = 5,4, j = 5,6; / * Chacun des éléments suivants convertit implicitement le flotteur en double * pour le paramètre, puis le double résultat peut être en toute sécurité* cast en int sans perte de précision. Bien sûr toi * pourrait vouloir utiliser long au lieu de int mais cela dépendrait * sur votre portée attendue. * /int ii = (int) round (i); / * Noms de variables horribles mais ce n'est qu'un exemple. * / int jj = (int) round (j);/ * Imprimez maintenant les valeurs. * / printf ("round de% f est% f qui est aussi% d \ n", i, round (i), ii); printf ("le tour de% f est% f qui est aussi% d \ n", j, round (j), jj); return 0;}

L'exemple est modifié à partir de:

C - fonction round ()

.


Réponse 7:

Pour convertir un nombre flottant en nombre entier, vous devez utiliser la conversion de type (le typage, ou conversion de type, est une méthode permettant de changer une entité d'un type de données à un autre).

#comprendre void main () { float var1 = 3,141592653589793238; int var2;var2 = (int) var1; // typecasting (conversion de float en entier) printf ("Valeur entière:% d", var2);}

Production


Réponse 8:

Réponse: (int)

Vous pouvez simplement utiliser cast (int) pour convertir float en entier.

Comme ça

votre_variable = (entier) votre_variable

Quelle est la fonction de (int)?

Il indique au compilateur que vous souhaitez traiter la valeur renvoyée par malloc comme un pointeur vers un entier.


Réponse 9:
flotteur a = 2,33;int b = (int) a;printf ("% d", b);

La sortie sera: 2


Réponse 10:

La coulée de type automatique a lieu lorsque,

  • les deux types sont compatibles
  • le type de cible est plus grand que le type de source

Exemple :

Test de classe publique{ public static void main (String [] args) { int i = 100; long l = i; // aucune conversion de type explicite requisefloat f = l; // aucune conversion de type explicite requise System.out.println ("Valeur int" + i); System.out.println ("Valeur longue" + l); System.out.println ("Valeur flottante" + f); } }

Production :

Valeur int 100Valeur longue 100Valeur flottante 100,0

Réponse 11:

Eh bien, vous pouvez utiliser 2 fonctions, «floor ()» et «ceil ()» pour convertir une valeur flottante en entier. Exemple:-

float a = 3,5;

int b = plancher (a); // cela mettra «b» à 3

int b = ceil (a); // cela mettra «b» à 4