chaîne de format %g dans C

Comment puis-je créer une chaîne afin qu'elle les formats des nombres à virgule flottante ont pas de virgule décimale de fin ou de chiffres, quand il est un entier, mais pour ne PAS passer à la notation scientifique pour un plus grand nombre?

Quand je fais:

float myFloat= 15.6f;
float myInt = 5.0f;
float myLarge = 7000000.0f;
sprintf(out, "my float is %g", myFloat);
sprintf(out, "my int is %g", myInt);
sprintf(out, "my large is %g", myLarge);

Je reçois quelque chose comme:

mon flotteur est de 15,6 
mon int est de 5 
mon grand est 7e+07f

Je souhaite à tous une seule chaîne de format qui donnera 15.6, 5, et 700000.

Édité cause des commentaires de ne pas faire de mise en forme:

qu'est ce que je pensais. mais un wrapper est assez gênant même si, comme les chaînes de format sont intégrés dans de plus longues chaînes de format:

sprintf(buf, "%d %g", myInt, myFloat);

comment avez-vous l'envelopper?

sprintf(buf, "%d %g", myInt, Wrapper(myFloat));??

ce qui devrait Wrapper de retour? Ou pire:

sprintf(buf, "%d %s", myInt, Wrapper(myFloat));??
Si vous utilisez %.*f, alors vous avez juste à faire: sprintf(buf, "%d %.*f", myint, getPlaces(myFloat), myFloat); Pas besoin d'un wrapper pour générer des chaînes de format.

OriginalL'auteur sean riley | 2009-05-06

  1. 5

    Je ne pense pas que vous pouvez obtenir avec %g, comme %g vous donne la plus courte de %e ou %f.

    Donc, je ne pense pas qu'il y a un seul printf argument qui vous satisfait. Pour 15.6, vous pouvez utiliser %2.1f; pour 7000000, vous pouvez utiliser %7.0f.

    Votre meilleur pari est probablement écrire une fonction wrapper qui ressemblerait à la taille de votre valeur et appliquer les bonnes printf argument.

    ouais c'est ce que je pensais. qui assez gênant si, comme le format des chaînes sont intégrés dans de plus longues chaînes de format: > sprintf(buf, "%d %g", myInt, myFloat); comment avez-vous l'envelopper? > sprintf(buf, "%d %g", myInt, Wrapper(myFloat));?? ce qui devrait Wrapper de retour? Ou pire: > sprintf(buf, "%d %s", myInt, Wrapper(myFloat));??
    Voici un bien: Écrire un my_sprintf. Vérifiez pour un jeton de vous définir (quelque chose comme %y ou quoi que ce soit), remplacez-vous et appelez sprintf dessous avec votre remplacé la chaîne en place. De cette façon, vous auriez my_sprintf(buf, "%d %y", myInt, myFloat);
    Vous pouvez utiliser Mike Chou frisé du truc (%.*f) dans votre my_sprintf au lieu de passer d'une chaîne réelle.

    OriginalL'auteur joce

  2. 10

    Vous pouvez formater avec "%.*f", qui vous permet de passer de la précision comme un paramètre individuel par exemple sprintf. Je l'ai utilisé dans le passé, lorsque j'ai voulu afficher 0, 1, 2, ou peut-être 3 chiffres bien sans extra fin 0. Écrire une petite fonction d'assistance qui prend le double/float et renvoie un entier de précision (en multipliant par 1000 et ensuite de faire le modulo 10, 100, 1000). Appelez ensuite sprintf "%.*f", appelez la fonction d'assistance, et de passer le flotteur.

    +1 C'est vraiment chouette! Je ne savais pas à ce sujet.

    OriginalL'auteur Mike Kale

  3. 1

    Mike approche est raisonnable, mais vous pouvez calculer le nombre de chiffres directement à l'aide de la fonction log10, et d'utiliser soit de plancher ou de plafond de vérifier que vous pouvez en fait avoir une valeur entière. Quelque chose comme:

    #include <math.h>
double x;
...
if (floor(x) == x && x != 0.0) { //x is an non-zero integer value
    int digits = floor(log10(fabs(x)+0.5)) + 1;
    printf("x is %.*f\n", digits, x);
}

    Déballage de la chaîne d'appels de fonction, nous avons d'abord prendre la valeur absolue de s'assurer que l'argument est non-négatif, ajouter 0,5 la valeur entière à prendre soin de tous les possibles erreurs d'arrondi dans le calcul de log10 d'une puissance de 10, combiner log10 et sol pour obtenir l'exposant de la plus grande puissance de 10 à moins de fabs(x)+0.5, et enfin ajouter 1 pour obtenir le nombre de chiffres nécessaires pour représenter x. Voici quelques exemples de valeurs (à partir de OpenOffice, mais la C log10 fonction doit calculer une précision similaire):

             x          log10(x+0.5)
         1  0.176091259055681000
         9  0.977723605288848000
        10  1.021189299069940000
        99  1.997823080745730000
       100  2.002166061756510000
       999  2.999782798454140000
      1000  3.000217092972230000
     10000  4.000021714181250000
    100000  5.000002171466980000
   1000000  6.000000217147190000
  10000000  7.000000021714720000
 100000000  8.000000002171470000
1000000000  9.000000000217150000
    Je pense que l'OP veut que le nombre de chiffres après la virgule, pas de l'ordre du nombre. 1 + floor(log10(l. 1.234 + 0.5)) est 1, pas la (je pense) désiré 3.
    Ouais, j'ai manqué le point de Mike successives mod opérations a été de comprendre comment de nombreux endroits à imprimer après la virgule pour les valeurs non entières. Je me concentre sur la partie de Sean demande qu'il n'y pas de chiffres de fin ou du point décimal pour des valeurs entières. Vous pouvez combiner nos deux approches pour comprendre les chiffres avant et après la virgule afin de calculer l'ensemble de la précision nécessaire.

    OriginalL'auteur dewtell

  4. 1

    Remplacer %g %.10g d'afficher jusqu'à 10 chiffres significatifs

    OriginalL'auteur david72