Skip to content

VS 2019 Changelog

Jump to bottom
Stephan T. Lavavej edited this page May 11, 2022 · 22 revisions

Table of Contents

For newer releases, see the current Changelog.

C++20 features generally require the /std:c++latest compiler option.

VS 2019 16.11.14

  • Backported all C++20 Defect Reports from the VS 2022 release series where they were originally implemented, and enabled all remaining C++20 features under /std:c++20. For more info, read MSVC's STL Completes /std:c++20.

VS 2019 16.11

  • Implemented our plan for a partial C++20 ABI freeze (see #1814). Effectively this means that <format>, the formatting parts of <chrono> (which rely on <format>), and the range factories and range adaptors from <ranges> (basically everything that needs the view concept) will be available only under /std:c++latest. We will make those final C++20 features available under /std:c++20 only after reaching agreement with WG21 that no further ABI-breaking changes will be necessary. #1929
  • Fixed bugs:
    • Fixed a major regression in the _ITERATOR_DEBUG_LEVEL == 2 machinery, where a multithreaded program in debug mode could crash when one thread is modifying a container and another thread is destroying iterators. #2060
      • This regression affected all Standard modes (C++14/17/20/23) and was introduced by #1546 in VS 2019 16.10.
      • Fixed in both VS 2019 16.11.4 and VS 2022 17.0.

VS 2019 16.10

  • The STL is C++20 feature complete.
  • Merged C++20 features:
    • P0053R7 #1564 <syncstream>
    • P0355R7 <chrono> Calendars And Time Zones:
      • #323 implemented calendars.
      • #1789 implemented new clocks, leap seconds, time zones, and parsing.
      • #1870 implemented <chrono>'s format() support (via formatter specializations) and remaining operator<<() overloads, completing this feature.
      • While the STL generally provides all features on all supported versions of Windows, leap seconds and time zones (which change over time) require OS support that was added to Windows 10. Specifically, updating the leap second database requires Windows 10 version 1809 or later, and time zones require icu.dll which is provided by Windows 10 version 1903/19H1 or later. This applies to both client and server OSes; note that Windows Server 2019 is based on Windows 10 version 1809.
    • P0408R7 #919 Efficient Access To basic_stringbuf's Buffer
    • P0466R5 #1575 Layout-Compatibility And Pointer-Interconvertibility Traits
      • Initially supported for MSVC only; will be supported for Clang after LLVM-48860 is resolved.
    • P0475R1 #1668 Guaranteed Copy Elision For Piecewise Construction
    • P0591R4 #1668 Utility Functions For Uses-Allocator Construction
      • LWG-3185 Uses-allocator construction functions missing constexpr and noexcept
      • LWG-3187 P0591R4 reverted LWG-2586 fixes to scoped_allocator_adaptor::construct()
      • LWG-3321 uninitialized_construct_using_allocator should use construct_at
    • P0608R3 #1629 Improving variant's Converting Constructor/Assignment
    • P0645R10 #1821 #1834 #1803 #1853 #1862 #1867 #1851 #1875 <format> Text Formatting
    • P0784R7 #1369 #1546 Library Support For More constexpr Containers
    • P0896R4 Ranges, completed with the final PRs:
      • #1383 algorithms inplace_merge, stable_partition, stable_sort
      • #1693 view ranges::iota_view
      • #1436 view ranges::join_view
      • #1731 view ranges::split_view
      • #1748 Define __cpp_lib_ranges and declare victory!
      • Completes support for the 23 proposals and 35 LWG issues listed in this GH issue comment.
    • P0980R1 #1502 constexpr std::string
      • Initially supported for MSVC only; will be supported for Clang after LLVM-48606 is resolved.
    • P1004R2 #1407 #1690 #1698 constexpr std::vector
      • Initially supported for MSVC only; see note for constexpr std::string.
    • P1208R6 #664 <source_location>
      • Initially supported for MSVC only; will be supported for Clang after it implements consteval (see Clang's C++20 status).
    • P1502R1 #1567 #1692 Standard Library Header Units
      • Initially supported for MSVC only; will be supported for Clang after it implements C++20 modules (see Clang's C++20 status).
    • P1614R2 #1602 #1678 Adding Spaceship <=> To The Library
  • Merged LWG issue resolutions:
    • LWG-3171 #1573 LWG-2989 breaks directory_entry stream insertion
    • LWG-3449 #1457 take_view and take_while_view's sentinel<false> not comparable with their const iterator
    • LWG-3466 #1572 Specify the requirements for promise/future/shared_future consistently
  • Fixed bugs:
    • Fixed regex character class behavior with regex::icase. #1503
    • Fixed compiler errors when calling std::equal() with user-defined contiguous iterators. #1527
    • Fixed boolalpha extraction to be case-sensitive again. #1543 #1570 (This was a regression in VS 2019 16.8 caused by #1168.)
    • Fixed a compiler error when calling std::fill() with volatile byte*. #1557
    • Fixed ranges::unique to correctly handle inputs that are already unique. #1561
    • Fixed compiler errors, specific to Clang targeting ARM64, in <atomic> and <bit>, related to compiler intrinsics. #1505
    • Fixed C++20 mode to remove old std::allocator members that were deprecated in C++17. (As usual, fine-grained and coarse-grained escape hatches are available for this removal.) #1585
    • Fixed an inaccurate approximation in binomial_distribution. #1531
    • Fixed incorrect min/max values for several <random> distributions. #1601
    • Fixed incorrect behavior in gamma_distribution::param_type::operator==. #1601
    • Fixed a regression in VS 2019 16.6 caused by #423, where __declspec(dllexport)ing a class derived from unordered_map or unordered_set would fail to compile with a static_assert. #1639
    • Fixed compiler errors in ranges::uninitialized_copy, ranges::uninitialized_copy_n, ranges::uninitialized_move, and ranges::uninitialized_move_n when attempting to use memcpy for efficiency. #1548
    • Fixed incorrect behavior in ranges::uninitialized_value_construct and ranges::uninitialized_value_construct_n when attempting to use memset for efficiency. #1700
    • Fixed year_month_day_last::day() to return a valid-but-unspecified value for !ok() dates, as required by the Standard. #1663
    • Fixed a regression in VS 2019 16.7 caused by #309, where <memory> would fail to compile with /std:c++latest /Zc:alignedNew-. #1689
    • Fixed incorrect behavior in get_time(). #1620
      • Format specifications without delimiters are now correctly handled, even when a field is all-zero. For example, "19700405T000006" can now be parsed with "%Y%m%dT%H%M%S".
      • Literal matching (outside of '%' conversion specifications) is now case-insensitive.
      • If the stream ends during literal matching, ios_base::eofbit | ios_base::failbit is now set.
      • Incomplete conversion specifications (e.g. '%' appearing as the last character of a format specification) now result in ios_base::failbit instead of literal matching.
      • The seconds field now permits 60 to handle leap seconds.
    • Fixed compiler errors in ranges::uninitialized_copy and ranges::uninitialized_move when attempting to use memcpy for efficiency. #1713
    • Fixed compiler errors where the ranges::uninitialized_meow() algorithms assumed that <algorithm> was included; now they can be called after including only <memory>. #1832
    • Fixed an off-by-default truncation warning in <complex> (warning C5219: implicit conversion from 'const int' to 'const float', possible loss of data). #1722
    • Fixed compiler errors in make_shared and allocate_shared with noexcept(false) destructors. #1736
    • Fixed compiler errors in an advanced scenario for Standard Library Header Units: using the IDE's build system to perform "dependency scanning" in addition to automatic translation of #include to import. #1781
    • Fixed a regression in VS 2019 16.9 caused by #1336, where <cmath>'s usage of new compiler intrinsics in ceil, copysign, floor, round, and trunc would fail to compile with CUDA and the Intel C++ Compiler. #1886
      • Also backported to VS 2019 16.9.7.
      • Will appear in VS 2019 16.11 Preview 2 (but not 16.11 Preview 1).
      • Note: The Intel C++ Compiler remains unsupported by MSVC.
  • Improved performance:
    • countr_zero() and countr_one() in <bit> are now faster for uint8_t and uint16_t. #1540
    • atomic locks on x86/x64 now use the _mm_pause intrinsic with increasing back-off. #1146
    • Slightly optimized <charconv>'s integer to_chars() for the bases 3, 5, 6, 7, and 9. #1622
    • Significantly optimized <chrono>'s conversions between year_month_day and sys_days. #1634 #1646
    • Extended std algorithm optimizations to std::ranges algorithms and generalized those optimizations from pointers to contiguous iterators. #1433 #1772
  • Enhanced behavior:
    • Added header-units.json, a file that will tell the compiler which headers are eligible to be automatically treated as header units at the user's request. (That is, there will be a compiler option allowing #include <vector> to be treated as import <vector>; without changing the source code.) #1545
    • Added [[nodiscard]] to several member functions in <hash_map> and <hash_set>, even though these non-Standard headers are deprecated and will be removed soon. #1574
    • Added static_assert(is_clock_v<Clock>); as required by N4878 [thread.req.paramname]/1. #1687
    • <coroutine> is now supported in C++14 mode and C++17 mode; the new /await:strict compiler option activates this "downlevel" support. #1730
      • <coroutine> remains supported in C++20 mode with no additional compiler options.
    • Added the STL's visualizers to this repo, see stl/debugger/STL.natvis. #1720
      • Significantly improved the visualizer for coroutine_handle. #1785
      • Added a visualizer for span. #1774
      • Added visualizers for new <chrono> types. #1773
      • Added visualizers for strong_ordering, weak_ordering, and partial_ordering. #1855
    • Generalized <complex>'s 80-bit long double detection logic to work with Clang in addition to the Intel C++ Compiler. #1728
      • Note: 80-bit long double remains unsupported by MSVC.
  • Improved test coverage:
    • Added test coverage for CUDA 10.1 Update 2. #1519 #1539
    • Accelerated the test for P1502R1 Standard Library Header Units by building the header units in parallel, using /MP. #1529
    • The test harness now builds all tests for ARM and ARM64. #1505
      • This is build-only; the goal of running tests on ARM and ARM64 is tracked by #820.
      • Clang is supported for ARM64 only, not ARM.
    • Updated the libcxx test suite. #1594
    • Added more test coverage for the default_initializable concept. #1604
  • Code cleanups:
    • Removed compiler bug workarounds. #1521 #1711 #1841
    • Improved formatting with clang-format 11. #1521
    • CUDA 10.1 Update 2 is now required, allowing the STL to unconditionally use if constexpr for compiler throughput and code clarity. #1544
    • Updated <charconv>'s product/test code to be more compatible with libc++. #1670
    • Rearranged [[nodiscard]] attributes to appear before __declspec specifications for functions (otherwise, [[nodiscard]] is ignored). #1703
    • Updated the Standard Library Header Units test now that the compiler supports attributes in modules. #1747
    • Suppressed a harmless warning in test code after MSVC implemented constinit. #1611
    • Renamed a few internal identifiers to be _Ugly, following the Standard's strict requirements. #1743
    • The STL now consistently uses SFINAE instead of concepts when __cpp_lib_concepts isn't defined. #1749
    • Removed comments that were citing proposed resolutions for LWG issues, now that those issues have been officially resolved by the February 2021 virtual plenary meeting. #1686
    • Fixed mysterious LWG issue citations in <optional>. #1788
  • Infrastructure improvements:
    • Updated dependencies. #1521 #1577 #1636 #1711
      • Updated build compiler to VS 2019 16.10 Preview 1 (now required).
      • Updated Clang to 11.0.0 (now required).
      • Updated vcpkg for Boost 1.75.0 (now required).
      • Updated CMake to 3.19 (now required).
      • Updated Ninja to 1.10.2.
      • Updated Python to 3.9.2.
    • Accelerated the CI with partial clones, shallow clones, and sparse checkouts. #1513 #1605
    • Fixed reliability issues in the parallelize tool, which is used to run clang-format on all files in the codebase. #1632
    • Skipped a flaky test in the legacy tr1 test suite. #1697
    • We now use GitHub Actions to update the Status Chart every day. #1769
    • The test harness now runs the Standard Library Header Units test in a "parallelism group", which should make the CI system more reliable. #1776
  • Updated _MSVC_STL_UPDATE. #1535 #1552 #1626 #1708 #1801

VS 2019 16.9

  • Merged C++20 features:
    • P0339R6 #1311 polymorphic_allocator<>
    • P0660R10 #1196 <stop_token> And jthread
    • P0768R1 #1370 Library Support For The Spaceship Comparison Operator <=>
      • This feature was mostly implemented in VS 2019 16.0; it's now complete with the addition of the spaceship customization point objects strong_order, weak_order, partial_order, compare_strong_order_fallback, compare_weak_order_fallback, and compare_partial_order_fallback.
    • P1007R3 #1306 assume_aligned()
    • P1020R1 #1315 Smart Pointer Creation With Default Initialization
    • P1771R1 #1495 #1514 [[nodiscard]] For Constructors
  • Merged partial C++20 features:
    • P0355R7 <chrono> Calendars And Time Zones:
      • #1341 operator<<(basic_ostream&, const duration&)
    • P0896R4 Ranges:
      • #1092 #1265 #1268 common_iterator
      • #1271 views::take and views::drop now handle basic_string_view as specified in P1739R4.
      • #1313 ranges::construct_at and ranges::destroy_at
      • #1164 algorithms ranges::uninitialized_default_construct, ranges::uninitialized_default_construct_n, ranges::uninitialized_value_construct, ranges::uninitialized_value_construct_n, ranges::uninitialized_fill, ranges::uninitialized_fill_n, ranges::uninitialized_copy, ranges::uninitialized_copy_n, ranges::uninitialized_move_n
      • #1281 Changes to the stream iterators (istream_iterator, ostream_iterator, istreambuf_iterator, and ostreambuf_iterator) to model the C++20 iterator concepts
      • #1366 view ranges::drop_while_view
      • #1406 view ranges::elements_view
      • #1334 view ranges::istream_view
      • #1372 view ranges::take_while_view
      • #1305 views::common
      • #1375 views::counted
    • P1502R1 Standard Library Header Units:
      • #1388 #1396 Added test coverage. This found blocking compiler bugs that are being fixed; see #1694 for their current status.
  • Merged LWG issue resolutions:
    • LWG-3036 #1455 polymorphic_allocator::destroy is extraneous
    • LWG-3117 #1493 Missing packaged_task deduction guides
    • LWG-3170 #1501 is_always_equal added to std::allocator makes the standard library treat derived types as always equal
    • LWG-3211 #1460 std::tuple<> should be trivially constructible
    • LWG-3448 #1458 transform_view's sentinel<false> not comparable with iterator<true>
    • LWG-3460 #1452 Unimplementable noop_coroutine_handle guarantees
    • LWG-3464 #1483 istream::gcount() can overflow
  • Fixed bugs:
    • Fixed the invocable_r family of type traits to handle C++17 deferred temporary materialization. #1282
    • Fixed a compiler error in atomic_ref<[u]int8_t>::operator--(int). #1303
    • Removed non-Standard implicitly converting constructors from complex. #1294
    • Enabled constexpr destruction of memory_resource. #1314
    • std::filesystem::create_directories() now throws an exception (or fails with an error_code) when called with an empty path. #1285
    • Fixed compiler errors (with clang-tidy and IntelliSense-in-Clang-mode) caused by intrin0.h including intrin.h, which no longer happens. #1300
    • Fixed undefined behavior and incorrect results in geometric_distribution, poisson_distribution, binomial_distribution, and gamma_distribution. #1159
    • Fixed incorrect results (infinity and NaN) in normal_distribution, lognormal_distribution, fisher_f_distribution, and student_t_distribution. #1228
    • Fixed bind_front() to determine its return type from the decayed types of its arguments. #1293
    • Fixed pow(complex, arithmetic) to strictly follow the Standard's rules and return correct results. #1299
    • Fixed _Node_handle - the internal class template that reifies the Standard's node-handle family of exposition-only types - to destroy contained values with an allocator rebound to the value type instead of to the type of the node. #1310
    • Fixed overflow when converting extreme relative times (like duration::max()) to absolute times in condition_variable_any::wait_for(), condition_variable::wait_for(), recursive_timed_mutex::try_lock_for(), shared_timed_mutex::try_lock_for(), shared_timed_mutex::try_lock_shared_for(), this_thread::sleep_for(), and timed_mutex::try_lock_for(). #1371
    • Fixed a compiler error when compiling <experimental/generator> in /kernel mode. #1373
    • Fixed std::atomic_init; C++20 deprecated it (which we previously implemented) and changed its effects to be equivalent to a relaxed store (which we previously missed). #1090
    • Fixed get_time() to correctly handle format specifications without delimiters; for example, "20201029" can now be parsed with "%Y%m%d". #1280
      • This fix was incomplete; it was completed by #1620 in VS 2019 16.10.
    • Fixed the ordered associative containers (map, multimap, set, multiset) so that their move constructors and move assignment operators don't attempt to swap their comparators (which could fail to compile, especially for lambdas which aren't assignable). #1357
    • Fixed a crash when a user-defined class, deriving from streambuf, threw an exception from its constructor. #1358
    • Fixed two lines in ranges machinery that mistakenly said noexcept(noexcept(is_nothrow_v)) (which is always noexcept(true)). Now they say noexcept(is_nothrow_v) as intended. #1417
    • Marked hash<coroutine_handle<>>::operator() as const, required by the Standard. #1423
    • Fixed several issues in complex sqrt() and log(): #935
      • Fixed sqrt() overflow for huge inputs.
      • Fixed sqrt() inaccuracy for tiny inputs, due to internal underflow.
      • Fixed log() inaccuracy for tiny inputs, due to internal underflow.
      • Improved accuracy of log() when |z| ~= 1.
      • Fixed log(complex<float>{1, 0}) for certain combinations of compile-time and run-time settings; now it correctly returns 0.
      • These correctness fixes have a moderate performance cost, partially mitigated by using hardware FMA when available on x86/x64/arm64.
    • Fixed an AddressSanitizer new-delete-type-mismatch issue in valarray. #1496
    • Fixed linker errors on ARM and ARM64 when using atomic waits. #1507
    • Fixed the exception specification for basic_string_view's (iterator, sentinel) constructor. #1510
    • Fixed regex_traits::transform() to accept arbitrary forward iterators instead of requiring raw pointers. #1494
    • Fixed a static_assert that was preventing atomic_ref<const T> from compiling. #1500
    • Fixed a compiler error when compiling <atomic> in C++20 mode with Clang targeting ARM64. #1509
  • Improved performance:
    • Removed unused code for Windows XP (and Server 2003) support, slightly improving runtime performance and decreasing the size of the STL's DLL by 3%. #1194 #1325 #1397
    • Optimized <charconv> from_chars() by simplifying how it assembles floating-point values, and by using the branchless rounding technique that was originally invented for hex precision to_chars(). #1220
    • Changed vector's move constructor to be more optimizer-friendly. #1330
    • Optimized the fill family of algorithms (including fill_n, the uninitialized_ forms, and the ranges:: forms) to use memset when setting scalars to all-bits-zero. #1273
    • Used new compiler intrinsics in <cmath>'s float and long double overloads of ceil, copysign, floor, round, and trunc. #1336
    • The range adaptor closure objects for views::filter and views::transform now properly move from their stashed function objects when possible. #1410
    • The spaceship customization point objects strong_order and weak_order now compare floating-point values without branching on the sign bit. #1475
  • Enhanced behavior:
    • Changed _Execute_once(), an internal helper function, to be compatible with XFG, an enhanced version of the Control Flow Guard feature. #1318 #1356
    • Added checks to optional::operator* and optional::operator-> that fire when called on an empty optional when _CONTAINER_DEBUG_LEVEL > 0 (which is implied by _ITERATOR_DEBUG_LEVEL != 0). #1362
    • Header improvements: #1405
      • <tuple> no longer includes <new>.
      • Changed most (but not all) C wrapper headers to be "core headers".
    • Function objects for operators (less, equal_to, greater, plus, etc., and the recently-added compare_three_way) now emit [[nodiscard]] warnings. #1474
  • Improved throughput:
    • Replaced one use of tag dispatch with if constexpr, and changed several uses of type trait structs to variable templates (which the MSVC compiler recognizes and efficiently handles). #1413
    • Added ::std:: qualification to certain names, improving throughput for extremely large tuples (noticeable with 50+ elements). #1490
  • Improved documentation:
    • Added llvm-project and the --progress option to the README's instructions for the initial submodule sync. This takes longer (a lot longer), but it simplifies the testing instructions later. #1441
  • Improved test coverage:
    • Added more <charconv> to_chars() test cases. #1278
    • Added tests for get_time() being called with a format specification that's longer than the stream's contents. #1326
    • Updated the libcxx test suite. #1090
    • Fixed the range adaptor tests to properly test const rvalues. #1393
    • Overhauled the test harness, improving its performance for both manual and CI runs. (For example, on one machine, testing time decreased from 75 minutes to 60 minutes.) #1394
    • Added /analyze:autolog- to /analyze:only test configurations; together, these compiler options run code analysis without producing an object file (/analyze:only) and without writing detailed analyzer results to an XML file (/analyze:autolog-), as we're simply looking for any warnings from code analysis. #1434
    • Skipped parts of tests/std/tests/VSO_0226079_mutex that could intermittently fail due to system_clock time adjustments on virtual machines. #1473
  • Code cleanups:
    • Removed compiler bug workarounds. #1291 #1327 #1451
    • Removed unused #include directives from stl/src files, and changed inclusions from <meow.h> to <cmeow>. #1270
    • Removed unnecessary macros and a compiler bug workaround. #1307
    • Removed unnecessary code in ranges::uninitialized_default_construct_n. #1377
    • Changed test code to consistently use unsigned int instead of unsigned. #1390
    • Moved helper structs in separately compiled code into unnamed namespaces. #1398
    • Changed test code to construct initializer_list with Standard code, instead of our internal constructor. #1400
    • Changed test code to always remove_cvref_t the argument to enable_borrowed_range (because the library doesn't allow user specializations for cv-qualified types or reference types). #1415
    • Renamed internal <ranges> machinery to _Category_base, which avoids shadowing the internal _Iterator_base used throughout the STL. #1420
    • Improved the readability of the <ranges> "expression-equivalent" machinery by extracting a constexpr "strategy" variable. #1426
    • Removed comments that were citing proposed resolutions for LWG issues, now that those issues have been officially resolved by the November 2020 virtual plenary meeting. #1456
    • Unified internal machinery for floating-point type traits. #1442
    • Fixed a comment that was mentioning a non-existent parameter. #1476
  • Infrastructure improvements:
    • Our pre-build code checks ("validate" and "clang-format") now both run even if one fails, and the tests are now skipped when the build fails. (Certainly one of our most leet contributions.) #1337
    • Accelerated CI tests by dividing them into shards across many machines. #1414
    • Updated dependencies.
      • Updated build compiler to VS 2019 16.9 Preview 1. #1290 #1399 #1451
      • Updated Python to 3.9.0. #1371
  • Updated _MSVC_STL_UPDATE. #1272 #1340 #1439

VS 2019 16.8

  • Merged C++20 features:
    • P0019R8 #843 atomic_ref
    • P0528R3 #1029 Atomic Compare-And-Exchange With Padding Bits (for MSVC; Clang support is pending compiler intrinsics, see LLVM-46685)
    • Completed P0553R4 and P0556R3 #795 by adding MSVC support for the functions in <bit> that were previously only supported when compiling with Clang (bit_ceil, bit_floor, bit_width, countl_one, countl_zero, countr_one, countr_zero, has_single_bit, popcount, rotl, and rotr).
    • Completed P0811R3 #1048 midpoint(), lerp() by adding constexpr support and improving handling of infinite arguments.
    • P0912R5 #894 #961 #1204 Library Support For Coroutines
    • P1001R2 #1111 execution::unseq
    • P1032R1 #491 #861 Miscellaneous constexpr
    • P1065R2 #703 constexpr INVOKE
    • Completed P1135R6 The C++20 Synchronization Library:
      • This feature adds a new satellite DLL "atomic_wait".
      • #593 #1143 #1179 std::atomic::wait
      • P1644R0 #1136 Adding wait/notify To atomic<shared_ptr<T>>, atomic<weak_ptr<T>>
      • #1057 <barrier>, <latch>, and <semaphore>
  • Merged partial C++20 features:
    • P0896R4 Ranges:
      • #888 algorithm ranges::move
      • #892 algorithm ranges::is_permutation
      • #896 algorithm ranges::search
      • #904 algorithms ranges::fill and ranges::fill_n
      • #905 algorithms ranges::generate and ranges::generate_n
      • #914 algorithm ranges::search_n
      • #915 algorithms ranges::is_sorted and ranges::is_sorted_until
      • #916 algorithms ranges::min, ranges::max, ranges::minmax, ranges::clamp, ranges::min_element, ranges::max_element, and ranges::minmax_element
      • #917 algorithms ranges::lower_bound, ranges::upper_bound, ranges::equal_range, and ranges::binary_search
      • #918 algorithm ranges::swap_ranges
      • #925 concepts std::permutable and std::sortable
      • #930 algorithms ranges::is_heap, ranges::is_heap_until, ranges::make_heap, ranges::push_heap, ranges::pop_heap, and ranges::sort_heap
      • #941 algorithm ranges::transform
      • #976 algorithms ranges::is_partitioned, ranges::partition, ranges::partition_copy, and ranges::partition_point
      • #983 algorithms ranges::replace, ranges::replace_copy, and ranges::replace_copy_if
      • #984 algorithm ranges::replace_if
      • #1005 algorithms ranges::remove, ranges::remove_if, ranges::remove_copy, and ranges::remove_copy_if
      • #1026 algorithm ranges::copy_backward
      • #1028 algorithm ranges::reverse (vectorized like std::reverse)
      • #1039 algorithms ranges::unique and ranges::unique_copy
      • #1044 Concept mergeable, and algorithms ranges::includes, ranges::set_difference, ranges::set_intersection, ranges::set_symmetric_difference, and ranges::set_union
      • #1052 algorithms ranges::sample and ranges::shuffle
      • #1053 algorithm ranges::move_backward
      • #1063 algorithm ranges::nth_element
      • #1073 algorithms ranges::rotate and ranges::rotate_copy
      • #1076 range access function ranges::ssize
      • #1081 algorithm ranges::lexicographical_compare
      • #1083 iterator adaptor counted_iterator
      • #1095 algorithm ranges::reverse_copy (vectorized like std::reverse_copy)
      • #1099 algorithms ranges::next_permutation and ranges::prev_permutation
      • #1101 algorithm ranges::merge
      • #1127 algorithm ranges::sort
      • #1132 view ranges::ref_view
      • #1137 algorithm ranges::uninitialized_move
      • #1201 range factories views::empty and views::single
      • #1229 range adaptors views::all and views::reverse
      • #1231 algorithms ranges::partial_sort and ranges::partial_sort_copy
      • #1245 P1391R4 Range Constructor For string_view
      • #1252 range adaptor views::filter
      • #1253 range adaptors views::drop and views::take
      • #1258 range adaptor views::transform
  • Merged LWG issue resolutions:
    • LWG-1203 #1225 More useful rvalue stream insertion
    • LWG-2597 #884 std::log misspecified for complex numbers
    • LWG-3070 #923 path::lexically_relative causes surprising results if a filename can also be a root-name
  • Fixed bugs:
    • variant no longer emits warnings about narrowing/sign conversions when determining which alternative should be activated for a given initializer. (Warnings can still be emitted by the chosen initialization; that's intentional and desirable.) #858
    • condition_variable_any now correctly unlocks-and-relocks the lock argument to timed wait functions when given a non-positive relative timeout or absolute time in the past. #685
    • std::pow is now templated to handle integral and floating-point types as required by C++11 and later. For example, std::pow(float, int) previously returned float and now returns double. #903
    • Removed a bogus overload of ranges::copy_n that wasn't supposed to exist and wouldn't have compiled. #957
    • filesystem_error now transcodes wide characters with no equivalent in the current locale to replacement characters instead of failing and throwing system error. #1010
    • Fixed 0 <=> partial_ordering::unordered to return the correct value, and improved <compare> codegen. #1049
    • discrete_distribution no longer yields invalid results when its parameters sum very close to, but not equal to 1. #1025
    • move_iterator::current is no longer inadvertently a protected data member - it has become properly private and been renamed. #1080
    • Range algorithms no longer mishandle pointer-to-member predicates and projections when they are larger than void*. #1091
    • The slice_array, gslice_array, mask_array, and indirect_array helpers defined in <valarray> now have proper copy constructors and copy assignment operators. #988
    • Fixed a bug in ranges::iter_swap that would cause it to sometimes drop one of the "swapped" values on the floor. #1072
    • weak_ptr conversions now preserve control blocks for expired objects. #1104
    • Fixed <bit>'s countl_zero to correctly use the bsr instruction as a fallback for old CPUs that don't support the lzcnt instruction. #1108 #1166
    • Fixed partial_sort_copy to perform only operations that are required by the Standard to compile. #1088
    • Fixed deque::erase(iter, iter) to no longer perform self-move-assignments when called with an empty range. #1148
    • Fixed coroutine_handle<>::resume and coroutine_handle<>::operator() to allow exceptions to be thrown from coroutines. #1182
    • Fixed piecewise_constant_distribution and piecewise_linear_distribution to return correctly distributed values. #1032
    • Fixed deque (and therefore queue and stack) compiler errors in unusual scenarios where iter + int and iter - int would invoke an unexpected operator overload. #1161
    • Fixed any and atomic compiler errors when building with /Zc:noexceptTypes-. #1150
    • Fixed <charconv> hexfloat from_chars() to correctly handle numbers like "0.fffffffffffff8p-1022" which are just below numeric_limits<Floating>::min(). #934
    • Changed shared_ptr's atomic functions to use SRWLOCK instead of a naive spinlock, fixing priority inversion and improving performance. #1200
    • Fixed incorrect constants that were producing incorrect results for cosh() and sinh(). #1156
    • Fixed 3 bugs in how ostream << floating_point handles precision: #1173
      • Hexfloat output now ignores precision, as required by the Standard.
      • Implemented LWG-231 (resolved in C++11, but overlooked); now, 0 precision for scientific or general notation is directly passed to sprintf, instead of being replaced with 6 precision.
      • Negative precision no longer crashes.
    • get_time() now ignores case when parsing day and month names, as required by the Standard. #1168 #1240
    • <experimental/generator> now defines an unhandled_exception() member function, required for C++20 coroutine promise types, even when /EHs isn't being used. #1219
    • Fixed compiler errors in the "iterator unwrapping" machinery for counted_iterator. #1213
    • fill now works correctly with pointers-to-volatile integral types. (This change also applies our memset/memcmp optimizations for fill/equal a bit more aggressively; they now activate for filling contiguous ranges of bool or comparing such with contiguous ranges of single-byte integer types.) #1160
    • valarray::operator[] now verifies its argument is in range when /D_CONTAINER_DEBUG_LEVEL=1. #1247
    • Fixed a compiler error in <complex> (introduced in VS 2019 16.7 by #367) when compiling with the Intel C++ Compiler's 80-bit long double mode. #1316
      • Note: 80-bit long double remains unsupported by MSVC.
  • Improved performance:
    • Extended equal()'s memcmp() optimization to ranges::equal_to and arbitrary contiguous iterators. #831
    • optional no longer unnecessarily zero-fills its storage when default constructed. #878
    • Improved span's debug codegen by simplifying its representation (as /std:c++latest isn't ABI-frozen). #877
    • Use __iso_volatile_store64 for relaxed atomics on x86, and use __iso_volatile_store64 unconditionally. #694
    • Enabled more constexpr in <system_error> using the [[msvc::noop_dtor]] attribute we requested from the MSVC compiler front-end. #1016
    • Hand-vectorized std::reverse_copy. #804
    • Refactored the comparison category types into aggregates so they can be passed in registers. #1065
    • Optimized std::fill and std::fill_n for vector<bool>. #879
    • Applied DisableThreadLibraryCalls to all "satellite" DLLs. #1142
    • Improved debug codegen in <valarray> by extracting repeated calls to size(). Also improved readability by expanding macros, and avoided unnecessary use of magic statics for non-trivial types. #1165
    • vector now avoids quadratic complexity when its size() is near max_size() (which is effectively impossible for the default allocator, making this an extremely obscure scenario). Now, if geometric growth would exceed max_size(), we clamp to max_size(). #1221
  • Enhanced behavior:
    • Strengthened noexcept for all container iterators. #1227
    • basic_string and basic_string_view now enforce the requirement that their character types must be non-array, trivial, standard-layout types. #1262
  • Improved throughput:
    • Simplified is_function, is_object, is_member_function_pointer, is_member_object_pointer, and is_member_pointer. #460
  • Improved documentation:
    • The README's IDE instructions now explain how to use the vcpkg submodule. #873
    • The README's command prompt instructions now explicitly explain how to build both x86 and x64. #1226
  • Improved test coverage:
    • Added test cases for the large integer fallback in <charconv> to_chars() plain shortest round-trip. #835
    • Future-proofed test code for the upcoming addition of C++20 std::chrono::last. #837
    • Enabled more libcxx test coverage for span. #839
    • Added test coverage for the new /Zc:preprocessor compiler option. #677
    • Added tests for LWG-3018 "shared_ptr of function type". #833
    • Fixed "unresolved" tests by linking with /MANIFEST:EMBED. #862
    • The test harness now emits a "note" for unsupported locales instead of a warning. #866
    • Prevented failing tests from displaying assertion/crash dialog boxes. Also, the standard output streams of failing tests are no longer lost due to buffering. #906
    • Increased test coverage in the ranges spaceship test by removing compiler bug workarounds. #852
    • Improved ranges test machinery. #959
    • Enabled "multiple translation unit" tests which hadn't been running in the new test infrastructure. These tests detect problems like forgetting to mark header-only non-templated functions as inline. #1109
    • Added a test to verify that deque::erase(iter, iter) no longer performs self-move-assignments when called with an empty range. #1203
    • Removed experimental /await from test configurations, and re-enabled various tests now that compiler bugs have been fixed. #1207
    • Added a test for <coroutine> "end-to-end" behavior. #1215
  • Code cleanups:
    • Updated comment to cite LWG-3446. #841
    • Renamed identifiers like _R1 to _Rx1, avoiding any resemblance to macros. #865
    • Added comments to <execution>, mentioning the subtle control flow. #849
    • Avoided function-style casts in test code. #899
    • Cleaned up stl/src, changing C casts to C++ casts, 0 to nullptr, and more. #900 #912
    • Added ranges::_Ubegin and ranges::_Uend internal helper functions to simplify getting "unwrapped" iterators from a range. #901
    • Renamed internal headers to .hpp and adjusted clang-format to sort them last. #902
    • Simplified comments, as using _Pred and using operator< weren't necessary to mention. #977
    • Removed compiler workarounds and used braces to construct objects. #978 #1020
    • Improved ranges test machinery to better tolerate using-directives. #979
    • Consistently formatted requires, preparing for when clang-format becomes aware of concepts. #999
    • Provided comparison operators for map, multimap, set, and multiset instead of their internal base class _Tree. #1022
    • Updated the implementations of some of the oldest Range algorithms to match our current style:
      • #956 ranges::copy
      • #958 ranges::copy_if
      • #970 ranges::move
      • #974 ranges::count
      • #975 ranges::count_if
      • #1058 the ranges::find family
      • #1060 the ranges::for_each family
      • #1061 the ranges::all_of family
      • #1062 ranges::swap_ranges and ranges::distance
    • Took advantage of some of the clang-format changes in LLVM 10 to keep our codebase looking nice. #1075
    • Removed unnecessary std:: qualification from product and test code. #1119
    • Cleaned up compiler bug workarounds, which will be possible to remove in the near future. #1191
    • Worked around some IntelliSense bugs in the concepts-enabled C++20 parts of the STL. #1216
    • Removed an unnecessary compiler option /d2Zi+ from CMakeLists.txt. #1218
    • Consistently use conjunction_v for short-circuiting in conditional explicit clauses. #1241
    • Avoided null pointer constants masquerading as integers by replacing 0 with nullptr in a great many places. #1250
  • Infrastructure improvements:
    • Updated dependencies.
    • CMakeLists.txt now defaults to using our vcpkg submodule, simplifying our build process. #1124
    • Removed a timing assumption from test_atomic_wait.hpp that was causing intermittent test failures.
    • Added /analyze to PR/CI builds, and fixed the resulting warnings. #1009
    • Enhanced our Code Format Validation check to detect lines exceeding 120 columns, and cleaned up a few occurrences in areas where clang-format had been suppressed. #1214
  • Updated _MSVC_STL_UPDATE. #897 #989 #1144

VS 2019 16.7

  • Merged C++20 features:
    • P0415R1 #367 constexpr For <complex> (Again)
    • P0476R2 #583 <bit> bit_cast
    • P0586R2 #621 Integer Comparison Functions
    • P0674R1 #309 make_shared() For Arrays
      • LWG-3005 Destruction order of arrays by make_shared/allocate_shared only recommended?
      • LWG-3007 allocate_shared should rebind allocator to cv-unqualified value_type for construction
    • P0718R2 #601 atomic<shared_ptr<T>>, atomic<weak_ptr<T>>
    • P0722R3 #692 Efficient Sized delete For Variable Sized Classes (library support types)
    • P1023R0 #599 constexpr For std::array Comparisons
    • P1115R3 #566 erase()/erase_if() Return size_type
    • P1831R1 #634 Deprecating volatile In The Standard Library
    • P1871R1 #607 disable_sized_sentinel_for; renames disable_sized_sentinel to disable_sized_sentinel_for.
    • P1956R1 #524 <bit> has_single_bit(), bit_ceil(), bit_floor(), bit_width()
    • P1976R2 #500 Explicit Constructors For Fixed-Extent span From Dynamic-Extent Ranges
    • P2116R0 #587 Removing tuple-Like Protocol Support From Fixed-Extent span
  • Merged partial C++20 features:
    • P0768R1 #515 Library Support For The Spaceship Comparison Operator <=>; includes lexicographical_compare_three_way.
    • P0784R7 #501 Library Support For More constexpr Containers; includes construct_at.
    • P0896R4 Ranges:
      • #385 function objects ranges::equal_to, ranges::not_equal_to, ranges::less, ranges::less_equal, ranges::greater, and ranges::greater_equal
      • #734 ranges::subrange and ranges::view_interface
      • #759 changes to reverse_iterator to better adapt C++20 iterators
      • #787 similar changes to move_iterator, implement move_sentinel
      • #815 algorithm ranges::find_end
      • #821 algorithm ranges::find_first_of
      • #822 algorithm ranges::adjacent_find
    • P1135R6 The C++20 Synchronization Library; includes atomic_flag::test and lock-free integral types. #684
    • P1614R2 #385 Adding Spaceship <=> To The Library; includes concepts three_way_comparable and three_way_comparable_with, type trait compare_three_way_result (with _t variant), and function object compare_three_way.
  • Merged LWG issue resolutions:
    • LWG-3149 #635 DefaultConstructible should require default initialization
    • LWG-3255 #506 span's array constructor is too strict
    • LWG-3320 #548 span::cbegin/cend methods produce different results than std::[ranges::]cbegin/cend
    • LWG-3329 #512 totally_ordered_with both directly and indirectly requires common_reference_with
    • LWG-3330 #513 Include <compare> from most library headers
    • LWG-3390 #567 make_move_iterator() cannot be used to construct a move_iterator for a move-only iterator
  • Merged proposed resolutions for LWG issues that were eventually accepted at the November 2020 virtual plenary meeting:
    • LWG-3420 #786 cpp17-iterator should check that the type looks like an iterator first
    • LWG-3446 #834 indirectly_readable_traits ambiguity for types with both value_type and element_type
  • Fixed bugs:
    • operator/ and operator% for chrono::duration now properly SFINAE away when common_type_t<Rep1, Rep2> can't be formed. #573
    • <filesystem> directory_iterator now properly handles "." and ".." on network drives. #494
    • <filesystem> space() no longer requires read permissions for every directory along the path in some cases, and resolves symbolic links. #552
    • <filesystem> now considers ERROR_BAD_NETPATH as a "file does not exist" condition. #616
    • filesystem::path::path(const Source&) is now properly removed from overload resolution when Source is a non-iterator with member value_type even in C++20 mode. #631
    • The CMake release build now correctly uses the compiler flags in VCLIBS_RELEASE_OPTIONS. #608
    • Enabled the implementation of LWG-2899 in /clr mode now that the fix for the compiler bug triggered by such (VSO-1006185) has been released. #417
    • Fixed a bug specific to Clang 10 in <system_error> and removed the _SILENCE_CLANG_CONCEPTS_MESSAGE barrier in <concepts> now that we've worked with Clang developers to ensure Clang 10 and the STL play well together with Concepts enabled. #622
    • __cpp_lib_int_pow2 is no longer incorrectly defined when the compiler lacks support for the intrinsics necessary to implement has_single_bit, bit_ceil, bit_floor, and bit_width. Also, __cpp_lib_bitops is no longer defined when the compiler is EDG-imitating-MSVC, so IntelliSense properly reflects the non-availability of operations not yet supported by MSVC. #695
    • Fixed a 43-year-old bug in boyer_moore_searcher by implementing a 40-year-old fix. #724
    • std::function now handles over-aligned types. #698
    • <cvt/sjis_0208> now correctly recognizes bad second bytes. #755
    • Fixed several bugs in complex's Sufficient Additional Overloads. #791
      • arg(real) now behaves like arg(complex), instead of always returning 0.
      • conj(real) now behaves like conj(complex), returning an imaginary part of negative zero.
      • proj(real) now behaves like proj(complex), mapping negative infinity to positive infinity.
      • conj and proj now return complex.
      • norm now upgrades integers to double before squaring, instead of after.
    • <filesystem> now consistently handles nonexistent network paths when the Windows API emits ERROR_INVALID_NAME. #800
    • Fixed a race condition in the parallel adjacent_find algorithm that could cause it to return a result other than the first under heavy load. #816
  • Enhanced behavior:
    • Strengthened noexcept for array iterators, also improving the behavior of span construction from array iterators. #627
    • Removed a static_assert in <atomic> that prevented certain (completely conforming) usage from compiling until users defined the macro _ENABLE_ATOMIC_ALIGNMENT_FIX. Note: MSVC's STL has generated correct code for such usage since VS 2015 Update 2, so this change doesn't degrade correctness in any way - it merely removes an annoying compilation roadblock that warned about potential ODR violations when mixing code compiled with ancient toolsets that generated incorrect code for such usage in the first place. #723
    • Enabled bit_cast for IntelliSense now that front-end support is available. #733
    • complex's real(T) and imag(T) setters now properly return void. #367
    • Fixed Clang warnings in STL headers (when they aren't suppressed by Clang's treatment of "system headers") and enhanced test coverage to remain clean. #755
    • We now detect compiler support for consteval by testing __cpp_consteval. #765
    • Fixed CUDA warnings/errors. #772
  • Improved performance:
    • Massively improved the performance of <system_error> by avoiding the need for synchronization when constructing error categories. #529
    • Removed layers of calls to helpers and forward() in invoke(). #585
    • Cached the result of QueryPerformanceFrequency in calls to steady_clock::now(). #646
    • #653 attempted to avoid one division in steady_clock::now(). This caused a regression where steady_clock::now() overflowed after approximately 15 minutes, so it was reverted by #972. The revert was ported to VS 2019 16.7 Preview 5, separately from the commit order in GitHub.)
    • bitset::all now returns upon finding the first non-set bit. #671
    • gcd now uses the same machinery as countr_zero instead of a hand-rolled bit counting loop. #665
    • atomic_thread_fence now avoids unnecessary contention by using separate guard variables. #740
    • <algorithm> now increments/decrements copies of iterators, which could be more efficient for certain user-defined iterators than adding/subtracting 1. #771 #803
    • <mutex> call_once uses InitOnceBeginInitialize and InitOnceComplete unconditionally now that we no longer support Windows XP, and avoids trips through try regions and std::current_exception. #688
  • Improved throughput:
    • <array> no longer includes <algorithm>, <iterator>, and <tuple>; this is a source-breaking change for projects that weren't strict about including what they use. #482
    • Reworked the machinery for the is_invocable family of type traits, improving throughput. #408
    • ~scoped_lock() now uses fold expressions, instead of helper functions in <tuple> that weren't used by product code anywhere else. #760
  • Code cleanups:
    • Consistently use empty braces to construct tags like _Meow{}. #497
    • Avoid declaring multiple variables on a single line. #550
    • Removed comment now that to_address() is now totally constexpr. #568
    • Consistently use __cpp_lib_byte to detect whether std::byte is available. #577
    • Replaced _STATIC_UNLESS_PURE with static. (This was a macro workaround for a compiler bug that was fixed.) #584
    • Removed #if 1 #endif pair after LWG-3150 was accepted. #638
    • Removed comments after LWG-3201 was accepted. #640
    • Updated the STL's required compilers to Clang 10 and MSVC 19.26. #708
    • Replaced some implicit conversions with explicit conversions to silence the new MSVC warning C5219 implicit conversion from '%s' to '%s', possible loss of data. #730
    • Refactored some for-loops to follow the normal pattern. #709
    • Removed the so-called _ITERATOR_DEBUG_ARRAY_OVERLOADS (see #660). #735
    • Silenced warnings for use of C++20 extensions in downlevel language modes when Clang believes the STL headers are not system headers. #737
    • Removed and updated compiler bug workarounds. #742
    • Fixed spelling mistakes. #743
    • Improved build instructions: now the command-line build matches the IDE build, and respects .gitignore. #764
    • Removed unused _RAISE macro. Modernized code to use {} for index_sequence, nullptr, and more C++ casts. Extracted assignments before comparisons. Used unsigned int consistently. #764
    • Avoided shadowing _Noinit and removed an unnecessary struct. #772
    • Removed redundant suppressions of warning C6294. #794
    • Used more empty braces, added _STD to system_category() etc. calls, changed <experimental/filesystem> error_code handling to be consistent with Standard <filesystem>, removed an unnecessary using-directive in <regex>. #827
  • Infrastructure improvements:
    • Updated dependencies. #620 #645
      • Updated build compiler to VS 2019 16.6 Preview 2.
      • Updated Clang to 10.0.0.
      • Updated CMake to 3.16.5.
      • Updated Ninja to 1.10.0.
      • Updated Python to 3.8.2.
      • Added CUDA 10.1 Update 2 (not yet used). #682
    • Introduced CI testing using lit. #520
      • Fully ported libcxx testsuite.
      • Partially ported std testsuite.
      • Partially ported tr1 testsuite. #652
      • Added testing instructions to the README. #647 #783
      • Added /BE test coverage (for EDG-powered IntelliSense). #682
      • Improved test infrastructure (speedups, timeouts, shuffling, etc.). #769
      • Skipped /clr test coverage (as /clr support libraries aren't yet built). #796
    • Updated the pull request template to reflect that testing is now online. #644
    • VCLIBS_SUFFIX is now a CMake cache variable. #649
    • Improved code format validation:
      • Reject long paths and paths containing spaces. #699
      • Moved code format validation into a separate stage. #682
      • Used constexpr is_sorted() in validate.cpp. #650
    • Added a new "question" issue template to encourage folks to ask questions about the STL implementation. #687
  • Updated _MSVC_STL_UPDATE. #637 #676 #793

VS 2019 16.6

  • Merged C++20 features:
    • P0122R7 #142 #474 <span>
      • P1024R3 Enhancing span Usability
      • P1085R2 Removing span Comparisons
      • P1227R2 Unsigned span::size()
      • P1394R4 Range Constructor For span
      • P1872R0 span Should Have size_type, Not index_type
      • LWG-3101 span's Container constructors need another constraint
      • LWG-3102 Clarify span iterator and const_iterator behavior
      • LWG-3103 Errors in taking subview of span should be ill-formed where possible
      • LWG-3144 span does not have a const_pointer typedef
      • LWG-3198 Bad constraint on std::span::span()
      • LWG-3274 Missing feature test macro for <span>
      • LWG-3369 span's deduction-guide for built-in arrays doesn't work
    • P0202R3 #425 constexpr For <algorithm> And exchange()
      • LWG-3256 Feature testing macro for constexpr algorithms
    • P0357R3 #393 Supporting Incomplete Types In reference_wrapper
    • P0619R4 #380 Removing C++17-Deprecated Features In C++20
    • P0879R0 #425 constexpr For Swapping Functions
    • P0883R2 #390 Fixing Atomic Initialization
    • P0935R0 #415 Eradicating Unnecessarily Explicit Default Constructors
    • P1006R1 #397 constexpr For pointer_traits<T*>::pointer_to()
    • P1165R1 #467 Consistently Propagating Stateful Allocators In basic_string's operator+()
    • P1423R3 #470 char8_t Backward Compatibility Remediation
    • P1645R1 #399 constexpr For <numeric> Algorithms
    • P1964R2 #565 Replacing boolean With boolean-testable
    • P2091R0 #565 Fixing Issues With Range Access CPOs
    • P2102R0 #565 Making "Implicit Expression Variations" More Explicit
  • Merged partial C++20 features:
    • P0768R1 Library Support For The Spaceship Comparison Operator <=>
      • #402 Deprecated std::rel_ops.
    • P0896R4 Ranges:
      • #389 some Ranges concepts, including P1456R1 Move-Only Views and P1870R1 safe_range.
      • #432 P2091R0 Issues With Range Access CPOs.
      • #565 algorithms ranges::all_of, ranges::any_of, ranges::copy, ranges::copy_if, ranges::copy_n, ranges::count, ranges::count_if, ranges::equal, ranges::find, ranges::find_if, ranges::find_if_not, ranges::for_each, ranges::for_each_n, ranges::mismatch, and ranges::none_of.
      • #589 changes to std::back_insert_iterator, std::front_insert_iterator, and std::insert_iterator necessary to model the Ranges iterator concepts.
  • Merged LWG issue resolutions:
  • Added test suites (not yet running):
  • Fixed bugs:
    • complex acos(), acosh(), and asinh() now return correct results. #401
    • complex pow() is now overloaded correctly. #383
    • Fixed std::filesystem::remove() on ReFS. #407
    • Avoided using iter[idx] in all algorithms, because it's problematic with some unusual but Standard-conforming iterators. #464
    • <system_error> now maps ERROR_BROKEN_PIPE to errc::broken_pipe. #406
    • Fixed a compiler error when compiling with the Intel C++ Compiler, because it hadn't implemented C++20 conditional explicit in C++14/17 mode. #424
      • Note: The Intel C++ Compiler remains unsupported by MSVC.
    • Fixed the visualizers for atomic and atomic_flag. #315
  • Improved performance:
    • Significantly improved performance of string + null terminated and null terminated + string operator+ overloads in <string>. #467
    • Reduced memory consumption of system_category().message(). #457
    • Optimized is_permutation() and operator== for unordered multi-containers. #423
  • Improved throughput:
    • Significantly improved compile times for <iterator> and <array>. Note that this is a source-breaking change for user code that expected STL headers to include other headers in certain ways. #355
  • Code cleanups:
    • src/syserror.cpp now uses range-for and static_cast. #481
    • Changed macro constants to constexpr variables. #487
    • Cleaned up the implementation of sort(). #449
    • Added static_assert is_sorted() for lookup tables. #451
    • Removed compiler workarounds. #410 #452 #453 #454
    • Added compiler workarounds. #475
    • Updated the STL's required compiler to MSVC 19.25. #430
    • Enabled clang-format for slightly more code. #458
  • Infrastructure improvements:
    • Fixed errors when building the STL with Boost 1.72. #447 #428
    • Improved how the CI builds boost-math. #450
  • Updated _MSVC_STL_UPDATE. #429 #486

VS 2019 16.5

  • Hello, world!
    • Announced this repo at CppCon 2019.
    • Added initial documentation: readme, license, and roadmap.
    • Added initial CMake build scripts for Desktop-only msvcp.
    • Investigated continuous integration options, like GitHub Actions or Azure Pipelines. (Chose Azure Pipelines.)
    • Automated builds running in PRs.
    • Investigated test harness solutions, either building our own to more closely match the internal system in a reasonable way, or using libcxx's lit. (Chose to use lit.)
    • Began auditing test case source files from the std and tr1 test suites.
    • Implemented Custom Autolinks in this repo.
  • Merged C++20 features:
  • Merged LWG issue resolutions:
    • LWG-2899 #193 is_(nothrow_)move_constructible and tuple, optional, and unique_ptr
    • LWG-3158 #195 tuple(allocator_arg_t, const Alloc&) should be conditionally explicit
    • LWG-3199 #353 istream >> bitset<0> fails
    • LWG-3257 #353 Missing feature testing macro update from P0858
    • LWG-3266 #353 to_chars(bool) should be deleted
  • Merged proposed resolutions for LWG issues (not yet accepted for the C++ Working Draft, but we've chosen to implement this speculatively):
    • LWG-3268 #151 memory_order::memory_order_meow broken in C++20
  • Fixed bugs:
    • Restored swap(unique_ptr&, unique_ptr&) which was mistakenly removed. #170
    • When erasing an empty range in a vector, avoided self-move-assigning all elements. #228
  • Improved performance:
    • Fixed a codegen size regression in atomic<integral> and atomic<pointer>. #227
  • Code cleanups:
    • Removed unnecessary public keywords in struct inheritance. #219
    • Used iter[idx] for clarity in <algorithm>. #289 (Note that this was reverted in VS 2019 16.6 by #464.)
  • Updated _MSVC_STL_UPDATE. #253 #358
Clone this wiki locally