Boost C++ Libraries of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.


Converters Compared
Boost.Convert Overhead
The Bigger Picture

The performance of Boost.Convert depends entirely on the performance of the converter deployed. A few converters have been tested for string conversions to basic types and to a user-defined type.

In turn, the relative and absolute performance of every particular converter depends on the platform, the compiler used and the particular implementation of the underlying conversion component (std::stream, printf, Boost.Spirit, etc.). Consequently, the results below are only an approximate indication of relative performance of the mentioned converters on the tested platforms.

Compiled with gcc-4.8.2 on 32-bit Ubuntu 14.04 tests produced the following relative results:

str-to-int: spirit/strtol/lcast/scanf/stream=   1.31/   2.15/   3.41/   6.72/   7.24 seconds.
str-to-lng: spirit/strtol/lcast/scanf/stream=   1.24/   2.39/   4.18/   6.63/   7.20 seconds.
str-to-dbl: spirit/strtol/lcast/scanf/stream=   1.45/   4.07/   5.19/  11.13/  14.47 seconds.
int-to-str: spirit/strtol/lcast/prntf/stream=   7.49/   6.48/   8.01/  11.76/   9.31 seconds.
lng-to-str: spirit/strtol/lcast/prntf/stream=   7.34/   6.89/   8.43/  11.55/   9.32 seconds.
dbl-to-str: spirit/strtol/lcast/prntf/stream=  14.13/  13.56/  50.03/  46.25/  44.72 seconds.

Compiled with gcc-4.6.3 on 64-bit Ubuntu 12.04 tests produced the following relative results:

str-to-int: spirit/strtol/lcast/scanf/stream=   0.29/   0.47/   1.14/   2.75/   3.15 seconds.
str-to-dbl: spirit/strtol/lcast/scanf/stream=   0.40/   1.44/   1.70/   4.32/   5.59 seconds.
int-to-str: spirit/strtol/lcast/prntf/stream=   1.75/   1.53/   2.06/   3.34/   2.73 seconds.
dbl-to-str: spirit/strtol/lcast/prntf/stream=   5.64/   3.00/  17.89/  14.24/  13.67 seconds.

Based on the results, all things considered, I tend to conclude that there is no clear winner:

  • the Spirit.Qi-based converter was the fastest for string to basic (int, double) conversions. So, it might be a good candidate for the tasks predominantly doing that kind of conversions (with Spirit.Qi conversion-related limitations in mind); Spirit.Karma's to-string performance did not seem as impressive;
  • the std::iostream-based converter was comparatively slow. Still, given its maturity, availability and formatting support, it might be an option to consider if conversion performance is not your primary concern;
  • the strtol-inspired converter was reasonably fast and with formatting support might be an attractive all-rounder. It should be noted that it is nowhere as mature as boost::cnv::lexical_cast and boost::cnv::stream. So, bugs are to be expected.

For user-defined types cnv::lexical_cast, cnv::cstream and cnv::strtol were tested with the following relative results:

str-to-user-type: lcast/stream/strtol=1.14/0.59/0.23 seconds.
user-type-to-str: lcast/stream/strtol=1.97/0.39/0.24 seconds.

To provide string-to-user-type and user-type-to-string conversions the first two deploy the same standard std::iostream library. However, boost::cnv::cstream considerably outperforms boost::lexical_cast in these tests. The results probably reflect different underlying designs. Namely, the standard Boost.Convert deployment pattern is to create a converter or converters once and then re-use them. boost::lexical_cast, on the other hand, due to its design, creates and then destroys a std::stream instance every time the function is called and the boost::lexical_cast performance table indicates that the "std::stringstream with construction" operation is considerably more expensive compared to "std::stringstream without construction".

boost::cnv::strtol support for user types has been implemented similarly but without the std::stream-related overhead. That resulted in the best out-of-three performance results.

Based on the performance data, I tend to conclude that, given type-safety and benefits provided by the Boost.Convert framework, it (with appropriate converters) should probably be the first choice for conversion-related tasks.