C++ 如何在C++；？

我需要将一个双精度存储为字符串。我知道如果我想显示它，我可以使用

printf

，但我只想将它存储在一个字符串变量中，以便以后可以将它存储在映射中（作为值，而不是键）。

看看

sprintf（）

和族。

您也可以使用。

//C方式：
字符缓冲区[32]；
snprintf（buffer，sizeof（buffer），“%g”，myDoubleVar）；
//C++03方法：
std：：ostringstream sstream；
ScFrase
如果使用C++，请避免<代码> SpRITF< < /代码>。它是un-C++y，有几个问题。Stringstreams是选择的方法，最好封装为非常容易实现的：
template <typename T>
std::string to_string(T const& value) {
    stringstream sstr;
    sstr << value;
    return sstr.str();
}

嘿，我刚刚写了这个（与这个问题无关）：

string temp=”“；
溪流外流；
双倍比率=（currentImage->宽度*1.0f）/currentImage->高度；
外流 <代码> SpaFrf是好的，但是在C++中，转换的更好、更安全和稍微慢的方式是<<代码> StrugSuth >：

#include <sstream>
#include <string>

// In some function:
double d = 453.23;
std::ostringstream os;
os << d;
std::string str = os.str();

#包括
#包括
//在某些功能中：
双d=453.23；
std：：ostringstream os；
osboost（tm）方式：

std:：string str=boost:：词法转换（dbl）；

标准C++方式：
std:：ostringstream strs；
strsHerb-Sutter具有良好的临床疗效。我建议你读一读。我一直在努力。

作为记录：在我自己的代码中，我喜欢snprintf（）。在本地堆栈上使用char数组，效率就没有那么低了。（好吧，如果您超出了数组大小并循环执行两次…）

（我还通过vsnprintf（）对其进行了包装。但这需要一些类型检查。如果需要代码，请发出Yelp…
词法转换的问题是无法定义精度。通常，如果要将double转换为字符串，这是因为要将其打印出来。如果精度太高或太低，将影响您的输出。
标准C++11方式（如果您不关心输出格式）：

#包括
自动str=std:：to_字符串（42.5）；

是（r0）、（r1）和（r2）“简单数字访问”中引入的新库函数。还有执行反向操作的
stod
功能

如果您确实希望使用不同于
“%f”
的输出格式，请使用
snprintf
或
ostringstream
方法，如其他答案所示。
您可以尝试更紧凑的样式：

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(); 

std:：字符串中的字符串编号；
双倍数字；
std：：ostringstream输出；
字符串中的数字=（dynamic_cast（&（output我会查看。刚刚在别处发布了一个类似的答案。我发现它非常快速可靠

#include <strtk.hpp>

double pi = M_PI;
std::string pi_as_string  = strtk::type_to_string<double>( pi );

#包括
双π=M_π；
std:：string pi_as_string=strtk:：type_to_string（pi）；
通常，此操作必须使用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   

使用
编辑字符串（）


例如：

#include <iostream>   
#include <string>  

using namespace std;
int main ()
{
    string pi = "pi is " + to_string(3.1415926);
    cout<< "pi = "<< pi << endl;

  return 0;
}

您可以使用此功能将任何内容转换为任何内容：

template<class T = std::string, class U>
T to(U a) {
    std::stringstream ss;
    T ret;
    ss << a;
    ss >> ret;
    return ret;
};

模板
T至（U a）{
std：：stringstream-ss；
T-ret；
ss>ret；
返回ret；
};

用法：

std::string str = to(2.5);
double d = to<double>("2.5");

std:：string str=to（2.5）；
双d=至（“2.5”）；
您可以在C++11中使用

请注意，字符串只是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();
}

我认为Boo:：ListalIX几乎是标准的C++方式，只是为您精心包装。BTW，LITB，您在那里有一个小的键入“引导：LoistalyCost”.boost:：lexical_cast不仅仅是stringstream代码的简单包装器。许多转换例程都是内联实现的。根据本页底部的性能度量（），boost:：lexical_cast比使用stringstreams更快，而且在大多数情况下比scanf更快/printf@Ferr谁说它是一个简单的包装器？谢谢提供链接，我实际上认为它或多或少是一个简单的包装器：“不要忘记<代码>包含C++的代码/ < >：出于文档的考虑，如果您不
#include
，您将得到一个错误“不允许使用不完整的类型”我提到printf是因为谷歌找到了一堆文章，上面说要将使用printf的字符串从双精度转换为字符串。他们假设你唯一能做的就是打印，这在我的例子中是错误的。为什么你投-1票？我认为sprintf是好的。@BilltheLizard，sprint将一些东西打印到一个字符*而不是屏幕上。有人说wered c方法仍然获得了很多选票。哦，是的，宝贝。to_字符串和stod都在Visual Studio 11中工作。哦，亲爱的宝贝…to_字符串在VisualStudio 2010中似乎不起作用）：那，或者我不知道我在做什么（很可能），有没有办法使此函数不添加超过需要的小数？当我转换双精度
8.0
时，它会给我字符串
“8.000000”
，而
“8”
会很好。您可以对（int lsd=str.len（）；lsd>0&&str[lsd]='0'；lsd--）执行类似
的操作；str=str.substr（lsd）这不适用于小数字。。。例如：
1e-9
生成一个问题来回答您的问题：为什么要将双精度值存储在字符串中以将其存储在地图中？你要用字符串作为键吗？如果不是，为什么不保持原样呢？有趣的一点。然而，使用double作为映射键可能充满危险，因为浮点值的精确比较总是存在的。对字符串表示进行索引可以避免这个问题。为什么要转换它呢？将其作为双精度存储在地图中，并避免与对象之间的转换。这听起来仍然像是对对象的调用。工会会起作用的。每个对象都需要向其中插入不同的值，并进行自我验证。我在一个文件中只有一组名称/值对。信息技术
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(); 

#include <strtk.hpp>

double pi = M_PI;
std::string pi_as_string  = strtk::type_to_string<double>( pi );

/* 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);
}

#include <iostream>   
#include <string>  

using namespace std;
int main ()
{
    string pi = "pi is " + to_string(3.1415926);
    cout<< "pi = "<< pi << endl;

  return 0;
}

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);

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");

double d = 3.0;
std::string str = std::to_string(d);

#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