STATUS.md

SLB

C++ Standard Library Backport

Status

Features

<functional>

• invoke
• mem_fn
• not_fn

<type_traits>

• bool_constant
• endian
• is_aggregate
• is_null_pointer
• remove_cvref
• type_identity
• void_t
• Invocable type traits
  • std::is_invocable
  • std::is_invocable_r
  • std::is_nothrow_invocable
  • std::is_nothrow_invocable_r
• Logical operator type traits
  • conjunction
  • disjunction
  • negation
• Metafunction aliases: *_t

<utility>

• as_const
• exchange
• integral_constant::operator()
• Compile-time integer sequences
  • integer_sequence
  • index_sequence
  • make_integer_sequence
  • make_index_sequence
  • index_sequence_for

---

All Papers and Issues

C++14

Papers

• N3302: Constexpr Library Additions: complex, v2
• N3346: Terminology for Container Element Requirements
• N3421: Making Operator Functors greater<>
• N3462: std::result_of and SFINAE
• N3469: Constexpr Library Additions: chrono, v3
• N3470: Constexpr Library Additions: containers, v2
• N3471: Constexpr Library Additions: utilities, v3
• N3545: An Incremental Improvement to integral_constant
• N3642: User-defined Literals
• N3644: Null Forward Iterators
• N3654: Quoted Strings
• N3655: TransformationTraits Redux (excluding part 4)
• N3656: make_unique
• N3657: Adding heterogeneous comparison lookup to associative containers
• N3658: Compile-time integer sequences
• N3659: Shared Locking in C++
• N3668: std::exchange() utility function
• N3669: Fixing constexpr member functions without const
• N3670: Addressing Tuples by Type
• N3671: Making non-modifying sequence operations more robust
• N3779: User-defined Literals for std::complex
• N3789: Constexpr Library Additions: functional
• N3887: Consistent Metafunction Aliases
• N3891: A proposal to rename shared_mutex to shared_timed_mutex
• N3924: Discouraging rand() in C++14

Issues

