| Home | Libraries | People | FAQ | More

## Changes

- boost 1.91.0 :
  - Added C++20 modules support.
- 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 :
  - Dropped support of C++98 and C++03.
- boost 1.56.0 :
  - Added `boost::conversion::try_lexical_convert` functions.
- 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 :
  - Much better input and output streams detection for user defined types.
- 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.