Discussion :

[Josué 243]

Bonjour,je voudrais créer une classe(ou type) fixed_32_t(en C++)mais pour ça je besoin de connaitre le nombre de chiffre après la virgule du float.
Quelqu'un peut m'aider svp?

[Bousk]

Kamoulox.
Ou bien 42 ?
La question ne veut rien dire.

[Josué 243]

j'ai peut-etre mal posé ma question,mais pour creer une classe virgule_fixe j'ai besoi de connaitre grace a un std::string le nombre de chiffre apres la virgule(si float vaut 5.xyz [le nombre de chiffre après virgule donc ici 3,pas la valeur])et le mettre dans un int ,donc je vous demande comment connaitre le nombre de chiffre après la virgule ?
vous pouvait m'aider svp?

[Bousk]

float représente les entiers relatifs, noté R en mathématiques et ces chiffres ont une infinité de chiffres après la virgule.
Le format binaire ne permet pas ça mais ne permet pas non plus d'avoir une valeur précise pour l'immense majorité des valeurs possibles.
Si tu veux afficher X chiffres après la virgule tu utilises la syntaxe de formatage d'affichage de std::ostream ou printf.
Si tu veux stocker des valeurs à virgule fixe, je l'ai fait ici https://bousk.developpez.com/cours/s...n-avancee/#LII
Si tu veux juste prendre 3 chiffres après la virgule, il suffit de multiplier par 1000

[foetus]

J'ai regardé vite fait mais je pense que c'est 1 truc impossible.
Tu peux le savoir avec les nombres appartenant à D, mais pas à R (et sûrement 1 partie de Z) - lien wiki sur les nombres décimaux en français
c'est à dire tous les nombres ayant 1 nombre fini de chiffres après la virgule et pas infini comme pi ou 1/3.

Il faut prendre la mantisse/ la significande d'1 nombre flottant et chercher le dernier bit mis à 1 (le plus à droite) - le nombre de chiffres après la virgule est la différence entre le nombre de chiffres exposant et cet index.

Rappel , d'après la norme IEEE 754, un nombre flottant est de la forme signe (1 ou -1) * base (2) ^ (exposant - biais) * 1,{mantisse/ significande}

[Christian 118]

bonjour a tous svp en voyant ce sujet jai essayer moi aussi d’aider mai je suis tomber face a un petit problème:

jai réussi a créer un code qui donnait le nombre de chiffre après la virgule mais ne pouvait pas donner plus de 6 est ce un problème de surcharge

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
int apres_virgule( double a)
{
//on creer dabord une chaine caractere elle conservera  le nombre apres la virgule
     std::ostringstream chaine("");
//on cree un variable  qui tranformeraa en entier de tel sorte que quon ai uniquement la partie entiere
    int b =a;
 //on cree une autre variable  en  faisant a-b il nous reste que le nombre decimal apresla virgule
    float c=a-b;
   // on  cree un variable nombre qui  retournera le nombre de chriffre apres la virgule a la fin dela fontion
    int nombre;
    //on transforme le  nombre decimal stocke dans c en chaine
    chaine<<c;
    //on compte le nombre de   lettre dans cette meme chaine
   nombre=(chaine.str().size())-2;
   //on retourne le nombre de  lettre
   return nombre;
 
 
}

[dalfab]

Bonjour,

Avant de rechercher les chiffres après la virgule, il faut comprendre ce que sont les types float et double.

