C++: what is the optimal way to convert a double to a string?

Question

What is the most optimal way to achieve the same as this?

void foo(double floatValue, char* stringResult)
{
    sprintf(stringResult, "%f", floatValue);
}

Answer 1

I'm sure someone will say boost::lexical_cast, so go for that if you're using boost, but it's basically the same as this anyway:

 #include <sstream>
 #include <string>

 std::string doubleToString(double d)
 {
    std::ostringstream ss;
    ss << d;
    return ss.str();
 }

Note that you could easily make this into a template that works on anything that can be stream-inserted (not just doubles).

Answer 2

http://www.cplusplus.com/reference/iostream/stringstream/

double d=123.456;
stringstream s;
s << d; // insert d into s

Answer 3

Boost::lexical_cast<>

Answer 4

On dinkumware STL, the stringstream is filled out by the C library snprintf.

Thus using snprintf formatting directly will be comparable with the STL formatting part. But someone once told me that the whole is greater than or equal to the sum of its known parts.

As it will be platform dependent as to whether stringstream will do an allocation (and I am quite sure that DINKUMWARE DOES NOT YET include a small buffer in stringstream for conversions of single items like yours) it is truely doubtful that ANYTHING that requires an allocation (ESPECIALLY if MULTITHREADED) can compete with snprintf.

In fact (formatting+allocation) has a chance of being really terrible as an allocation and a release might well require 2 full read-modify-write cycles in a multithreaded environment unless the allocation implementation has a thread local small heap.

That being said, if I was truely concerned about performance, I would take the advice from some of the other comments above, change the interface to include a size and use snprintf - i.e.

bool 
foo(const double d, char* const p, const size_t n){
     use snprintf......
     determine if it fit, etc etc etc.
}

If you want a std::string you are still better off using the above and instantiating the string from the resultant char* as there will be 2 allocations + 2 releases involved with the std::stringstream, std::string solution.

BTW I cannot tell if the "string" in the question is std::string or just generic ascii chars usage of "string"

Answer 5

The best thing to do would be to build a simple templatized function to convert any streamable type into a string. Here's the way I do it:

#include <sstream>
#include <string>

template <typename T>
const std::string to_string(const T& data)
{
   std::ostringstream conv;
   conv << data;
   return conv.str();
}

If you want a const char* representation, simply substitute conv.str().c_str() in the above.

Answer 6

I'd say sprintf is pretty much the optimal way. You may prefer snprintf over it, but it doesn't have much to do with performance.

Answer 7

I'd probably go with what you suggested in your question, since there's no built-in ftoa() function and sprintf gives you control over the format. A google search for "ftoa asm" yields some possibly useful results, but I'm not sure you want to go that far.

Answer 8

Herb Sutter has done an extensive study on the alternatives for converting an int to a string, but I would think his arguments hold for a double as well.

He looks at the balances between safety, efficiency, code clarity and usability in templates.

Read it here: http://www.gotw.ca/publications/mill19.htm

Answer 9

_gcvt or _gcvt_s.

Answer 10

If you use the Qt4 frame work you could go :

double d = 5.5;
QString num = QString::number(d);

Answer 11

This is very useful thread. I use sprintf_s for it but I started to doubt if it is really faster than other ways. I came across following document on Boost website which shows performance comparison between Printf/scanf, StringStream and Boost.

Double to String is most common conversion we do in our code, so i'll stick with what i've been using. But, using Boost in other scenarios could be your deciding factor.

http://www.boost.org/doc/libs/1_58_0/doc/html/boost_lexical_cast/performance.html

Answer 12

In the future, you can use std::to_chars to write code like https://godbolt.org/z/cEO4Sd . Unfortunately, only VS2017 and VS2019 support part of this functionality...

#include <iostream>
#include <charconv>
#include <system_error>
#include <string_view>
#include <array>

int main()
{
    std::array<char, 10> chars;
    auto [parsed, error] = std::to_chars(
        chars.data(), 
        chars.data() + chars.size(), 
        static_cast<double>(12345.234)
    );
    std::cout << std::string_view(chars.data(), parsed - chars.data());
}

For a lengthy discussion on MSVC details, see https://www.reddit.com/r/cpp/comments/a2mpaj/how_to_use_the_newest_c_string_conversion/eazo82q/