<iostream>: hexfloat stream output does not ignore precision as it should

[fsb4000]

Describe the bug
https://en.cppreference.com/w/cpp/io/manip/fixed

Notes
Hexadecimal floating-point formatting ignores the stream precision specification,
as required by the specification of std::num_put::do_put.

Command-line test case

C:\Temp>type main.cpp
#include <cstdlib>
#include <iomanip>
#include <iostream>

struct scand
{
    char* pos;
    double v;
    scand(const char* str) : v(std::strtod(str, &pos)) {}
    operator double() const { return v; }
};

// For hexfloat stream output, the stream precision should be ignored
int main()
{
    std::cout << std::hexfloat;
    std::cout << "default precision 6: " << scand("0x1.0123456789abcdef") << '\n';
    for (int i = 0; i < 16; ++i)
        std::cout << "precision set to " << std::setw(2) << i << ": "
        << std::setprecision(i) << scand("0x1.0123456789abcdef") << '\n';
}
C:\Temp>cl /EHsc /W4 /WX main.cpp
Оптимизирующий компилятор Microsoft (R) C/C++ версии 19.27.29109 для x64
(C) Корпорация Майкрософт (Microsoft Corporation).  Все права защищены.

main.cpp
Microsoft (R) Incremental Linker Version 14.27.29109.0
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:main.exe
main.obj

C:\Temp>main.exe
default precision 6: 0x1.012345p+0
precision set to  0: 0x1.012345p+0
precision set to  1: 0x1.0p+0
precision set to  2: 0x1.01p+0
precision set to  3: 0x1.012p+0
precision set to  4: 0x1.0123p+0
precision set to  5: 0x1.01234p+0
precision set to  6: 0x1.012345p+0
precision set to  7: 0x1.0123456p+0
precision set to  8: 0x1.01234567p+0
precision set to  9: 0x1.012345679p+0
precision set to 10: 0x1.012345678ap+0
precision set to 11: 0x1.0123456789bp+0
precision set to 12: 0x1.0123456789acp+0
precision set to 13: 0x1.0123456789abdp+0
precision set to 14: 0x1.0123456789abd0p+0
precision set to 15: 0x1.0123456789abd00p+0

Expected behavior
Correct output:

default precision 6: 0x1.0123456789abdp+0
precision set to  0: 0x1.0123456789abdp+0
precision set to  1: 0x1.0123456789abdp+0
precision set to  2: 0x1.0123456789abdp+0
precision set to  3: 0x1.0123456789abdp+0
precision set to  4: 0x1.0123456789abdp+0
precision set to  5: 0x1.0123456789abdp+0
precision set to  6: 0x1.0123456789abdp+0
precision set to  7: 0x1.0123456789abdp+0
precision set to  8: 0x1.0123456789abdp+0
precision set to  9: 0x1.0123456789abdp+0
precision set to 10: 0x1.0123456789abdp+0
precision set to 11: 0x1.0123456789abdp+0
precision set to 12: 0x1.0123456789abdp+0
precision set to 13: 0x1.0123456789abdp+0
precision set to 14: 0x1.0123456789abdp+0
precision set to 15: 0x1.0123456789abdp+0

STL version
Microsoft Visual Studio Community 2019 Preview Version 16.7.0 Preview 6.0

Additional context
VSO-847068 / AB#847068 | DevCom-520472

The zero-precision bug found by statementreply below is also tracked by Microsoft-internal VSO-294512 / AB#294512.

[statementreply]

Found a few additional issues when working on #1173:

1. We don’t do what the standard says when floatfield != fixed && precision == 0
2. Buffer size can be too small or huge when floatfield == fixed && precision < 0

Test case:

C:\Users\He\source\test>type num_put.cpp
#include <iomanip>
#include <iostream>
using namespace std;

int main() {
    constexpr double x = 12345.678901234567;
    cout << defaultfloat << setprecision(0) << x << "\n";
    cout << hexfloat << setprecision(1) << x << "\n";
    cout << scientific << setprecision(0) << x << "\n";
    cout << fixed << setprecision(-49) << x << "\n";
}

C:\Users\He\source\test>cl /EHsc /W4 /WX num_put.cpp
用于 x64 的 Microsoft (R) C/C++ 优化编译器 19.28.29115 版
版权所有(C) Microsoft Corporation。保留所有权利。

