仅使用标准 C++将任何浮点打印到恰好 N 个空格

Question

我有一个浮点数，我想将其打印到恰好 N 个空格。例如，N = 5。我想打印以下数字：

0.1        => 0.1
123.456789 => 123.5
-123.45678 => -123 (or -123.)
0.123456   => 0.123
123456.789 => 123456 (obviously, in this case, we cannot print less than 6 digits, if I can detect this, I can also print 12** to indicate the field is too wide.

我尝试了多种组合，包括以下内容：

// Leave 3 extra space: One for negative sign, one for zero, one for decimal
std::cout << std::setiosflags(std::ios::fixed) 
          << std::setprecision(N - 3) 
          << std::setw(N) 
          << input;

但结果并不理想。也许我错过了一些明显的东西？

这些示例输入的给定代码的输出是

 0.10     // not bad 
123.46    // Use 6 instead of 5 spaces
-123.46   // Use 7 instead of 5 spaces
 0.12     // Under-use the spaces
123456.79 // Ok, I guess

Answer 1

为此，请使用 Boost 的 Spirit.Karma：

#include <boost/spirit/include/karma.hpp>
namespace karma = boost::spirit::karma;

double d = 12345.6;

// will print: 12345
std::cout << karma::format(
        karma::maxwidth(5)[karma::double_], d
    ) << std::endl;

在任何情况下，这都会将输出的宽度限制为 5。如果您想捕获数字被切断的情况（如您的示例中的 123456.7），只需预先执行适当的检查：

if (d < 1e6) {
    // d == 12345 will print: 12345
    std::cout << karma::format(
            karma::maxwidth(5)[karma::double_], d
        ) << std::endl;
}
else {
    // d == 123456 will print: 12***
    std::cout << karma::format(
            karma::left_align(5, '*')[
                karma::maxwidth(2)[karma::double_]
            ], d
        ) << std::endl;
}

是的，如果您可能会问，Boost 的 Spirit.Karma 仅使用标准 C++ 编写特征。

Answer 2

int main ()
{
  const int N = 4;

  double f = 123.456789;

  // just use default floating-point notation to display N significant digits.
  // no fixed or scientific notation work for your requirement.
  // you can comment setf() line out if there is no one changing ios::floatfield.
  cout.setf(0, ios::floatfield); 
  cout.precision(N);

  cout << f << endl;              // will print 123.5
}

[更新]
我应该对提供的所有案例进行测试。 ：D

#include <iostream>
#include <math.h>
using namespace std;

void print_test(double number)
{
    const int N = 5; // should be greater than 2

    double maxIntPart = pow(10.0, number >= 0 ? N - 2 : N - 3);

    double fractpart, intpart;
    fractpart = modf(number , &intpart);

    ios_base::fmtflags prevNotation = cout.setf(0, ios::floatfield);  // use default floating-point notation
    streamsize prevPrecicion = cout.precision();

    if( abs(intpart) > maxIntPart )
    {
        intpart = ceil(number);
        if( abs(intpart) < maxIntPart * 10 )
        {
            cout << intpart << endl;
        }
        else
        {               
            while( abs(intpart) >= maxIntPart )
            {
                intpart /= 10;
            }

            cout << (intpart > 0 ? floor(intpart) : ceil(intpart)) << "**" << endl;
        }
    }
    else
    {
        if ( number < 0 )
        {
            cout.precision(N - 3);
        }
        else if ( intpart == 0)
        {
            cout.precision(N - 2);
        }
        else
        {
            cout.precision(N - 1);
        }
        cout << number << endl;
    }

    cout.setf(prevNotation, ios::floatfield); 
    cout.precision(prevPrecicion);
}


int main ()
{
    print_test(0.1);                // 0.1
    print_test(123.456789);         // 123.5
    print_test(-123.45678);         // -123
    print_test(0.123456);           // 0.123
    print_test(-0.123456);          // -0.12
    print_test(123456.789);         // 123**
    print_test(-123456.789);        // -12**
 }

Answer 3

您似乎想要打印 N 个字符 - 包括减号（如果有）和小数点。 set precision只关心小数点后的位数。所以，一点数学知识就能得到你想要的东西：

#include <cmath>

// determine what precision we need
int precision = N - 1;                      // leave room for the decimal point
if (input < 0) --precision;                 // leave room for the minus sign
precision -= (1 + (int)log10(abs(input)));  // how many digits before the decimal?
if (precision < 0) precision = 0;           // don't go negative with precision

std::cout << std::setiosflags(std::ios::fixed) 
          << std::setprecision(precision) 
          << std::setw(N) 
          << input;

我可能需要解释一下对数线：

precision -= (1 + (int)log10(abs(input))); // how many digits before the decimal?

• 从 0 到 9 的任何数字都需要一位数字来打印。
• 0-9 的 log10 会给出一个小于 1 的数字，这会截断为 int 0
• 10-99 之间的任何数字都需要两位数字来打印。
• log10 of 10-99 给出的数字至少为 1，但小于 2 - 截断为 int 1
• 所以... log10(input) 加 1 就是它打印的位数

Answer 4

iostream 精度/宽度标志不能很好地满足您的要求 - 例如，精度计算有效数字而不是字符位置，并且 4 个请求 0.123456 映射到 0.1234 而不是您请求的 0.123（您愿意吗？）期望 0.00123456 为“0.00”？）。无论如何，要使用精度，您需要根据值改变参数。 如下所示编写自己的函数可能会更容易...

最简单的方法是以额外的精度将值写入字符串流，然后从左到右扫描（记录是否找到 ' .') 直到到达要截断的位置，然后从右向左扫描以删除尾随 0，或者如果“.”则替换为“**”。之前没有遇到过。

否则，您可以实现自己的双精度到 ASCII 转换，可能使用 Linux 的 之类的标头来提供带有 上的位字段的 union >float 和 double 类型；否则使用您选择的数学运算。

Answer 5

丑陋，但也许你想要：

if(input < pow(10,N+1)) {
  ostringstream sout;
  sout << input;
  cout << setw(N) << sout.str().substr(0,N);
} else cout << (int)input;