ID Title
1 C library linkage editing oversight
2 Auto_ptr conversions effects incorrect
3 Atexit registration during atexit() call is not described
4 basic_string size_type and difference_type should be implementation defined
5 String::compare specification questionable
6 File position not an offset unimplementable
7 String clause minor problems
8 Locale::global lacks guarantee
9 Operator new(0) calls should not yield the same pointer
10 Codecvt<>::do unclear
11 Bitset minor problems
12 Way objects hold allocators unclear
13 Eos refuses to die
14 Locale::combine should be const
15 Locale::name requirement inconsistent
16 Bad ctype_byname<char> decl
17 Bad bool parsing
18 Get(...bool&) omitted
19 "Noconv" definition too vague
20 Thousands_sep returns wrong type
21 Codecvt_byname<> instantiations
22 Member open vs. flags
23 Num_get overflow result
24 "do_convert" doesn't exist
25 String operator<< uses width() value wrong
26 Bad sentry example
27 String::erase(range) yields wrong iterator
28 Ctype<char>is ambiguous
29 Ios_base::init doesn't exist
30 Wrong header for LC_*
31 Immutable locale values
32 Pbackfail description inconsistent
33 Codecvt<> mentions from_type
34 True/falsename() not in ctype<>
35 No manipulator unitbuf in synopsis
36 Iword & pword storage lifetime omitted
37 Leftover "global" reference
38 Facet definition incomplete
39 istreambuf_iterator<>::operator++(int) definition garbled
40 Meaningless normative paragraph in examples
41 Ios_base needs clear(), exceptions()
42 String ctors specify wrong default allocator
43 Locale table correction
44 Iostreams use operator== on int_type values
45 Stringstreams read/write pointers initial position unclear
46 Minor Annex D errors
47 Imbue() and getloc() Returns clauses swapped
48 Use of non-existent exception constructor
49 Underspecification of ios_base::sync_with_stdio
50 Copy constructor and assignment operator of ios_base
51 Requirement to not invalidate iterators missing
52 Small I/O problems
53 Basic_ios destructor unspecified
54 Basic_streambuf's destructor
55 Invalid stream position is undefined
56 Showmanyc's return type
57 Mistake in char_traits
58 Extracting a char from a wide-oriented stream
59 Ambiguity in specification of gbump
60 What is a formatted input function?
61 Ambiguity in iostreams exception policy
62 Sync's return value
63 Exception-handling policy for unformatted output
64 Exception handling in basic_istream::operator>>(basic_streambuf*)
65 Underspecification of strstreambuf::seekoff
66 Strstreambuf::setbuf
67 Setw useless for strings
68 Extractors for char* should store null at end
69 Must elements of a vector be contiguous?
70 Uncaught_exception() missing throw() specification
71 Do_get_monthname synopsis missing argument
72 Do_convert phantom member function
73 is_open should be const
74 Garbled text for codecvt::do_max_length
75 Contradiction in codecvt::length's argument types
76 Can a codecvt facet always convert one internal character at a time?
77 Valarray operator[] const returning value
78 Typo: event_call_back
79 Inconsistent declaration of polar()
80 Global Operators of complex declared twice
81 Wrong declaration of slice operations
82 Missing constant for set elements
83 String::npos vs. string::max_size()
84 Ambiguity with string::insert()
85 String char types
86 String constructors don't describe exceptions
87 Error in description of string::compare()
88 Inconsistency between string::insert() and string::append()
89 Missing throw specification for string::insert() and string::replace()
90 Incorrect description of operator >> for strings
91 Description of operator>> and getline() for string<> might cause endless loop
92 Incomplete Algorithm Requirements
93 Incomplete Valarray Subset Definitions
94 May library implementors add template parameters to Standard Library classes?
95 Members added by the implementation
96 Vector<bool> is not a container
97 Insert inconsistent definition
98 Input iterator requirements are badly written
99 Reverse_iterator comparisons completely wrong
100 Insert iterators/ostream_iterators overconstrained
101 No way to free storage for vector and deque
102 Bug in insert range in associative containers
103 set::iterator is required to be modifiable, but this allows modification of keys
104 Description of basic_string::operator[] is unclear
105 fstream ctors argument types desired
106 Numeric library private members are implementation defined
107 Valarray constructor is strange
108 Lifetime of exception::what() return unspecified
109 Missing binders for non-const sequence elements
110 istreambuf_iterator::equal not const
111 istreambuf_iterator::equal overspecified, inefficient
112 Minor typo in ostreambuf_iterator constructor
113 Missing/extra iostream sync semantics
114 Placement forms example in error twice
115 Typo in strstream constructors
116 bitset cannot be constructed with a const char*
117 basic_ostream uses nonexistent num_put member functions
118 basic_istream uses nonexistent num_get member functions
119 Should virtual functions be allowed to strengthen the exception specification?
120 Can an implementor add specializations?
121 Detailed definition for ctype<wchar_t> specialization
122 streambuf/wstreambuf description should not say they are specializations
123 Should valarray helper arrays fill functions be const?
124 ctype_byname<charT>::do_scan_is & do_scan_not return type should be const charT*
125 valarray<T>::operator!() return type is inconsistent
126 typos in Effects clause of ctype::do_narrow()
127 auto_ptr<> conversion issues
128 Need open_mode() function for file stream, string streams, file buffers, and string  buffers
129 Need error indication from seekp() and seekg()
130 Return type of container::erase(iterator) differs for associative containers
131 list::splice throws nothing
132 list::resize description uses random access iterators
133 map missing get_allocator()
134 vector constructors over specified
135 basic_iostream doubly initialized
136 seekp, seekg setting wrong streams?
137 Do use_facet and has_facet look in the global locale?
138 Class ctype_byname<char> redundant and misleading
139 Optional sequence operation table description unclear
140 map<Key, T>::value_type does not satisfy the assignable requirement
141 basic_string::find_last_of, find_last_not_of say pos instead of xpos
142 lexicographical_compare complexity wrong
143 C .h header wording unclear
144 Deque constructor complexity wrong
145 adjustfield lacks default value
146 complex<T> Inserter and Extractor need sentries
147 Library Intro refers to global functions that aren't global
148 Functions in the example facet BoolNames should be const
149 Insert should return iterator to first element inserted
150 Find_first_of says integer instead of iterator
151 Can't currently clear() empty container
152 Typo in scan_is() semantics
153 Typo in narrow() semantics
154 Missing double specifier for do_get()
155 Typo in naming the class defining the class Init
156 Typo in imbue() description
157 Meaningless error handling for pword() and iword()
158 Underspecified semantics for setbuf()
159 Strange use of underflow()
160 Typo: Use of non-existing function exception()
161 Typo: istream_iterator vs. istreambuf_iterator
162 Really "formatted input functions"?
163 Return of gcount() after a call to gcount
164 do_put() has apparently unused fill argument
165 xsputn(), pubsync() never called by basic_ostream members?
166 Really "formatted output functions"?
167 Improper use of traits_type::length()
168 Typo: formatted vs. unformatted
169 Bad efficiency of overflow() mandated
170 Inconsistent definition of traits_type
171 Strange seekpos() semantics due to joint position
172 Inconsistent types for basic_istream::ignore()
173 Inconsistent types for basic_filebuf::setbuf()
174 Typo: OFF_T vs. POS_T
175 Ambiguity for basic_streambuf::pubseekpos() and a few other functions.
176 exceptions() in ios_base...?
177 Complex operators cannot be explicitly instantiated
178 Should clog and cerr initially be tied to cout?
179 Comparison of const_iterators to iterators doesn't work
180 Container member iterator arguments constness has unintended consequences
181 make_pair() unintended behavior
182 Ambiguous references to size_t
183 I/O stream manipulators don't work for wide character streams
184 numeric_limits<bool> wording problems
185 Questionable use of term "inline"
186 bitset::set() second parameter should be bool
187 iter_swap underspecified
188 valarray helpers missing augmented assignment operators
189 setprecision() not specified correctly
190 min() and max() functions should be std::binary_functions
191 Unclear complexity for algorithms such as binary search
192 a.insert(p,t) is inefficient and overconstrained
193 Heap operations description incorrect
194 rdbuf() functions poorly specified
195 Should basic_istream::sentry's constructor ever set eofbit?
196 Placement new example has alignment problems
197 max_size() underspecified
198 Validity of pointers and references unspecified after iterator destruction
199 What does allocate(0) return?
200 Forward iterator requirements don't allow constant iterators
201 Numeric limits terminology wrong
202 unique() effects unclear when predicate not an equivalence relation
203 basic_istream::sentry::sentry() is uninstantiable with ctype<user-defined type>
204 distance(first, last) when "last" is before "first"
205 numeric_limits unclear on how to determine floating point types
206 operator new(size_t, nothrow) may become unlinked to ordinary operator new if ordinary version replaced
207 ctype<char> members return clause incomplete
208 Unnecessary restriction on past-the-end iterators
209 basic_string declarations inconsistent
210 distance first and last confused
211 operator>>(istream&, string&) doesn't set failbit
212 Empty range behavior unclear for several algorithms
213 Math function overloads ambiguous
214 set::find() missing const overload
215 Can a map's key_type be const?
216 setbase manipulator description flawed
217 Facets example (Classifying Japanese characters) contains errors
218 Algorithms do not use binary predicate objects for default comparisons
219 find algorithm missing version that takes a binary predicate argument
220 ~ios_base() usage valid?
221 num_get<>::do_get stage 2 processing broken
222 Are throw clauses necessary if a throw is already implied by the effects clause?
223 reverse algorithm should use iter_swap rather than swap
224 clear() complexity for associative containers refers to undefined N
225 std:: algorithms use of other unqualified algorithms
226 User supplied specializations or overloads of namespace std function templates
227 std::swap() should require CopyConstructible or DefaultConstructible arguments
228 Incorrect specification of "..._byname" facets
229 Unqualified references of other library entities
230 Assignable specified without also specifying CopyConstructible
231 Precision in iostream?
232 "depends" poorly defined in
233 Insertion hints in associative containers
234 Typos in allocator definition
235 No specification of default ctor for reverse_iterator
236 ctype<char>::is() member modifies facet
237 Undefined expression in complexity specification
238 Contradictory results of stringbuf initialization.
239 Complexity of unique() and/or unique_copy incorrect
240 Complexity of adjacent_find() is meaningless
241 Does unique_copy() require CopyConstructible and Assignable?
242 Side effects of function objects
243 get and getline when sentry reports failure
244 Must find's third argument be CopyConstructible?
245 Which operations on istream_iterator trigger input operations?
246 a.insert(p,t) is incorrectly specified
247 vector, deque::insert complexity
248 time_get fails to set eofbit
249 Return Type of auto_ptr::operator=
250 splicing invalidates iterators
251 basic_stringbuf missing allocator_type
252 missing casts/C-style casts used in iostreams
253 valarray helper functions are almost entirely useless
254 Exception types in clause 19 are constructed from std::string
255 Why do basic_streambuf<>::pbump() and gbump() take an int?
256 typo in, p17: copy_event does not exist
257 STL functional object and iterator inheritance.
258 Missing allocator requirement
259 basic_string::operator[] and const correctness
260 Inconsistent return type of istream_iterator::operator++(int)
261 Missing description of istream_iterator::operator!=
262 Bitmask operator ~ specified incorrectly
263 Severe restriction on basic_string reference counting
264 Associative container insert(i, j) complexity requirements are not feasible.
265 std::pair::pair() effects overly restrictive
266 bad_exception::~bad_exception() missing Effects clause
267 interaction of strstreambuf::overflow() and seekoff()
268 Typo in locale synopsis
269 cstdarg and unnamed parameters
270 Binary search requirements overly strict
271 basic_iostream missing typedefs
272 Missing parentheses around subexpression
273 Missing ios_base qualification on members of a dependent class
274 a missing/impossible allocator requirement
275 Wrong type in num_get::get() overloads
276 Assignable requirement for container value type overly strict
277 Normative encouragement in allocator requirements unclear
278 What does iterator validity mean?
279 const and non-const iterators should have equivalent typedefs
280 Comparison of reverse_iterator to const reverse_iterator
281 std::min() and max() requirements overly restrictive
282 What types does numpunct grouping refer to?
283 std::replace() requirement incorrect/insufficient
284 unportable example in 20.3.7, p6
285 minor editorial errors in fstream ctors
286 <cstdlib> requirements missing size_t typedef
287 conflicting ios_base fmtflags
288 <cerrno> requirements missing macro EILSEQ
289 <cmath> requirements missing C float and long double versions
290 Requirements to for_each and its function object
291 Underspecification of set algorithms
292 effects of a.copyfmt (a)
293 Order of execution in transform algorithm
294 User defined macros and standard headers
295 Is abs defined in <cmath>?
296 Missing descriptions and requirements of pair operators
297 const_mem_fun_t<>::argument_type should be const T*
298 ::operator delete[] requirement incorrect/insufficient
299 Incorrect return types for iterator dereference
300 list::merge() specification incomplete
301 basic_string template ctor effects clause omits allocator argument
302 Need error indication from codecvt<>::do_length
303 Bitset input operator underspecified
304 Must *a return an lvalue when a is an input iterator?
305 Default behavior of codecvt<wchar_t, char, mbstate_t>::length()
306 offsetof macro and non-POD types
307 Lack of reference typedefs in container adaptors
308 Table 82 mentions unrelated headers
309 Does sentry catch exceptions?
310 Is errno a macro?
311 Incorrect wording in basic_ostream class synopsis
312 Table 27 is missing headers
313 set_terminate and set_unexpected question
314 Is the stack unwound when terminate() is called?
315 Bad "range" in list::unique complexity
316 Vague text in Table 69
317 Instantiation vs. specialization of facets
318 Misleading comment in definition of numpunct_byname
319 Storage allocation wording confuses "Required behavior", "Requires"
320 list::assign overspecified
321 Typo in num_get
322 iterator and const_iterator should have the same value type
323 abs() overloads in different headers
324 Do output iterators have value types?
325 Misleading text in moneypunct<>::do_grouping
326 Missing typedef in moneypunct_byname
327 Typo in time_get facet in table 52
328 Bad sprintf format modifier in money_put<>::do_put()
329 vector capacity, reserve and reallocation
330 Misleading "exposition only" value in class locale definition
331 bad declaration of destructor for ios_base::failure
332 Consider adding increment and decrement operators to std::fpos< T >
333 does endl imply synchronization with the device?
334 map::operator[] specification forces inefficient implementation
335 minor issue with char_traits, table 37
336 Clause 17 lack of references to deprecated headers
337 replace_copy_if's template parameter should be InputIterator
338 is whitespace allowed between `-' and a digit?
339 definition of bitmask type restricted to clause 27
340 interpretation of has_facet<Facet>(loc)
341 Vector reallocation and swap
342 seek and eofbit
343 Unspecified library header dependencies
344 grouping + showbase
345 type tm in <cwchar>
346 Some iterator member functions should be const
347 locale::category and bitmask requirements
348 Minor issue with std::pair operator<
349 Minor typographical error in ostream_iterator
350 allocator<>::address
351 unary_negate and binary_negate: struct or class?
352 missing fpos requirements
353 std::pair missing template assignment
354 Associative container lower/upper bound requirements
355 Operational semantics for a.back()
356 Meaning of ctype_base::mask enumerators
357 <cmath> float functions cannot return HUGE_VAL
358 interpreting thousands_sep after a decimal_point
359 num_put<>::do_put (..., bool) undocumented
360 locale mandates inefficient implementation
361 num_get<>::do_get (..., void*&) checks grouping
362 bind1st/bind2nd type safety
363 Missing exception specification in
364 Inconsistent wording in
365 Lack of const-qualification in clause 27
366 Excessive const-qualification
367 remove_copy/remove_copy_if and Input Iterators
368 basic_string::replace has two "Throws" paragraphs
369 io stream objects and static ctors
370 Minor error in basic_istream::get
371 Stability of multiset and multimap member functions
372 Inconsistent description of stdlib exceptions
373 Are basic_istream and basic_ostream to use (exceptions()&badbit) != 0 ?
374 moneypunct::frac_digits returns int not unsigned
375 basic_ios should be ios_base in
376 basic_streambuf semantics
377 basic_string::insert and length_error
378 locale immutability and locale::operator=()
379 nonsensical ctype::do_widen() requirement
380 typos in codecvt tables 53 and 54
381 detection of invalid mbstate_t in codecvt
382 codecvt do_in/out result
383 Bidirectional iterator assertion typo
384 equal_range has unimplementable runtime complexity
385 Does call by value imply the CopyConstructible requirement?
386 Reverse iterator's operator[] has impossible return type
387 std::complex over-encapsulated
388 Use of complex as a key in associative containers
389 Const overload of valarray::operator[] returns by value
390 CopyConstructible requirements too strict
391 non-member functions specified as const
392 'equivalence' for input iterators
393 do_in/do_out operation on state unclear
394 behavior of formatted output on failure
395 inconsistencies in the definitions of rand() and random_shuffle()
396 what are characters zero and one
397 ostream::sentry dtor throws exceptions
398 effects of end-of-file on unformatted input functions
399 volations of unformatted input function requirements
400 redundant type cast in lib.allocator.members
401 incorrect type casts in table 32 in lib.allocator.requirements
402 wrong new expression in [some_]allocator::construct
403 basic_string::swap should not throw exceptions
404 May a replacement allocation function be declared inline?
405 qsort and POD
406 vector::insert(s) exception safety
407 Can singular iterators be destroyed?
408 Is vector<reverse_iterator<char*> > forbidden?
409 Closing an fstream should clear error state
410 Missing semantics for stack and queue comparison operators
411 Wrong names of set member functions
412 Typo in
413 Proposed resolution to LDR#64 still wrong
414 Which iterators are invalidated by v.erase()?
415 behavior of std::ws
416 definitions of XXX_MIN and XXX_MAX macros in climits
417 what does ctype::do_widen() return on failure
418 exceptions thrown during iostream cleanup
419 istream extractors not setting failbit if eofbit is already set
420 is std::FILE a complete type?
421 is basic_streambuf copy-constructible?
422 explicit specializations of member functions of class templates
423 Effects of negative streamsize in iostreams
424 normative notes
425 return value of std::get_temporary_buffer
426 search_n(), fill_n(), and generate_n() with negative n
427 Stage 2 and rationale of DR 221
428 string::erase(iterator) validity
429 typo in basic_ios::clear(iostate)
430 valarray subset operations
431 Swapping containers with unequal allocators
432 stringbuf::overflow() makes only one write position available
433 Contradiction in specification of unexpected()
434 bitset::to_string() hard to use
435 bug in DR 25
436 are cv-qualified facet types valid facets?
437 Formatted output of function pointers is confusing
438 Ambiguity in the "do the right thing" clause
439 Should facets be copyable?
440 Should std::complex use unqualified transcendentals?
441 Is fpos::state const?
442 sentry::operator bool() inconsistent signature
443 filebuf::close() inconsistent use of EOF
444 Bad use of casts in fstream
445 iterator_traits::reference unspecified for some iterator categories
446 Iterator equality between different containers
447 Wrong template argument for time facets
448 Random Access Iterators over abstract classes
449 Library Issue 306 Goes Too Far
450 set::find is inconsistent with associative container requirements
451 Associative erase should return an iterator
452 locale::combine should be permitted to generate a named locale
453 basic_stringbuf::seekoff need not always fail for an empty stream
454 basic_filebuf::open should accept wchar_t names
455 cerr::tie() and wcerr::tie() are overspecified
456 Traditional C header files are overspecified
457 bitset constructor: incorrect number of initialized bits
458 24.1.5 contains unintended limitation for operator-
459 Requirement for widening in stage 2 is overspecification
460 Default modes missing from basic_fstream member specifications
461 time_get hard or impossible to implement
462 Destroying objects with static storage duration
463 auto_ptr usability issues
464 Suggestion for new member functions in standard containers
465 Contents of <ciso646>
466 basic_string ctor should prevent null pointer error
467 char_traits::lt(), compare(), and memcmp()
468 unexpected consequences of ios_base::operator void*()
469 vector<bool> ill-formed relational operators
470 accessing containers from their elements' special functions
471 result of what() implementation-defined
472 Missing "Returns" clause in std::equal_range
473 underspecified ctype calls
474 confusing Footnote 297
475 May the function object passed to for_each modify the elements of the iterated sequence?
476 Forward Iterator implied mutability
477 Operator-> for const forward iterators
478 Should forward iterator requirements table have a line for r->m?
479 Container requirements and placement new
480 unary_function and binary_function should have protected nonvirtual destructors
481 unique's effects on the range [result, last)
482 Swapping pairs
483 Heterogeneous equality and EqualityComparable
484 Convertible to T
485 output iterator insufficiently constrained
486 min/max CopyConstructible requirement is too strict
487 Allocator::construct is too limiting
488 rotate throws away useful information
489 std::remove / std::remove_if wrongly specified
490 std::unique wrongly specified
491 std::list<>::unique incorrectly specified
492 Invalid iterator arithmetic expressions
493 Undefined Expression in Input Iterator Note Title
494 Wrong runtime complexity for associative container's insert and delete
495 Clause 22 template parameter requirements
496 Illegal use of "T" in vector<bool>
497 meaning of numeric_limits::traps for floating point types
498 Requirements for partition() and stable_partition() too strong
499 Std. doesn't seem to require stable_sort() to be stable!
500 do_length cannot be implemented correctly
501 Proposal: strengthen guarantees of lib.comparisons
502 Proposition: Clarification of the interaction between a facet and an iterator
503 more on locales
504 Integer types in pseudo-random number engine requirements
505 Result_type in random distribution requirements
506 Requirements of Distribution parameter for variate_generator
507 Missing requirement for variate_generator::operator()
508 Bad parameters for ranlux64_base_01
509 Uniform_int template parameters
510 Input_type for bernoulli_distribution
511 Input_type for binomial_distribution
512 Seeding subtract_with_carry_01 from a single unsigned long
513 Size of state for subtract_with_carry_01
514 Size of state for subtract_with_carry
515 Random number engine traits
516 Seeding subtract_with_carry_01 using a generator
517 Should include name in external representation
518 Are insert and erase stable for unordered_multiset and unordered_multimap?
519 Data() undocumented
520 Result_of and pointers to data members
521 Garbled requirements for argument_type in reference_wrapper
522 Tuple doesn't define swap
523 regex case-insensitive character ranges are unimplementable as specified
524 regex named character classes and case-insensitivity don't mix
525 type traits definitions not clear
526 Is it undefined if a function in the standard changes in parameters?
527 tr1::bind has lost its Throws clause
528 const_iterator iterator issue when they are the same type
529 The standard encourages redundant and confusing preconditions
530 Must elements of a string be contiguous?
531 array forms of unformatted input functions
532 Tuple comparison
533 typo in
534 Missing basic_string members
535 std::string::swap specification poorly worded
536 Container iterator constructor and explicit convertibility
537 Typos in the signatures in and
538 241 again: Does unique_copy() require CopyConstructible and Assignable?
539 partial_sum and adjacent_difference should mention requirements
540 shared_ptr<void>::operator*()
541 shared_ptr template assignment and void
542 shared_ptr observers
543 valarray slice default constructor
544 minor NULL problems in C.2
545 When is a deleter deleted?
546 [tr1] _Longlong and _ULonglong are integer types
547 division should be floating-point, not integer
548 May random_device block?
549 Undefined variable in binomial_distribution
550 What should the return type of pow(float,int) be?
551 <ccomplex>
552 random_shuffle and its generator
553 very minor editorial change intptr_t / uintptr_t
554 Problem with lwg DR 184 numeric_limits<bool>
555 [tr1] 8.21/1: typo
556 Is Compare a BinaryPredicate?
557 TR1: div(_Longlong, _Longlong) vs div(intmax_t, intmax_t)
558 lib.input.iterators Defect
559 numeric_limits<const T>
560 User-defined allocators without default constructor
561 inserter overly generic
562 stringbuf ctor inefficient
563 stringbuf seeking from end
564 stringbuf seekpos underspecified
565 xsputn inefficient
566 array forms of unformatted input function undefined for zero-element arrays
567 streambuf inserter and extractor should be unformatted
568 [tr1] log2 overloads missing
569 Postcondition for basic_ios::clear(iostate) incorrectly stated
570 Request adding additional explicit specializations of char_traits
571 Update C90 references to C99?
572 Oops, we gave 507 WP status
573 C++0x file positioning should handle modern file sizes
574 DR 369 Contradicts Text
575 the specification of ~shared_ptr is MT-unfriendly, makes implementation assumptions
576 find_first_of is overconstrained
577 upper_bound(first, last, ...) cannot return last
578 purpose of hint to allocator::allocate()
579 erase(iterator) for unordered containers should not return an iterator
580 unused allocator members
581 flush() not unformatted function
582 specialized algorithms and volatile storage
583 div() for unsigned integral types
584 missing int pow(int,int) functionality
585 facet error reporting
586 string inserter not a formatted function
587 iststream ctor missing description
588 requirements on zero sized tr1::arrays and other details
589 Requirements on iterators of member template functions of containers
590 Type traits implementation latitude should be removed for C++0x
591 Misleading "built-in
592 Incorrect treatment of rdbuf()->close() return type
594 Disadvantages of defining Swappable in terms of CopyConstructible and Assignable
595 TR1/C++0x: fabs(complex<T>) redundant / wrongly specified
596 Table 112 omits "a+" and "a+b" modes
597 [] The notion of 'promotion' cannot be emulated by user-defined types.
598 [] Conversion to integral should truncate, not round.
599 [] Say "octets" instead of "bytes."
600 [] Wrong parameters for wcstod* functions
601 [] numeric_limits typos
602 [] "generic floating type" not defined.
603 [] Trivially simplifying decimal classes.
604 [] Storing a reference to a facet unsafe.
605 [] <decfloat.h> doesn't live here anymore.
606 [] allow narrowing conversions
607 Concern about short seed vectors
608 Unclear seed_seq construction details
609 missing static const
610 Suggested non-normative note for C++0x
611 Standard library templates and incomplete types
612 numeric_limits::is_modulo insufficiently defined
613 max_digits10 missing from numeric_limits
614 std::string allocator requirements still inconsistent
615 Inconsistencies in Section 21.4
616 missing 'typename' in ctype_byname
617 std::array is a sequence that doesn't satisfy the sequence requirements?
618 valarray::cshift() effects on empty array
619 Longjmp wording problem
620 valid uses of empty valarrays
621 non-const copy assignment operators of helper arrays
622 behavior of filebuf dtor and close on error
623 pubimbue forbidden to call imbue
624 valarray assignment and arrays of unequal length
625 Mixed up Effects and Returns clauses
626 new Remark clauses not documented
627 Low memory and exceptions
628 Inconsistent definition of basic_regex constructor
629 complex<T> insertion and locale dependence
630 arrays of valarray
631 conflicting requirements for BinaryPredicate
632 Time complexity of size() for std::set
633 Return clause mentions undefined "type()"
634 allocator.address() doesn't work for types overloading operator&
635 domain of allocator::address
636 valarray::operator[]
637 §[c.math]/10 inconsistent return values
638 deque end invalidation during erase
639 Still problems with exceptions during streambuf IO
640 does not handle (unsigned) long long
641 Editorial fix for 27.6.4 (N2134)
642 Invalidated fstream footnotes in N2134
643 Impossible "as if" clauses
644 Possible typos in 'function' description
645 Missing members in match_results
646 const incorrect match_result members
647 Inconsistent regex_search params
648 regex_iterator c'tor needs clarification/editorial fix
649 Several typos in regex_token_iterator constructors
650 regex_token_iterator and const correctness
651 Missing preconditions for regex_token_iterator c'tors
652 regex_iterator and const correctness
653 Library reserved names
654 Missing IO roundtrip for random number engines
655 Signature of generate_canonical not useful
656 Typo in subtract_with_carry_engine declaration
657 unclear requirement about header inclusion
658 Two unspecified function comparators in [function.objects]
659 istreambuf_iterator should have an operator->()
660 Missing Bitwise Operations
661 New changes make special extractions useless
662 Inconsistent handling of incorrectly-placed thousands separators
663 Complexity Requirements
664 do_unshift for codecvt<char, char, mbstate_t>
665 do_unshift return value
666 moneypunct::do_curr_symbol()
667 money_get's widened minus sign
668 money_get's empty minus sign
669 Equivalent postive and negative signs in money_get
670 money_base::pattern and space
671 precision of hexfloat
672 Swappable requirements need updating
673 unique_ptr update
674 shared_ptr interface changes for consistency with N1856
675 Move assignment of containers
676 Moving the unordered containers
677 Weaknesses in seed_seq::randomize [rand.util.seedseq]
678 Changes for [rand.req.eng]
679 resize parameter by value
680 move_iterator operator-> return
681 Operator functions impossible to compare are defined in [re.submatch.op]
682 basic_regex ctor takes InputIterator or ForwardIterator?
683 regex_token_iterator summary error
684 Unclear which members of match_results should be used in comparison
685 reverse_iterator/move_iterator difference has invalid signatures
686 unique_ptr and shared_ptr fail to specify non-convertibility to int for unspecified-bool-type
687 shared_ptr conversion constructor not constrained
688 reference_wrapper, cref unsafe, allow binding to rvalues
689 reference_wrapper constructor overly constrained
690 abs(long long) should return long long
691 const_local_iterator cbegin, cend missing from TR1
692 get_money and put_money should be formatted I/O functions
693 std::bitset::all() missing
694 std::bitset and long long
695 ctype<char>::classic_table() not accessible
696 istream::operator>>(int&) broken
697 New <system_error> header leads to name clashes
698 system_error needs const char* constructors
699 N2111 changes min/max
700 N1856 defines struct identity
701 [tr1] assoc laguerre poly's
702 [tr1] Restriction in associated Legendre functions
703 map::at() need a complexity specification
704 MoveAssignable requirement for container value type overly strict
705 type-trait decay incompletely specified
706 make_pair() should behave as make_tuple() wrt. reference_wrapper()
707 null pointer constant for exception_ptr
708 Locales need to be per thread and updated for POSIX changes
709 char_traits::not_eof has wrong signature
710 Missing postconditions
711 Contradiction in empty shared_ptr
712 seed_seq::size no longer useful
713 sort() complexity is too lax
714 search_n complexity is too lax
715 minmax_element complexity is too lax
716 Production in [re.grammar] not actually modified
717 Incomplete valarray::operator[] specification in [valarray.access]
718 basic_string is not a sequence
719 std::is_literal type traits should be provided
720 Omissions in constexpr usages
721 wstring_convert inconsistensies
722 Missing [c.math] functions nanf and nanl
723 basic_regex should be moveable
724 DefaultConstructible is not defined
725 Optional sequence container requirements column label
726 Missing regex_replace() overloads
727 regex_replace() doesn't accept basic_strings with custom traits and allocators
728 Problem in [rand.eng.mers]/6
729 Problem in [rand.req.eng]/3
730 Comment on [rand.req.adapt]/3 e)
731 proposal for a customizable seed_seq
732 Defect in [rand.dist.samp.genpdf]
733 Comment on [rand.req.dist]/9
734 Unnecessary restriction in [rand.dist.norm.chisq]
735 Unfortunate naming
736 Comment on [rand.dist.samp.discrete]
737 Comment on [rand.dist.samp.pconst]
738 Editorial issue in [rand.adapt.disc]/3
739 Defect in [rand.util.canonical]/3
740 Please remove *_ptr<T[N]>
741 Const-incorrect get_deleter function for shared_ptr
742 Enabling swap for proxy iterators
743 rvalue swap for shared_ptr
744 What is the lifetime of an exception pointed to by an exception_ptr?
745 copy_exception API slices.
746 current_exception may fail with bad_alloc
747 We have 3 separate type traits to identify classes supporting no-throw operations
748 The is_abstract type trait is defined by reference to 10.4.
749 Currently has_nothrow_copy_constructor<T>::value is true if T has 'a' nothrow copy constructor.
750 The current definition for is_convertible requires that the type be implicitly convertible, so explicit constructors are ignored.
751 change pass-by-reference members of vector<bool> to pass-by-value?
752 Allocator complexity requirement
753 Move constructor in draft
754 Ambiguous return clause for std::uninitialized_copy
755 std::vector and std:string lack explicit shrink-to-fit operations
756 Container adaptors push
757 Typo in the synopsis of vector
758 shared_ptr and nullptr
759 A reference is not an object
760 The emplace issue
761 unordered_map needs an at() member function
762 std::unique_ptr requires complete type?
763 Renaming emplace() overloads
764 equal_range on unordered containers should return a pair of local_iterators
765 More on iterator validity
766 Inconsistent exception guarantees between ordered and unordered associative containers
767 Forwarding and backward compatibility
768 Typos in [atomics]?
769 std::function should use nullptr_t instead of "unspecified-null-pointer-type"
770 std::function should use rvalue swap
771 Impossible throws clause in [string.conversions]
772 Impossible return clause in [string.conversions]
773 issues with random
774 Member swap undefined for most containers
775 Tuple indexing should be unsigned?
776 Undescribed assign function of std::array
777 Atomics Library Issue
778 std::bitset does not have any constructor taking a string literal
779 Resolution of #283 incomplete
780 std::merge() specification incorrect/insufficient
781 std::complex should add missing C99 functions
782 Extended seed_seq constructor is useless
783 thread::id reuse
784 unique_lock::release
785 [tr1] Random Number Requirements in TR1
786 Thread library timed waits, UTC and monotonic clocks
787 complexity of binary_search
788 Ambiguity in [istream.iterator]
789 xor_combine_engine(result_type) should be explicit
790 xor_combine::seed not specified
791 piecewise_constant_distribution::densities has wrong name
792 piecewise_constant_distribution is undefined for a range with just one endpoint
793 discrete_distribution missing constructor
794 piecewise_constant_distribution missing constructor
795 general_pdf_distribution should be dropped
796 ranlux48_base returns wrong value
797 ranlux48 returns wrong value
798 Refactoring of binders lead to interface breakage
799 Mersenne twister equality overspecified
800 Issues in [rand.util.seedseq](6)
801 tuple and pair trivial members
802 knuth_b returns wrong value
803 Simplification of seed_seq::seq_seq
804 Some problems with classes error_code/error_condition
805 posix_error::posix_errno concerns
806 unique_ptr::reset effects incorrect, too permissive
807 tuple construction should not fail unless its element's construction fails
808 §[forward] incorrect redundant specification
809 std::swap should be overloaded for array types
810 Missing traits dependencies in operational semantics of extended manipulators
811 pair of pointers no longer works with literal 0
812 unsolicited multithreading considered harmful?
813 "empty" undefined for shared_ptr
814 vector<bool>::swap(reference, reference) not defined
815 std::function and reference_closure do not use perfect forwarding
816 Should bind()'s returned functor have a nofail copy ctor when bind() is nofail?
817 bind needs to be moved
818 wording for memory ordering
819 rethrow_if_nested
820 current_exception()'s interaction with throwing copy ctors
821 Minor cleanup : unique_ptr
822 Object with explicit copy constructor no longer CopyConstructible
823 identity<void> seems broken
824 rvalue ref issue with basic_string inserter
825 Missing rvalues reference stream insert/extract operators?
826 Equivalent of %'d, or rather, lack thereof?
827 constexpr shared_ptr::shared_ptr()?
828 Static initialization for std::mutex?
829 current_exception wording unclear about exception type
830 Incomplete list of char_traits specializations
831 wrong type for not_eof()
832 Applying constexpr to System error support
833 Freestanding implementations header list needs review for C++0x
834 unique_ptr::pointer requirements underspecified
835 Tying two streams together (correction to DR 581)
836 Effects of money_base::space and money_base::none on money_get
837 basic_ios::copyfmt() overly loosely specified
838 Can an end-of-stream iterator become a non-end-of-stream one?
839 Maps and sets missing splice operation
840 pair default template argument
841 cstdint.syn inconsistent with C99
842 ConstructibleAsElement and bit containers
843 Reference Closure
844 complex pow return type is ambiguous
845 atomics cannot support aggregate initialization
846 No definition for constructor
847 string exception safety guarantees
848 Missing std::hash specializations for std::bitset/std::vector<bool>
849 missing type traits to compute root class and derived class of types in a class hierachy
850 Should shrink_to_fit apply to std::deque?
851 simplified array construction
852 unordered containers begin(n) mistakenly const
853 to_string needs updating with zero and one
854 default_delete converting constructor underspecified
855 capacity() and reserve() for deque?
856 Removal of aligned_union
857 condition_variable::time_wait return bool error prone
858 Wording for Minimal Support for Garbage Collection
859 Monotonic Clock is Conditionally Supported?
860 Floating-Point State
861 Incomplete specification of EqualityComparable for std::forward_list
862 Impossible complexity for 'includes'
863 What is the state of a stream after close() succeeds
864 Defect in atomic wording
865 More algorithms that throw away information
866 Qualification of placement new-expressions
867 Valarray and value-initialization
868 Default construction and value-initialization
869 Bucket (local) iterators and iterating past end
870 Do unordered containers not support function pointers for predicate/hasher?
871 Iota's requirements on T are too strong
872 move_iterator::operator[] has wrong return type
873 signed integral type and unsigned integral type are not clearly defined
874 Missing initializer_list constructor for discrete_distribution
875 Missing initializer_list constructor for piecewise_constant_distribution
876 basic_string access operations should give stronger guarantees
877 to throw() or to Throw: Nothing.
878 forward_list preconditions
879 Atomic load const qualification
880 Missing atomic exchange parameter
881 shared_ptr conversion issue
882 duration non-member arithmetic requirements
883 swap circular definition
884 shared_ptr swap
885 pair assignment
886 tuple construction
887 issue with condition::wait_...
888 this_thread::yield too strong
889 thread::id comparisons
890 Improving <system_error> initialization
891 std::thread, std::call_once issue
892 Forward_list issues...
893 std::mutex issue
894 longjmp and destructors
895 "Requires:" on std::string::at et al
896 Library thread safety issue
897 Forward_list issues... Part 2
898 Small contradiction in n2723 to forward to committee
899 Adjusting shared_ptr for nullptr_t
900 Stream move-assignment
901 insert iterators can move from lvalues
902 Regular is the wrong concept to constrain numeric_limits
903 back_insert_iterator issue
904 result_of argument types
905 Mutex specification questions
906 ObjectType is the wrong concept to constrain initializer_list
907 Bitset's immutable element retrieval is inconsistently defined
908 Deleted assignment operators for atomic types must be volatile
909 regex_token_iterator should use initializer_list
910 Effects of MoveAssignable
911 I/O streams and move/swap semantic
912 Array swap needs to be conceptualized
913 Superfluous requirements for replace algorithms
914 Superfluous requirement for unique
915 minmax with initializer_list should return pair of T, not pair of const T&
916 Redundant move-assignment operator of pair should be removed
917 Redundant move-assignment operator of tuple should be removed
918 Swap for tuple needs to be conceptualized
919 (forward_)list specialized remove algorithms are over constrained
920 Ref-qualification support in the library
921 Rational Arithmetic should use template aliases
922 §[] Number of placeholders
923 atomics with floating-point
924 structs with internal padding
925 shared_ptr's explicit conversion from unique_ptr
926 Sequentially consistent fences, relaxed operations and modification order
927 Dereferenceable should be HasDereference
928 Wrong concepts used for tuple's comparison operators
929 Thread constructor
930 Access to std::array data as built-in array type
931 type trait extent<T, I>
932 unique_ptr(pointer p) for pointer deleter types
933 Unique_ptr defect
934 duration is missing operator%
935 clock error handling needs to be specified
936 Mutex type overspecified
937 Atomics for standard typedef types
938 default_delete<T[]>::operator() should only accept T*
939 Problem with std::identity and reference-to-temporaries
940 std::distance
941 Ref-qualifiers for assignment operators
942 Atomics synopsis typo
943 ssize_t undefined
944 atomic<bool> derive from atomic_bool?
945 system_clock::rep not specified
946 duration_cast improperly specified
947 duration arithmetic: contradictory requirements
948 ratio arithmetic tweak
949 owner_less
950 unique_ptr converting ctor shouldn't accept array form
951 Various threading bugs #1
952 Various threading bugs #2
953 Various threading bugs #3
954 Various threading bugs #4
955 Various threading bugs #5
956 Various threading bugs #6
957 Various threading bugs #7
958 Various threading bugs #8
959 Various threading bugs #9
960 Various threading bugs #10
961 Various threading bugs #11
962 Various threading bugs #12
963 Various threading bugs #13
964 Various threading bugs #14
965 Various threading bugs #15
966 Various threading bugs #16
967 Various threading bugs #17
968 Various threading bugs #18
969 What happened to Library Issue 475?
970 addressof overload unneeded
971 Spurious diagnostic conversion function
972 The term "Assignable" undefined but still in use
973 auto_ptr characteristics
974 duration<double> should not implicitly convert to duration<int>
975 is_convertible cannot be instantiated for non-convertible types
976 Class template std::stack should be movable
977 insert iterators inefficient for expensive to move types
978 Hashing smart pointers
979 Bad example
980 mutex lock() missing error conditions
981 Unordered container requirements should add initializer_list support
982 Wrong complexity for initializer_list assignment in Table 85
983 unique_ptr reference deleters should not be moved from
984 Does <cinttypes> have macro guards?
985 Allowing throwing move
986 Generic try_lock contradiction
987 reference_wrapper and function types
988 Reflexivity meaningless?
989 late_check and library
990 monotonic_clock::is_monotonic must be true
991 Provide allocator for wstring_convert
992 Allow implementations to implement C library in the global namespace
993 _Exit needs better specification
994 quick_exit should terminate well-defined
995 Operational Semantics Unclear
996 Move operation not well specified
997 "Effects: Equivalent to" is underspecified
998 Smart pointer referencing its owner
999 Taking the address of a function
1000 adjacent_find is over-constrained
1001 Pointers, concepts and headers
1002 Provide bulk include headers
1003 Require more useful headers for freestanding implementations
1004 Clarify "throws an exception"
1005 numeric_limits partial specializations not concept enabled
1006 operator delete in garbage collected implementation
1007 throw_with_nested not concept enabled
1008 nested_exception wording unclear
1009 InputIterator post-increment dangerous
1010 operator-= should use default in concept
1011 next/prev wrong iterator type
1012 reverse_iterator default ctor should value initialize
1013 Remove IsSameType hold-over constraints
1014 basic_regex should be created/assigned from initializer lists
1015 C++ programs - but not users - need to provide support concept_maps
1016 Provide LessThanComparable and EqualityComparable for FloatingPointType
1017 Floating-point types should not satisfy Regular
1018 Trait specifications should be expressed in terms of concepts
1019 Make integral_constant objects useable in integral-constant-expressions
1020 Restore aligned_union
1021 Allow nullptr_t assignments to unique_ptr
1022 Pointer-safety API has nothing to do with smart pointers
1023 Unclear inheritance relation for std::function
1024 std::function constructors overly generous
1025 The library should provide more specializations for std::hash
1026 Smart pointers need to be concept-constrained templates
1027 std::allocator needs to be a concept-constrained template
1028 raw_storage_iterator needs to be a concept-constrained template
1029 Specialized algorithms for memory management need to be concept-constrained templates
1030 Missing requirements for smart-pointer safety API
1031 Need shared_ptr conversion to a unique_ptr
1032 Tome utility templates need to be concept-constrained
1033 thread::join() effects?
1034 Clarify generality of Container Requirement tables
1035 <array>::swap can invalidate references, pointers, and iterators
1036 Remove iterator specification that is redundant due to concept constraints
1037 Unclear status of match_results as library container
1038 Sequence requirement table needs to reference several new containers
1039 Sequence container back function should also support const_iterator
1040 Clarify possible sameness of associative container's iterator and const_iterator
1041 Add associative/unordered container functions that allow to extract elements
1042 Provide ContiguousStorage concept and apply it to corresponding containers
1043 Clarify that compare_exchange is not a read-modify-write operation
1044 Empty tag types should be constexpr literals
1045 Remove unnecessary preconditions from unique_lock constructor
1046 Provide simple facility to start asynchronous operations
1047 Ensure that future's get() blocks when not ready
1048 Provide empty-state inspection for std::unique_future
1049 Move assignment of promise inverted
1050 Clarify postconditions for get_future()
1051 Specify subscript operation return types of reverse_iterator and move_iterator
1052 reverse_iterator::operator-> should also support smart pointers
1053 Unify algorithms with operator and function object variants
1054 forward broken
1055 Provide a trait that returns the underlying type of an enumeration type
1056 Must all Engines and Distributions be Streamable?
1057 RandomNumberEngineAdaptor
1058 New container issue
1059 Usage of no longer existing FunctionType concept
1060 Embedded nulls in NTBS
1061 Bad indexing for tuple access to pair (Editorial?)
1062 Missing insert_iterator for stacks/queues
1063 03 iterator compatibilty
1064 Term "object state" should not refer to classes
1065 Allow inline namespaces within namespace std for implementations
1066 Use [[noreturn]] attribute in the library
1067 simplified wording for inner_product
1068 class random_device should be movable
1069 class seed_seq should support efficient move operations
1070 Ambiguous move overloads in function
1071 is_bind_expression should derive from integral_constant<bool>
1072 Is std::hash a constrained template or not?
1073 Declaration of allocator_arg should be constexpr
1074 concept map broken by N2840
1075 Scoped allocators are too complex
1076 unary/binary_negate need constraining and move support
1077 Nonesense tuple declarations
1078 DE-17: Remove class type_index
1079 UK-265: RandomAccessIterator's operator- has nonsensical effects clause
1080 Concept ArithmeticLike should provide explicit boolean conversion
1081 basic_string needs to be a concept-constrained template
1082 codecvt needs to be a concept-constrained template
1083 InputIterator and OutputIterator template parameters need to be concept constraints
1084 Concept ForwardIterator should provide default implementation for post-increment
1085 BidirectionalIterator concept should provide default implementation for post-decrement
1086 Stream iterators need to be concept-constrained templates
1087 Incorrect OutputIterator concept requirements for replace algorithms
1088 std::promise should provide non-member swap overload
1089 Unify "Throws: Nothing." specifications
1090 Missing description of packaged_task member swap, missing non-member swap
1091 Multimap description confusing
1092 Class template integral_constant should be a constrained template
1093 Multiple definitions for random_shuffle algorithm
1094 Replace "unspecified-bool-type" by "explicit operator bool() const" in I/O library
1095 Shared objects and the library wording unclear
1096 unconstrained rvalue ref parameters
1097 #define __STDCPP_THREADS
1098 definition of get_pointer_safety()
1099 Various issues
1100 auto_ptr to unique_ptr conversion
1101 unique requirements
1102 std::vector's reallocation policy still unclear
1103 system_error constructor postcondition overly strict
1104 basic_ios::move should accept lvalues
1105 Shouldn't Range be an auto concept
1106 Multiple exceptions from connected shared_future::get()?
1107 constructor shared_future(unique_future) by value?
1108 thread.req.exception overly constrains implementations
1109 std::includes should require CopyConstructible predicate
1110 Is for_each overconstrained?
1111 associative containers underconstrained
1112 bitsets and new style for loop
1113 bitset::to_string could be simplified
1114 Type traits underspecified
1115 va_copy missing from Standard macros table
1116 Literal constructors for tuple
1117 tuple copy constructor
1118 tuple query APIs do not support cv-qualification
1119 tuple query APIs do not support references
1120 New type trait - remove_all
1121 Support for multiple arguments
1122 Ratio values should be constexpr
1123 No requirement that standard streams be flushed
1124 Invalid definition of concept RvalueOf
1125 ostream_iterator does not work with movable types
1126 istreambuff_iterator::equal needs a const & parameter
1127 rvalue references and iterator traits
1128 Missing definition of iterator_traits<T*>
1129 istream(buf)_iterator should support literal sentinel value
1130 copy_exception name misleading
1131 C++0x does not need alignment_of
1132 JP-30: nested exceptions
1133 Does N2844 break current specification of list::splice?
1134 Redundant specification of <stdint.h>, <fenv.h>, <tgmath.h>, and maybe <complex.h>
1135 exception_ptr should support contextual conversion to bool
1136 Incomplete specification of nested_exception::rethrow_nested()
1137 Return type of conj and proj
1138 Unusual return value for operator+
1139 Thread support library not concept enabled
1140 Numerics library not concept enabled
1141 Input/Output library not concept enabled
1142 Regular expressions library not concept enabled
1143 Atomic operations library not concept enabled
1144 "thread safe" is undefined
1145 Inappropriate headers for atomics
1146 "lockfree" does not say enough
1147 Non-volatile atomic functions
1148 Wrong argument type of I/O stream manipulators setprecision() and setw()
1149 Reformulating NonemptyRange axiom
1150 wchar_t, char16_t and char32_t filenames
1151 Behavior of the library in the presence of threads is incompletely specified
1152 Expressions parsed differently than intended
1153 Standard library needs review for constructors to be explicit to avoid treatment as initializer-list constructor
1154 complex should accept integral types
1155 Reference should be to C99
1156 Constraints on bitmask and enumeration types to be tightened
1157 Local types can now instantiate templates
1158 Encouragement to use monotonic clock
1159 Unclear spec for resource_deadlock_would_occur
1160 future_error public constructor is 'exposition only'
1161 Unnecessary unique_future limitations
1162 shared_future should support an efficient move constructor
1163 shared_future is inconsistent with shared_ptr
1164 promise::swap should pass by rvalue reference
1165 Unneeded promise move constructor
1166 Allocator-specific move/copy break model of move-constructor and move-assignment
1167 pair<T,U> doesn't model LessThanComparable in unconstrained code even if T and U do.
1168 Odd wording for bitset equality operators
1169 num_get not fully compatible with strto*
1170 String char-like types no longer PODs
1171 duration types should be literal
1172 select_on_container_(copy|move)_construction over-constrained
1173 "Equivalence" wishy-washiness
1174 Type property predicates
1175 unordered complexity
1176 Make thread constructor non-variadic
1177 Improve "diagnostic required" wording
1178 Header dependencies
1179 Probably editorial in [structure.specifications]
1180 Missing string_type member typedef in class sub_match
1181 Invalid sub_match comparison operators
1182 Unfortunate hash dependencies
1183 basic_ios::set_rdbuf may break class invariants
1184 Feature request: dynamic bitset
1185 Iterator categories and output iterators
1186 Forward list could model a stack
1187 std::decay
1188 Unordered containers should have a minimum load factor as well as a maximum
1189 Awkward interface for changing the number of buckets in an unordered associative container
1190 Setting the maximum load factor should return the previous value
1191 tuple get API should respect rvalues
1192 basic_string missing definitions for cbegin / cend / crbegin / crend
1193 default_delete cannot be instantiated with incomplete types
1194 Unintended queue constructor
1195 "Diagnostic required" wording is insufficient to prevent UB
1196 move semantics undefined for priority_queue
1197 Can unordered containers have bucket_count() == 0?
1198 Container adaptor swap: member or non-member?
1199 Missing extended copy constructor in container adaptors
1200 "surprising" char_traits<T>::int_type requirements
1201 Do we always want to unwrap ref-wrappers in make_tuple
1202 integral_constant needs a spring clean
1203 More useful rvalue stream insertion
1204 Global permission to move
1205 Some algorithms could more clearly document their handling of empty ranges
1206 Incorrect requires for move_backward and copy_backward
1207 Underspecified std::list operations?
1208 valarray initializer_list constructor has incorrect effects
1209 match_results should be moveable
1210 Iterator reachability should not require a container
1211 Move iterators should be restricted as input iterators
1212 result of post-increment/decrement operator
1213 Meaning of valid and singular iterator underspecified
1214 Insufficient/inconsistent key immutability requirements for associative containers
1215 list::merge with unequal allocators
1216 LWG 1066 Incomplete?
1217 Quaternion support
1218 mutex destructor synchronization
1219 unique_lock::lock and resource_deadlock_would_occur
1220 What does condition_variable wait on?
1221 condition_variable wording
1222 condition_variable incorrect effects for exception safety
1223 condition_variable_any lock matching?
1224 condition_variable_any support for recursive mutexes?
1225 C++0x result_of issue
1226 Incomplete changes of #890
1227 <bitset> synopsis overspecified
1228 User-specialized nothrow type traits
1229 error_code operator= typo
1230 mem_fn and variadic templates
1231 weak_ptr comparisons incompletely resolved
1232 Still swap's with rvalue-references
1233 Missing unique_ptr signatures in synopsis
1234 "Do the right thing" and NULL
1235 Issue with C++0x random number proposal
1236 reserved identifiers in programs not using the library
1237 Constrained error_code/error_condition members
1238 Defining algorithms taking iterator for range
1239 Defect report
1240 Deleted comparison functions of std::function not needed
1241 unique_copy needs to require EquivalenceRelation
1242 Enable SCARY iterators
1243 Missing operator+= (initializer_list<T>) for valarray
1244 wait_*() in *future for synchronous functions
1245 std::hash<string> & co
1246 vector::resize() missing efficiency guarantee
1247 auto_ptr is overspecified
1248 Equality comparison for unordered containers
1249 basic_ios default ctor
1250 <bitset> still overspecified
1251 move constructing basic_stringbuf
1252 wbuffer_convert::state_type inconsistency
1253 invalidation of iterators and emplace vs. insert inconsistence in assoc. containers
1254 Misleading sentence in vector<bool>::flip
1255 declval should be added to the library
1256 weak_ptr comparison functions should be removed
1257 Header <ios> still contains a concept_map
1258 std::function Effects clause impossible to satisfy
1259 Should initializer-list constructors move elements?
1260 is_constructible<int*,void*> reports true
1261 Insufficent overloads for to_string / to_wstring
1262 std::less<std::shared_ptr<T>> is underspecified
1263 missing swap overloads for regex
1264 quick_exit support for freestanding implementations
1265 longjmp and destructors
1266 shared_future::get and deferred async functions
1267 Incorrect wording for condition_variable_any::wait_for
1268 The Mutex requirements in 30.4.1 and 30.4.2 are wrong
1269 Associated state doesn't account for async
1270 result_of should be moved to <type_traits>
1271 CR undefined in duration operators
1272 confusing declarations of promise::set_value
1273 future::valid should be callable on an invalid future
1274 atomic_future constructor
1275 Creating and setting futures
1276 forwardlist missing allocator constructors
1277 std::thread::id should be trivially copyable
1278 Inconsistent return values for forward_list::insert_after
1279 forbid [u|bi]nary_function specialization
1280 Initialization of stream iterators
1281 CopyConstruction and Assignment between ratios having the same normalized form
1282 A proposal to add std::split algorithm
1283 MoveConstructible and MoveAssignable need clarification of moved-from state
1284 vector<bool> initializer_list constructor missing an allocator argument
1285 allocator_traits call to new
1286 allocator_traits::select_on_container_copy_construction type-o
1287 std::function requires CopyConstructible target object
1288 std::function assignment from rvalues
1289 Generic casting requirements for smart pointers
1290 Don't require [u|bi]nary_function inheritance
1291 Exceptions thrown during promise::set_value
1292 std::function should support all callable types
1293 unique_ptr<T[], D> needs to get rid of unspecified-pointer-type
1294 Difference between callable wrapper and forwarding call wrapper unclear
1295 Contradictory call wrapper requirements
1296 map and multimap value_compare overspecified
1297 unique_ptr's relational operator functions should induce a total order
1298 Missing specialization of ctype_byname<char>
1299 Confusing typo in specification for get_time
1300 Circular definition of promise::swap
1301 clear() and assignment
1302 different emplace semantics for sequence and associated containers
1303 shared_ptr, unique_ptr, and rvalue references v2
1304 Missing preconditions for shared_future
1305 preconditions for atomic_future
1306 pointer and const_pointer for <array>
1307 exception_ptr and allocator pointers don't understand !=
1308 Concerns about initializer_list overloads of min, max, and minmax
1309 Missing expressions for Move/CopyConstructible
1310 forward_list splice_after from lvalues
1311 multi-pass property of Forward Iterator underspecified
1312 vector::data no longer returns a raw pointer
1313 Seed sequence's param function not useful for pure output iterator
1314 NULL and nullptr
1315 return type of async
1316 scoped_allocator_adaptor operator== has no definition
1317 make_hash
1318 N2982 removes previous allocator capabilities
1319 Containers should require an iterator that is at least a Forward Iterator
1320 Header for iter_swap
1321 scoped_allocator_adaptor construct and destroy don't use allocator_traits
1322 Explicit CopyConstructible requirements are insufficient
1323 basic_string::replace should use const_iterator
1324 Still too many implicit conversions for pair and tuple
1325 bitset
1326 Missing/wrong preconditions for pair and tuple functions
1327 templates defined in <cmath> replacing C macros with the same name
1328 istream extractors not setting failbit if eofbit is already set
1329 Data races on vector<bool>
1330 Move container requirements into requirements tables
1331 incorporate move special member functions into library
1332 Let Hash objects throw!
1333 Missing forwarding during std::function invocation
1334 Insert iterators are broken for some proxy containers compared to C++03
1335 Insufficient requirements for tuple::operator<()
1336 Conflicting Error Conditions for packaged_task::operator()
1337 Swapped arguments in regex_traits::isctype
1338 LWG 1205 incorrectly applied
1339 uninitialized_fill_n should return the end of its range
1340 Why does forward_list::resize take the object to be copied by value?
1341 Reporting out-of-bound values on numeric string conversions
1342 is_* traits for binding operations can't be meaningfully specialized
1343 unexpected output required of strings
1344 Replace throw() with noexcept
1345 Library classes should have noexcept move operations
1346 Apply noexcept where library specification does not permit exceptions
1347 Apply noexcept judiciously throughout the library
1348 Exception safety of unspecified types
1349 swap should not throw
1350 Implicit contructors accidentally made some library types move-only
1351 Replace dynamic exception specifications with noexcept
1352 Apply noexcept where library specification says "Throws: Nothing"
1353 Clarify the state of a moved-from object
1354 The definition of deadlock excludes cases involving a single thread
1355 The definition of move-assignment operator is redundant
1356 The definition of move-constructor is redundant
1357 Library bitmask types to not satisfy the bimask type requirements
1358 Add <chrono> and <ratio> to freestanding implementations
1359 Add <tuple> and <utility> to freestanding implementations
1360 Add <atomic> to free-standing implementations
1361 Does use of std::size_t in a header imply that typedef name is available to users?
1362 Description of binding to rvalue-references should use the new 'xvalue' vocabulary
1363 offsetof should be marked noexcept
1364 It is not clear how exception_ptr is synchronized
1365 Thread-safety of handler functions
1366 New-handler and data races
1367 Deprecate library support for checking dynamic exception specifications
1368 Thread safety of std::uncaught_exception()
1369 rethrow_exception may introduce data races
1370 throw_with_nested should not use perfect forwarding
1371 Standard exceptions require stronger no-throw guarantees
1372 Adopt recommended practice for standard error categories
1373 Customizable traits should have their own headers
1374 Clarify moved-from objects are "toxic"
1375 reference_type should not have been removed from the allocator requirements
1376 Allocator interface is not backward compatible
1377 The revised forward is not compatible with access-control
1378 pair and tuple have too many conversions
1379 pair copy-assignment not consistent for references
1380 pair and tuple of references need to better specify move-semantics
1381 Replace pair's range support by proper range facility
1382 pair and tuple constructors should forward arguments
1383 Inconsistent defaulted move/copy members in pair and tuple
1384 Function pack_arguments is poorly named
1385 tuple_cat should be a single variadic signature
1386 pack_arguments overly complex
1387 Range support by tuple should be removed
1388 LWG 1281 incorrectly accepted
1389 Compile-time rational arithmetic and overflow
1390 Limit speculative compilation for constructible/convertible traits
1391 constructible/convertible traits and access control
1392 result_of should support pointer-to-data-member
1393 Trivial traits imply noexcept
1394 is_constructible reports false positives
1395 Inconsistent reference links should be unified
1396 regex should support allocators
1397 Deprecate '98 binders
1398 Users should be able to specialize functors without depending on whole <functional> header
1399 function does not need an explicit default constructor
1400 FCD function does not need an explicit default constructor
1401 Provide support for unique_ptr<T> == nullptr
1402 nullptr constructors for smart pointers should be constexpr
1403 Inconsistent definitions for allocator_arg
1404 pointer_traits should have a size_type member
1405 Move scoped_allocator_adaptor into separate header
1406 Support hashing smart-pointers based on owner
1407 Synch shared_ptr constructors taking movable types
1408 Allow recycling of pointers after undeclare_no_pointers
1409 Specify whether monotonic_clock is a distinct type or a typedef
1410 Add a feature-detect macro for monotonic_clock
1411 Add a compile-time flag to detect monotonic_clock
1412 Make monotonic clocks mandatory
1413 Specify whether high_resolution_clock is a distinct type or a typedef
1414 Fixing remaining dead links to POS_T and OFF_T
1415 Iterator stability bans the short-string optimization
1416 forward_list::erase_after should not be allowed to throw
1417 front/back on a zero-sized array should be undefined
1418 Effects of resize(size()) on a deque
1419 forward_list::erase_after should return an iterator
1420 Effects of resize(size()) on a list
1421 Accidental move-only library types due to new core language rules
1422 vector<bool> iterators are not random access
1423 map constructor accepting an allocator as single parameter should be explicit
1424 multimap constructor accepting an allocator as a single parameter should be explicit
1425 set constructor accepting an allocator as a single parameter should be explicit
1426 multiset constructor accepting an allocator as a single parameter should be explicit
1427 unordered_map constructor accepting an allocator as a single parameter should be explicit
1428 unordered_multimap constructor accepting an allocator as a single parameter should be explicit
1429 unordered_set constructor accepting an allocator as a single parameter should be explicit
1430 unordered_multiset constructor accepting an allocator as a single parameter should be explicit
1431 is_permutation must be more restrictive
1432 random_shuffle signatures are inconsistent
1433 random_shuffle and shuffle should have consistent signatures
1434 For min/max functions replace variadic arguments by initializer_list argument
1435 Unclear returns specifications for C99 complex number functions
1436 Random number engine constructor concerns
1437 Mersenne twister meaningless for word sizes less than two
1438 No definition for base()
1439 Return from densities() functions?
1440 Incorrect specification for piecewise_linear_distribution
1441 Floating-point test functions are incorrectly specified
1442 "happens-before" should be "synchronizes-with"
1443 Imposed happens-before edges are not made transitive
1444 OFF_T is not defined
1445 Several iostreams member functions incorrectly specified
1446 Move and swap for I/O streams
1447 Request to resolve issue LWG 1328
1448 Concerns about basic_stringbuf::str(basic_string) postconditions
1449 Incomplete specification of header <cinttypes>
1450 Contradiction in regex_constants
1451 regex should support allocators
1452 "target sequence" is not defined
1453 Default constructed match_results behavior for certain operations
1454 Ensure C compatibility for atomics
1455 C language compatibility for atomics
1456 Missing fixed-size atomic_ typedefs
1457 Splitting lock-free properties
1458 Overlapping evaluations are allowed
1459 Overlapping evaluations are allowed
1460 Missing lock-free property for type bool should be added
1461 Rename all ATOMIC_* macros as STD_ATOMIC_*
1462 Ambiguous value assignment to atomic_bool
1463 Inconsistent value assignment for atomic_bool
1464 Underspecified typedefs for atomic integral types
1465 Missing arithmetic operators for atomic_address
1466 Silent const breakage by compare_exchange_* member functions
1467 Deriving atomic<T*> from atomic_address breaks type safety
1468 atomic_address::compare_exchange_* member functions should match atomic_compare_exchange_* free functions
1469 atomic<T*> inheritance from atomic_address breaks type safety
1470 "Same-ness" curiosities
1471 Default constructor of atomics needs specification
1472 Incorrect semantics of atomic_init
1473 Incomplete memory order specifications
1474 weak compare-and-exchange confusion
1475 weak compare-and-exchange confusion II
1476 Meaningless specification of spurious failure
1477 weak compare-and-exchange confusion III
1478 Clarify race conditions in atomics initialization
1479 Fence functions should be extern "C"
1480 Atomic fences don't have synchronizes with relation
1481 Missing Lockable requirements
1482 Timeout operations are under-specified
1483 __STDCPP_THREADS spelling
1484 Need a way to join a thread with a timeout
1485 Unclear thread::id specification
1486 Value of this_thread::get_id() underspecified for detached thread
1487 Clock related operations exception specifications conflict
1488 Improve interoperability between the C++0x and C1x threads APIs
1489 unlock functions and unlock mutex requirements are inconsistent
1490 Mutex requirements too stringent
1491 try_lock does not guarantee forward progress
1492 Mutex requirements should not be bound to threads
1493 Add mutex, recursive_mutex, is_locked function
1494 Term "are serialized" not defined
1495 Condition variable wait_for return value insufficient
1496 condition_variable not implementable
1497 lock() postcondition can not be generally achieved
1498 Unclear specification for [thread.condition]
1499 Condition variables preclude wakeup optimization
1500 Consider removal of native_handle()
1501 Specification for managing associated asynchronous state has problems
1502 Specification of [futures.state] unclear
1503 "associated asynchronous state" must go
1504 Term "are serialized" is not defined
1505 Synchronization between promise::set_value and future::get
1506 set_exception with a null pointer
1507 promise::XXX_at_thread_exit functions have no synchronization requirements
1508 Rename packaged_task::operator bool()
1509 No restriction on calling future::get more than once
1510 Should be undefined behaviour to call atomic_future operations unless valid()
1511 Synchronize the move-constructor for atomic_future
1512 Conflict in specification: block or join?
1513 'launch' enum too restrictive
1514 packaged_task constructors need review
1515 packaged_task::make_ready_at_thread_exit has no synchronization requirements
1516 No specification for which header contains auto_ptr
1517 default_delete's default constructor should be trivial
1518 Waiting for deferred functions
1519 bucketsize() const only for unordered set
1520 INVOKE on member data pointer with too many arguments
1521 Requirements on internal pointer representations in containers
1522 conj specification is now nonsense
1523 noexcept for Clause 29
1524 Allocation functions are missing happens-before requirements and guarantees
1525 Effects of resize(size()) on a vector
1526 C++ should not impose thread safety requirements on C99 library implementations
2000 Missing definition of packaged_task specialization of uses_allocator
2001 Class template basic_regex uses non existent string_type
2002 Class template match_results does not specify the semantics of operator==
2003 String exception inconsistency in erase.
2004 duration::operator* has template parameters in funny order
2005 unordered_map::insert(T&&) protection should apply to map too
2006 emplace broken for associative containers
2007 Incorrect specification of return value for map<>::at()
2008 Conflicting Error Conditions for packaged_task::operator()
2009 Reporting out-of-bound values on numeric string conversions
2010 is_* traits for binding operations can't be meaningfully specialized
2011 Unexpected output required of strings
2012 Associative maps should insert pair, not tuple
2013 Do library implementers have the freedom to add constexpr?
2014 More restrictions on macro names
2015 Incorrect pre-conditions for some type traits
2016 Allocators must be no-throw swappable
2017 std::reference_wrapper makes incorrect usage of std::result_of
2018 [CD] regex_traits::isctype Returns clause is wrong
2019 isblank not supported by std::locale
2020 Time utility arithmetic constexpr functions have invalid effects
2021 Further incorrect usages of result_of
2022 reference_wrapper<T>::result_type is underspecified
2023 Incorrect requirements for lock_guard and unique_lock
2024 Inconsistent implementation requirements for atomic<integral> and atomic<T*>
2025 Incorrect semantics of move assignment operator of packaged_task
2026 hash should be std qualified for unordered container
2027 Initialization of the stored task of a packaged_task
2028 messages_base::catalog overspecified
2029 Missing 'noexcept' on basic_regex move-assignment operator
2030 packaged_task::result_type should be removed
2031 std::future<>::share() only applies to rvalues
2032 Incorrect synchronization clause of async function
2033 Preconditions of reserve, shrink_to_fit, and resize functions
2034 Initialization of atomics is misspecified so that it doesn't preserve sequential consistency
2035 Output iterator requirements are broken
2036 istream >> char and eofbit
2037 atomic free functions incorrectly specified
2038 Missing definition for incrementable iterator
2039 Issues with std::reverse and std::copy_if
2040 Missing type traits related to is_convertible
2041 Stage 2 accumulate incompatibilty
2042 Comparing forward_list::before_begin() to forward_list::end()
2043 std{in,out,err} should be usable as field names
2044 No definition of "Stable" for copy algorithms
2045 forward_list::merge and forward_list::splice_after with unequal allocators
2046 shared_future(future<R>&&) should be allowed to throw
2047 Incorrect "mixed" move-assignment semantics of unique_ptr
2048 Unnecessary mem_fn overloads
2049 is_destructible is underspecified
2050 Unordered associative containers do not use allocator_traits to define member types
2051 Explicit tuple constructors for more than one parameter
2052 Mixup between mapped_type and value_type for associative containers
2053 Errors in regex bitmask types
2054 time_point constructors need to be constexpr
2055 std::move in std::accumulate and other algorithms
2056 future_errc enums start with value 0 (invalid value for broken_promise)
2057 time_point + duration semantics should be made constexpr conforming
2058 valarray and begin/end
2059 C++0x ambiguity problem with map::erase
2060 unique_ptr<T[]>(nullptr_t) missing noexcept
2061 make_move_iterator and arrays
2062 Effect contradictions w/o no-throw guarantee of std::function swaps
2063 Contradictory requirements for string move assignment
2064 More noexcept issues in basic_string
2065 Minimal allocator interface
2066 Missing specification of vector::resize(size_type)
2067 packaged_task should have deleted copy c'tor with const parameter
2068 std::pair not C++03-compatible with defaulted copy c'tor
2069 Inconsistent exception spec for basic_string move constructor
2070 allocate_shared should use allocator_traits<A>::construct
2071 std::valarray move-assignment
2072 Unclear wording about capacity of temporary buffers
2073 Library exceptions that take string arguments
2074 Off by one error in std::reverse_copy
2075 Progress guarantees, lock-free property, and scheduling assumptions
2076 Bad CopyConstructible requirement in set constructors
2077 Further incomplete constraints for type traits
2078 Throw specification of async() incomplete
2079 Required pow() overloads
2080 Specify when once_flag becomes invalid
2081 Allocator requirements should include CopyConstructible
2082 Misleading complexity requirements in <algorithm>
2083 const-qualification on weak_ptr::owner_before
2084 basic_string use of charT*
2085 Wrong description of effect 1 of basic_istream::ignore
2086 Overly generic type support for math functions
2087 iostream_category() and noexcept
2088 std::terminate problem
2089 std::allocator::construct should use uniform initialization
2090 Minor Overconstraint in Mutex Types
2091 Misplaced effect in m.try_lock_for()
2092 Vague Wording for condition_variable_any
2093 Throws clause of condition_variable::wait with predicate
2094 duration conversion overflow shouldn't participate in overload resolution
2095 promise and packaged_task missing constructors needed for uses-allocator construction
2096 Incorrect constraints of future::get in regard to MoveAssignable
2097 packaged_task constructors should be constrained
2098 Minor Inconsistency between promise::set_value and promise::set_value_at_thread_exit
2099 Unnecessary constraints of va_start() usage
2100 timed waiting functions cannot timeout if launch::async policy used
2101 Some transformation types can produce impossible types
2102 Why is std::launch an implementation-defined type?
2103 std::allocator_traits<std::allocator<T>>::propagate_on_container_move_assignment
2104 unique_lock move-assignment should not be noexcept
2105 Inconsistent requirements on const_iterator's value_type
2106 move_iterator wrapping iterators returning prvalues
2107 Some iterator category should guarantee the lifetime of references
2108 No way to identify allocator types that always compare equal
2109 Incorrect requirements for hash specializations
2110 remove can't swap but note says it might
2111 Which unexpected/terminate handler is called from the exception handling runtime?
2112 User-defined classes that cannot be derived from
2113 Do library implementers have the freedom to add final to non-polymorphic components?
2114 Incorrect "contextually convertible to bool" requirements
2115 Undefined behaviour for valarray assignments with mask_array index?
2116 is_nothrow_constructible and destructors
2117 ios_base manipulators should have showgrouping/noshowgrouping
2118 [CD] unique_ptr for array does not support cv qualification conversion of actual argument
2119 Missing hash specializations for extended integer types
2120 What should async do if neither 'async' nor 'deferred' is set in policy?
2121 app for string streams
2122 merge() stability for lists versus forward lists
2123 merge() allocator requirements for lists versus forward lists
2124 Seed sequence over-specified
2125 TimedMutex specification problem
2126 Several specification problems in regard to mutex requirements
2127 Move-construction with raw_storage_iterator
2128 Absence of global functions cbegin/cend
2129 User specializations of std::initializer_list
2130 Missing ordering constraints
2131 Member function getline taking a string as parameter
2132 std::function ambiguity
2133 Attitude to overloaded comma for iterators
2134 Redundant Mutex requirement?
2135 Unclear requirement for exceptions thrown in condition_variable::wait()
2136 Postconditions vs. exceptions
2137 Misleadingly constrained post-condition in the presence of exceptions
2138 atomic_flag::clear should not accept memory_order_consume
2139 What is a user-defined type?
2140 Meaning of notify_all_at_thread_exit synchronization requirement?
2141 common_type trait produces reference types
2142 packaged_task::operator() synchronization too broad?
2143 ios_base::xalloc should be thread-safe
2144 Missing noexcept specification in type_index
2145 error_category default constructor
2146 Are reference types Copy/Move-Constructible/Assignable or Destructible?
2147 Unclear hint type in Allocator's allocate function
2148 Hashing enums should be supported directly by std::hash
2149 Concerns about 20.8/5
2150 Unclear specification of find_end
2151 basic_string<>::swap semantics ignore allocators
2152 Instances of standard container types are not swappable
2153 Narrowing of the non-member swap contract
2154 What exactly does compile-time complexity imply?
2155 Macro __bool_true_false_are_defined should be removed
2156 Unordered containers' reserve(n) reserves for n-1 elements
2157 How does std::array<T,0> initialization work when T is not default-constructible?
2158 Conditional copy/move in std::vector
2159 atomic_flag initialization
2160 Unintended destruction ordering-specification of resize
2161 const equivalence of std::map
2162 allocator_traits::max_size missing noexcept
2163 nth_element requires inconsistent post-conditions
2164 What are the semantics of vector.emplace(vector.begin(), vector.back())?
2165 std::atomic<X> requires X to be nothrow default constructible
2166 Heap property underspecified?
2167 Copy assignment requirements of Containers
2168 Inconsistent specification of uniform_real_distribution constructor
2169 Missing reset() requirements in unique_ptr specialization
2170 Aggregates cannot be DefaultConstructible
2171 "swappable" undefined for swapping lvalue and rvalue
2172 Does atomic_compare_exchange_* accept v == nullptr arguments?
2173 The meaning of operator + in the description of the algorithms
2174 wstring_convert::converted() should be noexcept
2175 wstring_convert and wbuffer_convert validity
2176 Special members for wstring_convert and wbuffer_convert
2177 Requirements on Copy/MoveInsertable
2178 Allocator requirement changes not mentioned Annex C
2179 enable_shared_from_this and construction from raw pointers
2180 Exceptions from std::seed_seq operations
2181 Exceptions from seed sequence operations
2182 Container::[const_]reference types are misleadingly specified
2183 Muddled allocator requirements for match_results constructors
2184 Muddled allocator requirements for match_results assignments
2185 Missing throws clause for future/shared_future::wait_for/wait_until
2186 Incomplete action on async/launch::deferred
2187 vector<bool> is missing emplace and emplace_back member functions
2188 Reverse iterator does not fully support targets that overload operator&
2189 Throwing swap breaks unordered containers' state
2190 Condition variable specification
2191 Incorrect specification of match_results(match_results&&)
2192 Validity and return type of std::abs(0u) is unclear
2193 Default constructors for standard library containers are explicit
2194 Impossible container requirements for adaptor types
2195 Missing constructors for match_results
2196 Specification of is_*[copy/move]_[constructible/assignable] unclear for non-referencable types
2197 Specification of is_[un]signed unclear for non-arithmetic types
2198 max_load_factor(z) makes no strong guarantees, but bans useful behavior
2199 unordered containers are required to have an initial max load factor of 1.0
2200 Data race avoidance for all containers, not only for sequences
2201 Missing macro entries from C standard library
2202 Missing allocator support by async
2203 scoped_allocator_adaptor uses wrong argument types for piecewise construction
2204 reverse_iterator should not require a second copy of the base iterator
2205 Problematic postconditions of regex_match and regex_search
2206 Inaccuracy in initializer_list constructor requirements
2207 basic_string::at should not have a Requires clause
2208 std::reverse_iterator should be a literal type
2209 assign() overspecified for sequence containers
2210 Missing allocator-extended constructor for allocator-aware containers
2211 Replace ambiguous use of "Allocator" in container requirements
2212 tuple_size for const pair request <tuple> header
2213 Return value of std::regex_replace
2214 Clarify basic_ios::init call restrictions
2215 (unordered) associative container functors should be CopyConstructible
2216 regex_replace(basic_string) allocator handling
2217 operator==(sub_match, string) slices on embedded '\0's
2218 Unclear how containers use allocator_traits::construct()
2219 INVOKE-ing a pointer to member with a reference_wrapper as the object expression
2220 Under-specification of operator== for regex_token_iterator
2221 No formatted output operator for nullptr
2222 Inconsistency in description of forward_list::splice_after single-element overload
2223 shrink_to_fit effect on iterator validity
2224 Ambiguous status of access to non-live objects
2225 Unrealistic header inclusion checks required
2226 wstring_convert methods do not take allocator instance
2227 Stateful comparison objects in associative containers
2228 Missing SFINAE rule in unique_ptr templated assignment
2229 Standard code conversion facets underspecified
2230 "see below" for initializer-list constructors of unordered containers
2231 DR 704 removes complexity guarantee for clear()
2232 [CD] The char_traits specializations should declare their length(), compare(), and find() members constexpr
2233 bad_function_call::what() unhelpful
2234 assert() should allow usage in constant expressions
2235 Undefined behavior without proper requirements on basic_string constructors
2236 kill_dependency unconditionally noexcept
2237 <cuchar> macros
2238 Problematic iterator-pair constructor of containers
2239 min/max/minmax requirements
2240 Probable misuse of term "function scope" in [thread.condition]
2241 <cstdalign> and #define of alignof
2242 [uninitialized_]copy_n() defect
2243 istream::putback problem
2244 Issue on basic_istream::seekg
2245 packaged_task::reset() memory allocation
2246 unique_ptr assignment effects w.r.t. deleter
2247 Type traits and std::nullptr_t
2248 numeric_limits::is_iec559 misnamed
2249 [CD] Remove gets from <cstdio>
2250 Follow-up On Library Issue 2207
2251 C++ library should define ssize_t
2252 Strong guarantee on vector::push_back() still broken with C++11?
2253 [arrays.ts] dynarray should state which container requirements aren't met
2254 [arrays.ts] Is dynarray an allocator-aware container?
2255 [arrays.ts] dynarray constructor ambiguity
2256 On vector iterator invalidation
2257 Simplify container requirements with the new algorithms
2258 a.erase(q1, q2) unable to directly return q2
2259 Issues in rules for member functions
2260 Missing requirement for Allocator::pointer
2261 Are containers required to use their 'pointer' type internally?
2262 Requirement for unique_ptr<T>::get_deleter()(p) to be able to destroy the unique_ptr
2263 Comparing iterators and allocator pointers with different const-character
2264 [arrays.ts] std::dynarray defines its initializer-list constructor in terms of a non-existent constructor
2265 29.3p9 appears to rule out some acceptable executions
2266 vector and deque have incorrect insert requirements
2267 partial_sort_copy underspecified for ranges of two different types
2268 Setting a default argument in the declaration of a member function assign of std::basic_string
2269 Container iterators and argument-dependent lookup
2270 Inconsistent to_string overloads
2271 regex_traits::lookup_classname specification unclear
2272 quoted should use char_traits::eq for character comparison
2273 regex_match ambiguity
2274 Does map::operator[] value-initialize or default-insert a missing element?
2275 [CD] Why is forward_as_tuple not constexpr?
2276 Missing requirement on std::promise::set_exception
2277 [arrays.ts] <dynarray> is missing in 24.7/1
2278 User-defined literals for Standard Library types
2279 Carefully state effects of list::splice function
2280 begin/end for arrays should be constexpr and noexcept
2281 C99 cross-reference typo in [using.linkage]
2282 [fund.ts] Incorrect is_assignable constraint in optional::op=(U&&)
2283 [fund.ts] optional declares and then does not define an operator<()
2284 Inconsistency in allocator_traits::max_size
2285 make_reverse_iterator
2286 stringbuf::underflow() underspecified
2287 [fund.ts] Incorrect exception safety for optional copy assignment operator
2288 Inconsistent requirements for shared mutexes
2289 constexpr guarantees of defaulted functions still insufficient
2290 Top-level "SFINAE"-based constraints should get a separate definition in Clause 17
2291 std::hash is vulnerable to collision DoS attack
2292 Find a better phrasing for "shall not participate in overload resolution"
2293 Wrong facet used by num_put::do_put
2294 <cstdlib> should declare abs(double)
2295 Locale name when the provided Facet is a nullptr
2296 std::addressof should be constexpr
2297 [CD] Missing type requirements for std::exchange
2298 [CD] is_nothrow_constructible is always false because of create<>
2299 [CD] Effects of inaccessible key_compare::is_transparent type are not clear
2300 [CD] Redundant sections for map and multimap members should be removed
2301 Why is std::tie not constexpr?
2302 Passing null pointer to placement new
2303 Explicit instantiation of std::vector<UserType> broken?
2304 Complexity of count in unordered associative containers
2305 [fund.ts] optional forwarding construction/assignment
2306 match_results::reference should be value_type&, not const value_type&
2307 Should the Standard Library use explicit only when necessary?
2308 Clarify container destructor requirements w.r.t. std::array
2309 mutex::lock() should not throw device_or_resource_busy
2310 Public exposition only member in std::array
2311 Allocator requirements should be further minimized
2312 tuple's constructor constraints need to be phrased more precisely
2313 tuple_size should always derive from integral_constant<size_t, N>
2314 apply() should return decltype(auto) and use decay_t before tuple_size
2315 weak_ptr should be movable
2316 weak_ptr::lock() should be atomic
2317 The type property queries should be UnaryTypeTraits returning size_t
2318 basic_string's wording has confusing relics from the copy-on-write era
2319 basic_string's move constructor should not be noexcept
2320 select_on_container_copy_construction() takes allocators, not containers
2321 Moving containers should (usually) be required to preserve iterators
2322 Associative(initializer_list, stuff) constructors are underspecified
2323 vector::resize(n, t)'s specification should be simplified
2324 Insert iterator constructors should use addressof()
2325 minmax_element()'s behavior differing from max_element()'s should be noted
2326 uniform_int_distribution<unsigned char> should be permitted
2327 Non-power-of-two URNGs should be forbidden
2328 Rvalue stream extraction should use perfect forwarding
2329 regex_match()/regex_search() with match_results should forbid temporary strings
2330 regex("meow", regex::icase) is technically forbidden but should be permitted
2331 regex_constants::collate's effects are inaccurately summarized
2332 regex_iterator/regex_token_iterator should forbid temporary regexes
2333 [fund.ts] Hashing disengaged optional<T> objects
2334 atomic's default constructor requires "uninitialized" state even for types with non-trivial default-constructor
2335 array<array<int, 3>, 4> should be layout-compatible with int[4][3]
2336 is_trivially_constructible/is_trivially_assignable traits are always false
2337 shared_ptr operator*() should not be noexcept
2338 §[re.traits]/7 expects of locale facets something not guaranteed by [locale.facet]/4
2339 Wording issue in nth_element
2340 Replacement allocation functions declared as inline
2341 Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)
2342 User conversion to wchar_t const* or to wchar_t not invoked for operator<<
2343 Is the value of the ECMA-262 RegExp object's multiline property really false?
2344 quoted()'s interaction with padding is unclear
2345 integer_sequence should have a self-typedef ::type
2346 integral_constant's member functions should be marked noexcept
2347 reverse_iterator::operator[] calls const version of current[]
2348 charT('1') is not the wide equivalent of '1'
2349 Clarify input/output function rethrow behavior
2350 min, max, and minmax should be constexpr
2351 Does .seed() completely reset state of engine?
2352 Is a default-constructed std::seed_seq intended to produce a predictable .generate()?
2353 std::next is over-constrained
2354 Unnecessary copying when inserting into maps with braced-init syntax
2355 "s" UDL suffix should be reserved for a compile-time string library type
2356 Stability of erasure in unordered associative containers
2357 Remaining "Assignable" requirement
2358 Apparently-bogus definition of is_empty type trait
2359 How does regex_constants::nosubs affect basic_regex::mark_count()?
2360 reverse_iterator::operator*() is unimplementable
2361 Apply 2299 resolution throughout library
2362 unique, associative emplace() should not move/copy the mapped_type constructor arguments when no insertion happens
2363 Defect in [thread.sharedtimedmutex.class]
2364 deque and vector pop_back don't specify iterator invalidation requirements
2365 Missing noexcept in shared_ptr::shared_ptr(nullptr_t)
2366 istreambuf_iterator end-of-stream equality
2367 pair and tuple are not correctly implemented for is_constructible with no args
2368 Replacing global operator new
2369 constexpr max(initializer_list) vs max_element
2370 Operations involving type-erased allocators should not be noexcept in std::function
2371 [fund.ts] No template aliases defined for new type traits
2372 Assignment from int to std::string
2373 Make new entities and names in namespace std conforming extensions
2374 [fund.ts] Remarks for optional::to_value are too restrictive
2375 Is [iterator.requirements.general]/9 too broadly applied?
2376 bad_weak_ptr::what() overspecified
2377 std::align requirements overly strict
2378 Behaviour of standard exception types
2379 Obtaining native handle of the current thread
2380 May <cstdlib> provide long ::abs(long) and long long ::abs(long long)?
2381 Inconsistency in parsing floating point numbers
2382 Unclear order of container update versus object destruction on removing an object
2383 Overflow cannot be ill-formed for chrono::duration integer literals
2384 Allocator's deallocate function needs better specification
2385 function::assign allocator argument doesn't make sense
2386 function::operator= handles allocators incorrectly
2387 More nested types that must be accessible and unambiguous
2388 Handling self-assignment in the proposed library function std::exchange
2389 [fund.ts] function::operator= is over-specified and handles allocators incorrectly
2390 [fund.ts] Invocation types and rvalues
2391 basic_string is missing non-const data()
2392 "character type" is used but not defined
2393 std::function's Callable definition is broken
2394 locale::name specification unclear — what is implementation-defined?
2395 [fund.ts] Preconditions: is defined nowhere
2396 underlying_type doesn't say what to do for an incomplete enumeration type
2397 map<K, V>::emplace and explicit V constructors
2398 type_info's destructor shouldn't be required to be virtual
2399 shared_ptr's constructor from unique_ptr should be constrained
2400 shared_ptr's get_deleter() should use addressof()
2401 std::function needs more noexcept
2402 basic_string(const basic_string& str, size_type pos, size_type n = npos) shouldn't use Allocator()
2403 stof() should call strtof() and wcstof()
2404 mismatch()'s complexity needs to be updated
2405 rotate()'s return value is incorrect when middle == first
2406 negative_binomial_distribution should reject p == 1
2407 packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit
2408 SFINAE-friendly common_type/iterator_traits is missing in C++14
2409 [fund.ts] SFINAE-friendly common_type/iterator_traits should be removed from the fundamental-ts
2410 [fund.ts] shared_ptr<array>'s constructor from unique_ptr should be constrained
2411 shared_ptr is only contextually convertible to bool
2412 promise::set_value() and promise::get_future() should not race
2413 assert macro is overconstrained
2414 Member function reentrancy should be implementation-defined
2415 Inconsistency between unique_ptr and shared_ptr
2416 [fund.ts] std::experimental::any allocator support is unimplementable
2417 [fund.ts.v2] std::experimental::optional::operator< and LessThanComparable requirement
2418 [fund.ts] apply does not work with member pointers
2419 Clang's libc++ extension to std::tuple
2420 function<void(ArgTypes...)> does not discard the return value of the target object
2421 Non-specification of handling zero size in std::align [ptr.align]
2422 std::numeric_limits<T>::is_modulo description: "most machines" errata
2423 Missing specification slice_array, gslice_array, mask_array, indirect_array copy constructor
2424 29.5 should state that atomic types are not trivially copyable
2425 operator delete(void*, size_t) doesn't invalidate pointers sufficiently
2426 Issue about compare_exchange
2427 Container adaptors as sequence containers, redux
2428 "External declaration" used without being defined
2429 std::basic_ostringstream is missing an allocator-extended constructor
2430 Heterogeneous container lookup should be enabled using meta-function instead of nested type
2431 Missing regular expression traits requirements
2432 initializer_list assignability
2433 uninitialized_copy()/etc. should tolerate overloaded operator&
2434 shared_ptr::use_count() is efficient
2435 reference_wrapper::operator()'s Remark should be deleted
2436 Comparators for associative containers should always be CopyConstructible
2437 iterator_traits<OutIt>::reference can and can't be void
2438 std::iterator inheritance shouldn't be mandated
2439 unique_copy() sometimes can't fall back to reading its output
2440 seed_seq::size() should be noexcept
2441 Exact-width atomic typedefs should be provided
2442 call_once() shouldn't DECAY_COPY()
2443 std::array member functions should be constexpr
2444 Inconsistent complexity for std::sort_heap
2445 "Stronger" memory ordering
2446 Unspecialized std::tuple_size should be defined
2447 Allocators and volatile-qualified value types
2448 Non-normative Container destructor specification
2449 vector::insert invalidates end()?
2450 (greater|less|greater_equal|less_equal)<void> do not yield a total order for pointers
2451 [fund.ts.v2] optional<T> should 'forward' T's implicit conversions
2452 is_constructible, etc. and default arguments
2453 §[iterator.range] and now [iterator.container] aren't available via <initializer_list>
2454 Add raw_storage_iterator::base() member
2455 Allocator default construction should be allowed to throw
2456 Incorrect exception specifications for 'swap' throughout library
2457 std::begin() and std::end() do not support multi-dimensional arrays correctly
2458 N3778 and new library deallocation signatures
2459 std::polar should require a non-negative rho
2460 LWG issue 2408 and value categories
2461 Interaction between allocators and container exception safety guarantees
2462 std::ios_base::failure is overspecified
2463 [fund.ts] Incorrect complexity for sample() algorithm
2464 try_emplace and insert_or_assign misspecified
2465 SFINAE-friendly common_type is nearly impossible to specialize correctly and regresses key functionality
2466 allocator_traits::max_size() default behavior is incorrect
2467 is_always_equal has slightly inconsistent default
2468 Self-move-assignment of library types
2469 Wrong specification of Requires clause of operator[] for map and unordered_map
2470 Allocator's destroy function should be allowed to fail to instantiate
2471 copy_n's number of InputIterator increments unspecified
2472 Heterogeneous comparisons in the standard library can result in ambiguities
2473 basic_filebuf's relation to C FILE semantics
2474 <cmath> functions unfriendly to integral_constant arguments
2475 Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs
2476 scoped_allocator_adaptor is not assignable
2477 Inconsistency of wordings in std::vector::erase() and std::deque::erase()
2478 Unclear how wstring_convert uses cvtstate
2479 Unclear how wbuffer_convert uses cvtstate
2480 Error handling of wbuffer_convert unclear
2481 wstring_convert should be more precise regarding "byte-error string" etc.
2482 §[c.strings] Table 73 mentions nonexistent functions
2483 throw_with_nested() should use is_final
2484 rethrow_if_nested() is doubly unimplementable
2485 get() should be overloaded for const tuple&&
2486 mem_fn() should be required to use perfect forwarding
2487 bind() should be const-overloaded, not cv-overloaded
2488 Placeholders should be allowed and encouraged to be constexpr
2489 mem_fn() should be noexcept
2490 <regex> needs lots of noexcept
2491 std::less<T*> in constant expression
2492 Clarify requirements for comp
2493 initializer_list supports incomplete classes
2494 [fund.ts.v2] ostream_joiner needs noexcept
2495 There is no such thing as an Exception Safety element
2496 Certain hard-to-avoid errors not in the immediate context are not allowed to be triggered by the evaluation of type traits
2497 Use of uncaught_exception()
2498 operator>>(basic_istream&&, T&&) returns basic_istream&, but should probably return basic_istream&&
2499 operator>>(basic_istream&, CharT*) makes it hard to avoid buffer overflows
2500 [fund.ts.v2] fundts.memory.smartptr.shared.obs/6 should apply to cv-unqualified void
2501 std::function requires POCMA/POCCA
2502 std::function does not use allocator::construct
2503 multiline option should be added to syntax_option_type
2504 basic_streambuf is not an abstract class
2505 auto_ptr_ref creation requirements underspecified
2506 Underspecification of atomics
2507 codecvt_mode should be a bitmask type
2508 §[new.delete.dataraces] wording needs to be updated
2509 [fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target
2510 Tag types should not be DefaultConstructible
2511 scoped_allocator_adaptor piecewise construction does not require CopyConstructible
2512 Y2K bites; what is an "unambiguous year identifier"?
2513 Missing requirements for basic_string::value_type
2514 Type traits must not be final
2515 [fund.ts.v2] Certain comparison operators of observer_ptr do not match synopsis
2516 [fund.ts.v2] Public "exposition only" members in observer_ptr
2517 [fund.ts.v2] Two propagate_const assignment operators have incorrect return type
2518 [fund.ts.v2] Non-member swap for propagate_const should call member swap
2519 Iterator operator-= has gratuitous undefined behaviour
2520 N4089 broke initializing unique_ptr<T[]> from a nullptr
2521 [fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support
2522 [fund.ts.v2] Contradiction in set_default_resource specification
2523 std::promise synopsis shows two set_value_at_thread_exit()'s for no apparent reason
2524 generate_canonical can occasionally return 1.0
2525 [fund.ts.v2] get_memory_resource should be const and noexcept
2526 [fund.ts.v2] Incorrect precondition for experimental::function::swap
2527 [fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default
2528 Order of std::tuple construction unspecified
2529 Assigning to enable_shared_from_this::__weak_this twice
2530 Clarify observable side effects of releasing a shared state
2531 future::get should explicitly state that the shared state is released
2532 Satisfying a promise at thread exit
2533 [concurr.ts] Constrain threads where future::then can run a continuation
2534 Constrain rvalue stream operators
2535 Inconsistency between ostream::write and ostream::operator<<
2536 What should <complex.h> do?
2537 Constructors for priority_queue taking allocators should call make_heap
2538 [parallel.ts] Requirements on data race behavior of iterators and swap should be clarified
2539 [fund.ts.v2] invocation_trait definition definition doesn't work for surrogate call functions
2540 unordered_multimap::insert hint iterator
2541 [parallel.ts] Headers for ExecutionPolicy algorithm overloads
2542 Missing const requirements for associative containers
2543 LWG 2148 (hash support for enum types) seems under-specified
2544 istreambuf_iterator(basic_streambuf<charT, traits>* s) effects unclear when s is 0
2545 Simplify wording for bind without explicitly specified return type
2546 Implementability of locale-sensitive UnicodeEscapeSequence matching
2547 Container requirements (and other library text) should say "strict total order", not just "total order"
2548 Missing vfscanf from <cstdio>
2549 Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references
2550 Wording of unordered container's clear() method complexity
2551 [fund.ts.v2] "Exception safety" cleanup in library fundamentals required
2552 priority_queue doesn't work with move-only types
2553 [fund.ts.v2] basic_string_view substring constructor
2554 Swapping multidimensional arrays is never noexcept
2555 [fund.ts.v2] No handling for over-aligned types in optional
2556 Wide contract for future::share()
2557 Logical operator traits are broken in the zero-argument case
2558 [fund.ts.v2] Logical operator traits are broken in the zero-argument case
2559 Error in LWG 2234's resolution
2560 is_constructible underspecified when applied to a function type
2561 [fund.ts.v2] Incorrect exception specifications for 'swap' in C++ Extensions for Library Fundamentals
2562 Consistent total ordering of pointers by comparison functors
2563 LWG 2259 relaxes requirements, perhaps unintentionally
2564 [fund.ts.v2] std::experimental::function constructors taking allocator arguments may throw exceptions
2565 std::function's move constructor should guarantee nothrow for reference_wrappers and function pointers
2566 Requirements on the first template parameter of container adaptors
2567 Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits
2568 [fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits
2569 conjunction and disjunction requirements are too strict
2570 [fund.ts.v2] conjunction and disjunction requirements are too strict
2571 §[map.modifiers]/2 imposes nonsensical requirement on insert(InputIterator, InputIterator)
2572 The remarks for shared_ptr::operator* should apply to cv-qualified void as well
2573 [fund.ts.v2] std::hash<std::experimental::shared_ptr<T>> does not work for arrays
2574 [fund.ts.v2] std::experimental::function::operator=(F&&) should be constrained
2575 [fund.ts.v2] experimental::function::assign should be removed
2576 istream_iterator and ostream_iterator should use std::addressof
2577 {shared,unique}_lock should use std::addressof
2578 Iterator requirements should reference iterator traits
2579 Inconsistency wrt Allocators in basic_string assignment vs. basic_string::assign
2580 Who is definitive: operator= or assign?
2581 Specialization of <type_traits> variable templates should be prohibited
2582 §[res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits
2583 There is no way to supply an allocator for basic_string(str, pos)
2584 <regex> ECMAScript IdentityEscape is ambiguous
2585 forward_list::resize(size_type, const value_type&) effects incorrect
2586 Wrong value category used in scoped_allocator_adaptor::construct()
2587 "Convertible to bool" requirement in conjunction and disjunction
2588 [fund.ts.v2] "Convertible to bool" requirement in conjunction and disjunction
2589 match_results can't satisfy the requirements of a container
2590 Aggregate initialization for std::array
2591 std::function's member template target() should not lead to undefined behaviour
2592 Require that chrono::duration_casts from smaller durations to larger durations do not overflow
2593 Moved-from state of Allocators
2594 Contradicting definition of empty shared_ptr on shared_ptr(nullptr, d)
2595 reverse_iterator::operator[]'s return type revisited
2596 vector::data() should use addressof
2597 std::log misspecified for complex numbers
2598 addressof works on temporaries
2599 Library incomplete type permission phrase is unclear
2600 ios_base must store inaccessible iostate flags
2601 [filesys.ts] [PDTS] Make namespaces consistent with Library TS policy
2602 [filesys.ts] [PDTS] Tighten specification when there is no reasonable behavior
2603 [filesys.ts] [PDTS] Filename length needs bullet item
2604 [filesys.ts] [PDTS] Need definition of dot and dot-dot
2605 [filesys.ts] [PDTS] Parent of root directory unspecified
2606 [filesys.ts] [PDTS] Path depth is underspecified
2607 [filesys.ts] [PDTS] Unhelpful comment for struct space_info
2608 [filesys.ts] [PDTS] file_time_type underspecified
2609 [filesys.ts] [PDTS] Unclear why range-based-for functions return different types
2610 [filesys.ts] [PDTS] Apparently inconsistent return types from several functions
2611 [filesys.ts] [PDTS] Lack of relative() operation function
2612 [filesys.ts] [PDTS] uintmax_t too small for large file sizes
2613 [filesys.ts] [PDTS] Missing actual error conditions thrown
2614 [filesys.ts] [PDTS] Incorrect postconditions for path copy/move constructor
2615 [filesys.ts] [PDTS] Missing behavior for characters with no representation
2616 [filesys.ts] [PDTS] Append behavior underspecified if target is empty
2617 [filesys.ts] [PDTS] path member swap() unnecessary
2618 [filesys.ts] [PDTS] is_absolute() return clause confusing
2619 [filesys.ts] [PDTS] Consider using quoted manipulators
2621 [filesys.ts] [PDTS] directory_entry operator== needs clarification
2622 [filesys.ts] [PDTS] directory_iterator underspecified
2623 [filesys.ts] [PDTS] Request for create_regular_file() and/or touch()
2624 [filesys.ts] [PDTS] Incorrect effects clause for path copy
2625 [filesys.ts] [PDTS] Copying equivalent paths effects not specified
2626 [filesys.ts] [PDTS] Equivalence is a volatile property
2627 [filesys.ts] [PDTS] Return value of uintmax_t on error?
2628 [filesys.ts] [PDTS] Possible last_write_time() postcondition?
2629 [filesys.ts] [PDTS] Unclear semantics of read_symlink on error
2630 [filesys.ts] [PDTS] remove() must avoid race
2631 [filesys.ts] [PDTS] POSIX guarantees atomicity for rename()
2632 [filesys.ts] [PDTS] system_complete() example needs clarification
2633 [filesys.ts] [PDTS] unique_path() is a security vulnerability
2634 [filesys.ts] [PDTS] enum class directory_options has no summary
2635 [filesys.ts] [PDTS] directory_options::skip_permission_denied is not used
2636 [filesys.ts] [PDTS] copy_options::copy_symlinks is not used
2637 [filesys.ts] [PDTS] All functions with error_code arguments should be noexcept
2638 [filesys.ts] [PDTS] Make certain functions noexcept and drop error_code version
2639 [filesys.ts] [PDTS] permissions() is missing from synopsis
2640 [filesys.ts] [PDTS] class directory_entry should retain operator const path&() from V2
2641 [filesys.ts] [PDTS] directory_iterator, recursive_directory_iterator, move construct/assign should be noexcept
2642 [filesys.ts] [PDTS] class path should have defaulted constructors/destructor/assignments.
2643 [filesys.ts] [PDTS] path::compare(const string&) should be path::compare(const string_type&)
2644 [filesys.ts] [PDTS] enum classes copy_options and perms should be bitmask types
2645 [filesys.ts] [PDTS] create_directory should refer to perms::all instead of Posix S_IRWXU|S_IRWXG|S_IRWXO
2646 [filesys.ts] [PDTS] Do we really need generic*?
2647 [filesys.ts] [PDTS] last_write_time() uses ill-formed cast
2648 [filesys.ts] [PDTS] path::template<class charT>string() conversion rules
2649 [filesys.ts] [PDTS] path and directory_entry move ctors should not be noexcept
2650 [filesys.ts] [PDTS] path::compare(const string& s) wrong argument type
2651 [filesys.ts] [PDTS] directory_iterator, recursive_directory_iterator, pointer/reference typedefs wrong
2652 [filesys.ts] [PDTS] Better to avoid deriving from std::iterator
2653 [filesys.ts] [PDTS] directory_entry multithreading concerns
2654 [filesys.ts] [PDTS] Concerns with security and testability
2655 [filesys.ts] [PDTS] Clarify Error reporting
2656 [filesys.ts] [PDTS] Feature test macro for TS version
2657 [filesys.ts] [PDTS] Inappropriate use of "No diagnostic is required"
2658 [filesys.ts] [PDTS] POSIX utime() is obsolescent
2659 [filesys.ts] [PDTS] Invalid expressions for bitmask types
2660 [filesys.ts] [PDTS] Incorrect Throws specification for absolute()
2661 [filesys.ts] Surprising equivalent() behavior if neither file exists
2662 [filesys.ts] Allocator requirements unspecified
2663 Enable efficient retrieval of file size from directory_entry
2664 operator/ (and other append) semantics not useful if argument has root
2665 remove_filename() post condition is incorrect
2666 Bitmask operations should use bitmask terms
2667 path::root_directory() description is confusing
2668 path::operator+= is defined, but not operator+
2669 recursive_directory_iterator effects refers to non-existent functions
2670 system_complete refers to undefined variable 'base'
2671 Errors in Copy
2672 Should is_empty use error_code in its specification?
2673 status() effects cannot be implemented as specified
2674 Bidirectional iterator requirement on path::iterator is very expensive
2675 register_callback can fail
2676 Provide filesystem::path overloads for File-based streams
2677 directory_entry::status is not allowed to be cached as a quality-of-implementation issue
2678 std::filesystem enum classes overspecified
2679 Inconsistent Use of Effects and Equivalent To
2680 Add "Equivalent to" to filesystem
2681 filesystem::copy() cannot copy symlinks
2682 filesystem::copy() won't create a symlink to a directory
2683 filesystem::copy() says "no effects"
2684 priority_queue lacking comparator typedef
2685 shared_ptr deleters must not not throw on move construction
2686 Why is std::hash specialized for error_code, but not error_condition?
2687 {inclusive,exclusive}_scan misspecified
2688 clamp misses preconditions and has extraneous condition on result
2689 Parallel versions of std::copy and std::move shouldn't be in order
2690 invoke<R>
2691 money_base::space and do_put: U+0020 versus fill
2692 Overspecification of lvalueness of bitmask elements
2693 constexpr for various std::complex arithmetic and value operators
2694 Application of LWG 436 accidentally deleted definition of "facet"
2695 "As if" unclear in [member.functions]
2696 Interaction between make_shared and enable_shared_from_this is underspecified
2697 [concurr.ts] Behavior of future/shared_future unwrapping constructor when given an invalid future
2698 Effect of assign() on iterators/pointers/references
2699 Missing restriction in [numeric.requirements]
2700 resource_adaptor went missing
2701 Unclear requirement in [memory.resource.private]
2702 num_put::do_put(..., bool) performs ill-formed do_put call
2703 No provision for fill-padding when boolalpha is set
2704 recursive_directory_iterator's members should require '*this is dereferenceable'
2705 Questionable precondition on Sequence containers a.assign(n, t)
2706 Error reporting for recursive_directory_iterator::pop() is under-specified
2707 path construction and assignment should have "string_type&&" overloads
2708 recursive_directory_iterator::recursion_pending() is incorrectly specified
2709 offsetof is unnecessarily imprecise
2710 "Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics
2711 path is convertible from approximately everything under the sun
2712 copy_file(from, to, ...) has a number of unspecified error conditions
2713 More missing allocator-extended constructors for unordered containers
2714 complex stream extraction underspecified
2715 What is 'aggregate initialization syntax'?
2716 Specification of shuffle and sample disallows lvalue URNGs
2717 scoped_allocator_adaptor uses forward to do move's job
2718 Parallelism bug in [algorithms.parallel.exec] p2
2719 permissions function should not be noexcept due to narrow contract
2720 permissions function incorrectly specified for symlinks
2721 remove_all has incorrect post conditions
2722 equivalent incorrectly specifies throws clause
2723 Do directory_iterator and recursive_directory_iterator become the end iterator upon error?
2724 The protected virtual member functions of memory_resource should be private
2725 filesystem::exists(const path&, error_code&) error reporting
2726 [recursive_]directory_iterator::increment(error_code&) is underspecified
2727 Parallel algorithms with constexpr specifier
2728 status(p).permissions() and symlink_status(p).permissions() are not specified
2729 Missing SFINAE on std::pair::operator=
2730 numeric_limits primary template definition
2731 Existence of lock_guard<MutexTypes...>::mutex_type typedef unclear
2732 Questionable specification of path::operator/= and path::append
2733 [fund.ts.v2] gcd / lcm and bool
2734 Questionable specification in [fs.path.concat]
2735 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
2736 nullopt_t insufficiently constrained
2737 Consider relaxing object size restrictions for single-object allocation functions
2738 is_constructible with void types
2739 Issue with time_point non-member subtraction with an unsigned duration
2740 constexpr optional<T>::operator->
2741 is_partitioned requirements need updating
2742 Inconsistent string interface taking string_view
2743 p0083r3 node_handle private members missing "exposition only" comment
2744 any's in_place constructors
2745 [fund.ts.v2] Implementability of LWG 2451
2746 Inconsistency between requirements for emplace between optional and variant
2747 Possibly redundant std::move in [alg.foreach]
2748 swappable traits for optionals
2749 swappable traits for variants
2750 [fund.ts.v2] LWG 2451 conversion constructor constraint
2751 shared_ptr deleter not specified to observe expired weak_ptr instances
2752 "Throws:" clauses of async and packaged_task are unimplementable
2753 Optional's constructors and assignments need constraints
2754 The in_place constructors and emplace functions added by P0032R3 don't require CopyConstructible
2755 §[] uses non-existent basic_string_view::to_string function
2756 C++ WP optional<T> should 'forward' T's implicit conversions
2757 std::string{}.insert(3, "ABCDE", 0, 1) is ambiguous
2758 std::string{}.assign("ABCDE", 0, 1) is ambiguous
2759 gcd / lcm and bool for the WP
2760 non-const basic_string::data should not invalidate iterators
2761 directory_entry comparisons are members
2762 unique_ptr operator*() should be noexcept
2763 common_type_t<void, void> is undefined
2764 Are <cstddint> macros optional?
2765 Did LWG 1123 go too far?
2766 Swapping non-swappable types
2767 not_fn call_wrapper can form invalid types
2768 any_cast and move semantics
2769 Redundant const in the return type of any_cast(const any&)
2770 tuple_size<const T> specialization is not SFINAE compatible and breaks decomposition declarations
2771 Broken Effects of some basic_string::compare functions in terms of basic_string_view
2772 Inconsistency in the insert(node) interface
2773 Making std::ignore constexpr
2774 std::function construction vs assignment
2775 reverse_iterator is does not compile for fancy pointers
2776 shared_ptr unique() and use_count()
2777 basic_string_view::copy should use char_traits::copy
2778 basic_string_view is missing constexpr
2779 [networking.ts] Relax requirements on buffer sequence iterators
2780 basic_string_view::copy is missing constexpr
2781 Contradictory requirements for std::function and std::reference_wrapper
2782 scoped_allocator_adaptor constructors must be constrained
2783 stack::emplace() and queue::emplace() should return decltype(auto)
2784 Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse
2785 quoted should work with basic_string_view
2786 Annex C should mention shared_ptr changes for array support
2787 §[fs.file_status.cons] doesn't match class definition
2788 basic_string range mutators unintentionally require a default constructible allocator
2789 Equivalence of contained objects
2790 Missing specification of istreambuf_iterator::operator->
2791 string_view objects and strings should yield the same hash values
2792 [fund.ts.v2] gcd and lcm should support a wider range of input values
2793 Awkward conflation of trivial special members of istream_iterator
2794 Missing requirements for allocator pointers
2795 §[global.functions] provides incorrect example of ADL use
2796 tuple should be a literal type
2797 Trait precondition violations
2798 Definition of path in terms of a string
2799 noexcept-specifications in shared_future
2800 constexpr swap
2801 Default-constructibility of unique_ptr
2802 shared_ptr constructor requirements for a deleter
2803 hash for arithmetic, pointer and standard library types should not throw
2804 Unconditional constexpr default constructor for istream_iterator
2805 void and reference type alternatives in variant, variant<> and index()
2806 Base class of bad_optional_access
2807 std::invoke should use std::is_nothrow_callable
2808 Requirements for fpos and stateT
2809 variant hash requirements
2810 use_count and unique in shared_ptr
2811 "Selected constructor" wording is incorrect for optional/variant/any
2812 Range access is available with <string_view>
2813 std::function should not return dangling references
2814 [fund.ts.v2] to_array should take rvalue reference as well
2815 quick_exit can deadlock
2816 resize_file has impossible postcondition
2817 std::hash for nullptr_t
2818 "::std::" everywhere rule needs tweaking
2819 Unspecified Return type: elements
2820 Clarify <cstdint> macros
2821 std::launder() should be marked as [[nodiscard]]
2822 Resolution for LWG 2742 introduces ambiguities
2823 std::array initialization is still not permissive enough
2824 list::sort should say that the order of elements is unspecified if an exception is thrown
2825 LWG 2756 breaks class template argument deduction for optional
2826 string_view iterators use old wording
2827 is_trivially_constructible and non-trivial destructors
2828 Clarify <cstdalign> (following adoption of P0063r3)
2829 LWG 2740 leaves behind vacuous words
2830 insert_return_type is only defined for containers with unique keys
2831 Equality can be defined when Hash function objects have different behaviour
2832 §[fpos.operations] strange requirement for P(i)
2833 Library needs to specify what it means when it declares a function constexpr
2834 Resolution LWG 2223 is missing wording about end iterators
2835 LWG 2536 seems to misspecify <tgmath.h>
2836 More string operations should be noexcept
2837 gcd and lcm should support a wider range of input values
2838 is_literal_type specification needs a little cleanup
2839 Self-move-assignment of library types, again
2840 directory_iterator::increment is seemingly narrow-contract but marked noexcept
2841 Use of "Equivalent to" in [strings]
2842 in_place_t check for optional::optional(U&&) should decay U
2843 Unclear behavior of std::pmr::memory_resource::do_allocate()
2844 Stability of a_uniq.insert(i, j)
2845 enable_if, result_of, common_type and aligned_storage do not meet the definition of TransformationTrait
2846 Undefined phrase "effectively cast"
2847 sin(float) should call sinf(float)
2848 Pass-through threshold for pool allocator
2849 Why does !is_regular_file(from) cause copy_file to report a "file already exists" error?
2850 std::function move constructor does unnecessary work
2851 std::filesystem enum classes are now underspecified
2852 Specifications of operator== for std::basic_strings and std::basic_string_views are difficult to conform to
2853 Possible inconsistency in specification of erase in [vector.modifiers]
2854 wstring_convert provides no indication of incomplete input or output
2855 std::throw_with_nested("string_literal")
2856 std::async should be marked as [[nodiscard]]
2857 {variant,optional,any}::emplace should return the constructed value
2858 LWG 2472: actually an incompatibility with C++03
2859 Definition of reachable in [ptr.launder] misses pointer arithmetic from pointer-interconvertible object
2860 launder and base class subobjects
2861 basic_string should require that charT match traits::char_type
2862 LWG 2756 should be accepted
2863 Undo default_order changes of maps and sets
2864 Merge shared_ptr changes from Library Fundamentals to C++17
2865 Resolve all open Library issues for C++17
2866 Incorrect derived classes constraints
2867 Bad footnote about explicit exception-specification
2868 Missing specification of bad_any_cast::what()
2869 Deprecate sub-clause [locale.stdcvt]
2870 Default value of parameter theta of polar should be dependent
2871 User specializations of type traits should be ill-formed
2872 Add definition for direct-non-list-initialization
2873 Add noexcept to several shared_ptr related functions
2874 Constructor shared_ptr::shared_ptr(Y*) should be constrained
2875 shared_ptr::shared_ptr(Y*, D, […]) constructors should be constrained
2876 shared_ptr::shared_ptr(const weak_ptr<Y>&) constructor should be constrained
2877 Strengthen meaning of "empty shared_ptr<T>" in dynamic_pointer_cast
2878 Missing DefaultConstructible requirement for istream_iterator default constructor
2879 Removing C dependencies from signal handler wording
2880 Relax complexity specifications for non-sequenced policies
2881 Adopt section III of P0308R0
2882 Clarify variant construction
2883 The standard library should provide string_view parameters instead or in addition for functions defined with char const * or string const & as parameter types.
2884 Relational operators for containers should sfinae; if the underlying type is not comparable, neither should the container be
2885 The relational operators of optional and variant completely reflect the semantics of the element types — this is inconsistent with other types in the library
2886 Keep the empty() functions in any
2887 Revert the changes from P0156R0: variadic lock_guard
2888 Variables of library tag types need to be inline variables
2889 Mark constexpr global variables as inline
2890 The definition of 'object state' applies only to class types
2891 Relax library requirements on volatile types
2892 Relax the prohibition on libraries adding constexpr
2893 Parsing Hexadecimally in P0067R4
2894 The function template std::apply() is required to be constexpr, but std::invoke() isn't
2895 Passing function types to result_of and is_callable
2896 The contents of <codecvt> are underspecified
2897 array::iterator and array::const_iterator should be literal types
2898 Prefer not to use member typedefs as constructor parameters
2899 is_(nothrow_)move_constructible and tuple, optional and unique_ptr
2900 The copy and move constructors of optional are not constexpr
2901 Variants cannot properly support allocators
2902 variant should only support complete types
2903 The form of initialization for the emplace-constructors is not specified
2904 Make variant move-assignment more exception safe
2905 is_constructible_v<unique_ptr<P, D>, P, D const &> should be false when D is not copy constructible
2906 There is no ability to supply an allocator for the control block when constructing a shared_ptr from a unique_ptr
2907 Semantics for destroying the deleter and the control-block of a shared_ptr are unclear
2908 The less-than operator for shared pointers could do more
2909 User specializations of is_execution_policy should be ill-formed
2910 Template deduction and integral_constant
2911 An is_aggregate type trait is needed
2912 Add a deduction guide for class template duration
2913 Containers need deduction guides
2914 std::array does not support class-template deduction from initializers
2915 The three container adapters should each have a deduction guide
2916 Insert iterators should each have an instantiation guide to initialize from a container
2917 Parallel algorithms cannot easily work with InputIterators
2918 Possible need for extra storage in inner_product
2919 The specification for adjacent_difference has baked-in sequential semantics
2920 Add a deduction guide for creating a shared_future from a future rvalue
2921 packaged_task and type-erased allocators
2922 The *_constant<> templates do not make use of template<auto>
2923 noexcept is inconsistently applied across headers which import components of the C standard library
2924 An ExecutionPolicy overload for inner_product() seems impractical
2925 Template argument deduction is not used in the standard library
2926 INVOKE(f, t1, t2,... tN) and INVOKE(f, t1, t2,... tN, R) are too similar
2927 Encoding a functor and argument types as a function signature for is_callable and result_of is fragile
2928 is_callable is not a good name
2929 basic_string misuses "Effects: Equivalent to"
2930 Are implementations allowed to split non-member functions into several overloads?
2931 Missed optimization opportunity with single-argument std::next
2932 Constraints on parallel algorithm implementations are underspecified
2933 PR for LWG 2773 could be clearer
2934 optional<const T> doesn't compare with T
2935 What should create_directories do when p already exists but is not a directory?
2936 Path comparison is defined in terms of the generic format
2937 Is equivalent("existing_thing", "not_existing_thing") an error?
2938 basic_string_view::const_iterator should be literal types
2939 Some type-completeness constraints of traits are overspecified
2940 result_of specification also needs a little cleanup
2941 §[thread.req.timing] wording should apply to both member and namespace-level functions
2942 LWG 2873's resolution missed weak_ptr::owner_before
2943 Problematic specification of the wide version of basic_filebuf::open
2944 LWG 2905 accidentally removed requirement that construction of the deleter doesn't throw an exception
2945 Order of template parameters in optional comparisons
2946 LWG 2758's resolution missed further corrections
2947 Clarify several filesystem terms
2948 unique_ptr does not define operator<< for stream output
2949 Unclear complexity requirements: space vs. time
2950 std::byte operations are misspecified
2951 iterator_traits should SFINAE for void* and function pointers
2952 iterator_traits should work for pointers to cv T
2953 LWG 2853 should apply to deque::erase too
2954 Specialization of the convenience variable templates should be prohibited
2955 to_chars / from_chars depend on std::string
2956 filesystem::canonical() still defined in terms of absolute(p, base)
2957 bind's specification doesn't apply the cv-qualification of the call wrapper to the callable object
2958 Moves improperly defined as deleted
2959 char_traits<char16_t>::eof is a valid UTF-16 code unit
2960 [fund.ts.v3] nonesuch is insufficiently useless
2961 Bad postcondition for set_default_resource
2962 Iterators of Containers of move-only types do not model InputIterator
2963 Algorithms with underspecified iterator requirements
2964 Apparently redundant requirement for dynamic_pointer_cast
2965 Non-existing path::native_string() in filesystem_error::what() specification
2966 Incomplete resolution of US 74
2967 std::equal on empty ranges
2968 Inconsistencies between basic_string reserve and vector/unordered_map/unordered_set reserve functions
2969 polymorphic_allocator::construct() shouldn't pass resource()
2970 Return type of std::visit misspecified
2971 variant should require Destructible types
2972 What is is_trivially_destructible_v<int>?
2973 inplace_merge exact comparison count complexity prohibits useful real-world optimizations
2974 Diagnose out of bounds tuple_element/variant_alternative
2975 Missing case for pair construction in scoped and polymorphic allocators
2976 Dangling uses_allocator specialization for packaged_task
2977 unordered_meow::merge() has incorrect Throws: clause
2978 Hash support for pmr::string and friends
2979 aligned_union should require complete object types
2980 Cannot compare_exchange empty pointers
2981 Remove redundant deduction guides from standard library
2982 Making size_type consistent in associative container deduction guides
2983 money_put::do_put underspecified
2984 put_money(99) is unnecessarily undefined
2985 std::reverse should be permitted to be vectorized
2986 Handling of multi-character collating elements by the regex FSM is underspecified
2987 Relationship between traits_inst.lookup_collatename and the regex FSM is underspecified with regards to ClassAtomCollatingElement
2988 Clause 32 cleanup missed one typename
2989 path's stream insertion operator lets you insert everything under the sun
2990 optional::value_type is not always a value type
2991 variant copy constructor missing noexcept(see below)
2992 system_category() and error_code::error_code() should be constexpr
2993 reference_wrapper<T> conversion from T&&
2994 Needless UB for basic_string and basic_string_view
2995 basic_stringbuf default constructor forbids it from using SSO capacity
2996 Missing rvalue overloads for shared_ptr operations
2997 LWG 491 and the specification of {forward_,}list::unique
2998 Requirements on function objects passed to {forward_,}list-specific algorithms
2999 §[thread.decaycopy] issue
3000 monotonic_memory_resource::do_is_equal uses dynamic_cast unnecessarily
3001 weak_ptr::element_type needs remove_extent_t
3002 [networking.ts] basic_socket_acceptor::is_open() isn't noexcept
3003 <future> still has type-erased allocators in promise
3004 §[string.capacity] and §[vector.capacity] should specify time complexity for capacity()
3005 Destruction order of arrays by make_shared/allocate_shared only recommended?
3006 Constructing a basic_stringbuf from a string — where does the allocator come from?
3007 allocate_shared should rebind allocator to cv-unqualified value_type for construction
3008 make_shared (sub)object destruction semantics are not specified
3009 Including <string_view> doesn't provide std::size/empty/data
3010 [networking.ts] uses_executor says "if a type T::executor_type exists"
3011 Requirements for assert(E) inconsistent with C
3012 atomic<T> is unimplementable for non-is_trivially_copy_constructible T
3013 (recursive_)directory_iterator construction and traversal should not be noexcept
3014 More noexcept issues with filesystem operations
3015 copy_options::unspecified underspecified
3016 optional and over-aligned types
3017 list splice functions should use addressof
3018 shared_ptr of function type
3019 Presentation of "program defined classes derived from error_category" [syserr.errcat.derived] unclear and contains mistakes
3020 [networking.ts] Remove spurious nested value_type buffer sequence requirement
3021 [networking.ts] Relax pointer equivalence requirement for ConstBufferSequence
3022 is_convertible<derived*, base*> may lead to ODR
3023 Clarify unspecified call wrappers
3024 variant's copies must be deleted instead of disabled via SFINAE
3025 Map-like container deduction guides should use pair<Key, T>, not pair<const Key, T>
3026 filesystem::weakly_canonical still defined in terms of canonical(p, base)
3027 [networking.ts] DynamicBuffer prepare exception specification
3028 Container requirements tables should distinguish const and non-const variables
3029 pop_heap over-constrains input
3030 Who shall meet the requirements of try_lock?
3031 Algorithms and predicates with non-const reference arguments
3032 ValueSwappable requirement missing for push_heap and make_heap
3033 basic_string move ctor is underspecified
3034 P0767R1 breaks previously-standard-layout types
3035 std::allocator's constructors should be constexpr
3036 polymorphic_allocator::destroy is extraneous
3037 polymorphic_allocator and incomplete types
3038 polymorphic_allocator::allocate should not allow integer overflow to create vulnerabilities
3039 Unnecessary decay in thread and packaged_task
3040 basic_string_view::starts_with Effects are incorrect
3041 Unnecessary decay in reference_wrapper
3042 is_literal_type_v should be inline
3043 Bogus postcondition for filesystem_error constructor
3044 Strange specification of max_size() for an allocator
3045 atomic<floating-point> doesn't have value_type or difference_type
3046 Do not require reference_wrapper to support non-referenceable function types
3047 atomic compound assignment operators can cause undefined behavior when corresponding fetch_meow members don't
3048 transform_reduce(exec, first1, last1, first2, init) discards execution policy
3049 Missing wording allowing algorithms to use copies of function objects as substitutes for their parameters
3050 Conversion specification problem in chrono::duration constructor
3051 Floating point classifications were inadvertently changed in P0175
3052 visit is underconstrained
3053 Prohibit error_code construction from rvalues of error_category
3054 uninitialized_copy appears to not be able to meet its exception-safety guarantee
3055 path::operator+=(single-character) misspecified
3056 copy_file() copies which attributes?
3057 Correct copy_options handling
3058 Parallel adjacent_difference shouldn't require creating temporaries
3059 Wrong requirements for map-like associative container assignment?
3060 XXX_scan algorithms are specified to work with move-only T, but are specified to make N copies of T into the destination range
3061 What is the return type of compare_3way?
3062 Unnecessary decay_t in is_execution_policy_v should be remove_cvref_t
3063 Parallel algorithms in <memory> are underspecified
3064 How do uninitialized memory algorithms obtain pointer without undefined behavior?
3065 LWG 2989 missed that all path's other operators should be hidden friends as well
3066 "report a domain error" in [sf.cmath]/1 is underspecified
3067 recursive_directory_iterator::pop must invalidate
3068 Forbid assigning an rvalue basic_string to basic_string_view
3069 Move assigning variant's subobject corrupts data
3070 path::lexically_relative causes surprising results if a filename can also be a root-name
3071 [networking.ts] read_until still refers to "input sequence"
3072 [networking.ts] DynamicBuffer object lifetimes underspecified
3073 [networking.ts] (async_)read and (async_)write don't support DynamicBuffer lvalues
3074 Non-member functions for valarray should only deduce from the valarray
3075 basic_string needs deduction guides from basic_string_view
3076 basic_string CTAD ambiguity
3077 (push|emplace)_back should invalidate the end iterator
3078 directory_entry, directory_iterator and recursive_directory_iterator perform needless path copies
3079 LWG 2935 forgot to fix the existing_p overloads of create_directory
3080 Floating point from_chars pattern specification breaks round-tripping
3081 Floating point from_chars API does not distinguish between overflow and underflow
3082 from_chars specification regarding floating point rounding is inconsistent
3083 What should ios::iword(-1) do?
3084 Termination in C++ is unclear
3085 char_traits::copy precondition too weak
3086 Possible problem in §[new.delete.single]
3087 One final &x in §[list.ops]
3088 forward_list::merge behavior unclear when passed *this
3089 copy_n should require non-overlapping ranges
3090 What is §[time.duration.cons]p4's "no overflow is induced in the conversion" intended to mean?
3091 subsecond-precision time_of_day and durations that seconds cannot convert to
3092 Unclear semantics of enum class bitmask types
3093 LWG 2294/2192 missed a std::abs overload
3094 §[]p4 makes surprising claims about encoding
3095 strstreambuf refers to nonexistent member of fpos, fpos::offset
3096 path::lexically_relative is confused by trailing slashes
3097 basic_stringbuf seekoff effects trigger undefined behavior and have contradictory returns
3098 Misleading example for filesystem::path::filename()
3099 is_assignable<Incomplete&, Incomplete&>
3100 Unnecessary and confusing "empty span" wording
3101 span's Container constructors need another constraint
3102 Clarify span iterator and const_iterator behavior
3103 Errors in taking subview of span should be ill-formed where possible
3104 Fixing duration division
3105 T1 is convertible to T2
3106 nothrow should be inline constexpr rather that extern const
3107 istreambuf_iterator has public exposition-only member
3108 istreambuf_iterator::proxy::operator* should be const
3109 strstreambuf is copyable
3110 Contiguous Iterators should always be Random-Access
3111 Too strong precondition on basic_string constructor
3112 system_error and filesystem_error constructors taking a string may not be able to meet their postconditions
3113 polymorphic_allocator::construct() should more closely match scoped_allocator_adaptor::construct()
3114 [networking.ts] Permit efficient composition when using DynamicBuffer
3115 Unclear description for algorithm includes
3116 OUTERMOST_ALLOC_TRAITS needs remove_reference_t
3117 Missing packaged_task deduction guides
3118 fpos equality comparison unspecified
3119 Program-definedness of closure types
3120 Unclear behavior of monotonic_buffer_resource::release()
3121 tuple constructor constraints for UTypes&&... overloads
3122 __cpp_lib_chrono_udls was accidentally dropped
3123 duration constructor from representation shouldn't be effectively non-throwing
3124 [networking.ts] Unclear how execution_context is intended to store services
3125 duration streaming precondition should be a SFINAE condition
3126 There's no std::sub_match::compare(string_view) overload
3127 basic_osyncstream::rdbuf needs a const_cast
3128 strstream::rdbuf needs a const_cast
3129 regex_token_iterator constructor uses wrong pointer arithmetic
3130 §[input.output] needs many addressof
3131 addressof all the things
3132 Library needs to ban macros named expects or ensures
3133 Modernizing numeric type requirements
3134 [fund.ts.v3] LFTSv3 contains extraneous [meta] variable templates that should have been deleted by P09961
3135 [fund.ts.v3] LFTSv3 contains two redundant alias templates
3136 [fund.ts.v3] LFTSv3 awkward wording in propagate_const requirements
3137 Header for __cpp_lib_to_chars
3138 There is no such thing as assertion-level
3139 contract_violation's special member functions
3140 COMMON_REF is unimplementable as specified
3141 CopyConstructible doesn't preserve source values
3142 std::foo<incomplete> should be ill-formed NDR
3143 monotonic_buffer_resource growth policy is unclear
3144 span does not have a const_pointer typedef
3145 file_clock breaks ABI for C++17 implementations
3146 Excessive unwrapping in std::ref/cref
3147 Definitions of "likely" and "unlikely" are likely to cause problems
3148 <concepts> should be freestanding
3149 DefaultConstructible should require default initialization
3150 UniformRandomBitGenerator should validate min and max
3151 ConvertibleTo rejects conversions from array and function types
3152 common_type and common_reference have flaws in common
3153 Common and common_type have too little in common
3154 Common and CommonReference have a common defect
3155 tuple<any, any>{allocator_arg_t, an_allocator}
3156 ForwardIterator should only mean forward iterator
3157 Allocator destroy and fancy pointer operations must be non-throwing
3158 tuple(allocator_arg_t, const Alloc&) should be conditionally explicit
3159 §[unique.ptr.single] requirements on deleter may be too strict
3160 atomic_ref() = delete; should be deleted
3161 Container adapters mandate use of emplace_back but don't require it
3162 system_error::system_error(error_code ec) not explicit
3163 [networking.ts] Buffer sequence iterator equivalency
3164 Unhelpful "shall not participate" constraints for unique_ptr with reference deleter
3165 All starts_with() overloads should be called "begins_with"
3166 No such descriptive element as Value:
3167 [fund.ts.v3] Does observer_ptr support function types?
3168 Expects: element should be specified in one place
3169 ranges permutation generators discard useful information
3170 is_always_equal added to std::allocator makes the standard library treat derived types as always equal
3171 LWG 2989 breaks directory_entry stream insertion
3172 3-arg std::hypot is underspecified compared to the 2-arg overload
3173 Enable CTAD for ref-view
3174 Precondition on is_convertible is too strong
3175 The CommonReference requirement of concept SwappableWith is not satisfied in the example
3176 Underspecified behavior of unordered containers when Container::key_equal differs from Pred
3177 Limit permission to specialize variable templates to program-defined types
3178 std::mismatch is missing an upper bound
3179 subrange should always model Range
3180 Inconsistently named return type for ranges::minmax_element
3181 split_view::outer_iterator converting constructor is misconstrained
3182 Specification of Same could be clearer
3183 Normative permission to specialize Ranges variable templates
3184 Inconsistencies in bind_front wording
3185 Uses-allocator construction functions missing constexpr and noexcept
3186 ranges removal, partition, and partial_sort_copy algorithms discard useful information
3187 P0591R4 reverted DR 2586 fixes to scoped_allocator_adaptor::construct()
3188 istreambuf_iterator::pointer should not be unspecified
3189 Missing requirement for std::priority_queue
3190 std::allocator::allocate sometimes returns too little storage
3191 std::ranges::shuffle synopsis does not match algorithm definition
3192 §[] functions misbehave for const types
3193 Mandates: and Expects: elements are not defined for types
3194 ConvertibleTo prose does not match code
3195 What is the stored pointer value of an empty weak_ptr?
3196 std::optional<T> is ill-formed is T is an array
3197 std::prev should not require BidirectionalIterator
3198 Bad constraint on std::span::span()
3199 istream >> bitset<0> fails
3200 midpoint should not constrain T is complete
3201 lerp should be marked as noexcept
3202 P0318R1 was supposed to be revised
3203 span element access invalidation
3204 sub_match::swap only swaps the base class
3205 decay_t in the new common_type fallback should be remove_cvref_t
3206 year_month_day conversion to sys_days uses not-existing member function
3207 N in ssize(const T (&)[N]) should be size_t
3208 Boolean's expression requirements are ordered inconsistently
3209 Expression in year::ok() returns clause is ill-formed
3210 allocate_shared is inconsistent about removing const from the pointer passed to allocator construct and destroy
3211 std::tuple<> should be trivially constructible
3212 tuple_element_t<1, const span<int, 42>> is const int
3213 for_each_n and copy_n missing requirements for Size
3214 §[facet.num.get.virtuals] doesn't say what it means for digit grouping to be consistent
3215 variant default constructor has vague constexpr requirements
3216 Rebinding the allocator before calling construct/destroy in allocate_shared
3217 <memory> and <execution> should define __cpp_lib_parallel_algorithm
3218 Modifier for %d parse flag does not match POSIX and format specification
3219 std::array overview container requirements are incorrect
3220 P0558 broke conforming C++14 uses of atomic shared_ptr
3221 Result of year_month arithmetic with months is ambiguous
3222 P0574R1 introduced preconditions on non-existent parameters
3223 lerp should not add the "sufficient additional overloads"
3224 zoned_time constructor from TimeZonePtr does not specify initialization of tp_
3225 zoned_time converting constructor shall not be noexcept
3226 zoned_time constructor from string_view should accept zoned_time<Duration2, TimeZonePtr2>
3227 Ambiguity issue for extract in ordered and unordered associative containers
3228 Surprising variant construction
3229 §[res.on.exception.handling]#3 cannot apply to types with implicitly declared destructors
3230 Format specifier %y/%Y is missing locale alternative versions
3231 year_month_day_last::day specification does not cover !ok() values
3232 Inconsistency in zoned_time deduction guides
3233 Broken requirements for shared_ptr converting constructors
3234 Sufficient Additional Special Math Overloads
3235 parse manipulator without abbreviation is not callable
3236 Random access iterator requirements lack limiting relational operators domain to comparing those from the same range
3237 LWG 3038 and 3190 have inconsistent PRs
3238 Insufficiently-defined behavior of std::function deduction guides
3239 Hidden friends should be specified more narrowly
3240 Headers declare more than entities
3241 chrono-spec grammar ambiguity in §[time.format]
3242 std::format: missing rules for arg-id in width and precision
3243 std::format and negative zeroes
3244 Constraints for Source in §[fs.path.req] insufficiently constrainty
3245 Unnecessary restriction on '%p' parse specifier
3246 What are the constraints on the template parameter of basic_format_arg?
3247 ranges::iter_move should perform ADL-only lookup of iter_move
3248 std::format #b, #B, #o, #x, and #X presentation types misformat negative numbers
3249 There are no 'pointers' in §[atomics.lockfree]
3250 std::format: # (alternate form) for NaN and inf
3251 Are std::format alignment specifiers applied to string arguments?
3252 Parse locale's aware modifiers for commands are not consistent with POSIX spec
3253 basic_syncbuf::basic_syncbuf() should not be explicit
3254 Strike stop_token's operator!=
3255 span's array constructor is too strict
3256 Feature testing macro for constexpr algorithms
3257 Missing feature testing macro update from P0858
3258 Range access and initializer_list
3259 The definition of constexpr iterators should be adjusted
3260 year_month* arithmetic rejects durations convertible to years
3261 regex components' noexcept annotations appear broken for POCMA or throwing BidirectionalIterator
3262 Formatting of negative durations is not specified
3263 Atomic waiting function calls should only be unblocked once
3264 sized_range and ranges::size redundantly use disable_sized_range
3265 move_iterator's conversions are more broken after P1207
3266 to_chars(bool) should be deleted
3267 Rebound allocators and is_always_equal
3268 memory_order::memory_order_foo broken in C++20
3269 Parse manipulators do not specify the result of the extraction from stream
3270 Parsing and formatting %j with durations
3271 Parsing functions should save and restore stream format state
3272 %I%p should parse/format duration since midnight
3273 Specify weekday_indexed to range of [0, 7]
3274 Missing feature test macro for <span>
3275 Why does time_get::do_get require a valid pointer when none of the others do?
3276 Class split_view::outer_iterator::value_type should inherit from view_interface
3277 Pre-increment on prvalues is not a requirement of weakly_incrementable
3278 join_view<V>::iterator<true> tries to write through const join_view ptr
3279 shared_ptr<int>& does not not satisfy readable
3280 View converting constructors can cause constraint recursion and are unneeded
3281 Conversion from pair-like types to subrange is a silent semantic promotion
3282 subrange converting constructor should disallow derived to base conversions
3283 Types satisfying input_iterator but not equality_comparable look like C++17 output iterators
3284 random_access_iterator semantic constraints accidentally promote difference type using unary negate
3285 The type of a customization point object shall satisfy semiregular
3286 ranges::size is not required to be valid after a call to ranges::begin on an input range
3287 Exposition-only cpp17-input-iterator concept is needlessly complex
3288 atomic<T>::notify_one is unimplementable
3289 Cannot opt out of C++17 iterator-ness without also opting out of C++20 iterator-ness
3290 Are std::format field widths code units, code points, or something else?
3291 iota_view::iterator has the wrong iterator_category
3292 iota_view is under-constrained
3293 move_iterator operator+() has incorrect constraints
3294 zoned_time deduction guides misinterprets string/char*
3295 Comparison category operator== are mis-specified
3296 Inconsistent default argument for basic_regex<>::assign
3297 Useless sequence container requirement
3298 Range adaptors introduced by P1035 do not require viewable_range
3299 Pointers don't need customized iterator behavior
3300 Non-array ssize overload is underconstrained
3301 transform_view::iterator has incorrect iterator_category
3302 Range adaptor objects keys and values are unspecified
3303 Bad "constexpr" marker for destroy/destroy_n
3304 Allocate functions of std::polymorphic_allocator should require [[nodiscard]]
3305 any_cast<void>
3306 ranges::advance violates its preconditions
3307 std::allocator<void>().allocate(n)
3308 vector and deque iterator erase invalidates elements even when no change occurs
3309 Is <ios> implicitly #included by <sstream>, <fstream> etc.?
3310 Replace SIZE_MAX with numeric_limits<size_t>::max()
3311 basic_string::operator=(charT c) should be constrained
3312 polymorphic_allocator::allocate_object and new_object should be [[nodiscard]]
3313 join_view::iterator::operator-- is incorrectly constrained
3314 Is stream insertion behavior locale dependent when Period::type is micro?
3315 Correct Allocator Default Behavior
3316 Correctly define epoch for utc_clock / utc_timepoint
3317 Incorrect operator<< for floating-point durations
3318 Clarify whether clocks can represent time before their epoch
3319 Properly reference specification of IANA time zone database
3320 span::cbegin/cend methods produce different results than std::[ranges::]cbegin/cend
3321 uninitialized_construct_using_allocator should use construct_at
3322 Add join_view::base() member function
3323 has-tuple-element helper concept needs convertible_to
3324 Special-case std::strong/weak/partial_order for pointers
3325 Constrain return type of transformation function for transform_view
3326 enable_view has false positives
3327 Format alignment specifiers vs. text direction
3328 Clarify that std::string is not good for UTF-8
3329 totally_ordered_with both directly and indirectly requires common_reference_with
3330 Include <compare> from most library headers
3331 Define totally_ordered/_with in terms of partially-ordered-with
3332 Issue in §[time.format]
3333 ranges::cbegin/ranges::cend, (and maybe ranges::crbegin/ranges::crend) are under-specified to allow rvalue-arrays
3334 basic_osyncstream move assignment and destruction calls basic_syncbuf::emit() twice
3335 Resolve C++20 NB comments US 273 and GB 274
3336 How does std::vformat handle exception thrown by formatters?
3337 What is "is initialized" supposed to mean?
3338 Rename default_constructible to default_initializable
3339 Move-constructed empty-container capacity
3340 Formatting functions should throw on argument/format string mismatch in §[format.functions]
3341 basic_regex range constructor: Missing requirements for iterator types
3342 Library wording uses "initializes x with y", which is underspecified
3343 Ordering of calls to unlock() and notify_all() in Effects element of notify_all_at_thread_exit() should be reversed
3344 advance(i, most-negative) and prev(i, most-negative)
3345 Incorrect usages of "models" versus "satisfies"
3346 pair and tuple copy and move constructor have backwards specification
3347 std::pair<T, U> now requires T and U to be less-than-comparable
3348 __cpp_lib_unwrap_ref in wrong header
3349 Missing __cpp_lib_constexpr_complex for P0415R1
3350 Simplify return type of lexicographical_compare_three_way
3351 ranges::enable_safe_range should not be constrained
3352 strong_equality isn't a thing
3353 locale's copy assignment operator should return locale&
3354 has_strong_structural_equality has a meaningless definition
3355 The memory algorithms should support move-only input iterators introduced by P1207
3356 __cpp_lib_nothrow_convertible should be __cpp_lib_is_nothrow_convertible
3357 [fund.ts.v3] default_random_engine is overspecified for per-thread engine
3358 §[span.cons] is mistaken that to_address can throw
3359 <chrono> leap second support should allow for negative leap seconds
3360 three_way_comparable_with is inconsistent with similar concepts
3361 safe_range<SomeRange&> case
3362 Strike stop_source's operator!=
3363 drop_while_view should opt-out of sized_range
3364 Initialize data members of ranges and their iterators
3365 Rename ref-is-glvalue to deref-is-ref
3366 Narrowing conversions between integer and integer-class types
3367 Integer-class conversions should not throw
3368 Exactly when does size return end - begin?
3369 span's deduction-guide for built-in arrays doesn't work
3370 §[cstdint.syn]p2 and §[headers]p5 are not sufficiently clear
3371 visit_format_arg and make_format_args are not hidden friends
3372 vformat_to should not try to deduce Out twice
3373 {to,from}_chars_result and format_to_n_result need the "we really mean what we say" wording
3374 P0653 + P1006 should have made the other std::to_address overload constexpr
3375 decay in viewable_range should be remove_cvref
3376 "integer-like class type" is too restrictive
3377 elements_view::iterator befriends a specialization of itself
3378 tuple_size_v/tuple_element_t should be available when tuple_size/tuple_element are
3379 "safe" in several library names is misleading
3380 common_type and comparison categories
3381 begin and data must agree for contiguous_range
3382 NTTP for pair and array
3383 §[] sys_seconds should be replaced with seconds
3384 transform_view::sentinel has an incorrect operator-
3385 common_iterator is not sufficiently constrained for non-copyable iterators
3386 elements_view needs its own sentinel type
3387 §[range.reverse.view] reverse_view<V> unintentionally requires range<const V>
3388 view iterator types have ill-formed <=> operators
3389 A move-only iterator still does not have a counted_iterator
3390 make_move_iterator() cannot be used to construct a move_iterator for a move-only iterator
3391 Problems with counted_iterator/move_iterator::base() const &
3392 ranges::distance() cannot be used on a move-only iterator with a sized sentinel
3393 Missing/incorrect feature test macro for coroutines
3394 ranges::basic_istream_view::iterator has an empty iterator_traits
3395 Definition for three-way comparison needs to be updated (US 152)
3396 Clarify point of reference for source_location::current() (DE 169)
3397 ranges::basic_istream_view::iterator should not provide iterator_category
3398 tuple_element_t is also wrong for const subrange
3399 basic_syncbuf::emit() + Qt's #define emit = Big Bada-Boom
3400 Does is_nothrow_convertible consider destruction of the destination type?
3401 Is "as if by" equivalent to "equivalent to"?
3402 Wording for negative_binomial_distribution is unclear as a consequence of LWG 2406 resolution
3403 Domain of ranges::ssize(E) doesn't match ranges::size(E)
3404 Finish removing subrange's conversions from pair-like
3405 common_view's converting constructor is bad, too
3406 elements_view::begin() and elements_view::end() have incompatible constraints
3407 Some problems with the wording changes of P1739R4
3408 LWG 3291 reveals deficiencies in counted_iterator
3409 Too lax description of atomic_ref<T>::required_alignment
3410 lexicographical_compare_three_way is overspecified
3411 [fund.ts.v3] Contradictory namespace rules in the Library Fundamentals TS
3412 §[format.string.std] references to "Unicode encoding" unclear
3413 [fund.ts.v3] propagate_const's swap's noexcept specification needs to be constrained and use a trait
3414 [networking.ts] service_already_exists has no usable constructors
3415 back_insert_iterator fails when a container is also its value type
3416 The Throws: specification of std::any does not mention allocation
3417 Missing volatile atomic deprecations
3418 Deprecated free functions in <atomic>
3419 §[algorithms.requirements]/15 doesn't reserve as many rights as it intends to
3420 cpp17-iterator should check that the type looks like an iterator first
3421 Imperfect ADL emulation for boolean-testable
3422 Issues of seed_seq's constructors
3423 std::any_cast should never return a cv-qualified type
3424 optional::value_or should never return a cv-qualified type
3425 condition_variable_any fails to constrain its Lock parameters
3426 operator<=>(const unique_ptr<T, D>&, nullptr_t) can't get no satisfaction
3427 operator<=>(const shared_ptr<T>&, nullptr_t) definition ill-formed
3428 single_view's in place constructor should be explicit
3429 "models" should subsume like "satisfies"
3430 std::fstream & co. should be constructible from string_view
3431 <=> for containers should require three_way_comparable<T> instead of <=>
3432 Missing requirement for comparison_category
3433 subrange::advance(n) has UB when n < 0
3434 ios_base never reclaims memory for iarray and parray
3435 three_way_comparable_with<reverse_iterator<int*>, reverse_iterator<const int*>>
3436 std::construct_at should support arrays
3437 __cpp_lib_polymorphic_allocator is in the wrong header
3438 §[container.node.overview] missing multiset/map cases
3439 "Distance" template parameter is underspecified
3440 Aggregate-paren-init breaks direct-initializing a tuple or optional from {aggregate-member-value}
3441 Misleading note about calls to customization points
3442 Unsatisfiable suggested implementation of customization points
3443 [networking.ts] net::basic_socket_iostream should use addressof
3444 [networking.ts] net::basic_socket_streambuf::connect(Args&&...) effects are wrong
3445 [networking.ts] net::basic_socket_istream::connect should be constrained
3446 indirectly_readable_traits ambiguity for types with both value_type and element_type
3447 Deduction guides for take_view and drop_view have different constraints
3448 transform_view's sentinel<false> not comparable with iterator<true>
3449 take_view and take_while_view's sentinel<false> not comparable with their const iterator
3450 The const overloads of take_while_view::begin/end are underconstrained
3451 Inconsistently explicit deduction guides
3452 Are views really supposed to have strict 𝒪(1) destruction?
3453 Generic code cannot call ranges::advance(i, s)
3454 pointer_traits::pointer_to should be constexpr
3455 Incorrect Postconditions on unique_ptr move assignment
3456 Pattern used by std::from_chars is underspecified
3457 *this is not invalidated
3458 Is shared_future intended to work with arrays or function types?
3459 Why doesn't std::convertible_to have semantic requirement when To is reference-to-function type?
3460 Unimplementable noop_coroutine_handle guarantees
3461 convertible_to's description mishandles cv-qualified void
3462 §[formatter.requirements]: Formatter requirements forbid use of fc.arg()
3463 Incorrect requirements for transform_inclusive_scan without initial value
3464 istream::gcount() can overflow
3465 compare_partial_order_fallback requires F < E
3466 Specify the requirements for promise/future/shared_future consistently
3467 bool can't be an integer-like type
3468 Transparent lookups in unordered containers are inconsistent
3469 Precondition of coroutine_handle::promise may be insufficient
3470 convertible-to-non-slicing seems to reject valid case
3471 polymorphic_allocator::allocate does not satisfy Cpp17Allocator requirements
3472 counted_iterator is missing preconditions
3473 Normative encouragement in non-normative note
3474 Nesting join_views is broken because of CTAD
3475 std::thread's constructor needs to be able to report general memory allocation failures
3476 thread and jthread constructors require that the parameters be move-constructible but never move construct the parameters
3477 Simplify constraints for semiregular-box
3478 views::split drops trailing empty range
3479 semiregular-box mishandles self-assignment
3480 directory_iterator and recursive_directory_iterator are not C++20 ranges
3481 viewable_range mishandles lvalue move-only views
3482 drop_view's const begin should additionally require sized_range
3483 transform_view::iterator's difference is overconstrained
3484 Should <stddef.h> declare ::nullptr_t?
3485 atomic_ref safety should be based on operations that "potentially conflict" rather than lifetime
3486 is_constructible<T[], T...> may be misleading in C++20
3487 Missing precondition on input and output aliasing of [numeric.ops]
3488 Is array<const int, 0> swappable or not?
3489 Improve istream_view wording
3490 ranges::drop_while_view::begin() is missing a precondition
3491 What is a "decayed type"?
3492 Minimal improvements to elements_view::iterator
3493 The constructor of std::function taking an F is missing a constraint
3494 Allow ranges to be conditionally borrowed
3495 constexpr launder makes pointers to inactive members of unions usable
3496 What does "uniquely associated" mean for basic_syncbuf::emit()?
3497 Postconditions for basic_syncbuf::emit()
3498 Inconsistent noexcept-specifiers for basic_syncbuf
3499 Timed lockable and mutex requirements are imprecise about duration and time_point
3500 join_view::iterator::operator->() is bogus
3501 basic_syncbuf-related manipulators refer to some Allocator without defining it
3502 elements_view should not be allowed to return dangling references
3503 chrono::ceil has surprising requirement
3504 condition_variable::wait_for is overspecified
3505 split_view::outer-iterator::operator++ misspecified
3506 Missing allocator-extended constructors for priority_queue
3507 P0881R7 ("stacktrace") does not define "actual file name", "actual line number"
3508 atomic_ref<cv T> is not well-specified
3509 Range adaptor objects are underspecified
3510 Customization point objects should be invocable as non-const too
3511 Clarify global permission to move
3512 Incorrect exception safety guarantee for unordered containers
3513 Fix definition of program-defined based on its uses
3514 stacktrace should add type alias pmr::stacktrace
3515 §[stacktrace.basic.nonmem]: operator<< should be less templatized
3516 thread::id spaceship may be inconsistent with equality
3517 join_view::iterator's iter_swap is underconstrained
3518 Exception requirements on char trait operations unclear
3519 Incomplete synopses for <random> classes
3520 iter_move and iter_swap are inconsistent for transform_view::iterator
3521 Overly strict requirements on qsort and bsearch
3522 Missing requirement on InputIterator template parameter for priority_queue constructors
3523 iota_view::sentinel is not always iota_view's sentinel
3524 Unimplementable narrowing and evaluation order requirements for range adaptors
3525 uses_allocator_construction_args fails to handle types convertible to pair
3526 Return types of uses_allocator_construction_args unspecified
3527 uses_allocator_construction_args handles rvalue pairs of rvalue references incorrectly
3528 make_from_tuple can perform (the equivalent of) a C-style cast
3529 priority_queue(first, last) should construct c with (first, last)
3530 BUILTIN-PTR-MEOW should not opt the type out of syntactic checks
3531 LWG 3025 broke previous valid code
3532 split_view<V, P>::inner-iterator<true>::operator++(int) should depend on Base
3533 Make base() const & consistent across iterator wrappers that supports input_iterators
3534 ranges::set_intersection and ranges::set_difference algorithm requirements are too strict
3535 join_view::iterator::iterator_category and ::iterator_concept lie
3536 Should chrono::from_stream() assign zero to duration for failure?
3537 §[iterator.range] Missing noexcept for std::rbegin/rend for arrays and initializer_list
3538 §[library.c] C library functions are not addressable
3539 format_to must not copy models of output_iterator<const charT&>
3540 §[format.arg] There should be no const in basic_format_arg(const T* p)
3541 indirectly_readable_traits should be SFINAE-friendly for all types
3542 basic_format_arg mis-handles basic_string_view with custom traits
3543 Definition of when counted_iterators refer to the same sequence isn't quite right
3544 format-arg-store::args is unintentionally not exposition-only
3545 std::pointer_traits should be SFINAE-friendly
3546 common_iterator's postfix-proxy is not quite right
3547 Time formatters should not be locale sensitive by default
3548 shared_ptr construction from unique_ptr should move (not copy) the deleter
3549 view_interface is overspecified to derive from view_base
3550 Names reserved by C for standard library not reserved by C++
3551 borrowed_{iterator,subrange}_t are overspecified
3552 Parallel specialized memory algorithms should require forward iterators
3553 Useless constraint in split_view::outer-iterator::value_type::begin()
3554 chrono::parse needs const charT* and basic_string_view<charT> overloads
3555 {transform,elements}_view::iterator::iterator_concept should consider const-qualification of the underlying range
3556 Specification of when semantic constraints are imposed by use of concepts is unclear
3557 The static_cast expression in convertible_to has the wrong operand
3558 elements_view::sentinel's first operator- has wrong return type
3559 Semantic requirements of sized_range is circular
3560 ranges::equal and ranges::is_permutation should short-circuit for sized_ranges
3561 Issue with internal counter in discard_block_engine
3562 Superseding nullopt_t's requirement to not be DefaultConstructible
3563 keys_view example is broken
3564 transform_view::iterator<true>::value_type and iterator_category should use const F&
3565 Handling of encodings in localized formatting of chrono types is underspecified
3566 Constraint recursion for operator<=>(optional<T>, U)
3567 Formatting move-only iterators take two
3568 basic_istream_view needs to initialize value_
3569 join_view fails to support ranges of ranges with non-default_initializable iterators
3570 basic_osyncstream::emit should be an unformatted output function
3571 flush_emit should set badbit if the emit call fails
3572 copyable-box should be fully constexpr
3573 Missing Throws element for basic_string_view(It begin, End end)
3574 common_iterator should be completely constexpr-able
3575 <=> for integer-class types isn't consistently specified
3576 Clarifying fill character in std::format
3577 Merging an (unordered) associative container with itself
3578 Iterator SCARYness in the context of associative container merging
3579 Complexity guarantees for resize() and append() functions across the library
3580 iota_view's iterator's binary operator+ should be improved
3581 The range constructor makes basic_string_view not trivially move constructible
3582 Unclear where std::async exceptions are handled
3583 Clarify if/when short circuiting applies to conditions in Constraints: elements
3584 Clarify common comparison category conversions
3585 Variant converting assignment with immovable alternative
3586 Formatting character alignment inconsistencies
3587 std::three_way_comparable_with<T, U, void> can be satisfied but can't be modeled
3588 Strike out purposeless UB involving the deleter in members functions of unique_ptr
3589 The const lvalue reference overload of get for subrange does not constrain I to be copyable when N == 0
3590 split_view::base() const & is overconstrained
3591 lazy_split_view<input_view>::inner-iterator::base() && invalidates outer iterators
3592 lazy_split_view needs to check the simpleness of Pattern
3593 Several iterators' base() const & and lazy_split_view::outer-iterator::value_type::end() missing noexcept
3594 inout_ptr — inconsistent release() in destructor
3595 Exposition-only classes proxy and postfix-proxy for common_iterator should be fully constexpr
3596 ranges::starts_with and ranges::ends_with are underspecified
3597 Unsigned integer types don't model advanceable
3598 system_category().default_error_condition(0) is underspecified
3599 The const overload of lazy_split_view::begin should be constrained by const Pattern
3600 Making istream_iterator copy constructor trivial is an ABI break
3601 common_iterator's postfix-proxy needs indirectly_readable
3602 reverse_iterator's converting assignment is overconstrained
3603 Matching of null characters by regular expressions is underspecified
3604 What is the effect of an invalid value of type syntax_option_type?
3605 regex_constants::match_prev_avail is underspecified
3606 Missing regex_traits::locale_type requirements
3607 contiguous_iterator should not be allowed to have custom iter_move and iter_swap behavior
3608 convertible_to and temporary-bound references
3609 std::ranges::iota_view<int, long> has non-subtractable iterator and sentinel types
3610 iota_view::size sometimes rejects integer-class types
3611 Should compare_exchange be allowed to modify the expected value on success?
3612 Inconsistent pointer alignment in std::format
3613 Specify that nullopt_t is copyable
3614 iota_view::size and the most negative signed integer values
3615 The last specialization of incrementable_traits has wrong operand types
3616 LWG 3498 seems to miss the non-member swap for basic_syncbuf
3617 function/packaged_task deduction guides and deducing this
3618 Unnecessary iter_move for transform_view::iterator
3619 Specification of vformat_to contains ill-formed formatted_size calls
3620 What are execution character sets and execution wide-character sets (after P2314R4)?
3621 Remove feature-test macro __cpp_lib_monadic_optional
3622 Misspecified transitivity of equivalence in §[unord.req.general]
3623 Uses of std::reverse_iterator with containers should not require manually including <iterator>
3624 Inconsistency of <typeinfo>, <initializer_list>, and <compare> in the standard library
3625 Should <stacktrace> provide range access function templates?
3626 Is std::basic_stacktrace required to use contiguous storage?
3627 Inconsistent specifications for std::make_optional overloads
3628 "Effects: Equivalent to:" and uninitialized memory algorithms
3629 make_error_code and make_error_condition are customization points
3630 Inconsistent basic_regex construction and assignment from iterator range
3631 basic_format_arg(T&&) should use remove_cvref_t<T> throughout
3632 unique_ptr "Mandates: This constructor is not selected by class template argument deduction"
3633 Atomics are copy constructible and copy assignable from volatile atomics
3634 When are static-duration memory_resource objects destroyed?
3635 Add __cpp_lib_deduction_guides to feature test macros
3636 formatter<T>::format should be const-qualified
3637 pmr::memory_resource::do_allocate needs clarification
3638 vector<bool>::swap(reference, reference) is useless
3639 Handling of fill character width is underspecified in std::format
3640 Clarify which exceptions are propagated
3641 Add operator== to format_to_n_result
3642 move_only_function assignment operators seem to be defined suboptimal
3643 Missing constexpr in std::counted_iterator
3644 std::format does not define "integer presentation type"
3645 resize_and_overwrite is overspecified to call its callback with lvalues
3646 std::ranges::view_interface::size returns a signed type
3647 nothrow-input-iterator constraints should not mention copying
3648 format should not print bool with 'c'
3649 [fund.ts.v3] Reinstate and bump __cpp_lib_experimental_memory_resource feature test macro
3650 Are std::basic_string's iterator and const_iterator constexpr iterators?
3651 Unspecified lifetime guarantees for the format string
3652 Can we relax the preconditions of longjmp?
3653 <coroutine> is freestanding, but uses std::hash which is not
3654 basic_format_context::arg(size_t) should be noexcept
3655 The INVOKE operation and union types
3656 Inconsistent bit operations returning a count
3657 std::hash<std::filesystem::path> is not enabled
3658 basic_streambuf::sputn is both overspecified and underspecified
3659 Consider ATOMIC_FLAG_INIT undeprecation
3660 iterator_traits<common_iterator>::pointer should conform to §[iterator.traits]
3661 constinit atomic<shared_ptr<T>> a(nullptr); should work
3662 basic_string::append/assign(NTBS, pos, n) suboptimal
3663 basic_string(const T&, const Alloc&) turns moves into copies
3664 LWG 3392 broke std::ranges::distance(a, a+3)
3665 Is std::allocator_traits<Alloc>::rebind_alloc SFINAE-friendly?
3666 join_view's difference type is too small
3667 std::cout << &X::f prints 1
3668 [recursive_]directory_iterator constructors refer to undefined options
3669 std::filesystem operations should be observable behaviour
3670 Cpp17InputIterators don't have integer-class difference types
3671 atomic_fetch_xor missing from stdatomic.h
3672 common_iterator::operator->() should return by value
3673 §[locale.cons] Ambiguous argument in Throws for locale+name+category constructor
3674 Removal of requirement for locale names for construction of locales not explained
3675 std::ios_base::iword/pword might be misspecified
3676 Name of locale composed using std::locale::none
3677 Is a cv-qualified pair specially handled in uses-allocator construction?
3678 Constructors of std::chrono::time_zone might be overly unspecified
3679 Is <ranges> sufficient for istream_view?
3680 Constructor of move_only_function with empty ref-qualifier is over-constrained
3681 Further considerations on LWG 3679
3682 A Cpp17Allocator type can't silently ignore an unsupported alignment
3683 operator== for polymorphic_allocator cannot deduce template argument in common cases
3684 std::allocator<T>::allocate_at_least in constant evaluation
3685 In lazy_split_view, CTAD doesn't work when given an input_range input and a tiny-range pattern
3686 In lazy_split_view, comparing a default-constructed outer-iterator or inner-iterator with std::default_sentinel results in null pointer dereference
3687 expected<cv void, E> move constructor should move
3688 Exception specifications of copy/move member functions of std::bad_expected_access
3689 num_get overflow determination unclear and incorrect
3690 std::make_from_tuple etc. should find all tuple-like std::get overloads
3691 Replacement of keys in associative containers
3692 zip_view::iterator's operator<=> is overconstrained
3693 §[c.math] Can any of float/double/long double overloads be fused into template overloads?
3694 Should traits_type::length be customizable?
3695 The standard-layout property of char-like types serves for nothing
3696 "Basic integral types" should not be used
3697 Preconditions of reference_constructs_from_temporary/reference_converts_from_temporary seem wrong
3698 regex_iterator and join_view don't work together very well
3699 lexically_relative on UNC drive paths (\\?\C:\...) results in a default-constructed value
3700 The const begin of the join_view family does not require InnerRng to be a range
3701 Make formatter<remove_cvref_t<const charT[N]>, charT> requirement explicit
3702 Should zip_transform_view::iterator remove operator<?
3703 Missing requirements for expected<T, E> requires is_void<T>
3704 LWG 2059 added overloads that might be ill-formed for sets
3705 Hashability shouldn't depend on basic_string's allocator
3706 How does std::format work with character arrays of unknown bound?
3707 chunk_view::outer-iterator::value_type::size should return unsigned type
3708 take_while_view::sentinel's conversion constructor should move
3709 LWG-3703 was underly ambitious
3710 The end of chunk_view for input ranges can be const
3711 Missing preconditions for slide_view constructor
3712 chunk_view and slide_view should not be default_initializable
3713 Sorted with respect to comparator (only)
3714 Non-single-argument constructors for range adaptors should not be explicit
3715 view_interface::empty is overconstrained
3716 §[iterator.concept.forward][forward.iterators] Two different definitions of multi-pass guarantee
3717 common_view::end should improve random_access_range case
3718 P2418R2 broke the overload resolution for std::basic_format_arg
3719 Directory iterators should be usable with default sentinel
3720 Restrict the valid types of arg-id for width and precision in std-format-spec
3721 Allow an arg-id with a value of zero for width in std-format-spec
3722 ranges::to reserves the wrong size
3723 priority_queue::push_range needs to append_range
3724 decay-copy should be constrained
3725 reverse_iterator::operator-> should not use prev for non-pointer iterators
3726 reverse_iterator::operator-> is underconstrained for non-pointer iterators
3727 reverse_iterator/common_iterator's operator-> should not require the underlying iterator's operator-> to be a const member function
3728 Can't make neither head nor tail of the description of operator<=>(tuple, tuple)
3729 std::tuple_element_t<std::ranges::subrange<I, S, K>> should remove top-level cv-qualifiers
3730 std::ranges::drop_view may have different size type from its underlying view
3731 zip_view and adjacent_view are underconstrained
3732 prepend_range and append_range can't be amortized constant time
3733 ranges::to misuses cpp17-input-iterator
3734 Inconsistency in inout_ptr and out_ptr for empty case
3735 views::adjacent<0> should be prohibited
3736 move_iterator missing disable_sized_sentinel_for specialization
3737 take_view::sentinel should provide operator-
3738 Missing preconditions for take_view constructor
3739 chunk_view::size should preserve the signedness of the size of the underlying range
3740 slide_view::size should preserve the signedness of underlying range's size
3741 std::chrono::abs(duration) is ill-formed with non-reduced periods
3742 deque::prepend_range needs to permute
3743 ranges::to's reserve may be ill-formed
3744 copy_symlink(junction, new_symlink)'s behavior is unclear
3745 std::atomic_wait and its friends lack noexcept
3746 optional's spaceship with U with a type derived from optional causes infinite constraint meta-recursion
3747 ranges::uninitialized_copy_n, ranges::uninitialized_move_n, and ranges::destroy_n should use std::move
3748 common_iterator and counted_iterator' operator- are missing cast to return type
3749 common_iterator should handle integer-class difference types
3750 Too many papers bump __cpp_lib_format
3751 Missing feature macro for flat_set
3752 Should string::substr forward the allocator to the newly created string?
3753 Clarify entity vs. freestanding entity
3754 Class template expected synopsis contains declarations that do not match the detailed description
3755 tuple-for-each can call user-defined operator,
3756 Is the std::atomic_flag class signal-safe?
3757 What's the effect of std::forward_like<void>(x)?
3758 Element-relocating operations of std::vector and std::deque should conditionally require Cpp17CopyInsertable in their preconditions
3759 ranges::rotate_copy should use std::move
3760 cartesian_product_view::iterator's parent_ is never valid
3761 cartesian_product_view::iterator::operator- should pass by reference
3762 generator::iterator::operator== should pass by reference
3763 Should range adaptor iterators only provide iterator_category when its difference_type is not an integer-class type?
3764 reference_wrapper::operator() should propagate noexcept
3765 const_sentinel should be constrained
3766 view_interface::cbegin is underconstrained
3767 codecvt<charN_t, char8_t, mbstate_t> incorrectly added to locale
3768 possibly-const-range is overconstrained
3769 basic_const_iterator::operator== causes infinite constraint recursion
3770 const_sentinel_t is missing
3771 [fund.ts.v3] remove binders typedefs from function
3772 repeat_view's piecewise constructor is missing Postconditions
3773 views::zip_transform still requires F to be copy_constructible when empty pack
3774 <flat_set> should include <compare>
3775 Broken dependencies in the Cpp17Allocator requirements
3776 Avoid parsing format-spec if it is not present or empty
3777 Common cartesian_product_view produces an invalid range if the first range is input and one of the ranges is empty
3778 vector<bool> missing exception specifications
3779 ranges::fold_* can unintentionally const_cast and reinterpret_cast
3780 format's width estimation is too approximate and not forward compatible
3781 The exposition-only alias templates cont-key-type and cont-mapped-type should be removed
3782 Should <math.h> declare ::lerp?
3783 views::common may not be a range adaptor object
3784 std.compat should not provide ::byte and its friends
3785 ranges::to is over-constrained on the destination type being a range
3786 Flat maps' deduction guide needs to default Allocator to be useful
3787 ranges::to's template parameter C should not be a reference type
3788 jthread::operator=(jthread&&) postconditions are unimplementable under self-assignment
3789 Precondition of (not replaced) operator delete[]
3790 P1467 accidentally changed nexttoward's signature
3791 join_view::iterator::operator-- may be ill-formed
3792 __cpp_lib_constexpr_algorithms should also be defined in <utility>
3793 Requirements for some algorithms' Size template parameters are unclear
3794 std::filesystem::path::iterator::reference should be allowed to be std::filesystem::path
3795 Self-move-assignment of std::future and std::shared_future have unimplementable postconditions
3796 movable-box as member should use default-initialization instead of copy-initialization
3797 elements_view insufficiently constrained
3798 Rvalue reference and iterator_category
3799 Should <math.h> provide 3-argument ::hypot overloads?
3800 No deduction guide for std::match_results
3801 cartesian_product_view::iterator::distance-from ignores the size of last underlying range
3802 flat_foo allocator-extended constructors lack move semantics
3803 flat_foo constructors taking KeyContainer lack KeyCompare parameter
3804 flat_foo missing some allocator-extended deduction guides
3805 Expression evaluating to a call wrapper is a prvalue, not an object
3806 Should concept formattable<T, charT> default to char?
3807 The feature test macro for ranges::find_last should be renamed
3808 Inconsistent feature test macros for ranges algorithms
3809 Is std::subtract_with_carry_engine<uint16_t> supposed to work?
3810 CTAD for std::basic_format_args
3811 views::as_const on ref_view<T> should return ref_view<const T>
3812 [fund.ts.v3] Incorrect constraint on propagate_const conversion function
3813 std::span<volatile T, E> is made ill-formed by P2278R4 when T is a normal class type
3814 Add freestanding items requested by NB comments
3815 Freestanding enumerators specification is lacking
3816 flat_map and flat_multimap should impose sequence container requirements
3817 Missing preconditions on forward_list modifiers
3818 Exposition-only concepts are not described in library intro
3819 reference_meows_from_temporary should not use is_meowible
3820 cartesian_product_view::iterator::prev is not quite right
3821 uses_allocator_construction_args should have overload for pair-like
3822 Avoiding normalization in filesystem::weakly_canonical
3823 Unnecessary precondition for is_aggregate
3824 Number of bind placeholders is underspecified
3825 Missing compile-time argument id check in basic_format_parse_context::next_arg_id
3826 Redundant specification [for overload of yield_value]
3827 Deprecate <stdalign.h> and <stdbool.h> macros
3828 Sync intmax_t and uintmax_t with C2x
3829 as_rvalue_view::end should improve non-common case
3830 reverse_view should not cache when ranges::next has constant time complexity
3831 Two-digit formatting of negative year is ambiguous
3832 Missing change for element_view::iterator in LWG 3798
3833 Remove specialization template<size_t N> struct formatter<const charT[N], charT>
3834 Missing constexpr for std::intmax_t math functions in <cinttypes>
3835 Requirements for CharT in the regex library
3836 std::expected<bool, E1> conversion constructor expected(const expected<U, G>&) should take precedence over expected(U&&) with operator bool
3837 std::erase_if overloads for non-associative containers should move (and not copy) their predicate object
3838 The last specialization of incrementable_traits is under-constrained
3839 range_formatter's set_separator, set_brackets, and underlying functions should be noexcept
3840 filesystem::u8path should be undeprecated
3841 <version> should not be "all freestanding"
3842 Unclear wording for precision in chrono-format-spec
3843 std::expected<T,E>::value() & assumes E is copy constructible
3844 Non-numeric formats for negative durations
3845 ranges::to's from_range_t tag branch has the wrong constraint
3846 iota_view::iterator::operator- is overconstrained
3847 ranges::to can still return views
3848 adjacent_view, adjacent_transform_view and slide_view missing base accessor
3849 cartesian_product_view::iterator's default constructor is overconstrained
3850 views::as_const on empty_view<T> should return empty_view<const T>
3851 chunk_view::inner-iterator missing custom iter_move and iter_swap
3852 join_with_view::iterator's iter_move and iter_swap should be conditionally noexcept
3853 basic_const_iterator<volatile int*>::operator-> is ill-formed
3854 §[res.on.exception.handling]/3 should not be applied to all standard library types
3855 tiny-range is not quite right
3856 Unclear which conversion specifiers are valid for each chrono type
3857 basic_string_view should allow explicit conversion when only traits vary
3858 basic_const_iterator is too strict to provide iterator_category
3859 std::projected cannot handle proxy iterator
3860 range_common_reference_t is missing
3861 mdspan layout_stride::mapping default constructor problem
3862 basic_const_iterator's common_type specialization is underconstrained
3863 Is input_iterator guaranteed to have iter_const_reference_t?
3864 zip over range of reference to an abstract type
3865 Sorting a range of pairs
3866 Bad Mandates for expected::transform_error overloads
3867 Should std::basic_osyncstream's move assignment operator be noexcept?
3868 Constrained algorithms should not require output_iterator
3869 Deprecate std::errc constants related to UNIX STREAMS
3870 Remove voidify
3871 Adjust note about terminate
3872 basic_const_iterator should have custom iter_move
3873 join_with_view's const begin is underconstrained
3874 Rename __cpp_lib_ranges_to_container to __cpp_lib_ranges_to
3875 std::ranges::repeat_view<T, IntegerClass>::iterator may be ill-formed
3876 Default constructor of std::layout_XX::mapping misses precondition
3877 Incorrect constraints on const-qualified monadic overloads for std::expected
3878 import std; should guarantee initialization of standard iostreams objects
3879 erase_if for flat_{,multi}set is incorrectly specified
3880 Clarify operator+= complexity for {chunk,stride}_view::iterator
3881 Incorrect formatting of container adapters backed by std::string
3882 tuple relational operators have confused friendships
3883 §[support.c.headers.other] Ambiguity in the requirements for includes
3884 flat_foo is missing allocator-extended copy/move constructors
3885 'op' should be in [zombie.names]
3886 Monad mo' problems
3887 Version macro for allocate_at_least
3888 Most ranges uninitialized memory algorithms are underconstrained
3889 std::(ranges::)destroy_at should destroy array elements in the decreasing index order
3890 ABI issue for integer-class types
3891 LWG 3870 breaks std::expected<cv T, E>
3892 Incorrect formatting of nested ranges and tuples
3893 LWG 3661 broke atomic<shared_ptr<T>> a; a = nullptr;
3894 generator::promise_type::yield_value(ranges::elements_of<Rng, Alloc>) should not be noexcept
3895 Various relation concepts are missing default values of the second template parameters
3896 The definition of viewable_range is not quite right
3897 inout_ptr will not update raw pointer to 0
3898 Possibly unintended preconditions for completion functions of std::barrier
3899 co_yielding elements of an lvalue generator is unnecessarily inefficient
3900 The allocator_arg_t overloads of generator::promise_type::operator new should not be constrained
3901 Is uses-allocator construction of a cv-qualified object type still well-formed after LWG 3870?
3902 Return type of std::declval<cv void> should be (cv-unqualified) void
3903 span destructor is redundantly noexcept
3904 lazy_split_view::outer-iterator's const-converting constructor isn't setting trailing_empty_
3905 Type of std::fexcept_t
3906 "Undefined address" is undefined
3907 Can iterator types of range adaptors and range factories be SCARY?
3908 enumerate_view::iterator constructor is explicit
3909 Issues about viewable_range
3910 The effects of including <iostream> on initialization are not yet precisely specified
3911 unique_ptr's operator* is missing a mandate
3912 enumerate_view::iterator::operator- should be noexcept
3913 ranges::const_iterator_t<range R> fails to accept arrays of unknown bound
3914 Inconsistent template-head of ranges::enumerate_view
3915 Redundant paragraph about expression variations
3916 allocator, polymorphic_allocator, and containers should forbid cv-qualified types
3917 Validity of allocator<void> and possibly polymorphic_allocator<void> should be clarified
3918 std::uninitialized_move/_n and guaranteed copy elision
3919 enumerate_view may invoke UB for sized common non-forward underlying ranges
3920 Bad footnotes claiming external linkage for entities defined as macros
3921 Is std::chrono::duration<std::int64_t, std::ratio<INT64_MAX - 1, INT64_MAX>>{40} required to be correctly formatted?
3922 It's unclear whether numeric_limits can be specialized by users
3923 The specification of numeric_limits doesn't clearly distinguish between implementation requirements and user requirements
3924 Stop token data race avoidance requirements unclear
3925 Concept formattable's definition is incorrect
3926 Which namespace std is the mentioned one?
3927 Unclear preconditions for operator[] for sequence containers
3928 Non-top-level namespace posix shouldn't be reserved
3929 Preconditions for type traits should be Mandates
3930 Simplify type trait wording
3931 Too many paper bump __cpp_lib_ranges
3932 Expression-equivalence is sometimes unimplementable when passing prvalue expressions to comparison CPOs
3933 P1467R9 accidentally changed the signatures of certain constructors of std::complex
3934 std::complex<T>::operator=(const T&) has no specification
3935 template<class X> constexpr complex& operator=(const complex<X>&) has no specification
3936 Are implementations allowed to deprecate components not in [depr]?
3937 I/O manipulators should be specified in terms of base classes
3938 Cannot use std::expected monadic ops with move-only error_type
3939 §[format.string.std] char is not formatted as a character when charT is wchar_t
3940 std::expected<void, E>::value() also needs E to be copy constructible
3941 §[atomics.order] inadvertently prohibits widespread implementation techniques
3942 Inconsistent use of const char_type& in standard specializations of std::char_traits
3943 Clarify lifetime requirements of BasicFormatter and Formatter
3944 Formatters converting sequences of char to sequences of wchar_t
3945 §[cstdarg.syn] 'Compatible types' are undefined
3946 The definition of const_iterator_t should be reworked
3947 Unexpected constraints on adjacent_transform_view::base()
3948 possibly-const-range and as-const-pointer should be noexcept
3949 std::atomic<bool>'s trivial destructor dropped in C++17 spec wording
3950 std::basic_string_view comparison operators are overspecified
3951 §[expected.object.swap]: Using value() instead of has_value()
3952 iter_common_reference_t does not conform to the definition of indirectly_readable
3953 iter_move for common_iterator and counted_iterator should return decltype(auto)
3954 Feature-test macros in C headers (<stddef.h> etc.)
3955 Add noexcept to several repeat_view[::iterator] member functions
3956 chrono::parse uses from_stream as a customization point
3957 §[container.alloc.reqmts] The value category of v should be claimed
3958 ranges::to should prioritize the "reserve" branch
3959 Should the comparator of std::flat_map/std::flat_multimap be copied twice in some operations?
3960 How does chrono::parse handle duplicated data?
3961 Does chrono::parse check format strings?
3962 What is the "decimal precision of the input"?
3963 Different std::flat_map/std::flat_multimap specializations should be able to share same nested classes
3964 std::atan2 and std::pow overloads that take two std::valarray parameters should require the arguments to have the same length
3965 Incorrect example in [format.string.escaped] p3 for formatting of combining characters
3966 The value_type and reference members of std::flat_(multi)map::(const_)iterator are unclear
3967 The specification for std::is_nothrow_* traits may be ambiguous in some cases involving noexcept(false)
3968 std::endian::native value should be more specific about object representations
3969 std::ranges::fold_left_first_with_iter should be more ADL-proof
3970 §[mdspan.syn] Missing definition of full_extent_t and full_extent
3971 Join ranges of rvalue references with ranges of prvalues
3972 Issues with join_with_view::iterator's iter_swap
3973 Monadic operations should be ADL-proof
3974 mdspan::operator[] should not copy OtherIndexTypes
3975 Specializations of basic_format_context should not be permitted
3976 What does it mean for a type to be "allocator aware"?
3977 constexpr and noexcept for operators for bitmask types
3978 The "no effect" requirement for std::ignore is unimplementable for volatile bit-fields
3979 Should we reject std::bind_front<42>() and its friends?
3980 The read exclusive ownership of an atomic read-modify-write operation and whether its read and write are two operations are unclear
3981 Range adaptor closure object is underspecified for its return type
3982 is-derived-from-view-interface should require that T is derived from view_interface<T>
3983 ranges::to adaptors are underconstrained
3984 ranges::to's recursion branch may be ill-formed
3985 ranges::to should Mandates C not to be view
3986 basic_const_iterator doesn't work with optional
3987 Including <flat_foo> doesn't provide std::begin/end
3988 Should as_const_view and basic_const_iterator provide base()?
3989 The whole range for an iterator obtained from a std::span or std::basic_string_view is not clear
3990 Program-defined specializations of std::tuple and std::variant can't be properly supported
3991 variant's move assignment should not be guaranteed to produce a valueless by exception state
3992 basic_stringbuf::str()&& should enforce 𝒪(1)
3993 The parse function of a BasicFormatter type needs to be constexpr
3994 adaptor(args...)(r) is not equivalent to std::bind_back(adaptor, args...)(r)
3995 Issue with custom index conversion in <mdspan>
3996 projected<I, identity> should just be I
3997 std::formatter specializations should be consistently restricted to supported character types
3998 Constants in std::regex_constants should be allowed to be enumerators
3999 P0439R0 changed the value category of memory order constants
4000 flat_map::insert_range's Effects is not quite right
4001 iota_view should provide empty
4002 The definition of iota_view::iterator::iterator_concept should be improved
4003 view_interface::back is overconstrained
4004 The load and store operation in §[atomics.order] p1 is ambiguous
4005 "Required behavior" too narrowly defined
4006 chunk_view::outer-iterator::value_type should provide empty
4007 Mystic prohibition of calling a volatile-qualified perfect forwarding call wrapper
4008 §[] ranges::to may cause infinite recursion if range_value_t<C> is a non-move-constructible range
4009 drop_view::begin const may have 𝒪(n) complexity
4010 subrange::advance should be improved
4011 "Effects: Equivalent to return" in [span.elem]
4012 common_view::begin/end are missing the simple-view check
4013 lazy_split_view::outer-iterator::value_type should not provide default constructor
4014 LWG 3809 changes behavior of some existing std::subtract_with_carry_engine code
4015 LWG 3973 broke const overloads of std::optional monadic operations
4016 container-insertable checks do not match what container-inserter does
4017 Behavior of std::views::split on an empty range
4018 ranges::to's copy branch is underconstrained
4019 Reversing an infinite range leads to an infinite loop
4020 extents::index-cast weirdness
4021 mdspan::is_always_meow() should be noexcept
4022 Ambiguity in the formatting of negative years with format specifier %C
4023 Preconditions of std::basic_streambuf::setg/setp
4024 Underspecified destruction of objects created in std::make_shared_for_overwrite/std::allocate_shared_for_overwrite
4025 Move assignment operator of std::expected<cv void, E> should not be conditionally deleted
4026 Assignment operators of std::expected should propagate triviality
4027 possibly-const-range should prefer returning const R&
4028 std::is_(nothrow_)convertible should be reworded to avoid dependence on the return statement
4029 basic_string accidentally fails to meet the reversible container requirements
4030 Clarify whether arithmetic expressions in [numeric.sat.func] are mathematical or C++
4031 bad_expected_access<void> member functions should be noexcept
4032 Possibly invalid types in the constraints of constructors of std::shared_ptr
4033 §[macro.names] defining macros after importing the standard library
4034 Clarify specification of std::min and std::max
4035 single_view should provide empty
4036 __alignof_is_defined is only implicitly specified in C++ and not yet deprecated
4037 Static data members of ctype_base are not yet required to be usable in constant expressions
4038 std::text_encoding::aliases_view should have constexpr iterators
4039 §[ostream.formatted.print]: Inappropriate usage of badbit in definition of vprint_unicode/vprint_nonunicode
4040 Contradictory specification of std::tuple_size
4041 The requirements on literal type in [concept.swappable] should be removed
4042 std::print should permit an efficient implementation
4043 "ASCII" is not a registered character encoding
4044 Confusing requirements for std::print on POSIX platforms
4045 tuple can create dangling references from tuple-like
4046 Effects of inserting into or erasing from flat container adaptors when an exception is thrown need to be more permissive
4047 Explicitly specifying template arguments for std::swap should not be supported
4048 Inconsistent preconditions for transparent insertion of std::flat_map/std::flat_set
4049 C <foo.h> headers not in freestanding
4050 Should views::iota(0) | views::take(5) be views::iota(0, 5)?
4051 A less hacky and more useful way to compare comparison category types
4052 Bogus requirements for piecewise_linear_distribution
4053 Unary call to std::views::repeat does not decay the argument
4054 Repeating a repeat_view should repeat the view
4055 §[iterator.operations] std::distance is missing a precondition
4056 The effects of std::swap are under-specified
4057 generator::iterator's operator* is not noexcept when it can be
4058 std::to_address() should be SFINAE-friendly
4059 Leaky abstraction in join_with_view's iterator
4060 submdspan preconditions do not forbid creating invalid pointer
4061 Should std::basic_format_context be default-constructible/copyable/movable?
4062 ranges::empty has no semantic requirements for forward_ranges
4063 Freestanding std::char_traits<char>::eof depends on non-freestanding EOF
4064 Clarify that std::launder is not needed when using the result of std::memcpy
4065 Requirements for fancy pointers might be insufficient for self-referential implementation of containers
4066 ranges::to should reserve when sized_sentinel_for is satisfied
4067 Inconsistency and potential infinity meta-recursion in std::chrono::zoned_time's constructors
4068 Terminology for objects whose types model a concept
4069 std::atomic<volatile T> should be ill-formed
4070 Transcoding by std::formatter<std::filesystem::path>
4071 reference_wrapper comparisons are not SFINAE-friendly
4072 `std::optional` comparisons: constrain harder
4073 `concat_view::size` may overflow
4074 compatible-joinable-ranges is underconstrained
4075 Thread stability requirement on constructors and destructors
4076 concat_view should be freestanding
4077 Unclear preconditions of `std::ranges::generate_random`
4078 What if arguments alias the output buffer in `std::format_to`?
4079 Missing Preconditions in concat_view::iterator's conversion constructor
4080 Presumed value and difference types of an iterator type in ranges and non-ranges algorithms
4081 concat_view::iterator::operator- is overconstrained
4082 views::concat(r) is well-formed when r is an output_range
4083 views::as_rvalue should reject non-input ranges
4084 std::fixed ignores std::uppercase
4085 ranges::generate_random's helper lambda should specify the return type
4086 ranges::generate_random_n is missing
4087 Standard exception messages have unspecified encoding
4088 println ignores the locale imbued in std::ostream
4089 concat_view::iterator's iter_swap is overconstrained
4090 Underspecified use of locale facets for locale-dependent std::format
4091 concat_view rejects non-movable references
4092 The monotonic version of common_iterator::operator== is underconstrained
4093 ranges::fold_left_first_with_iter incorrectly constructs optional<U>
4094 ranges::fold_meow is overconstrained
4095 ranges::fold_meow should explicitly spell out the return type
4096 views::iota(views::iota(0)) should be rejected
4097 views::reverse should be specialized for some view types
4098 LWG 117 loses the sign for negative NaN on some architectures
4099 The simple case of views::as_rvalue and views::common are not strictly correct
4100 Default arguments and signatures of standard library non-member functions
4101 LWG 117 loses the sign for negative NaN on some architectures
4102 `string_view(Iter, Iter)` constructor breaks existing code
4103 ranges::unique_copy's constraints for the case where result is an input_iterator are not quite right
4104 basic_const_iterator<volatile int*> is not a contiguous_iterator
4105 ranges::ends_with's Returns misses difference casting
4106 basic_format_args should not be default-constructible
4107 Map formatter may conflict with user-defined specializations of pair/tuple formatters
4108 lazy_split_view should be sized_range when pattern is empty tiny-range
4109 Instantiating templates in §[rand] with int8_t/uint8_t is undefined behavior
4110 `shared_ptr(nullptr_t, Deleter)` is overconstrained, breaking some sensible deleters
4111 LWG 270 and ranges version of binary search algorithms
4112 has-arrow should required operator->() to be const-qualified

Sort on
Group on