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 performance of every particular converter depends on the platform,
the compiler used and the particular implementation of the underlying conversion
components (small-string optimization, 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.
When compiled with gcc-11.2.0 on 64-bit Ubuntu 22.04, tests produced the following results:
str-to-int: spirit/strtol/lcast/scanf/stream/charconv= 0.15/0.13/1.99/0.86/0.67/0.16 seconds. str-to-lng: spirit/strtol/lcast/scanf/stream/charconv= 0.12/0.15/2.04/0.88/0.66/0.12 seconds. str-to-dbl: spirit/strtol/lcast/scanf/stream/charconv= 0.15/0.53/5.12/1.06/1.68/0.19 seconds. int-to-str: spirit/strtol/lcast/prntf/stream/charconv= 0.39/0.29/0.43/1.09/0.68/0.29 seconds. lng-to-str: spirit/strtol/lcast/prntf/stream/charconv= 0.39/0.29/0.45/1.11/0.68/0.31 seconds. dbl-to-str: spirit/strtol/lcast/prntf/stream/charconv= 1.12/1.17/7.34/5.05/4.65/1.07 seconds.
Based on the above, all things considered, I tend to conclude that:
strtol-inspired
and charconv-based converters
were the fastest for string to basic (int,
double) conversions. So,
they might be good candidates for the tasks doing that kind of conversions
(with Spirit.Qi conversion-related limitations in
mind);
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;
boost::lexical_cast-based converter was consistently
and noticeably the slowest (due to its underlying design);
charconv-based and
the strtol-inspired converters
were overall the fastest and with formatting support might be attractive
all-rounders.
For user-defined types converters were tested with the following results:
str-to-user-type: lcast/stream/strtol/charconv=0.13/0.05/0.01/0.02 seconds. user-type-to-str: lcast/stream/strtol/charconv=0.11/0.03/0.01/0.01 seconds.
To provide string-to-user-type and user-type-to-string
conversions the first two deploy the same standard std::iostream
library. Still, boost::cnv::cstream
considerably outperforms boost::lexical_cast
in these tests. That reflects 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, 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
and boost::cnv::charconv
support for user types has been implemented similarly but without the std::stream-related
overhead. That resulted in considerably better 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.