Quand on dit nombre, on pense souvent aux nombres dits réels. Ça inclut par exemple 42, 1/8, 1.1875, 2/3, 0.1, pi, racineCarrée(2). Les float et double ne peuvent pas stocker certains de ces nombres, ils peuvent mémoriser la valeur exacte de 42, 1/8, 1.1875, mais seulement une valeur approchée de 2/3, 0.1, pi, racineCarrée(2).
Un sous-ensemble des réels est l'ensemble des rationnels. Il inclut 42, 1/8, 1.1875, 2/3, 0.1 mais pas pi, racineCarrée(2). Les deux derniers ne peuvent pas écrits sous forme de fraction.
Un sous ensemble des rationnels est l'ensembles des décimaux, il correspond au cas où le diviseur est une puissance de dix. Il inclut 42=42/1, 1/8=125/1000, 1.1875=11875/10000, 0.1=1/10. Il n'a pas 2/3, pi, racineCarrée(2). Et les float et double ne peuvent pas stocker tous les décimaux, il manque par exemple le 0.1. Oui, un nombre aussi simple que 0.1 ne peut être stocké que par une valeur proche comme 2/3 et pi!
Il existe un autre sous ensemble des rationnels, ce sont les fractions dyadiques. il correspond au cas où le diviseur est une puissance de 2. Les dyadiques de ma liste exemple sont 42=42/1, 1/8=1/8, 1.1875=19/16. Tiens cette fois la liste correspond exactement à ce que peuvent stocker les float et double.
Les float et double ne peuvent stocker exactement que les fractions dyadique (mais pas toutes!)

Revenons sur le nombre 0.1. Comment est-ce possible, un nombre aussi simple ne peut pas être stocké exactement? Pourtant si j'écris :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
float x = 2./3.;               // 2/3 est converti en float
std::cout << x << std::endl;   // ça affiche une approximation 0.666667
float y = 0.1;                 // 0.1 décimal est converti en float
std::cout << y << std::endl;   // ça affiche bien 0.1

Car les fonctions d'affichage et de conversion des float et double veulent les rendre lisibles pour les humains et donc les fournissent en base 10 et donnent une valeur arrondies (par défaut std::cout cherche les 6 premiers chiffres décimaux arrondis.)
On va demander d'afficher les même nombres en forçant une précision de 60 chiffres

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
float x = 2./3.;               // 2/3 est converti en float
std::cout << std::setprecision(60) <<  x << std::endl; // ça affiche 0.666666686534881591796875
float y = 0.1;                 // 0.1 décimal est converti en float
std::cout << y << std::endl;   // ça affiche 0.100000001490116119384765625
float u = 123456789;           // 123456789 décimal est converti en float
std::cout << u << std::endl;   // ça affiche 123456792

Eh oui, le 0.1 est connu comme une approximation ayant 27 chiffres! Eh oui, 12345689 est devenu 123456792
Le point commun visible est que les 7 ou 8 premiers chiffres sont bons mais au delà ça semble être n'importe quoi.
Les nombres sont mémorisés en binaire. Par exemple le 0.1 est mémorisé comme la formule binaire :
0.000110011001100110011001101

Donc un nombre float ne peut stocker qu'une approximation qui a un peu plus de 6 chiffres significatifs.
Les double ont le même problème mais ont beaucoup plus de chiffres décimaux (53 au lieu de 23), donc un nombre double stocker une approximation qui a un peu plus de 15 chiffres significatifs.
On ne pourra donc jamais compter sur le 7^ième chiffre d'un float et sur le 16^ième chiffre d'un double.

On ne doit normalement pas utiliser le type float car on perd beaucoup en précision, on gagne un peu en taille mais très souvent il est en plus plus lent que le type double. Il faut donc une très bonne radine raison pour utiliser des float.

[Christian 118]

merci

[Stabia]

Même si je ne comprend pas l'utilité de ce que vous voulez faire, la réponse me semble assez simple :
- vous créez une chaine avec :printf(tp, %f, votre variable)
- vous récupérez un pointeur sur le séparateur décimal (normalement une ',' n'en déplaise aux thuriféraires de l’américanisation .. je sais printf ...)
- vous avancez votre pointeur d'un caractère
- vous appelez strlen(lePointeur) et vous avez le nombre de décimales - qui ne vous sert à rien.

Ceci doit être adapté si votre système utilise UTF16.