num_put.cpp
Microsoft (R) Incremental Linker Version 14.28.29115.0
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:num_put.exe
num_put.obj

C:\Users\He\source\test>.\num_put.exe
12345.7
0x1.8p+13
1.234568e+04

C:\Users\He\source\test>echo %ERRORLEVEL%
-1073740791

Expected:

1e+04
0x1.81cd6e63c53d7p+13
1e+04
12345.678901

[pabristow]

Thanks for this. Looks like a fix :-) I look forward to using the Preview release Microsoft Visual Studio Community 2019 Version 16.7.0 Preview 6.0 when it hits my machine.

The example given value does not show the fate of any trailing zeros. Are these always shown (as many as significant, of course) or are they only shown if std::showpoint has been set?

[fsb4000]

Hi Paul A. Bristow (@pabristow) .
This fix is expected in VS 2019 16.9 Preview 1. (https://github.com/microsoft/STL/wiki/Changelog)
Currently latest available VS 2019 16.8 Preview 2. So you should use git version of STL.

Test with trailing zeros:

C:\Dev\STL\playground>type main.cpp
#include <cstdlib>
#include <iomanip>
#include <iostream>

struct scand
{
    char* pos;
    double v;
    scand(const char* str) : v(std::strtod(str, &pos)) {}
    operator double() const { return v; }
};

// For hexfloat stream output, the stream precision should be ignored
int main()
{
    std::cout << std::hexfloat;
    std::cout << "default precision 6: " << scand("0x1.0000000000f") << '\n';
    for (int i = 0; i < 16; ++i)
        std::cout << "precision set to " << std::setw(2) << i << ": "
        << std::setprecision(i) << scand("0x1.0000000000f") << '\n';
}
C:\Dev\STL\playground>cl /EHsc /W4 /WX main.cpp
Оптимизирующий компилятор Microsoft (R) C/C++ версии 19.28.29213 для x64
(C) Корпорация Майкрософт (Microsoft Corporation).  Все права защищены.

main.cpp
Microsoft (R) Incremental Linker Version 14.28.29213.0
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:main.exe
main.obj

C:\Dev\STL\playground>main.exe
default precision 6: 0x1.0000000000f00p+0
precision set to  0: 0x1.0000000000f00p+0
precision set to  1: 0x1.0000000000f00p+0
precision set to  2: 0x1.0000000000f00p+0
precision set to  3: 0x1.0000000000f00p+0
precision set to  4: 0x1.0000000000f00p+0
precision set to  5: 0x1.0000000000f00p+0
precision set to  6: 0x1.0000000000f00p+0
precision set to  7: 0x1.0000000000f00p+0
precision set to  8: 0x1.0000000000f00p+0
precision set to  9: 0x1.0000000000f00p+0
precision set to 10: 0x1.0000000000f00p+0
precision set to 11: 0x1.0000000000f00p+0
precision set to 12: 0x1.0000000000f00p+0
precision set to 13: 0x1.0000000000f00p+0
precision set to 14: 0x1.0000000000f00p+0
precision set to 15: 0x1.0000000000f00p+0

Clang and gcc don't print trailing zeros: https://gcc.godbolt.org/z/erj4Ya

0x1.0000000000fp+0 instead of 0x1.0000000000f00p+0

Sorry, I can't say now if both options are acceptable, I will need to read the standard :(

[fsb4000]

Paul A. Bristow (@pabristow) it seems both variants are ok.

See: http://eel.is/c++draft/facet.num.put.virtuals#5

floatfield == (ios_­base​::​fixed | ios_­base​::​scientific) && !uppercase = stdio %a

And C standard for printf %a http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
page 313:

trailing zeros may be omitted

Not must be omitted
std::showpoint does not affect.
Trailing zeros are always shown
Sorry that you have to handle both cases as valid.

[pabristow]

OK - agree that this conforms with my reading of the confusing standard(s).

I note too that the hex digits can also differ in number of hexits and exponent (though the actual value read looks the same - though I have yet to check round-tripping of MSVC writing and Clang or GCC reading back).

C and C++ iostreams don't mesh well here, so we miss out on being able to chose the useful layouts of

• no trailing zeros for the most compact presentation, (Clang and GCC)

or

• trailing zeros to show the implied precision and neat and tidy tabulation (MSVC).

In all it seems a bit of a muddle to me, but there you go ... :-(