Nasıl bir çift C ++ dize dönüştürür?

Bir dize olarak bir çift depolamak gerekir. Bunu printfgörüntülemek istedim eğer kullanabilirsiniz biliyorum , ama ben daha sonra bir harita ( değer olarak , anahtar olarak ) saklayabilirsiniz böylece bir dize değişkeni saklamak istiyorum .

Boost (tm) yol:

std::string str = boost::lexical_cast<std::string>(dbl);

Standart C ++ yol:

std::ostringstream strs;
strs << dbl;
std::string str = strs.str();

Not : Unutma#include <sstream>

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

Standart C ++ 11 yolu (eğer çıkış biçimi umurumda değil ise):

#include <string>

auto str = std::to_string(42.5); 

to_stringN1803 (r0), N1982 (r1) ve N2408 (r2) " Basit Sayısal Erişim " de tanıtılan yeni bir kütüphane işlevidir . stodTers işlemi gerçekleştirme işlevi de vardır .

Farklı bir çıktı biçimine sahip olmak istiyorsanız , diğer yanıtlarda gösterildiği gibi veya yöntemlerini "%f"kullanın .snprintfostringstream

C ++ kullanıyorsanız kaçının sprintf. Un-C ++ y ve çeşitli sorunları var. Dize akışları, tercihen Boost.LexicalCast'te olduğu gibi oldukça kolayca yapılabilen seçim yöntemidir :

template <typename T>
std::string to_string(T const& value) {
    stringstream sstr;
    sstr << value;
    return sstr.str();
}

Kullanımı:

string s = to_string(42.5);

C ++ 11'de std :: to_string kullanabilirsiniz

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

sprintftamam, ancak C ++ 'da, dönüşüm yapmanın daha iyi, daha güvenli ve biraz daha yavaş yolu şudur stringstream:

#include <sstream>
#include <string>

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

Ayrıca Boost.LexicalCast kullanabilirsiniz :

#include <boost/lexical_cast.hpp>
#include <string>

// In some function:
double d = 453.23;
std::string str = boost::lexical_cast<string>(d);

Her iki durumda da, daha sonra strolmalıdır "453.23". LexicalCast, dönüşümün tamamlanmasını sağlaması açısından bazı avantajlara sahiptir. stringstreamDahili olarak s kullanır .

Ben bakardım C ++ dize Toolkit Libary . Sadece başka bir yerde benzer bir cevap gönderdi. Çok hızlı ve güvenilir buldum.

#include <strtk.hpp>

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

Herb Sutter, dize biçimlendirme hakkında mükemmel bir makaleye sahiptir . Okumanızı tavsiye ederim. Daha önce SO'ya bağladım.

Lexical_cast ile ilgili sorun, hassasiyetin tanımlanamamasıdır. Normalde, bir çifti bir dizeye dönüştürüyorsanız, bunun nedeni onu yazdırmak istemenizdir. Hassasiyet çok fazla veya çok azsa, çıktınızı etkiler.

Ayrıca stringstream kullanabilirsiniz .

Heh, ben sadece yazdım (bu soru ile ilgisiz):

string temp = "";
stringstream outStream;
double ratio = (currentImage->width*1.0f)/currentImage->height;
outStream << " R: " << ratio;
temp = outStream.str();

/* rest of the code */

SO ile ilgili önceki yayınımı okumak isteyebilirsiniz. (Geçici bir ostringstream nesnesine sahip Macro'ed sürümü.)

Kayıt için: Kendi kodumda snprintf () tercih ediyorum. Yerel yığındaki bir char dizisiyle o kadar verimsiz değil. (Peki, belki dizi boyutunu aştıysanız ve bunu iki kez yapmak için ilmeklediyseniz ...)

(Ben de vsnprintf () ile sarılmış. Ama bu bana bir tür kontrol maliyeti. Yelp kodu istiyorsanız Yelp ...)

sprintf()Ve aileye bir göz atın .

Normalde bu işlemler için ecvt, fcvt veya gcvt İşlevlerini kullanmanız gerekir:

/* 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   

İşlev olarak:

void double_to_char(double f,char * buffer){
  gcvt(f,10,buffer);
}

Daha kompakt bir stil deneyebilirsiniz:

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

Kullanın to_string().
misal :

#include <iostream>   
#include <string>  

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

  return 0;
}

kendiniz çalıştırın: http://ideone.com/7ejfaU
Bunlar da mevcuttur:

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

Bu işlevi kullanarak herhangi bir şeyi herhangi bir şeye dönüştürebilirsiniz:

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

kullanım:

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