Impression du nombre correct de points décimaux avec cout

133

J'ai une liste de floatvaleurs et je veux les imprimer coutavec 2 décimales.

Par exemple:

10.900  should be printed as 10.90
1.000 should be printed as 1.00
122.345 should be printed as 122.34

Comment puis-je faire ceci?

( setprecisionne semble pas aider à cela.)

thameera
la source

Réponses:

196

Avec <iomanip>, vous pouvez utiliser std::fixedetstd::setprecision

Voici un exemple

#include <iostream>
#include <iomanip>

int main()
{
    double d = 122.345;

    std::cout << std::fixed;
    std::cout << std::setprecision(2);
    std::cout << d;
}

Et vous obtiendrez une sortie

122.34
bédouin
la source
6
pourquoi avez-vous utilisé "std: fixed" dans le programme?
Vilas Joshi
1
Un en-tête utile peut être défini pour cela: ce #define FIXED_FLOAT(x) std::fixed <<std::setprecision(2)<<(x) qui simplifie l'utilisation à:cout<<FIXED_FLOAT(d)
Udayraj Deshmukh
13
@VilasJoshi, setprecision définit le nombre de chiffres après la décimale, s'il y a 5 chiffres et que nous utilisons setprecision (2), nous obtiendrons 2 chiffres, mais s'il y a 0 chiffres, il n'en affichera aucun, en utilisant fixe, nous corrigeons que beaucoup de chiffres ont à montrer donc 5 sera représenté par 5,00 no 5
vaibnak
43

Vous y étiez presque, vous devez également utiliser std :: fixed, reportez-vous à http://www.cplusplus.com/reference/iostream/manipulators/fixed/

#include <iostream>
#include <iomanip>

int main(int argc, char** argv)
{
    float testme[] = { 0.12345, 1.2345, 12.345, 123.45, 1234.5, 12345 };

    std::cout << std::setprecision(2) << std::fixed;

    for(int i = 0; i < 6; ++i)
    {
        std::cout << testme[i] << std::endl;
    }

    return 0;
}

les sorties:

0.12
1.23
12.35
123.45
1234.50
12345.00
Vusak
la source
18

setprecision(n)s'applique au nombre entier, pas à la partie fractionnaire. Vous devez utiliser le format à virgule fixe pour l'appliquer à la partie fractionnaire:setiosflags(ios::fixed)

QuantiqueMécanicien
la source
12

Simplifiez la réponse acceptée

Exemple simplifié:

#include <iostream>
#include <iomanip>

int main()
{
    double d = 122.345;
    std::cout << std::fixed << std::setprecision(2) << d;
}

Et vous obtiendrez une sortie

122.34

Référence:

Einverne
la source
Cela a fonctionné pour moi: std :: cout << std :: setprecision (2) << std :: fixed << d;
Andrea Girardi
5

J'ai eu un problème pour les entiers tout en voulant un formatage cohérent.

Une réécriture pour l'exhaustivité:

#include <iostream>
#include <iomanip>

int main()
{
    //    floating point formatting example

    double d = 122.345;
    cout << std::fixed << std::setprecision(2) << d << endl;
    //    Output:  122.34


    //    integer formatting example

    int i = 122;
    cout << std::fixed << std::setprecision(2) << double(i) << endl;
    //    Output:  122.00
}
Manohar Reddy Poreddy
la source
Il vous manque std :: juste avant cout et endl car vous n'utilisez pas l'espace de noms.
blackforest-tom
@ blackforest-tom - Peut-être que vous avez raison, je ne vous en souviens pas --- Je copie-colle généralement des programmes de travail, donc cela peut avoir fonctionné tel quel dans Visual Studio ou ailleurs.
Manohar Reddy Poreddy
3

J'ai eu ce problème similaire dans un concours de codage et c'est ainsi que je l'ai géré. Définition d'une précision de 2 pour toutes les valeurs doubles

Ajoutez d'abord l'en-tête pour utiliser setprecision

#include <iomanip>

Puis en ajoutant le code suivant dans notre main

  double answer=5.9999;
  double answer2=5.0000;
  cout<<setprecision(2)<<fixed;
  cout <<answer << endl;
  cout <<answer2 << endl;

Production:

5.99
5.00

Vous devez utiliser fixe pour écrire 5,00, c'est pourquoi votre sortie ne sera pas disponible pour 5,00.

Un court lien vidéo de référence que j'ajoute, ce qui est utile

Hargun Singh
la source
2

Vous devez définir le «mode flottant» sur fixe.

float num = 15.839;

// this will output 15.84
std::cout << std::fixed << "num = " << std::setprecision(2) << num << std::endl;
Eric Z
la source
1

Pour définir 2 chiffres fixes après la virgule décimale, utilisez-les d'abord:

cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(2);

Puis imprimez vos valeurs doubles.

Ceci est un exemple:

#include <iostream>
using std::cout;
using std::ios;
using std::endl;

int main(int argc, char *argv[]) {
    cout.setf(ios::fixed);
    cout.setf(ios::showpoint);
    cout.precision(2);
    double d = 10.90;
    cout << d << endl;
    return 0;
}
Hamid Rohani
la source
1
#include<stdio.h>
int main()

{

 double d=15.6464545347;

printf("%0.2lf",d);

}
saurav52
la source
0

avec des modèles

#include <iostream>

// d = decimal places
template<int d> 
std::ostream& fixed(std::ostream& os){
    os.setf(std::ios_base::fixed, std::ios_base::floatfield); 
    os.precision(d); 
    return os; 
}

int main(){
    double d = 122.345;
    std::cout << fixed<2> << d;
}

similaire pour les scientifiques également, avec une option de largeur également (utile pour les colonnes)

// d = decimal places
template<int d> 
std::ostream& f(std::ostream &os){
    os.setf(std::ios_base::fixed, std::ios_base::floatfield); 
    os.precision(d); 
    return os; 
}

// w = width, d = decimal places
template<int w, int d> 
std::ostream& f(std::ostream &os){
    os.setf(std::ios_base::fixed, std::ios_base::floatfield); 
    os.precision(d); 
    os.width(w);
    return os; 
}

// d = decimal places
template<int d> 
std::ostream& e(std::ostream &os){
    os.setf(std::ios_base::scientific, std::ios_base::floatfield); 
    os.precision(d); 
    return os; 
}

// w = width, d = decimal places
template<int w, int d> 
std::ostream& e(std::ostream &os){
    os.setf(std::ios_base::scientific, std::ios_base::floatfield); 
    os.precision(d); 
    os.width(w);
    return os; 
}

int main(){
    double d = 122.345;
    std::cout << f<10,2> << d << '\n'
        << e<10,2> << d << '\n';
}
QuentinUK
la source
-3

Juste un point mineur; mettre ce qui suit dans l'en-tête

en utilisant l'espace de noms std;

puis

std :: cout << std :: fixed << std :: setprecision (2) << d;

se simplifie en

cout << fixe << setprecision (2) << d;

Davidjgw
la source
2
Oui, cela devient «simplifié», mais cela est fortement déconseillé. Veuillez ne pas l'utiliser using namespace std;pour le plaisir - comprenez pourquoi vous le faites.
Carlos F
-6

ceci un exemple utilisant une matrice.

cout<<setprecision(4)<<fixed<<m[i][j]
Luis Enrique Martinez
la source