conversione di stringa in una doppia variabile in C

Question

Ho scritto il seguente codice .... E 'necessario convertire una stringa come "88" per raddoppiare il valore 88 e stamparlo

void convertType(char* value) 
{ 
    int i = 0; 
    char ch; 
    double ret = 0; 
    while((ch = value[i])!= '\0') 
    { 
     ret = ret*10 +(ch - '0'); 
     ++i; 
    } 
    printf("%d",ret);//or %f..what is the control string for double? 
} 



//input string :88 

ma stampa sempre 0. ..ma quando cambio tipo di ret a int ... funziona bene ... quando il tipo è float o double, stampa zero ... quindi perché sto ottenendo risultati ambigui?

Answer 1

Usa sscanf (intestazione stdio.h o cstdio in C++):

char str[] = "12345.56"; 
double d; 

sscanf(str, "%lf", &d); 

printf("%lf", d); 

Answer 2

si potrebbe essere in grado di utilizzare atof() restituisce una doppia.

source

Answer 3

ma stampa sempre 0 ... Ma quando cambio tipo di ret a int ... è funziona bene ... quando il tipo è float o doppia, stampa zero.

La logica è soddisfacente. Solo il tuo specificatore di formato è sbagliato. Cambialo a %f e tutto va bene!

Answer 4

Il seguente codice funziona per me.

#include <stdio.h> 

void convertType(char* value); 

int main(int argc, char *argv[]) { 
    char *str="0929"; 
    convertType(str); 

    return 0; 
} 

void convertType(char* value) { 
    double ret = 0; 

    while(*value != '\0') { 
     ret = ret*10 +(*value - '0'); 
     value++; 
    } 

    fprintf(stdout, "value: %f\n", ret); 
} 

Answer 5

#define ZERO 48 
#define NINE 57 
#define MINUS 45 
#define DECPNT 46 

long strtolng_n(char* str, int n) 
{ 
    int sign = 1; 
    int place = 1; 
    long ret = 0; 

    int i; 
    for (i = n-1; i >= 0; i--, place *= 10) 
    { 
     int c = str[i]; 
     switch (c) 
     { 
      case MINUS: 
       if (i == 0) sign = -1; 
       else return -1; 
       break; 
      default: 
       if (c >= ZERO && c <= NINE) ret += (c - ZERO) * place; 
       else return -1; 
     } 
    } 

    return sign * ret; 
} 

double _double_fraction(char* str, int n) 
{ 
    double place = 0.1; 
    double ret = 0.0; 

    int i; 
    for (i = 0; i < n; i++, place /= 10) 
    { 
     int c = str[i]; 
     ret += (c - ZERO) * place; 
    } 
    return ret; 
} 
double strtodbl(char* str) 
{ 
    int n = 0; 
    int sign = 1; 
    int d = -1; 
    long ret = 0; 

    char* temp = str; 
    while (*temp != '\0') 
    { 
     switch (*temp) 
     { 
      case MINUS: 
       if (n == 0) sign = -1; 
       else return -1; 
       break; 
      case DECPNT: 
       if (d == -1) d = n; 
       else return -1; 
       break; 
      default: 
       if (*temp < ZERO && *temp > NINE) return -1; 
     } 
     n++; 
     temp++; 
    } 

    if (d == -1) 
    { 
     return (double)(strtolng_n(str, n)); 
    } 
    else if (d == 0) 
    { 
     return _double_fraction((str+d+1), (n-d-1)); 
    } 
    else if (sign == -1 && d == 1) 
    { 
     return (-1)*_double_fraction((str+d+1), (n-d-1)); 
    } 
    else if (sign == -1) 
    { 
     ret = strtolng_n(str+1, d-1); 
     return (-1) * (ret + _double_fraction((str+d+1), (n-d-1))); 
    } 
    else 
    { 
     ret = strtolng_n(str, d); 
     return ret + _double_fraction((str+d+1), (n-d-1)); 
    } 
} 

Answer 6

Si dovrebbe usare la funzione "atof" se si vuole analizzare un char * a raddoppiare.

Si dovrebbe anche usare il delimitatore "% f" per stampare il doppio:

Maggiori informazioni ed esempio di utilizzo può essere trovato here.

Esempio di utilizzo:

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

int main() 
{ 
    float val; 
    char str[20]; 

    strcpy(str, "98993489"); 
    val = atof(str); 
    printf("String value = %s, Float value = %f\n", str, val); 

    strcpy(str, "tutorialspoint.com"); 
    val = atof(str); 
    printf("String value = %s, Float value = %f\n", str, val); 

    return(0); 
} 

Per stampare esso è necessario stamparlo come un float:

printf("This is the value in float: %f\n", yourFloatValue); 

Answer 7

conversione di stringa in una doppia variabile C

Se troppo pieno non è una preoccupazione, ma il codice vuole rilevare il testo non-bianco-spazio in più dopo il testo numerica:

// return 1 on success 
int convertType(const char* value, double *destination) { 
    char sentinel; 
    return sscanf(value,"%f %c", destination, &sentinel) == 1; 
} 

Se il sscanf() non riesce a trovare una double, il valore di ritorno di sscanf() sarà essere EOF o 0.

Se il sscanf() trova il testo non-bianco-spazio dopo numer testo, restituirà 2.

Se viene scansionato solo uno double, senza extra, sscanf() restituisce 1. Gli spazi bianchi iniziali e finali sono OK.

Esempio:

double x; 
if (convertType(some_string, &x)) { 
    printf("%.17e\n", x); // or whatever FP format you like 
} else { 
    puts("Failed"); 
}