• LWG1214: Insufficient/inconsistent key immutability requirements for associative containers
• LWG1450: Contradiction in regex_constants
• LWG2003: String exception inconsistency in erase.
• LWG2005: unordered_map::insert(T&&) protection should apply to map too
• LWG2009: Reporting out-of-bound values on numeric string conversions
• LWG2010: is_* traits for binding operations can't be meaningfully specialized
• LWG2011: Unexpected output required of strings
• LWG2013: Do library implementers have the freedom to add constexpr?
• LWG2015: Incorrect pre-conditions for some type traits
• LWG2018: regex_traits::isctype Returns clause is wrong
• LWG2021: Further incorrect usages of result_of
• LWG2028: messages_base::catalog overspecified
• LWG2033: Preconditions of reserve, shrink_to_fit, and resize functions
• LWG2039: Issues with std::reverse and std::copy_if
• LWG2044: No definition of "Stable" for copy algorithms
• LWG2045: forward_list::merge and forward_list::splice_after with unequal allocators
• LWG2047: Incorrect "mixed" move-assignment semantics of unique_ptr
• LWG2048: Unnecessary mem_fn overloads
• LWG2049: is_destructible is underspecified
• LWG2050: Unordered associative containers do not use allocator_traits to define member types
• LWG2053: Errors in regex bitmask types
• LWG2056: future_errc enums start with value 0 (invalid value for broken_promise)
• LWG2058: valarray and begin/end
• LWG2061: make_move_iterator and arrays
• LWG2064: More noexcept issues in basic_string
• LWG2065: Minimal allocator interface
• LWG2067: packaged_task should have deleted copy c'tor with const parameter
• LWG2069: Inconsistent exception spec for basic_string move constructor
• LWG2071: std::valarray move-assignment
• LWG2074: Off by one error in std::reverse_copy
• LWG2075: Progress guarantees, lock-free property, and scheduling assumptions
• LWG2078: Throw specification of async() incomplete
• LWG2080: Specify when once_flag becomes invalid
• LWG2081: Allocator requirements should include CopyConstructible
• LWG2083: const-qualification on weak_ptr::owner_before
• LWG2085: Wrong description of effect 1 of basic_istream::ignore
• LWG2086: Overly generic type support for math functions
• LWG2087: iostream_category() and noexcept
• LWG2091: Misplaced effect in m.try_lock_for()
• LWG2092: Vague Wording for condition_variable_any
• LWG2093: Throws clause of condition_variable::wait with predicate
• LWG2094: duration conversion overflow shouldn't participate in overload resolution
• LWG2096: Incorrect constraints of future::get in regard to MoveAssignable
• LWG2097: packaged_task constructors should be constrained
• LWG2098: promise throws clauses
• LWG2099: Unnecessary constraints of va_start() usage
• LWG2100: Timed waiting functions cannot timeout if launch::async policy used
• LWG2102: Why is std::launch an implementation-defined type?
• LWG2103: std::allocator_traits<std::allocator<T>>::propagate_on_container_move_assignment
• LWG2104: unique_lock move-assignment should not be noexcept
• LWG2105: Inconsistent requirements on const_iterator's value_type
• LWG2109: Incorrect requirements for hash specializations
• LWG2110: remove can't swap but note says it might
• LWG2112: User-defined classes that cannot be derived from
• LWG2120: What should async do if neither async nor deferred is set in policy?
• LWG2122: merge() stability for lists versus forward lists
• LWG2123: merge() allocator requirements for lists versus forward lists
• LWG2128: Absence of global functions cbegin/cend
• LWG2130: missing ordering constraints for fences
• LWG2132: std::function ambiguity
• LWG2135: Unclear requirement for exceptions thrown in condition_variable::wait()
• LWG2138: atomic_flag::clear ordering constraints
• LWG2140: notify_all_at_thread_exit synchronization
• LWG2141: common_type trait produces reference types
• LWG2142: packaged_task::operator() synchronization too broad?
• LWG2143: ios_base::xalloc should be thread-safe
• LWG2144: Missing noexcept specification in type_index
• LWG2145: error_category default constructor
• LWG2147: Unclear hint type in Allocator's allocate function
• LWG2148: Hashing enums should be supported directly by std::hash
• LWG2149: Concerns about 20.8/5
• LWG2150: Unclear specification of find_end
• LWG2159: atomic_flag initialization
• LWG2162: allocator_traits::max_size missing noexcept
• LWG2163: nth_element requires inconsistent post-conditions
• LWG2169: Missing reset() requirements in unique_ptr specialization
• LWG2172: Does atomic_compare_exchange_* accept v == nullptr arguments?
• LWG2174: wstring_convert::converted() should be noexcept
• LWG2175: string_convert and wbuffer_convert validity
• LWG2176: Special members for wstring_convert and wbuffer_convert
• LWG2177: Requirements on Copy/MoveInsertable
• LWG2180: Exceptions from std::seed_seq operations
• LWG2182: Container::[const_]reference types are misleadingly specified
• LWG2185: Missing throws clause for future/shared_future::wait_for/wait_until
• LWG2186: Incomplete action on async/launch::deferred
• LWG2187: vector<bool> is missing emplace and emplace_back member functions
• LWG2188: Reverse iterator does not fully support targets that overload operator&
• LWG2190: ordering of condition variable operations, reflects Posix discussion
• LWG2193: Default constructors for standard library containers are explicit
• LWG2194: Impossible container requirements for adaptor types
• LWG2196: Specification of is_*[copy/move]_[constructible/assignable] unclear for non-referencable types
• LWG2197: Specification of is_[un]signed unclear for non-arithmetic types
• LWG2200: Data race avoidance for all containers, not only for sequences
• LWG2203: scoped_allocator_adaptor uses wrong argument types for piecewise construction
• LWG2205: Problematic postconditions of regex_match and regex_search
• LWG2207: basic_string::at should not have a Requires clause
• LWG2209: assign() overspecified for sequence containers
• LWG2210: Missing allocator-extended constructor for allocator-aware containers
• LWG2211: Replace ambiguous use of "Allocator" in container requirements
• LWG2213: Return value of std::regex_replace
• LWG2222: Inconsistency in description of forward_list::splice_after single-element overload
• LWG2225: Unrealistic header inclusion checks required
• LWG2229: Standard code conversion facets underspecified
• LWG2231: DR 704 removes complexity guarantee for clear()
• LWG2235: Undefined behavior without proper requirements on basic_string constructors
• LWG2240: Probable misuse of term "function scope" in [thread.condition]
• LWG2246: unique_ptr assignment effects w.r.t. deleter
• LWG2247: Type traits and std::nullptr_t
• LWG2252: Strong guarantee on vector::push_back() still broken with C++11?
• LWG2257: Simplify container requirements with the new algorithms
• LWG2258: a.erase(q1, q2) unable to directly return q2
• LWG2263: Comparing iterators and allocator pointers with different const-character
• LWG2268: Setting a default argument in the declaration of a member function assign of std::basic_string
• LWG2271: regex_traits::lookup_classname specification unclear
• LWG2272: quoted should use char_traits::eq for character comparison
• LWG2275: Why is forward_as_tuple not constexpr?
• LWG2278: User-defined literals for Standard Library types
• LWG2280: begin / end for arrays should be constexpr and noexcept
• LWG2284: Inconsistency in allocator_traits::max_size
• LWG2285: make_reverse_iterator
• LWG2288: Inconsistent requirements for shared mutexes
• LWG2291: std::hash is vulnerable to collision DoS attack
• LWG2293: Wrong facet used by num_put::do_put
• LWG2298: is_nothrow_constructible is always false because of create<>
• LWG2299: Effects of inaccessible key_compare::is_transparent type are not clear
• LWG2300: Redundant sections for map and multimap members should be removed
• LWG2301: Why is std::tie not constexpr?
• LWG2304: Complexity of count in unordered associative containers
• LWG2306: match_results::reference should be value_type&, not const value_type&
• LWG2308: Clarify container destructor requirements w.r.t. std::array
• LWG2313: tuple_size should always derive from integral_constant
• LWG2314: apply() should return decltype(auto) and use decay_t before tuple_size
• LWG2315: weak_ptr should be movable
• LWG2316: weak_ptr::lock() should be atomic
• LWG2317: The type property queries should be UnaryTypeTraits returning size_t
• LWG2320: select_on_container_copy_construction() takes allocators, not containers
• LWG2322: Associative(initializer_list, stuff) constructors are underspecified
• LWG2323: vector::resize(n, t)'s specification should be simplified
• LWG2324: Insert iterator constructors should use addressof()
• LWG2329: regex_match()/regex_search() with match_results should forbid temporary strings
• LWG2330: regex("meow", regex::icase) is technically forbidden but should be permitted
• LWG2332: regex_iterator/regex_token_iterator should forbid temporary regexes
• LWG2339: Wording issue in nth_element
• LWG2341: Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)
• LWG2344: quoted()'s interaction with padding is unclear
• LWG2346: integral_constant's member functions should be marked noexcept
• LWG2350: min, max, and minmax should be constexpr
• LWG2356: Stability of erasure in unordered associative containers
• LWG2357: Remaining Assignable requirement
• LWG2359: How does regex_constants::nosubs affect basic_regex::mark_count()?
• LWG2360: reverse_iterator::operator*() is unimplementable
• GB9: Remove gets from C++14

C++17

Papers

