Espacios de nombres
Variantes
Acciones

std::fixed, std::scientific, std::hexfloat, std::defaultfloat

De cppreference.com
< cpp‎ | io‎ | manip
 
 
Biblioteca de E/S
Manipuladores de E/S
E/S estilo C
Búferes
(en desuso en C++98)
Flujos
Abstracciones
E/S de archivos
E/S de cadenas
E/S de arrays
(en desuso en C++98)
(en desuso en C++98)
(en desuso en C++98)
Salida sincronizada
Tipos
Interfaz de categoría de error
(C++11)
 
Manipuladores de E/S
Formateo de punto flotante
fixedscientifichexfloatdefaultfloat
(C++11)(C++11)
Formateo de enteros
Formateo de booleanos
Control de ancho de campo y relleno
Otro formateo
Procesamiento de espacio en blanco
Vaciado de salida
(C++20)  

Manipulación de indicadores de estado
E/S de tiempo y dinero
(C++11)
(C++11)
(C++11)
(C++11)
Manipulación entre comillas
(C++14)
 
Definido en el archivo de encabezado <ios>
(1)
std::ios_base& scientific( std::ios_base& str );
(2)
std::ios_base& hexfloat( std::ios_base& str );
(3) (desde C++11)
std::ios_base& defaultfloat( std::ios_base& str );
(4) (desde C++11)

Modifica el formateo por defecto de salida de punto flotante.

1) Establece el campo floatfield del flujo str to fixed como si se llamara a str.setf(std::ios_base::fixed, std::ios_base::floatfield).
2) Establece el campo floatfield del flujo str to scientific como si se llamara a str.setf(std::ios_base::scientific, std::ios_base::floatfield).
3) Establece el campo floatfield del flujo str a fixed y scientific simultáneamente como si se llamara a str.setf(std::ios_base::fixed | std::ios_base::scientific, std::ios_base::floatfield). Esto habilita el formateo de punto flotante hexadecimal.
4) Establece el campo floatfield del flujo str a cero, como si se llamara a str.unsetf(std::ios_base::floatfield). Esto habilita el formateo por defecto de punto flotante, que es distinto del fijo y del científico.

Este es un manipulador de E/S, puede llamarse con una expresión tal como out << std::fixed para cualquier out de tipo std::basic_ostream (o con una expresión tal como in >> std::scientific para cualquier in de tipo std::basic_istream).

Contenido

[editar] Parámetros

str - Referencia al flujo de E/S.

[editar] Valor de retorno

str (Referencia al flujo después de la manipulación).

[editar] Notas

El formateo hexadecimal de punto flotante ignora la especificación de precisión del flujo, como se requiere por la especificación de std::num_put::do_put.

Estos manipuladores no afectan el análisis de punto flotante.

[editar] Ejemplo

#include <iomanip>
#include <iostream>
#include <sstream>
 
enum class leyenda { titulo, medio, final };
 
void imprimir(const char* texto, double num, leyenda ley)
{
    if (ley == leyenda::titulo)
        std::cout <<
            "┌──────────┬────────────────┬──────────────────────────┐\n"
            "│  número  │   manipulador  │      representación      │\n"
            "├──────────┼────────────────┼──────────────────────────┤\n";
    std::cout << std::left
         << "│ " << std::setw(8) << texto <<      " │ fixed          │ "
         << std::setw(24) << std::fixed   << num <<            " │\n"
         << "│ " << std::setw(8) << texto <<      " │ scientific     │ "
         << std::setw(24) << std::scientific << num <<        " │\n"
         << "│ " << std::setw(8) << texto <<      " │ hexfloat       │ "
         << std::setw(24) << std::hexfloat << num <<          " │\n"
         << "│ " << std::setw(8) << texto <<      " │ default        │ "
         << std::setw(24) << std::defaultfloat << num <<      " │\n";
    std::cout << (ley != leyenda::final ?
            "├──────────┼────────────────┼──────────────────────────┤\n" :
            "└──────────┴────────────────┴──────────────────────────┘\n");
}
 
int main()
{
    imprimir("0.0", 0.0, leyenda::titulo);
    imprimir("0.01", 0.01, leyenda::medio);
    imprimir("0.00001", 0.00001, leyenda::final);
 
    // NOTA; escoger clang for para salida correcta
    double f;
    std::istringstream("0x1.8p+0") >> f;
    std::cout << "El análisis de 0x1.8p+0 da como resultado " << f << '\n';
 
    std::istringstream("0x1P-1022") >> f;
    std::cout << "El análisis de 0x1P-1022 da como resultado " << f << '\n';
}

Salida:

┌──────────┬────────────────┬──────────────────────────┐
│  número  │   manipulador  │      representación      │
├──────────┼────────────────┼──────────────────────────┤
│ 0.0      │ fixed          │ 0.000000                 │
│ 0.0      │ scientific     │ 0.000000e+00             │
│ 0.0      │ hexfloat       │ 0x0p+0                   │
│ 0.0      │ default        │ 0                        │
├──────────┼────────────────┼──────────────────────────┤
│ 0.01     │ fixed          │ 0.010000                 │
│ 0.01     │ scientific     │ 1.000000e-02             │
│ 0.01     │ hexfloat       │ 0x1.47ae147ae147bp-7     │
│ 0.01     │ default        │ 0.01                     │
├──────────┼────────────────┼──────────────────────────┤
│ 0.00001  │ fixed          │ 0.000010                 │
│ 0.00001  │ scientific     │ 1.000000e-05             │
│ 0.00001  │ hexfloat       │ 0x1.4f8b588e368f1p-17    │
│ 0.00001  │ default        │ 1e-05                    │
└──────────┴────────────────┴──────────────────────────┘
El análisis de 0x1.8p+0 da como resultado 1.5
El análisis de 0x1P-1022 da como resultado 2.22507e-308

[editar] Véase también

Cambia la precisión de punto flotante.
(función) [editar]