¿Cómo extraer la parte decimal de un número de punto flotante en C?

¿Cómo podemos extraer la parte decimal de un número de punto flotante y almacenar la parte decimal y la parte entera en dos variables enteras separadas?

usas el modf función:

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

También puede convertirlo en un número entero, pero tenga en cuenta que puede desbordar el número entero. El resultado no es predecible entonces.

Prueba esto:

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);
}

Para mí, produce:

Num = 23.345000, intpart = 23, decpart = 0.345000

Que parece ser lo que estás pidiendo.

La respuesta rápida “en pocas palabras” más obvia parece:

#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);

Cambiaría la cantidad de puntos decimales que desea cambiando el N_DECIMAL_POINTS_PRECISION para satisfacer sus necesidades.

Creé una subrutina usando un doble flotante, devuelve 2 valores enteros.

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);
  }
}

Creo que usar una cadena es la forma correcta de hacerlo en este caso, ya que no sabes a priori la cantidad de dígitos en la parte decimal. Pero no funcionará para todos los casos (p. ej., 1.005), como se mencionó anteriormente en @SingleNegationElimination. Aquí está mi opinión sobre esto:

#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;
}

Usa el número flotante para restar el pisoed valor para obtener su parte fraccionaria:

double fractional = some_double - floor(some_double);

Esto evita el encasillamiento a un número entero, lo que puede causar Desbordamiento si el número flotante es muy grande, un valor entero ni siquiera podría contenerlo.

También por valores negativoseste código te da la parte fraccionaria positiva del número flotante desde piso() calcula el valor entero más grande no mayor que el valor de entrada.

Aquí hay otra manera:

#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

Producción:

whole: 123 
mantissa: 4567