Changes

boost 1.86.0 :

Fixed conversion of std::basic_string_view and boost::basic_string_view containing one or more \0 characters. Issue was introduced in 1.85.0.

boost 1.85.0 :

Significant rewrite of the internal logic to separate optimized and C++ Standard Library IO-based streams:
- C++ Standard Library based streams now constructed in less cases leading to better performance;
- less template instantiations and simpler code;
- always use std::char_traits (do not use custom traits from input/output types as it leads to linktime or runtime errors);
- support for volatile input types was dropped, following the C++ Standard Library trend.
Optimized conversions from std::basic_string_view and boost::basic_string_view
Dropped dependency on Boost.NumericConversion and Boost.MPL. Fixed some cases of converting floting point types to arithmetics.
The library now works fine with -fno-sanitize-recover=integer.

boost 1.84.0 :

boost 1.56.0 :

boost 1.54.0 :

Fix some issues with boost::int128_type and boost::uint128_type conversions. Notify user at compile time if the std::numeric_limits are not specialized for 128bit types and boost::lexical_cast can not make conversions.

boost 1.54.0 :

Added code to convert boost::int128_type and boost::uint128_type types (requires GCC 4.7 or higher).
Conversions to pointers will now fail to compile, instead of throwing at runtime.
Restored ability to get pointers to lexical_cast function (was broken in 1.53.0).

boost 1.53.0 :

boost 1.52.0 :

Restored compilation on MSVC-2003 (was broken in 1.51.0).
Added lexical_cast(const CharType* chars, std::size_t count) function overload.

boost 1.51.0 :

Better performance, less memory usage for boost::array<character_type, N> and std::array<character_type, N> conversions.

boost 1.50.0 :

boost::bad_lexical_cast exception is now globaly visible and can be catched even if code is compiled with -fvisibility=hidden.
Now it is possible to compile library with disabled exceptions.
Better performance, less memory usage and bugfixes for boost::iterator_range<character_type*> conversions.

boost 1.49.0 :

Restored work with typedefed wchar_t (compilation flag /Zc:wchar_t- for Visual Studio).
Better performance and less memory usage for boost::container::basic_string conversions.

boost 1.48.0 :

Added code to work with Inf and NaN on any platform.
Better performance and less memory usage for conversions to float type (and to double type, if sizeof(double) < sizeof(long double)).

boost 1.47.0 :

Optimizations for "C" and other locales without number grouping.
Better performance and less memory usage for unsigned char and signed char conversions.
Better performance and less memory usage for conversions to arithmetic types.
Better performance and less memory usage for conversions from arithmetic type to arithmetic type.
Directly construct Target from Source on some conversions (like conversions from string to string, from char array to string, from char to char and others).

boost 1.34.0 :

Better performance for many combinations of Source and Target types. For more details refer to Alexander Nasonovs article Fine Tuning for lexical_cast, Overload #74, August 2006 (PDF).

boost 1.33.0 :

Call-by-const reference for the parameters. This requires partial specialization of class templates, so it doesn't work for MSVC 6, and it uses the original pass by value there.
The MSVC 6 support is deprecated, and will be removed in a future Boost version.

Earlier :

The previous version of lexical_cast used the default stream precision for reading and writing floating-point numbers. For numerics that have a corresponding specialization of std::numeric_limits, the current version now chooses a precision to match.
The previous version of lexical_cast did not support conversion to or from any wide-character-based types. For compilers with full language and library support for wide characters, lexical_cast now supports conversions from wchar_t, wchar_t *, and std::wstring and to wchar_t and std::wstring.
The previous version of lexical_cast assumed that the conventional stream extractor operators were sufficient for reading values. However, string I/O is asymmetric, with the result that spaces play the role of I/O separators rather than string content. The current version fixes this error for std::string and, where supported, std::wstring: lexical_cast<std::string>("Hello, World") succeeds instead of failing with a bad_lexical_cast exception.
The previous version of lexical_cast allowed unsafe and meaningless conversions to pointers. The current version now throws a bad_lexical_cast for conversions to pointers: lexical_cast<char *>("Goodbye, World") now throws an exception instead of causing undefined behavior.