C++11 double转化为string

C++11转化double为string是一件很容易的事情。

方法：

1：使用C中的sprintf函数，这里就不说了。

2：使用std::ostringstream。这个与std::cout是一样的。这个在C++11以前就已经支持了的。这个得出的结果与使用std::cout的结果是一样的。

3：从C++11开始，标准库提供了std::to_string辅助函数转化各类型为一个字符串。

std::ostringstream和std::to_string

但是std::ostringstream和std::to_string使用的结果就有些很奇怪的差异了。主要有：

1：std::string得到的结果始终是小数位必然是6！

2：默认情况下，std::ostringstream对double使用的是6位精度。这里精度值的是整数位和小数位个数和。但是精度是可以设置的。这里统一谈论默认的情况。

也就是说，如果参数精度超过6位的话，那么会将数值四舍五入，然后丢弃多余的位数！
具体来说是这样的：

1：如果整数位不足6位，而整体精度超过了6，那么小数位四舍五入，然后截断多余的位数。

2：如果是整数位超过了6，那么舍弃小数位，然后按照科学计数法保存。

比如：

序号	double原值	std::ostringstream结果
1	1.0000000000001	1
2	0.12345678	0.123457
3	123456789.0000000000001	1.23457e+08
4	123456789.1234567	1.23457e+08
5	0.0000000000001	1e-13

下面我们详细比较std::ostringstream和std::to_string使用的结果的差异。

这里是详细的测试代码，请注意，这里必须是C++11及以上版本！

      #include <string>
      #include <cassert>
      #include <iostream>
      #include <sstream>

      std::string DoubleToStringByStdToString(double value)
      {

          const std::string& new_val = std::to_string(value);
          return new_val;
      }
     ▫
      std::string DoubleToStringByStringStream(double value)
      {
          std::ostringstream stream;
          stream << value;
          return stream.str();
      }
     ▫
      void TestDoubleToStringByStdToString(const double value, const std::string& origin, const std::string& expect_str)
      {
          const std::string& val = DoubleToStringByStdToString(value);
          std::cout << __FUNCTION__ << " --> original:" << origin
                                    << ", std::cout:" << value
                                    << ", std::to_string:" << val<< std::endl;
     ▫
          assert( val == expect_str);
      }
     ▫
      void TestDoubleToStringByStringStream(const double value, const std::string& origin, const std::string& expect_str)
      {
          const std::string& val = DoubleToStringByStringStream(value);
          std::cout << __FUNCTION__ << " --> original:" << origin
                                    << ", std::cout:" << value
                                    << ", std::stringstream:" << val<< std::endl;
     ▫
          assert( val == expect_str);
      }

     int main(int argc, char* argv[])
     {
         TestDoubleToStringByStdToString(, "", "0.000000");
         TestDoubleToStringByStringStream(, "", "");

         TestDoubleToStringByStdToString(., ".0", "0.000000");
         TestDoubleToStringByStringStream(., ".0", "");

         TestDoubleToStringByStdToString(0.0, "0.0", "0.000000");
         TestDoubleToStringByStringStream(0.0, "0.0", "");

         TestDoubleToStringByStdToString(1.0, "1.0", "1.000000");
         TestDoubleToStringByStringStream(1.0, "1.0", "");

         TestDoubleToStringByStdToString(1.0000008, "1.0000008", "1.000001");
         TestDoubleToStringByStringStream(1.0000008, "1.0000008", "");

         TestDoubleToStringByStdToString(1.0000000000001,"1.0000000000001", "1.000000");
         TestDoubleToStringByStringStream(1.0000000000001,"1.0000000000001", "");

         TestDoubleToStringByStdToString(0.0000000000001,"0.0000000000001", "0.000000");
         TestDoubleToStringByStringStream(0.0000000000001,"0.0000000000001", "1e-13");

         TestDoubleToStringByStdToString(0.12345678,"0.12345678", "0.123457");
         TestDoubleToStringByStringStream(0.12345678,"0.12345678", "0.123457");

         TestDoubleToStringByStdToString(100000000000.0000000000001,"100000000000.0000000000001", "100000000000.000000");
         TestDoubleToStringByStringStream(100000000000.0000000000001,"100000000000.0000000000001", "1e+11");

         TestDoubleToStringByStdToString(1e+,"1e+11",  "100000000000.000000");
         TestDoubleToStringByStringStream(1e+,"1e+11",  "1e+11");

         TestDoubleToStringByStdToString(123456.0000000000001, "123456.0000000000001", "123456.000000");
         TestDoubleToStringByStringStream(123456.0000000000001, "123456.0000000000001", "");

         TestDoubleToStringByStdToString(123456789.1234567,"123456789.1234567", "123456789.123457");
         TestDoubleToStringByStringStream(123456789.1234567,"123456789.1234567", "1.23457e+08");

         TestDoubleToStringByStdToString(123456789.0000000000001,"123456789.0000000000001", "123456789.000000");
         TestDoubleToStringByStringStream(123456789.0000000000001,"123456789.0000000000001", "1.23457e+08");

         return ;
     }

我们这里将结果整理出来如下表

