我需要将双精度值存储为字符串。我知道如果我想显示它，我可以使用
printf// The C way:
char buffer[32];
snprintf(buffer, sizeof(buffer), "%g", myDoubleVar);
// The C++03 way:
std::ostringstream sstream;
sstream << myDoubleVar;
std::string varAsString = sstream.str();
// The C++11 way:
std::string varAsString = std::to_string(myDoubleVar);
// The boost way:
std::string varAsString = boost::lexical_cast<std::string>(myDoubleVar);
boost (tm)方式：
std::string str = boost::lexical_cast<std::string>(dbl);
标准 C++ 方式：
std::ostringstream strs;
strs << dbl;
std::string str = strs.str();
注意：别忘了
#include <sstream>您可以在 C++11 中使用 std::to_string
double d = 3.0;
std::string str = std::to_string(d);
如果您使用 C++，请避免
sprintftemplate <typename T>
std::string to_string(T const& value) {
stringstream sstr;
sstr << value;
return sstr.str();
}
用途：
string s = to_string(42.5);
sprintfstringstream#include <sstream>
#include <string>
// In some function:
double d = 453.23;
std::ostringstream os;
os << d;
std::string str = os.str();
您还可以使用Boost.LexicalCast：
#include <boost/lexical_cast.hpp>
#include <string>
// In some function:
double d = 453.23;
std::string str = boost::lexical_cast<string>(d);
在这两种情况下，
str"453.23"stringstream我会查看C++ String Toolkit Libary。刚刚在其他地方发布了类似的答案。我发现它非常快速且可靠。
#include <strtk.hpp>
double pi = M_PI;
std::string pi_as_string = strtk::type_to_string<double>( pi );
lexical_cast 的问题是无法定义精度。通常，如果您将双精度型转换为字符串，那是因为您想将其打印出来。如果精度太大或太小，都会影响你的输出。
您还可以使用stringstream。
呵呵，我刚刚写了这个（与这个问题无关）：
string temp = "";
stringstream outStream;
double ratio = (currentImage->width*1.0f)/currentImage->height;
outStream << " R: " << ratio;
temp = outStream.str();
/* rest of the code */
通常对于此操作，您必须使用 C 默认的 ecvt、fcvt 或 gcvt 函数：
/* gcvt example */
#include <stdio.h>
#include <stdlib.h>
main ()
{
char buffer [20];
gcvt (1365.249,6,buffer);
puts (buffer);
gcvt (1365.249,3,buffer);
puts (buffer);
return 0;
}
Output:
1365.25
1.37e+003
作为函数：
void double_to_char(double f,char * buffer){
gcvt(f,10,buffer);
}
您可能想阅读我之前关于 SO 的帖子。 （带有临时 ostringstream 对象的宏版本。）
郑重声明：在我自己的代码中，我更喜欢 snprintf()。使用本地堆栈上的 char 数组，效率并没有那么低。 （好吧，也许如果你超出了数组大小并循环执行两次......）
（我还通过 vsnprintf() 包装了它。但这需要我进行一些类型检查。如果你想要代码，请大声喊...）
看看
sprintf()请注意，字符串只是 double 的表示形式，将其转换回 double 可能不会产生相同的值。 另请注意，默认字符串转换可能会将转换修剪为一定的精度。 在标准C++方式中，可以按如下方式控制精度：
#include <sstream>
#include <math.h>
#include <iostream>
#include <iomanip>
int main()
{
std::ostringstream sout;
sout << M_PI << '\n';
sout << std::setprecision(99) << M_PI << '\n';
sout << std::setprecision(3) << M_PI << '\n';
sout << std::fixed; //now the setprecision() value will look at the decimal part only.
sout << std::setprecision(3) << M_PI << '\n';
std::cout << sout.str();
}
这会给你输出
3.14159
3.141592653589793115997963468544185161590576171875
3.14
3.142
使用
to_string()#include <iostream>
#include <string>
using namespace std;
int main ()
{
string pi = "pi is " + to_string(3.1415926);
cout<< "pi = "<< pi << endl;
return 0;
}
自己运行：http://ideone.com/7ejfaU
这些也可用：
string to_string (int val);
string to_string (long val);
string to_string (long long val);
string to_string (unsigned val);
string to_string (unsigned long val);
string to_string (unsigned long long val);
string to_string (float val);
string to_string (double val);
string to_string (long double val);
你可以尝试更紧凑的风格：
std::string number_in_string;
double number_in_double;
std::ostringstream output;
number_in_string = (dynamic_cast< std::ostringstream*>(&(output << number_in_double <<
std::endl)))->str();
您可以使用此功能将任何东西转换为任何东西：
template<class T = std::string, class U>
T to(U a) {
std::stringstream ss;
T ret;
ss << a;
ss >> ret;
return ret;
};
用法：
std::string str = to(2.5);
double d = to<double>("2.5");
C++17引入了： std::to_chars、std::to_chars_result - cppreference.com
std::to_chars_result to_chars( char* first, char* last, float value, std::chars_format fmt, int precision ); std::to_chars_result to_chars( char* first, char* last, double value, std::chars_format fmt, int precision ); std::to_chars_result to_chars( char* first, char* last, long double value, std::chars_format fmt, int precision );
它提供了快速的低级方法将浮点转换为具有某种格式控制级别的字符串。这应该很快，因为没有完成分配，只有特定场景的自定义实现应该更快。
C++20 引入了高级易于使用的格式字符串（相当于 fmt 库）：
std::格式
template< class... Args > std::string format( /*format_string<Args...>*/ fmt, Args&&... args ); template< class... Args > std::wstring format( /*wformat_string<Args...>*/ fmt, Args&&... args ); template< class... Args > std::string format( const std::locale& loc, /*format_string<Args...>*/ fmt, Args&&... args ); template< class... Args > std::wstring format( const std::locale& loc, /*wformat_string<Args...>*/ fmt, Args&&... args );
这非常好用且方便。应该会更快
sprintf将
doublestd::to_string在
std::to_stringstd::formatstd::string s = std::format("{}", 0.42);
免责声明：我是 C++20 的作者
std::format