Comparing 3 modern c++ ways to convert integral values to strings

by

Question 1. Why is the string stream method consistently the worst?

The classical mistake: creating a new stringstream every single time

template<typename T> // 1. Using stringstream
string StringFromIntegral_SS(T const &value) {
    thread_local stringstream ss;
    ss.str("");
    ss.clear();
    ss << value;
    return ss.str();
}

Question 2. Why is lexical cast consistently the best? Can we assume that this is the fastest implementation ?

Because it’s most specialized; and, no, faster implementations exist. FastFormat and Boost Spirit have competitive offerings, as far as I know.

Update Boost Spirit Karma still easily beats the bunch:

template<typename T> // 4. Karma to string
std::string StringFromIntegral_K(T const &value) {
    thread_local auto const gen = boost::spirit::traits::create_generator<T>::call();
    thread_local char buf[20];
    char* it = buf;
    boost::spirit::karma::generate(it, gen, value);
    return std::string(buf, it);
}

Timings:

C++ 11 method 111
String stream method 103
Lexical cast method 57
Spirit Karma method 36
Spirit Karma method with string_ref 13

See it Live On Coliru Clang or GCC

BONUS

Just to goof off, a version using boost::string_ref is much faster still due the reduced allocations:

template<typename T> // 5. Karma to string_ref
boost::string_ref StringFromIntegral_KSR(T const &value) {
    thread_local auto const gen = boost::spirit::traits::create_generator<T>::call();
    thread_local char buf[20];
    char* it = buf;
    boost::spirit::karma::generate(it, gen, value);
    return boost::string_ref(buf, it-buf);
}

I’ve tested all modified methods for correctness using an asserting test loop:

return measure<>::execution(
    //[&]() { for (auto const &i : v1) { func(i); }});
    [&]() { for (auto const &i : v1) { assert(func(i) == StringFromIntegral_LC(i)); }});

More Related Contents:

  1. Why do I get the same sequence for every run with std::random_device with mingw gcc4.8.1?
  2. How do I combine hash values in C++0x?
  3. Why is template argument deduction disabled with std::forward?
  4. What does the standard library guarantee about self move assignment?
  5. Why use non-member begin and end functions in C++11?
  6. when g++ static link pthread, cause Segmentation fault, why?
  7. Should we pass a shared_ptr by reference or by value?
  8. How to declare a vector of atomic in C++
  9. Which Boost features overlap with C++11?
  10. How to filter items from a std::map? [duplicate]
  11. std::optional specialization for reference types
  12. Doing a static_assert that a template type is another template
  13. What is the default hash function used in C++ std::unordered_map?
  14. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  15. C++11 STL containers and thread safety
  16. How do I erase elements from STL containers?
  17. C++11 equivalent to boost shared_mutex
  18. What happens when you call data() on a std::vector?
  19. Hash an arbitrary precision value (boost::multiprecision::cpp_int)
  20. Difference between C++11 std::bind and boost::bind
  21. Why can’t I replace std::map with std::unordered_map
  22. When must you pass io_context to boost::asio::spawn? (C++)
  23. Are lambdas inlined like functions in C++?
  24. Why isn’t std::array::size static?
  25. error for hash function of pair of ints
  26. stl container with std::unique_ptr’s vs boost::ptr_container
  27. STL algorithms: Why no additional interface for containers (additional to iterator pairs)?
  28. const auto std::initializer_list difference between Clang and GCC
  29. C++ priority_queue with lambda comparator error
  30. Using Boost adaptors with C++11 lambdas

Leave a Comment