Discussion :

[TiKeuj]

Voilà, c'est vraiment tout con mais :
je fais une division dont le résultat (compris entre 0 et 1, ce sont des "pourcentages") doit être écrit dans un format précis 6 chiffres après la virgule).
La première idée du bourrin (oui, c'est moi), c'est d'utiliser :

Code :

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

1
2
3
{ostringstream oss; 
	oss << setfill('0') << setw(7) << N;
	c = oss.str();}

Puis de retransformer ce string en chiffre pour l'enregistrer dans un element de maliste chaînée, pour l'enregistrer dans un autre sous-programme (j'vous avais prévenu, z'êtes pas pris en traitre!).
Ma deuxième idée, c'était printf (désolé ).
...
...
Et ma douzième idée c'est d'écrire dans le Forum.

[Rafy]

Il y a des fonction standard pour arrondir des flotants (float ou double). tu devrai regarde plutot ça car créer un ostringstream à chaque fois que tu veux calculer un pourcentage, il ne faut pas que tu ai à en calculer de trop.

[diogene]

Pour arrondir à 6 chiffres décimaux apès la virgule la valeur v (positive) :

Code :

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

1
2
int iv = v*1e6+0.5;
v = iv*1e-6;

[DaZumba]

Utilise les capacites des iostreams!

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include <iostream>
#include <iomanip>
 
using namespace std;
 
int main()
{
  double x = 2.0/3.0;
  cout << setiosflags(ios::fixed) << setprecision(4) << x << endl;
  return 0;
}

donne bien 0.6667 alors que

Code :

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

1
2
 
cout << x << endl;

aurait donne 0.666667

[JolyLoic]

Si tu dois faire des calculs avec un nombre précis de chiffre décimaux, les types double ou float ne sont sûrement pas adaptés.

Ces calculs apparaissent souvent dans le domaine de la finance, et demandent alors des règles d'arrondi défini par les lois de chaque pays, et auxquels les normes classiques pour les double et floats ne répondent absolumant pas.

Quel est ton domaine d'application ?

[TiKeuj]

D'abord, merci bien à tous de l'engouement sucité pour ma question !?! Et puis désolé d'"avoir pris mon temps" pour répondre mais je n'ai juste pas pu avant!
Alors je vais situer le plus précisement et de facon concise mon problème :
-Un programme calcul tout un tas de truc et me donne (notemment) dans deux fichiers séparés :
--Des distances (en milimetres) entre deux point (distance négative -> probleme -> je doit traiter) [il y a près de 1500 points].
--Des hauteurs relative [à la hauteur à vide de mon ressort], les fameux pourcentages. Ce document définit un nombre n de secteurs, et pour chaque secteurs, les hauteurs [ou dans un autre fichier les diamètres] mini et maxi.

-Je récupère tous les points à problème, je les classe dans les mêmes "secteurs" [fourchettes de pourcentage donc] que dans les fichier lus, je fais ma tambouille de calcul, et je doit restituer un document au même format exactement que celui lu, pour qu'il puisse être exploité par le logiciel qui à créé les document que j'utilise.

Soit :
[fichiers]---->LogInterneUsine---[fichiers]---->MonLogicel-----[fichiersModifiés]
/rienrienrienrienrien/ ^-------------------------------------------------------------|
Donc, mes fichiers Doivent être formattés comme suit :

• 3, 0.512195, 1.266347, 0.500000

L'explication, c'est pas mon fort, mais j'espère que j'ai réussi à me faire comprendre!

Ce qui serait bien, c'est de ne changer le format (mon quotient a 7 chiffres après la virgule) qu'au moment de l'écriture dans le fichier. Donc j'ai pas encore essayé mais je pense que si je fais un :

Code :

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

1
2
3
4
#include <iomanip> 
 
ofstream fileCibl(Cible);
fileCibl<<setiosflags(ios::fixed) << setprecision(6) << MonNombre;

... ca doit marcher!

[Laurent Gomila]

Oui.

Juste pour pinailler, l'appel à setiosflags peut être remplacé par un équivalent plus court :

Code :

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

fileCibl << fixed << setprecision(6) << MonNombre;

[TiKeuj]

OK
Merci, c'est cool! J'ai pas encore essayé (Je programme mes lois... C'est le plus dur mais pas à cause de la programmation!). Mais savoir que ca va marcher comme ca, c'est une épine en moins dans un pied [qui en est quand même (de moins en moins) bourré! ].

[Matthieu Brucher]

C'est peut-être pas le top non plus, de devoir mettre à chaque fois le fixed<<setprecision(6) pour chaque nombre, donc avec un cible.setioflags, ça te permettra de ne pas avoir à faire ça tout le temps, non ?

[TiKeuj]

Miles :

cible.setioflags

Ca m'interesse vachement ca! (parce que là j'en suis à le tapper et c'est super lourd). Mais comment faire pour que le premier élément (le numéro du secteur) soit quand même avec un seul chiffre ?
Mon sous programme écrit la solution ligne par ligne. Je pourrait faire un truc du type :

Code :

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

1
2
3
4
fileCibl<<secteur<<",        ";
fileCibl<<setiosflags(ios::fixed) << setprecision(6)<<info1<<",        ";
fileCibl<<info2<<",        ";
fileCibl<<info3<<endl;

Est-ce qu'alors, les info2 et info3 seront aussi écris avec 6 chiffres après la virgule,
Est-ce que le secteur au prochain appel de ce sous programme au sein d'une boucle sera de nouveau un simple chiffre (sans six "0" après la virgule)?

[Laurent Gomila]

Certains manipulateurs sont persistants, d'autres ne concernent que le prochain paramètre envoyé au flux. Apparemment, fixed et setprecision sont persistants. Enfin ce ne sont que des observations, je n'ai jamais cherché plus loin que ça.

[Matthieu Brucher]

Regarde là : http://www.cplusplus.com/ref/iostream/ios_base/flags.html

[TiKeuj]

je viens d'essayer à l'instant... à part que mes lois ont quelques problème (je trouve qu'il y a un probleme grave 27cm au-dessus du ressort -> i.e. des pourcentages négatifs ou supérieurs à 1), le principe a l'air d'être le bon.
Pour

Code :

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

 fileCibl << fixed << setprecision(6) << MonNombre;

, les nombre "0" et 7 chiffres Après la virgule (->ApV) s'écrivent bien à six chiffres Apv. Mais si ils s'écrivent "n!=0" et 7 chiffres ApV, ils s'écriront à 6 chiffres EN TOUT (pas ApV quoi!) sinon, ils s'écrivent "normalements" ->

• ex. 2.5 ou 0.2048 ou 0.204848 ou encore 23.3456 -> 23.23456 n'est par exemple pas possible.

Contrairement à

Code :

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

setiosflags(ios::fixed) << setprecision(6)

qui force juste l'écriture à 6 chiffres ApV.

• ex. 0.000000 ou 2.234243 ou 2.342500

Donc : les deux sont persistants au sein du sous-programme (si j'ai bien compris ce que ca voulait dire) et dans mon cas, je vais utiliser la solution de Miles.

Quoi qu'il en soit, avec vos deux solutions et mes erreurs de poucentages, j'aurai (on aura?) bien appri!
Merci

[edit]

En fait, vous allez rire : j'm'aétait planté d'câse! J'avais mis "fixed" dans une mauvaise boucle... hiiihihihi il était pas pris en compte... hiiiihiihi...
**Blam**
Bon OK... En ce qui me concerne, les deux solutions marchent et sont équivalentes! Elles fonctionnent comme j'ai expliqué au-dessus pour

Code :

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

setiosflags(ios::fixed) << setprecision(6)

Conclusion, pour ce que je veux faire, les deux solutions sont équivalentes (comme disait Loulou24), et sont toutes deux les avantages pronés par Miles. Donc vous aviez tout les deux raison [faites l'amour, pas la guerre ]/et pour chipotter, je vais utiliser la solution de Loulou, un quart de poil de cheveux coupé en quatre plus courte./
[/edit]