Comment pouvons-nous extraire la partie décimale d'un nombre à virgule flottante et stocker la partie décimale et la partie entière dans deux variables entières distinctes?
Vous utilisez la fonction modf
:
double integral;
double fractional = modf(some_double, &integral);
Vous pouvez également le convertir en un entier, mais sachez que vous pouvez dépasser le nombre entier. Le résultat n'est pas prévisible alors.
Essaye ça:
int main() {
double num = 23.345;
int intpart = (int)num;
double decpart = num - intpart;
printf("Num = %f, intpart = %d, decpart = %f\n", num, intpart, decpart);
}
Pour moi, cela produit:
Num = 23.345000, intpart = 23, decpart = 0.345000
Ce qui semble être ce que vous demandez.
La réponse la plus évidente "dans une coquille" rapide ressemble à:
#define N_DECIMAL_POINTS_PRECISION (1000) // n = 3. Three decimal points.
float f = 123.456;
int integerPart = (int)f;
int decimalPart = ((int)(f*N_DECIMAL_POINTS_PRECISION)%N_DECIMAL_POINTS_PRECISION);
Vous voudriez changer le nombre de points décimaux que vous souhaitez en modifiant le N_DECIMAL_POINTS_PRECISION
pour l'adapter à vos besoins.
Je pense que l'utilisation de chaîne est la bonne façon de procéder dans ce cas, puisque vous ne connaissez pas a priori le nombre de chiffres dans la partie décimale. Mais cela ne fonctionnera pas pour tous les cas (par exemple 1,005), comme mentionné précédemment par @SingleNegationElimination. Voici mon point de vue sur ceci:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char s_value[60], s_integral[60], s_fractional[60];
int i, found = 0, count = 1, integral, fractional;
scanf("%s", s_value);
for (i = 0; s_value[i] != '\0'; i++)
{
if (!found)
{
if (s_value[i] == '.')
{
found = 1;
s_integral[i] = '\0';
continue;
}
s_integral[i] = s_value[i];
count++;
}
else
s_fractional[i - count] = s_value[i];
}
s_fractional[i - count] = '\0';
integral = atoi(s_integral);
fractional = atoi(s_fractional);
printf("value = %s, integral = %d, fractional = %d\n",
s_value, integral, fractional);
return 0;
}
J'ai créé un sous-programme utilisant un double float, il retourne 2 valeurs entières.
void double2Ints(double f, int p, int *i, int *d)
{
// f = float, p=decimal precision, i=integer, d=decimal
int li;
int prec=1;
for(int x=p;x>0;x--)
{
prec*=10;
}; // same as power(10,p)
li = (int) f; // get integer part
*d = (int) ((f-li)*prec); // get decimal part
*i = li;
}
void test()
{
double df = 3.14159265;
int i,d;
for(int p=2;p<9;p++)
{
double2Ints(df, p, &i,&d); printf("d2i (%d) %f = %d.%d\r\n",p, df,i,d);
}
}
Même moi je pensais comment faire. Mais j'ai trouvé un moyen… .. Essayez ce code
printf("Enter a floating number");
scanf("%d%c%d", &no, &dot, &dec);
printf("Number=%d Decimal part=%d", no, dec);
Sortie:-
Enter a floating number
23.13
Number=23 Decimal part=13
#include <stdio.h>
Int main ()
{
float f=56.75;
int a=(int)f;
int result=(f-a)*100;
printf ("integer = %d\n decimal part to integer
=%d\n",result);
}
Output:-
integer =56
decimal part to integer = 75
Supposons que A soit votre nombre entier, alors (int) A, signifie convertir le nombre en un entier et sera la partie entière, l’autre étant (A - (int) A) * 10 ^ n, n étant le nombre de décimales .
Voici un autre moyen:
#include <stdlib.h>
int main()
{
char* inStr = "123.4567"; //the number we want to convert
char* endptr; //unused char ptr for strtod
char* loc = strchr(inStr, '.');
long mantissa = strtod(loc+1, endptr);
long whole = strtod(inStr, endptr);
printf("whole: %d \n", whole); //whole number portion
printf("mantissa: %d", mantissa); //decimal portion
}
Sortie:
whole: 123
mantissa: 4567
Si vous voulez juste obtenir la première valeur décimale, la solution est très simple.
Voici un exemple explicatif:
int leftSideOfDecimalPoint = (int) initialFloatValue; // The cast from float to int keeps only the integer part
int temp = (int) initialFloatValue * 10;
int rightSideOfDecimalPoint = temp % 10;
Disons par exemple que nous avons une valeur de flottement initiale de 27,8.
Cette technique peut ensuite être utilisée pour obtenir les caractères décimaux suivants en utilisant par exemple 100 au lieu de 10, etc.
Notez simplement que si vous utilisez cette technique sur des systèmes temps réel, par exemple pour l'afficher sur un affichage à 7 segments, elle risque de ne pas fonctionner correctement car nous sommes en train de multiplier avec une valeur flottante, où la multiplication prend beaucoup de temps.