Skip to content

STATUS.md

Latest commit

 

History

History
847 lines (817 loc) · 74.2 KB

STATUS.md

File metadata and controls

847 lines (817 loc) · 74.2 KB

SLB

C++ Standard Library Backport

travis appveyor license

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