iomanip set at most 4 digits after decimal point

Question

I want to print to screen some numbers with at most 4 digits after decimal point using iomanip .

I've learned that in default mode setprecision counts not only the digits after decimal point but also the digits in the integer part. This code

#include <iostream>
#include <iomanip>

int main () {
    double numbers[] = {3.141516, 1.01, 200.78901, 0.12345};
    int len = sizeof(numbers) / sizeof(numbers[0]);

    std::cout << std::setprecision(4);
    for (int i = 0; i < len; ++i) {
        std::cout << numbers[i] << '\n';
    }
    return 0;
}

outputs:

3.142
1.01
200.8
0.1235

But what I want is: (at most 4 digits after decimal point without trailing zeros)

3.1415
1.01
200.789
0.1235

Is iomanip capable of doing this? Without using other tricks (like round )?

EDIT

It seems that I haven't made it clear enough. My question is iomanip specific

All I want to know is whether iomanip is capable of doing things I've described because iomanip is said to be the standard library for input/output manipulators. The posted question is

Is iomanip capable of doing this?

It's more like "is it supported" rather than "give me any solution".

I have searched it again, looked up iomanip references hoping for a clean and compact way to format floating numbers for at most n digits, using unnecessary libraries as little as possible.

And there seems to be no standard way to achieve this.

Answer 1

One (ugly) option to obtain OP's desired output is to represent the number with the wanted maximum precision and then just remove the unwanted zeroes:

#include <iostream>
#include <iomanip>
#include <sstream>
#include <vector>

int main()
{
    std::vector<double> numbers {
        3.141516, 1.01, 200.78901, 0.12345, 9.99999
    };

    for (auto x : numbers)
    {
        // "print" the number
        std::stringstream ss;
        ss << std::fixed << std::setprecision(4) << x;

        // remove the unwanted zeroes
        std::string result{ss.str()};
        while (result.back() == '0')
            result.pop_back();

        // remove the separator if needed   
        if (result.back() == '.')
            result.pop_back();

        std::cout << result  << '\n';
    }

    std::cout << "\nJustified:\n";
    for (auto x : numbers)
    {
        // "print" the number
        std::stringstream ss;
        ss << std::fixed << std::setprecision(4) << std::setw(15) << x;

        // remove the unwanted zeroes
        std::string result{ss.str()};
        auto it = result.rbegin();
        while (*it == '0')
            *it++ = ' ';

        // remove the separator if needed   
        if (*it == '.')
            *it = ' ';

        std::cout << result  << '\n';
    }
}

Live example: https://ideone.com/8zP17O

Answer 2

So:

• in std::fixedfield mode, std::setprecision sets the maximum number of significant figures , not decimal places;
• if you flip to std::fixed it means exact number of decimal places;
• C++ does not provide any analogue to the %.Nf printf format string! (up to N decimal places)

I've just thrown together a little fake I/O manipulator that can get the behaviour we both want. It's not terribly performant, but it does the job:

#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <cstdio>

struct sprintf_wrapper
{
    sprintf_wrapper(std::string fmt_str)
        : _fmt_str(std::move(fmt_str))
    {}

    struct proxy
    {
        proxy(const sprintf_wrapper& wrapper, std::ostream& os)
            : _wrapper(wrapper)
            , _os(os)
        {}

        std::ostream& Resolve(const double value) const
        {
            // First find out how many characters we're going to need
            const int len = std::snprintf(nullptr, 0, _wrapper._fmt_str.c_str(), value);
            if (len < 0)
            {
                _os.setstate(std::ios::failbit);
                return _os;
            }

            // Then allocate a buffer
            std::string result;
            result.resize(len);

            // Actually serialise the value according to the format string
            if (std::sprintf(result.data(), _wrapper._fmt_str.c_str(), value) < 0)
            {
                _os.setstate(std::ios::failbit);
                return _os;
            }

            // Stream it out
            _os.write(result.data(), result.size());
            return _os;
        }

        friend std::ostream& operator<<(const proxy& obj, const double val)
        {
            return obj.Resolve(val);
        }

    private:
        const sprintf_wrapper& _wrapper;
        std::ostream& _os;
    };

    friend proxy operator<<(std::ostream& os, const sprintf_wrapper& obj)
    {
        return proxy(obj, os);
    }

private:
    std::string _fmt_str;
};

inline auto sprintf_f(size_t n, const bool showpos = false)
{
    std::stringstream fmt;
    fmt << '%';
    if (showpos) fmt << '+';
    fmt << '.' << n << 'f';

    return sprintf_wrapper(fmt.str());
}

int main()
{
    std::cout << sprintf_f(2) << 4.123456789 << '\n';
    std::cout << sprintf_f(3) << 4.123456789 << '\n';
    std::cout << sprintf_f(4) << 4.123456789 << '\n';
    std::cout << sprintf_f(5) << 4.123456789 << '\n';
    std::cout << sprintf_f(6) << 4.123456789 << '\n';
}

( live demo )

Answer 3

Use a combination of std::fixed and std::setprecision .

#include <iomanip>
#include <iostream>

int main() {
    double d = 311.3456;
    std::cout << std::fixed;
    std::cout << std::setprecision(4);
    std::cout << d << std::endl;
}