• N3911: TransformationTrait Alias void_t.
• N4089: Safe conversions in unique_ptr<T[]>.
• N4169: A proposal to add invoke function template
• N4190: Removing auto_ptr, random_shuffle(), And Old Stuff.
• N4258: Cleaning-up noexcept in the Library.
• N4259: Wording for std::uncaught_exceptions
• N4277: TriviallyCopyable reference_wrapper.
• N4279: Improved insertion interface for unique-key maps.
• N4280: Non-member size() and more
• N4284: Contiguous Iterators.
• N4285: Cleanup for exception-specification and throw-expression.
• N4387: improving pair and tuple
• N4389: bool_constant
• N4508: shared_mutex for C++17
• N4366: LWG 2228 missing SFINAE rule
• N4510: Minimal incomplete type support for standard containers, revision 4
• P0004: Remove Deprecated iostreams aliases.
• P0006: Adopt Type Traits Variable Templates for C++17.
• P0092: Polishing <chrono>
• P0007: Constant View: A proposal for a std::as_const helper function template.
• P0156: Variadic lock_guard(rev 3). Reverted in Kona
• P0074: Making std::owner_less more flexible
• P0013: Logical Operator Type Traits
• P0024: The Parallelism TS Should be Standardized
• P0226: Mathematical Special Functions for C++17
• P0220: Adopt Library Fundamentals V1 TS Components for C++17
• P0218: Adopt the File System TS for C++17
• P0033: Re-enabling shared_from_this
• P0005: Adopt not_fn from Library Fundamentals 2 for C++17
• P0152: constexpr atomic::is_always_lock_free
• P0185: Adding [nothrow-]swappable traits
• P0253: Fixing a design mistake in the searchers interface
• P0025: An algorithm to "clamp" a value between a pair of boundary values
• P0154: constexpr std::hardware_{constructive,destructive}_interference_size
• P0030: Proposal to Introduce a 3-Argument Overload to std::hypot
• P0031: A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access
• P0272: Give std::string a non-const .data() member function
• P0077: is_callable, the missing INVOKE related trait
• P0032: Homogeneous interface for variant, any and optional
• P0040: Extending memory management tools
• P0063: C++17 should refer to C11 instead of C99
• P0067: Elementary string conversions (P0067R5)
• P0083: Splicing Maps and Sets
• P0084: Emplace Return Type
• P0088: Variant: a type-safe union for C++17
• P0137: Core Issue 1776: Replacement of class objects containing reference members
• P0163: shared_ptr::weak_type
• P0174: Deprecating Vestigial Library Parts in C++17
• P0175: Synopses for the C library
• P0180: Reserve a New Library Namespace for Future Standardization
• P0209: make_from_tuple: apply for construction
• P0219: Relative Paths for Filesystem
• P0254: Integrating std::string_view and std::string
• P0258: has_unique_object_representations
• P0295: Adopt Selected Library Fundamentals V2 Components for C++17
• P0302: Removing Allocator Support in std::function
• P0307: Making Optional Greater Equal Again
• P0336: Better Names for Parallel Execution Policies in C++17
• P0337: Delete operator= for polymorphic_allocator
• P0346: A <random> Nomenclature Tweak
• P0358: Fixes for not_fn
• P0371: Temporarily discourage memory_order_consume
• P0392: Adapting string_view by filesystem paths
• P0393: Making Variant Greater Equal
• P0394: Hotel Parallelifornia: terminate() for Parallel Algorithms Exception Handling
• P0003: Removing Deprecated Exception Specifications from C++17
• P0067: Elementary string conversions, revision 5
• P0403: Literal suffixes for basic_string_view
• P0414: Merging shared_ptr changes from Library Fundamentals to C++17
• P0418: Fail or succeed: there is no atomic lattice
• P0426: Constexpr for std::char_traits
• P0435: Resolving LWG Issues re common_type
• P0502: Throwing out of a parallel algorithm terminates - but how?
• P0503: Correcting library usage of "literal type"
• P0504: Revisiting in-place tag types for any/optional/variant
• P0505: Wording for GB 50 - constexpr for chrono
• P0508: Wording for GB 58 - structured bindings for node_handles
• P0509: Updating "Restrictions on exception handling"
• P0510: Disallowing references, incomplete types, arrays, and empty variants
• P0513: Poisoning the Hash
• P0516: Clarify That shared_future's Copy Operations have Wide Contracts
• P0517: Make future_error Constructible
• P0521: Proposed Resolution for CA 14 (shared_ptr use_count/unique)
• P0156: Variadic Lock guard(rev 5)
• P0270: Removing C dependencies from signal handler wording
• P0298: A byte type definition
• P0317: Directory Entry Caching for Filesystem
• P0430: File system library on non-POSIX-like operating systems
• P0433: Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library
• P0452: Unifying <numeric> Parallel Algorithms
• P0467: Iterator Concerns for Parallel Algorithms
• P0492: Proposed Resolution of C++17 National Body Comments for Filesystems
• P0518: Allowing copies as arguments to function objects given to parallel algorithms in response to CH11
• P0523: Wording for CH 10: Complexity of parallel algorithms
• P0548: common_type and duration
• P0558: Resolving atomic<T> named base class inconsistencies
• P0574: Algorithm Complexity Constraints and Parallel Overloads
• P0599: noexcept for hash functions
• P0604: Resolving GB 55, US 84, US 85, US 86
• P0607: Inline Variables for the Standard Library
• P0618: Deprecating <codecvt>
• P0623: Final C++17 Parallel Algorithms Fixes
• P0682: Repairing elementary string conversions
• P0739: Some improvements to class template argument deduction integration into the standard library

Issues

