- 
          boost 1.56.0 :
          - 
                Added boost::conversion::try_lexical_convertfunctions.
 
- 
          boost 1.54.0 :
          - 
                Fix some issues with boost::int128_typeandboost::uint128_typeconversions. Notify
                user at compile time if thestd::numeric_limitsare not specialized for 128bit types andboost::lexical_castcan not make conversions.
 
- 
          boost 1.54.0 :
          
- 
                Added code to convert boost::int128_typeandboost::uint128_typetypes (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_castfunction (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>andstd::array<character_type, N>conversions.
 
- 
          boost 1.50.0 :
          
- 
                boost::bad_lexical_castexception 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_stringconversions.
 
- 
          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 :
          
        
- 
          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_castnow supports conversions fromwchar_t,wchar_t *,
                andstd::wstringand towchar_tandstd::wstring.
- 
                The previous version of lexical_castassumed 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 forstd::stringand, where supported,std::wstring:lexical_cast<std::string>("Hello, World")succeeds instead of failing with abad_lexical_castexception.
- 
                The previous version of lexical_castallowed unsafe and meaningless conversions to pointers. The current
                version now throws abad_lexical_castfor conversions to pointers:lexical_cast<char
                *>("Goodbye,
                World")now
                throws an exception instead of causing undefined behavior.