标签：val 个数 value nal c++11 辅助 使用 并且 截断
C++11转化double为string是一件很容易的事情。
1：使用C中的fprintf函数，这里就不说了。
2：使用std::ostringstream。这个与std::cout是一样的。这个在C++11以前就已经支持了的。这个得出的结果与使用std::cout的结果是一样的。
3：从C++11开始，标准库提供了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及以上版本！
1 1 #include <string> 2 2 #include <cassert> 3 3 #include <iostream> 4 4 #include <sstream> 5 5 6 6 std::string DoubleToStringByStdToString(double value) 7 7 { 8 9 8 const std::string& new_val = std::to_string(value); 10 9 return new_val; 11 10 } 12 11 ? 13 12 std::string DoubleToStringByStringStream(double value) 14 13 { 15 14 std::ostringstream stream; 16 15 stream << value; 17 16 return stream.str(); 18 17 } 19 18 ? 20 19 void TestDoubleToStringByStdToString(const double value, const std::string& origin, const std::string& expect_str) 21 20 { 22 21 const std::string& val = DoubleToStringByStdToString(value); 23 22 std::cout << __FUNCTION__ << " --> original:" << origin 24 23 << ", std::cout:" << value 25 24 << ", std::to_string:" << val<< std::endl; 26 25 ? 27 26 assert( val == expect_str); 28 27 } 29 28 ? 30 29 void TestDoubleToStringByStringStream(const double value, const std::string& origin, const std::string& expect_str) 31 30 { 32 31 const std::string& val = DoubleToStringByStringStream(value); 33 32 std::cout << __FUNCTION__ << " --> original:" << origin 34 33 << ", std::cout:" << value 35 34 << ", std::stringstream:" << val<< std::endl; 36 35 ? 37 36 assert( val == expect_str); 38 37 } 39 38 40 39 int main(int argc, char* argv[]) 41 40 { 42 41 TestDoubleToStringByStdToString(0, "0", "0.000000"); 43 42 TestDoubleToStringByStringStream(0, "0", "0"); 44 43 45 44 TestDoubleToStringByStdToString(.0, ".0", "0.000000"); 46 45 TestDoubleToStringByStringStream(.0, ".0", "0"); 47 46 48 47 TestDoubleToStringByStdToString(0.0, "0.0", "0.000000"); 49 48 TestDoubleToStringByStringStream(0.0, "0.0", "0"); 50 49 51 50 TestDoubleToStringByStdToString(1.0, "1.0", "1.000000"); 52 51 TestDoubleToStringByStringStream(1.0, "1.0", "1"); 53 52 54 53 TestDoubleToStringByStdToString(1.0000008, "1.0000008", "1.000001"); 55 54 TestDoubleToStringByStringStream(1.0000008, "1.0000008", "1"); 56 55 57 56 TestDoubleToStringByStdToString(1.0000000000001,"1.0000000000001", "1.000000"); 58 57 TestDoubleToStringByStringStream(1.0000000000001,"1.0000000000001", "1"); 59 58 60 59 TestDoubleToStringByStdToString(0.0000000000001,"0.0000000000001", "0.000000"); 61 60 TestDoubleToStringByStringStream(0.0000000000001,"0.0000000000001", "1e-13"); 62 61 63 62 TestDoubleToStringByStdToString(0.12345678,"0.12345678", "0.123457"); 64 63 TestDoubleToStringByStringStream(0.12345678,"0.12345678", "0.123457"); 65 64 66 65 TestDoubleToStringByStdToString(100000000000.0000000000001,"100000000000.0000000000001", "100000000000.000000"); 67 66 TestDoubleToStringByStringStream(100000000000.0000000000001,"100000000000.0000000000001", "1e+11"); 68 67 69 68 TestDoubleToStringByStdToString(1e+11,"1e+11", "100000000000.000000"); 70 69 TestDoubleToStringByStringStream(1e+11,"1e+11", "1e+11"); 71 70 72 71 TestDoubleToStringByStdToString(123456.0000000000001, "123456.0000000000001", "123456.000000"); 73 72 TestDoubleToStringByStringStream(123456.0000000000001, "123456.0000000000001", "123456"); 74 73 75 74 TestDoubleToStringByStdToString(123456789.1234567,"123456789.1234567", "123456789.123457"); 76 75 TestDoubleToStringByStringStream(123456789.1234567,"123456789.1234567", "1.23457e+08"); 77 76 78 77 TestDoubleToStringByStdToString(123456789.0000000000001,"123456789.0000000000001", "123456789.000000"); 79 78 TestDoubleToStringByStringStream(123456789.0000000000001,"123456789.0000000000001", "1.23457e+08"); 80 79 81 80 return 0; 82 81 }
我们这里将结果整理出来如下表
| 序号 | 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很敏感的行业，那么应该对该操作封装，并提供足够的控制参数。
标签：val 个数 value nal c++11 辅助 使用 并且 截断
原文地址：http://www.cnblogs.com/chorulex/p/7660187.html
