Extrait de partie décimale d'un nombre à virgule flottante en C

Question

Comment peut-on extraire la partie décimale d'un nombre à virgule flottante et de stocker la partie décimale et la partie entière en deux variables entières séparées?

Answer 1

Vous utilisez la fonction modf:

double integral; 
double fractional = modf(some_double, &integral); 

Vous pouvez également jeter un entier, mais attention, vous pouvez déborder l'entier. Le résultat n'est pas prévisible alors.

Answer 2

Essayez ceci:

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, il produit:

Num = 23.345000, intpart = 23, decpart = 0.345000 

qui semble être ce que vous demandez.

Answer 3

I créé un sous-programme à l'aide d'une double flotteur, il renvoie 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); 
    } 
} 
 

Answer 4

Le rapide « dans une coquille de noix » réponse la plus évidente semble être:

#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 changerais le nombre de décimales que vous voulez en changeant la N_DECIMAL_POINTS_PRECISION en fonction de vos besoins.

Answer 5

Peut-être la meilleure idée est de résoudre le problème alors que les données sont au format chaîne. Si vous avez les données sous forme de chaîne, vous pouvez l'analyser en fonction du point décimal. Vous extrayez la partie intégrale et décimale en sous-chaînes, puis convertissez ces sous-chaînes en entiers réels.

Answer 6

J'ai fait cette fonction, il semble bien fonctionner:

#include <math.h> 

void GetFloattoInt (double fnum, long precision, long *pe, long *pd) 
{ 
    long pe_sign; 
    long intpart; 
    float decpart; 

    if(fnum>=0) 
    { 
    pe_sign=1; 
    } 
    else 
    { 
    pe_sign=-1; 
    } 

    intpart=(long)fnum; 
    decpart=fnum-intpart; 

    *pe=intpart; 
    *pd=(((long)(decpart*pe_sign*pow(10,precision)))%(long)pow(10,precision)); 
} 

Answer 7

Voici une autre façon:

#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 

} 

http://codepad.org/jyHoBALU

Sortie:

whole: 123 
mantissa: 4567 

Answer 8

Je pense que l'utilisation string 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 dans tous les cas (par exemple, 1.005), comme mentionné précédemment par @SingleNegationElimination. Voici mon avis 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; 
} 

Answer 9

Si vous voulez juste pour 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; 

Dites par exemple, nous avons une valeur flottante initiale de 27,8. En convertissant simplement la valeur initiale du flottant en entier, vous supprimez la partie fraction et ne gardez que la partie entière.En multipliant la valeur flottante initiale par 10, nous obtenons un résultat de 278,0, puis en donnant ce résultat à int, vous donne la valeur de 278

Si nous divisons 278 par 10, nous obtenons 27,8, dont le reste est 8, qui est la valeur à droite du point décimal. Utilisez donc le module. Cette technique peut ensuite être utilisée pour obtenir les caractères décimaux suivants en utilisant, par exemple, 100 au lieu de 10, et ainsi de suite.

---

Il suffit de prendre note que si vous utilisez cette technique sur les systèmes en temps réel, par exemple pour l'afficher sur un afficheur 7 segments, il ne fonctionne pas correctement parce que nous multiplions avec une valeur flottante, où la multiplication prend beaucoup de temps.

Answer 10

cout<<"enter a decimal number\n"; 
cin>>str; 
for(i=0;i<str.size();i++) 
{ 
    if(str[i]=='.') 
    break; 
} 

for(j=i+1;j<str.size();j++) 
{ 
    cout<<str[j]; 
} 

Answer 11

Même je pensais comment le 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