Impression du nombre correct de points décimaux avec cout

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.)

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

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

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)

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:

• std::fixed
• std::setprecision

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
}

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

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;

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;
}

#include<stdio.h>
int main()

{

 double d=15.6464545347;

printf("%0.2lf",d);

}

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';
}

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;

ceci un exemple utilisant une matrice.

cout<<setprecision(4)<<fixed<<m[i][j]