• LWG2016: Allocators must be no-throw swappable
• LWG2118: unique_ptr for array does not support cv qualification conversion of actual argument
• LWG2170: Aggregates cannot be DefaultConstructible
• LWG2308: Clarify container destructor requirements w.r.t. std::array
• LWG2340: Replacement allocation functions declared as inline
• LWG2354: Unnecessary copying when inserting into maps with braced-init syntax
• LWG2377: std::align requirements overly strict
• LWG2396: underlying_type doesn't say what to do for an incomplete enumeration type
• LWG2399: shared_ptr's constructor from unique_ptr should be constrained
• LWG2400: shared_ptr's get_deleter() should use addressof()
• LWG2401: std::function needs more noexcept
• LWG2404: mismatch()'s complexity needs to be updated
• LWG2408: SFINAE-friendly common_type / iterator_traits is missing in C++14
• LWG2106: move_iterator wrapping iterators returning prvalues
• LWG2129: User specializations of std::initializer_list
• LWG2212: tuple_size for const pair request header
• LWG2217: operator==(sub_match, string) slices on embedded '\0's
• LWG2230: "see below" for initializer_list constructors of unordered containers
• LWG2233: bad_function_call::what() unhelpful
• LWG2266: vector and deque have incorrect insert requirements
• LWG2325: minmax_element()'s behavior differing from max_element()'s should be noted
• LWG2361: Apply 2299 resolution throughout library
• LWG2365: Missing noexcept in shared_ptr::shared_ptr(nullptr_t)
• LWG2376: bad_weak_ptr::what() overspecified
• LWG2387: More nested types that must be accessible and unambiguous
• LWG2059: C++0x ambiguity problem with map::erase
• LWG2063: Contradictory requirements for string move assignment
• LWG2076: Bad CopyConstructible requirement in set constructors
• LWG2160: Unintended destruction ordering-specification of resize
• LWG2168: Inconsistent specification of uniform_real_distribution constructor
• LWG2239: min/max/minmax requirements
• LWG2364: deque and vector pop_back don't specify iterator invalidation requirements
• LWG2369: constexpr max(initializer_list) vs max_element
• LWG2378: Behaviour of standard exception types
• LWG2403: stof() should call strtof() and wcstof()
• LWG2406: negative_binomial_distribution should reject p == 1
• LWG2407: packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit
• LWG2411: shared_ptr is only contextually convertible to bool
• LWG2415: Inconsistency between unique_ptr and shared_ptr
• LWG2420: function<void(ArgTypes...)> does not discard the return value of the target object
• LWG2425: operator delete(void*, size_t) doesn't invalidate pointers sufficiently
• LWG2427: Container adaptors as sequence containers, redux
• LWG2428: "External declaration" used without being defined
• LWG2433: uninitialized_copy()/etc. should tolerate overloaded operator&
• LWG2434: shared_ptr::use_count() is efficient
• LWG2437: iterator_traits::reference can and can't be void
• LWG2438: std::iterator inheritance shouldn't be mandated
• LWG2439: unique_copy() sometimes can't fall back to reading its output
• LWG2440: seed_seq::size() should be noexcept
• LWG2442: call_once() shouldn't DECAY_COPY()
• LWG2448: Non-normative Container destructor specification
• LWG2454: Add raw_storage_iterator::base() member
• LWG2455: Allocator default construction should be allowed to throw
• LWG2458: N3778 and new library deallocation signatures
• LWG2459: std::polar should require a non-negative rho
• LWG2464: try_emplace and insert_or_assign misspecified
• LWG2467: is_always_equal has slightly inconsistent default
• LWG2470: Allocator's destroy function should be allowed to fail to instantiate
• LWG2482: [c.strings] Table 73 mentions nonexistent functions
• LWG2488: Placeholders should be allowed and encouraged to be constexpr
• LWG1169: num_get not fully compatible with strto*
• LWG2072: Unclear wording about capacity of temporary buffers
• LWG2101: Some transformation types can produce impossible types
• LWG2111: Which unexpected/terminate handler is called from the exception handling runtime?
• LWG2119: Missing hash specializations for extended integer types
• LWG2127: Move-construction with raw_storage_iterator
• LWG2133: Attitude to overloaded comma for iterators
• LWG2156: Unordered containers' reserve(n) reserves for n-1 elements
• LWG2218: Unclear how containers use allocator_traits::construct()
• LWG2219: INVOKE-ing a pointer to member with a reference_wrapper as the object expression
• LWG2224: Ambiguous status of access to non-live objects
• LWG2234: assert() should allow usage in constant expressions
• LWG2244: Issue on basic_istream::seekg
• LWG2250: Follow-up On Library Issue 2207
• LWG2259: Issues in 17.6.5.5 rules for member functions
• LWG2273: regex_match ambiguity
• LWG2336: is_trivially_constructible/is_trivially_assignable traits are always false
• LWG2353: std::next is over-constrained
• LWG2367: pair and tuple are not correctly implemented for is_constructible with no args
• LWG2380: May <cstdlib> provide long ::abs(long) and long long ::abs(long long)?
• LWG2384: Allocator's deallocate function needs better specification
• LWG2385: function::assign allocator argument doesn't make sense
• LWG2435: reference_wrapper::operator()'s Remark should be deleted
• LWG2447: Allocators and volatile-qualified value types
• LWG2462: std::ios_base::failure is overspecified
• LWG2466: allocator_traits::max_size() default behavior is incorrect
• LWG2469: Wrong specification of Requires clause of operator[] for map and unordered_map
• LWG2473: basic_filebuf's relation to C FILE semantics
• LWG2476: scoped_allocator_adaptor is not assignable
• LWG2477: Inconsistency of wordings in std::vector::erase() and std::deque::erase()
• LWG2483: throw_with_nested() should use is_final
• LWG2484: rethrow_if_nested() is doubly unimplementable
• LWG2485: get() should be overloaded for const tuple&&
• LWG2486: mem_fn() should be required to use perfect forwarding
• LWG2487: bind() should be const-overloaded, not cv-overloaded
• LWG2489: mem_fn() should be noexcept
• LWG2492: Clarify requirements for comp
• LWG2495: There is no such thing as an Exception Safety element
• LWG2192: Validity and return type of std::abs(0u) is unclear
• LWG2276: Missing requirement on std::promise::set_exception
• LWG2296: std::addressof should be constexpr
• LWG2450: (greater|less|greater_equal|less_equal)<void> do not yield a total order for pointers
• LWG2520: N4089 broke initializing unique_ptr<T[]> from a nullptr
• LWG2523: std::promise synopsis shows two set_value_at_thread_exit()'s for no apparent reason
• LWG2537: Constructors for priority_queue taking allocators should call make_heap
• LWG2545: Simplify wording for bind without explicitly specified return type
• LWG2557: Logical operator traits are broken in the zero-argument case
• LWG2559: Error in LWG 2234's resolution
• LWG2560: is_constructible underspecified when applied to a function type
• LWG2565: std::function's move constructor should guarantee nothrow for reference_wrappers and function pointers
• LWG2566: Requirements on the first template parameter of container adaptors
• LWG2571: [map.modifiers]/2 imposes nonsensical requirement on insert(InputIterator, InputIterator)
• LWG2572: The remarks for shared_ptr::operator* should apply to cv-qualified void as well
• LWG2576: istream_iterator and ostream_iterator should use std::addressof
• LWG2577: {shared,unique}_lock should use std::addressof
• LWG2579: Inconsistency wrt Allocators in basic_string assignment vs. basic_string::assign
• LWG2581: Specialization of <type_traits> variable templates should be prohibited
• LWG2582: [res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits
• LWG2583: There is no way to supply an allocator for basic_string(str, pos)
• LWG2585: forward_list::resize(size_type, const value_type&) effects incorrect
• LWG2586: Wrong value category used in scoped_allocator_adaptor::construct()
• LWG2590: Aggregate initialization for std::array
• LWG2181: Exceptions from seed sequence operations
• LWG2309: mutex::lock() should not throw device_or_resource_busy
• LWG2310: Public exposition only member in std::array
• LWG2312: tuple's constructor constraints need to be phrased more precisely
• LWG2328: Rvalue stream extraction should use perfect forwarding
• LWG2393: std::function's Callable definition is broken
• LWG2422: std::numeric_limits<T>::is_modulo description: "most machines" errata
• LWG2426: Issue about compare_exchange
• LWG2436: Comparators for associative containers should always be CopyConstructible
• LWG2441: Exact-width atomic typedefs should be provided
• LWG2451: [fund.ts.v2] optional<T> should forward T's implicit conversions
• LWG2542: Missing const requirements for associative containers
• LWG2549: Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references
• LWG2550: Wording of unordered container's clear() method complexity
• LWG2596: vector::data() should use addressof
• LWG2667: path::root_directory() description is confusing
• LWG2669: recursive_directory_iterator effects refers to non-existent functions
• LWG2670: system_complete refers to undefined variable 'base'
• LWG2671: Errors in Copy
• LWG2673: status() effects cannot be implemented as specified
• LWG2674: Bidirectional iterator requirement on path::iterator is very expensive
• LWG2683: filesystem::copy() says "no effects"
• LWG2684: priority_queue lacking comparator typedef
• LWG2685: shared_ptr deleters must not throw on move construction
• LWG2687: {inclusive,exclusive}_scan misspecified
• LWG2688: clamp misses preconditions and has extraneous condition on result
• LWG2689: Parallel versions of std::copy and std::move shouldn't be in order
• LWG2698: Effect of assign() on iterators/pointers/references
• LWG2704: recursive_directory_iterator's members should require '*this is dereferenceable'
• LWG2706: Error reporting for recursive_directory_iterator::pop() is under-specified
• LWG2707: path construction and assignment should have string_type&& overloads
• LWG2709: offsetof is unnecessarily imprecise
• LWG2710: "Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics
• LWG2711: path is convertible from approximately everything under the sun
• LWG2716: Specification of shuffle and sample disallows lvalue URNGs
• LWG2718: Parallelism bug in [algorithms.parallel.exec] p2
• LWG2719: permissions function should not be noexcept due to narrow contract
• LWG2720: permissions function incorrectly specified for symlinks
• LWG2721: remove_all has incorrect post conditions
• LWG2723: Do directory_iterator and recursive_directory_iterator become the end iterator upon error?
• LWG2724: The protected virtual member functions of memory_resource should be private
• LWG2725: filesystem::exists(const path&, error_code&) error reporting
• LWG2726: [recursive_]directory_iterator::increment(error_code&) is underspecified
• LWG2727: Parallel algorithms with constexpr specifier
• LWG2728: status(p).permissions() and symlink_status(p).permissions() are not specified
• LWG2062: Effect contradictions w/o no-throw guarantee of std::function swaps
• LWG2166: Heap property underspecified?
• LWG2221: No formatted output operator for nullptr
• LWG2223: shrink_to_fit effect on iterator validity
• LWG2261: Are containers required to use their 'pointer' type internally?
• LWG2394: locale::name specification unclear - what is implementation-defined?
• LWG2460: LWG issue 2408 and value categories
• LWG2468: Self-move-assignment of library types
• LWG2475: Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs
• LWG2503: multiline option should be added to syntax_option_type
• LWG2510: Tag types should not be DefaultConstructible
• LWG2514: Type traits must not be final
• LWG2519: Iterator operator-= has gratuitous undefined behaviour
• LWG2531: future::get should explicitly state that the shared state is released
• LWG2534: Constrain rvalue stream operators
• LWG2536: What should <complex.h> do?
• LWG2540: unordered_multimap::insert hint iterator
• LWG2543: LWG 2148 (hash support for enum types) seems under-specified
• LWG2544: istreambuf_iterator(basic_streambuf* s) effects unclear when s is 0
• LWG2556: Wide contract for future::share()
• LWG2562: Consistent total ordering of pointers by comparison functors
• LWG2567: Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits
• LWG2569: conjunction and disjunction requirements are too strict
• LWG2578: Iterator requirements should reference iterator traits
• LWG2584: <regex> ECMAScript IdentityEscape is ambiguous
• LWG2587: "Convertible to bool" requirement in conjunction and disjunction
• LWG2589: match_results can't satisfy the requirements of a container
• LWG2591: std::function's member template target() should not lead to undefined behaviour
• LWG2598: addressof works on temporaries
• LWG2664: operator/ (and other append) semantics not useful if argument has root
• LWG2665: remove_filename() post condition is incorrect
• LWG2672: Should is_empty use error_code in its specification?
• LWG2678: std::filesystem enum classes overspecified
• LWG2679: Inconsistent Use of Effects and Equivalent To
• LWG2680: Add "Equivalent to" to filesystem
• LWG2681: filesystem::copy() cannot copy symlinks
• LWG2682: filesystem::copy() won't create a symlink to a directory
• LWG2686: Why is std::hash specialized for error_code, but not error_condition?
• LWG2694: Application of LWG 436 accidentally deleted definition of "facet"
• LWG2696: Interaction between make_shared and enable_shared_from_this is underspecified
• LWG2699: Missing restriction in [numeric.requirements]
• LWG2712: copy_file(from, to, ...) has a number of unspecified error conditions
• LWG2722: equivalent incorrectly specifies throws clause
• LWG2729: Missing SFINAE on std::pair::operator=
• LWG2732: Questionable specification of path::operator/= and path::append
• LWG2735: std::abs(short), std::abs(signed char) and others should return int instead of double in order to be compatible with C++98 and C
• LWG2736: nullopt_t insufficiently constrained
• LWG2738: is_constructible with void types
• LWG2739: Issue with time_point non-member subtraction with an unsigned duration
• LWG2740: constexpr optional::operator->
• LWG2742: Inconsistent string interface taking string_view
• LWG2744: any's in_place constructors
• LWG2747: Possibly redundant std::move in [alg.foreach]
• LWG2748: swappable traits for optionals
• LWG2749: swappable traits for variants
• LWG2752: "Throws:" clauses of async and packaged_task are unimplementable
• LWG2755: [string.view.io] uses non-existent basic_string_view::to_string function
• LWG2756: C++ WP optional should forward T's implicit conversions
• LWG2758: std::string{}.assign("ABCDE", 0, 1) is ambiguous
• LWG2759: gcd / lcm and bool for the WP
• LWG2760: non-const basic_string::data should not invalidate iterators
• LWG2765: Did LWG 1123 go too far?
• LWG2767: not_fn call_wrapper can form invalid types
• LWG2769: Redundant const in the return type of any_cast(const any&)
• LWG2771: Broken Effects of some basic_string::compare functions in terms of basic_string_view
• LWG2773: Making std::ignore constexpr
• LWG2777: basic_string_view::copy should use char_traits::copy
• LWG2778: basic_string_view is missing constexpr
• LWG2260: Missing requirement for Allocator::pointer
• LWG2676: Provide filesystem::path overloads for File-based streams
• LWG2768: any_cast and move semantics
• LWG2769: Redundant const in the return type of any_cast(const any&)
• LWG2781: Contradictory requirements for std::function and std::reference_wrapper
• LWG2782: scoped_allocator_adaptor constructors must be constrained
• LWG2784: Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse
• LWG2785: quoted should work with basic_string_view
• LWG2786: Annex C should mention shared_ptr changes for array support
• LWG2787: [file_status.cons] doesn't match class definition
• LWG2788: basic_string range mutators unintentionally require a default constructible allocator
• LWG2789: Equivalence of contained objects
• LWG2790: Missing specification of istreambuf_iterator::operator->
• LWG2794: Missing requirements for allocator pointers
• LWG2795: [global.functions] provides incorrect example of ADL use
• LWG2796: tuple should be a literal type
• LWG2801: Default-constructibility of unique_ptr
• LWG2802: shared_ptr constructor requirements for a deleter
• LWG2804: Unconditional constexpr default constructor for istream_iterator
• LWG2806: Base class of bad_optional_access
• LWG2807: std::invoke should use std::is_nothrow_callable
• LWG2812: Range access is available with <string_view>
• LWG2824: list::sort should say that the order of elements is unspecified if an exception is thrown
• LWG2826: string_view iterators use old wording
• LWG2834: Resolution LWG 2223 is missing wording about end iterators
• LWG2835: LWG 2536 seems to misspecify <tgmath.h>
• LWG2837: gcd and lcm should support a wider range of input values
• LWG2838: is_literal_type specification needs a little cleanup
• LWG2842: in_place_t check for optional::optional(U&&) should decay U
• LWG2850: std::function move constructor does unnecessary work
• LWG2853: Possible inconsistency in specification of erase in [vector.modifiers]
• LWG2855: std::throw_with_nested("string_literal")
• LWG2857: {variant,optional,any}::emplace should return the constructed value
• LWG2861: basic_string should require that charT match traits::char_type
• LWG2866: Incorrect derived classes constraints
• LWG2868: Missing specification of bad_any_cast::what()
• LWG2872: Add definition for direct-non-list-initialization
• LWG2873: Add noexcept to several shared_ptr related functions
• LWG2874: Constructor shared_ptr::shared_ptr(Y*) should be constrained
• LWG2875: shared_ptr::shared_ptr(Y*, D, [...]) constructors should be constrained
• LWG2876: shared_ptr::shared_ptr(const weak_ptr<Y>&) constructor should be constrained
• LWG2878: Missing DefaultConstructible requirement for istream_iterator default constructor
• LWG2890: The definition of 'object state' applies only to class types
• LWG2900: The copy and move constructors of optional are not constexpr
• LWG2903: The form of initialization for the emplace-constructors is not specified
• LWG2904: Make variant move-assignment more exception safe
• LWG2905: is_constructible_v<unique_ptr<P, D>, P, D const &> should be false when D is not copy constructible
• LWG2908: The less-than operator for shared pointers could do more
• LWG2911: An is_aggregate type trait is needed
• LWG2921: packaged_task and type-erased allocators
• LWG2934: optional<const T> doesn't compare with T
• LWG2901: Variants cannot properly support allocators
• LWG2955: to_chars / from_chars depend on std::string (P0682R1)
• LWG2956: filesystem::canonical() still defined in terms of absolute(p, base)

C++2a

Papers

• P0463: endian, just endian
• P0674: Extending make_shared to Support Arrays
• P0020: Floating Point Atomic
• P0053: C++ Synchronized Buffered Ostream
• P0202: Add constexpr modifiers to functions in <algorithm> and <utility> Headers
• P0415: Constexpr for std::complex
• P0439: Make std::memory_order a scoped enumeration
• P0457: String Prefix and Suffix Checking
• P0550: Transformation Trait remove_cvref
• P0600: nodiscard in the Library
• P0616: de-pessimize legacy algorithms with std::move
• P0653: Utility to convert a pointer to a raw pointer
• P0718: Atomic shared_ptr
• P0767: Deprecate POD
• P0768: Library Support for the Spaceship (Comparison) Operator
• P0777: Treating Unnecessary decay
• P0122: <span>
• P0355: Extending chrono to Calendars and Time Zones
• P0551: Thou Shalt Not Specialize std Function Templates!
• P0753: Manipulators for C++ Synchronized Buffered Ostream
• P0754: <version>
• P0809: Comparing Unordered Containers
• P0858: Constexpr iterator requirements
• P0905: Symmetry for spaceship
• P0966: string::reserve Should Not Shrink
• P0019: Atomic Ref
• P0458: Checking for Existence of an Element in Associative Containers
• P0475: LWG 2511: guaranteed copy elision for piecewise construction
• P0476: Bit-casting object representations
• P0528: The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange
• P0542: Support for contract based programming in C++
• P0556: Integral power-of-2 operations
• P0619: Reviewing Deprecated Facilities of C++17 for C++20
• P0646: Improving the Return Value of Erase-Like Algorithms
• P0722: Efficient sized delete for variable sized classes
• P0758: Implicit conversion traits and utility functions
• P0759: fpos Requirements
• P0769: Add shift to <algorithm>
• P0788: Standard Library Specification in a Concepts and Contracts World
• P0879: Constexpr for swap and swap related functions Also resolves LWG issue 2800.
• P0887: The identity metafunction
• P0892: explicit(bool)
• P0898: Standard Library Concepts
• P0935: Eradicating unnecessarily explicit default constructors from the standard library
• P0941: Integrating feature-test macros into the C++ WD
• P1023: constexpr comparison operators for std::array
• P1025: Update The Reference To The Unicode Standard
• P1120: Consistency improvements for <=> and other comparison operators
• P0318: unwrap_ref_decay and unwrap_reference
• P0356: Simplified partial function application
• P0357: reference_wrapper for incomplete types
• P0482: char8_t: A type for UTF-8 characters and strings
• P0487: Fixing operator>>(basic_istream&, CharT*) (LWG 2499)
• P0591: Utility functions to implement uses-allocator construction
• P0595: std::is_constant_evaluated()
• P0602: variant and optional should propagate copy/move triviality
• P0608: A sane variant converting constructor
• P0655: visit<R>: Explicit Return Type for visit
• P0771: std::function move constructor should be noexcept
• P0896: The One Ranges Proposal
• P0899: LWG 3016 is not a defect
• P0919: Heterogeneous lookup for unordered containers
• P0972: <chrono> zero(), min(), and max() should be noexcept
• P1006: Constexpr in std::pointer_traits
• P1007: std::assume_aligned
• P1020: Smart pointer creation with default initialization
• P1032: Misc constexpr bits
• P1085: Should Span be Regular?
• P1123: Editorial Guidance for merging P0019r8 and P0528r3
• P1148: Cleaning up Clause 20
• P1165: Make stateful allocator propagation more consistent for operator+(basic_string)
• P1209: Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20
• P1236: Alternative Wording for P0907R4 Signed Integers are Two's Complement
• P1248: Remove CommonReference requirement from StrictWeakOrdering (a.k.a Fixing Relations)
• P1285: Improving Completeness Requirements for Type Traits
• P1353: Missing feature test macros

Issues

• LWG2070: allocate_shared should use allocator_traits<A>::construct (P0674R1)
• LWG2444: Inconsistent complexity for std::sort_heap
• LWG2593: Moved-from state of Allocators
• LWG2597: std::log misspecified for complex numbers
• LWG2783: stack::emplace() and queue::emplace() should return decltype(auto)
• LWG2932: Constraints on parallel algorithm implementations are underspecified
• LWG2937: Is equivalent("existing_thing", "not_existing_thing") an error
• LWG2940: result_of specification also needs a little cleanup
• LWG2942: LWG 2873's resolution missed weak_ptr::owner_before
• LWG2954: Specialization of the convenience variable templates should be prohibited
• LWG2961: Bad postcondition for set_default_resource
• LWG2966: Incomplete resolution of US 74
• LWG2974: Diagnose out of bounds tuple_element/variant_alternative
• LWG2870: Default value of parameter theta of polar should be dependent
• LWG2935: What should create_directories do when p already exists but is not a directory?
• LWG2941: [thread.req.timing] wording should apply to both member and namespace-level functions
• LWG2944: LWG 2905 accidentally removed requirement that construction of the deleter doesn't throw an exception
• LWG2945: Order of template parameters in optional comparisons
• LWG2948: unique_ptr does not define operator<< for stream output
• LWG2950: std::byte operations are misspecified
• LWG2952: iterator_traits should work for pointers to cv T
• LWG2953: LWG 2853 should apply to deque::erase too
• LWG2958: Moves improperly defined as deleted
• LWG2964: Apparently redundant requirement for dynamic_pointer_cast
• LWG2965: Non-existing path::native_string() in filesystem_error::what() specification
• LWG2972: What is is_trivially_destructible_v?
• LWG2976: Dangling uses_allocator specialization for packaged_task
• LWG2977: unordered_meow::merge() has incorrect Throws: clause
• LWG2978: Hash support for pmr::string and friends
• LWG2979: aligned_union should require object types
• LWG2980: Cannot compare_exchange empty pointers
• LWG2981: Remove redundant deduction guides from standard library
• LWG2982: Making size_type consistent in associative container deduction guides
• LWG2988: Clause 32 cleanup missed one typename
• LWG2993: reference_wrapper conversion from T&&
• LWG2998: Requirements on function objects passed to {forward_,}list-specific algorithms
• LWG3001: weak_ptr::element_type needs remove_extent_t
• LWG3024: variant's copies must be deleted instead of disabled via SFINAE
• LWG2164: What are the semantics of vector.emplace(vector.begin(), vector.back())?
• LWG2243: istream::putback problem
• LWG2816: resize_file has impossible postcondition
• LWG2843: Unclear behavior of std::pmr::memory_resource::do_allocate()
• LWG2849: Why does !is_regular_file(from) cause copy_file to report a "file already exists" error?
• LWG2851: std::filesystem enum classes are now underspecified
• LWG2946: LWG 2758's resolution missed further corrections
• LWG2969: polymorphic_allocator::construct() shouldn't pass resource()
• LWG2975: Missing case for pair construction in scoped and polymorphic allocators
• LWG2989: path's stream insertion operator lets you insert everything under the sun
• LWG3000: monotonic_memory_resource::do_is_equal uses dynamic_cast unnecessarily
• LWG3004: string.capacity and vector.capacity should specify time complexity for capacity()
• LWG3005: Destruction order of arrays by make_shared/allocate_shared only recommended?
• LWG3007: allocate_shared should rebind allocator to cv-unqualified value_type for construction
• LWG3009: Including <string_view> doesn't provide std::size/empty/data
• LWG3013: (recursive_)directory_iterator construction and traversal should not be noexcept
• LWG3014: More noexcept issues with filesystem operations
• LWG3015: copy_options::unspecified underspecified
• LWG3017: list splice functions should use addressof
• LWG3026: filesystem::weakly_canonical still defined in terms of canonical(p, base)
• LWG3030: Who shall meet the requirements of try_lock?
• LWG3034: P0767R1 breaks previously-standard-layout types
• LWG3035: std::allocator's constructors should be constexpr
• LWG3039: Unnecessary decay in thread and packaged_task
• LWG3041: Unnecessary decay in reference_wrapper
• LWG3043: Bogus postcondition for filesystem_error constructor
• LWG3045: atomic<floating-point> doesn't have value_type or difference_type
• LWG3048: transform_reduce(exec, first1, last1, first2, init) discards execution policy
• LWG3051: Floating point classifications were inadvertently changed in P0175
• LWG3075: basic_string needs deduction guides from basic_string_view
• LWG2139: What is a user-defined type?
• LWG2970: Return type of std::visit misspecified
• LWG3058: Parallel adjacent_difference shouldn't require creating temporaries
• LWG3062: Unnecessary decay_t in is_execution_policy_v should be remove_cvref_t
• LWG3067: recursive_directory_iterator::pop must invalidate
• LWG3074: Non-member functions for valarray should only deduce from the valarray
• LWG3076: basic_string CTAD ambiguity
• LWG3079: LWG 2935 forgot to fix the existing_p overloads of create_directory
• LWG3080: Floating point from_chars pattern specification breaks round-tripping
• LWG3083: What should ios::iword(-1) do?
• LWG3094: [time.duration.io]p4 makes surprising claims about encoding
• LWG3100: Unnecessary and confusing "empty span" wording
• LWG3102: Clarify span iterator and const_iterator behavior
• LWG3104: Fixing duration division
• LWG2183: Muddled allocator requirements for match_results constructors
• LWG2184: Muddled allocator requirements for match_results assignments
• LWG2412: promise::set_value() and promise::get_future() should not race
• LWG2499: operator>>(basic_istream&, CharT*) makes it hard to avoid buffer overflows
• LWG2682: filesystem::copy() won't create a symlink to a directory
• LWG2797: Trait precondition violations
• LWG2936: Path comparison is defined in terms of the generic format
• LWG2943: Problematic specification of the wide version of basic_filebuf::open
• LWG2995: basic_stringbuf default constructor forbids it from using SSO capacity
• LWG2996: Missing rvalue overloads for shared_ptr operations
• LWG3008: make_shared (sub)object destruction semantics are not specified
• LWG3022: is_convertible<derived*, base*> may lead to ODR
• LWG3025: Map-like container deduction guides should use pair<Key, T>, not pair<const Key, T>
• LWG3031: Algorithms and predicates with non-const reference arguments
• LWG3037: polymorphic_allocator and incomplete types
• LWG3038: polymorphic_allocator::allocate should not allow integer overflow to create vulnerabilities
• LWG3054: uninitialized_copy appears to not be able to meet its exception-safety guarantee
• LWG3065: LWG 2989 missed that all path's other operators should be hidden friends as well
• LWG3096: path::lexically_relative is confused by trailing slashes
• LWG3116: OUTERMOST_ALLOC_TRAITS> needs remove_reference_t
• LWG3122: __cpp_lib_chrono_udls was accidentally dropped
• LWG3127: basic_osyncstream::rdbuf needs a const_cast
• LWG3128: strstream::rdbuf needs a const_cast
• LWG3129: regex_token_iterator constructor uses wrong pointer arithmetic
• LWG3130: [input.output] needs many addressof
• LWG3131: addressof all the things
• LWG3132: Library needs to ban macros named expects or ensures
• LWG3137: Header for __cpp_lib_to_chars
• LWG3145: file_clock breaks ABI for C++17 implementations
• LWG3147: Definitions of "likely" and "unlikely" are likely to cause problems
• LWG3148: <concepts> should be freestanding
• LWG3153: Common and common_type have too little in common
• LWG3154: Common and CommonReference have a common defect