序号	double原值	std::cout	std::ostringstream结果	std::to_string()结果
1	0	0	0	0.000000
2	.0	0	0	0.000000
3	0.0	0	0	0.000000
4	1.0	1	1	1.000000
5	1.0000008	1	1	1.000001
6	1.0000000000001	1	1	1.000000
7	0.0000000000001	1e-13	1e-13	0.000000
8	0.12345678	0.123457	0.123457	0.123457
9	100000000000.0000000000001	1e+11	1e+11	100000000000.000000
10	1e+11	1e+11	1e+11	100000000000.000000
11	123456.0000000000001	123456	123456	123456.000000
12	123456789.1234567	1.23457e+08	1.23457e+08	123456789.123457
13	123456789.0000000000001	1.23457e+08	1.23457e+08	123456789.000000

从上面的结果我们还可以发现一个关于std::to_string的特点

如果传入的double本身是科学记数法，to_string仍然可以执行转化，且得出的结果与该科学技术法表述的值转化的结果是一样的！

总结

虽然C++对关转化double为string提供的方法很多,但是的得出的结果不一样。所以在使用时应该统一方法，并且格外小心，如果是在对double很敏感的行业，那么应该对该操作封装，并提供足够的控制参数。

一种可参考的实现

从上面我们可以看出使用ostringstream或者to_string的方法，要么存在精度显示问题要么调整为科学计数法显示。这些都不是我们想要的。

所以我们可以使用ostringstream封装一个辅助函数，可以控制精度也可以控制科学计数法显示。

精度

ostringstream是可以控制精度的，函数原型如下：

std::ios_base::precision

第一版

 std::string DoubleToString(const double value, unsigned int precision)
 {
    std::ostringstream out;
    if (precision > )
        out.precision(precision);

    out << value;
    return out.str();
 }

 int main(int argc, char* argv[])
 {
     std::cout << DoubleToString(., ) << std::endl;
     std::cout << DoubleToString(0.0, ) << std::endl;
     std::cout << DoubleToString(., ) << std::endl;
     std::cout << DoubleToString(1.0, ) << std::endl;
     std::cout << DoubleToString(, ) << std::endl;
     std::cout << DoubleToString(0.12345, ) << std::endl;
     std::cout << DoubleToString(0.12345678, ) << std::endl;
     std::cout << DoubleToString(0.12345678, ) << std::endl;
     std::cout << DoubleToString(0.12345678, ) << std::endl;
     std::cout << DoubleToString(0.12345678, ) << std::endl;
     return ;
 }

这是测试结果的输出：

0
0
0
1
11234
0.12345
0.12345678
0.12345678
0.12345678
0.123457

第二版

多数情况下我们更加关注的是小数点后的几位数，所以我们调整参数控制小数点后位数。

 #include <limits>
 std::string DoubleToString(const double value, unsigned int precisionAfterPoint)
 {
    std::ostringstream out;
    // 清除默认精度
    out.precision(std::numeric_limits<double>::digits10);
    out << value;

    std::string res = std::move(out.str());
    auto pos = res.find('.');
    if (pos == std::string::npos)
        return res;

    auto splitLen = pos +  + precisionAfterPoint;
    if (res.size() <= splitLen)
        return res;

    return res.substr(, splitLen);
 }

 int main(int argc, char* argv[])
 {
     std::cout << DoubleToString(., ) << std::endl;
     std::cout << DoubleToString(0.0, ) << std::endl;
     std::cout << DoubleToString(., ) << std::endl;
     std::cout << DoubleToString(1.0, ) << std::endl;
     std::cout << DoubleToString(, ) << std::endl;
     std::cout << DoubleToString(12345.12345678, ) << std::endl;
     std::cout << DoubleToString(12345.12345678, ) << std::endl;
     std::cout << DoubleToString(12345.12345678, ) << std::endl;
     std::cout << DoubleToString(12345.12345678, ) << std::endl;
     std::cout << DoubleToString(12345.12345678, ) << std::endl;
     std::cout << DoubleToString(12345.00000001, ) << std::endl;
     std::cout << DoubleToString(12345.00000001, ) << std::endl;
     std::cout << DoubleToString(12345.00000001, ) << std::endl;
     return ;
 }

这是测试结果的输出：

0
0
0
1
11234
12345.12345678
12345.12345678
12345.1234567
12345.12345678
12345.123456
12345.0000000
12345.00000001
12345.000000

第三版

更进一步的，我们一般默认情况下小数点后是是6位小数的。所以我们可以设置默认参数：

 #include <limits>
 std::string DoubleToString(const double value, unsigned int precisionAfterPoint = )
 {
    std::ostringstream out;
    // 清除默认精度
    out.precision(std::numeric_limits<double>::digits10);
    out << value;

    std::string res = std::move(out.str());
    auto pos = res.find('.');
    if (pos == std::string::npos)
        return res;

    auto splitLen = pos +  + precisionAfterPoint;
    if (res.size() <= splitLen)
        return res;

    return res.substr(, splitLen);
 }

第四版

1：实际上第三版的实现存在一个BUG，即设置默认小数位后没有执行四舍五入！

2：性能。这个实现性能如何，是不是存在更佳的实现呢？

3：处理完成后，如果小数位全是0，该怎么处理？

请读者自己去研究解决。