| Home | Libraries | People | FAQ | More

## Change Log

### Boost 1.33.0

- Initial Release

### Boost 1.33.1

- Fixed the points example, as pointed out by 沈慧峰.

### Boost 1.34.0

- Use declarations for standard classes, so that the library doesn't need to include all of their headers
- Deprecated the `<boost/functional/hash/*.hpp>` headers. Now a single header, <`boost/functional/hash.hpp`> is used.
- Add support for the `BOOST_HASH_NO_EXTENSIONS` macro, which disables the extensions to TR1.
- Minor improvements to the hash functions for floating point numbers.
- Update the portable example to hopefully be more generally portable.

### Boost 1.34.1

- Ticket 952: Suppress incorrect 64-bit warning on Visual C++.

### Boost 1.35.0

- Support for `long long`, `std::complex`.
- Improved algorithm for hashing floating point numbers:
  - Improved portablity, as described by Daniel Krügler in a post to the boost users list.
  - Fits more information into each combine loop, which can reduce the the number of times combine is called and hopefully give a better quality hash function.
  - Improved the algorithm for hashing floating point numbers.
  - On Cygwin use a binary hash function for floating point numbers, as Cygwin doesn't have decent floating point functions for `long double`.
  - Never uses `fpclass` which doesn't support `long double`.
  - Ticket 1064: Removed unnecessary use of `errno`.
- Explicitly overload for more built in types.
- Minor improvements to the documentation.
- A few bug and warning fixes:
  - Ticket 1509: Suppress another Visual C++ warning.
  - Some workarounds for the Sun compilers.

### Boost 1.36.0

- Stop using OpenBSD's dodgy `std::numeric_limits`.
- Using the boost typedefs for `long long` and `unsigned long long`.
- Move the extensions into their own header.

### Boost 1.37.0

- Ticket 2264: In Visual C++, always use C99 float functions for `long double` and `float` as the C++ overloads aren't always availables.

### Boost 1.38.0

- Changed the warnings in the deprecated headers from 1.34.0 to errors. These will be removed in a future version of Boost.
- Moved detail headers out of `boost/container_hash/detail`, since they are part of functional/hash, not container_hash. `boost/container_hash/detail/container_fwd.hpp` has been moved to `boost/detail/container_fwd.hpp` as it's used outside of this library, the others have been moved to `boost/functional/hash/detail`.

### Boost 1.39.0

- Move the hash_fwd.hpp implementation into the hash subdirectory, leaving a forwarding header in the old location. You should still use the old location, the new location is mainly for implementation and possible modularization.
- Ticket 2412: Removed deprecated headers.
- Ticket 2957: Fix configuration for vxworks.

### Boost 1.40.0

- Automatically configure the float functions using template metaprogramming instead of trying to configure every possibility manually.
- Workaround for when STLport doesn't support long double.

### Boost 1.42.0

- Reduce the number of warnings for Visual C++ warning level 4.
- Some code formatting changes to fit lines into 80 characters.
- Rename an internal namespace.

### Boost 1.43.0

- Ticket 3866: Don't foward declare containers when using gcc's parallel library, allow user to stop forward declaration by defining the `BOOST_DETAIL_NO_CONTAINER_FWD` macro.
- Ticket 4038: Avoid hashing 0.5 and 0 to the same number.
- Stop using deprecated `BOOST_HAS_*` macros.

### Boost 1.44.0

- Add option to prevent implicit conversions when calling `hash_value` by defining `BOOST_HASH_NO_IMPLICIT_CASTS`. When using `boost::hash` for a type that does not have `hash_value` declared but does have an implicit conversion to a type that does, it would use that implicit conversion to hash it. Which can sometimes go very wrong, e.g. using a conversion to bool and only hashing to 2 possible values. Since fixing this is a breaking change and was only approached quite late in the release cycle with little discussion it's opt-in for now. This, or something like it, will become the default in a future version.

### Boost 1.46.0

- Avoid warning due with gcc's `-Wconversion` flag.

### Boost 1.50.0

- Ticket 6771: Avoid gcc's `-Wfloat-equal` warning.
- Ticket 6806: Support `std::array` and `std::tuple` when available.
- Add deprecation warning to the long deprecated `boost/container_hash/detail/container_fwd.hpp`.

### Boost 1.51.0

- Support the standard smart pointers.
- `hash_value` now implemented using SFINAE to avoid implicit casts to built in types when calling it.
- Updated to use the new config macros.

### Boost 1.52.0

- Restore `enum` support, which was accidentally removed in the last version.
- New floating point hasher - will hash the binary representation on more platforms, which should be faster.

### Boost 1.53.0

- Add support for `boost::int128_type` and `boost::uint128_type` where available - currently only `__int128` and `unsigned __int128` on some versions of gcc.
- On platforms that are known to have the standard floating point functions, don't use automatic detection - which can break if there are ambiguous overloads.
- Fix undefined behaviour when using the binary float hash (Thomas Heller).

### Boost 1.54.0

- Ticket 7957: Fixed a typo.

### Boost 1.55.0

- Simplify a SFINAE check so that it will hopefully work on Sun 5.9 (#8822).
- Suppress Visual C++ infinite loop warning (#8568).

### Boost 1.56.0

- Removed some Visual C++ 6 workarounds.
- Ongoing work on improving `hash_combine`. This changes the combine function which was previously defined in the reference documentation.

### Boost 1.58.0

- Fixed strict aliasing violation (GitHub #3).

### Boost 1.63.0

- Fixed some warnings.
- Only define hash for `std::wstring` when we know we have a `wchar_t`. Otherwise there's a compile error as there's no overload for hashing the characters in wide strings (#8552).

### Boost 1.64.0

- Fix for recent versions of Visual C++ which have removed `std::unary_function` and `std::binary_function` (#12353).

### Boost 1.65.0

- Support for `char16_t`, `char32_t`, `u16string`, `u32string`

### Boost 1.66.0

- Avoid float comparison warning when using Clang - this workaround was already in place for GCC, and was used when Clang pretends to be GCC, but the warning was appearing when running Clang in other contexts.

### Boost 1.67.0

- Moved library into its own module, `container_hash`.
- Moved headers for new module name, now at: `<boost/container_hash/hash.hpp>`, `<boost/container_hash/hash_fwd.hpp>`, `<boost/container_hash/extensions.hpp>`.
- Added forwarding headers to support the old headers locations.
- Support `std::string_view`, `std::error_code`, `std::error_condition` `std::optional`, `std::variant`, `std::monostate` where available.
- Update include paths from other Boost libraries.
- Manually write out tuple overloads, rather than using the preprocessor to generate them. Should improve usability, due to better error messages, and easier debugging.
- Fix tutorial example (#11017).
- Quick fix for hashing `vector<bool>` when using libc++. Will try to introduce a more general fix in the next release.