Imprimir el número correcto de puntos decimales con cout

Tengo una lista de floatvalores y quiero imprimirlos coutcon 2 decimales.

Por ejemplo:

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

¿Cómo puedo hacer esto?

( setprecisionno parece ayudar en esto)

Con <iomanip>, puedes usar std::fixedystd::setprecision

Aquí hay un ejemplo

#include <iostream>
#include <iomanip>

int main()
{
    double d = 122.345;

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

Y obtendrás salida

122.34

Estaba casi allí, necesita usar std :: fixed también, consulte 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;
}

salidas:

0.12
1.23
12.35
123.45
1234.50
12345.00

setprecision(n)se aplica al número entero, no a la parte fraccionaria. Debe usar el formato de punto fijo para que se aplique a la parte fraccionaria:setiosflags(ios::fixed)

Simplifica la respuesta aceptada

Ejemplo simplificado:

#include <iostream>
#include <iomanip>

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

Y obtendrás salida

122.34

Referencia:

• std::fixed
• std::setprecision

Tuve un problema con los enteros mientras quería un formato consistente.

Una reescritura para completar:

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

Tuve este problema similar en una competencia de codificación y así es como lo manejé. Establecer una precisión de 2 para todos los valores dobles

Primero agregue el encabezado para usar setprecision

#include <iomanip>

Luego agregando el siguiente código en nuestro principal

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

Salida:

5.99
5.00

Debe usar fijo para escribir 5.00, por eso, su salida no vendrá para 5.00.

Estoy agregando un breve enlace de video de referencia que es útil

Tienes que configurar el 'modo flotante' como fijo.

float num = 15.839;

// this will output 15.84
std::cout << std::fixed << "num = " << std::setprecision(2) << num << std::endl;

Para establecer 2 dígitos fijos después del punto decimal, use estos primero:

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

Luego imprima sus valores dobles.

Esto es un ejemplo:

#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);

}

con plantillas

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

similar para científico también, con una opción de ancho también (útil para columnas)

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

Solo un punto menor; pon lo siguiente en el encabezado

usando el espacio de nombres estándar;

luego

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

se simplifica a

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

Este es un ejemplo usando una matriz.

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