如何格式化浮点值，使其从不使用指数表示法，也没有尾随零？

Question

根据ios_base manipulators，在格式化没有指数表示法的浮点数（使用十进制数）时，我基本上可以在defaultfloat 和fixed 之间进行选择。

但是，我想选择 maximum precision，这会为许多数字（例如 1.）产生 a lot 尾随零的 fixed，但避免使用指数表示法。如果设置为defaultfloat，它将在大多数时间看起来正确，除非该值非常小，但不是0.。在这种情况下，默认表示会自行切换为科学记数法，这会破坏格式化输出的接收器（因为它不知道2.22045e-16 的含义。

那么，我怎样才能把我的馅饼也吃掉呢？也就是说，没有不必要的尾随零的非指数表示法。

---

_{注意：我没有测试defaultfloat 标志的效果，因为我的 gcc 似乎还没有实现该标志，但我认为它是默认设置，没有使用任何标志。我确实检查了fixed 标志，它的行为确实符合预期。}

Answer 1

一个简单的方法是这样的：

std::string float2string(double f)
{
    std::stringstream ss;

    ss << std::fixed << std::setprecision(122) << f;   // 122 is LARGE, but you may find that really tiny or really large numbers still don't work out... 

    std::string s = ss.str();

    std::string::size_type len = s.length();

    int zeros = 0;
    while(len > 1 && s[--len] == '0')
        zeros++;
    if (s[len] == '.')  // remove final '.' if number ends with '.'
        zeros++;
    s.resize(s.length()-zeros);


    return s;
}

我已经对其进行了一些测试。最大的问题是它为某些数字提供了大量的小数，并且像 0.05 这样的东西出来为0.05000000000000000277555756156289135105907917022705078125 0.7 变为： 0.05000000000000000277555756156289135105907917022705078125

那是因为它不是二进制形式的“精确”数字。

我认为解决方案是通过取整数位数（或 floor(log(f)/log(10)+1)）然后从一个常数，例如 17，这是您可以从 double 中获得的位数。然后删除多余的零。

我暂时先不说这个，因为我还有一些其他的事情要做，我应该在不久前就开始做……;)

Answer 2

由于似乎没有正确的方法来使用 stdlib 执行此操作，因此这是我的包装器。

  template <typename T>
  struct FpFormat {
    template <typename Stream>
    static Stream& setfmt(Stream& str) {
      return str;
    }
    template <typename String>
    static String const& untrail(String const& str) {
      return str;
    }
  };
  template <typename T>
  struct FpFormatFloats {
    template <typename Stream>
    static auto setfmt(Stream& str) -> decltype(str << std::fixed << std::setprecision(std::numeric_limits<T>::digits10)) {
      return str << std::fixed << std::setprecision(std::numeric_limits<T>::digits10);
    }
    template <typename String>
    static String untrail(String str) {
      if (str.find('.') == String::npos)
        return str;
      return ([](String s){
        return String(s.begin(),s.begin()+((s.back() == '.')?(s.size()-1):s.size()));
      })(str.substr(0,(str+"0").find_last_not_of('0')+1));
    }
  };
  template <> struct FpFormat<float> : FpFormatFloats<float> {};
  template <> struct FpFormat<double> : FpFormatFloats<double> {};
  template <> struct FpFormat<long double> : FpFormatFloats<long double> {};

  template <typename T>
  std::string toString(T x) {
    std::stringstream str;
    FpFormat<T>::setfmt(str) << x;
    return FpFormat<T>::untrail(str.str());
  }

Answer 3

遗憾的是，iostream 或 printf() 中似乎没有代码可以执行此操作。任何“这个”我的意思是：

1. 以固定格式打印。
2. 打印最小位数，以便编码无损（即最接近的有效浮点数是您打印的那个）。

您不能仅以非常大的精度打印并去除尾随零，因为可能存在不必要的非零数字。

我相信真正做到这一点的唯一好方法是使用像 Ryu 这样的专用代码。

另一种方法是以非常高的精度打印下一个和上一个数字，并取小数点后相同的数字（加一个）。不过会很丑。

Answer 4

没有内置格式可以为您执行此操作。您可以从头开始生成自己的格式化程序，也可以编写一个对字符串进行后处理以删除不必要的尾随零的格式化程序。

例如，您可以使用正则表达式替换：

#include <iomanip>
#include <iostream>
#include <sstream>
#include <regex>

// not thoroughly tested
std::string format(double d, int precision = 100) {
   std::stringstream ss;
   ss << std::fixed << std::setprecision(precision);
   ss << d;

   return std::regex_replace(
       std::regex_replace(ss.str(), std::regex(R"((-?\d*\.\d*?)0*$)"), "$1"),
       std::regex(R"(\.$)"), "");
}

int main() {
   std::cout << format(-1) << '\n';
   std::cout << format(1e20) << '\n';
   std::cout << format(1e-20) << '\n';
   std::cout << format(2.22045e-16) << '\n';
}

虽然使用正则表达式可能不是特别有效的解决方案。