d:lwg1
LWG1

TC1
C library linkage editing oversight
https://wg21.link/lwg1




Beman Dawes
-
d:lwg10
LWG10

Dup
Codecvt<>::do unclear
https://wg21.link/lwg10




Matt Austern
-
d:lwg100
LWG100

NAD
Insert iterators/ostream_iterators overconstrained
https://wg21.link/lwg100




AFNOR
-
d:lwg1000
LWG1000

NAD Concepts
adjacent_find is over-constrained
https://wg21.link/lwg1000




Chris Jefferson
-
d:lwg1001
LWG1001

NAD Concepts
Pointers, concepts and headers
https://wg21.link/lwg1001




Alisdair Meredith
-
d:lwg1002
LWG1002

NAD
Provide bulk include headers
https://wg21.link/lwg1002




Alisdair Meredith
-
d:lwg1003
LWG1003

NAD
Require more useful headers for freestanding implementations
https://wg21.link/lwg1003




Alisdair Meredith
-
d:lwg1004
LWG1004

C++11
Clarify "throws an exception"
https://wg21.link/lwg1004




Alisdair Meredith
-
d:lwg1005
LWG1005

NAD Concepts
numeric_limits partial specializations not concept enabled
https://wg21.link/lwg1005




Alisdair Meredith
-
d:lwg1006
LWG1006

C++11
operator delete in garbage collected implementation
https://wg21.link/lwg1006




Alisdair Meredith
-
d:lwg1007
LWG1007

NAD Concepts
throw_with_nested not concept enabled
https://wg21.link/lwg1007




Alisdair Meredith
-
d:lwg1008
LWG1008

NAD
nested_exception wording unclear
https://wg21.link/lwg1008




Alisdair Meredith
-
d:lwg1009
LWG1009

NAD
InputIterator post-increment dangerous
https://wg21.link/lwg1009




Alisdair Meredith
-
d:lwg101
LWG101

NAD Editorial
No way to free storage for vector and deque
https://wg21.link/lwg101




AFNOR
-
d:lwg1010
LWG1010

NAD Concepts
operator-= should use default in concept
https://wg21.link/lwg1010




Alisdair Meredith
-
d:lwg1011
LWG1011

C++11
next/prev wrong iterator type
https://wg21.link/lwg1011




Alisdair Meredith
-
d:lwg1012
LWG1012

C++11
reverse_iterator default ctor should value initialize
https://wg21.link/lwg1012




Alisdair Meredith
-
d:lwg1013
LWG1013

NAD Editorial
Remove IsSameType hold-over constraints
https://wg21.link/lwg1013




Alisdair Meredith
-
d:lwg1014
LWG1014

C++11
basic_regex should be created/assigned from initializer lists
https://wg21.link/lwg1014




Alisdair Meredith
-
d:lwg1015
LWG1015

NAD Concepts
C++ programs - but not users - need to provide support concept_maps
https://wg21.link/lwg1015




Alisdair Meredith
-
d:lwg1016
LWG1016

NAD Concepts
Provide LessThanComparable and EqualityComparable for FloatingPointType
https://wg21.link/lwg1016




Alisdair Meredith
-
d:lwg1017
LWG1017

NAD Concepts
Floating-point types should not satisfy Regular
https://wg21.link/lwg1017




Alisdair Meredith
-
d:lwg1018
LWG1018

NAD Concepts
Trait specifications should be expressed in terms of concepts
https://wg21.link/lwg1018




Alisdair Meredith
-
d:lwg1019
LWG1019

C++11
Make integral_constant objects useable in integral-constant-expressions
https://wg21.link/lwg1019




Alisdair Meredith
-
d:lwg102
LWG102

Dup
Bug in insert range in associative containers
https://wg21.link/lwg102




AFNOR
-
d:lwg1020
LWG1020

NAD
Restore aligned_union
https://wg21.link/lwg1020




Alisdair Meredith
-
d:lwg1021
LWG1021

C++11
Allow nullptr_t assignments to unique_ptr
https://wg21.link/lwg1021




Alisdair Meredith
-
d:lwg1022
LWG1022

NAD Editorial
Pointer-safety API has nothing to do with smart pointers
https://wg21.link/lwg1022




Alisdair Meredith
-
d:lwg1023
LWG1023

NAD Editorial
Unclear inheritance relation for std::function
https://wg21.link/lwg1023




Alisdair Meredith
-
d:lwg1024
LWG1024

NAD Concepts
std::function constructors overly generous
https://wg21.link/lwg1024




Alisdair Meredith
-
d:lwg1025
LWG1025

LEWG
The library should provide more specializations for std::hash
https://wg21.link/lwg1025




Alisdair Meredith
-
d:lwg1026
LWG1026

NAD Concepts
Smart pointers need to be concept-constrained templates
https://wg21.link/lwg1026




Alisdair Meredith
-
d:lwg1027
LWG1027

NAD Concepts
std::allocator needs to be a concept-constrained template
https://wg21.link/lwg1027




Alisdair Meredith
-
d:lwg1028
LWG1028

NAD Concepts
raw_storage_iterator needs to be a concept-constrained template
https://wg21.link/lwg1028




Alisdair Meredith
-
d:lwg1029
LWG1029

NAD Concepts
Specialized algorithms for memory management need to be concept-constrained templates
https://wg21.link/lwg1029




Alisdair Meredith
-
d:lwg103
LWG103

CD1
set::iterator is required to be modifiable, but this allows modification of keys
https://wg21.link/lwg103




AFNOR
-
d:lwg1030
LWG1030

C++11
Missing requirements for smart-pointer safety API
https://wg21.link/lwg1030




Alisdair Meredith
-
d:lwg1031
LWG1031

NAD
Need shared_ptr conversion to a unique_ptr
https://wg21.link/lwg1031




Alisdair Meredith
-
d:lwg1032
LWG1032

NAD Concepts
Tome utility templates need to be concept-constrained
https://wg21.link/lwg1032




Alisdair Meredith
-
d:lwg1033
LWG1033

C++11
thread::join() effects?
https://wg21.link/lwg1033




Alberto Ganesh Barbati
-
d:lwg1034
LWG1034

C++11
Clarify generality of Container Requirement tables
https://wg21.link/lwg1034




Alisdair Meredith
-
d:lwg1035
LWG1035

NAD
<array>::swap can invalidate references, pointers, and iterators
https://wg21.link/lwg1035




Alisdair Meredith
-
d:lwg1036
LWG1036

NAD Concepts
Remove iterator specification that is redundant due to concept constraints
https://wg21.link/lwg1036




Alisdair Meredith
-
d:lwg1037
LWG1037

C++11
Unclear status of match_results as library container
https://wg21.link/lwg1037




Alisdair Meredith
-
d:lwg1038
LWG1038

C++11
Sequence requirement table needs to reference several new containers
https://wg21.link/lwg1038




Alisdair Meredith
-
d:lwg1039
LWG1039

C++11
Sequence container back function should also support const_iterator
https://wg21.link/lwg1039




Alisdair Meredith
-
d:lwg104
LWG104

NAD
Description of basic_string::operator[] is unclear
https://wg21.link/lwg104




AFNOR
-
d:lwg1040
LWG1040

C++11
Clarify possible sameness of associative container's iterator and const_iterator
https://wg21.link/lwg1040




Alisdair Meredith
-
d:lwg1041
LWG1041

Resolved
Add associative/unordered container functions that allow to extract elements
https://wg21.link/lwg1041




Alisdair Meredith
-
d:lwg1042
LWG1042

NAD
Provide ContiguousStorage concept and apply it to corresponding containers
https://wg21.link/lwg1042




Alisdair Meredith
-
d:lwg1043
LWG1043

Resolved
Clarify that compare_exchange is not a read-modify-write operation
https://wg21.link/lwg1043




Alisdair Meredith
-
d:lwg1044
LWG1044

C++11
Empty tag types should be constexpr literals
https://wg21.link/lwg1044




Alisdair Meredith
-
d:lwg1045
LWG1045

C++11
Remove unnecessary preconditions from unique_lock constructor
https://wg21.link/lwg1045




Alisdair Meredith
-
d:lwg1046
LWG1046

Resolved
Provide simple facility to start asynchronous operations
https://wg21.link/lwg1046




Alisdair Meredith
-
d:lwg1047
LWG1047

Resolved
Ensure that future's get() blocks when not ready
https://wg21.link/lwg1047




Alisdair Meredith
-
d:lwg1048
LWG1048

Resolved
Provide empty-state inspection for std::unique_future
https://wg21.link/lwg1048




Alisdair Meredith
-
d:lwg1049
LWG1049

Resolved
Move assignment of promise inverted
https://wg21.link/lwg1049




Alisdair Meredith
-
d:lwg105
LWG105

Dup
fstream ctors argument types desired
https://wg21.link/lwg105




AFNOR
-
d:lwg1050
LWG1050

Resolved
Clarify postconditions for get_future()
https://wg21.link/lwg1050




Alisdair Meredith
-
d:lwg1051
LWG1051

NAD
Specify subscript operation return types of reverse_iterator and move_iterator
https://wg21.link/lwg1051




Alisdair Meredith
-
d:lwg1052
LWG1052

Resolved
reverse_iterator::operator-> should also support smart pointers
https://wg21.link/lwg1052




Alisdair Meredith
-
d:lwg1053
LWG1053

NAD
Unify algorithms with operator and function object variants
https://wg21.link/lwg1053




Alisdair Meredith
-
d:lwg1054
LWG1054

Resolved
forward broken
https://wg21.link/lwg1054




Howard Hinnant
-
d:lwg1055
LWG1055

Resolved
Provide a trait that returns the underlying type of an enumeration type
https://wg21.link/lwg1055




Alisdair Meredith
-
d:lwg1056
LWG1056

NAD
Must all Engines and Distributions be Streamable?
https://wg21.link/lwg1056




Alisdair Meredith
-
d:lwg1057
LWG1057

NAD Concepts
RandomNumberEngineAdaptor
https://wg21.link/lwg1057




Alisdair Meredith
-
d:lwg1058
LWG1058

NAD Editorial
New container issue
https://wg21.link/lwg1058




Alisdair Meredith
-
d:lwg1059
LWG1059

NAD Concepts
Usage of no longer existing FunctionType concept
https://wg21.link/lwg1059




Daniel Krügler
-
d:lwg106
LWG106

TC1
Numeric library private members are implementation defined
https://wg21.link/lwg106




AFNOR
-
d:lwg1060
LWG1060

NAD Editorial
Embedded nulls in NTBS
https://wg21.link/lwg1060




Alisdair Meredith
-
d:lwg1061
LWG1061

NAD Editorial
Bad indexing for tuple access to pair (Editorial?)
https://wg21.link/lwg1061




Alisdair Meredith
-
d:lwg1062
LWG1062

NAD
Missing insert_iterator for stacks/queues
https://wg21.link/lwg1062




Alisdair Meredith
-
d:lwg1063
LWG1063

NAD Concepts
03 iterator compatibilty
https://wg21.link/lwg1063




Alisdair Meredith
-
d:lwg1064
LWG1064

NAD
Term "object state" should not refer to classes
https://wg21.link/lwg1064




Howard Hinnant
-
d:lwg1065
LWG1065

C++11
Allow inline namespaces within namespace std for implementations
https://wg21.link/lwg1065




Howard Hinnant
-
d:lwg1066
LWG1066

C++11
Use [[noreturn]] attribute in the library
https://wg21.link/lwg1066




Howard Hinnant
-
d:lwg1067
LWG1067

NAD Concepts
simplified wording for inner_product
https://wg21.link/lwg1067




Alisdair Meredith
-
d:lwg1068
LWG1068

NAD
class random_device should be movable
https://wg21.link/lwg1068




Alisdair Meredith
-
d:lwg1069
LWG1069

NAD
class seed_seq should support efficient move operations
https://wg21.link/lwg1069




Alisdair Meredith
-
d:lwg107
LWG107

NAD
Valarray constructor is strange
https://wg21.link/lwg107




AFNOR
-
d:lwg1070
LWG1070

C++11
Ambiguous move overloads in function
https://wg21.link/lwg1070




Howard Hinnant
-
d:lwg1071
LWG1071

C++11
is_bind_expression should derive from integral_constant<bool>
https://wg21.link/lwg1071




Alisdair Meredith
-
d:lwg1072
LWG1072

NAD Concepts
Is std::hash a constrained template or not?
https://wg21.link/lwg1072




Alisdair Meredith
-
d:lwg1073
LWG1073

C++11
Declaration of allocator_arg should be constexpr
https://wg21.link/lwg1073




Alisdair Meredith
-
d:lwg1074
LWG1074

NAD Concepts
concept map broken by N2840
https://wg21.link/lwg1074




Alisdair Meredith
-
d:lwg1075
LWG1075

Resolved
Scoped allocators are too complex
https://wg21.link/lwg1075




Alan Talbot
-
d:lwg1076
LWG1076

NAD Concepts
unary/binary_negate need constraining and move support
https://wg21.link/lwg1076




Alisdair Meredith
-
d:lwg1077
LWG1077

NAD Editorial
Nonesense tuple declarations
https://wg21.link/lwg1077




Pete Becker
-
d:lwg1078
LWG1078

NAD Concepts
DE-17: Remove class type_index
https://wg21.link/lwg1078




Doug Gregor
-
d:lwg1079
LWG1079

C++11
UK-265: RandomAccessIterator's operator- has nonsensical effects clause
https://wg21.link/lwg1079




Doug Gregor
-
d:lwg108
LWG108

TC1
Lifetime of exception::what() return unspecified
https://wg21.link/lwg108




AFNOR
-
d:lwg1080
LWG1080

NAD Concepts
Concept ArithmeticLike should provide explicit boolean conversion
https://wg21.link/lwg1080




Daniel Krügler
-
d:lwg1081
LWG1081

NAD Concepts
basic_string needs to be a concept-constrained template
https://wg21.link/lwg1081




Howard Hinnant
-
d:lwg1082
LWG1082

NAD Concepts
codecvt needs to be a concept-constrained template
https://wg21.link/lwg1082




Howard Hinnant
-
d:lwg1083
LWG1083

NAD Concepts
InputIterator and OutputIterator template parameters need to be concept constraints
https://wg21.link/lwg1083




Howard Hinnant
-
d:lwg1084
LWG1084

NAD Concepts
Concept ForwardIterator should provide default implementation for post-increment
https://wg21.link/lwg1084




Howard Hinnant
-
d:lwg1085
LWG1085

NAD Concepts
BidirectionalIterator concept should provide default implementation for post-decrement
https://wg21.link/lwg1085




Howard Hinnant
-
d:lwg1086
LWG1086

NAD Concepts
Stream iterators need to be concept-constrained templates
https://wg21.link/lwg1086




Howard Hinnant
-
d:lwg1087
LWG1087

NAD Concepts
Incorrect OutputIterator concept requirements for replace algorithms
https://wg21.link/lwg1087




Howard Hinnant
-
d:lwg1088
LWG1088

Resolved
std::promise should provide non-member swap overload
https://wg21.link/lwg1088




Howard Hinnant
-
d:lwg1089
LWG1089

C++11
Unify "Throws: Nothing." specifications
https://wg21.link/lwg1089




Howard Hinnant
-
d:lwg109
LWG109

CD1
Missing binders for non-const sequence elements
https://wg21.link/lwg109




Bjarne Stroustrup
-
d:lwg1090
LWG1090

Resolved
Missing description of packaged_task member swap, missing non-member swap
https://wg21.link/lwg1090




Daniel Krügler
-
d:lwg1091
LWG1091

NAD
Multimap description confusing
https://wg21.link/lwg1091




LWG
-
d:lwg1092
LWG1092

NAD Concepts
Class template integral_constant should be a constrained template
https://wg21.link/lwg1092




Daniel Krügler
-
d:lwg1093
LWG1093

Resolved
Multiple definitions for random_shuffle algorithm
https://wg21.link/lwg1093




Alisdair Meredith
-
d:lwg1094
LWG1094

C++11
Replace "unspecified-bool-type" by "explicit operator bool() const" in I/O library
https://wg21.link/lwg1094




P.J. Plauger
-
d:lwg1095
LWG1095

C++11
Shared objects and the library wording unclear
https://wg21.link/lwg1095




Beman Dawes
-
d:lwg1096
LWG1096

NAD Concepts
unconstrained rvalue ref parameters
https://wg21.link/lwg1096




David Abrahams
-
d:lwg1097
LWG1097

C++11
#define __STDCPP_THREADS
https://wg21.link/lwg1097




Jens Maurer
-
d:lwg1098
LWG1098

C++11
definition of get_pointer_safety()
https://wg21.link/lwg1098




Jens Maurer
-
d:lwg1099
LWG1099

NAD
Various issues
https://wg21.link/lwg1099




David Abrahams
-
d:lwg11
LWG11

TC1
Bitset minor problems
https://wg21.link/lwg11




Matt Austern
-
d:lwg110
LWG110

TC1
istreambuf_iterator::equal not const
https://wg21.link/lwg110




Nathan Myers
-
d:lwg1100
LWG1100

Resolved
auto_ptr to unique_ptr conversion
https://wg21.link/lwg1100




Howard Hinnant
-
d:lwg1101
LWG1101

NAD Editorial
unique requirements
https://wg21.link/lwg1101




Howard Hinnant
-
d:lwg1102
LWG1102

NAD
std::vector's reallocation policy still unclear
https://wg21.link/lwg1102




Daniel Krügler
-
d:lwg1103
LWG1103

C++11
system_error constructor postcondition overly strict
https://wg21.link/lwg1103




Howard Hinnant
-
d:lwg1104
LWG1104

C++11
basic_ios::move should accept lvalues
https://wg21.link/lwg1104




Howard Hinnant
-
d:lwg1105
LWG1105

NAD Concepts
Shouldn't Range be an auto concept
https://wg21.link/lwg1105




David Abrahams
-
d:lwg1106
LWG1106

Resolved
Multiple exceptions from connected shared_future::get()?
https://wg21.link/lwg1106




Thomas J. Gritzan
-
d:lwg1107
LWG1107

NAD Editorial
constructor shared_future(unique_future) by value?
https://wg21.link/lwg1107




Thomas J. Gritzan
-
d:lwg1108
LWG1108

C++11
thread.req.exception overly constrains implementations
https://wg21.link/lwg1108




Christopher Kohlhoff
-
d:lwg1109
LWG1109

NAD Concepts
std::includes should require CopyConstructible predicate
https://wg21.link/lwg1109




Alisdair Meredith
-
d:lwg111
LWG111

NAD
istreambuf_iterator::equal overspecified, inefficient
https://wg21.link/lwg111




Nathan Myers
-
d:lwg1110
LWG1110

C++11
Is for_each overconstrained?
https://wg21.link/lwg1110




Alisdair Meredith
-
d:lwg1111
LWG1111

NAD Concepts
associative containers underconstrained
https://wg21.link/lwg1111




Alisdair Meredith
-
d:lwg1112
LWG1112

NAD
bitsets and new style for loop
https://wg21.link/lwg1112




Alisdair Meredith
-
d:lwg1113
LWG1113

C++11
bitset::to_string could be simplified
https://wg21.link/lwg1113




Alisdair Meredith
-
d:lwg1114
LWG1114

C++11
Type traits underspecified
https://wg21.link/lwg1114




Daniel Krügler
-
d:lwg1115
LWG1115

NAD Editorial
va_copy missing from Standard macros table
https://wg21.link/lwg1115




Miles Zhao
-
d:lwg1116
LWG1116

Resolved
Literal constructors for tuple
https://wg21.link/lwg1116




Alisdair Meredith
-
d:lwg1117
LWG1117

Resolved
tuple copy constructor
https://wg21.link/lwg1117




Alisdair Meredith
-
d:lwg1118
LWG1118

C++11
tuple query APIs do not support cv-qualification
https://wg21.link/lwg1118




Alisdair Meredith
-
d:lwg1119
LWG1119

NAD
tuple query APIs do not support references
https://wg21.link/lwg1119




Alisdair Meredith
-
d:lwg112
LWG112

TC1
Minor typo in ostreambuf_iterator constructor
https://wg21.link/lwg112




Matt Austern
-
d:lwg1120
LWG1120

NAD
New type trait - remove_all
https://wg21.link/lwg1120




Alisdair Meredith
-
d:lwg1121
LWG1121

NAD
Support for multiple arguments
https://wg21.link/lwg1121




Alisdair Meredith
-
d:lwg1122
LWG1122

Resolved
Ratio values should be constexpr
https://wg21.link/lwg1122




Alisdair Meredith
-
d:lwg1123
LWG1123

C++11
No requirement that standard streams be flushed
https://wg21.link/lwg1123




James Kanze
-
d:lwg1124
LWG1124

NAD Concepts
Invalid definition of concept RvalueOf
https://wg21.link/lwg1124




Daniel Krügler
-
d:lwg1125
LWG1125

NAD
ostream_iterator does not work with movable types
https://wg21.link/lwg1125




Alisdair Meredith
-
d:lwg1126
LWG1126

C++11
istreambuff_iterator::equal needs a const & parameter
https://wg21.link/lwg1126




Alisdair Meredith
-
d:lwg1127
LWG1127

NAD Concepts
rvalue references and iterator traits
https://wg21.link/lwg1127




Alisdair Meredith
-
d:lwg1128
LWG1128

NAD Concepts
Missing definition of iterator_traits<T*>
https://wg21.link/lwg1128




Alisdair Meredith
-
d:lwg1129
LWG1129

Resolved
istream(buf)_iterator should support literal sentinel value
https://wg21.link/lwg1129




Alisdair Meredith
-
d:lwg113
LWG113

NAD
Missing/extra iostream sync semantics
https://wg21.link/lwg113




Steve Clamage
-
d:lwg1130
LWG1130

C++11
copy_exception name misleading
https://wg21.link/lwg1130




Peter Dimov
-
d:lwg1131
LWG1131

C++11
C++0x does not need alignment_of
https://wg21.link/lwg1131




Niels Dekker
-
d:lwg1132
LWG1132

NAD
JP-30: nested exceptions
https://wg21.link/lwg1132




Seiji Hayashida
-
d:lwg1133
LWG1133

C++11
Does N2844 break current specification of list::splice?
https://wg21.link/lwg1133




Alisdair Meredith
-
d:lwg1134
LWG1134

C++11
Redundant specification of <stdint.h>, <fenv.h>, <tgmath.h>, and maybe <complex.h>
https://wg21.link/lwg1134




Robert Klarer
-
d:lwg1135
LWG1135

Resolved
exception_ptr should support contextual conversion to bool
https://wg21.link/lwg1135




Daniel Krügler
-
d:lwg1136
LWG1136

C++11
Incomplete specification of nested_exception::rethrow_nested()
https://wg21.link/lwg1136




Daniel Krügler
-
d:lwg1137
LWG1137

C++11
Return type of conj and proj
https://wg21.link/lwg1137




Marc Steinbach
-
d:lwg1138
LWG1138

C++11
Unusual return value for operator+
https://wg21.link/lwg1138




Alisdair Meredith
-
d:lwg1139
LWG1139

NAD Concepts
Thread support library not concept enabled
https://wg21.link/lwg1139




LWG
-
d:lwg114
LWG114

TC1
Placement forms example in error twice
https://wg21.link/lwg114




Steve Clamage
-
d:lwg1140
LWG1140

NAD Concepts
Numerics library not concept enabled
https://wg21.link/lwg1140




LWG
-
d:lwg1141
LWG1141

NAD Concepts
Input/Output library not concept enabled
https://wg21.link/lwg1141




LWG
-
d:lwg1142
LWG1142

NAD Concepts
Regular expressions library not concept enabled
https://wg21.link/lwg1142




LWG
-
d:lwg1143
LWG1143

Resolved
Atomic operations library not concept enabled
https://wg21.link/lwg1143




LWG
-
d:lwg1144
LWG1144

C++11
"thread safe" is undefined
https://wg21.link/lwg1144




LWG
-
d:lwg1145
LWG1145

Resolved
Inappropriate headers for atomics
https://wg21.link/lwg1145




LWG
-
d:lwg1146
LWG1146

Resolved
"lockfree" does not say enough
https://wg21.link/lwg1146




Jeffrey Yasskin
-
d:lwg1147
LWG1147

Resolved
Non-volatile atomic functions
https://wg21.link/lwg1147




Jeffrey Yasskin
-
d:lwg1148
LWG1148

NAD
Wrong argument type of I/O stream manipulators setprecision() and setw()
https://wg21.link/lwg1148




Marc Steinbach
-
d:lwg1149
LWG1149

NAD Concepts
Reformulating NonemptyRange axiom
https://wg21.link/lwg1149




Walter Brown
-
d:lwg115
LWG115

TC1
Typo in strstream constructors
https://wg21.link/lwg115




Steve Clamage
-
d:lwg1150
LWG1150

Resolved
wchar_t, char16_t and char32_t filenames
https://wg21.link/lwg1150




LWG
-
d:lwg1151
LWG1151

Resolved
Behavior of the library in the presence of threads is incompletely specified
https://wg21.link/lwg1151




LWG
-
d:lwg1152
LWG1152

C++11
Expressions parsed differently than intended
https://wg21.link/lwg1152




Seungbeom Kim
-
d:lwg1153
LWG1153

NAD
Standard library needs review for constructors to be explicit to avoid treatment as initializer-list constructor
https://wg21.link/lwg1153




LWG
-
d:lwg1154
LWG1154

NAD
complex should accept integral types
https://wg21.link/lwg1154




LWG
-
d:lwg1155
LWG1155

NAD Editorial
Reference should be to C99
https://wg21.link/lwg1155




LWG
-
d:lwg1156
LWG1156

NAD
Constraints on bitmask and enumeration types to be tightened
https://wg21.link/lwg1156




LWG
-
d:lwg1157
LWG1157

C++11
Local types can now instantiate templates
https://wg21.link/lwg1157




LWG
-
d:lwg1158
LWG1158

C++11
Encouragement to use monotonic clock
https://wg21.link/lwg1158




LWG
-
d:lwg1159
LWG1159

C++11
Unclear spec for resource_deadlock_would_occur
https://wg21.link/lwg1159




LWG
-
d:lwg116
LWG116

Dup
bitset cannot be constructed with a const char*
https://wg21.link/lwg116




Judy Ward
-
d:lwg1160
LWG1160

Resolved
future_error public constructor is 'exposition only'
https://wg21.link/lwg1160




LWG
-
d:lwg1161
LWG1161

Resolved
Unnecessary unique_future limitations
https://wg21.link/lwg1161




LWG
-
d:lwg1162
LWG1162

Resolved
shared_future should support an efficient move constructor
https://wg21.link/lwg1162




LWG
-
d:lwg1163
LWG1163

Resolved
shared_future is inconsistent with shared_ptr
https://wg21.link/lwg1163




LWG
-
d:lwg1164
LWG1164

NAD
promise::swap should pass by rvalue reference
https://wg21.link/lwg1164




LWG
-
d:lwg1165
LWG1165

Resolved
Unneeded promise move constructor
https://wg21.link/lwg1165




LWG
-
d:lwg1166
LWG1166

Resolved
Allocator-specific move/copy break model of move-constructor and move-assignment
https://wg21.link/lwg1166




LWG
-
d:lwg1167
LWG1167

NAD Concepts
pair<T,U> doesn't model LessThanComparable in unconstrained code even if T and U do.
https://wg21.link/lwg1167




Dave Abrahams
-
d:lwg1168
LWG1168

NAD Editorial
Odd wording for bitset equality operators
https://wg21.link/lwg1168




Alisdair Meredith
-
d:lwg1169
LWG1169

C++17
num_get not fully compatible with strto*
https://wg21.link/lwg1169




Cosmin Truta
-
d:lwg117
LWG117

CD1
basic_ostream uses nonexistent num_put member functions
https://wg21.link/lwg117




Matt Austern
-
d:lwg1170
LWG1170

C++11
String char-like types no longer PODs
https://wg21.link/lwg1170




Beman Dawes
-
d:lwg1171
LWG1171

C++11
duration types should be literal
https://wg21.link/lwg1171




Alisdair Meredith
-
d:lwg1172
LWG1172

Resolved
select_on_container_(copy|move)_construction over-constrained
https://wg21.link/lwg1172




Alberto Ganesh Barbati
-
d:lwg1173
LWG1173

NAD
"Equivalence" wishy-washiness
https://wg21.link/lwg1173




David Abrahams
-
d:lwg1174
LWG1174

Resolved
Type property predicates
https://wg21.link/lwg1174




Jason Merrill
-
d:lwg1175
LWG1175

Open
unordered complexity
https://wg21.link/lwg1175




Pablo Halpern
-
d:lwg1176
LWG1176

NAD
Make thread constructor non-variadic
https://wg21.link/lwg1176




Howard Hinnant
-
d:lwg1177
LWG1177

C++11
Improve "diagnostic required" wording
https://wg21.link/lwg1177




Howard Hinnant
-
d:lwg1178
LWG1178

C++11
Header dependencies
https://wg21.link/lwg1178




Beman Dawes
-
d:lwg1179
LWG1179

NAD Editorial
Probably editorial in [structure.specifications]
https://wg21.link/lwg1179




Robert Klarer
-
d:lwg118
LWG118

CD1
basic_istream uses nonexistent num_get member functions
https://wg21.link/lwg118




Matt Austern
-
d:lwg1180
LWG1180

C++11
Missing string_type member typedef in class sub_match
https://wg21.link/lwg1180




Daniel Krügler
-
d:lwg1181
LWG1181

C++11
Invalid sub_match comparison operators
https://wg21.link/lwg1181




Daniel Krügler
-
d:lwg1182
LWG1182

C++11
Unfortunate hash dependencies
https://wg21.link/lwg1182




Alisdair Meredith
-
d:lwg1183
LWG1183

C++11
basic_ios::set_rdbuf may break class invariants
https://wg21.link/lwg1183




Daniel Krügler
-
d:lwg1184
LWG1184

NAD
Feature request: dynamic bitset
https://wg21.link/lwg1184




Alisdair Meredith
-
d:lwg1185
LWG1185

Resolved
Iterator categories and output iterators
https://wg21.link/lwg1185




Alisdair Meredith
-
d:lwg1186
LWG1186

NAD Concepts
Forward list could model a stack
https://wg21.link/lwg1186




Alisdair Meredith
-
d:lwg1187
LWG1187

C++11
std::decay
https://wg21.link/lwg1187




Jason Merrill
-
d:lwg1188
LWG1188

NAD
Unordered containers should have a minimum load factor as well as a maximum
https://wg21.link/lwg1188




Matt Austern
-
d:lwg1189
LWG1189

C++11
Awkward interface for changing the number of buckets in an unordered associative container
https://wg21.link/lwg1189




Matt Austern
-
d:lwg119
LWG119

TC1
Should virtual functions be allowed to strengthen the exception specification?
https://wg21.link/lwg119




Judy Ward
-
d:lwg1190
LWG1190

NAD
Setting the maximum load factor should return the previous value
https://wg21.link/lwg1190




Matt Austern
-
d:lwg1191
LWG1191

C++11
tuple get API should respect rvalues
https://wg21.link/lwg1191




Alisdair Meredith
-
d:lwg1192
LWG1192

C++11
basic_string missing definitions for cbegin / cend / crbegin / crend
https://wg21.link/lwg1192




Jonathan Wakely
-
d:lwg1193
LWG1193

C++11
default_delete cannot be instantiated with incomplete types
https://wg21.link/lwg1193




Daniel Krügler
-
d:lwg1194
LWG1194

C++11
Unintended queue constructor
https://wg21.link/lwg1194




Howard Hinnant
-
d:lwg1195
LWG1195

C++11
"Diagnostic required" wording is insufficient to prevent UB
https://wg21.link/lwg1195




Daniel Krügler
-
d:lwg1196
LWG1196

Resolved
move semantics undefined for priority_queue
https://wg21.link/lwg1196




Alisdair Meredith
-
d:lwg1197
LWG1197

C++11
Can unordered containers have bucket_count() == 0?
https://wg21.link/lwg1197




Howard Hinnant
-
d:lwg1198
LWG1198

C++11
Container adaptor swap: member or non-member?
https://wg21.link/lwg1198




Pablo Halpern
-
d:lwg1199
LWG1199

C++11
Missing extended copy constructor in container adaptors
https://wg21.link/lwg1199




Pablo Halpern
-
d:lwg12
LWG12

NAD
Way objects hold allocators unclear
https://wg21.link/lwg12




Angelika Langer
-
d:lwg120
LWG120

CD1
Can an implementor add specializations?
https://wg21.link/lwg120




Judy Ward
-
d:lwg1200
LWG1200

NAD
"surprising" char_traits<T>::int_type requirements
https://wg21.link/lwg1200




Sean Hunt
-
d:lwg1201
LWG1201

Resolved
Do we always want to unwrap ref-wrappers in make_tuple
https://wg21.link/lwg1201




Alisdair Meredith
-
d:lwg1202
LWG1202

NAD
integral_constant needs a spring clean
https://wg21.link/lwg1202




Alisdair Meredith
-
d:lwg1203
LWG1203

WP
More useful rvalue stream insertion
https://wg21.link/lwg1203




Howard Hinnant
-
d:lwg1204
LWG1204

C++11
Global permission to move
https://wg21.link/lwg1204




Howard Hinnant
-
d:lwg1205
LWG1205

C++11
Some algorithms could more clearly document their handling of empty ranges
https://wg21.link/lwg1205




Alisdair Meredith
-
d:lwg1206
LWG1206

C++11
Incorrect requires for move_backward and copy_backward
https://wg21.link/lwg1206




Howard Hinnant
-
d:lwg1207
LWG1207

C++11
Underspecified std::list operations?
https://wg21.link/lwg1207




Loïc Joly
-
d:lwg1208
LWG1208

C++11
valarray initializer_list constructor has incorrect effects
https://wg21.link/lwg1208




Howard Hinnant
-
d:lwg1209
LWG1209

C++11
match_results should be moveable
https://wg21.link/lwg1209




Stephan T. Lavavej
-
d:lwg121
LWG121

NAD
Detailed definition for ctype<wchar_t> specialization
https://wg21.link/lwg121




Judy Ward
-
d:lwg1210
LWG1210

Resolved
Iterator reachability should not require a container
https://wg21.link/lwg1210




Alisdair Meredith
-
d:lwg1211
LWG1211

Resolved
Move iterators should be restricted as input iterators
https://wg21.link/lwg1211




Alisdair Meredith
-
d:lwg1212
LWG1212

Resolved
result of post-increment/decrement operator
https://wg21.link/lwg1212




Alisdair Meredith
-
d:lwg1213
LWG1213

Open
Meaning of valid and singular iterator underspecified
https://wg21.link/lwg1213




Daniel Krügler
-
d:lwg1214
LWG1214

C++14
Insufficient/inconsistent key immutability requirements for associative containers
https://wg21.link/lwg1214




Daniel Krügler
-
d:lwg1215
LWG1215

C++11
list::merge with unequal allocators
https://wg21.link/lwg1215




Pablo Halpern
-
d:lwg1216
LWG1216

C++11
LWG 1066 Incomplete?
https://wg21.link/lwg1216




Pete Becker
-
d:lwg1217
LWG1217

NAD
Quaternion support
https://wg21.link/lwg1217




Ted Shaneyfelt
-
d:lwg1218
LWG1218

C++11
mutex destructor synchronization
https://wg21.link/lwg1218




Jeffrey Yasskin
-
d:lwg1219
LWG1219

Dup
unique_lock::lock and resource_deadlock_would_occur
https://wg21.link/lwg1219




Jeffrey Yasskin
-
d:lwg122
LWG122

TC1
streambuf/wstreambuf description should not say they are specializations
https://wg21.link/lwg122




Judy Ward
-
d:lwg1220
LWG1220

C++11
What does condition_variable wait on?
https://wg21.link/lwg1220




Jeffrey Yasskin
-
d:lwg1221
LWG1221

C++11
condition_variable wording
https://wg21.link/lwg1221




Jeffrey Yasskin
-
d:lwg1222
LWG1222

C++11
condition_variable incorrect effects for exception safety
https://wg21.link/lwg1222




Jeffrey Yasskin
-
d:lwg1223
LWG1223

NAD
condition_variable_any lock matching?
https://wg21.link/lwg1223




Jeffrey Yasskin
-
d:lwg1224
LWG1224

NAD
condition_variable_any support for recursive mutexes?
https://wg21.link/lwg1224




Jeffrey Yasskin
-
d:lwg1225
LWG1225

Resolved
C++0x result_of issue
https://wg21.link/lwg1225




Sebastian Gesemann
-
d:lwg1226
LWG1226

Resolved
Incomplete changes of #890
https://wg21.link/lwg1226




Daniel Krügler
-
d:lwg1227
LWG1227

C++11
<bitset> synopsis overspecified
https://wg21.link/lwg1227




Bo Persson
-
d:lwg1228
LWG1228

NAD
User-specialized nothrow type traits
https://wg21.link/lwg1228




Alisdair Meredith
-
d:lwg1229
LWG1229

Resolved
error_code operator= typo
https://wg21.link/lwg1229




Stephan T. Lavavej
-
d:lwg123
LWG123

CD1
Should valarray helper arrays fill functions be const?
https://wg21.link/lwg123




Judy Ward
-
d:lwg1230
LWG1230

Dup
mem_fn and variadic templates
https://wg21.link/lwg1230




Alisdair Meredith
-
d:lwg1231
LWG1231

C++11
weak_ptr comparisons incompletely resolved
https://wg21.link/lwg1231




Daniel Krügler
-
d:lwg1232
LWG1232

NAD Editorial
Still swap's with rvalue-references
https://wg21.link/lwg1232




Daniel Krügler
-
d:lwg1233
LWG1233

NAD Editorial
Missing unique_ptr signatures in synopsis
https://wg21.link/lwg1233




Daniel Krügler
-
d:lwg1234
LWG1234

C++11
"Do the right thing" and NULL
https://wg21.link/lwg1234




Matt Austern
-
d:lwg1235
LWG1235

NAD
Issue with C++0x random number proposal
https://wg21.link/lwg1235




Matthias Troyer
-
d:lwg1236
LWG1236

NAD
reserved identifiers in programs not using the library
https://wg21.link/lwg1236




Sean Hunt
-
d:lwg1237
LWG1237

C++11
Constrained error_code/error_condition members
https://wg21.link/lwg1237




Daniel Krügler
-
d:lwg1238
LWG1238

Open
Defining algorithms taking iterator for range
https://wg21.link/lwg1238




Alisdair Meredith
-
d:lwg1239
LWG1239

NAD Editorial
Defect report
https://wg21.link/lwg1239




David Abrahams
-
d:lwg124
LWG124

TC1
ctype_byname<charT>::do_scan_is & do_scan_not return type should be const charT*
https://wg21.link/lwg124




Judy Ward
-
d:lwg1240
LWG1240

C++11
Deleted comparison functions of std::function not needed
https://wg21.link/lwg1240




Daniel Krügler
-
d:lwg1241
LWG1241

C++11
unique_copy needs to require EquivalenceRelation
https://wg21.link/lwg1241




Daniel Krügler
-
d:lwg1242
LWG1242

NAD
Enable SCARY iterators
https://wg21.link/lwg1242




Herb Sutter
-
d:lwg1243
LWG1243

NAD
Missing operator+= (initializer_list<T>) for valarray
https://wg21.link/lwg1243




Daniel Krügler
-
d:lwg1244
LWG1244

Resolved
wait_*() in *future for synchronous functions
https://wg21.link/lwg1244




Detlef Vollmann
-
d:lwg1245
LWG1245

C++11
std::hash<string> & co
https://wg21.link/lwg1245




Paolo Carlini
-
d:lwg1246
LWG1246

NAD
vector::resize() missing efficiency guarantee
https://wg21.link/lwg1246




David Abrahams
-
d:lwg1247
LWG1247

C++11
auto_ptr is overspecified
https://wg21.link/lwg1247




Alisdair Meredith
-
d:lwg1248
LWG1248

Resolved
Equality comparison for unordered containers
https://wg21.link/lwg1248




Herb Sutter
-
d:lwg1249
LWG1249

C++11
basic_ios default ctor
https://wg21.link/lwg1249




Martin Sebor
-
d:lwg125
LWG125

TC1
valarray<T>::operator!() return type is inconsistent
https://wg21.link/lwg125




Judy Ward
-
d:lwg1250
LWG1250

C++11
<bitset> still overspecified
https://wg21.link/lwg1250




Martin Sebor
-
d:lwg1251
LWG1251

NAD
move constructing basic_stringbuf
https://wg21.link/lwg1251




Martin Sebor
-
d:lwg1252
LWG1252

C++11
wbuffer_convert::state_type inconsistency
https://wg21.link/lwg1252




Bo Persson
-
d:lwg1253
LWG1253

C++11
invalidation of iterators and emplace vs. insert inconsistence in assoc. containers
https://wg21.link/lwg1253




Boris Dušek
-
d:lwg1254
LWG1254

C++11
Misleading sentence in vector<bool>::flip
https://wg21.link/lwg1254




Christopher Jefferson
-
d:lwg1255
LWG1255

C++11
declval should be added to the library
https://wg21.link/lwg1255




Daniel Krügler
-
d:lwg1256
LWG1256

C++11
weak_ptr comparison functions should be removed
https://wg21.link/lwg1256




Daniel Krügler
-
d:lwg1257
LWG1257

C++11
Header <ios> still contains a concept_map
https://wg21.link/lwg1257




Beman Dawes
-
d:lwg1258
LWG1258

Resolved
std::function Effects clause impossible to satisfy
https://wg21.link/lwg1258




Daniel Krügler
-
d:lwg1259
LWG1259

NAD
Should initializer-list constructors move elements?
https://wg21.link/lwg1259




Sean Hunt
-
d:lwg126
LWG126

TC1
typos in Effects clause of ctype::do_narrow()
https://wg21.link/lwg126




Judy Ward
-
d:lwg1260
LWG1260

Resolved
is_constructible<int*,void*> reports true
https://wg21.link/lwg1260




Peter Dimov
-
d:lwg1261
LWG1261

C++11
Insufficent overloads for to_string / to_wstring
https://wg21.link/lwg1261




Christopher Jefferson
-
d:lwg1262
LWG1262

C++11
std::less<std::shared_ptr<T>> is underspecified
https://wg21.link/lwg1262




Jonathan Wakely
-
d:lwg1263
LWG1263

NAD
missing swap overloads for regex
https://wg21.link/lwg1263




Howard Hinnant
-
d:lwg1264
LWG1264

C++11
quick_exit support for freestanding implementations
https://wg21.link/lwg1264




Alisdair Meredith
-
d:lwg1265
LWG1265

NAD
longjmp and destructors
https://wg21.link/lwg1265




Sean Hunt
-
d:lwg1266
LWG1266

Resolved
shared_future::get and deferred async functions
https://wg21.link/lwg1266




Anthony Williams
-
d:lwg1267
LWG1267

C++11
Incorrect wording for condition_variable_any::wait_for
https://wg21.link/lwg1267




Anthony Williams
-
d:lwg1268
LWG1268

Resolved
The Mutex requirements in 30.4.1 and 30.4.2 are wrong
https://wg21.link/lwg1268




Anthony Williams
-
d:lwg1269
LWG1269

Resolved
Associated state doesn't account for async
https://wg21.link/lwg1269




Anthony Williams
-
d:lwg127
LWG127

TC1
auto_ptr<> conversion issues
https://wg21.link/lwg127




Greg Colvin
-
d:lwg1270
LWG1270

C++11
result_of should be moved to <type_traits>
https://wg21.link/lwg1270




Alisdair Meredith
-
d:lwg1271
LWG1271

C++11
CR undefined in duration operators
https://wg21.link/lwg1271




Daniel Krügler
-
d:lwg1272
LWG1272

Resolved
confusing declarations of promise::set_value
https://wg21.link/lwg1272




Jonathan Wakely
-
d:lwg1273
LWG1273

Resolved
future::valid should be callable on an invalid future
https://wg21.link/lwg1273




Jonathan Wakely
-
d:lwg1274
LWG1274

Resolved
atomic_future constructor
https://wg21.link/lwg1274




Jonathan Wakely
-
d:lwg1275
LWG1275

Resolved
Creating and setting futures
https://wg21.link/lwg1275




Jonathan Wakely
-
d:lwg1276
LWG1276

C++11
forwardlist missing allocator constructors
https://wg21.link/lwg1276




Daniel Krügler
-
d:lwg1277
LWG1277

C++11
std::thread::id should be trivially copyable
https://wg21.link/lwg1277




Anthony Williams
-
d:lwg1278
LWG1278

C++11
Inconsistent return values for forward_list::insert_after
https://wg21.link/lwg1278




Bo Persson
-
d:lwg1279
LWG1279

C++11
forbid [u|bi]nary_function specialization
https://wg21.link/lwg1279




Alberto Ganesh Barbati
-
d:lwg128
LWG128

NAD
Need open_mode() function for file stream, string streams, file buffers, and string buffers
https://wg21.link/lwg128




Angelika Langer
-
d:lwg1280
LWG1280

C++11
Initialization of stream iterators
https://wg21.link/lwg1280




Jonathan Wakely
-
d:lwg1281
LWG1281

Resolved
CopyConstruction and Assignment between ratios having the same normalized form
https://wg21.link/lwg1281




Vicente Juan Botet Escribá
-
d:lwg1282
LWG1282

NAD
A proposal to add std::split algorithm
https://wg21.link/lwg1282




Igor Semenov
-
d:lwg1283
LWG1283

Resolved
MoveConstructible and MoveAssignable need clarification of moved-from state
https://wg21.link/lwg1283




Howard Hinnant
-
d:lwg1284
LWG1284

C++11
vector<bool> initializer_list constructor missing an allocator argument
https://wg21.link/lwg1284




Bo Persson
-
d:lwg1285
LWG1285

C++11
allocator_traits call to new
https://wg21.link/lwg1285




Howard Hinnant
-
d:lwg1286
LWG1286

C++11
allocator_traits::select_on_container_copy_construction type-o
https://wg21.link/lwg1286




Howard Hinnant
-
d:lwg1287
LWG1287

C++11
std::function requires CopyConstructible target object
https://wg21.link/lwg1287




Jonathan Wakely
-
d:lwg1288
LWG1288

C++11
std::function assignment from rvalues
https://wg21.link/lwg1288




Jonathan Wakely
-
d:lwg1289
LWG1289

NAD
Generic casting requirements for smart pointers
https://wg21.link/lwg1289




Ion Gaztañaga
-
d:lwg129
LWG129

TC1
Need error indication from seekp() and seekg()
https://wg21.link/lwg129




Angelika Langer
-
d:lwg1290
LWG1290

Resolved
Don't require [u|bi]nary_function inheritance
https://wg21.link/lwg1290




Daniel Krügler
-
d:lwg1291
LWG1291

Resolved
Exceptions thrown during promise::set_value
https://wg21.link/lwg1291




Jonathan Wakely
-
d:lwg1292
LWG1292

C++11
std::function should support all callable types
https://wg21.link/lwg1292




Daniel Krügler
-
d:lwg1293
LWG1293

Resolved
unique_ptr<T[], D> needs to get rid of unspecified-pointer-type
https://wg21.link/lwg1293




Daniel Krügler
-
d:lwg1294
LWG1294

C++11
Difference between callable wrapper and forwarding call wrapper unclear
https://wg21.link/lwg1294




Jens Maurer
-
d:lwg1295
LWG1295

C++11
Contradictory call wrapper requirements
https://wg21.link/lwg1295




Daniel Krügler
-
d:lwg1296
LWG1296

NAD
map and multimap value_compare overspecified
https://wg21.link/lwg1296




Alisdair Meredith
-
d:lwg1297
LWG1297

Resolved
unique_ptr's relational operator functions should induce a total order
https://wg21.link/lwg1297




Daniel Krügler
-
d:lwg1298
LWG1298

C++11
Missing specialization of ctype_byname<char>
https://wg21.link/lwg1298




Alisdair Meredith
-
d:lwg1299
LWG1299

C++11
Confusing typo in specification for get_time
https://wg21.link/lwg1299




Alisdair Meredith
-
d:lwg13
LWG13

TC1
Eos refuses to die
https://wg21.link/lwg13




William M. Miller
-
d:lwg130
LWG130

CD1
Return type of container::erase(iterator) differs for associative containers
https://wg21.link/lwg130




Andrew Koenig
-
d:lwg1300
LWG1300

Resolved
Circular definition of promise::swap
https://wg21.link/lwg1300




Jonathan Wakely
-
d:lwg1301
LWG1301

NAD Editorial
clear() and assignment
https://wg21.link/lwg1301




Nicolai Josuttis
-
d:lwg1302
LWG1302

NAD
different emplace semantics for sequence and associated containers
https://wg21.link/lwg1302




Nicolai Josuttis
-
d:lwg1303
LWG1303

C++11
shared_ptr, unique_ptr, and rvalue references v2
https://wg21.link/lwg1303




Stephan T. Lavavej
-
d:lwg1304
LWG1304

Resolved
Missing preconditions for shared_future
https://wg21.link/lwg1304




Alisdair Meredith
-
d:lwg1305
LWG1305

Resolved
preconditions for atomic_future
https://wg21.link/lwg1305




Alisdair Meredith
-
d:lwg1306
LWG1306

C++11
pointer and const_pointer for <array>
https://wg21.link/lwg1306




Nicolai Josuttis
-
d:lwg1307
LWG1307

Resolved
exception_ptr and allocator pointers don't understand !=
https://wg21.link/lwg1307




Daniel Krügler
-
d:lwg1308
LWG1308

NAD
Concerns about initializer_list overloads of min, max, and minmax
https://wg21.link/lwg1308




Niels Dekker
-
d:lwg1309
LWG1309

C++11
Missing expressions for Move/CopyConstructible
https://wg21.link/lwg1309




Daniel Krügler
-
d:lwg131
LWG131

NAD
list::splice throws nothing
https://wg21.link/lwg131




Howard Hinnant
-
d:lwg1310
LWG1310

C++11
forward_list splice_after from lvalues
https://wg21.link/lwg1310




Howard Hinnant
-
d:lwg1311
LWG1311

Resolved
multi-pass property of Forward Iterator underspecified
https://wg21.link/lwg1311




Alisdair Meredith
-
d:lwg1312
LWG1312

C++11
vector::data no longer returns a raw pointer
https://wg21.link/lwg1312




Alisdair Meredith
-
d:lwg1313
LWG1313

NAD
Seed sequence's param function not useful for pure output iterator
https://wg21.link/lwg1313




Daniel Krügler
-
d:lwg1314
LWG1314

NAD
NULL and nullptr
https://wg21.link/lwg1314




Sean Hunt
-
d:lwg1315
LWG1315

NAD Editorial
return type of async
https://wg21.link/lwg1315




Jonathan Wakely
-
d:lwg1316
LWG1316

C++11
scoped_allocator_adaptor operator== has no definition
https://wg21.link/lwg1316




Pablo Halpern
-
d:lwg1317
LWG1317

NAD
make_hash
https://wg21.link/lwg1317




Nicolai M. Josuttis
-
d:lwg1318
LWG1318

NAD
N2982 removes previous allocator capabilities
https://wg21.link/lwg1318




Pete Becker
-
d:lwg1319
LWG1319

C++11
Containers should require an iterator that is at least a Forward Iterator
https://wg21.link/lwg1319




Alisdair Meredith
-
d:lwg132
LWG132

TC1
list::resize description uses random access iterators
https://wg21.link/lwg132




Howard Hinnant
-
d:lwg1320
LWG1320

NAD
Header for iter_swap
https://wg21.link/lwg1320




Alisdair Meredith
-
d:lwg1321
LWG1321

Resolved
scoped_allocator_adaptor construct and destroy don't use allocator_traits
https://wg21.link/lwg1321




Howard Hinnant
-
d:lwg1322
LWG1322

Resolved
Explicit CopyConstructible requirements are insufficient
https://wg21.link/lwg1322




Daniel Krügler
-
d:lwg1323
LWG1323

C++11
basic_string::replace should use const_iterator
https://wg21.link/lwg1323




Daniel Krügler
-
d:lwg1324
LWG1324

Resolved
Still too many implicit conversions for pair and tuple
https://wg21.link/lwg1324




Daniel Krügler
-
d:lwg1325
LWG1325

C++11
bitset
https://wg21.link/lwg1325




Christopher Jefferson
-
d:lwg1326
LWG1326

Resolved
Missing/wrong preconditions for pair and tuple functions
https://wg21.link/lwg1326




Daniel Krügler
-
d:lwg1327
LWG1327

Resolved
templates defined in <cmath> replacing C macros with the same name
https://wg21.link/lwg1327




Michael Wong
-
d:lwg1328
LWG1328

Resolved
istream extractors not setting failbit if eofbit is already set
https://wg21.link/lwg1328




Paolo Carlini
-
d:lwg1329
LWG1329

Resolved
Data races on vector<bool>
https://wg21.link/lwg1329




Jeffrey Yaskin
-
d:lwg133
LWG133

TC1
map missing get_allocator()
https://wg21.link/lwg133




Howard Hinnant
-
d:lwg1330
LWG1330

NAD
Move container requirements into requirements tables
https://wg21.link/lwg1330




Nicolai Josuttis
-
d:lwg1331
LWG1331

NAD
incorporate move special member functions into library
https://wg21.link/lwg1331




Martin Sebor
-
d:lwg1332
LWG1332

C++11
Let Hash objects throw!
https://wg21.link/lwg1332




Daniel Krügler
-
d:lwg1333
LWG1333

C++11
Missing forwarding during std::function invocation
https://wg21.link/lwg1333




Daniel Krügler
-
d:lwg1334
LWG1334

C++11
Insert iterators are broken for some proxy containers compared to C++03
https://wg21.link/lwg1334




Daniel Krügler
-
d:lwg1335
LWG1335

C++11
Insufficient requirements for tuple::operator<()
https://wg21.link/lwg1335




Joe Gottman
-
d:lwg1337
LWG1337

C++11
Swapped arguments in regex_traits::isctype
https://wg21.link/lwg1337




Howard Hinnant
-
d:lwg1338
LWG1338

C++11
LWG 1205 incorrectly applied
https://wg21.link/lwg1338




Howard Hinnant
-
d:lwg1339
LWG1339

C++11
uninitialized_fill_n should return the end of its range
https://wg21.link/lwg1339




Jared Hoberock
-
d:lwg134
LWG134

TC1
vector constructors over specified
https://wg21.link/lwg134




Howard Hinnant
-
d:lwg1340
LWG1340

C++11
Why does forward_list::resize take the object to be copied by value?
https://wg21.link/lwg1340




James McNellis
-
d:lwg1344
LWG1344

Resolved
Replace throw() with noexcept
https://wg21.link/lwg1344




BSI
-
d:lwg1345
LWG1345

Resolved
Library classes should have noexcept move operations
https://wg21.link/lwg1345




BSI
-
d:lwg1346
LWG1346

Resolved
Apply noexcept where library specification does not permit exceptions
https://wg21.link/lwg1346




BSI
-
d:lwg1347
LWG1347

Resolved
Apply noexcept judiciously throughout the library
https://wg21.link/lwg1347




BSI
-
d:lwg1348
LWG1348

NAD
Exception safety of unspecified types
https://wg21.link/lwg1348




BSI
-
d:lwg1349
LWG1349

C++11
swap should not throw
https://wg21.link/lwg1349




BSI
-
d:lwg135
LWG135

NAD
basic_iostream doubly initialized
https://wg21.link/lwg135




Howard Hinnant
-
d:lwg1350
LWG1350

Dup
Implicit contructors accidentally made some library types move-only
https://wg21.link/lwg1350




Switzerland
-
d:lwg1351
LWG1351

Dup
Replace dynamic exception specifications with noexcept
https://wg21.link/lwg1351




Switzerland
-
d:lwg1352
LWG1352

Dup
Apply noexcept where library specification says "Throws: Nothing"
https://wg21.link/lwg1352




Switzerland
-
d:lwg1353
LWG1353

Resolved
Clarify the state of a moved-from object
https://wg21.link/lwg1353




Switzerland
-
d:lwg1354
LWG1354

C++11
The definition of deadlock excludes cases involving a single thread
https://wg21.link/lwg1354




BSI
-
d:lwg1355
LWG1355

Resolved
The definition of move-assignment operator is redundant
https://wg21.link/lwg1355




BSI
-
d:lwg1356
LWG1356

Resolved
The definition of move-constructor is redundant
https://wg21.link/lwg1356




BSI
-
d:lwg1357
LWG1357

Resolved
Library bitmask types to not satisfy the bimask type requirements
https://wg21.link/lwg1357




BSI
-
d:lwg1358
LWG1358

NAD
Add <chrono> and <ratio> to freestanding implementations
https://wg21.link/lwg1358




BSI
-
d:lwg1359
LWG1359

NAD
Add <tuple> and <utility> to freestanding implementations
https://wg21.link/lwg1359




BSI
-
d:lwg136
LWG136

CD1
seekp, seekg setting wrong streams?
https://wg21.link/lwg136




Howard Hinnant
-
d:lwg1360
LWG1360

C++11
Add <atomic> to free-standing implementations
https://wg21.link/lwg1360




BSI
-
d:lwg1361
LWG1361

NAD
Does use of std::size_t in a header imply that typedef name is available to users?
https://wg21.link/lwg1361




BSI
-
d:lwg1362
LWG1362

C++11
Description of binding to rvalue-references should use the new 'xvalue' vocabulary
https://wg21.link/lwg1362




INCITS
-
d:lwg1363
LWG1363

C++11
offsetof should be marked noexcept
https://wg21.link/lwg1363




BSI
-
d:lwg1364
LWG1364

Resolved
It is not clear how exception_ptr is synchronized
https://wg21.link/lwg1364




Switzerland
-
d:lwg1365
LWG1365

Resolved
Thread-safety of handler functions
https://wg21.link/lwg1365




BSI
-
d:lwg1366
LWG1366

Resolved
New-handler and data races
https://wg21.link/lwg1366




DIN
-
d:lwg1367
LWG1367

C++11
Deprecate library support for checking dynamic exception specifications
https://wg21.link/lwg1367




BSI
-
d:lwg1368
LWG1368

C++11
Thread safety of std::uncaught_exception()
https://wg21.link/lwg1368




BSI
-
d:lwg1369
LWG1369

NAD
rethrow_exception may introduce data races
https://wg21.link/lwg1369




BSI
-
d:lwg137
LWG137

TC1
Do use_facet and has_facet look in the global locale?
https://wg21.link/lwg137




Angelika Langer
-
d:lwg1370
LWG1370

C++11
throw_with_nested should not use perfect forwarding
https://wg21.link/lwg1370




INCITS
-
d:lwg1371
LWG1371

NAD
Standard exceptions require stronger no-throw guarantees
https://wg21.link/lwg1371




BSI
-
d:lwg1372
LWG1372

C++11
Adopt recommended practice for standard error categories
https://wg21.link/lwg1372




BSI
-
d:lwg1373
LWG1373

NAD
Customizable traits should have their own headers
https://wg21.link/lwg1373




BSI
-
d:lwg1374
LWG1374

NAD
Clarify moved-from objects are "toxic"
https://wg21.link/lwg1374




INCITS
-
d:lwg1375
LWG1375

Dup
reference_type should not have been removed from the allocator requirements
https://wg21.link/lwg1375




INCITS
-
d:lwg1376
LWG1376

NAD
Allocator interface is not backward compatible
https://wg21.link/lwg1376




INCITS
-
d:lwg1377
LWG1377

Resolved
The revised forward is not compatible with access-control
https://wg21.link/lwg1377




INCITS
-
d:lwg1378
LWG1378

Resolved
pair and tuple have too many conversions
https://wg21.link/lwg1378




DIN
-
d:lwg1379
LWG1379

Resolved
pair copy-assignment not consistent for references
https://wg21.link/lwg1379




INCITS
-
d:lwg138
LWG138

NAD
Class ctype_byname<char> redundant and misleading
https://wg21.link/lwg138




Angelika Langer
-
d:lwg1380
LWG1380

Resolved
pair and tuple of references need to better specify move-semantics
https://wg21.link/lwg1380




DIN
-
d:lwg1381
LWG1381

C++11
Replace pair's range support by proper range facility
https://wg21.link/lwg1381




BSI
-
d:lwg1382
LWG1382

Resolved
pair and tuple constructors should forward arguments
https://wg21.link/lwg1382




INCITS
-
d:lwg1383
LWG1383

Resolved
Inconsistent defaulted move/copy members in pair and tuple
https://wg21.link/lwg1383




INCITS
-
d:lwg1384
LWG1384

C++11
Function pack_arguments is poorly named
https://wg21.link/lwg1384




INCITS
-
d:lwg1385
LWG1385

C++11
tuple_cat should be a single variadic signature
https://wg21.link/lwg1385




BSI
-
d:lwg1386
LWG1386

C++11
pack_arguments overly complex
https://wg21.link/lwg1386




INCITS
-
d:lwg1387
LWG1387

C++11
Range support by tuple should be removed
https://wg21.link/lwg1387




BSI
-
d:lwg1388
LWG1388

C++11
LWG 1281 incorrectly accepted
https://wg21.link/lwg1388




INCITS
-
d:lwg1389
LWG1389

Resolved
Compile-time rational arithmetic and overflow
https://wg21.link/lwg1389




BSI
-
d:lwg139
LWG139

TC1
Optional sequence operation table description unclear
https://wg21.link/lwg139




Andrew Koenig
-
d:lwg1390
LWG1390

Resolved
Limit speculative compilation for constructible/convertible traits
https://wg21.link/lwg1390




DIN
-
d:lwg1391
LWG1391

Resolved
constructible/convertible traits and access control
https://wg21.link/lwg1391




DIN
-
d:lwg1392
LWG1392

Resolved
result_of should support pointer-to-data-member
https://wg21.link/lwg1392




INCITS
-
d:lwg1393
LWG1393

Resolved
Trivial traits imply noexcept
https://wg21.link/lwg1393




BSI
-
d:lwg1394
LWG1394

Resolved
is_constructible reports false positives
https://wg21.link/lwg1394




DIN
-
d:lwg1395
LWG1395

NAD Editorial
Inconsistent reference links should be unified
https://wg21.link/lwg1395




Japan
-
d:lwg1396
LWG1396

Open
regex should support allocators
https://wg21.link/lwg1396




INCITS
-
d:lwg1397
LWG1397

Resolved
Deprecate '98 binders
https://wg21.link/lwg1397




BSI
-
d:lwg1398
LWG1398

NAD
Users should be able to specialize functors without depending on whole <functional> header
https://wg21.link/lwg1398




BSI
-
d:lwg1399
LWG1399

C++11
function does not need an explicit default constructor
https://wg21.link/lwg1399




Japan
-
d:lwg14
LWG14

TC1
Locale::combine should be const
https://wg21.link/lwg14




Nathan Myers
-
d:lwg140
LWG140

NAD Editorial
map<Key, T>::value_type does not satisfy the assignable requirement
https://wg21.link/lwg140




Mark Mitchell
-
d:lwg1400
LWG1400

C++11
FCD function does not need an explicit default constructor
https://wg21.link/lwg1400




Japan
-
d:lwg1401
LWG1401

C++11
Provide support for unique_ptr<T> == nullptr
https://wg21.link/lwg1401




BSI
-
d:lwg1402
LWG1402

C++11
nullptr constructors for smart pointers should be constexpr
https://wg21.link/lwg1402




BSI
-
d:lwg1403
LWG1403

C++11
Inconsistent definitions for allocator_arg
https://wg21.link/lwg1403




Japan
-
d:lwg1404
LWG1404

C++11
pointer_traits should have a size_type member
https://wg21.link/lwg1404




INCITS
-
d:lwg1405
LWG1405

Resolved
Move scoped_allocator_adaptor into separate header
https://wg21.link/lwg1405




INCITS
-
d:lwg1406
LWG1406

NAD
Support hashing smart-pointers based on owner
https://wg21.link/lwg1406




Japan
-
d:lwg1407
LWG1407

Resolved
Synch shared_ptr constructors taking movable types
https://wg21.link/lwg1407




INCITS
-
d:lwg1408
LWG1408

C++11
Allow recycling of pointers after undeclare_no_pointers
https://wg21.link/lwg1408




BSI
-
d:lwg1409
LWG1409

Resolved
Specify whether monotonic_clock is a distinct type or a typedef
https://wg21.link/lwg1409




INCITS
-
d:lwg141
LWG141

TC1
basic_string::find_last_of, find_last_not_of say pos instead of xpos
https://wg21.link/lwg141




Arch Robison
-
d:lwg1410
LWG1410

Resolved
Add a feature-detect macro for monotonic_clock
https://wg21.link/lwg1410




BSI
-
d:lwg1411
LWG1411

Dup
Add a compile-time flag to detect monotonic_clock
https://wg21.link/lwg1411




DIN
-
d:lwg1412
LWG1412

Resolved
Make monotonic clocks mandatory
https://wg21.link/lwg1412




Switzerland
-
d:lwg1413
LWG1413

NAD
Specify whether high_resolution_clock is a distinct type or a typedef
https://wg21.link/lwg1413




INCITS
-
d:lwg1414
LWG1414

C++11
Fixing remaining dead links to POS_T and OFF_T
https://wg21.link/lwg1414




BSI
-
d:lwg1415
LWG1415

NAD Editorial
Iterator stability bans the short-string optimization
https://wg21.link/lwg1415




INCITS
-
d:lwg1416
LWG1416

C++11
forward_list::erase_after should not be allowed to throw
https://wg21.link/lwg1416




DIN
-
d:lwg1417
LWG1417

C++11
front/back on a zero-sized array should be undefined
https://wg21.link/lwg1417




BSI
-
d:lwg1418
LWG1418

C++11
Effects of resize(size()) on a deque
https://wg21.link/lwg1418




BSI
-
d:lwg1419
LWG1419

NAD Editorial
forward_list::erase_after should return an iterator
https://wg21.link/lwg1419




INCITS
-
d:lwg142
LWG142

TC1
lexicographical_compare complexity wrong
https://wg21.link/lwg142




Howard Hinnant
-
d:lwg1420
LWG1420

C++11
Effects of resize(size()) on a list
https://wg21.link/lwg1420




BSI
-
d:lwg1421
LWG1421

Resolved
Accidental move-only library types due to new core language rules
https://wg21.link/lwg1421




DIN
-
d:lwg1422
LWG1422

Open
vector<bool> iterators are not random access
https://wg21.link/lwg1422




BSI
-
d:lwg1423
LWG1423

C++11
map constructor accepting an allocator as single parameter should be explicit
https://wg21.link/lwg1423




Japan
-
d:lwg1424
LWG1424

C++11
multimap constructor accepting an allocator as a single parameter should be explicit
https://wg21.link/lwg1424




Japan
-
d:lwg1425
LWG1425

C++11
set constructor accepting an allocator as a single parameter should be explicit
https://wg21.link/lwg1425




Japan
-
d:lwg1426
LWG1426

C++11
multiset constructor accepting an allocator as a single parameter should be explicit
https://wg21.link/lwg1426




Japan
-
d:lwg1427
LWG1427

C++11
unordered_map constructor accepting an allocator as a single parameter should be explicit
https://wg21.link/lwg1427




Japan
-
d:lwg1428
LWG1428

C++11
unordered_multimap constructor accepting an allocator as a single parameter should be explicit
https://wg21.link/lwg1428




Japan
-
d:lwg1429
LWG1429

C++11
unordered_set constructor accepting an allocator as a single parameter should be explicit
https://wg21.link/lwg1429




Japan
-
d:lwg143
LWG143

NAD
C .h header wording unclear
https://wg21.link/lwg143




Christophe de Dinechin
-
d:lwg1430
LWG1430

C++11
unordered_multiset constructor accepting an allocator as a single parameter should be explicit
https://wg21.link/lwg1430




Japan
-
d:lwg1431
LWG1431

C++11
is_permutation must be more restrictive
https://wg21.link/lwg1431




INCITS
-
d:lwg1432
LWG1432

C++11
random_shuffle signatures are inconsistent
https://wg21.link/lwg1432




INCITS
-
d:lwg1433
LWG1433

Dup
random_shuffle and shuffle should have consistent signatures
https://wg21.link/lwg1433




BSI
-
d:lwg1434
LWG1434

NAD Editorial
For min/max functions replace variadic arguments by initializer_list argument
https://wg21.link/lwg1434




INCITS
-
d:lwg1435
LWG1435

C++11
Unclear returns specifications for C99 complex number functions
https://wg21.link/lwg1435




BSI
-
d:lwg1436
LWG1436

C++11
Random number engine constructor concerns
https://wg21.link/lwg1436




BSI
-
d:lwg1437
LWG1437

C++11
Mersenne twister meaningless for word sizes less than two
https://wg21.link/lwg1437




INCITS
-
d:lwg1438
LWG1438

C++11
No definition for base()
https://wg21.link/lwg1438




INCITS
-
d:lwg1439
LWG1439

C++11
Return from densities() functions?
https://wg21.link/lwg1439




INCITS
-
d:lwg144
LWG144

TC1
Deque constructor complexity wrong
https://wg21.link/lwg144




Herb Sutter
-
d:lwg1440
LWG1440

C++11
Incorrect specification for piecewise_linear_distribution
https://wg21.link/lwg1440




INCITS
-
d:lwg1441
LWG1441

C++11
Floating-point test functions are incorrectly specified
https://wg21.link/lwg1441




INCITS
-
d:lwg1442
LWG1442

NAD Editorial
"happens-before" should be "synchronizes-with"
https://wg21.link/lwg1442




Canada
-
d:lwg1443
LWG1443

Dup
Imposed happens-before edges are not made transitive
https://wg21.link/lwg1443




BSI
-
d:lwg1444
LWG1444

Dup
OFF_T is not defined
https://wg21.link/lwg1444




BSI
-
d:lwg1445
LWG1445

Resolved
Several iostreams member functions incorrectly specified
https://wg21.link/lwg1445




INCITS/PJ Plauger
-
d:lwg1446
LWG1446

NAD
Move and swap for I/O streams
https://wg21.link/lwg1446




INCITS
-
d:lwg1447
LWG1447

Resolved
Request to resolve issue LWG 1328
https://wg21.link/lwg1447




INCITS
-
d:lwg1448
LWG1448

C++11
Concerns about basic_stringbuf::str(basic_string) postconditions
https://wg21.link/lwg1448




BSI
-
d:lwg1449
LWG1449

C++11
Incomplete specification of header <cinttypes>
https://wg21.link/lwg1449




Canada
-
d:lwg145
LWG145

NAD
adjustfield lacks default value
https://wg21.link/lwg145




Angelika Langer
-
d:lwg1450
LWG1450

C++14
Contradiction in regex_constants
https://wg21.link/lwg1450




BSI
-
d:lwg1451
LWG1451

Dup
regex should support allocators
https://wg21.link/lwg1451




INCITS
-
d:lwg1452
LWG1452

NAD
"target sequence" is not defined
https://wg21.link/lwg1452




BSI
-
d:lwg1453
LWG1453

Resolved
Default constructed match_results behavior for certain operations
https://wg21.link/lwg1453




BSI
-
d:lwg1454
LWG1454

Dup
Ensure C compatibility for atomics
https://wg21.link/lwg1454




BSI
-
d:lwg1455
LWG1455

Resolved
C language compatibility for atomics
https://wg21.link/lwg1455




Switzerland
-
d:lwg1456
LWG1456

NAD
Missing fixed-size atomic_ typedefs
https://wg21.link/lwg1456




BSI
-
d:lwg1457
LWG1457

Resolved
Splitting lock-free properties
https://wg21.link/lwg1457




BSI
-
d:lwg1458
LWG1458

Dup
Overlapping evaluations are allowed
https://wg21.link/lwg1458




BSI
-
d:lwg1459
LWG1459

LEWG
Overlapping evaluations are allowed
https://wg21.link/lwg1459




Canada
-
d:lwg146
LWG146

TC1
complex<T> Inserter and Extractor need sentries
https://wg21.link/lwg146




Angelika Langer
-
d:lwg1460
LWG1460

Resolved
Missing lock-free property for type bool should be added
https://wg21.link/lwg1460




INCITS
-
d:lwg1461
LWG1461

NAD
Rename all ATOMIC_* macros as STD_ATOMIC_*
https://wg21.link/lwg1461




Canada
-
d:lwg1462
LWG1462

Resolved
Ambiguous value assignment to atomic_bool
https://wg21.link/lwg1462




BSI
-
d:lwg1463
LWG1463

Dup
Inconsistent value assignment for atomic_bool
https://wg21.link/lwg1463




INCITS
-
d:lwg1464
LWG1464

Resolved
Underspecified typedefs for atomic integral types
https://wg21.link/lwg1464




INCITS
-
d:lwg1465
LWG1465

Resolved
Missing arithmetic operators for atomic_address
https://wg21.link/lwg1465




INCITS
-
d:lwg1466
LWG1466

Resolved
Silent const breakage by compare_exchange_* member functions
https://wg21.link/lwg1466




INCITS
-
d:lwg1467
LWG1467

Resolved
Deriving atomic<T*> from atomic_address breaks type safety
https://wg21.link/lwg1467




INCITS
-
d:lwg1468
LWG1468

Resolved
atomic_address::compare_exchange_* member functions should match atomic_compare_exchange_* free functions
https://wg21.link/lwg1468




INCITS
-
d:lwg1469
LWG1469

Resolved
atomic<T*> inheritance from atomic_address breaks type safety
https://wg21.link/lwg1469




BSI
-
d:lwg147
LWG147

TC1
Library Intro refers to global functions that aren't global
https://wg21.link/lwg147




Lois Goldthwaite
-
d:lwg1470
LWG1470

Dup
"Same-ness" curiosities
https://wg21.link/lwg1470




INCITS
-
d:lwg1471
LWG1471

NAD Editorial
Default constructor of atomics needs specification
https://wg21.link/lwg1471




INCITS
-
d:lwg1472
LWG1472

NAD Editorial
Incorrect semantics of atomic_init
https://wg21.link/lwg1472




INCITS
-
d:lwg1473
LWG1473

NAD
Incomplete memory order specifications
https://wg21.link/lwg1473




INCITS
-
d:lwg1474
LWG1474

C++11
weak compare-and-exchange confusion
https://wg21.link/lwg1474




INCITS
-
d:lwg1475
LWG1475

Dup
weak compare-and-exchange confusion II
https://wg21.link/lwg1475




Switzerland
-
d:lwg1476
LWG1476

Dup
Meaningless specification of spurious failure
https://wg21.link/lwg1476




INCITS
-
d:lwg1477
LWG1477

Dup
weak compare-and-exchange confusion III
https://wg21.link/lwg1477




BSI
-
d:lwg1478
LWG1478

C++11
Clarify race conditions in atomics initialization
https://wg21.link/lwg1478




BSI
-
d:lwg1479
LWG1479

C++11
Fence functions should be extern "C"
https://wg21.link/lwg1479




INCITS
-
d:lwg148
LWG148

TC1
Functions in the example facet BoolNames should be const
https://wg21.link/lwg148




Jeremy Siek
-
d:lwg1480
LWG1480

C++11
Atomic fences don't have synchronizes with relation
https://wg21.link/lwg1480




BSI
-
d:lwg1481
LWG1481

Resolved
Missing Lockable requirements
https://wg21.link/lwg1481




BSI
-
d:lwg1482
LWG1482

Resolved
Timeout operations are under-specified
https://wg21.link/lwg1482




INCITS
-
d:lwg1483
LWG1483

NAD Editorial
__STDCPP_THREADS spelling
https://wg21.link/lwg1483




DIN
-
d:lwg1484
LWG1484

LEWG
Need a way to join a thread with a timeout
https://wg21.link/lwg1484




INCITS
-
d:lwg1485
LWG1485

NAD
Unclear thread::id specification
https://wg21.link/lwg1485




INCITS
-
d:lwg1486
LWG1486

NAD
Value of this_thread::get_id() underspecified for detached thread
https://wg21.link/lwg1486




Switzerland
-
d:lwg1487
LWG1487

C++11
Clock related operations exception specifications conflict
https://wg21.link/lwg1487




Switzerland
-
d:lwg1488
LWG1488

LEWG
Improve interoperability between the C++0x and C1x threads APIs
https://wg21.link/lwg1488




INCITS
-
d:lwg1489
LWG1489

NAD Editorial
unlock functions and unlock mutex requirements are inconsistent
https://wg21.link/lwg1489




Switzerland
-
d:lwg149
LWG149

C++11
Insert should return iterator to first element inserted
https://wg21.link/lwg149




Andrew Koenig
-
d:lwg1490
LWG1490

Resolved
Mutex requirements too stringent
https://wg21.link/lwg1490




Switzerland
-
d:lwg1491
LWG1491

Resolved
try_lock does not guarantee forward progress
https://wg21.link/lwg1491




INCITS
-
d:lwg1492
LWG1492

Resolved
Mutex requirements should not be bound to threads
https://wg21.link/lwg1492




INCITS
-
d:lwg1493
LWG1493

LEWG
Add mutex, recursive_mutex, is_locked function
https://wg21.link/lwg1493




INCITS
-
d:lwg1494
LWG1494

C++11
Term "are serialized" not defined
https://wg21.link/lwg1494




INCITS
-
d:lwg1495
LWG1495

NAD Editorial
Condition variable wait_for return value insufficient
https://wg21.link/lwg1495




INCITS
-
d:lwg1496
LWG1496

NAD Editorial
condition_variable not implementable
https://wg21.link/lwg1496




Switzerland
-
d:lwg1497
LWG1497

C++11
lock() postcondition can not be generally achieved
https://wg21.link/lwg1497




Switzerland
-
d:lwg1498
LWG1498

Resolved
Unclear specification for [thread.condition]
https://wg21.link/lwg1498




Switzerland
-
d:lwg1499
LWG1499

NAD
Condition variables preclude wakeup optimization
https://wg21.link/lwg1499




INCITS
-
d:lwg15
LWG15

TC1
Locale::name requirement inconsistent
https://wg21.link/lwg15




Nathan Myers
-
d:lwg150
LWG150

TC1
Find_first_of says integer instead of iterator
https://wg21.link/lwg150




Matt McClure
-
d:lwg1500
LWG1500

NAD Editorial
Consider removal of native_handle()
https://wg21.link/lwg1500




Switzerland
-
d:lwg1501
LWG1501

Resolved
Specification for managing associated asynchronous state has problems
https://wg21.link/lwg1501




INCITS
-
d:lwg1502
LWG1502

Resolved
Specification of [futures.state] unclear
https://wg21.link/lwg1502




INCITS
-
d:lwg1503
LWG1503

NAD Editorial
"associated asynchronous state" must go
https://wg21.link/lwg1503




Switzerland
-
d:lwg1504
LWG1504

Resolved
Term "are serialized" is not defined
https://wg21.link/lwg1504




INCITS
-
d:lwg1505
LWG1505

Resolved
Synchronization between promise::set_value and future::get
https://wg21.link/lwg1505




INCITS
-
d:lwg1506
LWG1506

NAD Editorial
set_exception with a null pointer
https://wg21.link/lwg1506




INCITS
-
d:lwg1507
LWG1507

Resolved
promise::XXX_at_thread_exit functions have no synchronization requirements
https://wg21.link/lwg1507




INCITS
-
d:lwg1508
LWG1508

Resolved
Rename packaged_task::operator bool()
https://wg21.link/lwg1508




INCITS
-
d:lwg1509
LWG1509

NAD Editorial
No restriction on calling future::get more than once
https://wg21.link/lwg1509




INCITS
-
d:lwg151
LWG151

TC1
Can't currently clear() empty container
https://wg21.link/lwg151




Ed Brey
-
d:lwg1510
LWG1510

NAD Editorial
Should be undefined behaviour to call atomic_future operations unless valid()
https://wg21.link/lwg1510




INCITS
-
d:lwg1511
LWG1511

NAD Editorial
Synchronize the move-constructor for atomic_future
https://wg21.link/lwg1511




INCITS
-
d:lwg1512
LWG1512

NAD Editorial
Conflict in specification: block or join?
https://wg21.link/lwg1512




INCITS
-
d:lwg1513
LWG1513

Resolved
'launch' enum too restrictive
https://wg21.link/lwg1513




Switzerland
-
d:lwg1514
LWG1514

C++11
packaged_task constructors need review
https://wg21.link/lwg1514




INCITS
-
d:lwg1515
LWG1515

Resolved
packaged_task::make_ready_at_thread_exit has no synchronization requirements
https://wg21.link/lwg1515




INCITS
-
d:lwg1516
LWG1516

C++11
No specification for which header contains auto_ptr
https://wg21.link/lwg1516




BSI
-
d:lwg1517
LWG1517

C++11
default_delete's default constructor should be trivial
https://wg21.link/lwg1517




Daniel Krügler
-
d:lwg1518
LWG1518

C++11
Waiting for deferred functions
https://wg21.link/lwg1518




Alberto Ganesh Barbati
-
d:lwg1519
LWG1519

C++11
bucketsize() const only for unordered set
https://wg21.link/lwg1519




Nicolai Josuttis
-
d:lwg152
LWG152

TC1
Typo in scan_is() semantics
https://wg21.link/lwg152




Dietmar Kühl
-
d:lwg1520
LWG1520

C++11
INVOKE on member data pointer with too many arguments
https://wg21.link/lwg1520




Howard Hinnant
-
d:lwg1521
LWG1521

Open
Requirements on internal pointer representations in containers
https://wg21.link/lwg1521




Mike Spertus
-
d:lwg1522
LWG1522

C++11
conj specification is now nonsense
https://wg21.link/lwg1522




P.J. Plauger
-
d:lwg1523
LWG1523

Resolved
noexcept for Clause 29
https://wg21.link/lwg1523




Hans Boehm
-
d:lwg1524
LWG1524

C++11
Allocation functions are missing happens-before requirements and guarantees
https://wg21.link/lwg1524




Hans Boehm
-
d:lwg1525
LWG1525

C++11
Effects of resize(size()) on a vector
https://wg21.link/lwg1525




BSI
-
d:lwg1526
LWG1526

Resolved
C++ should not impose thread safety requirements on C99 library implementations
https://wg21.link/lwg1526




BSI
-
d:lwg153
LWG153

CD1
Typo in narrow() semantics
https://wg21.link/lwg153




Dietmar Kühl
-
d:lwg154
LWG154

TC1
Missing double specifier for do_get()
https://wg21.link/lwg154




Dietmar Kühl
-
d:lwg155
LWG155

TC1
Typo in naming the class defining the class Init
https://wg21.link/lwg155




Dietmar Kühl
-
d:lwg156
LWG156

TC1
Typo in imbue() description
https://wg21.link/lwg156




Dietmar Kühl
-
d:lwg157
LWG157

Dup
Meaningless error handling for pword() and iword()
https://wg21.link/lwg157




Dietmar Kühl
-
d:lwg158
LWG158

TC1
Underspecified semantics for setbuf()
https://wg21.link/lwg158




Dietmar Kühl
-
d:lwg159
LWG159

TC1
Strange use of underflow()
https://wg21.link/lwg159




Dietmar Kühl
-
d:lwg16
LWG16

TC1
Bad ctype_byname<char> decl
https://wg21.link/lwg16




Nathan Myers
-
d:lwg160
LWG160

TC1
Typo: Use of non-existing function exception()
https://wg21.link/lwg160




Dietmar Kühl
-
d:lwg161
LWG161

TC1
Typo: istream_iterator vs. istreambuf_iterator
https://wg21.link/lwg161




Dietmar Kühl
-
d:lwg162
LWG162

Dup
Really "formatted input functions"?
https://wg21.link/lwg162




Dietmar Kühl
-
d:lwg163
LWG163

Dup
Return of gcount() after a call to gcount
https://wg21.link/lwg163




Dietmar Kühl
-
d:lwg164
LWG164

TC1
do_put() has apparently unused fill argument
https://wg21.link/lwg164




Angelika Langer
-
d:lwg165
LWG165

CD1
xsputn(), pubsync() never called by basic_ostream members?
https://wg21.link/lwg165




Dietmar Kühl
-
d:lwg166
LWG166

Dup
Really "formatted output functions"?
https://wg21.link/lwg166




Dietmar Kühl
-
d:lwg167
LWG167

CD1
Improper use of traits_type::length()
https://wg21.link/lwg167




Dietmar Kühl
-
d:lwg168
LWG168

TC1
Typo: formatted vs. unformatted
https://wg21.link/lwg168




Dietmar Kühl
-
d:lwg169
LWG169

TC1
Bad efficiency of overflow() mandated
https://wg21.link/lwg169




Dietmar Kühl
-
d:lwg17
LWG17

TC1
Bad bool parsing
https://wg21.link/lwg17




Nathan Myers
-
d:lwg170
LWG170

TC1
Inconsistent definition of traits_type
https://wg21.link/lwg170




Dietmar Kühl
-
d:lwg171
LWG171

CD1
Strange seekpos() semantics due to joint position
https://wg21.link/lwg171




Dietmar Kühl
-
d:lwg172
LWG172

TC1
Inconsistent types for basic_istream::ignore()
https://wg21.link/lwg172




Greg Comeau, Dietmar Kühl
-
d:lwg173
LWG173

TC1
Inconsistent types for basic_filebuf::setbuf()
https://wg21.link/lwg173




Greg Comeau, Dietmar Kühl
-
d:lwg174
LWG174

TC1
Typo: OFF_T vs. POS_T
https://wg21.link/lwg174




Dietmar Kühl
-
d:lwg175
LWG175

TC1
Ambiguity for basic_streambuf::pubseekpos() and a few other functions.
https://wg21.link/lwg175




Dietmar Kühl
-
d:lwg176
LWG176

TC1
exceptions() in ios_base...?
https://wg21.link/lwg176




Dietmar Kühl
-
d:lwg177
LWG177

NAD
Complex operators cannot be explicitly instantiated
https://wg21.link/lwg177




Judy Ward
-
d:lwg178
LWG178

NAD
Should clog and cerr initially be tied to cout?
https://wg21.link/lwg178




Judy Ward
-
d:lwg179
LWG179

CD1
Comparison of const_iterators to iterators doesn't work
https://wg21.link/lwg179




Judy Ward
-
d:lwg18
LWG18

TC1
Get(...bool&) omitted
https://wg21.link/lwg18




Nathan Myers
-
d:lwg180
LWG180

CD1
Container member iterator arguments constness has unintended consequences
https://wg21.link/lwg180




Dave Abrahams
-
d:lwg181
LWG181

TC1
make_pair() unintended behavior
https://wg21.link/lwg181




Andrew Koenig
-
d:lwg182
LWG182

CD1
Ambiguous references to size_t
https://wg21.link/lwg182




Al Stevens
-
d:lwg183
LWG183

CD1
I/O stream manipulators don't work for wide character streams
https://wg21.link/lwg183




Andy Sawyer
-
d:lwg184
LWG184

CD1
numeric_limits<bool> wording problems
https://wg21.link/lwg184




Gabriel Dos Reis
-
d:lwg185
LWG185

CD1
Questionable use of term "inline"
https://wg21.link/lwg185




UK Panel
-
d:lwg186
LWG186

CD1
bitset::set() second parameter should be bool
https://wg21.link/lwg186




Darin Adler
-
d:lwg187
LWG187

CD1
iter_swap underspecified
https://wg21.link/lwg187




Andrew Koenig
-
d:lwg188
LWG188

NAD
valarray helpers missing augmented assignment operators
https://wg21.link/lwg188




Gabriel Dos Reis
-
d:lwg189
LWG189

TC1
setprecision() not specified correctly
https://wg21.link/lwg189




Andrew Koenig
-
d:lwg19
LWG19

TC1
"Noconv" definition too vague
https://wg21.link/lwg19




Nathan Myers
-
d:lwg190
LWG190

NAD
min() and max() functions should be std::binary_functions
https://wg21.link/lwg190




Mark Rintoul
-
d:lwg191
LWG191

NAD
Unclear complexity for algorithms such as binary search
https://wg21.link/lwg191




Nico Josuttis
-
d:lwg192
LWG192

NAD
a.insert(p,t) is inefficient and overconstrained
https://wg21.link/lwg192




Ed Brey
-
d:lwg193
LWG193

TC1
Heap operations description incorrect
https://wg21.link/lwg193




Markus Mauhart
-
d:lwg194
LWG194

NAD
rdbuf() functions poorly specified
https://wg21.link/lwg194




Steve Clamage
-
d:lwg195
LWG195

TC1
Should basic_istream::sentry's constructor ever set eofbit?
https://wg21.link/lwg195




Matt Austern
-
d:lwg196
LWG196

Dup
Placement new example has alignment problems
https://wg21.link/lwg196




Herb Sutter
-
d:lwg197
LWG197

NAD
max_size() underspecified
https://wg21.link/lwg197




Andy Sawyer
-
d:lwg198
LWG198

CD1
Validity of pointers and references unspecified after iterator destruction
https://wg21.link/lwg198




Beman Dawes
-
d:lwg199
LWG199

TC1
What does allocate(0) return?
https://wg21.link/lwg199




Matt Austern
-
d:lwg2
LWG2

NAD
Auto_ptr conversions effects incorrect
https://wg21.link/lwg2




Nathan Myers
-
d:lwg20
LWG20

TC1
Thousands_sep returns wrong type
https://wg21.link/lwg20




Nathan Myers
-
d:lwg200
LWG200

CD1
Forward iterator requirements don't allow constant iterators
https://wg21.link/lwg200




Matt Austern
-
d:lwg2000
LWG2000

C++11
Missing definition of packaged_task specialization of uses_allocator
https://wg21.link/lwg2000




Howard Hinnant
-
d:lwg2001
LWG2001

C++11
Class template basic_regex uses non existent string_type
https://wg21.link/lwg2001




Volker Lukas
-
d:lwg2002
LWG2002

Resolved
Class template match_results does not specify the semantics of operator==
https://wg21.link/lwg2002




Daniel Krügler
-
d:lwg2003
LWG2003

C++14
String exception inconsistency in erase.
https://wg21.link/lwg2003




José Daniel García Sánchez
-
d:lwg2004
LWG2004

C++11
duration::operator* has template parameters in funny order
https://wg21.link/lwg2004




P.J. Plauger
-
d:lwg2005
LWG2005

C++14
unordered_map::insert(T&&) protection should apply to map too
https://wg21.link/lwg2005




P.J. Plauger
-
d:lwg2006
LWG2006

NAD
emplace broken for associative containers
https://wg21.link/lwg2006




Pablo Halpern
-
d:lwg2007
LWG2007

C++11
Incorrect specification of return value for map<>::at()
https://wg21.link/lwg2007




Matt Austern
-
d:lwg2008
LWG2008

C++11
Conflicting Error Conditions for packaged_task::operator()
https://wg21.link/lwg2008




Pete Becker
-
d:lwg2009
LWG2009

C++14
Reporting out-of-bound values on numeric string conversions
https://wg21.link/lwg2009




Alisdair Meredith
-
d:lwg201
LWG201

CD1
Numeric limits terminology wrong
https://wg21.link/lwg201




Stephen Cleary
-
d:lwg2010
LWG2010

C++14
is_* traits for binding operations can't be meaningfully specialized
https://wg21.link/lwg2010




Sean Hunt
-
d:lwg2011
LWG2011

C++14
Unexpected output required of strings
https://wg21.link/lwg2011




James Kanze
-
d:lwg2012
LWG2012

Resolved
Associative maps should insert pair, not tuple
https://wg21.link/lwg2012




Paolo Carlini
-
d:lwg2013
LWG2013

C++14
Do library implementers have the freedom to add constexpr?
https://wg21.link/lwg2013




Matt Austern
-
d:lwg2014
LWG2014

C++11
More restrictions on macro names
https://wg21.link/lwg2014




Alberto Ganesh Barbati
-
d:lwg2015
LWG2015

C++14
Incorrect pre-conditions for some type traits
https://wg21.link/lwg2015




Nikolay Ivchenkov
-
d:lwg2016
LWG2016

C++17
Allocators must be no-throw swappable
https://wg21.link/lwg2016




Daniel Krügler
-
d:lwg2017
LWG2017

C++11
std::reference_wrapper makes incorrect usage of std::result_of
https://wg21.link/lwg2017




Nikolay Ivchenkov
-
d:lwg2018
LWG2018

C++14
[CD] regex_traits::isctype Returns clause is wrong
https://wg21.link/lwg2018




Jonathan Wakely
-
d:lwg2019
LWG2019

C++11
isblank not supported by std::locale
https://wg21.link/lwg2019




Jonathan Wakely
-
d:lwg202
LWG202

CD1
unique() effects unclear when predicate not an equivalence relation
https://wg21.link/lwg202




Andrew Koenig
-
d:lwg2020
LWG2020

C++11
Time utility arithmetic constexpr functions have invalid effects
https://wg21.link/lwg2020




Daniel Krügler
-
d:lwg2021
LWG2021

C++14
Further incorrect usages of result_of
https://wg21.link/lwg2021




Daniel Krügler
-
d:lwg2022
LWG2022

C++11
reference_wrapper<T>::result_type is underspecified
https://wg21.link/lwg2022




Daniel Krügler
-
d:lwg2023
LWG2023

Resolved
Incorrect requirements for lock_guard and unique_lock
https://wg21.link/lwg2023




Daniel Krügler
-
d:lwg2024
LWG2024

Resolved
Inconsistent implementation requirements for atomic<integral> and atomic<T*>
https://wg21.link/lwg2024




Daniel Krügler
-
d:lwg2025
LWG2025

Resolved
Incorrect semantics of move assignment operator of packaged_task
https://wg21.link/lwg2025




Daniel Krügler
-
d:lwg2026
LWG2026

NAD
hash should be std qualified for unordered container
https://wg21.link/lwg2026




Pete Becker
-
d:lwg2027
LWG2027

C++11
Initialization of the stored task of a packaged_task
https://wg21.link/lwg2027




Alberto Ganesh Barbati
-
d:lwg2028
LWG2028

C++14
messages_base::catalog overspecified
https://wg21.link/lwg2028




Howard Hinnant
-
d:lwg2029
LWG2029

C++11
Missing 'noexcept' on basic_regex move-assignment operator
https://wg21.link/lwg2029




Jonathan Wakely
-
d:lwg203
LWG203

NAD
basic_istream::sentry::sentry() is uninstantiable with ctype<user-defined type>
https://wg21.link/lwg203




Matt McClure and Dietmar Kühl
-
d:lwg2030
LWG2030

C++11
packaged_task::result_type should be removed
https://wg21.link/lwg2030




Anthony Williams
-
d:lwg2031
LWG2031

C++11
std::future<>::share() only applies to rvalues
https://wg21.link/lwg2031




Anthony Williams
-
d:lwg2032
LWG2032

C++11
Incorrect synchronization clause of async function
https://wg21.link/lwg2032




Alberto Ganesh Barbati
-
d:lwg2033
LWG2033

C++14
Preconditions of reserve, shrink_to_fit, and resize functions
https://wg21.link/lwg2033




Nikolay Ivchenkov
-
d:lwg2034
LWG2034

Resolved
Initialization of atomics is misspecified so that it doesn't preserve sequential consistency
https://wg21.link/lwg2034




Hans Boehm
-
d:lwg2035
LWG2035

Open
Output iterator requirements are broken
https://wg21.link/lwg2035




Daniel Krügler
-
d:lwg2036
LWG2036

NAD
istream >> char and eofbit
https://wg21.link/lwg2036




Howard Hinnant
-
d:lwg2037
LWG2037

Resolved
atomic free functions incorrectly specified
https://wg21.link/lwg2037




Pete Becker
-
d:lwg2038
LWG2038

Open
Missing definition for incrementable iterator
https://wg21.link/lwg2038




Pete Becker
-
d:lwg2039
LWG2039

C++14
Issues with std::reverse and std::copy_if
https://wg21.link/lwg2039




Nikolay Ivchenkov
-
d:lwg204
LWG204

NAD
distance(first, last) when "last" is before "first"
https://wg21.link/lwg204




Rintala Matti
-
d:lwg2040
LWG2040

Resolved
Missing type traits related to is_convertible
https://wg21.link/lwg2040




Daniel Krügler
-
d:lwg2041
LWG2041

C++11
Stage 2 accumulate incompatibilty
https://wg21.link/lwg2041




Howard Hinnant
-
d:lwg2042
LWG2042

C++11
Comparing forward_list::before_begin() to forward_list::end()
https://wg21.link/lwg2042




Joe Gottman
-
d:lwg2043
LWG2043

NAD
std{in,out,err} should be usable as field names
https://wg21.link/lwg2043




Jeffrey Yasskin
-
d:lwg2044
LWG2044

C++14
No definition of "Stable" for copy algorithms
https://wg21.link/lwg2044




Pablo Halpern
-
d:lwg2045
LWG2045

C++14
forward_list::merge and forward_list::splice_after with unequal allocators
https://wg21.link/lwg2045




Pablo Halpern
-
d:lwg2046
LWG2046

NAD
shared_future(future<R>&&) should be allowed to throw
https://wg21.link/lwg2046




Peter Sommerlad
-
d:lwg2047
LWG2047

C++14
Incorrect "mixed" move-assignment semantics of unique_ptr
https://wg21.link/lwg2047




Daniel Krügler
-
d:lwg2048
LWG2048

C++14
Unnecessary mem_fn overloads
https://wg21.link/lwg2048




Jonathan Wakely
-
d:lwg2049
LWG2049

C++14
is_destructible is underspecified
https://wg21.link/lwg2049




Daniel Krügler
-
d:lwg205
LWG205

NAD
numeric_limits unclear on how to determine floating point types
https://wg21.link/lwg205




Steve Cleary
-
d:lwg2050
LWG2050

C++14
Unordered associative containers do not use allocator_traits to define member types
https://wg21.link/lwg2050




Tom Zieberman
-
d:lwg2051
LWG2051

Resolved
Explicit tuple constructors for more than one parameter
https://wg21.link/lwg2051




Ville Voutilainen
-
d:lwg2052
LWG2052

Resolved
Mixup between mapped_type and value_type for associative containers
https://wg21.link/lwg2052




Marc Glisse
-
d:lwg2053
LWG2053

C++14
Errors in regex bitmask types
https://wg21.link/lwg2053




Jonathan Wakely
-
d:lwg2054
LWG2054

Resolved
time_point constructors need to be constexpr
https://wg21.link/lwg2054




Anthony Williams
-
d:lwg2055
LWG2055

Resolved
std::move in std::accumulate and other algorithms
https://wg21.link/lwg2055




Chris Jefferson
-
d:lwg2056
LWG2056

C++14
future_errc enums start with value 0 (invalid value for broken_promise)
https://wg21.link/lwg2056




Nicolai Josuttis
-
d:lwg2057
LWG2057

Resolved
time_point + duration semantics should be made constexpr conforming
https://wg21.link/lwg2057




Daniel Krügler
-
d:lwg2058
LWG2058

C++14
valarray and begin/end
https://wg21.link/lwg2058




Gabriel Dos Reis
-
d:lwg2059
LWG2059

C++17
C++0x ambiguity problem with map::erase
https://wg21.link/lwg2059




Christopher Jefferson
-
d:lwg206
LWG206

CD1
operator new(size_t, nothrow) may become unlinked to ordinary operator new if ordinary version replaced
https://wg21.link/lwg206




Howard Hinnant
-
d:lwg2060
LWG2060

NAD Editorial
unique_ptr<T[]>(nullptr_t) missing noexcept
https://wg21.link/lwg2060




Howard Hinnant, Paolo Carlini
-
d:lwg2061
LWG2061

C++14
make_move_iterator and arrays
https://wg21.link/lwg2061




Marc Glisse
-
d:lwg2062
LWG2062

C++17
Effect contradictions w/o no-throw guarantee of std::function swaps
https://wg21.link/lwg2062




Daniel Krügler
-
d:lwg2063
LWG2063

C++17
Contradictory requirements for string move assignment
https://wg21.link/lwg2063




Howard Hinnant
-
d:lwg2064
LWG2064

C++14
More noexcept issues in basic_string
https://wg21.link/lwg2064




Howard Hinnant
-
d:lwg2065
LWG2065

C++14
Minimal allocator interface
https://wg21.link/lwg2065




Jonathan Wakely
-
d:lwg2066
LWG2066

Resolved
Missing specification of vector::resize(size_type)
https://wg21.link/lwg2066




Rani Sharoni
-
d:lwg2067
LWG2067

C++14
packaged_task should have deleted copy c'tor with const parameter
https://wg21.link/lwg2067




Daniel Krügler
-
d:lwg2068
LWG2068

NAD
std::pair not C++03-compatible with defaulted copy c'tor
https://wg21.link/lwg2068




Daniel Krügler
-
d:lwg2069
LWG2069

C++14
Inconsistent exception spec for basic_string move constructor
https://wg21.link/lwg2069




Bo Persson
-
d:lwg207
LWG207

Dup
ctype<char> members return clause incomplete
https://wg21.link/lwg207




Robert Klarer
-
d:lwg2070
LWG2070

Resolved
allocate_shared should use allocator_traits<A>::construct
https://wg21.link/lwg2070




Jonathan Wakely
-
d:lwg2071
LWG2071

C++14
std::valarray move-assignment
https://wg21.link/lwg2071




Paolo Carlini
-
d:lwg2072
LWG2072

C++17
Unclear wording about capacity of temporary buffers
https://wg21.link/lwg2072




Kazutoshi Satoda
-
d:lwg2073
LWG2073

NAD
Library exceptions that take string arguments
https://wg21.link/lwg2073




Eelis van der Weegen
-
d:lwg2074
LWG2074

C++14
Off by one error in std::reverse_copy
https://wg21.link/lwg2074




Peter Miller
-
d:lwg2075
LWG2075

Resolved
Progress guarantees, lock-free property, and scheduling assumptions
https://wg21.link/lwg2075




Torvald Riegel
-
d:lwg2076
LWG2076

C++17
Bad CopyConstructible requirement in set constructors
https://wg21.link/lwg2076




Jens Maurer
-
d:lwg2077
LWG2077

Open
Further incomplete constraints for type traits
https://wg21.link/lwg2077




Daniel Krügler
-
d:lwg2078
LWG2078

C++14
Throw specification of async() incomplete
https://wg21.link/lwg2078




Nicolai Josuttis
-
d:lwg2079
LWG2079

NAD
Required pow() overloads
https://wg21.link/lwg2079




Steve Clamage
-
d:lwg208
LWG208

TC1
Unnecessary restriction on past-the-end iterators
https://wg21.link/lwg208




Stephen Cleary
-
d:lwg2080
LWG2080

C++14
Specify when once_flag becomes invalid
https://wg21.link/lwg2080




Nicolai Josuttis
-
d:lwg2081
LWG2081

C++14
Allocator requirements should include CopyConstructible
https://wg21.link/lwg2081




Jonathan Wakely
-
d:lwg2082
LWG2082

NAD
Misleading complexity requirements in <algorithm>
https://wg21.link/lwg2082




Nicolai Josuttis
-
d:lwg2083
LWG2083

C++14
const-qualification on weak_ptr::owner_before
https://wg21.link/lwg2083




Ai Azuma
-
d:lwg2084
LWG2084

NAD
basic_string use of charT*
https://wg21.link/lwg2084




Howard Hinnant
-
d:lwg2085
LWG2085

C++14
Wrong description of effect 1 of basic_istream::ignore
https://wg21.link/lwg2085




Krzysztof Żelechowski
-
d:lwg2086
LWG2086

C++14
Overly generic type support for math functions
https://wg21.link/lwg2086




Daniel Krügler
-
d:lwg2087
LWG2087

C++14
iostream_category() and noexcept
https://wg21.link/lwg2087




Nicolai Josuttis
-
d:lwg2088
LWG2088

Open
std::terminate problem
https://wg21.link/lwg2088




Daniel Krügler
-
d:lwg2089
LWG2089

Resolved
std::allocator::construct should use uniform initialization
https://wg21.link/lwg2089




David Krauss
-
d:lwg209
LWG209

TC1
basic_string declarations inconsistent
https://wg21.link/lwg209




Igor Stauder
-
d:lwg2090
LWG2090

NAD
Minor Overconstraint in Mutex Types
https://wg21.link/lwg2090




Pete Becker
-
d:lwg2091
LWG2091

C++14
Misplaced effect in m.try_lock_for()
https://wg21.link/lwg2091




Pete Becker
-
d:lwg2092
LWG2092

C++14
Vague Wording for condition_variable_any
https://wg21.link/lwg2092




Pete Becker
-
d:lwg2093
LWG2093

C++14
Throws clause of condition_variable::wait with predicate
https://wg21.link/lwg2093




Alberto Ganesh Barbati
-
d:lwg2094
LWG2094

C++14
duration conversion overflow shouldn't participate in overload resolution
https://wg21.link/lwg2094




Vicente J. Botet Escriba
-
d:lwg2095
LWG2095

LEWG
promise and packaged_task missing constructors needed for uses-allocator construction
https://wg21.link/lwg2095




Jonathan Wakely
-
d:lwg2096
LWG2096

C++14
Incorrect constraints of future::get in regard to MoveAssignable
https://wg21.link/lwg2096




Daniel Krügler
-
d:lwg2097
LWG2097

C++14
packaged_task constructors should be constrained
https://wg21.link/lwg2097




Jonathan Wakely
-
d:lwg2098
LWG2098

C++14
Minor Inconsistency between promise::set_value and promise::set_value_at_thread_exit
https://wg21.link/lwg2098




Pete Becker
-
d:lwg2099
LWG2099

C++14
Unnecessary constraints of va_start() usage
https://wg21.link/lwg2099




Daniel Krügler
-
d:lwg21
LWG21

TC1
Codecvt_byname<> instantiations
https://wg21.link/lwg21




Nathan Myers
-
d:lwg210
LWG210

TC1
distance first and last confused
https://wg21.link/lwg210




Lisa Lippincott
-
d:lwg2100
LWG2100

C++14
timed waiting functions cannot timeout if launch::async policy used
https://wg21.link/lwg2100




Jonathan Wakely
-
d:lwg2101
LWG2101

C++17
Some transformation types can produce impossible types
https://wg21.link/lwg2101




Daniel Krügler
-
d:lwg2102
LWG2102

C++14
Why is std::launch an implementation-defined type?
https://wg21.link/lwg2102




Jonathan Wakely
-
d:lwg2103
LWG2103

C++14
std::allocator_traits<std::allocator<T>>::propagate_on_container_move_assignment
https://wg21.link/lwg2103




Ai Azuma
-
d:lwg2104
LWG2104

C++14
unique_lock move-assignment should not be noexcept
https://wg21.link/lwg2104




Anthony Williams
-
d:lwg2105
LWG2105

C++14
Inconsistent requirements on const_iterator's value_type
https://wg21.link/lwg2105




Jeffrey Yasskin
-
d:lwg2106
LWG2106

C++17
move_iterator wrapping iterators returning prvalues
https://wg21.link/lwg2106




Dave Abrahams
-
d:lwg2107
LWG2107

NAD
Some iterator category should guarantee the lifetime of references
https://wg21.link/lwg2107




Jeffrey Yasskin
-
d:lwg2108
LWG2108

Resolved
No way to identify allocator types that always compare equal
https://wg21.link/lwg2108




Jonathan Wakely
-
d:lwg2109
LWG2109

C++14
Incorrect requirements for hash specializations
https://wg21.link/lwg2109




Daniel Krügler
-
d:lwg211
LWG211

TC1
operator>>(istream&, string&) doesn't set failbit
https://wg21.link/lwg211




Scott Snyder
-
d:lwg2110
LWG2110

C++14
remove can't swap but note says it might
https://wg21.link/lwg2110




Howard Hinnant
-
d:lwg2111
LWG2111

C++17
Which unexpected/terminate handler is called from the exception handling runtime?
https://wg21.link/lwg2111




Howard Hinnant
-
d:lwg2112
LWG2112

C++14
User-defined classes that cannot be derived from
https://wg21.link/lwg2112




Daniel Krügler
-
d:lwg2113
LWG2113

NAD
Do library implementers have the freedom to add final to non-polymorphic components?
https://wg21.link/lwg2113




Daniel Krügler
-
d:lwg2114
LWG2114

Open
Incorrect "contextually convertible to bool" requirements
https://wg21.link/lwg2114




Daniel Krügler
-
d:lwg2115
LWG2115

Open
Undefined behaviour for valarray assignments with mask_array index?
https://wg21.link/lwg2115




Thomas Plum
-
d:lwg2116
LWG2116

Open
is_nothrow_constructible and destructors
https://wg21.link/lwg2116




Dave Abrahams
-
d:lwg2117
LWG2117

Open
ios_base manipulators should have showgrouping/noshowgrouping
https://wg21.link/lwg2117




Benjamin Kosnik
-
d:lwg2118
LWG2118

Resolved
[CD] unique_ptr for array does not support cv qualification conversion of actual argument
https://wg21.link/lwg2118




Alf P. Steinbach
-
d:lwg2119
LWG2119

C++17
Missing hash specializations for extended integer types
https://wg21.link/lwg2119




Daniel Krügler
-
d:lwg212
LWG212

TC1
Empty range behavior unclear for several algorithms
https://wg21.link/lwg212




Nico Josuttis
-
d:lwg2120
LWG2120

C++14
What should async do if neither 'async' nor 'deferred' is set in policy?
https://wg21.link/lwg2120




Jonathan Wakely
-
d:lwg2121
LWG2121

NAD
app for string streams
https://wg21.link/lwg2121




Nicolai Josuttis
-
d:lwg2122
LWG2122

C++14
merge() stability for lists versus forward lists
https://wg21.link/lwg2122




Nicolai Josuttis
-
d:lwg2123
LWG2123

C++14
merge() allocator requirements for lists versus forward lists
https://wg21.link/lwg2123




Nicolai Josuttis
-
d:lwg2124
LWG2124

NAD
Seed sequence over-specified
https://wg21.link/lwg2124




Alberto Ganesh Barbati
-
d:lwg2125
LWG2125

Pending NAD Editorial
TimedMutex specification problem
https://wg21.link/lwg2125




Vicente J. Botet Escriba
-
d:lwg2126
LWG2126

Pending NAD Editorial
Several specification problems in regard to mutex requirements
https://wg21.link/lwg2126




Pete Becker
-
d:lwg2127
LWG2127

C++17
Move-construction with raw_storage_iterator
https://wg21.link/lwg2127




Jonathan Wakely
-
d:lwg2128
LWG2128

C++14
Absence of global functions cbegin/cend
https://wg21.link/lwg2128




Dmitry Polukhin
-
d:lwg2129
LWG2129

C++17
User specializations of std::initializer_list
https://wg21.link/lwg2129




Richard Smith
-
d:lwg213
LWG213

NAD
Math function overloads ambiguous
https://wg21.link/lwg213




Nico Josuttis
-
d:lwg2130
LWG2130

C++14
Missing ordering constraints
https://wg21.link/lwg2130




Mark Batty
-
d:lwg2131
LWG2131

NAD
Member function getline taking a string as parameter
https://wg21.link/lwg2131




Loïc Joly
-
d:lwg2132
LWG2132

C++14
std::function ambiguity
https://wg21.link/lwg2132




Ville Voutilainen
-
d:lwg2133
LWG2133

C++17
Attitude to overloaded comma for iterators
https://wg21.link/lwg2133




Yakov Galka
-
d:lwg2134
LWG2134

Pending NAD Editorial
Redundant Mutex requirement?
https://wg21.link/lwg2134




Pete Becker
-
d:lwg2135
LWG2135

C++14
Unclear requirement for exceptions thrown in condition_variable::wait()
https://wg21.link/lwg2135




Pete Becker
-
d:lwg2136
LWG2136

Open
Postconditions vs. exceptions
https://wg21.link/lwg2136




Jens Maurer
-
d:lwg2137
LWG2137

Open
Misleadingly constrained post-condition in the presence of exceptions
https://wg21.link/lwg2137




Jonathan Wakely
-
d:lwg2138
LWG2138

C++14
atomic_flag::clear should not accept memory_order_consume
https://wg21.link/lwg2138




Ben Viglietta
-
d:lwg2139
LWG2139

WP
What is a user-defined type?
https://wg21.link/lwg2139




Loïc Joly
-
d:lwg214
LWG214

CD1
set::find() missing const overload
https://wg21.link/lwg214




Judy Ward
-
d:lwg2140
LWG2140

C++14
Meaning of notify_all_at_thread_exit synchronization requirement?
https://wg21.link/lwg2140




Pete Becker
-
d:lwg2141
LWG2141

C++14
common_type trait produces reference types
https://wg21.link/lwg2141




Doug Gregor
-
d:lwg2142
LWG2142

C++14
packaged_task::operator() synchronization too broad?
https://wg21.link/lwg2142




Pete Becker
-
d:lwg2143
LWG2143

C++14
ios_base::xalloc should be thread-safe
https://wg21.link/lwg2143




Alberto Ganesh Barbati
-
d:lwg2144
LWG2144

C++14
Missing noexcept specification in type_index
https://wg21.link/lwg2144




Daniel Krügler
-
d:lwg2145
LWG2145

C++14
error_category default constructor
https://wg21.link/lwg2145




Howard Hinnant
-
d:lwg2146
LWG2146

Open
Are reference types Copy/Move-Constructible/Assignable or Destructible?
https://wg21.link/lwg2146




Nikolay Ivchenkov
-
d:lwg2147
LWG2147

C++14
Unclear hint type in Allocator's allocate function
https://wg21.link/lwg2147




Daniel Krügler
-
d:lwg2148
LWG2148

C++14
Hashing enums should be supported directly by std::hash
https://wg21.link/lwg2148




Ville Voutilainen
-
d:lwg2149
LWG2149

C++14
Concerns about 20.8/5
https://wg21.link/lwg2149




Scott Meyers
-
d:lwg215
LWG215

NAD
Can a map's key_type be const?
https://wg21.link/lwg215




Judy Ward
-
d:lwg2150
LWG2150

C++14
Unclear specification of find_end
https://wg21.link/lwg2150




Andrew Koenig
-
d:lwg2151
LWG2151

Resolved
basic_string<>::swap semantics ignore allocators
https://wg21.link/lwg2151




Robert Shearer
-
d:lwg2152
LWG2152

LEWG
Instances of standard container types are not swappable
https://wg21.link/lwg2152




Robert Shearer
-
d:lwg2153
LWG2153

LEWG
Narrowing of the non-member swap contract
https://wg21.link/lwg2153




Robert Shearer
-
d:lwg2154
LWG2154

New
What exactly does compile-time complexity imply?
https://wg21.link/lwg2154




John Salmon
-
d:lwg2155
LWG2155

Tentatively Resolved
Macro __bool_true_false_are_defined should be removed
https://wg21.link/lwg2155




Thomas Plum
-
d:lwg2156
LWG2156

C++17
Unordered containers' reserve(n) reserves for n-1 elements
https://wg21.link/lwg2156




Daniel James
-
d:lwg2157
LWG2157

Open
How does std::array<T,0> initialization work when T is not default-constructible?
https://wg21.link/lwg2157




Daryle Walker
-
d:lwg2158
LWG2158

Open
Conditional copy/move in std::vector
https://wg21.link/lwg2158




Nikolay Ivchenkov
-
d:lwg2159
LWG2159

C++14
atomic_flag initialization
https://wg21.link/lwg2159




Alberto Ganesh Barbati
-
d:lwg216
LWG216

Dup
setbase manipulator description flawed
https://wg21.link/lwg216




Hyman Rosen
-
d:lwg2160
LWG2160

C++17
Unintended destruction ordering-specification of resize
https://wg21.link/lwg2160




Daniel Krügler
-
d:lwg2161
LWG2161

NAD
const equivalence of std::map
https://wg21.link/lwg2161




Bjarne Stroustrup
-
d:lwg2162
LWG2162

C++14
allocator_traits::max_size missing noexcept
https://wg21.link/lwg2162




Bo Persson
-
d:lwg2163
LWG2163

C++14
nth_element requires inconsistent post-conditions
https://wg21.link/lwg2163




Peter Sommerlad
-
d:lwg2164
LWG2164

WP
What are the semantics of vector.emplace(vector.begin(), vector.back())?
https://wg21.link/lwg2164




Howard Hinnant
-
d:lwg2165
LWG2165

Resolved
std::atomic<X> requires X to be nothrow default constructible
https://wg21.link/lwg2165




Jonathan Wakely
-
d:lwg2166
LWG2166

C++17
Heap property underspecified?
https://wg21.link/lwg2166




Peter Sommerlad
-
d:lwg2167
LWG2167

NAD
Copy assignment requirements of Containers
https://wg21.link/lwg2167




Dean Michael Berris
-
d:lwg2168
LWG2168

C++17
Inconsistent specification of uniform_real_distribution constructor
https://wg21.link/lwg2168




Marshall Clow
-
d:lwg2169
LWG2169

C++14
Missing reset() requirements in unique_ptr specialization
https://wg21.link/lwg2169




Geoffrey Romer
-
d:lwg217
LWG217

TC1
Facets example (Classifying Japanese characters) contains errors
https://wg21.link/lwg217




Martin Sebor
-
d:lwg2170
LWG2170

C++17
Aggregates cannot be DefaultConstructible
https://wg21.link/lwg2170




Daniel Krügler
-
d:lwg2171
LWG2171

NAD
"swappable" undefined for swapping lvalue and rvalue
https://wg21.link/lwg2171




Robert Shearer
-
d:lwg2172
LWG2172

C++14
Does atomic_compare_exchange_* accept v == nullptr arguments?
https://wg21.link/lwg2172




Howard Hinnant
-
d:lwg2173
LWG2173

Open
The meaning of operator + in the description of the algorithms
https://wg21.link/lwg2173




Nikolay Ivchenkov
-
d:lwg2174
LWG2174

C++14
wstring_convert::converted() should be noexcept
https://wg21.link/lwg2174




Jonathan Wakely
-
d:lwg2175
LWG2175

C++14
wstring_convert and wbuffer_convert validity
https://wg21.link/lwg2175




Jonathan Wakely
-
d:lwg2176
LWG2176

C++14
Special members for wstring_convert and wbuffer_convert
https://wg21.link/lwg2176




Jonathan Wakely
-
d:lwg2177
LWG2177

C++14
Requirements on Copy/MoveInsertable
https://wg21.link/lwg2177




Loïc Joly
-
d:lwg2178
LWG2178

Pending NAD Editorial
Allocator requirement changes not mentioned Annex C
https://wg21.link/lwg2178




Nevin Liber
-
d:lwg2179
LWG2179

Resolved
enable_shared_from_this and construction from raw pointers
https://wg21.link/lwg2179




Daniel Krügler
-
d:lwg218
LWG218

NAD
Algorithms do not use binary predicate objects for default comparisons
https://wg21.link/lwg218




Pablo Halpern
-
d:lwg2180
LWG2180

C++14
Exceptions from std::seed_seq operations
https://wg21.link/lwg2180




Daniel Krügler
-
d:lwg2181
LWG2181

C++17
Exceptions from seed sequence operations
https://wg21.link/lwg2181




Daniel Krügler
-
d:lwg2182
LWG2182

C++14
Container::[const_]reference types are misleadingly specified
https://wg21.link/lwg2182




Daniel Krügler
-
d:lwg2183
LWG2183

WP
Muddled allocator requirements for match_results constructors
https://wg21.link/lwg2183




Pete Becker
-
d:lwg2184
LWG2184

WP
Muddled allocator requirements for match_results assignments
https://wg21.link/lwg2184




Pete Becker
-
d:lwg2185
LWG2185

C++14
Missing throws clause for future/shared_future::wait_for/wait_until
https://wg21.link/lwg2185




Vicente J. Botet Escriba
-
d:lwg2186
LWG2186

C++14
Incomplete action on async/launch::deferred
https://wg21.link/lwg2186




Vicente J. Botet Escriba
-
d:lwg2187
LWG2187

C++14
vector<bool> is missing emplace and emplace_back member functions
https://wg21.link/lwg2187




Nevin Liber
-
d:lwg2188
LWG2188

C++14
Reverse iterator does not fully support targets that overload operator&
https://wg21.link/lwg2188




Alisdair Meredith
-
d:lwg2189
LWG2189

Open
Throwing swap breaks unordered containers' state
https://wg21.link/lwg2189




Alisdair Meredith
-
d:lwg219
LWG219

NAD
find algorithm missing version that takes a binary predicate argument
https://wg21.link/lwg219




Pablo Halpern
-
d:lwg2190
LWG2190

C++14
Condition variable specification
https://wg21.link/lwg2190




Hans Boehm
-
d:lwg2191
LWG2191

New
Incorrect specification of match_results(match_results&&)
https://wg21.link/lwg2191




Pete Becker
-
d:lwg2192
LWG2192

C++17
Validity and return type of std::abs(0u) is unclear
https://wg21.link/lwg2192




Daniel Krügler
-
d:lwg2193
LWG2193

C++14
Default constructors for standard library containers are explicit
https://wg21.link/lwg2193




Richard Smith
-
d:lwg2194
LWG2194

C++14
Impossible container requirements for adaptor types
https://wg21.link/lwg2194




Sebastian Mach
-
d:lwg2195
LWG2195

Open
Missing constructors for match_results
https://wg21.link/lwg2195




Daniel Krügler
-
d:lwg2196
LWG2196

C++14
Specification of is_*[copy/move]_[constructible/assignable] unclear for non-referencable types
https://wg21.link/lwg2196




Daniel Krügler
-
d:lwg2197
LWG2197

C++14
Specification of is_[un]signed unclear for non-arithmetic types
https://wg21.link/lwg2197




Daniel Krügler
-
d:lwg2198
LWG2198

Open
max_load_factor(z) makes no strong guarantees, but bans useful behavior
https://wg21.link/lwg2198




Alisdair Meredith
-
d:lwg2199
LWG2199

NAD
unordered containers are required to have an initial max load factor of 1.0
https://wg21.link/lwg2199




Alisdair Meredith
-
d:lwg22
LWG22

TC1
Member open vs. flags
https://wg21.link/lwg22




Nathan Myers
-
d:lwg220
LWG220

TC1
~ios_base() usage valid?
https://wg21.link/lwg220




Jonathan Schilling, Howard Hinnant
-
d:lwg2200
LWG2200

C++14
Data race avoidance for all containers, not only for sequences
https://wg21.link/lwg2200




Jonathan Wakely
-
d:lwg2201
LWG2201

NAD Editorial
Missing macro entries from C standard library
https://wg21.link/lwg2201




Kevin McCarty
-
d:lwg2202
LWG2202

Deferred
Missing allocator support by async
https://wg21.link/lwg2202




Detlef Vollmann
-
d:lwg2203
LWG2203

C++14
scoped_allocator_adaptor uses wrong argument types for piecewise construction
https://wg21.link/lwg2203




Jonathan Wakely
-
d:lwg2204
LWG2204

NAD
reverse_iterator should not require a second copy of the base iterator
https://wg21.link/lwg2204




David Abrahams
-
d:lwg2205
LWG2205

C++14
Problematic postconditions of regex_match and regex_search
https://wg21.link/lwg2205




Pete Becker
-
d:lwg2206
LWG2206

Open
Inaccuracy in initializer_list constructor requirements
https://wg21.link/lwg2206




Jeffrey Yasskin
-
d:lwg2207
LWG2207

C++14
basic_string::at should not have a Requires clause
https://wg21.link/lwg2207




Nevin Liber
-
d:lwg2208
LWG2208

Resolved
std::reverse_iterator should be a literal type
https://wg21.link/lwg2208




Jeffrey Yasskin
-
d:lwg2209
LWG2209

C++14
assign() overspecified for sequence containers
https://wg21.link/lwg2209




Jonathan Wakely
-
d:lwg221
LWG221

CD1
num_get<>::do_get stage 2 processing broken
https://wg21.link/lwg221




Matt Austern
-
d:lwg2210
LWG2210

C++14
Missing allocator-extended constructor for allocator-aware containers
https://wg21.link/lwg2210




Jonathan Wakely
-
d:lwg2211
LWG2211

C++14
Replace ambiguous use of "Allocator" in container requirements
https://wg21.link/lwg2211




Jonathan Wakely
-
d:lwg2212
LWG2212

C++17
tuple_size for const pair request <tuple> header
https://wg21.link/lwg2212




Alisdair Meredith
-
d:lwg2213
LWG2213

C++14
Return value of std::regex_replace
https://wg21.link/lwg2213




Pete Becker
-
d:lwg2214
LWG2214

Open
Clarify basic_ios::init call restrictions
https://wg21.link/lwg2214




Andrey Semashev
-
d:lwg2215
LWG2215

Open
(unordered) associative container functors should be CopyConstructible
https://wg21.link/lwg2215




Alisdair Meredith
-
d:lwg2216
LWG2216

New
regex_replace(basic_string) allocator handling
https://wg21.link/lwg2216




Jeffrey Yasskin
-
d:lwg2217
LWG2217

C++17
operator==(sub_match, string) slices on embedded '\0's
https://wg21.link/lwg2217




Jeffrey Yasskin
-
d:lwg2218
LWG2218

C++17
Unclear how containers use allocator_traits::construct()
https://wg21.link/lwg2218




Jonathan Wakely
-
d:lwg2219
LWG2219

C++17
INVOKE-ing a pointer to member with a reference_wrapper as the object expression
https://wg21.link/lwg2219




Jonathan Wakely
-
d:lwg222
LWG222

TC1
Are throw clauses necessary if a throw is already implied by the effects clause?
https://wg21.link/lwg222




Judy Ward
-
d:lwg2220
LWG2220

Open
Under-specification of operator== for regex_token_iterator
https://wg21.link/lwg2220




Pete Becker
-
d:lwg2221
LWG2221

C++17
No formatted output operator for nullptr
https://wg21.link/lwg2221




Matt Austern
-
d:lwg2222
LWG2222

C++14
Inconsistency in description of forward_list::splice_after single-element overload
https://wg21.link/lwg2222




Edward Catmur
-
d:lwg2223
LWG2223

C++17
shrink_to_fit effect on iterator validity
https://wg21.link/lwg2223




Juan Soulie
-
d:lwg2224
LWG2224

C++17
Ambiguous status of access to non-live objects
https://wg21.link/lwg2224




Geoffrey Romer
-
d:lwg2225
LWG2225

C++14
Unrealistic header inclusion checks required
https://wg21.link/lwg2225




Richard Smith
-
d:lwg2226
LWG2226

NAD
wstring_convert methods do not take allocator instance
https://wg21.link/lwg2226




Glen Fernandes
-
d:lwg2227
LWG2227

Open
Stateful comparison objects in associative containers
https://wg21.link/lwg2227




Juan Soulie
-
d:lwg2228
LWG2228

Resolved
Missing SFINAE rule in unique_ptr templated assignment
https://wg21.link/lwg2228




Geoffrey Romer
-
d:lwg2229
LWG2229

C++14
Standard code conversion facets underspecified
https://wg21.link/lwg2229




Beman Dawes
-
d:lwg223
LWG223

TC1
reverse algorithm should use iter_swap rather than swap
https://wg21.link/lwg223




Dave Abrahams
-
d:lwg2230
LWG2230

C++17
"see below" for initializer-list constructors of unordered containers
https://wg21.link/lwg2230




Jonathan Wakely
-
d:lwg2231
LWG2231

C++14
DR 704 removes complexity guarantee for clear()
https://wg21.link/lwg2231




Jonathan Wakely
-
d:lwg2232
LWG2232

Resolved
[CD] The char_traits specializations should declare their length(), compare(), and find() members constexpr
https://wg21.link/lwg2232




Jeffrey Yasskin
-
d:lwg2233
LWG2233

C++17
bad_function_call::what() unhelpful
https://wg21.link/lwg2233




Jonathan Wakely
-
d:lwg2234
LWG2234

C++17
assert() should allow usage in constant expressions
https://wg21.link/lwg2234




Daniel Krügler
-
d:lwg2235
LWG2235

C++14
Undefined behavior without proper requirements on basic_string constructors
https://wg21.link/lwg2235




Juan Soulie
-
d:lwg2236
LWG2236

SG1
kill_dependency unconditionally noexcept
https://wg21.link/lwg2236




Daniel Krügler
-
d:lwg2237
LWG2237

New
<cuchar> macros
https://wg21.link/lwg2237




Jason Merrill
-
d:lwg2238
LWG2238

Open
Problematic iterator-pair constructor of containers
https://wg21.link/lwg2238




Johannes Schaub
-
d:lwg2239
LWG2239

C++17
min/max/minmax requirements
https://wg21.link/lwg2239




Juan Soulie
-
d:lwg224
LWG224

TC1
clear() complexity for associative containers refers to undefined N
https://wg21.link/lwg224




Ed Brey
-
d:lwg2240
LWG2240

Resolved
Probable misuse of term "function scope" in [thread.condition]
https://wg21.link/lwg2240




FrankHB1989
-
d:lwg2241
LWG2241

Resolved
<cstdalign> and #define of alignof
https://wg21.link/lwg2241




Richard Smith
-
d:lwg2242
LWG2242

NAD
[uninitialized_]copy_n() defect
https://wg21.link/lwg2242




Sean Parent
-
d:lwg2243
LWG2243

WP
istream::putback problem
https://wg21.link/lwg2243




Juan Soulie
-
d:lwg2244
LWG2244

C++17
Issue on basic_istream::seekg
https://wg21.link/lwg2244




Juan Soulie
-
d:lwg2245
LWG2245

Resolved
packaged_task::reset() memory allocation
https://wg21.link/lwg2245




Jonathan Wakely
-
d:lwg2246
LWG2246

C++14
unique_ptr assignment effects w.r.t. deleter
https://wg21.link/lwg2246




Jonathan Wakely
-
d:lwg2247
LWG2247

C++14
Type traits and std::nullptr_t
https://wg21.link/lwg2247




Joe Gottman
-
d:lwg2248
LWG2248

New
numeric_limits::is_iec559 misnamed
https://wg21.link/lwg2248




Pete Becker
-
d:lwg2249
LWG2249

Resolved
[CD] Remove gets from <cstdio>
https://wg21.link/lwg2249




Jonathan Wakely
-
d:lwg225
LWG225

CD1
std:: algorithms use of other unqualified algorithms
https://wg21.link/lwg225




Dave Abrahams
-
d:lwg2250
LWG2250

C++17
Follow-up On Library Issue 2207
https://wg21.link/lwg2250




Frank Birbacher
-
d:lwg2251
LWG2251

NAD
C++ library should define ssize_t
https://wg21.link/lwg2251




Matt Austern
-
d:lwg2252
LWG2252

C++14
Strong guarantee on vector::push_back() still broken with C++11?
https://wg21.link/lwg2252




Nicolai Josuttis
-
d:lwg2253
LWG2253

NAD Arrays
[arrays.ts] dynarray should state which container requirements aren't met
https://wg21.link/lwg2253




Jonathan Wakely
-
d:lwg2254
LWG2254

NAD Arrays
[arrays.ts] Is dynarray an allocator-aware container?
https://wg21.link/lwg2254




Jonathan Wakely
-
d:lwg2255
LWG2255

NAD Arrays
[arrays.ts] dynarray constructor ambiguity
https://wg21.link/lwg2255




Jonathan Wakely
-
d:lwg2256
LWG2256

NAD
On vector iterator invalidation
https://wg21.link/lwg2256




Howard Hinnant
-
d:lwg2257
LWG2257

C++14
Simplify container requirements with the new algorithms
https://wg21.link/lwg2257




Marshall Clow
-
d:lwg2258
LWG2258

C++14
a.erase(q1, q2) unable to directly return q2
https://wg21.link/lwg2258




Geoff Alexander
-
d:lwg2259
LWG2259

C++17
Issues in 17.6.5.5 rules for member functions
https://wg21.link/lwg2259




Richard Smith
-
d:lwg226
LWG226

CD1
User supplied specializations or overloads of namespace std function templates
https://wg21.link/lwg226




Dave Abrahams
-
d:lwg2260
LWG2260

C++17
Missing requirement for Allocator::pointer
https://wg21.link/lwg2260




Jonathan Wakely
-
d:lwg2261
LWG2261

C++17
Are containers required to use their 'pointer' type internally?
https://wg21.link/lwg2261




Jonathan Wakely
-
d:lwg2262
LWG2262

Open
Requirement for unique_ptr<T>::get_deleter()(p) to be able to destroy the unique_ptr
https://wg21.link/lwg2262




Rob Desbois
-
d:lwg2263
LWG2263

C++14
Comparing iterators and allocator pointers with different const-character
https://wg21.link/lwg2263




Howard Hinnant
-
d:lwg2264
LWG2264

NAD Arrays
[arrays.ts] std::dynarray defines its initializer-list constructor in terms of a non-existent constructor
https://wg21.link/lwg2264




Povilas Kanapickas
-
d:lwg2265
LWG2265

Open
29.3p9 appears to rule out some acceptable executions
https://wg21.link/lwg2265




Brian Demsky
-
d:lwg2266
LWG2266

C++17
vector and deque have incorrect insert requirements
https://wg21.link/lwg2266




Ahmed Charles
-
d:lwg2267
LWG2267

New
partial_sort_copy underspecified for ranges of two different types
https://wg21.link/lwg2267




Matt Austern
-
d:lwg2268
LWG2268

C++14
Setting a default argument in the declaration of a member function assign of std::basic_string
https://wg21.link/lwg2268




Vladimir Grigoriev
-
d:lwg2269
LWG2269

New
Container iterators and argument-dependent lookup
https://wg21.link/lwg2269




Matt Austern
-
d:lwg227
LWG227

TC1
std::swap() should require CopyConstructible or DefaultConstructible arguments
https://wg21.link/lwg227




Dave Abrahams
-
d:lwg2270
LWG2270

NAD
Inconsistent to_string overloads
https://wg21.link/lwg2270




Raf Schietekat
-
d:lwg2271
LWG2271

C++14
regex_traits::lookup_classname specification unclear
https://wg21.link/lwg2271




Jonathan Wakely
-
d:lwg2272
LWG2272

C++14
quoted should use char_traits::eq for character comparison
https://wg21.link/lwg2272




Marshall Clow
-
d:lwg2273
LWG2273

C++17
regex_match ambiguity
https://wg21.link/lwg2273




Howard Hinnant
-
d:lwg2274
LWG2274

Resolved
Does map::operator[] value-initialize or default-insert a missing element?
https://wg21.link/lwg2274




Andrzej Krzemieński
-
d:lwg2275
LWG2275

C++14
[CD] Why is forward_as_tuple not constexpr?
https://wg21.link/lwg2275




Marshall Clow
-
d:lwg2276
LWG2276

C++17
Missing requirement on std::promise::set_exception
https://wg21.link/lwg2276




Jonathan Wakely
-
d:lwg2277
LWG2277

NAD Arrays
[arrays.ts] <dynarray> is missing in 24.7/1
https://wg21.link/lwg2277




Cassio Neri
-
d:lwg2278
LWG2278

C++14
User-defined literals for Standard Library types
https://wg21.link/lwg2278




Howard Hinnant
-
d:lwg2279
LWG2279

NAD
Carefully state effects of list::splice function
https://wg21.link/lwg2279




Arseny Klimovsky
-
d:lwg228
LWG228

CD1
Incorrect specification of "..._byname" facets
https://wg21.link/lwg228




Dietmar Kühl
-
d:lwg2280
LWG2280

C++14
begin/end for arrays should be constexpr and noexcept
https://wg21.link/lwg2280




Andy Sawyer
-
d:lwg2281
LWG2281

NAD Editorial
C99 cross-reference typo in [using.linkage]
https://wg21.link/lwg2281




Chris Sharpe
-
d:lwg2282
LWG2282

Resolved
[fund.ts] Incorrect is_assignable constraint in optional::op=(U&&)
https://wg21.link/lwg2282




Howard Hinnant
-
d:lwg2283
LWG2283

Resolved
[fund.ts] optional declares and then does not define an operator<()
https://wg21.link/lwg2283




Howard Hinnant
-
d:lwg2284
LWG2284

C++14
Inconsistency in allocator_traits::max_size
https://wg21.link/lwg2284




Marshall Clow
-
d:lwg2285
LWG2285

C++14
make_reverse_iterator
https://wg21.link/lwg2285




Zhihao Yuan
-
d:lwg2286
LWG2286

Open
stringbuf::underflow() underspecified
https://wg21.link/lwg2286




Sergey Zubkov
-
d:lwg2287
LWG2287

Resolved
[fund.ts] Incorrect exception safety for optional copy assignment operator
https://wg21.link/lwg2287




Howard Hinnant
-
d:lwg2288
LWG2288

C++14
Inconsistent requirements for shared mutexes
https://wg21.link/lwg2288




Daniel Krügler
-
d:lwg2289
LWG2289

Open
constexpr guarantees of defaulted functions still insufficient
https://wg21.link/lwg2289




Daniel Krügler
-
d:lwg229
LWG229

CD1
Unqualified references of other library entities
https://wg21.link/lwg229




Steve Clamage
-
d:lwg2290
LWG2290

Open
Top-level "SFINAE"-based constraints should get a separate definition in Clause 17
https://wg21.link/lwg2290




Daniel Krügler
-
d:lwg2291
LWG2291

C++14
std::hash is vulnerable to collision DoS attack
https://wg21.link/lwg2291




Zhihao Yuan
-
d:lwg2292
LWG2292

Tentatively Resolved
Find a better phrasing for "shall not participate in overload resolution"
https://wg21.link/lwg2292




Jeffrey Yasskin
-
d:lwg2293
LWG2293

C++14
Wrong facet used by num_put::do_put
https://wg21.link/lwg2293




Juan Soulie
-
d:lwg2294
LWG2294

Resolved
<cstdlib> should declare abs(double)
https://wg21.link/lwg2294




Pete Becker
-
d:lwg2295
LWG2295

New
Locale name when the provided Facet is a nullptr
https://wg21.link/lwg2295




Juan Soulie
-
d:lwg2296
LWG2296

C++17
std::addressof should be constexpr
https://wg21.link/lwg2296




Daryle Walker
-
d:lwg2297
LWG2297

NAD
[CD] Missing type requirements for std::exchange
https://wg21.link/lwg2297




Alisdair Meredith
-
d:lwg2298
LWG2298

C++14
[CD] is_nothrow_constructible is always false because of create<>
https://wg21.link/lwg2298




Daniel Krügler
-
d:lwg2299
LWG2299

C++14
[CD] Effects of inaccessible key_compare::is_transparent type are not clear
https://wg21.link/lwg2299




Daniel Krügler
-
d:lwg23
LWG23

CD1
Num_get overflow result
https://wg21.link/lwg23




Nathan Myers
-
d:lwg230
LWG230

CD1
Assignable specified without also specifying CopyConstructible
https://wg21.link/lwg230




Beman Dawes
-
d:lwg2300
LWG2300

C++14
[CD] Redundant sections for map and multimap members should be removed
https://wg21.link/lwg2300




Daniel Krügler
-
d:lwg2301
LWG2301

C++14
Why is std::tie not constexpr?
https://wg21.link/lwg2301




Rein Halbersma
-
d:lwg2302
LWG2302

Pending NAD
Passing null pointer to placement new
https://wg21.link/lwg2302




Marc Glisse
-
d:lwg2303
LWG2303

New
Explicit instantiation of std::vector<UserType> broken?
https://wg21.link/lwg2303




Daniel Krügler
-
d:lwg2304
LWG2304

C++14
Complexity of count in unordered associative containers
https://wg21.link/lwg2304




Joaquín M López Muñoz
-
d:lwg2305
LWG2305

NAD
[fund.ts] optional forwarding construction/assignment
https://wg21.link/lwg2305




Cassio Neri
-
d:lwg2306
LWG2306

C++14
match_results::reference should be value_type&, not const value_type&
https://wg21.link/lwg2306




Matt Austern
-
d:lwg2307
LWG2307

LEWG
Should the Standard Library use explicit only when necessary?
https://wg21.link/lwg2307




Zhihao Yuan
-
d:lwg2308
LWG2308

C++14
Clarify container destructor requirements w.r.t. std::array
https://wg21.link/lwg2308




Jonathan Wakely
-
d:lwg2309
LWG2309

C++17
mutex::lock() should not throw device_or_resource_busy
https://wg21.link/lwg2309




Detlef Vollmann
-
d:lwg231
LWG231

CD1
Precision in iostream?
https://wg21.link/lwg231




James Kanze, Stephen Clamage
-
d:lwg2310
LWG2310

C++17
Public exposition only member in std::array
https://wg21.link/lwg2310




Jonathan Wakely
-
d:lwg2311
LWG2311

NAD
Allocator requirements should be further minimized
https://wg21.link/lwg2311




Stephan T. Lavavej
-
d:lwg2312
LWG2312

C++17
tuple's constructor constraints need to be phrased more precisely
https://wg21.link/lwg2312




Stephan T. Lavavej
-
d:lwg2313
LWG2313

C++14
tuple_size should always derive from integral_constant<size_t, N>
https://wg21.link/lwg2313




Stephan T. Lavavej
-
d:lwg2314
LWG2314

C++14
apply() should return decltype(auto) and use decay_t before tuple_size
https://wg21.link/lwg2314




Stephan T. Lavavej
-
d:lwg2315
LWG2315

C++14
weak_ptr should be movable
https://wg21.link/lwg2315




Stephan T. Lavavej
-
d:lwg2316
LWG2316

C++14
weak_ptr::lock() should be atomic
https://wg21.link/lwg2316




Stephan T. Lavavej
-
d:lwg2317
LWG2317

C++14
The type property queries should be UnaryTypeTraits returning size_t
https://wg21.link/lwg2317




Stephan T. Lavavej
-
d:lwg2318
LWG2318

Resolved
basic_string's wording has confusing relics from the copy-on-write era
https://wg21.link/lwg2318




Stephan T. Lavavej
-
d:lwg2319
LWG2319

NAD
basic_string's move constructor should not be noexcept
https://wg21.link/lwg2319




Stephan T. Lavavej
-
d:lwg232
LWG232

CD1
"depends" poorly defined in 17.4.3.1
https://wg21.link/lwg232




Peter Dimov
-
d:lwg2320
LWG2320

C++14
select_on_container_copy_construction() takes allocators, not containers
https://wg21.link/lwg2320




Stephan T. Lavavej
-
d:lwg2321
LWG2321

Open
Moving containers should (usually) be required to preserve iterators
https://wg21.link/lwg2321




Stephan T. Lavavej
-
d:lwg2322
LWG2322

C++14
Associative(initializer_list, stuff) constructors are underspecified
https://wg21.link/lwg2322




Stephan T. Lavavej
-
d:lwg2323
LWG2323

C++14
vector::resize(n, t)'s specification should be simplified
https://wg21.link/lwg2323




Stephan T. Lavavej
-
d:lwg2324
LWG2324

C++14
Insert iterator constructors should use addressof()
https://wg21.link/lwg2324




Stephan T. Lavavej
-
d:lwg2325
LWG2325

C++17
minmax_element()'s behavior differing from max_element()'s should be noted
https://wg21.link/lwg2325




Stephan T. Lavavej
-
d:lwg2326
LWG2326

NAD
uniform_int_distribution<unsigned char> should be permitted
https://wg21.link/lwg2326




Stephan T. Lavavej
-
d:lwg2327
LWG2327

NAD
Non-power-of-two URNGs should be forbidden
https://wg21.link/lwg2327




Stephan T. Lavavej
-
d:lwg2328
LWG2328

C++17
Rvalue stream extraction should use perfect forwarding
https://wg21.link/lwg2328




Stephan T. Lavavej
-
d:lwg2329
LWG2329

C++14
regex_match()/regex_search() with match_results should forbid temporary strings
https://wg21.link/lwg2329




Stephan T. Lavavej
-
d:lwg233
LWG233

CD1
Insertion hints in associative containers
https://wg21.link/lwg233




Andrew Koenig
-
d:lwg2330
LWG2330

C++14
regex("meow", regex::icase) is technically forbidden but should be permitted
https://wg21.link/lwg2330




Stephan T. Lavavej
-
d:lwg2331
LWG2331

Open
regex_constants::collate's effects are inaccurately summarized
https://wg21.link/lwg2331




Stephan T. Lavavej
-
d:lwg2332
LWG2332

C++14
regex_iterator/regex_token_iterator should forbid temporary regexes
https://wg21.link/lwg2332




Stephan T. Lavavej
-
d:lwg2333
LWG2333

Resolved
[fund.ts] Hashing disengaged optional<T> objects
https://wg21.link/lwg2333




Jonathan Wakely
-
d:lwg2334
LWG2334

Resolved
atomic's default constructor requires "uninitialized" state even for types with non-trivial default-constructor
https://wg21.link/lwg2334




Daniel Krügler
-
d:lwg2335
LWG2335

Tentatively NAD
array<array<int, 3>, 4> should be layout-compatible with int[4][3]
https://wg21.link/lwg2335




Jeffrey Yasskin
-
d:lwg2336
LWG2336

C++17
is_trivially_constructible/is_trivially_assignable traits are always false
https://wg21.link/lwg2336




Daniel Krügler
-
d:lwg2337
LWG2337

NAD
shared_ptr operator*() should not be noexcept
https://wg21.link/lwg2337




Stephan T. Lavavej
-
d:lwg2338
LWG2338

Open
§[re.traits]/7 expects of locale facets something not guaranteed by [locale.facet]/4
https://wg21.link/lwg2338




Sergey Zubkov
-
d:lwg2339
LWG2339

C++14
Wording issue in nth_element
https://wg21.link/lwg2339




Christopher Jefferson
-
d:lwg234
LWG234

CD1
Typos in allocator definition
https://wg21.link/lwg234




Dietmar Kühl
-
d:lwg2340
LWG2340

C++17
Replacement allocation functions declared as inline
https://wg21.link/lwg2340




David Majnemer
-
d:lwg2341
LWG2341

C++14
Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)
https://wg21.link/lwg2341




Marshall Clow
-
d:lwg2342
LWG2342

New
User conversion to wchar_t const* or to wchar_t not invoked for operator<<
https://wg21.link/lwg2342




Alf P. Steinbach
-
d:lwg2343
LWG2343

Resolved
Is the value of the ECMA-262 RegExp object's multiline property really false?
https://wg21.link/lwg2343




Nayuta Taga
-
d:lwg2344
LWG2344

C++14
quoted()'s interaction with padding is unclear
https://wg21.link/lwg2344




Stephan T. Lavavej
-
d:lwg2345
LWG2345

NAD
integer_sequence should have a self-typedef ::type
https://wg21.link/lwg2345




Stephan T. Lavavej
-
d:lwg2346
LWG2346

C++14
integral_constant's member functions should be marked noexcept
https://wg21.link/lwg2346




Stephan T. Lavavej
-
d:lwg2347
LWG2347

NAD
reverse_iterator::operator[] calls const version of current[]
https://wg21.link/lwg2347




Timo Bingmann
-
d:lwg2348
LWG2348

Open
charT('1') is not the wide equivalent of '1'
https://wg21.link/lwg2348




Zhihao Yuan
-
d:lwg2349
LWG2349

Open
Clarify input/output function rethrow behavior
https://wg21.link/lwg2349




Zhihao Yuan
-
d:lwg235
LWG235

CD1
No specification of default ctor for reverse_iterator
https://wg21.link/lwg235




Dietmar Kühl
-
d:lwg2350
LWG2350

C++14
min, max, and minmax should be constexpr
https://wg21.link/lwg2350




Ville Voutilainen
-
d:lwg2351
LWG2351

NAD
Does .seed() completely reset state of engine?
https://wg21.link/lwg2351




Thomas Plum
-
d:lwg2352
LWG2352

New
Is a default-constructed std::seed_seq intended to produce a predictable .generate()?
https://wg21.link/lwg2352




Thomas Plum
-
d:lwg2353
LWG2353

C++17
std::next is over-constrained
https://wg21.link/lwg2353




Eric Niebler
-
d:lwg2354
LWG2354

C++17
Unnecessary copying when inserting into maps with braced-init syntax
https://wg21.link/lwg2354




Geoffrey Romer
-
d:lwg2355
LWG2355

NAD
"s" UDL suffix should be reserved for a compile-time string library type
https://wg21.link/lwg2355




Michael Price
-
d:lwg2356
LWG2356

C++14
Stability of erasure in unordered associative containers
https://wg21.link/lwg2356




Joaquín M López Muñoz
-
d:lwg2357
LWG2357

C++14
Remaining "Assignable" requirement
https://wg21.link/lwg2357




Daniel Krügler
-
d:lwg2358
LWG2358

Open
Apparently-bogus definition of is_empty type trait
https://wg21.link/lwg2358




Richard Smith
-
d:lwg2359
LWG2359

C++14
How does regex_constants::nosubs affect basic_regex::mark_count()?
https://wg21.link/lwg2359




Jonathan Wakely
-
d:lwg236
LWG236

Dup
ctype<char>::is() member modifies facet
https://wg21.link/lwg236




Dietmar Kühl
-
d:lwg2360
LWG2360

C++14
reverse_iterator::operator*() is unimplementable
https://wg21.link/lwg2360




Stephan T. Lavavej
-
d:lwg2361
LWG2361

C++17
Apply 2299 resolution throughout library
https://wg21.link/lwg2361




Jonathan Wakely
-
d:lwg2362
LWG2362

New
unique, associative emplace() should not move/copy the mapped_type constructor arguments when no insertion happens
https://wg21.link/lwg2362




Jeffrey Yasskin
-
d:lwg2363
LWG2363

Open
Defect in 30.4.1.4.1 [thread.sharedtimedmutex.class]
https://wg21.link/lwg2363




Richard Smith
-
d:lwg2364
LWG2364

C++17
deque and vector pop_back don't specify iterator invalidation requirements
https://wg21.link/lwg2364




Deskin Miller
-
d:lwg2365
LWG2365

C++17
Missing noexcept in shared_ptr::shared_ptr(nullptr_t)
https://wg21.link/lwg2365




Cassio Neri
-
d:lwg2366
LWG2366

New
istreambuf_iterator end-of-stream equality
https://wg21.link/lwg2366




Hyman Rosen
-
d:lwg2367
LWG2367

C++17
pair and tuple are not correctly implemented for is_constructible with no args
https://wg21.link/lwg2367




Howard Hinnant
-
d:lwg2368
LWG2368

Resolved
Replacing global operator new
https://wg21.link/lwg2368




Stephen Clamage
-
d:lwg2369
LWG2369

C++17
constexpr max(initializer_list) vs max_element
https://wg21.link/lwg2369




Marc Glisse
-
d:lwg237
LWG237

CD1
Undefined expression in complexity specification
https://wg21.link/lwg237




Dietmar Kühl
-
d:lwg2370
LWG2370

Resolved
Operations involving type-erased allocators should not be noexcept in std::function
https://wg21.link/lwg2370




Pablo Halpern
-
d:lwg2371
LWG2371

TS
[fund.ts] No template aliases defined for new type traits
https://wg21.link/lwg2371




Joe Gottman
-
d:lwg2372
LWG2372

NAD
Assignment from int to std::string
https://wg21.link/lwg2372




Andrzej Krzemieński
-
d:lwg2373
LWG2373

NAD
Make new entities and names in namespace std conforming extensions
https://wg21.link/lwg2373




Chandler Carruth
-
d:lwg2374
LWG2374

TS
[fund.ts] Remarks for optional::to_value are too restrictive
https://wg21.link/lwg2374




Jonathan Wakely
-
d:lwg2375
LWG2375

New
Is [iterator.requirements.general]/9 too broadly applied?
https://wg21.link/lwg2375




Marshall Clow
-
d:lwg2376
LWG2376

C++17
bad_weak_ptr::what() overspecified
https://wg21.link/lwg2376




Jonathan Wakely
-
d:lwg2377
LWG2377

C++17
std::align requirements overly strict
https://wg21.link/lwg2377




Peter Dimov
-
d:lwg2378
LWG2378

C++17
Behaviour of standard exception types
https://wg21.link/lwg2378




Andy Sawyer
-
d:lwg2379
LWG2379

NAD
Obtaining native handle of the current thread
https://wg21.link/lwg2379




Matt Austern
-
d:lwg238
LWG238

CD1
Contradictory results of stringbuf initialization.
https://wg21.link/lwg238




Dietmar Kühl
-
d:lwg2380
LWG2380

C++17
May <cstdlib> provide long ::abs(long) and long long ::abs(long long)?
https://wg21.link/lwg2380




Richard Smith
-
d:lwg2381
LWG2381

Open
Inconsistency in parsing floating point numbers
https://wg21.link/lwg2381




Marshall Clow
-
d:lwg2382
LWG2382

Pending NAD
Unclear order of container update versus object destruction on removing an object
https://wg21.link/lwg2382




Peter Kasting
-
d:lwg2383
LWG2383

Open
Overflow cannot be ill-formed for chrono::duration integer literals
https://wg21.link/lwg2383




Jonathan Wakely
-
d:lwg2384
LWG2384

C++17
Allocator's deallocate function needs better specification
https://wg21.link/lwg2384




Daniel Krügler
-
d:lwg2385
LWG2385

C++17
function::assign allocator argument doesn't make sense
https://wg21.link/lwg2385




Pablo Halpern
-
d:lwg2386
LWG2386

NAD
function::operator= handles allocators incorrectly
https://wg21.link/lwg2386




Pablo Halpern
-
d:lwg2387
LWG2387

C++17
More nested types that must be accessible and unambiguous
https://wg21.link/lwg2387




Jonathan Wakely
-
d:lwg2388
LWG2388

NAD
Handling self-assignment in the proposed library function std::exchange
https://wg21.link/lwg2388




Nick Calus
-
d:lwg2389
LWG2389

TS
[fund.ts] function::operator= is over-specified and handles allocators incorrectly
https://wg21.link/lwg2389




Pablo Halpern
-
d:lwg239
LWG239

CD1
Complexity of unique() and/or unique_copy incorrect
https://wg21.link/lwg239




Angelika Langer
-
d:lwg2390
LWG2390

TS
[fund.ts] Invocation types and rvalues
https://wg21.link/lwg2390




Michael Spertus
-
d:lwg2391
LWG2391

Resolved
basic_string is missing non-const data()
https://wg21.link/lwg2391




Michael Bradshaw
-
d:lwg2392
LWG2392

New
"character type" is used but not defined
https://wg21.link/lwg2392




Jeffrey Yasskin
-
d:lwg2393
LWG2393

C++17
std::function's Callable definition is broken
https://wg21.link/lwg2393




Daniel Krügler
-
d:lwg2394
LWG2394

C++17
locale::name specification unclear — what is implementation-defined?
https://wg21.link/lwg2394




Richard Smith
-
d:lwg2395
LWG2395

TS
[fund.ts] Preconditions: is defined nowhere
https://wg21.link/lwg2395




Zhihao Yuan
-
d:lwg2396
LWG2396

C++17
underlying_type doesn't say what to do for an incomplete enumeration type
https://wg21.link/lwg2396




Richard Smith
-
d:lwg2397
LWG2397

Resolved
map<K, V>::emplace and explicit V constructors
https://wg21.link/lwg2397




Peter Dimov
-
d:lwg2398
LWG2398

Open
type_info's destructor shouldn't be required to be virtual
https://wg21.link/lwg2398




Stephan T. Lavavej
-
d:lwg2399
LWG2399

C++17
shared_ptr's constructor from unique_ptr should be constrained
https://wg21.link/lwg2399




Stephan T. Lavavej
-
d:lwg24
LWG24

TC1
"do_convert" doesn't exist
https://wg21.link/lwg24




Nathan Myers
-
d:lwg240
LWG240

CD1
Complexity of adjacent_find() is meaningless
https://wg21.link/lwg240




Angelika Langer
-
d:lwg2400
LWG2400

C++17
shared_ptr's get_deleter() should use addressof()
https://wg21.link/lwg2400




Stephan T. Lavavej
-
d:lwg2401
LWG2401

C++17
std::function needs more noexcept
https://wg21.link/lwg2401




Stephan T. Lavavej
-
d:lwg2402
LWG2402

NAD
basic_string(const basic_string& str, size_type pos, size_type n = npos) shouldn't use Allocator()
https://wg21.link/lwg2402




Stephan T. Lavavej
-
d:lwg2403
LWG2403

C++17
stof() should call strtof() and wcstof()
https://wg21.link/lwg2403




Stephan T. Lavavej
-
d:lwg2404
LWG2404

C++17
mismatch()'s complexity needs to be updated
https://wg21.link/lwg2404




Stephan T. Lavavej
-
d:lwg2405
LWG2405

NAD
rotate()'s return value is incorrect when middle == first
https://wg21.link/lwg2405




Stephan T. Lavavej
-
d:lwg2406
LWG2406

C++17
negative_binomial_distribution should reject p == 1
https://wg21.link/lwg2406




Stephan T. Lavavej
-
d:lwg2407
LWG2407

C++17
packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit
https://wg21.link/lwg2407




Stephan T. Lavavej
-
d:lwg2408
LWG2408

C++17
SFINAE-friendly common_type/iterator_traits is missing in C++14
https://wg21.link/lwg2408




Daniel Krügler
-
d:lwg2409
LWG2409

TS
[fund.ts] SFINAE-friendly common_type/iterator_traits should be removed from the fundamental-ts
https://wg21.link/lwg2409




Daniel Krügler
-
d:lwg241
LWG241

CD1
Does unique_copy() require CopyConstructible and Assignable?
https://wg21.link/lwg241




Angelika Langer
-
d:lwg2410
LWG2410

TS
[fund.ts] shared_ptr<array>'s constructor from unique_ptr should be constrained
https://wg21.link/lwg2410




Jeffrey Yasskin
-
d:lwg2411
LWG2411

C++17
shared_ptr is only contextually convertible to bool
https://wg21.link/lwg2411




Jonathan Wakely
-
d:lwg2412
LWG2412

WP
promise::set_value() and promise::get_future() should not race
https://wg21.link/lwg2412




Jonathan Wakely
-
d:lwg2413
LWG2413

New
assert macro is overconstrained
https://wg21.link/lwg2413




David Krauss
-
d:lwg2414
LWG2414

Open
Member function reentrancy should be implementation-defined
https://wg21.link/lwg2414




Stephan T. Lavavej
-
d:lwg2415
LWG2415

C++17
Inconsistency between unique_ptr and shared_ptr
https://wg21.link/lwg2415




Jonathan Wakely
-
d:lwg2416
LWG2416

Resolved
[fund.ts] std::experimental::any allocator support is unimplementable
https://wg21.link/lwg2416




Jonathan Wakely
-
d:lwg2417
LWG2417

NAD
[fund.ts.v2] std::experimental::optional::operator< and LessThanComparable requirement
https://wg21.link/lwg2417




Daniel Krügler
-
d:lwg2418
LWG2418

TS
[fund.ts] apply does not work with member pointers
https://wg21.link/lwg2418




Zhihao Yuan
-
d:lwg2419
LWG2419

Resolved
Clang's libc++ extension to std::tuple
https://wg21.link/lwg2419




Akim Demaille
-
d:lwg242
LWG242

CD1
Side effects of function objects
https://wg21.link/lwg242




Angelika Langer
-
d:lwg2420
LWG2420

C++17
function<void(ArgTypes...)> does not discard the return value of the target object
https://wg21.link/lwg2420




Agustín Bergé
-
d:lwg2421
LWG2421

New
Non-specification of handling zero size in std::align [ptr.align]
https://wg21.link/lwg2421




Melissa Mears
-
d:lwg2422
LWG2422

C++17
std::numeric_limits<T>::is_modulo description: "most machines" errata
https://wg21.link/lwg2422




Melissa Mears
-
d:lwg2423
LWG2423

New
Missing specification slice_array, gslice_array, mask_array, indirect_array copy constructor
https://wg21.link/lwg2423




Akira Takahashi
-
d:lwg2424
LWG2424

Resolved
29.5 should state that atomic types are not trivially copyable
https://wg21.link/lwg2424




Jens Maurer
-
d:lwg2425
LWG2425

C++17
operator delete(void*, size_t) doesn't invalidate pointers sufficiently
https://wg21.link/lwg2425




Richard Smith
-
d:lwg2426
LWG2426

C++17
Issue about compare_exchange
https://wg21.link/lwg2426




Hans Boehm
-
d:lwg2427
LWG2427

C++17
Container adaptors as sequence containers, redux
https://wg21.link/lwg2427




Tim Song
-
d:lwg2428
LWG2428

C++17
"External declaration" used without being defined
https://wg21.link/lwg2428




Tim Song
-
d:lwg2429
LWG2429

NAD
std::basic_ostringstream is missing an allocator-extended constructor
https://wg21.link/lwg2429




Markus Kemp
-
d:lwg243
LWG243

CD1
get and getline when sentry reports failure
https://wg21.link/lwg243




Martin Sebor
-
d:lwg2430
LWG2430

NAD
Heterogeneous container lookup should be enabled using meta-function instead of nested type
https://wg21.link/lwg2430




Tomasz Kamiński
-
d:lwg2431
LWG2431

New
Missing regular expression traits requirements
https://wg21.link/lwg2431




Jonathan Wakely
-
d:lwg2432
LWG2432

EWG
initializer_list assignability
https://wg21.link/lwg2432




David Krauss
-
d:lwg2433
LWG2433

C++17
uninitialized_copy()/etc. should tolerate overloaded operator&
https://wg21.link/lwg2433




Stephan T. Lavavej
-
d:lwg2434
LWG2434

C++17
shared_ptr::use_count() is efficient
https://wg21.link/lwg2434




Stephan T. Lavavej
-
d:lwg2435
LWG2435

C++17
reference_wrapper::operator()'s Remark should be deleted
https://wg21.link/lwg2435




Stephan T. Lavavej
-
d:lwg2436
LWG2436

C++17
Comparators for associative containers should always be CopyConstructible
https://wg21.link/lwg2436




Stephan T. Lavavej
-
d:lwg2437
LWG2437

C++17
iterator_traits<OutIt>::reference can and can't be void
https://wg21.link/lwg2437




Stephan T. Lavavej
-
d:lwg2438
LWG2438

C++17
std::iterator inheritance shouldn't be mandated
https://wg21.link/lwg2438




Stephan T. Lavavej
-
d:lwg2439
LWG2439

C++17
unique_copy() sometimes can't fall back to reading its output
https://wg21.link/lwg2439




Stephan T. Lavavej
-
d:lwg244
LWG244

NAD
Must find's third argument be CopyConstructible?
https://wg21.link/lwg244




Andrew Koenig
-
d:lwg2440
LWG2440

C++17
seed_seq::size() should be noexcept
https://wg21.link/lwg2440




Stephan T. Lavavej
-
d:lwg2441
LWG2441

C++17
Exact-width atomic typedefs should be provided
https://wg21.link/lwg2441




Stephan T. Lavavej
-
d:lwg2442
LWG2442

C++17
call_once() shouldn't DECAY_COPY()
https://wg21.link/lwg2442




Stephan T. Lavavej
-
d:lwg2443
LWG2443

Resolved
std::array member functions should be constexpr
https://wg21.link/lwg2443




Peter Sommerlad
-
d:lwg2444
LWG2444

WP
Inconsistent complexity for std::sort_heap
https://wg21.link/lwg2444




François Dumont
-
d:lwg2445
LWG2445

Resolved
"Stronger" memory ordering
https://wg21.link/lwg2445




JF Bastien
-
d:lwg2446
LWG2446

NAD
Unspecialized std::tuple_size should be defined
https://wg21.link/lwg2446




Nevin Liber
-
d:lwg2447
LWG2447

C++17
Allocators and volatile-qualified value types
https://wg21.link/lwg2447




Daniel Krügler
-
d:lwg2448
LWG2448

C++17
Non-normative Container destructor specification
https://wg21.link/lwg2448




Daniel Krügler
-
d:lwg2449
LWG2449

NAD
vector::insert invalidates end()?
https://wg21.link/lwg2449




Marc Glisse
-
d:lwg245
LWG245

NAD
Which operations on istream_iterator trigger input operations?
https://wg21.link/lwg245




Andrew Koenig
-
d:lwg2450
LWG2450

C++17
(greater|less|greater_equal|less_equal)<void> do not yield a total order for pointers
https://wg21.link/lwg2450




Joaquín M López Muñoz
-
d:lwg2451
LWG2451

TS
[fund.ts.v2] optional<T> should 'forward' T's implicit conversions
https://wg21.link/lwg2451




Geoffrey Romer
-
d:lwg2452
LWG2452

Core
is_constructible, etc. and default arguments
https://wg21.link/lwg2452




Hubert Tong
-
d:lwg2453
LWG2453

New
§[iterator.range] and now [iterator.container] aren't available via <initializer_list>
https://wg21.link/lwg2453




Richard Smith
-
d:lwg2454
LWG2454

C++17
Add raw_storage_iterator::base() member
https://wg21.link/lwg2454




Jonathan Wakely
-
d:lwg2455
LWG2455

C++17
Allocator default construction should be allowed to throw
https://wg21.link/lwg2455




Pablo Halpern
-
d:lwg2456
LWG2456

Resolved
Incorrect exception specifications for 'swap' throughout library
https://wg21.link/lwg2456




Richard Smith
-
d:lwg2457
LWG2457

New
std::begin() and std::end() do not support multi-dimensional arrays correctly
https://wg21.link/lwg2457




Janez Žemva
-
d:lwg2458
LWG2458

C++17
N3778 and new library deallocation signatures
https://wg21.link/lwg2458




Richard Smith
-
d:lwg2459
LWG2459

C++17
std::polar should require a non-negative rho
https://wg21.link/lwg2459




Marshall Clow
-
d:lwg246
LWG246

Dup
a.insert(p,t) is incorrectly specified
https://wg21.link/lwg246




Mark Rodgers
-
d:lwg2460
LWG2460

C++17
LWG issue 2408 and value categories
https://wg21.link/lwg2460




Richard Smith
-
d:lwg2461
LWG2461

New
Interaction between allocators and container exception safety guarantees
https://wg21.link/lwg2461




dyp
-
d:lwg2462
LWG2462

C++17
std::ios_base::failure is overspecified
https://wg21.link/lwg2462




Jonathan Wakely
-
d:lwg2463
LWG2463

TS
[fund.ts] Incorrect complexity for sample() algorithm
https://wg21.link/lwg2463




Joe Gottman
-
d:lwg2464
LWG2464

C++17
try_emplace and insert_or_assign misspecified
https://wg21.link/lwg2464




Thomas Koeppe
-
d:lwg2465
LWG2465

Resolved
SFINAE-friendly common_type is nearly impossible to specialize correctly and regresses key functionality
https://wg21.link/lwg2465




Eric Niebler
-
d:lwg2466
LWG2466

C++17
allocator_traits::max_size() default behavior is incorrect
https://wg21.link/lwg2466




Howard Hinnant
-
d:lwg2467
LWG2467

C++17
is_always_equal has slightly inconsistent default
https://wg21.link/lwg2467




Howard Hinnant
-
d:lwg2468
LWG2468

C++17
Self-move-assignment of library types
https://wg21.link/lwg2468




Matt Austern
-
d:lwg2469
LWG2469

C++17
Wrong specification of Requires clause of operator[] for map and unordered_map
https://wg21.link/lwg2469




Tomasz Kamiński
-
d:lwg247
LWG247

CD1
vector, deque::insert complexity
https://wg21.link/lwg247




Lisa Lippincott
-
d:lwg2470
LWG2470

C++17
Allocator's destroy function should be allowed to fail to instantiate
https://wg21.link/lwg2470




Daniel Krügler
-
d:lwg2471
LWG2471

Open
copy_n's number of InputIterator increments unspecified
https://wg21.link/lwg2471




Jonathan Wakely
-
d:lwg2472
LWG2472

New
Heterogeneous comparisons in the standard library can result in ambiguities
https://wg21.link/lwg2472




Richard Smith
-
d:lwg2473
LWG2473

C++17
basic_filebuf's relation to C FILE semantics
https://wg21.link/lwg2473




Aaron Ballman
-
d:lwg2474
LWG2474

NAD
<cmath> functions unfriendly to integral_constant arguments
https://wg21.link/lwg2474




Matheus Izvekov
-
d:lwg2475
LWG2475

C++17
Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs
https://wg21.link/lwg2475




Matt Weber
-
d:lwg2476
LWG2476

C++17
scoped_allocator_adaptor is not assignable
https://wg21.link/lwg2476




Jonathan Wakely
-
d:lwg2477
LWG2477

C++17
Inconsistency of wordings in std::vector::erase() and std::deque::erase()
https://wg21.link/lwg2477




Anton Savin
-
d:lwg2478
LWG2478

New
Unclear how wstring_convert uses cvtstate
https://wg21.link/lwg2478




Jonathan Wakely
-
d:lwg2479
LWG2479

New
Unclear how wbuffer_convert uses cvtstate
https://wg21.link/lwg2479




Jonathan Wakely
-
d:lwg248
LWG248

CD1
time_get fails to set eofbit
https://wg21.link/lwg248




Martin Sebor
-
d:lwg2480
LWG2480

New
Error handling of wbuffer_convert unclear
https://wg21.link/lwg2480




Jonathan Wakely
-
d:lwg2481
LWG2481

New
wstring_convert should be more precise regarding "byte-error string" etc.
https://wg21.link/lwg2481




Jonathan Wakely
-
d:lwg2482
LWG2482

C++17
§[c.strings] Table 73 mentions nonexistent functions
https://wg21.link/lwg2482




S. B.Tam
-
d:lwg2483
LWG2483

C++17
throw_with_nested() should use is_final
https://wg21.link/lwg2483




Stephan T. Lavavej
-
d:lwg2484
LWG2484

C++17
rethrow_if_nested() is doubly unimplementable
https://wg21.link/lwg2484




Stephan T. Lavavej
-
d:lwg2485
LWG2485

C++17
get() should be overloaded for const tuple&&
https://wg21.link/lwg2485




Stephan T. Lavavej
-
d:lwg2486
LWG2486

C++17
mem_fn() should be required to use perfect forwarding
https://wg21.link/lwg2486




Stephan T. Lavavej
-
d:lwg2487
LWG2487

C++17
bind() should be const-overloaded, not cv-overloaded
https://wg21.link/lwg2487




Stephan T. Lavavej
-
d:lwg2488
LWG2488

C++17
Placeholders should be allowed and encouraged to be constexpr
https://wg21.link/lwg2488




Stephan T. Lavavej
-
d:lwg2489
LWG2489

C++17
mem_fn() should be noexcept
https://wg21.link/lwg2489




Stephan T. Lavavej
-
d:lwg249
LWG249

NAD
Return Type of auto_ptr::operator=
https://wg21.link/lwg249




Joseph Gottman
-
d:lwg2490
LWG2490

New
<regex> needs lots of noexcept
https://wg21.link/lwg2490




Stephan T. Lavavej
-
d:lwg2491
LWG2491

New
std::less<T*> in constant expression
https://wg21.link/lwg2491




Agustín K-ballo Bergé
-
d:lwg2492
LWG2492

C++17
Clarify requirements for comp
https://wg21.link/lwg2492




Anton Savin
-
d:lwg2493
LWG2493

New
initializer_list supports incomplete classes
https://wg21.link/lwg2493




David Krauss
-
d:lwg2494
LWG2494

TS
[fund.ts.v2] ostream_joiner needs noexcept
https://wg21.link/lwg2494




Nate Wilson
-
d:lwg2495
LWG2495

C++17
There is no such thing as an Exception Safety element
https://wg21.link/lwg2495




Jonathan Wakely
-
d:lwg2496
LWG2496

New
Certain hard-to-avoid errors not in the immediate context are not allowed to be triggered by the evaluation of type traits
https://wg21.link/lwg2496




Hubert Tong
-
d:lwg2497
LWG2497

New
Use of uncaught_exception()
https://wg21.link/lwg2497




Roger Orr
-
d:lwg2498
LWG2498

Tentatively Resolved
operator>>(basic_istream&&, T&&) returns basic_istream&, but should probably return basic_istream&&
https://wg21.link/lwg2498




Richard Smith
-
d:lwg2499
LWG2499

Resolved
operator>>(basic_istream&, CharT*) makes it hard to avoid buffer overflows
https://wg21.link/lwg2499




Richard Smith
-
d:lwg25
LWG25

TC1
String operator<< uses width() value wrong
https://wg21.link/lwg25




Nathan Myers
-
d:lwg250
LWG250

CD1
splicing invalidates iterators
https://wg21.link/lwg250




Brian Parker
-
d:lwg2500
LWG2500

TS
[fund.ts.v2] fundts.memory.smartptr.shared.obs/6 should apply to cv-unqualified void
https://wg21.link/lwg2500




Jeffrey Yasskin
-
d:lwg2501
LWG2501

Resolved
std::function requires POCMA/POCCA
https://wg21.link/lwg2501




David Krauss
-
d:lwg2502
LWG2502

Resolved
std::function does not use allocator::construct
https://wg21.link/lwg2502




David Krauss
-
d:lwg2503
LWG2503

C++17
multiline option should be added to syntax_option_type
https://wg21.link/lwg2503




Nozomu Katō
-
d:lwg2504
LWG2504

New
basic_streambuf is not an abstract class
https://wg21.link/lwg2504




Jonathan Wakely
-
d:lwg2505
LWG2505

Resolved
auto_ptr_ref creation requirements underspecified
https://wg21.link/lwg2505




Hubert Tong
-
d:lwg2506
LWG2506

SG1
Underspecification of atomics
https://wg21.link/lwg2506




Geoffrey Romer
-
d:lwg2507
LWG2507

New
codecvt_mode should be a bitmask type
https://wg21.link/lwg2507




Jonathan Wakely
-
d:lwg2508
LWG2508

New
§[new.delete.dataraces] wording needs to be updated
https://wg21.link/lwg2508




Hans Boehm
-
d:lwg2509
LWG2509

TS
[fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target
https://wg21.link/lwg2509




Ville Voutilainen
-
d:lwg251
LWG251

CD1
basic_stringbuf missing allocator_type
https://wg21.link/lwg251




Martin Sebor
-
d:lwg2510
LWG2510

C++17
Tag types should not be DefaultConstructible
https://wg21.link/lwg2510




Ville Voutilainen
-
d:lwg2511
LWG2511

Resolved
scoped_allocator_adaptor piecewise construction does not require CopyConstructible
https://wg21.link/lwg2511




David Krauss
-
d:lwg2512
LWG2512

Open
Y2K bites; what is an "unambiguous year identifier"?
https://wg21.link/lwg2512




Hubert Tong
-
d:lwg2513
LWG2513

New
Missing requirements for basic_string::value_type
https://wg21.link/lwg2513




Jonathan Wakely
-
d:lwg2514
LWG2514

C++17
Type traits must not be final
https://wg21.link/lwg2514




Jonathan Wakely
-
d:lwg2515
LWG2515

TS
[fund.ts.v2] Certain comparison operators of observer_ptr do not match synopsis
https://wg21.link/lwg2515




Tim Song
-
d:lwg2516
LWG2516

TS
[fund.ts.v2] Public "exposition only" members in observer_ptr
https://wg21.link/lwg2516




Tim Song
-
d:lwg2517
LWG2517

TS
[fund.ts.v2] Two propagate_const assignment operators have incorrect return type
https://wg21.link/lwg2517




Tim Song
-
d:lwg2518
LWG2518

TS
[fund.ts.v2] Non-member swap for propagate_const should call member swap
https://wg21.link/lwg2518




Tim Song
-
d:lwg2519
LWG2519

C++17
Iterator operator-= has gratuitous undefined behaviour
https://wg21.link/lwg2519




Hubert Tong
-
d:lwg252
LWG252

CD1
missing casts/C-style casts used in iostreams
https://wg21.link/lwg252




Martin Sebor
-
d:lwg2520
LWG2520

C++17
N4089 broke initializing unique_ptr<T[]> from a nullptr
https://wg21.link/lwg2520




Ville Voutilainen
-
d:lwg2521
LWG2521

TS
[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support
https://wg21.link/lwg2521




Tim Song
-
d:lwg2522
LWG2522

TS
[fund.ts.v2] Contradiction in set_default_resource specification
https://wg21.link/lwg2522




Tim Song
-
d:lwg2523
LWG2523

C++17
std::promise synopsis shows two set_value_at_thread_exit()'s for no apparent reason
https://wg21.link/lwg2523




Tim Song
-
d:lwg2524
LWG2524

Open
generate_canonical can occasionally return 1.0
https://wg21.link/lwg2524




Michael Prähofer
-
d:lwg2525
LWG2525

TS
[fund.ts.v2] get_memory_resource should be const and noexcept
https://wg21.link/lwg2525




Tim Song
-
d:lwg2526
LWG2526

TS
[fund.ts.v2] Incorrect precondition for experimental::function::swap
https://wg21.link/lwg2526




Tim Song
-
d:lwg2527
LWG2527

TS
[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default
https://wg21.link/lwg2527




Tim Song
-
d:lwg2528
LWG2528

New
Order of std::tuple construction unspecified
https://wg21.link/lwg2528




Brian Rodriguez
-
d:lwg2529
LWG2529

Resolved
Assigning to enable_shared_from_this::__weak_this twice
https://wg21.link/lwg2529




Jonathan Wakely
-
d:lwg253
LWG253

CD1
valarray helper functions are almost entirely useless
https://wg21.link/lwg253




Robert Klarer
-
d:lwg2530
LWG2530

Open
Clarify observable side effects of releasing a shared state
https://wg21.link/lwg2530




Agustín K-ballo Bergé
-
d:lwg2531
LWG2531

C++17
future::get should explicitly state that the shared state is released
https://wg21.link/lwg2531




Agustín K-ballo Bergé
-
d:lwg2532
LWG2532

Open
Satisfying a promise at thread exit
https://wg21.link/lwg2532




Agustín K-ballo Bergé
-
d:lwg2533
LWG2533

SG1
[concurr.ts] Constrain threads where future::then can run a continuation
https://wg21.link/lwg2533




Agustín K-ballo Bergé
-
d:lwg2534
LWG2534

C++17
Constrain rvalue stream operators
https://wg21.link/lwg2534




Robert Haberlach
-
d:lwg2535
LWG2535

NAD
Inconsistency between ostream::write and ostream::operator<<
https://wg21.link/lwg2535




Marshall Clow
-
d:lwg2536
LWG2536

C++17
What should <complex.h> do?
https://wg21.link/lwg2536




Richard Smith
-
d:lwg2537
LWG2537

C++17
Constructors for priority_queue taking allocators should call make_heap
https://wg21.link/lwg2537




Eric Schmidt
-
d:lwg2538
LWG2538

NAD
[parallel.ts] Requirements on data race behavior of iterators and swap should be clarified
https://wg21.link/lwg2538




Robert Geva
-
d:lwg2539
LWG2539

TS
[fund.ts.v2] invocation_trait definition definition doesn't work for surrogate call functions
https://wg21.link/lwg2539




Mike Spertus
-
d:lwg254
LWG254

CD1
Exception types in clause 19 are constructed from std::string
https://wg21.link/lwg254




Dave Abrahams
-
d:lwg2540
LWG2540

C++17
unordered_multimap::insert hint iterator
https://wg21.link/lwg2540




Isaac Hier
-
d:lwg2541
LWG2541

Resolved
[parallel.ts] Headers for ExecutionPolicy algorithm overloads
https://wg21.link/lwg2541




Tim Song
-
d:lwg2542
LWG2542

C++17
Missing const requirements for associative containers
https://wg21.link/lwg2542




Daniel Krügler
-
d:lwg2543
LWG2543

Resolved
LWG 2148 (hash support for enum types) seems under-specified
https://wg21.link/lwg2543




Ville Voutilainen
-
d:lwg2544
LWG2544

C++17
istreambuf_iterator(basic_streambuf<charT, traits>* s) effects unclear when s is 0
https://wg21.link/lwg2544




S. B. Tam
-
d:lwg2545
LWG2545

C++17
Simplify wording for bind without explicitly specified return type
https://wg21.link/lwg2545




Tomasz Kamiński
-
d:lwg2546
LWG2546

New
Implementability of locale-sensitive UnicodeEscapeSequence matching
https://wg21.link/lwg2546




Hubert Tong
-
d:lwg2547
LWG2547

New
Container requirements (and other library text) should say "strict total order", not just "total order"
https://wg21.link/lwg2547




Matt Austern
-
d:lwg2548
LWG2548

Resolved
Missing vfscanf from <cstdio>
https://wg21.link/lwg2548




Richard Smith
-
d:lwg2549
LWG2549

C++17
Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references
https://wg21.link/lwg2549




Ville Voutilainen
-
d:lwg255
LWG255

NAD
Why do basic_streambuf<>::pbump() and gbump() take an int?
https://wg21.link/lwg255




Martin Sebor
-
d:lwg2550
LWG2550

C++17
Wording of unordered container's clear() method complexity
https://wg21.link/lwg2550




Yegor Derevenets
-
d:lwg2551
LWG2551

TS
[fund.ts.v2] "Exception safety" cleanup in library fundamentals required
https://wg21.link/lwg2551




Daniel Krügler
-
d:lwg2552
LWG2552

NAD
priority_queue doesn't work with move-only types
https://wg21.link/lwg2552




Matt Austern
-
d:lwg2553
LWG2553

NAD
[fund.ts.v2] basic_string_view substring constructor
https://wg21.link/lwg2553




Evan Teran
-
d:lwg2554
LWG2554

Resolved
Swapping multidimensional arrays is never noexcept
https://wg21.link/lwg2554




Orson Peters
-
d:lwg2555
LWG2555

TS
[fund.ts.v2] No handling for over-aligned types in optional
https://wg21.link/lwg2555




Marshall Clow
-
d:lwg2556
LWG2556

C++17
Wide contract for future::share()
https://wg21.link/lwg2556




Agustín K-ballo Bergé
-
d:lwg2557
LWG2557

C++17
Logical operator traits are broken in the zero-argument case
https://wg21.link/lwg2557




Geoffrey Romer
-
d:lwg2558
LWG2558

TS
[fund.ts.v2] Logical operator traits are broken in the zero-argument case
https://wg21.link/lwg2558




Geoffrey Romer
-
d:lwg2559
LWG2559

C++17
Error in LWG 2234's resolution
https://wg21.link/lwg2559




Tim Song
-
d:lwg256
LWG256

CD1
typo in 27.4.4.2, p17: copy_event does not exist
https://wg21.link/lwg256




Martin Sebor
-
d:lwg2560
LWG2560

C++17
is_constructible underspecified when applied to a function type
https://wg21.link/lwg2560




Richard Smith
-
d:lwg2561
LWG2561

New
[fund.ts.v2] Incorrect exception specifications for 'swap' in C++ Extensions for Library Fundamentals
https://wg21.link/lwg2561




Daniel Krügler
-
d:lwg2562
LWG2562

C++17
Consistent total ordering of pointers by comparison functors
https://wg21.link/lwg2562




Casey Carter
-
d:lwg2563
LWG2563

NAD
LWG 2259 relaxes requirements, perhaps unintentionally
https://wg21.link/lwg2563




Ville Voutilainen
-
d:lwg2564
LWG2564

New
[fund.ts.v2] std::experimental::function constructors taking allocator arguments may throw exceptions
https://wg21.link/lwg2564




Tim Song
-
d:lwg2565
LWG2565

C++17
std::function's move constructor should guarantee nothrow for reference_wrappers and function pointers
https://wg21.link/lwg2565




Tim Song
-
d:lwg2566
LWG2566

C++17
Requirements on the first template parameter of container adaptors
https://wg21.link/lwg2566




Tim Song
-
d:lwg2567
LWG2567

C++17
Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits
https://wg21.link/lwg2567




Tim Song
-
d:lwg2568
LWG2568

TS
[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits
https://wg21.link/lwg2568




Tim Song
-
d:lwg2569
LWG2569

C++17
conjunction and disjunction requirements are too strict
https://wg21.link/lwg2569




Tim Song
-
d:lwg257
LWG257

NAD
STL functional object and iterator inheritance.
https://wg21.link/lwg257




Robert Dick
-
d:lwg2570
LWG2570

TS
[fund.ts.v2] conjunction and disjunction requirements are too strict
https://wg21.link/lwg2570




Tim Song
-
d:lwg2571
LWG2571

C++17
§[map.modifiers]/2 imposes nonsensical requirement on insert(InputIterator, InputIterator)
https://wg21.link/lwg2571




Tim Song
-
d:lwg2572
LWG2572

C++17
The remarks for shared_ptr::operator* should apply to cv-qualified void as well
https://wg21.link/lwg2572




Tim Song
-
d:lwg2573
LWG2573

TS
[fund.ts.v2] std::hash<std::experimental::shared_ptr<T>> does not work for arrays
https://wg21.link/lwg2573




Tim Song
-
d:lwg2574
LWG2574

TS
[fund.ts.v2] std::experimental::function::operator=(F&&) should be constrained
https://wg21.link/lwg2574




Tim Song
-
d:lwg2575
LWG2575

TS
[fund.ts.v2] experimental::function::assign should be removed
https://wg21.link/lwg2575




Tim Song
-
d:lwg2576
LWG2576

C++17
istream_iterator and ostream_iterator should use std::addressof
https://wg21.link/lwg2576




Tim Song
-
d:lwg2577
LWG2577

C++17
{shared,unique}_lock should use std::addressof
https://wg21.link/lwg2577




Tim Song
-
d:lwg2578
LWG2578

C++17
Iterator requirements should reference iterator traits
https://wg21.link/lwg2578




Ville Voutilainen
-
d:lwg2579
LWG2579

C++17
Inconsistency wrt Allocators in basic_string assignment vs. basic_string::assign
https://wg21.link/lwg2579




Marshall Clow
-
d:lwg258
LWG258

CD1
Missing allocator requirement
https://wg21.link/lwg258




Matt Austern
-
d:lwg2580
LWG2580

NAD
Who is definitive: operator= or assign?
https://wg21.link/lwg2580




Marshall Clow
-
d:lwg2581
LWG2581

C++17
Specialization of <type_traits> variable templates should be prohibited
https://wg21.link/lwg2581




Tim Song
-
d:lwg2582
LWG2582

C++17
§[res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits
https://wg21.link/lwg2582




Tim Song
-
d:lwg2583
LWG2583

C++17
There is no way to supply an allocator for basic_string(str, pos)
https://wg21.link/lwg2583




Pablo Halpern
-
d:lwg2584
LWG2584

C++17
<regex> ECMAScript IdentityEscape is ambiguous
https://wg21.link/lwg2584




Billy O'Neal III
-
d:lwg2585
LWG2585

C++17
forward_list::resize(size_type, const value_type&) effects incorrect
https://wg21.link/lwg2585




Tim Song
-
d:lwg2586
LWG2586

C++17
Wrong value category used in scoped_allocator_adaptor::construct()
https://wg21.link/lwg2586




Jonathan Wakely
-
d:lwg2587
LWG2587

C++17
"Convertible to bool" requirement in conjunction and disjunction
https://wg21.link/lwg2587




Tim Song
-
d:lwg2588
LWG2588

TS
[fund.ts.v2] "Convertible to bool" requirement in conjunction and disjunction
https://wg21.link/lwg2588




Tim Song
-
d:lwg2589
LWG2589

C++17
match_results can't satisfy the requirements of a container
https://wg21.link/lwg2589




S. B. Tam
-
d:lwg259
LWG259

CD1
basic_string::operator[] and const correctness
https://wg21.link/lwg259




Chris Newton
-
d:lwg2590
LWG2590

C++17
Aggregate initialization for std::array
https://wg21.link/lwg2590




Robert Haberlach
-
d:lwg2591
LWG2591

C++17
std::function's member template target() should not lead to undefined behaviour
https://wg21.link/lwg2591




Daniel Krügler
-
d:lwg2592
LWG2592

New
Require that chrono::duration_casts from smaller durations to larger durations do not overflow
https://wg21.link/lwg2592




Andy Giese
-
d:lwg2593
LWG2593

WP
Moved-from state of Allocators
https://wg21.link/lwg2593




David Krauss
-
d:lwg2594
LWG2594

New
Contradicting definition of empty shared_ptr on shared_ptr(nullptr, d)
https://wg21.link/lwg2594




Kazutoshi Satoda
-
d:lwg2595
LWG2595

New
reverse_iterator::operator[]'s return type revisited
https://wg21.link/lwg2595




Robert Haberlach
-
d:lwg2596
LWG2596

C++17
vector::data() should use addressof
https://wg21.link/lwg2596




Marshall Clow
-
d:lwg2597
LWG2597

WP
std::log misspecified for complex numbers
https://wg21.link/lwg2597




Thomas Koeppe
-
d:lwg2598
LWG2598

C++17
addressof works on temporaries
https://wg21.link/lwg2598




Brent Friedman
-
d:lwg2599
LWG2599

New
Library incomplete type permission phrase is unclear
https://wg21.link/lwg2599




Zhihao Yuan
-
d:lwg26
LWG26

TC1
Bad sentry example
https://wg21.link/lwg26




Nathan Myers
-
d:lwg260
LWG260

CD1
Inconsistent return type of istream_iterator::operator++(int)
https://wg21.link/lwg260




Martin Sebor
-
d:lwg2600
LWG2600

NAD
ios_base must store inaccessible iostate flags
https://wg21.link/lwg2600




David Krauss
-
d:lwg2601
LWG2601

TS
[filesys.ts] [PDTS] Make namespaces consistent with Library TS policy
https://wg21.link/lwg2601




FI-5, US-5, GB-3, CH-6
-
d:lwg2602
LWG2602

TS
[filesys.ts] [PDTS] Tighten specification when there is no reasonable behavior
https://wg21.link/lwg2602




FI-1
-
d:lwg2603
LWG2603

TS
[filesys.ts] [PDTS] Filename length needs bullet item
https://wg21.link/lwg2603




CH-2
-
d:lwg2604
LWG2604

NAD
[filesys.ts] [PDTS] Need definition of dot and dot-dot
https://wg21.link/lwg2604




CH-3
-
d:lwg2605
LWG2605

TS
[filesys.ts] [PDTS] Parent of root directory unspecified
https://wg21.link/lwg2605




CH-4
-
d:lwg2606
LWG2606

TS
[filesys.ts] [PDTS] Path depth is underspecified
https://wg21.link/lwg2606




CH-5
-
d:lwg2607
LWG2607

TS
[filesys.ts] [PDTS] Unhelpful comment for struct space_info
https://wg21.link/lwg2607




GB-4
-
d:lwg2608
LWG2608

TS
[filesys.ts] [PDTS] file_time_type underspecified
https://wg21.link/lwg2608




CH-7
-
d:lwg2609
LWG2609

TS
[filesys.ts] [PDTS] Unclear why range-based-for functions return different types
https://wg21.link/lwg2609




FI-2
-
d:lwg261
LWG261

CD1
Missing description of istream_iterator::operator!=
https://wg21.link/lwg261




Martin Sebor
-
d:lwg2610
LWG2610

NAD
[filesys.ts] [PDTS] Apparently inconsistent return types from several functions
https://wg21.link/lwg2610




FI-4
-
d:lwg2611
LWG2611

NAD Future
[filesys.ts] [PDTS] Lack of relative() operation function
https://wg21.link/lwg2611




GB-1
-
d:lwg2612
LWG2612

NAD Future
[filesys.ts] [PDTS] uintmax_t too small for large file sizes
https://wg21.link/lwg2612




CH-8
-
d:lwg2613
LWG2613

NAD
[filesys.ts] [PDTS] Missing actual error conditions thrown
https://wg21.link/lwg2613




CH 9
-
d:lwg2614
LWG2614

TS
[filesys.ts] [PDTS] Incorrect postconditions for path copy/move constructor
https://wg21.link/lwg2614




GB-7, CH-10
-
d:lwg2615
LWG2615

TS
[filesys.ts] [PDTS] Missing behavior for characters with no representation
https://wg21.link/lwg2615




GB-8
-
d:lwg2616
LWG2616

TS
[filesys.ts] [PDTS] Append behavior underspecified if target is empty
https://wg21.link/lwg2616




CH-11
-
d:lwg2617
LWG2617

NAD
[filesys.ts] [PDTS] path member swap() unnecessary
https://wg21.link/lwg2617




CH-12
-
d:lwg2618
LWG2618

TS
[filesys.ts] [PDTS] is_absolute() return clause confusing
https://wg21.link/lwg2618




FI-7
-
d:lwg2619
LWG2619

TS
[filesys.ts] [PDTS] Consider using quoted manipulators
https://wg21.link/lwg2619




FI-8
-
d:lwg262
LWG262

CD1
Bitmask operator ~ specified incorrectly
https://wg21.link/lwg262




Beman Dawes
-
d:lwg2621
LWG2621

TS
[filesys.ts] [PDTS] directory_entry operator== needs clarification
https://wg21.link/lwg2621




GB-12
-
d:lwg2622
LWG2622

TS
[filesys.ts] [PDTS] directory_iterator underspecified
https://wg21.link/lwg2622




CH-13
-
d:lwg2623
LWG2623

NAD
[filesys.ts] [PDTS] Request for create_regular_file() and/or touch()
https://wg21.link/lwg2623




CH-14
-
d:lwg2624
LWG2624

TS
[filesys.ts] [PDTS] Incorrect effects clause for path copy
https://wg21.link/lwg2624




GB-14
-
d:lwg2625
LWG2625

TS
[filesys.ts] [PDTS] Copying equivalent paths effects not specified
https://wg21.link/lwg2625




CH-15
-
d:lwg2626
LWG2626

NAD
[filesys.ts] [PDTS] Equivalence is a volatile property
https://wg21.link/lwg2626




CH-16
-
d:lwg2627
LWG2627

TS
[filesys.ts] [PDTS] Return value of uintmax_t on error?
https://wg21.link/lwg2627




FI-9
-
d:lwg2628
LWG2628

NAD
[filesys.ts] [PDTS] Possible last_write_time() postcondition?
https://wg21.link/lwg2628




GB-15
-
d:lwg2629
LWG2629

TS
[filesys.ts] [PDTS] Unclear semantics of read_symlink on error
https://wg21.link/lwg2629




GB-16
-
d:lwg263
LWG263

CD1
Severe restriction on basic_string reference counting
https://wg21.link/lwg263




Kevlin Henney
-
d:lwg2630
LWG2630

NAD
[filesys.ts] [PDTS] remove() must avoid race
https://wg21.link/lwg2630




CH-17
-
d:lwg2631
LWG2631

NAD
[filesys.ts] [PDTS] POSIX guarantees atomicity for rename()
https://wg21.link/lwg2631




CH-18
-
d:lwg2632
LWG2632

TS
[filesys.ts] [PDTS] system_complete() example needs clarification
https://wg21.link/lwg2632




FI-10
-
d:lwg2633
LWG2633

TS
[filesys.ts] [PDTS] unique_path() is a security vulnerability
https://wg21.link/lwg2633




CH-19
-
d:lwg2634
LWG2634

TS
[filesys.ts] [PDTS] enum class directory_options has no summary
https://wg21.link/lwg2634




P.J. Plauger
-
d:lwg2635
LWG2635

TS
[filesys.ts] [PDTS] directory_options::skip_permission_denied is not used
https://wg21.link/lwg2635




P.J. Plauger
-
d:lwg2636
LWG2636

TS
[filesys.ts] [PDTS] copy_options::copy_symlinks is not used
https://wg21.link/lwg2636




P.J. Plauger
-
d:lwg2637
LWG2637

TS
[filesys.ts] [PDTS] All functions with error_code arguments should be noexcept
https://wg21.link/lwg2637




P.J. Plauger
-
d:lwg2638
LWG2638

NAD
[filesys.ts] [PDTS] Make certain functions noexcept and drop error_code version
https://wg21.link/lwg2638




P.J. Plauger
-
d:lwg2639
LWG2639

NAD Editorial
[filesys.ts] [PDTS] permissions() is missing from synopsis
https://wg21.link/lwg2639




P.J. Plauger
-
d:lwg264
LWG264

CD1
Associative container insert(i, j) complexity requirements are not feasible.
https://wg21.link/lwg264




John Potter
-
d:lwg2640
LWG2640

TS
[filesys.ts] [PDTS] class directory_entry should retain operator const path&() from V2
https://wg21.link/lwg2640




P.J. Plauger
-
d:lwg2641
LWG2641

TS
[filesys.ts] [PDTS] directory_iterator, recursive_directory_iterator, move construct/assign should be noexcept
https://wg21.link/lwg2641




P.J. Plauger
-
d:lwg2642
LWG2642

NAD
[filesys.ts] [PDTS] class path should have defaulted constructors/destructor/assignments.
https://wg21.link/lwg2642




P.J. Plauger
-
d:lwg2643
LWG2643

Dup
[filesys.ts] [PDTS] path::compare(const string&) should be path::compare(const string_type&)
https://wg21.link/lwg2643




P.J. Plauger
-
d:lwg2644
LWG2644

TS
[filesys.ts] [PDTS] enum classes copy_options and perms should be bitmask types
https://wg21.link/lwg2644




P.J. Plauger
-
d:lwg2645
LWG2645

TS
[filesys.ts] [PDTS] create_directory should refer to perms::all instead of Posix S_IRWXU|S_IRWXG|S_IRWXO
https://wg21.link/lwg2645




P.J. Plauger
-
d:lwg2646
LWG2646

NAD
[filesys.ts] [PDTS] Do we really need generic*?
https://wg21.link/lwg2646




P.J. Plauger
-
d:lwg2647
LWG2647

TS
[filesys.ts] [PDTS] last_write_time() uses ill-formed cast
https://wg21.link/lwg2647




P.J. Plauger
-
d:lwg2648
LWG2648

TS
[filesys.ts] [PDTS] path::template<class charT>string() conversion rules
https://wg21.link/lwg2648




P.J. Plauger
-
d:lwg2649
LWG2649

TS
[filesys.ts] [PDTS] path and directory_entry move ctors should not be noexcept
https://wg21.link/lwg2649




Stephan T. Lavavej
-
d:lwg265
LWG265

CD1
std::pair::pair() effects overly restrictive
https://wg21.link/lwg265




Martin Sebor
-
d:lwg2650
LWG2650

TS
[filesys.ts] [PDTS] path::compare(const string& s) wrong argument type
https://wg21.link/lwg2650




Stephan T. Lavavej
-
d:lwg2651
LWG2651

Dup
[filesys.ts] [PDTS] directory_iterator, recursive_directory_iterator, pointer/reference typedefs wrong
https://wg21.link/lwg2651




Stephan T. Lavavej
-
d:lwg2652
LWG2652

TS
[filesys.ts] [PDTS] Better to avoid deriving from std::iterator
https://wg21.link/lwg2652




Stephan T. Lavavej
-
d:lwg2653
LWG2653

TS
[filesys.ts] [PDTS] directory_entry multithreading concerns
https://wg21.link/lwg2653




Stephan T. Lavavej
-
d:lwg2654
LWG2654

NAD Future
[filesys.ts] [PDTS] Concerns with security and testability
https://wg21.link/lwg2654




Google
-
d:lwg2655
LWG2655

TS
[filesys.ts] [PDTS] Clarify Error reporting
https://wg21.link/lwg2655




Beman Dawes
-
d:lwg2656
LWG2656

TS
[filesys.ts] [PDTS] Feature test macro for TS version
https://wg21.link/lwg2656




Clark Nelson
-
d:lwg2657
LWG2657

TS
[filesys.ts] [PDTS] Inappropriate use of "No diagnostic is required"
https://wg21.link/lwg2657




LWG/SG-3
-
d:lwg2658
LWG2658

TS
[filesys.ts] [PDTS] POSIX utime() is obsolescent
https://wg21.link/lwg2658




LWG/SG-3
-
d:lwg2659
LWG2659

NAD Editorial
[filesys.ts] [PDTS] Invalid expressions for bitmask types
https://wg21.link/lwg2659




Daniel Krügler
-
d:lwg266
LWG266

CD1
bad_exception::~bad_exception() missing Effects clause
https://wg21.link/lwg266




Martin Sebor
-
d:lwg2660
LWG2660

TS
[filesys.ts] [PDTS] Incorrect Throws specification for absolute()
https://wg21.link/lwg2660




Daniel Krügler
-
d:lwg2661
LWG2661

NAD
[filesys.ts] Surprising equivalent() behavior if neither file exists
https://wg21.link/lwg2661




Beman Dawes
-
d:lwg2662
LWG2662

TS
[filesys.ts] Allocator requirements unspecified
https://wg21.link/lwg2662




Daniel Krügler
-
d:lwg2663
LWG2663

Resolved
Enable efficient retrieval of file size from directory_entry
https://wg21.link/lwg2663




Gor Nishanov
-
d:lwg2664
LWG2664

C++17
operator/ (and other append) semantics not useful if argument has root
https://wg21.link/lwg2664




Peter Dimov
-
d:lwg2665
LWG2665

Resolved
remove_filename() post condition is incorrect
https://wg21.link/lwg2665




Eric Fiselier
-
d:lwg2666
LWG2666

NAD Editorial
Bitmask operations should use bitmask terms
https://wg21.link/lwg2666




Jonathan Wakely
-
d:lwg2667
LWG2667

C++17
path::root_directory() description is confusing
https://wg21.link/lwg2667




Jonathan Wakely
-
d:lwg2668
LWG2668

NAD
path::operator+= is defined, but not operator+
https://wg21.link/lwg2668




Jonathan Wakely
-
d:lwg2669
LWG2669

C++17
recursive_directory_iterator effects refers to non-existent functions
https://wg21.link/lwg2669




Jonathan Wakely
-
d:lwg267
LWG267

NAD
interaction of strstreambuf::overflow() and seekoff()
https://wg21.link/lwg267




Martin Sebor
-
d:lwg2670
LWG2670

C++17
system_complete refers to undefined variable 'base'
https://wg21.link/lwg2670




Jonathan Wakely
-
d:lwg2671
LWG2671

C++17
Errors in Copy
https://wg21.link/lwg2671




Jonathan Wakely
-
d:lwg2672
LWG2672

C++17
Should is_empty use error_code in its specification?
https://wg21.link/lwg2672




Jonathan Wakely
-
d:lwg2673
LWG2673

C++17
status() effects cannot be implemented as specified
https://wg21.link/lwg2673




Jonathan Wakely
-
d:lwg2674
LWG2674

C++17
Bidirectional iterator requirement on path::iterator is very expensive
https://wg21.link/lwg2674




Jonathan Wakely
-
d:lwg2675
LWG2675

New
register_callback can fail
https://wg21.link/lwg2675




David Krauss
-
d:lwg2676
LWG2676

C++17
Provide filesystem::path overloads for File-based streams
https://wg21.link/lwg2676




Beman Dawes
-
d:lwg2677
LWG2677

Resolved
directory_entry::status is not allowed to be cached as a quality-of-implementation issue
https://wg21.link/lwg2677




Billy O'Neal
-
d:lwg2678
LWG2678

C++17
std::filesystem enum classes overspecified
https://wg21.link/lwg2678




Richard Smith
-
d:lwg2679
LWG2679

C++17
Inconsistent Use of Effects and Equivalent To
https://wg21.link/lwg2679




Dawn Perchik
-
d:lwg268
LWG268

CD1
Typo in locale synopsis
https://wg21.link/lwg268




Martin Sebor
-
d:lwg2680
LWG2680

C++17
Add "Equivalent to" to filesystem
https://wg21.link/lwg2680




Beman Dawes
-
d:lwg2681
LWG2681

C++17
filesystem::copy() cannot copy symlinks
https://wg21.link/lwg2681




Jonathan Wakely
-
d:lwg2682
LWG2682

WP
filesystem::copy() won't create a symlink to a directory
https://wg21.link/lwg2682




Jonathan Wakely
-
d:lwg2683
LWG2683

C++17
filesystem::copy() says "no effects"
https://wg21.link/lwg2683




Jonathan Wakely
-
d:lwg2684
LWG2684

C++17
priority_queue lacking comparator typedef
https://wg21.link/lwg2684




Robert Haberlach
-
d:lwg2685
LWG2685

C++17
shared_ptr deleters must not not throw on move construction
https://wg21.link/lwg2685




Jonathan Wakely
-
d:lwg2686
LWG2686

C++17
Why is std::hash specialized for error_code, but not error_condition?
https://wg21.link/lwg2686




Tim Song
-
d:lwg2687
LWG2687

C++17
{inclusive,exclusive}_scan misspecified
https://wg21.link/lwg2687




Tim Song
-
d:lwg2688
LWG2688

C++17
clamp misses preconditions and has extraneous condition on result
https://wg21.link/lwg2688




Martin Moene
-
d:lwg2689
LWG2689

C++17
Parallel versions of std::copy and std::move shouldn't be in order
https://wg21.link/lwg2689




Tim Song
-
d:lwg269
LWG269

NAD
cstdarg and unnamed parameters
https://wg21.link/lwg269




J. Stephen Adamczyk
-
d:lwg2690
LWG2690

LEWG
invoke<R>
https://wg21.link/lwg2690




Zhihao Yuan
-
d:lwg2691
LWG2691

New
money_base::space and do_put: U+0020 versus fill
https://wg21.link/lwg2691




Hubert Tong
-
d:lwg2692
LWG2692

NAD
Overspecification of lvalueness of bitmask elements
https://wg21.link/lwg2692




Hubert Tong
-
d:lwg2693
LWG2693

Resolved
constexpr for various std::complex arithmetic and value operators
https://wg21.link/lwg2693




Oliver Rosten
-
d:lwg2694
LWG2694

C++17
Application of LWG 436 accidentally deleted definition of "facet"
https://wg21.link/lwg2694




Tim Song
-
d:lwg2695
LWG2695

New
"As if" unclear in [member.functions]
https://wg21.link/lwg2695




Hubert Tong
-
d:lwg2696
LWG2696

C++17
Interaction between make_shared and enable_shared_from_this is underspecified
https://wg21.link/lwg2696




Joe Gottman
-
d:lwg2697
LWG2697

WP
[concurr.ts] Behavior of future/shared_future unwrapping constructor when given an invalid future
https://wg21.link/lwg2697




Tim Song
-
d:lwg2698
LWG2698

C++17
Effect of assign() on iterators/pointers/references
https://wg21.link/lwg2698




Tim Song
-
d:lwg2699
LWG2699

C++17
Missing restriction in [numeric.requirements]
https://wg21.link/lwg2699




Hubert Tong
-
d:lwg27
LWG27

TC1
String::erase(range) yields wrong iterator
https://wg21.link/lwg27




Nathan Myers
-
d:lwg270
LWG270

CD1
Binary search requirements overly strict
https://wg21.link/lwg270




Matt Austern
-
d:lwg2700
LWG2700

NAD
resource_adaptor went missing
https://wg21.link/lwg2700




Jonathan Wakely
-
d:lwg2701
LWG2701

NAD Editorial
Unclear requirement in [memory.resource.private]
https://wg21.link/lwg2701




Jonathan Wakely
-
d:lwg2702
LWG2702

New
num_put::do_put(..., bool) performs ill-formed do_put call
https://wg21.link/lwg2702




Hubert Tong
-
d:lwg2703
LWG2703

New
No provision for fill-padding when boolalpha is set
https://wg21.link/lwg2703




Hubert Tong
-
d:lwg2704
LWG2704

C++17
recursive_directory_iterator's members should require '*this is dereferenceable'
https://wg21.link/lwg2704




Eric Fiselier
-
d:lwg2705
LWG2705

New
Questionable precondition on Sequence containers a.assign(n, t)
https://wg21.link/lwg2705




Kazutoshi Satoda
-
d:lwg2706
LWG2706

C++17
Error reporting for recursive_directory_iterator::pop() is under-specified
https://wg21.link/lwg2706




Eric Fiselier
-
d:lwg2707
LWG2707

C++17
path construction and assignment should have "string_type&&" overloads
https://wg21.link/lwg2707




Eric Fiselier
-
d:lwg2708
LWG2708

Open
recursive_directory_iterator::recursion_pending() is incorrectly specified
https://wg21.link/lwg2708




Eric Fiselier
-
d:lwg2709
LWG2709

C++17
offsetof is unnecessarily imprecise
https://wg21.link/lwg2709




Richard Smith
-
d:lwg271
LWG271

CD1
basic_iostream missing typedefs
https://wg21.link/lwg271




Martin Sebor
-
d:lwg2710
LWG2710

C++17
"Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics
https://wg21.link/lwg2710




Kazutoshi Satoda
-
d:lwg2711
LWG2711

C++17
path is convertible from approximately everything under the sun
https://wg21.link/lwg2711




Tim Song
-
d:lwg2712
LWG2712

C++17
copy_file(from, to, ...) has a number of unspecified error conditions
https://wg21.link/lwg2712




Eric Fiselier
-
d:lwg2713
LWG2713

New
More missing allocator-extended constructors for unordered containers
https://wg21.link/lwg2713




Billy Robert O'Neal III
-
d:lwg2714
LWG2714

New
complex stream extraction underspecified
https://wg21.link/lwg2714




Tim Song
-
d:lwg2715
LWG2715

Resolved
What is 'aggregate initialization syntax'?
https://wg21.link/lwg2715




S. B. Tam
-
d:lwg2716
LWG2716

C++17
Specification of shuffle and sample disallows lvalue URNGs
https://wg21.link/lwg2716




Tim Song
-
d:lwg2717
LWG2717

NAD
scoped_allocator_adaptor uses forward to do move's job
https://wg21.link/lwg2717




Billy Robert O'Neal III
-
d:lwg2718
LWG2718

C++17
Parallelism bug in [algorithms.parallel.exec] p2
https://wg21.link/lwg2718




Jared Hoberock
-
d:lwg2719
LWG2719

C++17
permissions function should not be noexcept due to narrow contract
https://wg21.link/lwg2719




Eric Fiselier
-
d:lwg272
LWG272

CD1
Missing parentheses around subexpression
https://wg21.link/lwg272




Martin Sebor
-
d:lwg2720
LWG2720

C++17
permissions function incorrectly specified for symlinks
https://wg21.link/lwg2720




Eric Fiselier
-
d:lwg2721
LWG2721

C++17
remove_all has incorrect post conditions
https://wg21.link/lwg2721




Eric Fiselier
-
d:lwg2722
LWG2722

C++17
equivalent incorrectly specifies throws clause
https://wg21.link/lwg2722




Eric Fiselier
-
d:lwg2723
LWG2723

C++17
Do directory_iterator and recursive_directory_iterator become the end iterator upon error?
https://wg21.link/lwg2723




Eric Fiselier
-
d:lwg2724
LWG2724

C++17
The protected virtual member functions of memory_resource should be private
https://wg21.link/lwg2724




Ville Voutilainen
-
d:lwg2725
LWG2725

C++17
filesystem::exists(const path&, error_code&) error reporting
https://wg21.link/lwg2725




Jonathan Wakely
-
d:lwg2726
LWG2726

C++17
[recursive_]directory_iterator::increment(error_code&) is underspecified
https://wg21.link/lwg2726




Daniel Krügler
-
d:lwg2727
LWG2727

C++17
Parallel algorithms with constexpr specifier
https://wg21.link/lwg2727




Jonathan Wakely
-
d:lwg2728
LWG2728

C++17
status(p).permissions() and symlink_status(p).permissions() are not specified
https://wg21.link/lwg2728




Eric Fiselier
-
d:lwg2729
LWG2729

C++17
Missing SFINAE on std::pair::operator=
https://wg21.link/lwg2729




Richard Smith
-
d:lwg273
LWG273

CD1
Missing ios_base qualification on members of a dependent class
https://wg21.link/lwg273




Martin Sebor
-
d:lwg2730
LWG2730

Open
numeric_limits primary template definition
https://wg21.link/lwg2730




Richard Smith
-
d:lwg2731
LWG2731

Open
Existence of lock_guard<MutexTypes...>::mutex_type typedef unclear
https://wg21.link/lwg2731




Eric Fiselier
-
d:lwg2732
LWG2732

C++17
Questionable specification of path::operator/= and path::append
https://wg21.link/lwg2732




Tim Song
-
d:lwg2733
LWG2733

TS
[fund.ts.v2] gcd / lcm and bool
https://wg21.link/lwg2733




Richard Smith
-
d:lwg2734
LWG2734

Resolved
Questionable specification in [fs.path.concat]
https://wg21.link/lwg2734




Tim Song
-
d:lwg2735
LWG2735

C++17
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
https://wg21.link/lwg2735




Jörn Heusipp
-
d:lwg2736
LWG2736

C++17
nullopt_t insufficiently constrained
https://wg21.link/lwg2736




Tim Song
-
d:lwg2737
LWG2737

New
Consider relaxing object size restrictions for single-object allocation functions
https://wg21.link/lwg2737




Clark Nelson
-
d:lwg2738
LWG2738

C++17
is_constructible with void types
https://wg21.link/lwg2738




S. B. Tam
-
d:lwg2739
LWG2739

C++17
Issue with time_point non-member subtraction with an unsigned duration
https://wg21.link/lwg2739




Michael Winterberg
-
d:lwg274
LWG274

CD1
a missing/impossible allocator requirement
https://wg21.link/lwg274




Martin Sebor
-
d:lwg2740
LWG2740

C++17
constexpr optional<T>::operator->
https://wg21.link/lwg2740




Agustín K-ballo Bergé
-
d:lwg2741
LWG2741

Open
is_partitioned requirements need updating
https://wg21.link/lwg2741




Jonathan Wakely
-
d:lwg2742
LWG2742

C++17
Inconsistent string interface taking string_view
https://wg21.link/lwg2742




Richard Smith
-
d:lwg2743
LWG2743

New
p0083r3 node_handle private members missing "exposition only" comment
https://wg21.link/lwg2743




Richard Smith
-
d:lwg2744
LWG2744

C++17
any's in_place constructors
https://wg21.link/lwg2744




Ville Voutilainen
-
d:lwg2745
LWG2745

TS
[fund.ts.v2] Implementability of LWG 2451
https://wg21.link/lwg2745




Casey Carter
-
d:lwg2746
LWG2746

New
Inconsistency between requirements for emplace between optional and variant
https://wg21.link/lwg2746




Richard Smith
-
d:lwg2747
LWG2747

C++17
Possibly redundant std::move in [alg.foreach]
https://wg21.link/lwg2747




Jonathan Wakely
-
d:lwg2748
LWG2748

C++17
swappable traits for optionals
https://wg21.link/lwg2748




Agustín K-ballo Bergé
-
d:lwg2749
LWG2749

C++17
swappable traits for variants
https://wg21.link/lwg2749




Agustín K-ballo Bergé
-
d:lwg275
LWG275

CD1
Wrong type in num_get::get() overloads
https://wg21.link/lwg275




Matt Austern
-
d:lwg2750
LWG2750

TS
[fund.ts.v2] LWG 2451 conversion constructor constraint
https://wg21.link/lwg2750




Casey Carter
-
d:lwg2751
LWG2751

New
shared_ptr deleter not specified to observe expired weak_ptr instances
https://wg21.link/lwg2751




Aaron Jacobs
-
d:lwg2752
LWG2752

C++17
"Throws:" clauses of async and packaged_task are unimplementable
https://wg21.link/lwg2752




Billy Robert O'Neal III
-
d:lwg2753
LWG2753

Resolved
Optional's constructors and assignments need constraints
https://wg21.link/lwg2753




Casey Carter
-
d:lwg2754
LWG2754

Resolved
The in_place constructors and emplace functions added by P0032R3 don't require CopyConstructible
https://wg21.link/lwg2754




Ville Voutilainen
-
d:lwg2755
LWG2755

C++17
§[string.view.io] uses non-existent basic_string_view::to_string function
https://wg21.link/lwg2755




Billy Baker
-
d:lwg2756
LWG2756

C++17
C++ WP optional<T> should 'forward' T's implicit conversions
https://wg21.link/lwg2756




Casey Carter
-
d:lwg2757
LWG2757

Resolved
std::string{}.insert(3, "ABCDE", 0, 1) is ambiguous
https://wg21.link/lwg2757




Marshall Clow
-
d:lwg2758
LWG2758

C++17
std::string{}.assign("ABCDE", 0, 1) is ambiguous
https://wg21.link/lwg2758




Marshall Clow
-
d:lwg2759
LWG2759

C++17
gcd / lcm and bool for the WP
https://wg21.link/lwg2759




Walter Brown
-
d:lwg276
LWG276

CD1
Assignable requirement for container value type overly strict
https://wg21.link/lwg276




Peter Dimov
-
d:lwg2760
LWG2760

C++17
non-const basic_string::data should not invalidate iterators
https://wg21.link/lwg2760




Billy Baker
-
d:lwg2761
LWG2761

NAD
directory_entry comparisons are members
https://wg21.link/lwg2761




Ville Voutilainen
-
d:lwg2762
LWG2762

Open
unique_ptr operator*() should be noexcept
https://wg21.link/lwg2762




Ville Voutilainen
-
d:lwg2763
LWG2763

Resolved
common_type_t<void, void> is undefined
https://wg21.link/lwg2763




Tim Song
-
d:lwg2764
LWG2764

Dup
Are <cstddint> macros optional?
https://wg21.link/lwg2764




Thomas Koeppe
-
d:lwg2765
LWG2765

C++17
Did LWG 1123 go too far?
https://wg21.link/lwg2765




Richard Smith
-
d:lwg2766
LWG2766

New
Swapping non-swappable types
https://wg21.link/lwg2766




Agustín K-ballo Bergé
-
d:lwg2767
LWG2767

C++17
not_fn call_wrapper can form invalid types
https://wg21.link/lwg2767




Jonathan Wakely
-
d:lwg2768
LWG2768

C++17
any_cast and move semantics
https://wg21.link/lwg2768




Casey Carter
-
d:lwg2769
LWG2769

C++17
Redundant const in the return type of any_cast(const any&)
https://wg21.link/lwg2769




Casey Carter
-
d:lwg277
LWG277

NAD
Normative encouragement in allocator requirements unclear
https://wg21.link/lwg277




Matt Austern
-
d:lwg2770
LWG2770

C++17
tuple_size<const T> specialization is not SFINAE compatible and breaks decomposition declarations
https://wg21.link/lwg2770




Richard Smith
-
d:lwg2771
LWG2771

C++17
Broken Effects of some basic_string::compare functions in terms of basic_string_view
https://wg21.link/lwg2771




Daniel Krügler
-
d:lwg2772
LWG2772

NAD
Inconsistency in the insert(node) interface
https://wg21.link/lwg2772




Tomasz Kamiński
-
d:lwg2773
LWG2773

C++17
Making std::ignore constexpr
https://wg21.link/lwg2773




Vincent Reverdy
-
d:lwg2774
LWG2774

New
std::function construction vs assignment
https://wg21.link/lwg2774




Barry Revzin
-
d:lwg2775
LWG2775

Dup
reverse_iterator is does not compile for fancy pointers
https://wg21.link/lwg2775




Billy Robert O'Neal III
-
d:lwg2776
LWG2776

Resolved
shared_ptr unique() and use_count()
https://wg21.link/lwg2776




Hans Boehm
-
d:lwg2777
LWG2777

C++17
basic_string_view::copy should use char_traits::copy
https://wg21.link/lwg2777




Billy Robert O'Neal III
-
d:lwg2778
LWG2778

C++17
basic_string_view is missing constexpr
https://wg21.link/lwg2778




Billy Robert O'Neal III
-
d:lwg2779
LWG2779

WP
[networking.ts] Relax requirements on buffer sequence iterators
https://wg21.link/lwg2779




Vinnie Falco
-
d:lwg278
LWG278

CD1
What does iterator validity mean?
https://wg21.link/lwg278




P.J. Plauger
-
d:lwg2780
LWG2780

Resolved
basic_string_view::copy is missing constexpr
https://wg21.link/lwg2780




Billy Robert O'Neal III
-
d:lwg2781
LWG2781

C++17
Contradictory requirements for std::function and std::reference_wrapper
https://wg21.link/lwg2781




Jonathan Wakely
-
d:lwg2782
LWG2782

C++17
scoped_allocator_adaptor constructors must be constrained
https://wg21.link/lwg2782




Jonathan Wakely
-
d:lwg2783
LWG2783

WP
stack::emplace() and queue::emplace() should return decltype(auto)
https://wg21.link/lwg2783




Jonathan Wakely
-
d:lwg2784
LWG2784

C++17
Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse
https://wg21.link/lwg2784




Jonathan Wakely
-
d:lwg2785
LWG2785

C++17
quoted should work with basic_string_view
https://wg21.link/lwg2785




Marshall Clow
-
d:lwg2786
LWG2786

C++17
Annex C should mention shared_ptr changes for array support
https://wg21.link/lwg2786




Jonathan Wakely
-
d:lwg2787
LWG2787

C++17
§[fs.file_status.cons] doesn't match class definition
https://wg21.link/lwg2787




Tim Song
-
d:lwg2788
LWG2788

C++17
basic_string range mutators unintentionally require a default constructible allocator
https://wg21.link/lwg2788




Billy O'Neal III
-
d:lwg2789
LWG2789

C++17
Equivalence of contained objects
https://wg21.link/lwg2789




Jonathan Wakely
-
d:lwg279
LWG279

NAD
const and non-const iterators should have equivalent typedefs
https://wg21.link/lwg279




Steve Cleary
-
d:lwg2790
LWG2790

C++17
Missing specification of istreambuf_iterator::operator->
https://wg21.link/lwg2790




Jonathan Wakely
-
d:lwg2791
LWG2791

Resolved
string_view objects and strings should yield the same hash values
https://wg21.link/lwg2791




Nicolai Josuttis
-
d:lwg2792
LWG2792

TS
[fund.ts.v2] gcd and lcm should support a wider range of input values
https://wg21.link/lwg2792




Marshall Clow
-
d:lwg2793
LWG2793

C++17
Awkward conflation of trivial special members of istream_iterator
https://wg21.link/lwg2793




Erich Keane
-
d:lwg2794
LWG2794

C++17
Missing requirements for allocator pointers
https://wg21.link/lwg2794




Billy O'Neal III
-
d:lwg2795
LWG2795

C++17
§[global.functions] provides incorrect example of ADL use
https://wg21.link/lwg2795




Jonathan Wakely
-
d:lwg2796
LWG2796

C++17
tuple should be a literal type
https://wg21.link/lwg2796




Jonathan Wakely
-
d:lwg2797
LWG2797

Resolved
Trait precondition violations
https://wg21.link/lwg2797




Russia
-
d:lwg2798
LWG2798

Resolved
Definition of path in terms of a string
https://wg21.link/lwg2798




Billy O'Neal III
-
d:lwg2799
LWG2799

Resolved
noexcept-specifications in shared_future
https://wg21.link/lwg2799




Zhihao Yuan
-
d:lwg28
LWG28

TC1
Ctype<char>is ambiguous
https://wg21.link/lwg28




Nathan Myers
-
d:lwg280
LWG280

CD1
Comparison of reverse_iterator to const reverse_iterator
https://wg21.link/lwg280




Steve Cleary
-
d:lwg2800
LWG2800

Resolved
constexpr swap
https://wg21.link/lwg2800




United States
-
d:lwg2801
LWG2801

C++17
Default-constructibility of unique_ptr
https://wg21.link/lwg2801




United States
-
d:lwg2802
LWG2802

C++17
shared_ptr constructor requirements for a deleter
https://wg21.link/lwg2802




United States
-
d:lwg2803
LWG2803

Resolved
hash for arithmetic, pointer and standard library types should not throw
https://wg21.link/lwg2803




United States
-
d:lwg2804
LWG2804

C++17
Unconditional constexpr default constructor for istream_iterator
https://wg21.link/lwg2804




United States
-
d:lwg2805
LWG2805

Resolved
void and reference type alternatives in variant, variant<> and index()
https://wg21.link/lwg2805




Switzerland
-
d:lwg2806
LWG2806

C++17
Base class of bad_optional_access
https://wg21.link/lwg2806




Great Britain
-
d:lwg2807
LWG2807

C++17
std::invoke should use std::is_nothrow_callable
https://wg21.link/lwg2807




Great Britain
-
d:lwg2808
LWG2808

Tentatively Resolved
Requirements for fpos and stateT
https://wg21.link/lwg2808




Great Britain
-
d:lwg2809
LWG2809

Resolved
variant hash requirements
https://wg21.link/lwg2809




Great Britain
-
d:lwg281
LWG281

CD1
std::min() and max() requirements overly restrictive
https://wg21.link/lwg281




Martin Sebor
-
d:lwg2810
LWG2810

Resolved
use_count and unique in shared_ptr
https://wg21.link/lwg2810




Marshall Clow
-
d:lwg2811
LWG2811

New
"Selected constructor" wording is incorrect for optional/variant/any
https://wg21.link/lwg2811




Tim Song
-
d:lwg2812
LWG2812

C++17
Range access is available with <string_view>
https://wg21.link/lwg2812




Johel Ernesto Guerrero Peña
-
d:lwg2813
LWG2813

EWG
std::function should not return dangling references
https://wg21.link/lwg2813




Brian Bi
-
d:lwg2814
LWG2814

LEWG
[fund.ts.v2] to_array should take rvalue reference as well
https://wg21.link/lwg2814




Zhihao Yuan
-
d:lwg2815
LWG2815

New
quick_exit can deadlock
https://wg21.link/lwg2815




Jean-François Bastien
-
d:lwg2816
LWG2816

WP
resize_file has impossible postcondition
https://wg21.link/lwg2816




Richard Smith
-
d:lwg2817
LWG2817

Resolved
std::hash for nullptr_t
https://wg21.link/lwg2817




Marshall Clow
-
d:lwg2818
LWG2818

Open
"::std::" everywhere rule needs tweaking
https://wg21.link/lwg2818




Tim Song
-
d:lwg2819
LWG2819

New
Unspecified Return type: elements
https://wg21.link/lwg2819




Agustín K-ballo Bergé
-
d:lwg282
LWG282

CD1
What types does numpunct grouping refer to?
https://wg21.link/lwg282




Howard Hinnant
-
d:lwg2820
LWG2820

Tentatively Ready
Clarify <cstdint> macros
https://wg21.link/lwg2820




Thomas Köppe
-
d:lwg2821
LWG2821

Resolved
std::launder() should be marked as [[nodiscard]]
https://wg21.link/lwg2821




Tony van Eerd
-
d:lwg2822
LWG2822

NAD
Resolution for LWG 2742 introduces ambiguities
https://wg21.link/lwg2822




Jonathan Wakely
-
d:lwg2823
LWG2823

Open
std::array initialization is still not permissive enough
https://wg21.link/lwg2823




Robert Haberlach
-
d:lwg2824
LWG2824

C++17
list::sort should say that the order of elements is unspecified if an exception is thrown
https://wg21.link/lwg2824




Tim Song
-
d:lwg2825
LWG2825

LEWG
LWG 2756 breaks class template argument deduction for optional
https://wg21.link/lwg2825




Richard Smith
-
d:lwg2826
LWG2826

C++17
string_view iterators use old wording
https://wg21.link/lwg2826




Alisdair Meredith
-
d:lwg2827
LWG2827

New
is_trivially_constructible and non-trivial destructors
https://wg21.link/lwg2827




Richard Smith
-
d:lwg2828
LWG2828

NAD Editorial
Clarify <cstdalign> (following adoption of P0063r3)
https://wg21.link/lwg2828




Thomas Koeppe
-
d:lwg2829
LWG2829

Open
LWG 2740 leaves behind vacuous words
https://wg21.link/lwg2829




Richard Smith
-
d:lwg283
LWG283

CD1
std::replace() requirement incorrect/insufficient
https://wg21.link/lwg283




Martin Sebor
-
d:lwg2830
LWG2830

Resolved
insert_return_type is only defined for containers with unique keys
https://wg21.link/lwg2830




Daniel James
-
d:lwg2831
LWG2831

Resolved
Equality can be defined when Hash function objects have different behaviour
https://wg21.link/lwg2831




Daniel James
-
d:lwg2832
LWG2832

Tentatively Resolved
§[fpos.operations] strange requirement for P(i)
https://wg21.link/lwg2832




Jens Maurer
-
d:lwg2833
LWG2833

Open
Library needs to specify what it means when it declares a function constexpr
https://wg21.link/lwg2833




Richard Smith
-
d:lwg2834
LWG2834

C++17
Resolution LWG 2223 is missing wording about end iterators
https://wg21.link/lwg2834




Thomas Koeppe
-
d:lwg2835
LWG2835

C++17
LWG 2536 seems to misspecify <tgmath.h>
https://wg21.link/lwg2835




Thomas Koeppe
-
d:lwg2836
LWG2836

Resolved
More string operations should be noexcept
https://wg21.link/lwg2836




Jonathan Wakely
-
d:lwg2837
LWG2837

C++17
gcd and lcm should support a wider range of input values
https://wg21.link/lwg2837




Marshall Clow
-
d:lwg2838
LWG2838

C++17
is_literal_type specification needs a little cleanup
https://wg21.link/lwg2838




Tim Song
-
d:lwg2839
LWG2839

Open
Self-move-assignment of library types, again
https://wg21.link/lwg2839




Tim Song
-
d:lwg284
LWG284

CD1
unportable example in 20.3.7, p6
https://wg21.link/lwg284




Martin Sebor
-
d:lwg2840
LWG2840

Resolved
directory_iterator::increment is seemingly narrow-contract but marked noexcept
https://wg21.link/lwg2840




Tim Song
-
d:lwg2841
LWG2841

Resolved
Use of "Equivalent to" in [strings]
https://wg21.link/lwg2841




Jeffrey Yasskin
-
d:lwg2842
LWG2842

C++17
in_place_t check for optional::optional(U&&) should decay U
https://wg21.link/lwg2842




Tim Song
-
d:lwg2843
LWG2843

WP
Unclear behavior of std::pmr::memory_resource::do_allocate()
https://wg21.link/lwg2843




Jens Maurer
-
d:lwg2844
LWG2844

Open
Stability of a_uniq.insert(i, j)
https://wg21.link/lwg2844




Matt Austern
-
d:lwg2845
LWG2845

New
enable_if, result_of, common_type and aligned_storage do not meet the definition of TransformationTrait
https://wg21.link/lwg2845




Tim Song
-
d:lwg2846
LWG2846

New
Undefined phrase "effectively cast"
https://wg21.link/lwg2846




Jens Maurer
-
d:lwg2847
LWG2847

New
sin(float) should call sinf(float)
https://wg21.link/lwg2847




Jens Maurer
-
d:lwg2848
LWG2848

New
Pass-through threshold for pool allocator
https://wg21.link/lwg2848




Jens Maurer
-
d:lwg2849
LWG2849

WP
Why does !is_regular_file(from) cause copy_file to report a "file already exists" error?
https://wg21.link/lwg2849




Tim Song
-
d:lwg285
LWG285

CD1
minor editorial errors in fstream ctors
https://wg21.link/lwg285




Martin Sebor
-
d:lwg2850
LWG2850

C++17
std::function move constructor does unnecessary work
https://wg21.link/lwg2850




Geoffrey Romer
-
d:lwg2851
LWG2851

WP
std::filesystem enum classes are now underspecified
https://wg21.link/lwg2851




Tim Song
-
d:lwg2852
LWG2852

NAD
Specifications of operator== for std::basic_strings and std::basic_string_views are difficult to conform to
https://wg21.link/lwg2852




Ahti Leppänen
-
d:lwg2853
LWG2853

C++17
Possible inconsistency in specification of erase in [vector.modifiers]
https://wg21.link/lwg2853




Gerard Stone
-
d:lwg2854
LWG2854

NAD
wstring_convert provides no indication of incomplete input or output
https://wg21.link/lwg2854




PowerGamer
-
d:lwg2855
LWG2855

C++17
std::throw_with_nested("string_literal")
https://wg21.link/lwg2855




Jonathan Wakely
-
d:lwg2856
LWG2856

Resolved
std::async should be marked as [[nodiscard]]
https://wg21.link/lwg2856




Andrey Davydov
-
d:lwg2857
LWG2857

C++17
{variant,optional,any}::emplace should return the constructed value
https://wg21.link/lwg2857




Zhihao Yuan
-
d:lwg2858
LWG2858

New
LWG 2472: actually an incompatibility with C++03
https://wg21.link/lwg2858




Hubert Tong
-
d:lwg2859
LWG2859

WP
Definition of reachable in [ptr.launder] misses pointer arithmetic from pointer-interconvertible object
https://wg21.link/lwg2859




Hubert Tong
-
d:lwg286
LWG286

CD1
<cstdlib> requirements missing size_t typedef
https://wg21.link/lwg286




Judy Ward
-
d:lwg2860
LWG2860

NAD
launder and base class subobjects
https://wg21.link/lwg2860




Hubert Tong
-
d:lwg2861
LWG2861

C++17
basic_string should require that charT match traits::char_type
https://wg21.link/lwg2861




United States
-
d:lwg2862
LWG2862

Resolved
LWG 2756 should be accepted
https://wg21.link/lwg2862




Finland
-
d:lwg2863
LWG2863

Resolved
Undo default_order changes of maps and sets
https://wg21.link/lwg2863




Finland
-
d:lwg2864
LWG2864

Resolved
Merge shared_ptr changes from Library Fundamentals to C++17
https://wg21.link/lwg2864




Finland
-
d:lwg2865
LWG2865

NAD
Resolve all open Library issues for C++17
https://wg21.link/lwg2865




Finland
-
d:lwg2866
LWG2866

C++17
Incorrect derived classes constraints
https://wg21.link/lwg2866




Great Britain
-
d:lwg2867
LWG2867

Resolved
Bad footnote about explicit exception-specification
https://wg21.link/lwg2867




Great Britain
-
d:lwg2868
LWG2868

C++17
Missing specification of bad_any_cast::what()
https://wg21.link/lwg2868




Great Britain
-
d:lwg2869
LWG2869

Resolved
Deprecate sub-clause [locale.stdcvt]
https://wg21.link/lwg2869




Great Britain
-
d:lwg287
LWG287

NAD
conflicting ios_base fmtflags
https://wg21.link/lwg287




Judy Ward
-
d:lwg2870
LWG2870

WP
Default value of parameter theta of polar should be dependent
https://wg21.link/lwg2870




Japan
-
d:lwg2871
LWG2871

NAD
User specializations of type traits should be ill-formed
https://wg21.link/lwg2871




United States
-
d:lwg2872
LWG2872

C++17
Add definition for direct-non-list-initialization
https://wg21.link/lwg2872




United States
-
d:lwg2873
LWG2873

C++17
Add noexcept to several shared_ptr related functions
https://wg21.link/lwg2873




United States
-
d:lwg2874
LWG2874

C++17
Constructor shared_ptr::shared_ptr(Y*) should be constrained
https://wg21.link/lwg2874




United States
-
d:lwg2875
LWG2875

C++17
shared_ptr::shared_ptr(Y*, D, […]) constructors should be constrained
https://wg21.link/lwg2875




United States
-
d:lwg2876
LWG2876

C++17
shared_ptr::shared_ptr(const weak_ptr<Y>&) constructor should be constrained
https://wg21.link/lwg2876




United States
-
d:lwg2877
LWG2877

Resolved
Strengthen meaning of "empty shared_ptr<T>" in dynamic_pointer_cast
https://wg21.link/lwg2877




United States
-
d:lwg2878
LWG2878

C++17
Missing DefaultConstructible requirement for istream_iterator default constructor
https://wg21.link/lwg2878




United States
-
d:lwg2879
LWG2879

Resolved
Removing C dependencies from signal handler wording
https://wg21.link/lwg2879




Canada
-
d:lwg288
LWG288

CD1
<cerrno> requirements missing macro EILSEQ
https://wg21.link/lwg288




Judy Ward
-
d:lwg2880
LWG2880

Resolved
Relax complexity specifications for non-sequenced policies
https://wg21.link/lwg2880




Switzerland
-
d:lwg2881
LWG2881

New
Adopt section III of P0308R0
https://wg21.link/lwg2881




Switzerland
-
d:lwg2882
LWG2882

Resolved
Clarify variant construction
https://wg21.link/lwg2882




Switzerland
-
d:lwg2883
LWG2883

LEWG
The standard library should provide string_view parameters instead or in addition for functions defined with char const * or string const & as parameter types.
https://wg21.link/lwg2883




Switzerland
-
d:lwg2884
LWG2884

LEWG
Relational operators for containers should sfinae; if the underlying type is not comparable, neither should the container be
https://wg21.link/lwg2884




Finland
-
d:lwg2885
LWG2885

LEWG
The relational operators of optional and variant completely reflect the semantics of the element types — this is inconsistent with other types in the library
https://wg21.link/lwg2885




Finland
-
d:lwg2886
LWG2886

NAD
Keep the empty() functions in any
https://wg21.link/lwg2886




Finland
-
d:lwg2887
LWG2887

Resolved
Revert the changes from P0156R0: variadic lock_guard
https://wg21.link/lwg2887




Finland, Great Britain
-
d:lwg2888
LWG2888

Resolved
Variables of library tag types need to be inline variables
https://wg21.link/lwg2888




Finland
-
d:lwg2889
LWG2889

Resolved
Mark constexpr global variables as inline
https://wg21.link/lwg2889




Great Britain
-
d:lwg289
LWG289

NAD
<cmath> requirements missing C float and long double versions
https://wg21.link/lwg289




Judy Ward
-
d:lwg2890
LWG2890

C++17
The definition of 'object state' applies only to class types
https://wg21.link/lwg2890




Great Britain
-
d:lwg2891
LWG2891

NAD
Relax library requirements on volatile types
https://wg21.link/lwg2891




Great Britain
-
d:lwg2892
LWG2892

NAD
Relax the prohibition on libraries adding constexpr
https://wg21.link/lwg2892




Great Britain
-
d:lwg2893
LWG2893

NAD
Parsing Hexadecimally in P0067R4
https://wg21.link/lwg2893




Great Britain
-
d:lwg2894
LWG2894

Resolved
The function template std::apply() is required to be constexpr, but std::invoke() isn't
https://wg21.link/lwg2894




Great Britain
-
d:lwg2895
LWG2895

Resolved
Passing function types to result_of and is_callable
https://wg21.link/lwg2895




Great Britain
-
d:lwg2896
LWG2896

Dup
The contents of <codecvt> are underspecified
https://wg21.link/lwg2896




Great Britain
-
d:lwg2897
LWG2897

Resolved
array::iterator and array::const_iterator should be literal types
https://wg21.link/lwg2897




Russia
-
d:lwg2898
LWG2898

NAD
Prefer not to use member typedefs as constructor parameters
https://wg21.link/lwg2898




United States
-
d:lwg2899
LWG2899

WP
is_(nothrow_)move_constructible and tuple, optional and unique_ptr
https://wg21.link/lwg2899




United States
-
d:lwg29
LWG29

TC1
Ios_base::init doesn't exist
https://wg21.link/lwg29




Nathan Myers
-
d:lwg290
LWG290

NAD
Requirements to for_each and its function object
https://wg21.link/lwg290




Angelika Langer
-
d:lwg2900
LWG2900

C++17
The copy and move constructors of optional are not constexpr
https://wg21.link/lwg2900




United States
-
d:lwg2901
LWG2901

C++17
Variants cannot properly support allocators
https://wg21.link/lwg2901




United States
-
d:lwg2902
LWG2902

NAD
variant should only support complete types
https://wg21.link/lwg2902




United States
-
d:lwg2903
LWG2903

C++17
The form of initialization for the emplace-constructors is not specified
https://wg21.link/lwg2903




United States
-
d:lwg2904
LWG2904

C++17
Make variant move-assignment more exception safe
https://wg21.link/lwg2904




United States
-
d:lwg2905
LWG2905

C++17
is_constructible_v<unique_ptr<P, D>, P, D const &> should be false when D is not copy constructible
https://wg21.link/lwg2905




United States
-
d:lwg2906
LWG2906

New
There is no ability to supply an allocator for the control block when constructing a shared_ptr from a unique_ptr
https://wg21.link/lwg2906




United States
-
d:lwg2907
LWG2907

NAD
Semantics for destroying the deleter and the control-block of a shared_ptr are unclear
https://wg21.link/lwg2907




United States
-
d:lwg2908
LWG2908

C++17
The less-than operator for shared pointers could do more
https://wg21.link/lwg2908




United States
-
d:lwg2909
LWG2909

NAD
User specializations of is_execution_policy should be ill-formed
https://wg21.link/lwg2909




United States
-
d:lwg291
LWG291

CD1
Underspecification of set algorithms
https://wg21.link/lwg291




Matt Austern
-
d:lwg2910
LWG2910

Dup
Template deduction and integral_constant
https://wg21.link/lwg2910




United States
-
d:lwg2911
LWG2911

C++17
An is_aggregate type trait is needed
https://wg21.link/lwg2911




United States
-
d:lwg2912
LWG2912

Resolved
Add a deduction guide for class template duration
https://wg21.link/lwg2912




United States
-
d:lwg2913
LWG2913

Resolved
Containers need deduction guides
https://wg21.link/lwg2913




United States
-
d:lwg2914
LWG2914

Resolved
std::array does not support class-template deduction from initializers
https://wg21.link/lwg2914




United States
-
d:lwg2915
LWG2915

Resolved
The three container adapters should each have a deduction guide
https://wg21.link/lwg2915




United States
-
d:lwg2916
LWG2916

NAD
Insert iterators should each have an instantiation guide to initialize from a container
https://wg21.link/lwg2916




United States
-
d:lwg2917
LWG2917

Resolved
Parallel algorithms cannot easily work with InputIterators
https://wg21.link/lwg2917




United States
-
d:lwg2918
LWG2918

Resolved
Possible need for extra storage in inner_product
https://wg21.link/lwg2918




United States
-
d:lwg2919
LWG2919

Resolved
The specification for adjacent_difference has baked-in sequential semantics
https://wg21.link/lwg2919




United States
-
d:lwg292
LWG292

CD1
effects of a.copyfmt (a)
https://wg21.link/lwg292




Martin Sebor
-
d:lwg2920
LWG2920

Resolved
Add a deduction guide for creating a shared_future from a future rvalue
https://wg21.link/lwg2920




United States
-
d:lwg2921
LWG2921

C++17
packaged_task and type-erased allocators
https://wg21.link/lwg2921




United States
-
d:lwg2922
LWG2922

LEWG
The *_constant<> templates do not make use of template<auto>
https://wg21.link/lwg2922




United States
-
d:lwg2923
LWG2923

New
noexcept is inconsistently applied across headers which import components of the C standard library
https://wg21.link/lwg2923




United States
-
d:lwg2924
LWG2924

Resolved
An ExecutionPolicy overload for inner_product() seems impractical
https://wg21.link/lwg2924




United States
-
d:lwg2925
LWG2925

Resolved
Template argument deduction is not used in the standard library
https://wg21.link/lwg2925




United States
-
d:lwg2926
LWG2926

Resolved
INVOKE(f, t1, t2,... tN) and INVOKE(f, t1, t2,... tN, R) are too similar
https://wg21.link/lwg2926




United States
-
d:lwg2927
LWG2927

Resolved
Encoding a functor and argument types as a function signature for is_callable and result_of is fragile
https://wg21.link/lwg2927




United States
-
d:lwg2928
LWG2928

Resolved
is_callable is not a good name
https://wg21.link/lwg2928




United States
-
d:lwg2929
LWG2929

Resolved
basic_string misuses "Effects: Equivalent to"
https://wg21.link/lwg2929




Jonathan Wakely
-
d:lwg293
LWG293

NAD
Order of execution in transform algorithm
https://wg21.link/lwg293




Angelika Langer
-
d:lwg2930
LWG2930

NAD
Are implementations allowed to split non-member functions into several overloads?
https://wg21.link/lwg2930




Morwenn
-
d:lwg2931
LWG2931

Open
Missed optimization opportunity with single-argument std::next
https://wg21.link/lwg2931




Morwenn
-
d:lwg2932
LWG2932

WP
Constraints on parallel algorithm implementations are underspecified
https://wg21.link/lwg2932




Dietmar Kühl
-
d:lwg2933
LWG2933

New
PR for LWG 2773 could be clearer
https://wg21.link/lwg2933




Eric Fiselier
-
d:lwg2934
LWG2934

C++17
optional<const T> doesn't compare with T
https://wg21.link/lwg2934




Ville Voutilainen
-
d:lwg2935
LWG2935

WP
What should create_directories do when p already exists but is not a directory?
https://wg21.link/lwg2935




Billy Robert O'Neal III
-
d:lwg2936
LWG2936

WP
Path comparison is defined in terms of the generic format
https://wg21.link/lwg2936




Billy Robert O'Neal III
-
d:lwg2937
LWG2937

WP
Is equivalent("existing_thing", "not_existing_thing") an error?
https://wg21.link/lwg2937




Billy Robert O'Neal III
-
d:lwg2938
LWG2938

Resolved
basic_string_view::const_iterator should be literal types
https://wg21.link/lwg2938




Antony Polukhin
-
d:lwg2939
LWG2939

New
Some type-completeness constraints of traits are overspecified
https://wg21.link/lwg2939




Daniel Krügler
-
d:lwg294
LWG294

CD1
User defined macros and standard headers
https://wg21.link/lwg294




James Kanze
-
d:lwg2940
LWG2940

WP
result_of specification also needs a little cleanup
https://wg21.link/lwg2940




Daniel Krügler
-
d:lwg2941
LWG2941

WP
§[thread.req.timing] wording should apply to both member and namespace-level functions
https://wg21.link/lwg2941




Jonathan Mcdougall
-
d:lwg2942
LWG2942

WP
LWG 2873's resolution missed weak_ptr::owner_before
https://wg21.link/lwg2942




Tim Song
-
d:lwg2943
LWG2943

WP
Problematic specification of the wide version of basic_filebuf::open
https://wg21.link/lwg2943




Tim Song
-
d:lwg2944
LWG2944

WP
LWG 2905 accidentally removed requirement that construction of the deleter doesn't throw an exception
https://wg21.link/lwg2944




Tim Song
-
d:lwg2945
LWG2945

WP
Order of template parameters in optional comparisons
https://wg21.link/lwg2945




Jonathan Wakely
-
d:lwg2946
LWG2946

WP
LWG 2758's resolution missed further corrections
https://wg21.link/lwg2946




Daniel Krügler
-
d:lwg2947
LWG2947

New
Clarify several filesystem terms
https://wg21.link/lwg2947




Thomas Köppe
-
d:lwg2948
LWG2948

WP
unique_ptr does not define operator<< for stream output
https://wg21.link/lwg2948




Peter Dimov
-
d:lwg2949
LWG2949

New
Unclear complexity requirements: space vs. time
https://wg21.link/lwg2949




Jens Maurer
-
d:lwg295
LWG295

CD1
Is abs defined in <cmath>?
https://wg21.link/lwg295




Jens Maurer
-
d:lwg2950
LWG2950

WP
std::byte operations are misspecified
https://wg21.link/lwg2950




Thomas Köppe
-
d:lwg2951
LWG2951

Resolved
iterator_traits should SFINAE for void* and function pointers
https://wg21.link/lwg2951




Billy Robert O'Neal III
-
d:lwg2952
LWG2952

WP
iterator_traits should work for pointers to cv T
https://wg21.link/lwg2952




Billy Robert O'Neal III
-
d:lwg2953
LWG2953

WP
LWG 2853 should apply to deque::erase too
https://wg21.link/lwg2953




Tim Song
-
d:lwg2954
LWG2954

WP
Specialization of the convenience variable templates should be prohibited
https://wg21.link/lwg2954




Tim Song
-
d:lwg2955
LWG2955

Resolved
to_chars / from_chars depend on std::string
https://wg21.link/lwg2955




Jens Maurer
-
d:lwg2956
LWG2956

C++17
filesystem::canonical() still defined in terms of absolute(p, base)
https://wg21.link/lwg2956




Sergey Zubkov
-
d:lwg2957
LWG2957

Resolved
bind's specification doesn't apply the cv-qualification of the call wrapper to the callable object
https://wg21.link/lwg2957




Tim Song
-
d:lwg2958
LWG2958

WP
Moves improperly defined as deleted
https://wg21.link/lwg2958




Casey Carter
-
d:lwg2959
LWG2959

New
char_traits<char16_t>::eof is a valid UTF-16 code unit
https://wg21.link/lwg2959




Jonathan Wakely
-
d:lwg296
LWG296

C++11
Missing descriptions and requirements of pair operators
https://wg21.link/lwg296




Martin Sebor
-
d:lwg2960
LWG2960

WP
[fund.ts.v3] nonesuch is insufficiently useless
https://wg21.link/lwg2960




Tim Song
-
d:lwg2961
LWG2961

WP
Bad postcondition for set_default_resource
https://wg21.link/lwg2961




Casey Carter
-
d:lwg2962
LWG2962

Open
Iterators of Containers of move-only types do not model InputIterator
https://wg21.link/lwg2962




Gašper Ažman
-
d:lwg2963
LWG2963

New
Algorithms with underspecified iterator requirements
https://wg21.link/lwg2963




Gašper Ažman
-
d:lwg2964
LWG2964

WP
Apparently redundant requirement for dynamic_pointer_cast
https://wg21.link/lwg2964




Tim Song
-
d:lwg2965
LWG2965

WP
Non-existing path::native_string() in filesystem_error::what() specification
https://wg21.link/lwg2965




Daniel Krügler
-
d:lwg2966
LWG2966

WP
Incomplete resolution of US 74
https://wg21.link/lwg2966




Jonathan Wakely
-
d:lwg2967
LWG2967

NAD
std::equal on empty ranges
https://wg21.link/lwg2967




Gennaro Prota
-
d:lwg2968
LWG2968

Resolved
Inconsistencies between basic_string reserve and vector/unordered_map/unordered_set reserve functions
https://wg21.link/lwg2968




Andrew Luo
-
d:lwg2969
LWG2969

WP
polymorphic_allocator::construct() shouldn't pass resource()
https://wg21.link/lwg2969




Pablo Halpern
-
d:lwg297
LWG297

CD1
const_mem_fun_t<>::argument_type should be const T*
https://wg21.link/lwg297




Martin Sebor
-
d:lwg2970
LWG2970

WP
Return type of std::visit misspecified
https://wg21.link/lwg2970




Tim Song
-
d:lwg2971
LWG2971

NAD
variant should require Destructible types
https://wg21.link/lwg2971




Agustín K-ballo Bergé
-
d:lwg2972
LWG2972

WP
What is is_trivially_destructible_v<int>?
https://wg21.link/lwg2972




Richard Smith
-
d:lwg2973
LWG2973

LEWG
inplace_merge exact comparison count complexity prohibits useful real-world optimizations
https://wg21.link/lwg2973




Billy Robert O'Neal III
-
d:lwg2974
LWG2974

WP
Diagnose out of bounds tuple_element/variant_alternative
https://wg21.link/lwg2974




Agustín K-ballo Bergé
-
d:lwg2975
LWG2975

WP
Missing case for pair construction in scoped and polymorphic allocators
https://wg21.link/lwg2975




Casey Carter
-
d:lwg2976
LWG2976

WP
Dangling uses_allocator specialization for packaged_task
https://wg21.link/lwg2976




Tim Song
-
d:lwg2977
LWG2977

WP
unordered_meow::merge() has incorrect Throws: clause
https://wg21.link/lwg2977




Tim Song
-
d:lwg2978
LWG2978

WP
Hash support for pmr::string and friends
https://wg21.link/lwg2978




Tim Song
-
d:lwg2979
LWG2979

WP
aligned_union should require complete object types
https://wg21.link/lwg2979




Tim Song
-
d:lwg298
LWG298

CD1
::operator delete[] requirement incorrect/insufficient
https://wg21.link/lwg298




John A. Pedretti
-
d:lwg2980
LWG2980

WP
Cannot compare_exchange empty pointers
https://wg21.link/lwg2980




Alisdair Meredith
-
d:lwg2981
LWG2981

WP
Remove redundant deduction guides from standard library
https://wg21.link/lwg2981




Mike Spertus
-
d:lwg2982
LWG2982

WP
Making size_type consistent in associative container deduction guides
https://wg21.link/lwg2982




Mike Spertus
-
d:lwg2983
LWG2983

New
money_put::do_put underspecified
https://wg21.link/lwg2983




Jonathan Wakely
-
d:lwg2984
LWG2984

New
put_money(99) is unnecessarily undefined
https://wg21.link/lwg2984




Jonathan Wakely
-
d:lwg2985
LWG2985

LEWG
std::reverse should be permitted to be vectorized
https://wg21.link/lwg2985




Billy O'Neal III
-
d:lwg2986
LWG2986

New
Handling of multi-character collating elements by the regex FSM is underspecified
https://wg21.link/lwg2986




Hubert Tong
-
d:lwg2987
LWG2987

New
Relationship between traits_inst.lookup_collatename and the regex FSM is underspecified with regards to ClassAtomCollatingElement
https://wg21.link/lwg2987




Hubert Tong
-
d:lwg2988
LWG2988

WP
Clause 32 cleanup missed one typename
https://wg21.link/lwg2988




Jens Maurer
-
d:lwg2989
LWG2989

WP
path's stream insertion operator lets you insert everything under the sun
https://wg21.link/lwg2989




Billy O'Neal III
-
d:lwg299
LWG299

NAD Editorial
Incorrect return types for iterator dereference
https://wg21.link/lwg299




John Potter
-
d:lwg2990
LWG2990

Open
optional::value_type is not always a value type
https://wg21.link/lwg2990




Casey Carter
-
d:lwg2991
LWG2991

LEWG
variant copy constructor missing noexcept(see below)
https://wg21.link/lwg2991




Peter Dimov
-
d:lwg2992
LWG2992

NAD
system_category() and error_code::error_code() should be constexpr
https://wg21.link/lwg2992




Peter Dimov
-
d:lwg2993
LWG2993

WP
reference_wrapper<T> conversion from T&&
https://wg21.link/lwg2993




Tim Song
-
d:lwg2994
LWG2994

Open
Needless UB for basic_string and basic_string_view
https://wg21.link/lwg2994




Gennaro Prota
-
d:lwg2995
LWG2995

WP
basic_stringbuf default constructor forbids it from using SSO capacity
https://wg21.link/lwg2995




Jonathan Wakely
-
d:lwg2996
LWG2996

WP
Missing rvalue overloads for shared_ptr operations
https://wg21.link/lwg2996




Geoffrey Romer
-
d:lwg2997
LWG2997

New
LWG 491 and the specification of {forward_,}list::unique
https://wg21.link/lwg2997




Tim Song
-
d:lwg2998
LWG2998

WP
Requirements on function objects passed to {forward_,}list-specific algorithms
https://wg21.link/lwg2998




Tim Song
-
d:lwg2999
LWG2999

Tentatively Resolved
§[thread.decaycopy] issue
https://wg21.link/lwg2999




Marshall Clow
-
d:lwg3
LWG3

TC1
Atexit registration during atexit() call is not described
https://wg21.link/lwg3




Steve Clamage
-
d:lwg30
LWG30

TC1
Wrong header for LC_*
https://wg21.link/lwg30




Nathan Myers
-
d:lwg300
LWG300

CD1
list::merge() specification incomplete
https://wg21.link/lwg300




John Pedretti
-
d:lwg3000
LWG3000

WP
monotonic_memory_resource::do_is_equal uses dynamic_cast unnecessarily
https://wg21.link/lwg3000




Pablo Halpern
-
d:lwg3001
LWG3001

WP
weak_ptr::element_type needs remove_extent_t
https://wg21.link/lwg3001




Stephan T. Lavavej
-
d:lwg3002
LWG3002

WP
[networking.ts] basic_socket_acceptor::is_open() isn't noexcept
https://wg21.link/lwg3002




Jonathan Wakely
-
d:lwg3003
LWG3003

Open
<future> still has type-erased allocators in promise
https://wg21.link/lwg3003




Billy O'Neal III
-
d:lwg3004
LWG3004

WP
§[string.capacity] and §[vector.capacity] should specify time complexity for capacity()
https://wg21.link/lwg3004




Andy Giese
-
d:lwg3005
LWG3005

WP
Destruction order of arrays by make_shared/allocate_shared only recommended?
https://wg21.link/lwg3005




Richard Smith
-
d:lwg3006
LWG3006

New
Constructing a basic_stringbuf from a string — where does the allocator come from?
https://wg21.link/lwg3006




Marshall Clow
-
d:lwg3007
LWG3007

WP
allocate_shared should rebind allocator to cv-unqualified value_type for construction
https://wg21.link/lwg3007




Glen Joseph Fernandes
-
d:lwg3008
LWG3008

WP
make_shared (sub)object destruction semantics are not specified
https://wg21.link/lwg3008




Glen Joseph Fernandes
-
d:lwg3009
LWG3009

WP
Including <string_view> doesn't provide std::size/empty/data
https://wg21.link/lwg3009




Tim Song
-
d:lwg301
LWG301

CD1
basic_string template ctor effects clause omits allocator argument
https://wg21.link/lwg301




Martin Sebor
-
d:lwg3010
LWG3010

WP
[networking.ts] uses_executor says "if a type T::executor_type exists"
https://wg21.link/lwg3010




Jonathan Wakely
-
d:lwg3011
LWG3011

Open
Requirements for assert(E) inconsistent with C
https://wg21.link/lwg3011




Jonathan Wakely
-
d:lwg3012
LWG3012

WP
atomic<T> is unimplementable for non-is_trivially_copy_constructible T
https://wg21.link/lwg3012




Billy O'Neal III
-
d:lwg3013
LWG3013

WP
(recursive_)directory_iterator construction and traversal should not be noexcept
https://wg21.link/lwg3013




Tim Song
-
d:lwg3014
LWG3014

WP
More noexcept issues with filesystem operations
https://wg21.link/lwg3014




Tim Song
-
d:lwg3015
LWG3015

WP
copy_options::unspecified underspecified
https://wg21.link/lwg3015




Tim Song
-
d:lwg3016
LWG3016

NAD
optional and over-aligned types
https://wg21.link/lwg3016




Tim Song
-
d:lwg3017
LWG3017

WP
list splice functions should use addressof
https://wg21.link/lwg3017




Jonathan Wakely
-
d:lwg3018
LWG3018

WP
shared_ptr of function type
https://wg21.link/lwg3018




Agustín K-ballo Bergé
-
d:lwg3019
LWG3019

New
Presentation of "program defined classes derived from error_category" [syserr.errcat.derived] unclear and contains mistakes
https://wg21.link/lwg3019




Thomas Köppe
-
d:lwg302
LWG302

NAD
Need error indication from codecvt<>::do_length
https://wg21.link/lwg302




Gregory Bumgardner
-
d:lwg3020
LWG3020

WP
[networking.ts] Remove spurious nested value_type buffer sequence requirement
https://wg21.link/lwg3020




Vinnie Falco
-
d:lwg3021
LWG3021

New
[networking.ts] Relax pointer equivalence requirement for ConstBufferSequence
https://wg21.link/lwg3021




Vinnie Falco
-
d:lwg3022
LWG3022

Resolved
is_convertible<derived*, base*> may lead to ODR
https://wg21.link/lwg3022




Alisdair Meredith
-
d:lwg3023
LWG3023

Resolved
Clarify unspecified call wrappers
https://wg21.link/lwg3023




Detlef Vollmann
-
d:lwg3024
LWG3024

WP
variant's copies must be deleted instead of disabled via SFINAE
https://wg21.link/lwg3024




Casey Carter
-
d:lwg3025
LWG3025

WP
Map-like container deduction guides should use pair<Key, T>, not pair<const Key, T>
https://wg21.link/lwg3025




Ville Voutilainen
-
d:lwg3026
LWG3026

WP
filesystem::weakly_canonical still defined in terms of canonical(p, base)
https://wg21.link/lwg3026




Jonathan Wakely
-
d:lwg3027
LWG3027

New
[networking.ts] DynamicBuffer prepare exception specification
https://wg21.link/lwg3027




Vinnie Falco
-
d:lwg3028
LWG3028

New
Container requirements tables should distinguish const and non-const variables
https://wg21.link/lwg3028




Jonathan Wakely
-
d:lwg3029
LWG3029

Open
pop_heap over-constrains input
https://wg21.link/lwg3029




Mathias Stearn
-
d:lwg303
LWG303

CD1
Bitset input operator underspecified
https://wg21.link/lwg303




Matt Austern
-
d:lwg3030
LWG3030

WP
Who shall meet the requirements of try_lock?
https://wg21.link/lwg3030




Jonathan Wakely
-
d:lwg3031
LWG3031

WP
Algorithms and predicates with non-const reference arguments
https://wg21.link/lwg3031




Jonathan Wakely
-
d:lwg3032
LWG3032

New
ValueSwappable requirement missing for push_heap and make_heap
https://wg21.link/lwg3032




Robert Douglas
-
d:lwg3033
LWG3033

NAD Editorial
basic_string move ctor is underspecified
https://wg21.link/lwg3033




Peter Sommerlad
-
d:lwg3034
LWG3034

WP
P0767R1 breaks previously-standard-layout types
https://wg21.link/lwg3034




Casey Carter
-
d:lwg3035
LWG3035

WP
std::allocator's constructors should be constexpr
https://wg21.link/lwg3035




Geoffrey Romer
-
d:lwg3036
LWG3036

Open
polymorphic_allocator::destroy is extraneous
https://wg21.link/lwg3036




Casey Carter
-
d:lwg3037
LWG3037

WP
polymorphic_allocator and incomplete types
https://wg21.link/lwg3037




Casey Carter
-
d:lwg3038
LWG3038

WP
polymorphic_allocator::allocate should not allow integer overflow to create vulnerabilities
https://wg21.link/lwg3038




Billy O'Neal III
-
d:lwg3039
LWG3039

WP
Unnecessary decay in thread and packaged_task
https://wg21.link/lwg3039




Stephan T. Lavavej
-
d:lwg304
LWG304

NAD
Must *a return an lvalue when a is an input iterator?
https://wg21.link/lwg304




Dave Abrahams
-
d:lwg3040
LWG3040

WP
basic_string_view::starts_with Effects are incorrect
https://wg21.link/lwg3040




Marshall Clow
-
d:lwg3041
LWG3041

WP
Unnecessary decay in reference_wrapper
https://wg21.link/lwg3041




Agustín K-ballo Bergé
-
d:lwg3042
LWG3042

WP
is_literal_type_v should be inline
https://wg21.link/lwg3042




Tim Song
-
d:lwg3043
LWG3043

WP
Bogus postcondition for filesystem_error constructor
https://wg21.link/lwg3043




Tim Song
-
d:lwg3044
LWG3044

New
Strange specification of max_size() for an allocator
https://wg21.link/lwg3044




Jon Cohen
-
d:lwg3045
LWG3045

WP
atomic<floating-point> doesn't have value_type or difference_type
https://wg21.link/lwg3045




Tim Song
-
d:lwg3046
LWG3046

New
Do not require reference_wrapper to support non-referenceable function types
https://wg21.link/lwg3046




Jonathan Wakely
-
d:lwg3047
LWG3047

New
atomic compound assignment operators can cause undefined behavior when corresponding fetch_meow members don't
https://wg21.link/lwg3047




Tim Song
-
d:lwg3048
LWG3048

WP
transform_reduce(exec, first1, last1, first2, init) discards execution policy
https://wg21.link/lwg3048




Billy Robert O'Neal III
-
d:lwg3049
LWG3049

Open
Missing wording allowing algorithms to use copies of function objects as substitutes for their parameters
https://wg21.link/lwg3049




Jared Hoberock
-
d:lwg305
LWG305

CD1
Default behavior of codecvt<wchar_t, char, mbstate_t>::length()
https://wg21.link/lwg305




Howard Hinnant
-
d:lwg3050
LWG3050

WP
Conversion specification problem in chrono::duration constructor
https://wg21.link/lwg3050




Barry Revzin
-
d:lwg3051
LWG3051

WP
Floating point classifications were inadvertently changed in P0175
https://wg21.link/lwg3051




Thomas Köppe
-
d:lwg3052
LWG3052

LEWG
visit is underconstrained
https://wg21.link/lwg3052




Casey Carter
-
d:lwg3053
LWG3053

New
Prohibit error_code construction from rvalues of error_category
https://wg21.link/lwg3053




Antony Polukhin
-
d:lwg3054
LWG3054

WP
uninitialized_copy appears to not be able to meet its exception-safety guarantee
https://wg21.link/lwg3054




Jon Cohen
-
d:lwg3055
LWG3055

WP
path::operator+=(single-character) misspecified
https://wg21.link/lwg3055




Tim Song
-
d:lwg3056
LWG3056

New
copy_file() copies which attributes?
https://wg21.link/lwg3056




Davis Herring
-
d:lwg3057
LWG3057

Open
Correct copy_options handling
https://wg21.link/lwg3057




Davis Herring
-
d:lwg3058
LWG3058

WP
Parallel adjacent_difference shouldn't require creating temporaries
https://wg21.link/lwg3058




Billy O'Neal III
-
d:lwg3059
LWG3059

New
Wrong requirements for map-like associative container assignment?
https://wg21.link/lwg3059




Richard Smith
-
d:lwg306
LWG306

CD1
offsetof macro and non-POD types
https://wg21.link/lwg306




Steve Clamage
-
d:lwg3060
LWG3060

New
XXX_scan algorithms are specified to work with move-only T, but are specified to make N copies of T into the destination range
https://wg21.link/lwg3060




Billy O'Neal III
-
d:lwg3061
LWG3061

Resolved
What is the return type of compare_3way?
https://wg21.link/lwg3061




Richard Smith
-
d:lwg3062
LWG3062

WP
Unnecessary decay_t in is_execution_policy_v should be remove_cvref_t
https://wg21.link/lwg3062




Billy O'Neal III
-
d:lwg3063
LWG3063

New
Parallel algorithms in <memory> are underspecified
https://wg21.link/lwg3063




Alisdair Meredith
-
d:lwg3064
LWG3064

New
How do uninitialized memory algorithms obtain pointer without undefined behavior?
https://wg21.link/lwg3064




Alisdair Meredith
-
d:lwg3065
LWG3065

WP
LWG 2989 missed that all path's other operators should be hidden friends as well
https://wg21.link/lwg3065




Billy O'Neal III
-
d:lwg3066
LWG3066

New
"report a domain error" in [sf.cmath]/1 is underspecified
https://wg21.link/lwg3066




Casey Carter
-
d:lwg3067
LWG3067

WP
recursive_directory_iterator::pop must invalidate
https://wg21.link/lwg3067




Casey Carter
-
d:lwg3068
LWG3068

LEWG
Forbid assigning an rvalue basic_string to basic_string_view
https://wg21.link/lwg3068




Antony Polukhin
-
d:lwg3069
LWG3069

New
Move assigning variant's subobject corrupts data
https://wg21.link/lwg3069




Antony Polukhin
-
d:lwg307
LWG307

CD1
Lack of reference typedefs in container adaptors
https://wg21.link/lwg307




Howard Hinnant
-
d:lwg3070
LWG3070

WP
path::lexically_relative causes surprising results if a filename can also be a root-name
https://wg21.link/lwg3070




Billy O'Neal III
-
d:lwg3071
LWG3071

WP
[networking.ts] read_until still refers to "input sequence"
https://wg21.link/lwg3071




Christopher Kohlhoff
-
d:lwg3072
LWG3072

New
[networking.ts] DynamicBuffer object lifetimes underspecified
https://wg21.link/lwg3072




Christopher Kohlhoff
-
d:lwg3073
LWG3073

New
[networking.ts] (async_)read and (async_)write don't support DynamicBuffer lvalues
https://wg21.link/lwg3073




Christopher Kohlhoff
-
d:lwg3074
LWG3074

WP
Non-member functions for valarray should only deduce from the valarray
https://wg21.link/lwg3074




Jonathan Wakely
-
d:lwg3075
LWG3075

WP
basic_string needs deduction guides from basic_string_view
https://wg21.link/lwg3075




Stephan T. Lavavej
-
d:lwg3076
LWG3076

WP
basic_string CTAD ambiguity
https://wg21.link/lwg3076




Stephan T. Lavavej
-
d:lwg3077
LWG3077

WP
(push|emplace)_back should invalidate the end iterator
https://wg21.link/lwg3077




Casey Carter
-
d:lwg3078
LWG3078

New
directory_entry, directory_iterator and recursive_directory_iterator perform needless path copies
https://wg21.link/lwg3078




Gor Nishanov
-
d:lwg3079
LWG3079

WP
LWG 2935 forgot to fix the existing_p overloads of create_directory
https://wg21.link/lwg3079




Billy O'Neal III
-
d:lwg308
LWG308

CD1
Table 82 mentions unrelated headers
https://wg21.link/lwg308




Martin Sebor
-
d:lwg3080
LWG3080

WP
Floating point from_chars pattern specification breaks round-tripping
https://wg21.link/lwg3080




Greg Falcon
-
d:lwg3081
LWG3081

Open
Floating point from_chars API does not distinguish between overflow and underflow
https://wg21.link/lwg3081




Greg Falcon
-
d:lwg3082
LWG3082

Open
from_chars specification regarding floating point rounding is inconsistent
https://wg21.link/lwg3082




Greg Falcon
-
d:lwg3083
LWG3083

WP
What should ios::iword(-1) do?
https://wg21.link/lwg3083




Jonathan Wakely
-
d:lwg3084
LWG3084

New
Termination in C++ is unclear
https://wg21.link/lwg3084




JF Bastien
-
d:lwg3085
LWG3085

Open
char_traits::copy precondition too weak
https://wg21.link/lwg3085




Jonathan Wakely
-
d:lwg3086
LWG3086

New
Possible problem in §[new.delete.single]
https://wg21.link/lwg3086




William M. Miller
-
d:lwg3087
LWG3087

WP
One final &x in §[list.ops]
https://wg21.link/lwg3087




Tim Song
-
d:lwg3088
LWG3088

New
forward_list::merge behavior unclear when passed *this
https://wg21.link/lwg3088




Tim Song
-
d:lwg3089
LWG3089

New
copy_n should require non-overlapping ranges
https://wg21.link/lwg3089




Marshall Clow
-
d:lwg309
LWG309

NAD
Does sentry catch exceptions?
https://wg21.link/lwg309




Martin Sebor
-
d:lwg3090
LWG3090

New
What is §[time.duration.cons]p4's "no overflow is induced in the conversion" intended to mean?
https://wg21.link/lwg3090




Richard Smith
-
d:lwg3091
LWG3091

Resolved
subsecond-precision time_of_day and durations that seconds cannot convert to
https://wg21.link/lwg3091




Richard Smith
-
d:lwg3092
LWG3092

Open
Unclear semantics of enum class bitmask types
https://wg21.link/lwg3092




Geoffrey Romer
-
d:lwg3093
LWG3093

New
LWG 2294/2192 missed a std::abs overload
https://wg21.link/lwg3093




Richard Smith
-
d:lwg3094
LWG3094

WP
§[time.duration.io]p4 makes surprising claims about encoding
https://wg21.link/lwg3094




Richard Smith
-
d:lwg3095
LWG3095

New
strstreambuf refers to nonexistent member of fpos, fpos::offset
https://wg21.link/lwg3095




Billy O'Neal III
-
d:lwg3096
LWG3096

WP
path::lexically_relative is confused by trailing slashes
https://wg21.link/lwg3096




Jonathan Wakely
-
d:lwg3097
LWG3097

New
basic_stringbuf seekoff effects trigger undefined behavior and have contradictory returns
https://wg21.link/lwg3097




Billy O'Neal III
-
d:lwg3098
LWG3098

New
Misleading example for filesystem::path::filename()
https://wg21.link/lwg3098




Jonathan Wakely
-
d:lwg3099
LWG3099

New
is_assignable<Incomplete&, Incomplete&>
https://wg21.link/lwg3099




Casey Carter
-
d:lwg31
LWG31

TC1
Immutable locale values
https://wg21.link/lwg31




Nathan Myers
-
d:lwg310
LWG310

CD1
Is errno a macro?
https://wg21.link/lwg310




Steve Clamage
-
d:lwg3100
LWG3100

WP
Unnecessary and confusing "empty span" wording
https://wg21.link/lwg3100




Stephan T. Lavavej
-
d:lwg3101
LWG3101

WP
span's Container constructors need another constraint
https://wg21.link/lwg3101




Stephan T. Lavavej
-
d:lwg3102
LWG3102

WP
Clarify span iterator and const_iterator behavior
https://wg21.link/lwg3102




Stephan T. Lavavej
-
d:lwg3103
LWG3103

WP
Errors in taking subview of span should be ill-formed where possible
https://wg21.link/lwg3103




Tomasz Kamiński
-
d:lwg3104
LWG3104

WP
Fixing duration division
https://wg21.link/lwg3104




Johel Ernesto Guerrero Peña
-
d:lwg3105
LWG3105

New
T1 is convertible to T2
https://wg21.link/lwg3105




Jens Maurer
-
d:lwg3106
LWG3106

NAD
nothrow should be inline constexpr rather that extern const
https://wg21.link/lwg3106




Antony Polukhin
-
d:lwg3107
LWG3107

New
istreambuf_iterator has public exposition-only member
https://wg21.link/lwg3107




Billy O'Neal III
-
d:lwg3108
LWG3108

New
istreambuf_iterator::proxy::operator* should be const
https://wg21.link/lwg3108




Billy O'Neal III
-
d:lwg3109
LWG3109

New
strstreambuf is copyable
https://wg21.link/lwg3109




Jonathan Wakely
-
d:lwg311
LWG311

CD1
Incorrect wording in basic_ostream class synopsis
https://wg21.link/lwg311




Andy Sawyer
-
d:lwg3110
LWG3110

New
Contiguous Iterators should always be Random-Access
https://wg21.link/lwg3110




Marc Aldorasi
-
d:lwg3111
LWG3111

Resolved
Too strong precondition on basic_string constructor
https://wg21.link/lwg3111




Andrzej Krzemienski
-
d:lwg3112
LWG3112

WP
system_error and filesystem_error constructors taking a string may not be able to meet their postconditions
https://wg21.link/lwg3112




Tim Song
-
d:lwg3113
LWG3113

Resolved
polymorphic_allocator::construct() should more closely match scoped_allocator_adaptor::construct()
https://wg21.link/lwg3113




Arthur O'Dwyer
-
d:lwg3114
LWG3114

LEWG
[networking.ts] Permit efficient composition when using DynamicBuffer
https://wg21.link/lwg3114




Vinnie Falco
-
d:lwg3115
LWG3115

Resolved
Unclear description for algorithm includes
https://wg21.link/lwg3115




Casey Carter
-
d:lwg3116
LWG3116

WP
OUTERMOST_ALLOC_TRAITS needs remove_reference_t
https://wg21.link/lwg3116




Tim Song
-
d:lwg3117
LWG3117

Ready
Missing packaged_task deduction guides
https://wg21.link/lwg3117




Marc Mutz
-
d:lwg3118
LWG3118

New
fpos equality comparison unspecified
https://wg21.link/lwg3118




Jonathan Wakely
-
d:lwg3119
LWG3119

WP
Program-definedness of closure types
https://wg21.link/lwg3119




Hubert Tong
-
d:lwg312
LWG312

CD1
Table 27 is missing headers
https://wg21.link/lwg312




Martin Sebor
-
d:lwg3120
LWG3120

Open
Unclear behavior of monotonic_buffer_resource::release()
https://wg21.link/lwg3120




Arthur O'Dwyer
-
d:lwg3121
LWG3121

Open
tuple constructor constraints for UTypes&&... overloads
https://wg21.link/lwg3121




Matt Calabrese
-
d:lwg3122
LWG3122

WP
__cpp_lib_chrono_udls was accidentally dropped
https://wg21.link/lwg3122




Stephan T. Lavavej
-
d:lwg3123
LWG3123

New
duration constructor from representation shouldn't be effectively non-throwing
https://wg21.link/lwg3123




Johel Ernesto Guerrero Peña
-
d:lwg3124
LWG3124

New
[networking.ts] Unclear how execution_context is intended to store services
https://wg21.link/lwg3124




Billy O'Neal III
-
d:lwg3125
LWG3125

Tentatively Resolved
duration streaming precondition should be a SFINAE condition
https://wg21.link/lwg3125




Johel Ernesto Guerrero Peña
-
d:lwg3126
LWG3126

New
There's no std::sub_match::compare(string_view) overload
https://wg21.link/lwg3126




Jonathan Wakely
-
d:lwg3127
LWG3127

WP
basic_osyncstream::rdbuf needs a const_cast
https://wg21.link/lwg3127




Tim Song
-
d:lwg3128
LWG3128

WP
strstream::rdbuf needs a const_cast
https://wg21.link/lwg3128




Tim Song
-
d:lwg3129
LWG3129

WP
regex_token_iterator constructor uses wrong pointer arithmetic
https://wg21.link/lwg3129




Tim Song
-
d:lwg313
LWG313

NAD
set_terminate and set_unexpected question
https://wg21.link/lwg313




Judy Ward
-
d:lwg3130
LWG3130

WP
§[input.output] needs many addressof
https://wg21.link/lwg3130




Tim Song
-
d:lwg3131
LWG3131

WP
addressof all the things
https://wg21.link/lwg3131




Tim Song
-
d:lwg3132
LWG3132

WP
Library needs to ban macros named expects or ensures
https://wg21.link/lwg3132




Tim Song
-
d:lwg3133
LWG3133

WP
Modernizing numeric type requirements
https://wg21.link/lwg3133




Tim Song
-
d:lwg3134
LWG3134

Resolved
[fund.ts.v3] LFTSv3 contains extraneous [meta] variable templates that should have been deleted by P09961
https://wg21.link/lwg3134




Thomas Köppe
-
d:lwg3135
LWG3135

New
[fund.ts.v3] LFTSv3 contains two redundant alias templates
https://wg21.link/lwg3135




Thomas Köppe
-
d:lwg3136
LWG3136

New
[fund.ts.v3] LFTSv3 awkward wording in propagate_const requirements
https://wg21.link/lwg3136




Thomas Köppe
-
d:lwg3137
LWG3137

WP
Header for __cpp_lib_to_chars
https://wg21.link/lwg3137




S. B.Tam
-
d:lwg3138
LWG3138

NAD
There is no such thing as assertion-level
https://wg21.link/lwg3138




Tim Song
-
d:lwg3139
LWG3139

NAD
contract_violation's special member functions
https://wg21.link/lwg3139




Tim Song
-
d:lwg314
LWG314

NAD
Is the stack unwound when terminate() is called?
https://wg21.link/lwg314




Detlef Vollmann
-
d:lwg3140
LWG3140

WP
COMMON_REF is unimplementable as specified
https://wg21.link/lwg3140




Casey Carter
-
d:lwg3141
LWG3141

WP
CopyConstructible doesn't preserve source values
https://wg21.link/lwg3141




Casey Carter
-
d:lwg3142
LWG3142

New
std::foo<incomplete> should be ill-formed NDR
https://wg21.link/lwg3142




Casey Carter
-
d:lwg3143
LWG3143

New
monotonic_buffer_resource growth policy is unclear
https://wg21.link/lwg3143




Jonathan Wakely
-
d:lwg3144
LWG3144

WP
span does not have a const_pointer typedef
https://wg21.link/lwg3144




Louis Dionne
-
d:lwg3145
LWG3145

WP
file_clock breaks ABI for C++17 implementations
https://wg21.link/lwg3145




Billy Robert O'Neal III
-
d:lwg3146
LWG3146

New
Excessive unwrapping in std::ref/cref
https://wg21.link/lwg3146




Agustín K-ballo Bergé
-
d:lwg3147
LWG3147

WP
Definitions of "likely" and "unlikely" are likely to cause problems
https://wg21.link/lwg3147




Casey Carter
-
d:lwg3148
LWG3148

WP
<concepts> should be freestanding
https://wg21.link/lwg3148




Casey Carter
-
d:lwg3149
LWG3149

WP
DefaultConstructible should require default initialization
https://wg21.link/lwg3149




Casey Carter
-
d:lwg315
LWG315

CD1
Bad "range" in list::unique complexity
https://wg21.link/lwg315




Andy Sawyer
-
d:lwg3150
LWG3150

WP
UniformRandomBitGenerator should validate min and max
https://wg21.link/lwg3150




Casey Carter
-
d:lwg3151
LWG3151

Tentatively Resolved
ConvertibleTo rejects conversions from array and function types
https://wg21.link/lwg3151




Casey Carter
-
d:lwg3152
LWG3152

New
common_type and common_reference have flaws in common
https://wg21.link/lwg3152




Casey Carter
-
d:lwg3153
LWG3153

WP
Common and common_type have too little in common
https://wg21.link/lwg3153




Casey Carter
-
d:lwg3154
LWG3154

WP
Common and CommonReference have a common defect
https://wg21.link/lwg3154




Casey Carter
-
d:lwg3155
LWG3155

Open
tuple<any, any>{allocator_arg_t, an_allocator}
https://wg21.link/lwg3155




Jonathan Wakely
-
d:lwg3156
LWG3156

New
ForwardIterator should only mean forward iterator
https://wg21.link/lwg3156




Casey Carter
-
d:lwg3157
LWG3157

New
Allocator destroy and fancy pointer operations must be non-throwing
https://wg21.link/lwg3157




Billy O'Neal III
-
d:lwg3158
LWG3158

WP
tuple(allocator_arg_t, const Alloc&) should be conditionally explicit
https://wg21.link/lwg3158




Jonathan Wakely
-
d:lwg3159
LWG3159

New
§[unique.ptr.single] requirements on deleter may be too strict
https://wg21.link/lwg3159




Jonathan Wakely
-
d:lwg316
LWG316

CD1
Vague text in Table 69
https://wg21.link/lwg316




Martin Sebor
-
d:lwg3160
LWG3160

WP
atomic_ref() = delete; should be deleted
https://wg21.link/lwg3160




Tim Song
-
d:lwg3161
LWG3161

Open
Container adapters mandate use of emplace_back but don't require it
https://wg21.link/lwg3161




Marshall Clow
-
d:lwg3162
LWG3162

New
system_error::system_error(error_code ec) not explicit
https://wg21.link/lwg3162




Peter Dimov
-
d:lwg3163
LWG3163

NAD
[networking.ts] Buffer sequence iterator equivalency
https://wg21.link/lwg3163




Vinnie Falco
-
d:lwg3164
LWG3164

NAD
Unhelpful "shall not participate" constraints for unique_ptr with reference deleter
https://wg21.link/lwg3164




Jonathan Wakely
-
d:lwg3165
LWG3165

LEWG
All starts_with() overloads should be called "begins_with"
https://wg21.link/lwg3165




Gennaro Prota
-
d:lwg3166
LWG3166

New
No such descriptive element as Value:
https://wg21.link/lwg3166




Walter Brown
-
d:lwg3167
LWG3167

New
[fund.ts.v3] Does observer_ptr support function types?
https://wg21.link/lwg3167




Alisdair Meredith
-
d:lwg3168
LWG3168

Open
Expects: element should be specified in one place
https://wg21.link/lwg3168




Geoffrey Romer
-
d:lwg3169
LWG3169

WP
ranges permutation generators discard useful information
https://wg21.link/lwg3169




Casey Carter
-
d:lwg317
LWG317

CD1
Instantiation vs. specialization of facets
https://wg21.link/lwg317




Martin Sebor
-
d:lwg3170
LWG3170

Open
is_always_equal added to std::allocator makes the standard library treat derived types as always equal
https://wg21.link/lwg3170




Billy O'Neal III
-
d:lwg3171
LWG3171

Open
LWG 2989 breaks directory_entry stream insertion
https://wg21.link/lwg3171




Tim Song
-
d:lwg3172
LWG3172

New
3-arg std::hypot is underspecified compared to the 2-arg overload
https://wg21.link/lwg3172




Matthias Kretz
-
d:lwg3173
LWG3173

WP
Enable CTAD for ref-view
https://wg21.link/lwg3173




Casey Carter
-
d:lwg3174
LWG3174

New
Precondition on is_convertible is too strong
https://wg21.link/lwg3174




Casey Carter
-
d:lwg3175
LWG3175

WP
The CommonReference requirement of concept SwappableWith is not satisfied in the example
https://wg21.link/lwg3175




Kostas Kyrimis
-
d:lwg3176
LWG3176

Resolved
Underspecified behavior of unordered containers when Container::key_equal differs from Pred
https://wg21.link/lwg3176




S. B. Tam
-
d:lwg3177
LWG3177

New
Limit permission to specialize variable templates to program-defined types
https://wg21.link/lwg3177




Johel Ernesto Guerrero Peña
-
d:lwg3178
LWG3178

Tentatively Resolved
std::mismatch is missing an upper bound
https://wg21.link/lwg3178




Geoffrey Romer
-
d:lwg3179
LWG3179

WP
subrange should always model Range
https://wg21.link/lwg3179




Casey Carter
-
d:lwg318
LWG318

CD1
Misleading comment in definition of numpunct_byname
https://wg21.link/lwg318




Martin Sebor
-
d:lwg3180
LWG3180

WP
Inconsistently named return type for ranges::minmax_element
https://wg21.link/lwg3180




Casey Carter
-
d:lwg3181
LWG3181

NAD
split_view::outer_iterator converting constructor is misconstrained
https://wg21.link/lwg3181




Casey Carter
-
d:lwg3182
LWG3182

WP
Specification of Same could be clearer
https://wg21.link/lwg3182




Casey Carter
-
d:lwg3183
LWG3183

WP
Normative permission to specialize Ranges variable templates
https://wg21.link/lwg3183




Casey Carter
-
d:lwg3184
LWG3184

WP
Inconsistencies in bind_front wording
https://wg21.link/lwg3184




Tomasz Kamiński
-
d:lwg3185
LWG3185

WP
Uses-allocator construction functions missing constexpr and noexcept
https://wg21.link/lwg3185




Pablo Halpern
-
d:lwg3186
LWG3186

WP
ranges removal, partition, and partial_sort_copy algorithms discard useful information
https://wg21.link/lwg3186




Tomasz Kamiński
-
d:lwg3187
LWG3187

WP
P0591R4 reverted DR 2586 fixes to scoped_allocator_adaptor::construct()
https://wg21.link/lwg3187




Jonathan Wakely
-
d:lwg3188
LWG3188

New
istreambuf_iterator::pointer should not be unspecified
https://wg21.link/lwg3188




Jonathan Wakely
-
d:lwg3189
LWG3189

New
Missing requirement for std::priority_queue
https://wg21.link/lwg3189




Jonathan Wakely
-
d:lwg319
LWG319

CD1
Storage allocation wording confuses "Required behavior", "Requires"
https://wg21.link/lwg319




Beman Dawes
-
d:lwg3190
LWG3190

WP
std::allocator::allocate sometimes returns too little storage
https://wg21.link/lwg3190




Casey Carter
-
d:lwg3191
LWG3191

WP
std::ranges::shuffle synopsis does not match algorithm definition
https://wg21.link/lwg3191




Christopher Di Bella
-
d:lwg3192
LWG3192

New
§[allocator.uses.construction] functions misbehave for const types
https://wg21.link/lwg3192




Jonathan Wakely
-
d:lwg3193
LWG3193

New
Mandates: and Expects: elements are not defined for types
https://wg21.link/lwg3193




Daniel Krügler
-
d:lwg3194
LWG3194

WP
ConvertibleTo prose does not match code
https://wg21.link/lwg3194




Hubert Tong
-
d:lwg3195
LWG3195

New
What is the stored pointer value of an empty weak_ptr?
https://wg21.link/lwg3195




Casey Carter
-
d:lwg3196
LWG3196

WP
std::optional<T> is ill-formed is T is an array
https://wg21.link/lwg3196




Jonathan Wakely
-
d:lwg3197
LWG3197

New
std::prev should not require BidirectionalIterator
https://wg21.link/lwg3197




Billy O'Neal III
-
d:lwg3198
LWG3198

WP
Bad constraint on std::span::span()
https://wg21.link/lwg3198




Lars Gullik Bjønnes
-
d:lwg3199
LWG3199

WP
istream >> bitset<0> fails
https://wg21.link/lwg3199




Davis Herring
-
d:lwg32
LWG32

TC1
Pbackfail description inconsistent
https://wg21.link/lwg32




Nathan Myers
-
d:lwg320
LWG320

CD1
list::assign overspecified
https://wg21.link/lwg320




Howard Hinnant
-
d:lwg3200
LWG3200

WP
midpoint should not constrain T is complete
https://wg21.link/lwg3200




Paolo Torres
-
d:lwg3201
LWG3201

WP
lerp should be marked as noexcept
https://wg21.link/lwg3201




Paolo Torres
-
d:lwg3202
LWG3202

WP
P0318R1 was supposed to be revised
https://wg21.link/lwg3202




Jonathan Wakely
-
d:lwg3203
LWG3203

New
span element access invalidation
https://wg21.link/lwg3203




Johel Ernesto Guerrero Peña
-
d:lwg3204
LWG3204

New
sub_match::swap only swaps the base class
https://wg21.link/lwg3204




Jonathan Wakely
-
d:lwg3205
LWG3205

New
decay_t in the new common_type fallback should be remove_cvref_t
https://wg21.link/lwg3205




Casey Carter
-
d:lwg3206
LWG3206

WP
year_month_day conversion to sys_days uses not-existing member function
https://wg21.link/lwg3206




Tomasz Kamiński
-
d:lwg3207
LWG3207

Tentatively NAD
N in ssize(const T (&)[N]) should be size_t
https://wg21.link/lwg3207




Nevin Liber
-
d:lwg3208
LWG3208

WP
Boolean's expression requirements are ordered inconsistently
https://wg21.link/lwg3208




Casey Carter
-
d:lwg3209
LWG3209

WP
Expression in year::ok() returns clause is ill-formed
https://wg21.link/lwg3209




Tomasz Kamiński
-
d:lwg321
LWG321

CD1
Typo in num_get
https://wg21.link/lwg321




Kevin Djang
-
d:lwg3210
LWG3210

New
allocate_shared is inconsistent about removing const from the pointer passed to allocator construct and destroy
https://wg21.link/lwg3210




Billy O'Neal III
-
d:lwg3211
LWG3211

Ready
std::tuple<> should be trivially constructible
https://wg21.link/lwg3211




Louis Dionne
-
d:lwg3212
LWG3212

New
tuple_element_t<1, const span<int, 42>> is const int
https://wg21.link/lwg3212




Tim Song
-
d:lwg3213
LWG3213

New
for_each_n and copy_n missing requirements for Size
https://wg21.link/lwg3213




Jonathan Wakely
-
d:lwg3214
LWG3214

New
§[facet.num.get.virtuals] doesn't say what it means for digit grouping to be consistent
https://wg21.link/lwg3214




Jonathan Wakely
-
d:lwg3215
LWG3215

New
variant default constructor has vague constexpr requirements
https://wg21.link/lwg3215




Louis Dionne
-
d:lwg3216
LWG3216

New
Rebinding the allocator before calling construct/destroy in allocate_shared
https://wg21.link/lwg3216




Billy O'Neal III
-
d:lwg3217
LWG3217

New
<memory> and <execution> should define __cpp_lib_parallel_algorithm
https://wg21.link/lwg3217




Jonathan Wakely
-
d:lwg3218
LWG3218

WP
Modifier for %d parse flag does not match POSIX and format specification
https://wg21.link/lwg3218




Tomasz Kamiński
-
d:lwg3219
LWG3219

New
std::array overview container requirements are incorrect
https://wg21.link/lwg3219




Nevin Liber & Christian Trott
-
d:lwg322
LWG322

CD1
iterator and const_iterator should have the same value type
https://wg21.link/lwg322




Matt Austern
-
d:lwg3220
LWG3220

New
P0558 broke conforming C++14 uses of atomic shared_ptr
https://wg21.link/lwg3220




Casey Carter
-
d:lwg3221
LWG3221

WP
Result of year_month arithmetic with months is ambiguous
https://wg21.link/lwg3221




Tomasz Kamiński
-
d:lwg3222
LWG3222

WP
P0574R1 introduced preconditions on non-existent parameters
https://wg21.link/lwg3222




Jonathan Wakely
-
d:lwg3223
LWG3223

New
lerp should not add the "sufficient additional overloads"
https://wg21.link/lwg3223




Billy O'Neal III
-
d:lwg3224
LWG3224

WP
zoned_time constructor from TimeZonePtr does not specify initialization of tp_
https://wg21.link/lwg3224




Tomasz Kamiński
-
d:lwg3225
LWG3225

WP
zoned_time converting constructor shall not be noexcept
https://wg21.link/lwg3225




Tomasz Kamiński
-
d:lwg3226
LWG3226

WP
zoned_time constructor from string_view should accept zoned_time<Duration2, TimeZonePtr2>
https://wg21.link/lwg3226




Tomasz Kamiński
-
d:lwg3227
LWG3227

New
Ambiguity issue for extract in ordered and unordered associative containers
https://wg21.link/lwg3227




Konstantin Boyarinov
-
d:lwg3228
LWG3228

LEWG
Surprising variant construction
https://wg21.link/lwg3228




Barry Revzin
-
d:lwg3229
LWG3229

New
§[res.on.exception.handling]#3 cannot apply to types with implicitly declared destructors
https://wg21.link/lwg3229




Nevin Liber
-
d:lwg323
LWG323

NAD
abs() overloads in different headers
https://wg21.link/lwg323




Dave Abrahams
-
d:lwg3230
LWG3230

WP
Format specifier %y/%Y is missing locale alternative versions
https://wg21.link/lwg3230




Tomasz Kamiński
-
d:lwg3231
LWG3231

WP
year_month_day_last::day specification does not cover !ok() values
https://wg21.link/lwg3231




Tomasz Kamiński
-
d:lwg3232
LWG3232

WP
Inconsistency in zoned_time deduction guides
https://wg21.link/lwg3232




Tomasz Kamiński
-
d:lwg3233
LWG3233

WP
Broken requirements for shared_ptr converting constructors
https://wg21.link/lwg3233




Casey Carter
-
d:lwg3234
LWG3234

New
Sufficient Additional Special Math Overloads
https://wg21.link/lwg3234




Casey Carter
-
d:lwg3235
LWG3235

WP
parse manipulator without abbreviation is not callable
https://wg21.link/lwg3235




Tomasz Kamiński
-
d:lwg3236
LWG3236

Ready
Random access iterator requirements lack limiting relational operators domain to comparing those from the same range
https://wg21.link/lwg3236




Peter Sommerlad
-
d:lwg3237
LWG3237

WP
LWG 3038 and 3190 have inconsistent PRs
https://wg21.link/lwg3237




Casey Carter
-
d:lwg3238
LWG3238

WP
Insufficiently-defined behavior of std::function deduction guides
https://wg21.link/lwg3238




Louis Dionne
-
d:lwg3239
LWG3239

Resolved
Hidden friends should be specified more narrowly
https://wg21.link/lwg3239




Daniel Sunderland
-
d:lwg324
LWG324

CD1
Do output iterators have value types?
https://wg21.link/lwg324




Dave Abrahams
-
d:lwg3240
LWG3240

New
Headers declare more than entities
https://wg21.link/lwg3240




Alisdair Meredith
-
d:lwg3241
LWG3241

WP
chrono-spec grammar ambiguity in §[time.format]
https://wg21.link/lwg3241




Victor Zverovich
-
d:lwg3242
LWG3242

WP
std::format: missing rules for arg-id in width and precision
https://wg21.link/lwg3242




Richard Smith
-
d:lwg3243
LWG3243

WP
std::format and negative zeroes
https://wg21.link/lwg3243




Richard Smith
-
d:lwg3244
LWG3244

WP
Constraints for Source in §[fs.path.req] insufficiently constrainty
https://wg21.link/lwg3244




Casey Carter
-
d:lwg3245
LWG3245

WP
Unnecessary restriction on '%p' parse specifier
https://wg21.link/lwg3245




Tomasz Kamiński
-
d:lwg3246
LWG3246

WP
What are the constraints on the template parameter of basic_format_arg?
https://wg21.link/lwg3246




Richard Smith
-
d:lwg3247
LWG3247

WP
ranges::iter_move should perform ADL-only lookup of iter_move
https://wg21.link/lwg3247




Casey Carter
-
d:lwg3248
LWG3248

WP
std::format #b, #B, #o, #x, and #X presentation types misformat negative numbers
https://wg21.link/lwg3248




Richard Smith
-
d:lwg3249
LWG3249

Ready
There are no 'pointers' in §[atomics.lockfree]
https://wg21.link/lwg3249




Billy O'Neal III
-
d:lwg325
LWG325

CD1
Misleading text in moneypunct<>::do_grouping
https://wg21.link/lwg325




Martin Sebor
-
d:lwg3250
LWG3250

WP
std::format: # (alternate form) for NaN and inf
https://wg21.link/lwg3250




Richard Smith
-
d:lwg3251
LWG3251

WP
Are std::format alignment specifiers applied to string arguments?
https://wg21.link/lwg3251




Richard Smith
-
d:lwg3252
LWG3252

WP
Parse locale's aware modifiers for commands are not consistent with POSIX spec
https://wg21.link/lwg3252




Tomasz Kamiński
-
d:lwg3253
LWG3253

WP
basic_syncbuf::basic_syncbuf() should not be explicit
https://wg21.link/lwg3253




Nevin Liber
-
d:lwg3254
LWG3254

WP
Strike stop_token's operator!=
https://wg21.link/lwg3254




Casey Carter
-
d:lwg3255
LWG3255

WP
span's array constructor is too strict
https://wg21.link/lwg3255




Jean Guegant & Barry Revzin
-
d:lwg3256
LWG3256

WP
Feature testing macro for constexpr algorithms
https://wg21.link/lwg3256




Antony Polukhin
-
d:lwg3257
LWG3257

WP
Missing feature testing macro update from P0858
https://wg21.link/lwg3257




Antony Polukhin
-
d:lwg3258
LWG3258

New
Range access and initializer_list
https://wg21.link/lwg3258




Casey Carter
-
d:lwg3259
LWG3259

WP
The definition of constexpr iterators should be adjusted
https://wg21.link/lwg3259




Daniel Krügler
-
d:lwg326
LWG326

NAD
Missing typedef in moneypunct_byname
https://wg21.link/lwg326




Martin Sebor
-
d:lwg3260
LWG3260

WP
year_month* arithmetic rejects durations convertible to years
https://wg21.link/lwg3260




Tomasz Kamiński
-
d:lwg3261
LWG3261

New
regex components' noexcept annotations appear broken for POCMA or throwing BidirectionalIterator
https://wg21.link/lwg3261




Billy O'Neal III
-
d:lwg3262
LWG3262

WP
Formatting of negative durations is not specified
https://wg21.link/lwg3262




Tomasz Kamiński
-
d:lwg3263
LWG3263

New
Atomic waiting function calls should only be unblocked once
https://wg21.link/lwg3263




Geoffrey Romer
-
d:lwg3264
LWG3264

WP
sized_range and ranges::size redundantly use disable_sized_range
https://wg21.link/lwg3264




Casey Carter
-
d:lwg3265
LWG3265

New
move_iterator's conversions are more broken after P1207
https://wg21.link/lwg3265




Casey Carter
-
d:lwg3266
LWG3266

WP
to_chars(bool) should be deleted
https://wg21.link/lwg3266




Jens Maurer
-
d:lwg3267
LWG3267

New
Rebound allocators and is_always_equal
https://wg21.link/lwg3267




FrankHB1989
-
d:lwg3268
LWG3268

New
memory_order::memory_order_foo broken in C++20
https://wg21.link/lwg3268




Eric Fiselier
-
d:lwg3269
LWG3269

WP
Parse manipulators do not specify the result of the extraction from stream
https://wg21.link/lwg3269




Tomasz Kamiński
-
d:lwg327
LWG327

CD1
Typo in time_get facet in table 52
https://wg21.link/lwg327




Tiki Wan
-
d:lwg3270
LWG3270

WP
Parsing and formatting %j with durations
https://wg21.link/lwg3270




Howard Hinnant
-
d:lwg3271
LWG3271

NAD
Parsing functions should save and restore stream format state
https://wg21.link/lwg3271




Howard Hinnant
-
d:lwg3272
LWG3272

WP
%I%p should parse/format duration since midnight
https://wg21.link/lwg3272




Howard Hinnant
-
d:lwg3273
LWG3273

WP
Specify weekday_indexed to range of [0, 7]
https://wg21.link/lwg3273




Howard Hinnant
-
d:lwg3274
LWG3274

WP
Missing feature test macro for <span>
https://wg21.link/lwg3274




Jonathan Wakely
-
d:lwg3275
LWG3275

New
Why does time_get::do_get require a valid pointer when none of the others do?
https://wg21.link/lwg3275




Marshall Clow
-
d:lwg3276
LWG3276

WP
Class split_view::outer_iterator::value_type should inherit from view_interface
https://wg21.link/lwg3276




Eric Niebler
-
d:lwg3277
LWG3277

WP
Pre-increment on prvalues is not a requirement of weakly_incrementable
https://wg21.link/lwg3277




Eric Niebler
-
d:lwg3278
LWG3278

New
join_view<V>::iterator<true> tries to write through const join_view ptr
https://wg21.link/lwg3278




Eric Niebler
-
d:lwg3279
LWG3279

Resolved
shared_ptr<int>& does not not satisfy readable
https://wg21.link/lwg3279




Eric Niebler
-
d:lwg328
LWG328

CD1
Bad sprintf format modifier in money_put<>::do_put()
https://wg21.link/lwg328




Martin Sebor
-
d:lwg3280
LWG3280

WP
View converting constructors can cause constraint recursion and are unneeded
https://wg21.link/lwg3280




Eric Niebler
-
d:lwg3281
LWG3281

WP
Conversion from pair-like types to subrange is a silent semantic promotion
https://wg21.link/lwg3281




Eric Niebler
-
d:lwg3282
LWG3282

WP
subrange converting constructor should disallow derived to base conversions
https://wg21.link/lwg3282




Eric Niebler
-
d:lwg3283
LWG3283

New
Types satisfying input_iterator but not equality_comparable look like C++17 output iterators
https://wg21.link/lwg3283




Eric Niebler
-
d:lwg3284
LWG3284

WP
random_access_iterator semantic constraints accidentally promote difference type using unary negate
https://wg21.link/lwg3284




Eric Niebler
-
d:lwg3285
LWG3285

WP
The type of a customization point object shall satisfy semiregular
https://wg21.link/lwg3285




Eric Niebler
-
d:lwg3286
LWG3286

WP
ranges::size is not required to be valid after a call to ranges::begin on an input range
https://wg21.link/lwg3286




Eric Niebler
-
d:lwg3287
LWG3287

New
Exposition-only cpp17-input-iterator concept is needlessly complex
https://wg21.link/lwg3287




Eric Niebler
-
d:lwg3288
LWG3288

New
atomic<T>::notify_one is unimplementable
https://wg21.link/lwg3288




Anthony Williams
-
d:lwg3289
LWG3289

New
Cannot opt out of C++17 iterator-ness without also opting out of C++20 iterator-ness
https://wg21.link/lwg3289




Eric Niebler
-
d:lwg329
LWG329

CD1
vector capacity, reserve and reallocation
https://wg21.link/lwg329




Anthony Williams
-
d:lwg3290
LWG3290

New
Are std::format field widths code units, code points, or something else?
https://wg21.link/lwg3290




Tom Honermann
-
d:lwg3291
LWG3291

WP
iota_view::iterator has the wrong iterator_category
https://wg21.link/lwg3291




Eric Niebler
-
d:lwg3292
LWG3292

WP
iota_view is under-constrained
https://wg21.link/lwg3292




Barry Revzin
-
d:lwg3293
LWG3293

New
move_iterator operator+() has incorrect constraints
https://wg21.link/lwg3293




Bo Persson
-
d:lwg3294
LWG3294

WP
zoned_time deduction guides misinterprets string/char*
https://wg21.link/lwg3294




Tomasz Kamiński
-
d:lwg3295
LWG3295

Resolved
Comparison category operator== are mis-specified
https://wg21.link/lwg3295




Barry Revzin
-
d:lwg3296
LWG3296

WP
Inconsistent default argument for basic_regex<>::assign
https://wg21.link/lwg3296




Mark de Wever
-
d:lwg3297
LWG3297

New
Useless sequence container requirement
https://wg21.link/lwg3297




Casey Carter
-
d:lwg3298
LWG3298

NAD
Range adaptors introduced by P1035 do not require viewable_range
https://wg21.link/lwg3298




Christopher Di Bella
-
d:lwg3299
LWG3299

WP
Pointers don't need customized iterator behavior
https://wg21.link/lwg3299




Casey Carter
-
d:lwg33
LWG33

TC1
Codecvt<> mentions from_type
https://wg21.link/lwg33




Nathan Myers
-
d:lwg330
LWG330

NAD
Misleading "exposition only" value in class locale definition
https://wg21.link/lwg330




Martin Sebor
-
d:lwg3300
LWG3300

WP
Non-array ssize overload is underconstrained
https://wg21.link/lwg3300




Casey Carter
-
d:lwg3301
LWG3301

WP
transform_view::iterator has incorrect iterator_category
https://wg21.link/lwg3301




Michel Morin
-
d:lwg3302
LWG3302

WP
Range adaptor objects keys and values are unspecified
https://wg21.link/lwg3302




Michel Morin
-
d:lwg3303
LWG3303

WP
Bad "constexpr" marker for destroy/destroy_n
https://wg21.link/lwg3303




Jens Maurer
-
d:lwg3304
LWG3304

WP
Allocate functions of std::polymorphic_allocator should require [[nodiscard]]
https://wg21.link/lwg3304




Hiroaki Ando
-
d:lwg3305
LWG3305

Open
any_cast<void>
https://wg21.link/lwg3305




John Shaw
-
d:lwg3306
LWG3306

New
ranges::advance violates its preconditions
https://wg21.link/lwg3306




Casey Carter
-
d:lwg3307
LWG3307

WP
std::allocator<void>().allocate(n)
https://wg21.link/lwg3307




Jonathan Wakely
-
d:lwg3308
LWG3308

New
vector and deque iterator erase invalidates elements even when no change occurs
https://wg21.link/lwg3308




Billy O'Neal III
-
d:lwg3309
LWG3309

New
Is <ios> implicitly #included by <sstream>, <fstream> etc.?
https://wg21.link/lwg3309




Jens Maurer
-
d:lwg331
LWG331

CD1
bad declaration of destructor for ios_base::failure
https://wg21.link/lwg331




PremAnand M. Rao
-
d:lwg3310
LWG3310

WP
Replace SIZE_MAX with numeric_limits<size_t>::max()
https://wg21.link/lwg3310




Japan
-
d:lwg3311
LWG3311

Dup
basic_string::operator=(charT c) should be constrained
https://wg21.link/lwg3311




Russia
-
d:lwg3312
LWG3312

Dup
polymorphic_allocator::allocate_object and new_object should be [[nodiscard]]
https://wg21.link/lwg3312




United States
-
d:lwg3313
LWG3313

WP
join_view::iterator::operator-- is incorrectly constrained
https://wg21.link/lwg3313




United States
-
d:lwg3314
LWG3314

WP
Is stream insertion behavior locale dependent when Period::type is micro?
https://wg21.link/lwg3314




Tom Honermann
-
d:lwg3315
LWG3315

WP
Correct Allocator Default Behavior
https://wg21.link/lwg3315




United States
-
d:lwg3316
LWG3316

WP
Correctly define epoch for utc_clock / utc_timepoint
https://wg21.link/lwg3316




Great Britain
-
d:lwg3317
LWG3317

WP
Incorrect operator<< for floating-point durations
https://wg21.link/lwg3317




United States
-
d:lwg3318
LWG3318

WP
Clarify whether clocks can represent time before their epoch
https://wg21.link/lwg3318




Great Britain
-
d:lwg3319
LWG3319

WP
Properly reference specification of IANA time zone database
https://wg21.link/lwg3319




Germany
-
d:lwg332
LWG332

NAD
Consider adding increment and decrement operators to std::fpos< T >
https://wg21.link/lwg332




PremAnand M. Rao
-
d:lwg3320
LWG3320

WP
span::cbegin/cend methods produce different results than std::[ranges::]cbegin/cend
https://wg21.link/lwg3320




Poland
-
d:lwg3321
LWG3321

WP
uninitialized_construct_using_allocator should use construct_at
https://wg21.link/lwg3321




United States
-
d:lwg3322
LWG3322

Tentatively Resolved
Add join_view::base() member function
https://wg21.link/lwg3322




United States
-
d:lwg3323
LWG3323

WP
has-tuple-element helper concept needs convertible_to
https://wg21.link/lwg3323




Great Britain
-
d:lwg3324
LWG3324

WP
Special-case std::strong/weak/partial_order for pointers
https://wg21.link/lwg3324




Canada
-
d:lwg3325
LWG3325

WP
Constrain return type of transformation function for transform_view
https://wg21.link/lwg3325




United States
-
d:lwg3326
LWG3326

WP
enable_view has false positives
https://wg21.link/lwg3326




Germany
-
d:lwg3327
LWG3327

WP
Format alignment specifiers vs. text direction
https://wg21.link/lwg3327




Great Britain
-
d:lwg3328
LWG3328

WP
Clarify that std::string is not good for UTF-8
https://wg21.link/lwg3328




The Netherlands
-
d:lwg3329
LWG3329

WP
totally_ordered_with both directly and indirectly requires common_reference_with
https://wg21.link/lwg3329




United States
-
d:lwg333
LWG333

CD1
does endl imply synchronization with the device?
https://wg21.link/lwg333




PremAnand M. Rao
-
d:lwg3330
LWG3330

WP
Include <compare> from most library headers
https://wg21.link/lwg3330




United States
-
d:lwg3331
LWG3331

WP
Define totally_ordered/_with in terms of partially-ordered-with
https://wg21.link/lwg3331




Great Britain
-
d:lwg3332
LWG3332

WP
Issue in §[time.format]
https://wg21.link/lwg3332




Mateusz Pusz
-
d:lwg3333
LWG3333

NAD
ranges::cbegin/ranges::cend, (and maybe ranges::crbegin/ranges::crend) are under-specified to allow rvalue-arrays
https://wg21.link/lwg3333




Christopher Di Bella
-
d:lwg3334
LWG3334

WP
basic_osyncstream move assignment and destruction calls basic_syncbuf::emit() twice
https://wg21.link/lwg3334




Tim Song
-
d:lwg3335
LWG3335

WP
Resolve C++20 NB comments US 273 and GB 274
https://wg21.link/lwg3335




United States/Great Britain
-
d:lwg3336
LWG3336

Resolved
How does std::vformat handle exception thrown by formatters?
https://wg21.link/lwg3336




Tam S. B.
-
d:lwg3337
LWG3337

New
What is "is initialized" supposed to mean?
https://wg21.link/lwg3337




Richard Smith
-
d:lwg3338
LWG3338

WP
Rename default_constructible to default_initializable
https://wg21.link/lwg3338




Casey Carter
-
d:lwg3339
LWG3339

New
Move-constructed empty-container capacity
https://wg21.link/lwg3339




Nathan Myers
-
d:lwg334
LWG334

CD1
map::operator[] specification forces inefficient implementation
https://wg21.link/lwg334




Andrea Griffini
-
d:lwg3340
LWG3340

WP
Formatting functions should throw on argument/format string mismatch in §[format.functions]
https://wg21.link/lwg3340




Great Britain
-
d:lwg3341
LWG3341

New
basic_regex range constructor: Missing requirements for iterator types
https://wg21.link/lwg3341




Денис Захаров
-
d:lwg3342
LWG3342

New
Library wording uses "initializes x with y", which is underspecified
https://wg21.link/lwg3342




Richard Smith
-
d:lwg3343
LWG3343

New
Ordering of calls to unlock() and notify_all() in Effects element of notify_all_at_thread_exit() should be reversed
https://wg21.link/lwg3343




Lewis Baker
-
d:lwg3344
LWG3344

New
advance(i, most-negative) and prev(i, most-negative)
https://wg21.link/lwg3344




Casey Carter
-
d:lwg3345
LWG3345

New
Incorrect usages of "models" versus "satisfies"
https://wg21.link/lwg3345




Daniel Krügler
-
d:lwg3346
LWG3346

WP
pair and tuple copy and move constructor have backwards specification
https://wg21.link/lwg3346




Richard Smith
-
d:lwg3347
LWG3347

WP
std::pair<T, U> now requires T and U to be less-than-comparable
https://wg21.link/lwg3347




Jonathan Wakely
-
d:lwg3348
LWG3348

WP
__cpp_lib_unwrap_ref in wrong header
https://wg21.link/lwg3348




Barry Revzin
-
d:lwg3349
LWG3349

WP
Missing __cpp_lib_constexpr_complex for P0415R1
https://wg21.link/lwg3349




Stephan T. Lavavej
-
d:lwg335
LWG335

CD1
minor issue with char_traits, table 37
https://wg21.link/lwg335




Andy Sawyer
-
d:lwg3350
LWG3350

WP
Simplify return type of lexicographical_compare_three_way
https://wg21.link/lwg3350




Jonathan Wakely
-
d:lwg3351
LWG3351

WP
ranges::enable_safe_range should not be constrained
https://wg21.link/lwg3351




Jonathan Wakely
-
d:lwg3352
LWG3352

WP
strong_equality isn't a thing
https://wg21.link/lwg3352




Casey Carter
-
d:lwg3353
LWG3353

New
locale's copy assignment operator should return locale&
https://wg21.link/lwg3353




Stephan T. Lavavej
-
d:lwg3354
LWG3354

WP
has_strong_structural_equality has a meaningless definition
https://wg21.link/lwg3354




Daniel Krügler
-
d:lwg3355
LWG3355

WP
The memory algorithms should support move-only input iterators introduced by P1207
https://wg21.link/lwg3355




Corentin Jabot
-
d:lwg3356
LWG3356

WP
__cpp_lib_nothrow_convertible should be __cpp_lib_is_nothrow_convertible
https://wg21.link/lwg3356




Barry Revzin
-
d:lwg3357
LWG3357

LEWG
[fund.ts.v3] default_random_engine is overspecified for per-thread engine
https://wg21.link/lwg3357




Zhihao Yuan
-
d:lwg3358
LWG3358

WP
§[span.cons] is mistaken that to_address can throw
https://wg21.link/lwg3358




Casey Carter
-
d:lwg3359
LWG3359

WP
<chrono> leap second support should allow for negative leap seconds
https://wg21.link/lwg3359




Asher Dunn
-
d:lwg336
LWG336

CD1
Clause 17 lack of references to deprecated headers
https://wg21.link/lwg336




Detlef Vollmann
-
d:lwg3360
LWG3360

WP
three_way_comparable_with is inconsistent with similar concepts
https://wg21.link/lwg3360




Casey Carter
-
d:lwg3361
LWG3361

New
safe_range<SomeRange&> case
https://wg21.link/lwg3361




Johel Ernesto Guerrero Peña
-
d:lwg3362
LWG3362

WP
Strike stop_source's operator!=
https://wg21.link/lwg3362




Tim Song
-
d:lwg3363
LWG3363

WP
drop_while_view should opt-out of sized_range
https://wg21.link/lwg3363




Johel Ernesto Guerrero Peña
-
d:lwg3364
LWG3364

WP
Initialize data members of ranges and their iterators
https://wg21.link/lwg3364




Johel Ernesto Guerrero Peña
-
d:lwg3365
LWG3365

Tentatively NAD
Rename ref-is-glvalue to deref-is-ref
https://wg21.link/lwg3365




Johel Ernesto Guerrero Peña
-
d:lwg3366
LWG3366

New
Narrowing conversions between integer and integer-class types
https://wg21.link/lwg3366




Casey Carter
-
d:lwg3367
LWG3367

WP
Integer-class conversions should not throw
https://wg21.link/lwg3367




Casey Carter
-
d:lwg3368
LWG3368

Tentatively Ready
Exactly when does size return end - begin?
https://wg21.link/lwg3368




Casey Carter
-
d:lwg3369
LWG3369

WP
span's deduction-guide for built-in arrays doesn't work
https://wg21.link/lwg3369




Stephan T. Lavavej
-
d:lwg337
LWG337

CD1
replace_copy_if's template parameter should be InputIterator
https://wg21.link/lwg337




Detlef Vollmann
-
d:lwg3370
LWG3370

New
§[cstdint.syn]p2 and §[headers]p5 are not sufficiently clear
https://wg21.link/lwg3370




Dawid Pilarski
-
d:lwg3371
LWG3371

WP
visit_format_arg and make_format_args are not hidden friends
https://wg21.link/lwg3371




Tim Song
-
d:lwg3372
LWG3372

WP
vformat_to should not try to deduce Out twice
https://wg21.link/lwg3372




Tim Song
-
d:lwg3373
LWG3373

WP
{to,from}_chars_result and format_to_n_result need the "we really mean what we say" wording
https://wg21.link/lwg3373




Tim Song
-
d:lwg3374
LWG3374

WP
P0653 + P1006 should have made the other std::to_address overload constexpr
https://wg21.link/lwg3374




Billy O'Neal III
-
d:lwg3375
LWG3375

WP
decay in viewable_range should be remove_cvref
https://wg21.link/lwg3375




Casey Carter
-
d:lwg3376
LWG3376

New
"integer-like class type" is too restrictive
https://wg21.link/lwg3376




Jonathan Wakely
-
d:lwg3377
LWG3377

WP
elements_view::iterator befriends a specialization of itself
https://wg21.link/lwg3377




Casey Carter
-
d:lwg3378
LWG3378

New
tuple_size_v/tuple_element_t should be available when tuple_size/tuple_element are
https://wg21.link/lwg3378




Casey Carter
-
d:lwg3379
LWG3379

WP
"safe" in several library names is misleading
https://wg21.link/lwg3379




Casey Carter
-
d:lwg338
LWG338

CD1
is whitespace allowed between `-' and a digit?
https://wg21.link/lwg338




Martin Sebor
-
d:lwg3380
LWG3380

WP
common_type and comparison categories
https://wg21.link/lwg3380




Casey Carter
-
d:lwg3381
LWG3381

WP
begin and data must agree for contiguous_range
https://wg21.link/lwg3381




Casey Carter
-
d:lwg3382
LWG3382

WP
NTTP for pair and array
https://wg21.link/lwg3382




Barry Revzin
-
d:lwg3383
LWG3383

WP
§[time.zone.leap.nonmembers] sys_seconds should be replaced with seconds
https://wg21.link/lwg3383




Jiang An
-
d:lwg3384
LWG3384

WP
transform_view::sentinel has an incorrect operator-
https://wg21.link/lwg3384




Ville Voutilainen
-
d:lwg3385
LWG3385

WP
common_iterator is not sufficiently constrained for non-copyable iterators
https://wg21.link/lwg3385




Corentin Jabot
-
d:lwg3386
LWG3386

New
elements_view needs its own sentinel type
https://wg21.link/lwg3386




Tim Song
-
d:lwg3387
LWG3387

WP
§[range.reverse.view] reverse_view<V> unintentionally requires range<const V>
https://wg21.link/lwg3387




Patrick Palka
-
d:lwg3388
LWG3388

WP
view iterator types have ill-formed <=> operators
https://wg21.link/lwg3388




Jonathan Wakely
-
d:lwg3389
LWG3389

WP
A move-only iterator still does not have a counted_iterator
https://wg21.link/lwg3389




Patrick Palka
-
d:lwg339
LWG339

CD1
definition of bitmask type restricted to clause 27
https://wg21.link/lwg339




Martin Sebor
-
d:lwg3390
LWG3390

WP
make_move_iterator() cannot be used to construct a move_iterator for a move-only iterator
https://wg21.link/lwg3390




Patrick Palka
-
d:lwg3391
LWG3391

New
Problems with counted_iterator/move_iterator::base() const &
https://wg21.link/lwg3391




Patrick Palka
-
d:lwg3392
LWG3392

LEWG
ranges::distance() cannot be used on a move-only iterator with a sized sentinel
https://wg21.link/lwg3392




Patrick Palka
-
d:lwg3393
LWG3393

WP
Missing/incorrect feature test macro for coroutines
https://wg21.link/lwg3393




Barry Revzin
-
d:lwg3394
LWG3394

Tentatively NAD
ranges::basic_istream_view::iterator has an empty iterator_traits
https://wg21.link/lwg3394




Patrick Palka
-
d:lwg3395
LWG3395

WP
Definition for three-way comparison needs to be updated (US 152)
https://wg21.link/lwg3395




Jeff Garland
-
d:lwg3396
LWG3396

WP
Clarify point of reference for source_location::current() (DE 169)
https://wg21.link/lwg3396




Jens Maurer
-
d:lwg3397
LWG3397

WP
ranges::basic_istream_view::iterator should not provide iterator_category
https://wg21.link/lwg3397




Tomasz Kamiński
-
d:lwg3398
LWG3398

WP
tuple_element_t is also wrong for const subrange
https://wg21.link/lwg3398




Casey Carter
-
d:lwg3399
LWG3399

Tentatively NAD
basic_syncbuf::emit() + Qt's #define emit = Big Bada-Boom
https://wg21.link/lwg3399




Marc Mutz
-
d:lwg34
LWG34

TC1
True/falsename() not in ctype<>
https://wg21.link/lwg34




Nathan Myers
-
d:lwg340
LWG340

CD1
interpretation of has_facet<Facet>(loc)
https://wg21.link/lwg340




Martin Sebor
-
d:lwg3400
LWG3400

New
Does is_nothrow_convertible consider destruction of the destination type?
https://wg21.link/lwg3400




Jiang An
-
d:lwg3401
LWG3401

New
Is "as if by" equivalent to "equivalent to"?
https://wg21.link/lwg3401




Casey Carter
-
d:lwg3402
LWG3402

New
Wording for negative_binomial_distribution is unclear as a consequence of LWG 2406 resolution
https://wg21.link/lwg3402




Ahti Leppänen
-
d:lwg3403
LWG3403

New
Domain of ranges::ssize(E) doesn't match ranges::size(E)
https://wg21.link/lwg3403




Jonathan Wakely
-
d:lwg3404
LWG3404

New
Finish removing subrange's conversions from pair-like
https://wg21.link/lwg3404




Casey Carter
-
d:lwg3405
LWG3405

New
common_view's converting constructor is bad, too
https://wg21.link/lwg3405




Casey Carter
-
d:lwg3406
LWG3406

New
elements_view::begin() and elements_view::end() have incompatible constraints
https://wg21.link/lwg3406




Patrick Palka
-
d:lwg3407
LWG3407

New
Some problems with the wording changes of P1739R4
https://wg21.link/lwg3407




Patrick Palka
-
d:lwg3408
LWG3408

New
LWG 3291 reveals deficiencies in counted_iterator
https://wg21.link/lwg3408




Patrick Palka
-
d:lwg3409
LWG3409

New
Too lax description of atomic_ref<T>::required_alignment
https://wg21.link/lwg3409




Andrey Semashev
-
d:lwg341
LWG341

CD1
Vector reallocation and swap
https://wg21.link/lwg341




Anthony Williams
-
d:lwg3410
LWG3410

New
lexicographical_compare_three_way is overspecified
https://wg21.link/lwg3410




Casey Carter
-
d:lwg3411
LWG3411

New
[fund.ts.v3] Contradictory namespace rules in the Library Fundamentals TS
https://wg21.link/lwg3411




Thomas Köppe
-
d:lwg3412
LWG3412

New
§[format.string.std] references to "Unicode encoding" unclear
https://wg21.link/lwg3412




Hubert Tong
-
d:lwg3413
LWG3413

New
[fund.ts.v3] propagate_const's swap's noexcept specification needs to use a trait
https://wg21.link/lwg3413




Thomas Köppe
-
d:lwg342
LWG342

NAD
seek and eofbit
https://wg21.link/lwg342




Howard Hinnant
-
d:lwg343
LWG343

Resolved
Unspecified library header dependencies
https://wg21.link/lwg343




Martin Sebor
-
d:lwg344
LWG344

NAD
grouping + showbase
https://wg21.link/lwg344




Howard Hinnant
-
d:lwg345
LWG345

CD1
type tm in <cwchar>
https://wg21.link/lwg345




Clark Nelson
-
d:lwg346
LWG346

CD1
Some iterator member functions should be const
https://wg21.link/lwg346




Jeremy Siek
-
d:lwg347
LWG347

CD1
locale::category and bitmask requirements
https://wg21.link/lwg347




P.J. Plauger, Nathan Myers
-
d:lwg348
LWG348

Dup
Minor issue with std::pair operator<
https://wg21.link/lwg348




Andy Sawyer
-
d:lwg349
LWG349

CD1
Minor typographical error in ostream_iterator
https://wg21.link/lwg349




Andy Sawyer
-
d:lwg35
LWG35

TC1
No manipulator unitbuf in synopsis
https://wg21.link/lwg35




Nathan Myers
-
d:lwg350
LWG350

Dup
allocator<>::address
https://wg21.link/lwg350




Nathan Myers
-
d:lwg351
LWG351

NAD Editorial
unary_negate and binary_negate: struct or class?
https://wg21.link/lwg351




Dale Riley
-
d:lwg352
LWG352

CD1
missing fpos requirements
https://wg21.link/lwg352




Martin Sebor
-
d:lwg353
LWG353

Resolved
std::pair missing template assignment
https://wg21.link/lwg353




Martin Sebor
-
d:lwg354
LWG354

CD1
Associative container lower/upper bound requirements
https://wg21.link/lwg354




Hans Aberg
-
d:lwg355
LWG355

CD1
Operational semantics for a.back()
https://wg21.link/lwg355




Yaroslav Mironov
-
d:lwg356
LWG356

NAD
Meaning of ctype_base::mask enumerators
https://wg21.link/lwg356




Matt Austern
-
d:lwg357
LWG357

NAD Editorial
<cmath> float functions cannot return HUGE_VAL
https://wg21.link/lwg357




Ray Lischner
-
d:lwg358
LWG358

CD1
interpreting thousands_sep after a decimal_point
https://wg21.link/lwg358




Martin Sebor
-
d:lwg359
LWG359

CD1
num_put<>::do_put (..., bool) undocumented
https://wg21.link/lwg359




Martin Sebor
-
d:lwg36
LWG36

TC1
Iword & pword storage lifetime omitted
https://wg21.link/lwg36




Nathan Myers
-
d:lwg360
LWG360

CD1
locale mandates inefficient implementation
https://wg21.link/lwg360




Martin Sebor
-
d:lwg361
LWG361

NAD
num_get<>::do_get (..., void*&) checks grouping
https://wg21.link/lwg361




Martin Sebor
-
d:lwg362
LWG362

CD1
bind1st/bind2nd type safety
https://wg21.link/lwg362




Andrew Demkin
-
d:lwg363
LWG363

CD1
Missing exception specification in 27.4.2.1.1
https://wg21.link/lwg363




Walter Brown and Marc Paterno
-
d:lwg364
LWG364

CD1
Inconsistent wording in 27.5.2.4.2
https://wg21.link/lwg364




Walter Brown, Marc Paterno
-
d:lwg365
LWG365

CD1
Lack of const-qualification in clause 27
https://wg21.link/lwg365




Walter Brown, Marc Paterno
-
d:lwg366
LWG366

NAD
Excessive const-qualification
https://wg21.link/lwg366




Walter Brown, Marc Paterno
-
d:lwg367
LWG367

NAD
remove_copy/remove_copy_if and Input Iterators
https://wg21.link/lwg367




Anthony Williams
-
d:lwg368
LWG368

NAD Editorial
basic_string::replace has two "Throws" paragraphs
https://wg21.link/lwg368




Beman Dawes
-
d:lwg369
LWG369

CD1
io stream objects and static ctors
https://wg21.link/lwg369




Ruslan Abdikeev
-
d:lwg37
LWG37

TC1
Leftover "global" reference
https://wg21.link/lwg37




Nathan Myers
-
d:lwg370
LWG370

CD1
Minor error in basic_istream::get
https://wg21.link/lwg370




Ray Lischner
-
d:lwg371
LWG371

CD1
Stability of multiset and multimap member functions
https://wg21.link/lwg371




Frank Compagner
-
d:lwg372
LWG372

NAD
Inconsistent description of stdlib exceptions
https://wg21.link/lwg372




Randy Maddox
-
d:lwg373
LWG373

CD1
Are basic_istream and basic_ostream to use (exceptions()&badbit) != 0 ?
https://wg21.link/lwg373




Keith Baker
-
d:lwg374
LWG374

NAD
moneypunct::frac_digits returns int not unsigned
https://wg21.link/lwg374




Ray Lischner
-
d:lwg375
LWG375

CD1
basic_ios should be ios_base in 27.7.1.3
https://wg21.link/lwg375




Ray Lischner
-
d:lwg376
LWG376

CD1
basic_streambuf semantics
https://wg21.link/lwg376




Ray Lischner
-
d:lwg377
LWG377

NAD
basic_string::insert and length_error
https://wg21.link/lwg377




Ray Lischner
-
d:lwg378
LWG378

Dup
locale immutability and locale::operator=()
https://wg21.link/lwg378




Martin Sebor
-
d:lwg379
LWG379

CD1
nonsensical ctype::do_widen() requirement
https://wg21.link/lwg379




Martin Sebor
-
d:lwg38
LWG38

TC1
Facet definition incomplete
https://wg21.link/lwg38




Nathan Myers
-
d:lwg380
LWG380

CD1
typos in codecvt tables 53 and 54
https://wg21.link/lwg380




Martin Sebor
-
d:lwg381
LWG381

CD1
detection of invalid mbstate_t in codecvt
https://wg21.link/lwg381




Martin Sebor
-
d:lwg382
LWG382

NAD
codecvt do_in/out result
https://wg21.link/lwg382




Martin Sebor
-
d:lwg383
LWG383

CD1
Bidirectional iterator assertion typo
https://wg21.link/lwg383




ysapir (submitted via comp.std.c++)
-
d:lwg384
LWG384

CD1
equal_range has unimplementable runtime complexity
https://wg21.link/lwg384




Hans Bos
-
d:lwg385
LWG385

NAD
Does call by value imply the CopyConstructible requirement?
https://wg21.link/lwg385




Matt Austern
-
d:lwg386
LWG386

CD1
Reverse iterator's operator[] has impossible return type
https://wg21.link/lwg386




Matt Austern
-
d:lwg387
LWG387

CD1
std::complex over-encapsulated
https://wg21.link/lwg387




Gabriel Dos Reis
-
d:lwg388
LWG388

NAD
Use of complex as a key in associative containers
https://wg21.link/lwg388




Gabriel Dos Reis
-
d:lwg389
LWG389

CD1
Const overload of valarray::operator[] returns by value
https://wg21.link/lwg389




Gabriel Dos Reis
-
d:lwg39
LWG39

TC1
istreambuf_iterator<>::operator++(int) definition garbled
https://wg21.link/lwg39




Nathan Myers
-
d:lwg390
LWG390

NAD Editorial
CopyConstructible requirements too strict
https://wg21.link/lwg390




Doug Gregor
-
d:lwg391
LWG391

CD1
non-member functions specified as const
https://wg21.link/lwg391




James Kanze
-
d:lwg392
LWG392

NAD
'equivalence' for input iterators
https://wg21.link/lwg392




Corwin Joy
-
d:lwg393
LWG393

NAD Editorial
do_in/do_out operation on state unclear
https://wg21.link/lwg393




Alberto Barbati
-
d:lwg394
LWG394

NAD
behavior of formatted output on failure
https://wg21.link/lwg394




Martin Sebor
-
d:lwg395
LWG395

CD1
inconsistencies in the definitions of rand() and random_shuffle()
https://wg21.link/lwg395




James Kanze
-
d:lwg396
LWG396

CD1
what are characters zero and one
https://wg21.link/lwg396




Martin Sebor
-
d:lwg397
LWG397

NAD Editorial
ostream::sentry dtor throws exceptions
https://wg21.link/lwg397




Martin Sebor
-
d:lwg398
LWG398

NAD
effects of end-of-file on unformatted input functions
https://wg21.link/lwg398




Martin Sebor
-
d:lwg399
LWG399

NAD
volations of unformatted input function requirements
https://wg21.link/lwg399




Martin Sebor
-
d:lwg4
LWG4

NAD
basic_string size_type and difference_type should be implementation defined
https://wg21.link/lwg4




Beman Dawes
-
d:lwg40
LWG40

TC1
Meaningless normative paragraph in examples
https://wg21.link/lwg40




Nathan Myers
-
d:lwg400
LWG400

CD1
redundant type cast in lib.allocator.members
https://wg21.link/lwg400




Markus Mauhart
-
d:lwg401
LWG401

CD1
incorrect type casts in table 32 in lib.allocator.requirements
https://wg21.link/lwg401




Markus Mauhart
-
d:lwg402
LWG402

CD1
wrong new expression in [some_]allocator::construct
https://wg21.link/lwg402




Markus Mauhart
-
d:lwg403
LWG403

CD1
basic_string::swap should not throw exceptions
https://wg21.link/lwg403




Beman Dawes
-
d:lwg404
LWG404

CD1
May a replacement allocation function be declared inline?
https://wg21.link/lwg404




Matt Austern
-
d:lwg405
LWG405

CD1
qsort and POD
https://wg21.link/lwg405




Ray Lischner
-
d:lwg406
LWG406

CD1
vector::insert(s) exception safety
https://wg21.link/lwg406




Dave Abrahams
-
d:lwg407
LWG407

CD1
Can singular iterators be destroyed?
https://wg21.link/lwg407




Nathan Myers
-
d:lwg408
LWG408

NAD Editorial
Is vector<reverse_iterator<char*> > forbidden?
https://wg21.link/lwg408




Nathan Myers
-
d:lwg409
LWG409

CD1
Closing an fstream should clear error state
https://wg21.link/lwg409




Nathan Myers
-
d:lwg41
LWG41

TC1
Ios_base needs clear(), exceptions()
https://wg21.link/lwg41




Nathan Myers
-
d:lwg410
LWG410

CD1
Missing semantics for stack and queue comparison operators
https://wg21.link/lwg410




Hans Bos
-
d:lwg411
LWG411

CD1
Wrong names of set member functions
https://wg21.link/lwg411




Daniel Frey
-
d:lwg412
LWG412

CD1
Typo in 27.4.4.3
https://wg21.link/lwg412




Martin Sebor
-
d:lwg413
LWG413

CD1
Proposed resolution to LDR#64 still wrong
https://wg21.link/lwg413




Bo Persson
-
d:lwg414
LWG414

CD1
Which iterators are invalidated by v.erase()?
https://wg21.link/lwg414




Matt Austern
-
d:lwg415
LWG415

CD1
behavior of std::ws
https://wg21.link/lwg415




Martin Sebor
-
d:lwg416
LWG416

CD1
definitions of XXX_MIN and XXX_MAX macros in climits
https://wg21.link/lwg416




Martin Sebor
-
d:lwg417
LWG417

NAD
what does ctype::do_widen() return on failure
https://wg21.link/lwg417




Martin Sebor
-
d:lwg418
LWG418

NAD
exceptions thrown during iostream cleanup
https://wg21.link/lwg418




Martin Sebor
-
d:lwg419
LWG419

C++11
istream extractors not setting failbit if eofbit is already set
https://wg21.link/lwg419




Martin Sebor
-
d:lwg42
LWG42

TC1
String ctors specify wrong default allocator
https://wg21.link/lwg42




Nathan Myers
-
d:lwg420
LWG420

CD1
is std::FILE a complete type?
https://wg21.link/lwg420




Martin Sebor
-
d:lwg421
LWG421

NAD
is basic_streambuf copy-constructible?
https://wg21.link/lwg421




Martin Sebor
-
d:lwg422
LWG422

CD1
explicit specializations of member functions of class templates
https://wg21.link/lwg422




Martin Sebor
-
d:lwg423
LWG423

Open
Effects of negative streamsize in iostreams
https://wg21.link/lwg423




Martin Sebor
-
d:lwg424
LWG424

NAD Editorial
normative notes
https://wg21.link/lwg424




Martin Sebor
-
d:lwg425
LWG425

CD1
return value of std::get_temporary_buffer
https://wg21.link/lwg425




Martin Sebor
-
d:lwg426
LWG426

CD1
search_n(), fill_n(), and generate_n() with negative n
https://wg21.link/lwg426




Martin Sebor
-
d:lwg427
LWG427

C++11
Stage 2 and rationale of DR 221
https://wg21.link/lwg427




Martin Sebor
-
d:lwg428
LWG428

CD1
string::erase(iterator) validity
https://wg21.link/lwg428




Martin Sebor
-
d:lwg429
LWG429

Dup
typo in basic_ios::clear(iostate)
https://wg21.link/lwg429




Martin Sebor
-
d:lwg43
LWG43

Dup
Locale table correction
https://wg21.link/lwg43




Brendan Kehoe
-
d:lwg430
LWG430

C++11
valarray subset operations
https://wg21.link/lwg430




Martin Sebor
-
d:lwg431
LWG431

Resolved
Swapping containers with unequal allocators
https://wg21.link/lwg431




Matt Austern
-
d:lwg432
LWG432

CD1
stringbuf::overflow() makes only one write position available
https://wg21.link/lwg432




Christian W Brock
-
d:lwg433
LWG433

NAD
Contradiction in specification of unexpected()
https://wg21.link/lwg433




Vyatcheslav Sysoltsev
-
d:lwg434
LWG434

CD1
bitset::to_string() hard to use
https://wg21.link/lwg434




Martin Sebor
-
d:lwg435
LWG435

CD1
bug in DR 25
https://wg21.link/lwg435




Martin Sebor
-
d:lwg436
LWG436

CD1
are cv-qualified facet types valid facets?
https://wg21.link/lwg436




Martin Sebor
-
d:lwg437
LWG437

NAD
Formatted output of function pointers is confusing
https://wg21.link/lwg437




Ivan Godard
-
d:lwg438
LWG438

CD1
Ambiguity in the "do the right thing" clause
https://wg21.link/lwg438




Howard Hinnant
-
d:lwg439
LWG439

NAD
Should facets be copyable?
https://wg21.link/lwg439




Matt Austern
-
d:lwg44
LWG44

CD1
Iostreams use operator== on int_type values
https://wg21.link/lwg44




Nathan Myers
-
d:lwg440
LWG440

NAD
Should std::complex use unqualified transcendentals?
https://wg21.link/lwg440




Matt Austern
-
d:lwg441
LWG441

CD1
Is fpos::state const?
https://wg21.link/lwg441




Vincent Leloup
-
d:lwg442
LWG442

CD1
sentry::operator bool() inconsistent signature
https://wg21.link/lwg442




Vincent Leloup
-
d:lwg443
LWG443

CD1
filebuf::close() inconsistent use of EOF
https://wg21.link/lwg443




Vincent Leloup
-
d:lwg444
LWG444

CD1
Bad use of casts in fstream
https://wg21.link/lwg444




Vincent Leloup
-
d:lwg445
LWG445

CD1
iterator_traits::reference unspecified for some iterator categories
https://wg21.link/lwg445




Dave Abrahams
-
d:lwg446
LWG446

NAD Editorial
Iterator equality between different containers
https://wg21.link/lwg446




Andy Koenig
-
d:lwg447
LWG447

Dup
Wrong template argument for time facets
https://wg21.link/lwg447




Pete Becker
-
d:lwg448
LWG448

CD1
Random Access Iterators over abstract classes
https://wg21.link/lwg448




Dave Abrahams
-
d:lwg449
LWG449

CD1
Library Issue 306 Goes Too Far
https://wg21.link/lwg449




Pete Becker
-
d:lwg45
LWG45

NAD
Stringstreams read/write pointers initial position unclear
https://wg21.link/lwg45




Matthias Mueller
-
d:lwg450
LWG450

Dup
set::find is inconsistent with associative container requirements
https://wg21.link/lwg450




Bill Plauger
-
d:lwg451
LWG451

Dup
Associative erase should return an iterator
https://wg21.link/lwg451




Bill Plauger
-
d:lwg452
LWG452

NAD
locale::combine should be permitted to generate a named locale
https://wg21.link/lwg452




Bill Plauger
-
d:lwg453
LWG453

CD1
basic_stringbuf::seekoff need not always fail for an empty stream
https://wg21.link/lwg453




Bill Plauger
-
d:lwg454
LWG454

NAD
basic_filebuf::open should accept wchar_t names
https://wg21.link/lwg454




Bill Plauger
-
d:lwg455
LWG455

CD1
cerr::tie() and wcerr::tie() are overspecified
https://wg21.link/lwg455




Bill Plauger
-
d:lwg456
LWG456

CD1
Traditional C header files are overspecified
https://wg21.link/lwg456




Bill Plauger
-
d:lwg457
LWG457

CD1
bitset constructor: incorrect number of initialized bits
https://wg21.link/lwg457




Dag Henriksson
-
d:lwg458
LWG458

NAD
24.1.5 contains unintended limitation for operator-
https://wg21.link/lwg458




Daniel Frey
-
d:lwg459
LWG459

NAD
Requirement for widening in stage 2 is overspecification
https://wg21.link/lwg459




Martin Sebor
-
d:lwg46
LWG46

TC1
Minor Annex D errors
https://wg21.link/lwg46




Brendan Kehoe
-
d:lwg460
LWG460

CD1
Default modes missing from basic_fstream member specifications
https://wg21.link/lwg460




Ben Hutchings
-
d:lwg461
LWG461

CD1
time_get hard or impossible to implement
https://wg21.link/lwg461




Bill Plauger
-
d:lwg462
LWG462

NAD
Destroying objects with static storage duration
https://wg21.link/lwg462




Bill Plauger
-
d:lwg463
LWG463

NAD
auto_ptr usability issues
https://wg21.link/lwg463




Rani Sharoni
-
d:lwg464
LWG464

CD1
Suggestion for new member functions in standard containers
https://wg21.link/lwg464




Thorsten Ottosen
-
d:lwg465
LWG465

CD1
Contents of <ciso646>
https://wg21.link/lwg465




Steve Clamage
-
d:lwg466
LWG466

NAD
basic_string ctor should prevent null pointer error
https://wg21.link/lwg466




Daniel Frey
-
d:lwg467
LWG467

CD1
char_traits::lt(), compare(), and memcmp()
https://wg21.link/lwg467




Martin Sebor
-
d:lwg468
LWG468

CD1
unexpected consequences of ios_base::operator void*()
https://wg21.link/lwg468




Martin Sebor
-
d:lwg469
LWG469

CD1
vector<bool> ill-formed relational operators
https://wg21.link/lwg469




Martin Sebor
-
d:lwg47
LWG47

TC1
Imbue() and getloc() Returns clauses swapped
https://wg21.link/lwg47




Matt Austern
-
d:lwg470
LWG470

NAD
accessing containers from their elements' special functions
https://wg21.link/lwg470




Martin Sebor
-
d:lwg471
LWG471

C++11
result of what() implementation-defined
https://wg21.link/lwg471




Martin Sebor
-
d:lwg472
LWG472

Dup
Missing "Returns" clause in std::equal_range
https://wg21.link/lwg472




Prateek R Karandikar
-
d:lwg473
LWG473

C++11
underspecified ctype calls
https://wg21.link/lwg473




Martin Sebor
-
d:lwg474
LWG474

CD1
confusing Footnote 297
https://wg21.link/lwg474




Martin Sebor
-
d:lwg475
LWG475

CD1
May the function object passed to for_each modify the elements of the iterated sequence?
https://wg21.link/lwg475




Stephan T. Lavavej, Jaakko Jarvi
-
d:lwg476
LWG476

NAD
Forward Iterator implied mutability
https://wg21.link/lwg476




Dave Abrahams
-
d:lwg477
LWG477

Dup
Operator-> for const forward iterators
https://wg21.link/lwg477




Dave Abrahams
-
d:lwg478
LWG478

CD1
Should forward iterator requirements table have a line for r->m?
https://wg21.link/lwg478




Dave Abrahams
-
d:lwg479
LWG479

Dup
Container requirements and placement new
https://wg21.link/lwg479




Herb Sutter
-
d:lwg48
LWG48

TC1
Use of non-existent exception constructor
https://wg21.link/lwg48




Matt Austern
-
d:lwg480
LWG480

NAD
unary_function and binary_function should have protected nonvirtual destructors
https://wg21.link/lwg480




Joe Gottman
-
d:lwg481
LWG481

NAD
unique's effects on the range [result, last)
https://wg21.link/lwg481




Andrew Koenig
-
d:lwg482
LWG482

Resolved
Swapping pairs
https://wg21.link/lwg482




Andrew Koenig
-
d:lwg483
LWG483

Dup
Heterogeneous equality and EqualityComparable
https://wg21.link/lwg483




Peter Dimov
-
d:lwg484
LWG484

Open
Convertible to T
https://wg21.link/lwg484




Chris Jefferson
-
d:lwg485
LWG485

Resolved
output iterator insufficiently constrained
https://wg21.link/lwg485




Chris Jefferson
-
d:lwg486
LWG486

Dup
min/max CopyConstructible requirement is too strict
https://wg21.link/lwg486




Dave Abrahams
-
d:lwg487
LWG487

NAD
Allocator::construct is too limiting
https://wg21.link/lwg487




Dhruv Matani
-
d:lwg488
LWG488

CD1
rotate throws away useful information
https://wg21.link/lwg488




Howard Hinnant
-
d:lwg489
LWG489

NAD
std::remove / std::remove_if wrongly specified
https://wg21.link/lwg489




Thomas Mang
-
d:lwg49
LWG49

CD1
Underspecification of ios_base::sync_with_stdio
https://wg21.link/lwg49




Matt Austern
-
d:lwg490
LWG490

NAD
std::unique wrongly specified
https://wg21.link/lwg490




Thomas Mang
-
d:lwg491
LWG491

NAD
std::list<>::unique incorrectly specified
https://wg21.link/lwg491




Thomas Mang
-
d:lwg492
LWG492

NAD
Invalid iterator arithmetic expressions
https://wg21.link/lwg492




Thomas Mang
-
d:lwg493
LWG493

NAD
Undefined Expression in Input Iterator Note Title
https://wg21.link/lwg493




Chris Jefferson
-
d:lwg494
LWG494

NAD
Wrong runtime complexity for associative container's insert and delete
https://wg21.link/lwg494




Hans B os
-
d:lwg495
LWG495

CD1
Clause 22 template parameter requirements
https://wg21.link/lwg495




Beman Dawes
-
d:lwg496
LWG496

CD1
Illegal use of "T" in vector<bool>
https://wg21.link/lwg496




richard@ex-parrot.com
-
d:lwg497
LWG497

CD1
meaning of numeric_limits::traps for floating point types
https://wg21.link/lwg497




Martin Sebor
-
d:lwg498
LWG498

C++11
Requirements for partition() and stable_partition() too strong
https://wg21.link/lwg498




Sean Parent, Joe Gottman
-
d:lwg499
LWG499

NAD Editorial
Std. doesn't seem to require stable_sort() to be stable!
https://wg21.link/lwg499




Prateek Karandikar
-
d:lwg5
LWG5

TC1
String::compare specification questionable
https://wg21.link/lwg5




Jack Reeves
-
d:lwg50
LWG50

TC1
Copy constructor and assignment operator of ios_base
https://wg21.link/lwg50




Matt Austern
-
d:lwg500
LWG500

NAD
do_length cannot be implemented correctly
https://wg21.link/lwg500




Krzysztof Żelechowski
-
d:lwg501
LWG501

NAD
Proposal: strengthen guarantees of lib.comparisons
https://wg21.link/lwg501




Me <anti_spam_email2003@yahoo.com>
-
d:lwg502
LWG502

NAD
Proposition: Clarification of the interaction between a facet and an iterator
https://wg21.link/lwg502




Christopher Conrade Zseleghovski
-
d:lwg503
LWG503

NAD
more on locales
https://wg21.link/lwg503




P.J. Plauger
-
d:lwg504
LWG504

NAD Editorial
Integer types in pseudo-random number engine requirements
https://wg21.link/lwg504




Walter Brown
-
d:lwg505
LWG505

CD1
Result_type in random distribution requirements
https://wg21.link/lwg505




Walter Brown
-
d:lwg506
LWG506

NAD
Requirements of Distribution parameter for variate_generator
https://wg21.link/lwg506




Walter Brown
-
d:lwg507
LWG507

CD1
Missing requirement for variate_generator::operator()
https://wg21.link/lwg507




Walter Brown
-
d:lwg508
LWG508

CD1
Bad parameters for ranlux64_base_01
https://wg21.link/lwg508




Walter Brown
-
d:lwg509
LWG509

NAD
Uniform_int template parameters
https://wg21.link/lwg509




Walter Brown
-
d:lwg51
LWG51

TC1
Requirement to not invalidate iterators missing
https://wg21.link/lwg51




David Vandevoorde
-
d:lwg510
LWG510

NAD
Input_type for bernoulli_distribution
https://wg21.link/lwg510




Walter Brown
-
d:lwg511
LWG511

NAD
Input_type for binomial_distribution
https://wg21.link/lwg511




Walter Brown
-
d:lwg512
LWG512

NAD Editorial
Seeding subtract_with_carry_01 from a single unsigned long
https://wg21.link/lwg512




Walter Brown
-
d:lwg513
LWG513

NAD Editorial
Size of state for subtract_with_carry_01
https://wg21.link/lwg513




Walter Brown
-
d:lwg514
LWG514

NAD Editorial
Size of state for subtract_with_carry
https://wg21.link/lwg514




Walter Brown
-
d:lwg515
LWG515

NAD
Random number engine traits
https://wg21.link/lwg515




Walter Brown
-
d:lwg516
LWG516

NAD Editorial
Seeding subtract_with_carry_01 using a generator
https://wg21.link/lwg516




Walter Brown
-
d:lwg517
LWG517

NAD
Should include name in external representation
https://wg21.link/lwg517




Walter Brown
-
d:lwg518
LWG518

CD1
Are insert and erase stable for unordered_multiset and unordered_multimap?
https://wg21.link/lwg518




Matt Austern
-
d:lwg519
LWG519

CD1
Data() undocumented
https://wg21.link/lwg519




Pete Becker
-
d:lwg52
LWG52

TC1
Small I/O problems
https://wg21.link/lwg52




Matt Austern
-
d:lwg520
LWG520

CD1
Result_of and pointers to data members
https://wg21.link/lwg520




Pete Becker
-
d:lwg521
LWG521

CD1
Garbled requirements for argument_type in reference_wrapper
https://wg21.link/lwg521




Pete Becker
-
d:lwg522
LWG522

CD1
Tuple doesn't define swap
https://wg21.link/lwg522




Andy Koenig
-
d:lwg523
LWG523

Open
regex case-insensitive character ranges are unimplementable as specified
https://wg21.link/lwg523




Eric Niebler
-
d:lwg524
LWG524

CD1
regex named character classes and case-insensitivity don't mix
https://wg21.link/lwg524




Eric Niebler
-
d:lwg525
LWG525

Resolved
type traits definitions not clear
https://wg21.link/lwg525




Robert Klarer
-
d:lwg526
LWG526

NAD
Is it undefined if a function in the standard changes in parameters?
https://wg21.link/lwg526




Chris Jefferson
-
d:lwg527
LWG527

CD1
tr1::bind has lost its Throws clause
https://wg21.link/lwg527




Peter Dimov
-
d:lwg528
LWG528

NAD
const_iterator iterator issue when they are the same type
https://wg21.link/lwg528




Paolo Carlini
-
d:lwg529
LWG529

NAD Editorial
The standard encourages redundant and confusing preconditions
https://wg21.link/lwg529




David Abrahams
-
d:lwg53
LWG53

TC1
Basic_ios destructor unspecified
https://wg21.link/lwg53




Matt Austern
-
d:lwg530
LWG530

CD1
Must elements of a string be contiguous?
https://wg21.link/lwg530




Matt Austern
-
d:lwg531
LWG531

CD1
array forms of unformatted input functions
https://wg21.link/lwg531




Martin Sebor
-
d:lwg532
LWG532

LEWG
Tuple comparison
https://wg21.link/lwg532




David Abrahams
-
d:lwg533
LWG533

CD1
typo in 2.2.3.10/1
https://wg21.link/lwg533




Paolo Carlini
-
d:lwg534
LWG534

CD1
Missing basic_string members
https://wg21.link/lwg534




Alisdair Meredith
-
d:lwg535
LWG535

CD1
std::string::swap specification poorly worded
https://wg21.link/lwg535




Beman Dawes
-
d:lwg536
LWG536

Dup
Container iterator constructor and explicit convertibility
https://wg21.link/lwg536




Joaquín M López Muñoz
-
d:lwg537
LWG537

CD1
Typos in the signatures in 27.6.1.3/42-43 and 27.6.2.4
https://wg21.link/lwg537




Paolo Carlini
-
d:lwg538
LWG538

CD1
241 again: Does unique_copy() require CopyConstructible and Assignable?
https://wg21.link/lwg538




Howard Hinnant
-
d:lwg539
LWG539

C++11
partial_sum and adjacent_difference should mention requirements
https://wg21.link/lwg539




Marc Schoolderman
-
d:lwg54
LWG54

TC1
Basic_streambuf's destructor
https://wg21.link/lwg54




Matt Austern
-
d:lwg540
LWG540

CD1
shared_ptr<void>::operator*()
https://wg21.link/lwg540




Martin Sebor
-
d:lwg541
LWG541

CD1
shared_ptr template assignment and void
https://wg21.link/lwg541




Martin Sebor
-
d:lwg542
LWG542

CD1
shared_ptr observers
https://wg21.link/lwg542




Martin Sebor
-
d:lwg543
LWG543

CD1
valarray slice default constructor
https://wg21.link/lwg543




Howard Hinnant
-
d:lwg544
LWG544

NAD Editorial
minor NULL problems in C.2
https://wg21.link/lwg544




Martin Sebor
-
d:lwg545
LWG545

CD1
When is a deleter deleted?
https://wg21.link/lwg545




Matt Austern
-
d:lwg546
LWG546

NAD
[tr1] _Longlong and _ULonglong are integer types
https://wg21.link/lwg546




Matt Austern
-
d:lwg547
LWG547

NAD
division should be floating-point, not integer
https://wg21.link/lwg547




Matt Austern
-
d:lwg548
LWG548

NAD
May random_device block?
https://wg21.link/lwg548




Matt Austern
-
d:lwg549
LWG549

NAD Editorial
Undefined variable in binomial_distribution
https://wg21.link/lwg549




Matt Austern
-
d:lwg55
LWG55

TC1
Invalid stream position is undefined
https://wg21.link/lwg55




Matt Austern
-
d:lwg550
LWG550

CD1
What should the return type of pow(float,int) be?
https://wg21.link/lwg550




Howard Hinnant
-
d:lwg551
LWG551

CD1
<ccomplex>
https://wg21.link/lwg551




Howard Hinnant
-
d:lwg552
LWG552

CD1
random_shuffle and its generator
https://wg21.link/lwg552




Martin Sebor
-
d:lwg553
LWG553

NAD Editorial
very minor editorial change intptr_t / uintptr_t
https://wg21.link/lwg553




Paolo Carlini
-
d:lwg554
LWG554

NAD
Problem with lwg DR 184 numeric_limits<bool>
https://wg21.link/lwg554




Howard Hinnant
-
d:lwg555
LWG555

NAD Editorial
[tr1] 8.21/1: typo
https://wg21.link/lwg555




Paolo Carlini
-
d:lwg556
LWG556

C++11
Is Compare a BinaryPredicate?
https://wg21.link/lwg556




Martin Sebor
-
d:lwg557
LWG557

NAD Editorial
TR1: div(_Longlong, _Longlong) vs div(intmax_t, intmax_t)
https://wg21.link/lwg557




Paolo Carlini
-
d:lwg558
LWG558

NAD Editorial
lib.input.iterators Defect
https://wg21.link/lwg558




David Abrahams
-
d:lwg559
LWG559

CD1
numeric_limits<const T>
https://wg21.link/lwg559




Martin Sebor
-
d:lwg56
LWG56

TC1
Showmanyc's return type
https://wg21.link/lwg56




Matt Austern
-
d:lwg560
LWG560

NAD
User-defined allocators without default constructor
https://wg21.link/lwg560




Sergey P. Derevyago
-
d:lwg561
LWG561

CD1
inserter overly generic
https://wg21.link/lwg561




Howard Hinnant
-
d:lwg562
LWG562

CD1
stringbuf ctor inefficient
https://wg21.link/lwg562




Martin Sebor
-
d:lwg563
LWG563

CD1
stringbuf seeking from end
https://wg21.link/lwg563




Martin Sebor
-
d:lwg564
LWG564

C++11
stringbuf seekpos underspecified
https://wg21.link/lwg564




Martin Sebor
-
d:lwg565
LWG565

C++11
xsputn inefficient
https://wg21.link/lwg565




Martin Sebor
-
d:lwg566
LWG566

CD1
array forms of unformatted input function undefined for zero-element arrays
https://wg21.link/lwg566




Martin Sebor
-
d:lwg567
LWG567

CD1
streambuf inserter and extractor should be unformatted
https://wg21.link/lwg567




Martin Sebor
-
d:lwg568
LWG568

NAD
[tr1] log2 overloads missing
https://wg21.link/lwg568




Paolo Carlini
-
d:lwg569
LWG569

Dup
Postcondition for basic_ios::clear(iostate) incorrectly stated
https://wg21.link/lwg569




Seungbeom Kim
-
d:lwg57
LWG57

TC1
Mistake in char_traits
https://wg21.link/lwg57




Matt Austern
-
d:lwg570
LWG570

NAD
Request adding additional explicit specializations of char_traits
https://wg21.link/lwg570




Jack Reeves
-
d:lwg571
LWG571

NAD Editorial
Update C90 references to C99?
https://wg21.link/lwg571




Beman Dawes
-
d:lwg572
LWG572

NAD
Oops, we gave 507 WP status
https://wg21.link/lwg572




Howard Hinnant
-
d:lwg573
LWG573

NAD
C++0x file positioning should handle modern file sizes
https://wg21.link/lwg573




Beman Dawes
-
d:lwg574
LWG574

CD1
DR 369 Contradicts Text
https://wg21.link/lwg574




Pete Becker
-
d:lwg575
LWG575

CD1
the specification of ~shared_ptr is MT-unfriendly, makes implementation assumptions
https://wg21.link/lwg575




Peter Dimov
-
d:lwg576
LWG576

CD1
find_first_of is overconstrained
https://wg21.link/lwg576




Doug Gregor
-
d:lwg577
LWG577

CD1
upper_bound(first, last, ...) cannot return last
https://wg21.link/lwg577




Seungbeom Kim
-
d:lwg578
LWG578

CD1
purpose of hint to allocator::allocate()
https://wg21.link/lwg578




Martin Sebor
-
d:lwg579
LWG579

NAD
erase(iterator) for unordered containers should not return an iterator
https://wg21.link/lwg579




Joaquín M López Muñoz
-
d:lwg58
LWG58

NAD
Extracting a char from a wide-oriented stream
https://wg21.link/lwg58




Matt Austern
-
d:lwg580
LWG580

NAD Editorial
unused allocator members
https://wg21.link/lwg580




Martin Sebor
-
d:lwg581
LWG581

CD1
flush() not unformatted function
https://wg21.link/lwg581




Martin Sebor
-
d:lwg582
LWG582

NAD
specialized algorithms and volatile storage
https://wg21.link/lwg582




Martin Sebor
-
d:lwg583
LWG583

NAD
div() for unsigned integral types
https://wg21.link/lwg583




Beman Dawes
-
d:lwg584
LWG584

NAD
missing int pow(int,int) functionality
https://wg21.link/lwg584




Beman Dawes
-
d:lwg585
LWG585

NAD
facet error reporting
https://wg21.link/lwg585




Martin Sebor, Paolo Carlini
-
d:lwg586
LWG586

CD1
string inserter not a formatted function
https://wg21.link/lwg586




Martin Sebor
-
d:lwg587
LWG587

NAD Editorial
iststream ctor missing description
https://wg21.link/lwg587




Martin Sebor
-
d:lwg588
LWG588

NAD
requirements on zero sized tr1::arrays and other details
https://wg21.link/lwg588




Gennaro Prota
-
d:lwg589
LWG589

CD1
Requirements on iterators of member template functions of containers
https://wg21.link/lwg589




Peter Dimov
-
d:lwg59
LWG59

TC1
Ambiguity in specification of gbump
https://wg21.link/lwg59




Matt Austern
-
d:lwg590
LWG590

NAD Editorial
Type traits implementation latitude should be removed for C++0x
https://wg21.link/lwg590




Beman Dawes
-
d:lwg591
LWG591

NAD Editorial
Misleading "built-in
https://wg21.link/lwg591




whyglinux
-
d:lwg592
LWG592

NAD Editorial
Incorrect treatment of rdbuf()->close() return type
https://wg21.link/lwg592




Christopher Kohlhoff
-
d:lwg593
LWG593

CD1
__STDC_CONSTANT_MACROS
https://wg21.link/lwg593




Walter Brown
-
d:lwg594
LWG594

Resolved
Disadvantages of defining Swappable in terms of CopyConstructible and Assignable
https://wg21.link/lwg594




Niels Dekker
-
d:lwg595
LWG595

CD1
TR1/C++0x: fabs(complex<T>) redundant / wrongly specified
https://wg21.link/lwg595




Stefan Große Pawig
-
d:lwg596
LWG596

CD1
27.8.1.3 Table 112 omits "a+" and "a+b" modes
https://wg21.link/lwg596




Thomas Plum
-
d:lwg597
LWG597

NAD
[dec.tr] The notion of 'promotion' cannot be emulated by user-defined types.
https://wg21.link/lwg597




Daveed Vandevoorde
-
d:lwg598
LWG598

TRDec
[dec.tr] Conversion to integral should truncate, not round.
https://wg21.link/lwg598




Daniel Krugler
-
d:lwg599
LWG599

TRDec
[dec.tr] Say "octets" instead of "bytes."
https://wg21.link/lwg599




Daniel Krugler
-
d:lwg6
LWG6

NAD
File position not an offset unimplementable
https://wg21.link/lwg6




Matt Austern
-
d:lwg60
LWG60

TC1
What is a formatted input function?
https://wg21.link/lwg60




Matt Austern
-
d:lwg600
LWG600

TRDec
[dec.tr] Wrong parameters for wcstod* functions
https://wg21.link/lwg600




Daniel Krugler
-
d:lwg601
LWG601

TRDec
[dec.tr] numeric_limits typos
https://wg21.link/lwg601




Daniel Krugler
-
d:lwg602
LWG602

TRDec
[dec.tr] "generic floating type" not defined.
https://wg21.link/lwg602




Daniel Krügler
-
d:lwg603
LWG603

TRDec
[dec.tr] Trivially simplifying decimal classes.
https://wg21.link/lwg603




Martin Sebor
-
d:lwg604
LWG604

TRDec
[dec.tr] Storing a reference to a facet unsafe.
https://wg21.link/lwg604




Martin Sebor
-
d:lwg605
LWG605

TRDec
[dec.tr] <decfloat.h> doesn't live here anymore.
https://wg21.link/lwg605




Robert Klarer
-
d:lwg606
LWG606

NAD
[dec.tr] allow narrowing conversions
https://wg21.link/lwg606




Martin Sebor
-
d:lwg607
LWG607

CD1
Concern about short seed vectors
https://wg21.link/lwg607




Charles Karney
-
d:lwg608
LWG608

CD1
Unclear seed_seq construction details
https://wg21.link/lwg608




Charles Karney
-
d:lwg609
LWG609

CD1
missing static const
https://wg21.link/lwg609




Walter E. Brown
-
d:lwg61
LWG61

TC1
Ambiguity in iostreams exception policy
https://wg21.link/lwg61




Matt Austern
-
d:lwg610
LWG610

CD1
Suggested non-normative note for C++0x
https://wg21.link/lwg610




Scott Meyers
-
d:lwg611
LWG611

CD1
Standard library templates and incomplete types
https://wg21.link/lwg611




Nicola Musatti
-
d:lwg612
LWG612

CD1
numeric_limits::is_modulo insufficiently defined
https://wg21.link/lwg612




Chris Jefferson
-
d:lwg613
LWG613

CD1
max_digits10 missing from numeric_limits
https://wg21.link/lwg613




Bo Persson
-
d:lwg614
LWG614

NAD
std::string allocator requirements still inconsistent
https://wg21.link/lwg614




Bo Persson
-
d:lwg615
LWG615

NAD Editorial
Inconsistencies in Section 21.4
https://wg21.link/lwg615




Bo Persson
-
d:lwg616
LWG616

CD1
missing 'typename' in ctype_byname
https://wg21.link/lwg616




Bo Persson
-
d:lwg617
LWG617

NAD
std::array is a sequence that doesn't satisfy the sequence requirements?
https://wg21.link/lwg617




Bo Persson
-
d:lwg618
LWG618

CD1
valarray::cshift() effects on empty array
https://wg21.link/lwg618




Gabriel Dos Reis
-
d:lwg619
LWG619

CD1
Longjmp wording problem
https://wg21.link/lwg619




Lawrence Crowl
-
d:lwg62
LWG62

TC1
Sync's return value
https://wg21.link/lwg62




Matt Austern
-
d:lwg620
LWG620

CD1
valid uses of empty valarrays
https://wg21.link/lwg620




Martin Sebor
-
d:lwg621
LWG621

CD1
non-const copy assignment operators of helper arrays
https://wg21.link/lwg621




Martin Sebor
-
d:lwg622
LWG622

CD1
behavior of filebuf dtor and close on error
https://wg21.link/lwg622




Martin Sebor
-
d:lwg623
LWG623

CD1
pubimbue forbidden to call imbue
https://wg21.link/lwg623




Martin Sebor
-
d:lwg624
LWG624

CD1
valarray assignment and arrays of unequal length
https://wg21.link/lwg624




Martin Sebor
-
d:lwg625
LWG625

Resolved
Mixed up Effects and Returns clauses
https://wg21.link/lwg625




Martin Sebor
-
d:lwg626
LWG626

NAD Editorial
new Remark clauses not documented
https://wg21.link/lwg626




Martin Sebor
-
d:lwg627
LWG627

NAD
Low memory and exceptions
https://wg21.link/lwg627




P.J. Plauger
-
d:lwg628
LWG628

CD1
Inconsistent definition of basic_regex constructor
https://wg21.link/lwg628




Bo Persson
-
d:lwg629
LWG629

CD1
complex<T> insertion and locale dependence
https://wg21.link/lwg629




Gabriel Dos Reis
-
d:lwg63
LWG63

TC1
Exception-handling policy for unformatted output
https://wg21.link/lwg63




Matt Austern
-
d:lwg630
LWG630

C++11
arrays of valarray
https://wg21.link/lwg630




Martin Sebor
-
d:lwg631
LWG631

NAD
conflicting requirements for BinaryPredicate
https://wg21.link/lwg631




James Kanze
-
d:lwg632
LWG632

NAD
Time complexity of size() for std::set
https://wg21.link/lwg632




Lionel B
-
d:lwg633
LWG633

NAD Editorial
Return clause mentions undefined "type()"
https://wg21.link/lwg633




Daniel Krügler
-
d:lwg634
LWG634

CD1
allocator.address() doesn't work for types overloading operator&
https://wg21.link/lwg634




Howard Hinnant
-
d:lwg635
LWG635

Resolved
domain of allocator::address
https://wg21.link/lwg635




Howard Hinnant
-
d:lwg636
LWG636

NAD Editorial
26.5.2.3 valarray::operator[]
https://wg21.link/lwg636




Bo Persson
-
d:lwg637
LWG637

NAD Editorial
§[c.math]/10 inconsistent return values
https://wg21.link/lwg637




Bo Persson
-
d:lwg638
LWG638

CD1
deque end invalidation during erase
https://wg21.link/lwg638




Steve LoBasso
-
d:lwg639
LWG639

NAD
Still problems with exceptions during streambuf IO
https://wg21.link/lwg639




Daniel Krügler
-
d:lwg64
LWG64

TC1
Exception handling in basic_istream::operator>>(basic_streambuf*)
https://wg21.link/lwg64




Matt Austern
-
d:lwg640
LWG640

CD1
27.6.2.5.2 does not handle (unsigned) long long
https://wg21.link/lwg640




Daniel Krügler
-
d:lwg641
LWG641

NAD Editorial
Editorial fix for 27.6.4 (N2134)
https://wg21.link/lwg641




Daniel Krügler
-
d:lwg642
LWG642

NAD Editorial
Invalidated fstream footnotes in N2134
https://wg21.link/lwg642




Daniel Krügler
-
d:lwg643
LWG643

CD1
Impossible "as if" clauses
https://wg21.link/lwg643




Daniel Krügler
-
d:lwg644
LWG644

NAD
Possible typos in 'function' description
https://wg21.link/lwg644




Bo Persson
-
d:lwg645
LWG645

NAD Editorial
Missing members in match_results
https://wg21.link/lwg645




Daniel Krügler
-
d:lwg646
LWG646

CD1
const incorrect match_result members
https://wg21.link/lwg646




Daniel Krügler
-
d:lwg647
LWG647

NAD Editorial
Inconsistent regex_search params
https://wg21.link/lwg647




Daniel Krügler
-
d:lwg648
LWG648

NAD Editorial
regex_iterator c'tor needs clarification/editorial fix
https://wg21.link/lwg648




Daniel Krügler
-
d:lwg649
LWG649

NAD Editorial
Several typos in regex_token_iterator constructors
https://wg21.link/lwg649




Daniel Krügler
-
d:lwg65
LWG65

NAD
Underspecification of strstreambuf::seekoff
https://wg21.link/lwg65




Matt Austern
-
d:lwg650
LWG650

CD1
regex_token_iterator and const correctness
https://wg21.link/lwg650




Daniel Krügler
-
d:lwg651
LWG651

CD1
Missing preconditions for regex_token_iterator c'tors
https://wg21.link/lwg651




Daniel Krügler
-
d:lwg652
LWG652

CD1
regex_iterator and const correctness
https://wg21.link/lwg652




Daniel Krügler
-
d:lwg653
LWG653

NAD
Library reserved names
https://wg21.link/lwg653




Alisdair Meredith
-
d:lwg654
LWG654

CD1
Missing IO roundtrip for random number engines
https://wg21.link/lwg654




Daniel Krügler
-
d:lwg655
LWG655

CD1
Signature of generate_canonical not useful
https://wg21.link/lwg655




Daniel Krügler
-
d:lwg656
LWG656

NAD Editorial
Typo in subtract_with_carry_engine declaration
https://wg21.link/lwg656




Daniel Krügler
-
d:lwg657
LWG657

NAD
unclear requirement about header inclusion
https://wg21.link/lwg657




Gennaro Prota
-
d:lwg658
LWG658

Resolved
Two unspecified function comparators in [function.objects]
https://wg21.link/lwg658




Daniel Krügler
-
d:lwg659
LWG659

C++11
istreambuf_iterator should have an operator->()
https://wg21.link/lwg659




Niels Dekker
-
d:lwg66
LWG66

TC1
Strstreambuf::setbuf
https://wg21.link/lwg66




Matt Austern
-
d:lwg660
LWG660

CD1
Missing Bitwise Operations
https://wg21.link/lwg660




Beman Dawes
-
d:lwg661
LWG661

CD1
New 27.6.1.2.2 changes make special extractions useless
https://wg21.link/lwg661




Daniel Krügler
-
d:lwg662
LWG662

NAD
Inconsistent handling of incorrectly-placed thousands separators
https://wg21.link/lwg662




Cosmin Truta
-
d:lwg663
LWG663

NAD
Complexity Requirements
https://wg21.link/lwg663




Thomas Plum
-
d:lwg664
LWG664

CD1
do_unshift for codecvt<char, char, mbstate_t>
https://wg21.link/lwg664




Thomas Plum
-
d:lwg665
LWG665

CD1
do_unshift return value
https://wg21.link/lwg665




Thomas Plum
-
d:lwg666
LWG666

CD1
moneypunct::do_curr_symbol()
https://wg21.link/lwg666




Thomas Plum
-
d:lwg667
LWG667

NAD
money_get's widened minus sign
https://wg21.link/lwg667




Thomas Plum
-
d:lwg668
LWG668

NAD
money_get's empty minus sign
https://wg21.link/lwg668




Thomas Plum
-
d:lwg669
LWG669

NAD
Equivalent postive and negative signs in money_get
https://wg21.link/lwg669




Thomas Plum
-
d:lwg67
LWG67

Dup
Setw useless for strings
https://wg21.link/lwg67




Steve Clamage
-
d:lwg670
LWG670

Dup
money_base::pattern and space
https://wg21.link/lwg670




Thomas Plum
-
d:lwg671
LWG671

C++11
precision of hexfloat
https://wg21.link/lwg671




John Salmon
-
d:lwg672
LWG672

CD1
Swappable requirements need updating
https://wg21.link/lwg672




Howard Hinnant
-
d:lwg673
LWG673

CD1
unique_ptr update
https://wg21.link/lwg673




Howard Hinnant
-
d:lwg674
LWG674

CD1
shared_ptr interface changes for consistency with N1856
https://wg21.link/lwg674




Peter Dimov
-
d:lwg675
LWG675

CD1
Move assignment of containers
https://wg21.link/lwg675




Howard Hinnant
-
d:lwg676
LWG676

C++11
Moving the unordered containers
https://wg21.link/lwg676




Howard Hinnant
-
d:lwg677
LWG677

CD1
Weaknesses in seed_seq::randomize [rand.util.seedseq]
https://wg21.link/lwg677




Charles Karney
-
d:lwg678
LWG678

CD1
Changes for [rand.req.eng]
https://wg21.link/lwg678




Charles Karney
-
d:lwg679
LWG679

CD1
resize parameter by value
https://wg21.link/lwg679




Howard Hinnant
-
d:lwg68
LWG68

TC1
Extractors for char* should store null at end
https://wg21.link/lwg68




Angelika Langer
-
d:lwg680
LWG680

CD1
move_iterator operator-> return
https://wg21.link/lwg680




Howard Hinnant
-
d:lwg681
LWG681

CD1
Operator functions impossible to compare are defined in [re.submatch.op]
https://wg21.link/lwg681




Nozomu Katoo
-
d:lwg682
LWG682

CD1
basic_regex ctor takes InputIterator or ForwardIterator?
https://wg21.link/lwg682




Eric Niebler
-
d:lwg683
LWG683

NAD Editorial
regex_token_iterator summary error
https://wg21.link/lwg683




Eric Niebler
-
d:lwg684
LWG684

NAD Editorial
Unclear which members of match_results should be used in comparison
https://wg21.link/lwg684




Nozomu Katoo
-
d:lwg685
LWG685

CD1
reverse_iterator/move_iterator difference has invalid signatures
https://wg21.link/lwg685




Bo Persson
-
d:lwg686
LWG686

NAD
unique_ptr and shared_ptr fail to specify non-convertibility to int for unspecified-bool-type
https://wg21.link/lwg686




Beman Dawes
-
d:lwg687
LWG687

CD1
shared_ptr conversion constructor not constrained
https://wg21.link/lwg687




Peter Dimov
-
d:lwg688
LWG688

C++11
reference_wrapper, cref unsafe, allow binding to rvalues
https://wg21.link/lwg688




Peter Dimov
-
d:lwg689
LWG689

CD1
reference_wrapper constructor overly constrained
https://wg21.link/lwg689




Peter Dimov
-
d:lwg69
LWG69

TC1
Must elements of a vector be contiguous?
https://wg21.link/lwg69




Andrew Koenig
-
d:lwg690
LWG690

NAD Editorial
abs(long long) should return long long
https://wg21.link/lwg690




Niels Dekker
-
d:lwg691
LWG691

CD1
const_local_iterator cbegin, cend missing from TR1
https://wg21.link/lwg691




Joaquín M López Muñoz
-
d:lwg692
LWG692

CD1
get_money and put_money should be formatted I/O functions
https://wg21.link/lwg692




Martin Sebor
-
d:lwg693
LWG693

CD1
std::bitset::all() missing
https://wg21.link/lwg693




Martin Sebor
-
d:lwg694
LWG694

CD1
std::bitset and long long
https://wg21.link/lwg694




Martin Sebor
-
d:lwg695
LWG695

CD1
ctype<char>::classic_table() not accessible
https://wg21.link/lwg695




Martin Sebor
-
d:lwg696
LWG696

C++11
istream::operator>>(int&) broken
https://wg21.link/lwg696




Martin Sebor
-
d:lwg697
LWG697

Resolved
New <system_error> header leads to name clashes
https://wg21.link/lwg697




Daniel Krügler
-
d:lwg698
LWG698

CD1
system_error needs const char* constructors
https://wg21.link/lwg698




Daniel Krügler
-
d:lwg699
LWG699

CD1
N2111 changes min/max
https://wg21.link/lwg699




P.J. Plauger
-
d:lwg7
LWG7

TC1
String clause minor problems
https://wg21.link/lwg7




Matt Austern
-
d:lwg70
LWG70

TC1
Uncaught_exception() missing throw() specification
https://wg21.link/lwg70




Steve Clamage
-
d:lwg700
LWG700

CD1
N1856 defines struct identity
https://wg21.link/lwg700




P.J. Plauger
-
d:lwg701
LWG701

NAD
[tr1] assoc laguerre poly's
https://wg21.link/lwg701




Christopher Crawford
-
d:lwg702
LWG702

NAD
[tr1] Restriction in associated Legendre functions
https://wg21.link/lwg702




Christopher Crawford
-
d:lwg703
LWG703

CD1
map::at() need a complexity specification
https://wg21.link/lwg703




Joe Gottman
-
d:lwg704
LWG704

C++11
MoveAssignable requirement for container value type overly strict
https://wg21.link/lwg704




Howard Hinnant
-
d:lwg705
LWG705

CD1
type-trait decay incompletely specified
https://wg21.link/lwg705




Thorsten Ottosen
-
d:lwg706
LWG706

CD1
make_pair() should behave as make_tuple() wrt. reference_wrapper()
https://wg21.link/lwg706




Thorsten Ottosen
-
d:lwg707
LWG707

NAD
null pointer constant for exception_ptr
https://wg21.link/lwg707




Jens Maurer
-
d:lwg708
LWG708

NAD
Locales need to be per thread and updated for POSIX changes
https://wg21.link/lwg708




Peter Dimov
-
d:lwg709
LWG709

CD1
char_traits::not_eof has wrong signature
https://wg21.link/lwg709




Bo Persson
-
d:lwg71
LWG71

TC1
Do_get_monthname synopsis missing argument
https://wg21.link/lwg71




Nathan Myers
-
d:lwg710
LWG710

CD1
Missing postconditions
https://wg21.link/lwg710




Peter Dimov
-
d:lwg711
LWG711

C++11
Contradiction in empty shared_ptr
https://wg21.link/lwg711




Peter Dimov
-
d:lwg712
LWG712

CD1
seed_seq::size no longer useful
https://wg21.link/lwg712




Marc Paterno
-
d:lwg713
LWG713

CD1
sort() complexity is too lax
https://wg21.link/lwg713




Matt Austern
-
d:lwg714
LWG714

CD1
search_n complexity is too lax
https://wg21.link/lwg714




Matt Austern
-
d:lwg715
LWG715

CD1
minmax_element complexity is too lax
https://wg21.link/lwg715




Matt Austern
-
d:lwg716
LWG716

C++11
Production in [re.grammar] not actually modified
https://wg21.link/lwg716




Stephan T. Lavavej
-
d:lwg717
LWG717

NAD Editorial
Incomplete valarray::operator[] specification in [valarray.access]
https://wg21.link/lwg717




Daniel Krügler
-
d:lwg718
LWG718

NAD Editorial
basic_string is not a sequence
https://wg21.link/lwg718




Bo Persson
-
d:lwg719
LWG719

Resolved
std::is_literal type traits should be provided
https://wg21.link/lwg719




Daniel Krügler
-
d:lwg72
LWG72

Dup
Do_convert phantom member function
https://wg21.link/lwg72




Nathan Myers
-
d:lwg720
LWG720

CD1
Omissions in constexpr usages
https://wg21.link/lwg720




Daniel Krügler
-
d:lwg721
LWG721

NAD
wstring_convert inconsistensies
https://wg21.link/lwg721




Bo Persson
-
d:lwg722
LWG722

CD1
Missing [c.math] functions nanf and nanl
https://wg21.link/lwg722




Daniel Krügler
-
d:lwg723
LWG723

C++11
basic_regex should be moveable
https://wg21.link/lwg723




Daniel Krügler
-
d:lwg724
LWG724

C++11
DefaultConstructible is not defined
https://wg21.link/lwg724




Pablo Halpern
-
d:lwg725
LWG725

NAD Editorial
Optional sequence container requirements column label
https://wg21.link/lwg725




David Abrahams
-
d:lwg726
LWG726

NAD
Missing regex_replace() overloads
https://wg21.link/lwg726




Stephan T. Lavavej
-
d:lwg727
LWG727

C++11
regex_replace() doesn't accept basic_strings with custom traits and allocators
https://wg21.link/lwg727




Stephan T. Lavavej
-
d:lwg728
LWG728

CD1
Problem in [rand.eng.mers]/6
https://wg21.link/lwg728




Stephan Tolksdorf
-
d:lwg729
LWG729

NAD
Problem in [rand.req.eng]/3
https://wg21.link/lwg729




Stephan Tolksdorf
-
d:lwg73
LWG73

NAD
is_open should be const
https://wg21.link/lwg73




Matt Austern
-
d:lwg730
LWG730

NAD
Comment on [rand.req.adapt]/3 e)
https://wg21.link/lwg730




Stephan Tolksdorf
-
d:lwg731
LWG731

NAD
proposal for a customizable seed_seq
https://wg21.link/lwg731




Stephan Tolksdorf
-
d:lwg732
LWG732

Resolved
Defect in [rand.dist.samp.genpdf]
https://wg21.link/lwg732




Stephan Tolksdorf
-
d:lwg733
LWG733

NAD
Comment on [rand.req.dist]/9
https://wg21.link/lwg733




Stephan Tolksdorf
-
d:lwg734
LWG734

CD1
Unnecessary restriction in [rand.dist.norm.chisq]
https://wg21.link/lwg734




Stephan Tolksdorf
-
d:lwg735
LWG735

NAD
Unfortunate naming
https://wg21.link/lwg735




Stephan Tolksdorf
-
d:lwg736
LWG736

NAD
Comment on [rand.dist.samp.discrete]
https://wg21.link/lwg736




Stephan Tolksdorf
-
d:lwg737
LWG737

NAD
Comment on [rand.dist.samp.pconst]
https://wg21.link/lwg737




Stephan Tolksdorf
-
d:lwg738
LWG738

NAD Editorial
Editorial issue in [rand.adapt.disc]/3
https://wg21.link/lwg738




Stephan Tolksdorf
-
d:lwg739
LWG739

NAD
Defect in [rand.util.canonical]/3
https://wg21.link/lwg739




Stephan Tolksdorf
-
d:lwg74
LWG74

TC1
Garbled text for codecvt::do_max_length
https://wg21.link/lwg74




Matt Austern
-
d:lwg740
LWG740

CD1
Please remove *_ptr<T[N]>
https://wg21.link/lwg740




Herb Sutter
-
d:lwg741
LWG741

NAD
Const-incorrect get_deleter function for shared_ptr
https://wg21.link/lwg741




Daniel Krügler
-
d:lwg742
LWG742

Resolved
Enabling swap for proxy iterators
https://wg21.link/lwg742




Howard Hinnant
-
d:lwg743
LWG743

CD1
rvalue swap for shared_ptr
https://wg21.link/lwg743




Howard Hinnant
-
d:lwg744
LWG744

CD1
What is the lifetime of an exception pointed to by an exception_ptr?
https://wg21.link/lwg744




Alisdair Meredith
-
d:lwg745
LWG745

NAD
copy_exception API slices.
https://wg21.link/lwg745




Alisdair Meredith
-
d:lwg746
LWG746

CD1
current_exception may fail with bad_alloc
https://wg21.link/lwg746




Alisdair Meredith
-
d:lwg747
LWG747

NAD
We have 3 separate type traits to identify classes supporting no-throw operations
https://wg21.link/lwg747




Alisdair Meredith
-
d:lwg748
LWG748

NAD
The is_abstract type trait is defined by reference to 10.4.
https://wg21.link/lwg748




Alisdair Meredith
-
d:lwg749
LWG749

CD1
Currently has_nothrow_copy_constructor<T>::value is true if T has 'a' nothrow copy constructor.
https://wg21.link/lwg749




Alisdair Meredith
-
d:lwg75
LWG75

TC1
Contradiction in codecvt::length's argument types
https://wg21.link/lwg75




Matt
Austern
-
d:lwg750
LWG750

Dup
The current definition for is_convertible requires that the type be implicitly convertible, so explicit constructors are ignored.
https://wg21.link/lwg750




Alisdair Meredith
-
d:lwg751
LWG751

NAD
change pass-by-reference members of vector<bool> to pass-by-value?
https://wg21.link/lwg751




Alisdair Meredith
-
d:lwg752
LWG752

C++11
Allocator complexity requirement
https://wg21.link/lwg752




Hans Boehm
-
d:lwg753
LWG753

C++11
Move constructor in draft
https://wg21.link/lwg753




Yechezkel Mett
-
d:lwg754
LWG754

NAD Editorial
Ambiguous return clause for std::uninitialized_copy
https://wg21.link/lwg754




Daniel Krügler
-
d:lwg755
LWG755

CD1
std::vector and std:string lack explicit shrink-to-fit operations
https://wg21.link/lwg755




Beman Dawes
-
d:lwg756
LWG756

Resolved
Container adaptors push
https://wg21.link/lwg756




Paolo Carlini
-
d:lwg757
LWG757

NAD Editorial
Typo in the synopsis of vector
https://wg21.link/lwg757




Paolo Carlini
-
d:lwg758
LWG758

C++11
shared_ptr and nullptr
https://wg21.link/lwg758




Joe Gottman
-
d:lwg759
LWG759

CD1
A reference is not an object
https://wg21.link/lwg759




Jens Maurer
-
d:lwg76
LWG76

CD1
Can a codecvt facet always convert one internal character at a time?
https://wg21.link/lwg76




Matt Austern
-
d:lwg760
LWG760

NAD
The emplace issue
https://wg21.link/lwg760




Paolo Carlini
-
d:lwg761
LWG761

CD1
unordered_map needs an at() member function
https://wg21.link/lwg761




Joe Gottman
-
d:lwg762
LWG762

CD1
std::unique_ptr requires complete type?
https://wg21.link/lwg762




Daniel Krügler
-
d:lwg763
LWG763

NAD
Renaming emplace() overloads
https://wg21.link/lwg763




Sylvain Pion
-
d:lwg764
LWG764

NAD
equal_range on unordered containers should return a pair of local_iterators
https://wg21.link/lwg764




Joe Gottman
-
d:lwg765
LWG765

C++11
More on iterator validity
https://wg21.link/lwg765




Martin Sebor
-
d:lwg766
LWG766

CD1
Inconsistent exception guarantees between ordered and unordered associative containers
https://wg21.link/lwg766




Ion Gaztañaga
-
d:lwg767
LWG767

Resolved
Forwarding and backward compatibility
https://wg21.link/lwg767




Sylvain Pion
-
d:lwg768
LWG768

CD1
Typos in [atomics]?
https://wg21.link/lwg768




Alberto Ganesh Barbati
-
d:lwg769
LWG769

CD1
std::function should use nullptr_t instead of "unspecified-null-pointer-type"
https://wg21.link/lwg769




Daniel Krügler
-
d:lwg77
LWG77

Dup
Valarray operator[] const returning value
https://wg21.link/lwg77




Levente Farkas
-
d:lwg770
LWG770

CD1
std::function should use rvalue swap
https://wg21.link/lwg770




Daniel Krügler
-
d:lwg771
LWG771

CD1
Impossible throws clause in [string.conversions]
https://wg21.link/lwg771




Daniel Krügler
-
d:lwg772
LWG772

CD1
Impossible return clause in [string.conversions]
https://wg21.link/lwg772




Daniel Krügler
-
d:lwg773
LWG773

NAD
issues with random
https://wg21.link/lwg773




P.J. Plauger
-
d:lwg774
LWG774

C++11
Member swap undefined for most containers
https://wg21.link/lwg774




Alisdair Meredith
-
d:lwg775
LWG775

CD1
Tuple indexing should be unsigned?
https://wg21.link/lwg775




Alisdair Meredith
-
d:lwg776
LWG776

CD1
Undescribed assign function of std::array
https://wg21.link/lwg776




Daniel Krügler
-
d:lwg777
LWG777

CD1
Atomics Library Issue
https://wg21.link/lwg777




Lawrence Crowl
-
d:lwg778
LWG778

CD1
std::bitset does not have any constructor taking a string literal
https://wg21.link/lwg778




Thorsten Ottosen
-
d:lwg779
LWG779

CD1
Resolution of #283 incomplete
https://wg21.link/lwg779




Daniel Krügler
-
d:lwg78
LWG78

TC1
Typo: event_call_back
https://wg21.link/lwg78




Nico Josuttis
-
d:lwg780
LWG780

C++11
std::merge() specification incorrect/insufficient
https://wg21.link/lwg780




Daniel Krügler
-
d:lwg781
LWG781

CD1
std::complex should add missing C99 functions
https://wg21.link/lwg781




Daniel Krügler
-
d:lwg782
LWG782

CD1
Extended seed_seq constructor is useless
https://wg21.link/lwg782




Daniel Krügler
-
d:lwg783
LWG783

CD1
thread::id reuse
https://wg21.link/lwg783




Hans Boehm
-
d:lwg784
LWG784

NAD
unique_lock::release
https://wg21.link/lwg784




Constantine Sapuntzakis
-
d:lwg785
LWG785

NAD
[tr1] Random Number Requirements in TR1
https://wg21.link/lwg785




John Maddock
-
d:lwg786
LWG786

Resolved
Thread library timed waits, UTC and monotonic clocks
https://wg21.link/lwg786




Christopher Kohlhoff, Jeff Garland
-
d:lwg787
LWG787

CD1
complexity of binary_search
https://wg21.link/lwg787




Daniel Krügler
-
d:lwg788
LWG788

C++11
Ambiguity in [istream.iterator]
https://wg21.link/lwg788




Martin Sebor
-
d:lwg789
LWG789

CD1
xor_combine_engine(result_type) should be explicit
https://wg21.link/lwg789




P.J. Plauger
-
d:lwg79
LWG79

TC1
Inconsistent declaration of polar()
https://wg21.link/lwg79




Nico Josuttis
-
d:lwg790
LWG790

NAD
xor_combine::seed not specified
https://wg21.link/lwg790




P.J. Plauger
-
d:lwg791
LWG791

NAD
piecewise_constant_distribution::densities has wrong name
https://wg21.link/lwg791




P.J. Plauger
-
d:lwg792
LWG792

CD1
piecewise_constant_distribution is undefined for a range with just one endpoint
https://wg21.link/lwg792




P.J. Plauger
-
d:lwg793
LWG793

Resolved
discrete_distribution missing constructor
https://wg21.link/lwg793




P.J. Plauger
-
d:lwg794
LWG794

Resolved
piecewise_constant_distribution missing constructor
https://wg21.link/lwg794




P.J. Plauger
-
d:lwg795
LWG795

Dup
general_pdf_distribution should be dropped
https://wg21.link/lwg795




P.J. Plauger
-
d:lwg796
LWG796

NAD
ranlux48_base returns wrong value
https://wg21.link/lwg796




P.J. Plauger
-
d:lwg797
LWG797

NAD
ranlux48 returns wrong value
https://wg21.link/lwg797




P.J. Plauger
-
d:lwg798
LWG798

CD1
Refactoring of binders lead to interface breakage
https://wg21.link/lwg798




Daniel Krügler
-
d:lwg799
LWG799

NAD
[tr1] [tr.rand.eng.mers] and [rand.eng.mers]
https://wg21.link/lwg799




Stephan Tolksdorf
-
d:lwg8
LWG8

TC1
Locale::global lacks guarantee
https://wg21.link/lwg8




Matt Austern
-
d:lwg80
LWG80

TC1
Global Operators of complex declared twice
https://wg21.link/lwg80




Nico Josuttis
-
d:lwg800
LWG800

Resolved
Issues in 26.4.7.1 [rand.util.seedseq](6)
https://wg21.link/lwg800




Stephan Tolksdorf
-
d:lwg801
LWG801

Resolved
tuple and pair trivial members
https://wg21.link/lwg801




Lawrence Crowl
-
d:lwg802
LWG802

NAD
knuth_b returns wrong value
https://wg21.link/lwg802




P.J. Plauger
-
d:lwg803
LWG803

Resolved
Simplification of seed_seq::seq_seq
https://wg21.link/lwg803




Charles Karney
-
d:lwg804
LWG804

CD1
Some problems with classes error_code/error_condition
https://wg21.link/lwg804




Daniel Krügler
-
d:lwg805
LWG805

CD1
posix_error::posix_errno concerns
https://wg21.link/lwg805




Jens Maurer
-
d:lwg806
LWG806

CD1
unique_ptr::reset effects incorrect, too permissive
https://wg21.link/lwg806




Peter Dimov
-
d:lwg807
LWG807

CD1
tuple construction should not fail unless its element's construction fails
https://wg21.link/lwg807




Howard Hinnant
-
d:lwg808
LWG808

CD1
§[forward] incorrect redundant specification
https://wg21.link/lwg808




Jens Maurer
-
d:lwg809
LWG809

CD1
std::swap should be overloaded for array types
https://wg21.link/lwg809




Niels Dekker
-
d:lwg81
LWG81

NAD
Wrong declaration of slice operations
https://wg21.link/lwg81




Nico Josuttis
-
d:lwg810
LWG810

C++11
Missing traits dependencies in operational semantics of extended manipulators
https://wg21.link/lwg810




Daniel Krügler
-
d:lwg811
LWG811

C++11
pair of pointers no longer works with literal 0
https://wg21.link/lwg811




Doug Gregor
-
d:lwg812
LWG812

NAD Editorial
unsolicited multithreading considered harmful?
https://wg21.link/lwg812




Paul McKenney
-
d:lwg813
LWG813

CD1
"empty" undefined for shared_ptr
https://wg21.link/lwg813




Matt Austern
-
d:lwg814
LWG814

C++11
vector<bool>::swap(reference, reference) not defined
https://wg21.link/lwg814




Alisdair Meredith
-
d:lwg815
LWG815

Resolved
std::function and reference_closure do not use perfect forwarding
https://wg21.link/lwg815




Alisdair Meredith
-
d:lwg816
LWG816

Resolved
Should bind()'s returned functor have a nofail copy ctor when bind() is nofail?
https://wg21.link/lwg816




Stephan T. Lavavej
-
d:lwg817
LWG817

C++11
bind needs to be moved
https://wg21.link/lwg817




Howard Hinnant
-
d:lwg818
LWG818

CD1
wording for memory ordering
https://wg21.link/lwg818




Jens Maurer
-
d:lwg819
LWG819

C++11
rethrow_if_nested
https://wg21.link/lwg819




Alisdair Meredith
-
d:lwg82
LWG82

NAD
Missing constant for set elements
https://wg21.link/lwg82




Nico Josuttis
-
d:lwg820
LWG820

CD1
current_exception()'s interaction with throwing copy ctors
https://wg21.link/lwg820




Stephan T. Lavavej
-
d:lwg821
LWG821

C++11
Minor cleanup : unique_ptr
https://wg21.link/lwg821




Alisdair Meredith
-
d:lwg822
LWG822

NAD
Object with explicit copy constructor no longer CopyConstructible
https://wg21.link/lwg822




James Kanze
-
d:lwg823
LWG823

Resolved
identity<void> seems broken
https://wg21.link/lwg823




Walter Brown
-
d:lwg824
LWG824

CD1
rvalue ref issue with basic_string inserter
https://wg21.link/lwg824




Alisdair Meredith
-
d:lwg825
LWG825

Resolved
Missing rvalues reference stream insert/extract operators?
https://wg21.link/lwg825




Alisdair Meredith
-
d:lwg826
LWG826

NAD
Equivalent of %'d, or rather, lack thereof?
https://wg21.link/lwg826




Peter Dimov
-
d:lwg827
LWG827

Resolved
constexpr shared_ptr::shared_ptr()?
https://wg21.link/lwg827




Peter Dimov
-
d:lwg828
LWG828

Resolved
Static initialization for std::mutex?
https://wg21.link/lwg828




Peter Dimov
-
d:lwg829
LWG829

CD1
current_exception wording unclear about exception type
https://wg21.link/lwg829




Beman Dawes
-
d:lwg83
LWG83

TC1
String::npos vs. string::max_size()
https://wg21.link/lwg83




Nico Josuttis
-
d:lwg830
LWG830

NAD Editorial
Incomplete list of char_traits specializations
https://wg21.link/lwg830




Dietmar Kühl
-
d:lwg831
LWG831

NAD Editorial
wrong type for not_eof()
https://wg21.link/lwg831




Dietmar Kühl
-
d:lwg832
LWG832

NAD
Applying constexpr to System error support
https://wg21.link/lwg832




Beman Dawes
-
d:lwg833
LWG833

NAD
Freestanding implementations header list needs review for C++0x
https://wg21.link/lwg833




Beman Dawes
-
d:lwg834
LWG834

Resolved
unique_ptr::pointer requirements underspecified
https://wg21.link/lwg834




Daniel Krügler
-
d:lwg835
LWG835

C++11
Tying two streams together (correction to DR 581)
https://wg21.link/lwg835




Martin Sebor
-
d:lwg836
LWG836

C++11
Effects of money_base::space and money_base::none on money_get
https://wg21.link/lwg836




Martin Sebor
-
d:lwg837
LWG837

NAD Editorial
basic_ios::copyfmt() overly loosely specified
https://wg21.link/lwg837




Martin Sebor
-
d:lwg838
LWG838

C++11
Can an end-of-stream iterator become a non-end-of-stream one?
https://wg21.link/lwg838




Martin Sebor
-
d:lwg839
LWG839

Resolved
Maps and sets missing splice operation
https://wg21.link/lwg839




Alan Talbot
-
d:lwg84
LWG84

NAD
Ambiguity with string::insert()
https://wg21.link/lwg84




Nico Josuttis
-
d:lwg840
LWG840

NAD
pair default template argument
https://wg21.link/lwg840




Thorsten Ottosen
-
d:lwg841
LWG841

NAD Editorial
cstdint.syn inconsistent with C99
https://wg21.link/lwg841




Martin Sebor
-
d:lwg842
LWG842

CD1
ConstructibleAsElement and bit containers
https://wg21.link/lwg842




Howard Hinnant
-
d:lwg843
LWG843

CD1
Reference Closure
https://wg21.link/lwg843




Lawrence Crowl
-
d:lwg844
LWG844

CD1
complex pow return type is ambiguous
https://wg21.link/lwg844




Howard Hinnant
-
d:lwg845
LWG845

CD1
atomics cannot support aggregate initialization
https://wg21.link/lwg845




Alisdair Meredith
-
d:lwg846
LWG846

CD1
No definition for constructor
https://wg21.link/lwg846




Alisdair Meredith
-
d:lwg847
LWG847

C++11
string exception safety guarantees
https://wg21.link/lwg847




Hervé Brönnimann
-
d:lwg848
LWG848

CD1
Missing std::hash specializations for std::bitset/std::vector<bool>
https://wg21.link/lwg848




Thorsten Ottosen
-
d:lwg849
LWG849

NAD
missing type traits to compute root class and derived class of types in a class hierachy
https://wg21.link/lwg849




Thorsten Ottosen
-
d:lwg85
LWG85

NAD
String char types
https://wg21.link/lwg85




Nico Josuttis
-
d:lwg850
LWG850

CD1
Should shrink_to_fit apply to std::deque?
https://wg21.link/lwg850




Niels Dekker
-
d:lwg851
LWG851

NAD
simplified array construction
https://wg21.link/lwg851




Benjamin Kosnik
-
d:lwg852
LWG852

CD1
unordered containers begin(n) mistakenly const
https://wg21.link/lwg852




Robert Klarer
-
d:lwg853
LWG853

C++11
to_string needs updating with zero and one
https://wg21.link/lwg853




Howard Hinnant
-
d:lwg854
LWG854

C++11
default_delete converting constructor underspecified
https://wg21.link/lwg854




Howard Hinnant
-
d:lwg855
LWG855

NAD
capacity() and reserve() for deque?
https://wg21.link/lwg855




Hervé Brönnimann
-
d:lwg856
LWG856

CD1
Removal of aligned_union
https://wg21.link/lwg856




Jens Maurer
-
d:lwg857
LWG857

C++11
condition_variable::time_wait return bool error prone
https://wg21.link/lwg857




Beman Dawes
-
d:lwg858
LWG858

CD1
Wording for Minimal Support for Garbage Collection
https://wg21.link/lwg858




Pete Becker
-
d:lwg859
LWG859

C++11
Monotonic Clock is Conditionally Supported?
https://wg21.link/lwg859




Pete Becker
-
d:lwg86
LWG86

TC1
String constructors don't describe exceptions
https://wg21.link/lwg86




Nico Josuttis
-
d:lwg860
LWG860

C++11
Floating-Point State
https://wg21.link/lwg860




Lawrence Crowl
-
d:lwg861
LWG861

C++11
Incomplete specification of EqualityComparable for std::forward_list
https://wg21.link/lwg861




Daniel Krügler
-
d:lwg862
LWG862

NAD Editorial
Impossible complexity for 'includes'
https://wg21.link/lwg862




Alisdair Meredith
-
d:lwg863
LWG863

NAD
What is the state of a stream after close() succeeds
https://wg21.link/lwg863




Steve Clamage
-
d:lwg864
LWG864

NAD Editorial
Defect in atomic wording
https://wg21.link/lwg864




Anthony Williams
-
d:lwg865
LWG865

C++11
More algorithms that throw away information
https://wg21.link/lwg865




Daniel Krügler
-
d:lwg866
LWG866

C++11
Qualification of placement new-expressions
https://wg21.link/lwg866




Alberto Ganesh Barbati
-
d:lwg867
LWG867

NAD Editorial
Valarray and value-initialization
https://wg21.link/lwg867




Alberto Ganesh Barbati
-
d:lwg868
LWG868

C++11
Default construction and value-initialization
https://wg21.link/lwg868




Alberto Ganesh Barbati
-
d:lwg869
LWG869

C++11
Bucket (local) iterators and iterating past end
https://wg21.link/lwg869




Sohail Somani
-
d:lwg87
LWG87

Dup
Error in description of string::compare()
https://wg21.link/lwg87




Nico Josuttis
-
d:lwg870
LWG870

C++11
Do unordered containers not support function pointers for predicate/hasher?
https://wg21.link/lwg870




Daniel Krügler
-
d:lwg871
LWG871

C++11
Iota's requirements on T are too strong
https://wg21.link/lwg871




Daniel Krügler
-
d:lwg872
LWG872

C++11
move_iterator::operator[] has wrong return type
https://wg21.link/lwg872




Doug Gregor
-
d:lwg873
LWG873

NAD Editorial
signed integral type and unsigned integral type are not clearly defined
https://wg21.link/lwg873




Travis Vitek
-
d:lwg874
LWG874

Resolved
Missing initializer_list constructor for discrete_distribution
https://wg21.link/lwg874




Daniel Krügler
-
d:lwg875
LWG875

Resolved
Missing initializer_list constructor for piecewise_constant_distribution
https://wg21.link/lwg875




Daniel Krügler
-
d:lwg876
LWG876

C++11
basic_string access operations should give stronger guarantees
https://wg21.link/lwg876




Daniel Krügler
-
d:lwg877
LWG877

NAD
to throw() or to Throw: Nothing.
https://wg21.link/lwg877




Martin Sebor
-
d:lwg878
LWG878

C++11
forward_list preconditions
https://wg21.link/lwg878




Martin Sebor
-
d:lwg879
LWG879

NAD Editorial
Atomic load const qualification
https://wg21.link/lwg879




Alexander Chemeris
-
d:lwg88
LWG88

NAD
Inconsistency between string::insert() and string::append()
https://wg21.link/lwg88




Nico Josuttis
-
d:lwg880
LWG880

Resolved
Missing atomic exchange parameter
https://wg21.link/lwg880




Lawrence Crowl
-
d:lwg881
LWG881

C++11
shared_ptr conversion issue
https://wg21.link/lwg881




Peter Dimov
-
d:lwg882
LWG882

CD1
duration non-member arithmetic requirements
https://wg21.link/lwg882




Howard Hinnant
-
d:lwg883
LWG883

C++11
swap circular definition
https://wg21.link/lwg883




Alisdair Meredith
-
d:lwg884
LWG884

Resolved
shared_ptr swap
https://wg21.link/lwg884




Jonathan Wakely
-
d:lwg885
LWG885

C++11
pair assignment
https://wg21.link/lwg885




Alisdair Meredith
-
d:lwg886
LWG886

C++11
tuple construction
https://wg21.link/lwg886




Alisdair Meredith
-
d:lwg887
LWG887

NAD
issue with condition::wait_...
https://wg21.link/lwg887




Lawrence Crowl
-
d:lwg888
LWG888

C++11
this_thread::yield too strong
https://wg21.link/lwg888




Lawrence Crowl
-
d:lwg889
LWG889

Resolved
thread::id comparisons
https://wg21.link/lwg889




Lawrence Crowl
-
d:lwg89
LWG89

Dup
Missing throw specification for string::insert() and string::replace()
https://wg21.link/lwg89




Nico Josuttis
-
d:lwg890
LWG890

C++11
Improving <system_error> initialization
https://wg21.link/lwg890




Beman Dawes
-
d:lwg891
LWG891

C++11
std::thread, std::call_once issue
https://wg21.link/lwg891




Peter Dimov
-
d:lwg892
LWG892

NAD Editorial
Forward_list issues...
https://wg21.link/lwg892




Ed Smith-Rowland
-
d:lwg893
LWG893

C++11
std::mutex issue
https://wg21.link/lwg893




Peter Dimov
-
d:lwg894
LWG894

C++11
longjmp and destructors
https://wg21.link/lwg894




Lawrence Crowl, Alisdair Meredith
-
d:lwg895
LWG895

Dup
"Requires:" on std::string::at et al
https://wg21.link/lwg895




James Dennett
-
d:lwg896
LWG896

C++11
Library thread safety issue
https://wg21.link/lwg896




Hans Boehm
-
d:lwg897
LWG897

Resolved
Forward_list issues... Part 2
https://wg21.link/lwg897




Howard Hinnant
-
d:lwg898
LWG898

C++11
Small contradiction in n2723 to forward to committee
https://wg21.link/lwg898




Arch Robison
-
d:lwg899
LWG899

C++11
Adjusting shared_ptr for nullptr_t
https://wg21.link/lwg899




Peter Dimov
-
d:lwg9
LWG9

TC1
Operator new(0) calls should not yield the same pointer
https://wg21.link/lwg9




Steve Clamage
-
d:lwg90
LWG90

TC1
Incorrect description of operator >> for strings
https://wg21.link/lwg90




Nico Josuttis
-
d:lwg900
LWG900

C++11
Stream move-assignment
https://wg21.link/lwg900




Niels Dekker
-
d:lwg901
LWG901

NAD
insert iterators can move from lvalues
https://wg21.link/lwg901




Alisdair Meredith
-
d:lwg902
LWG902

NAD Concepts
Regular is the wrong concept to constrain numeric_limits
https://wg21.link/lwg902




Alisdair Meredith
-
d:lwg903
LWG903

NAD
back_insert_iterator issue
https://wg21.link/lwg903




Dave Abrahams
-
d:lwg904
LWG904

C++11
result_of argument types
https://wg21.link/lwg904




Jonathan Wakely
-
d:lwg905
LWG905

Dup
Mutex specification questions
https://wg21.link/lwg905




Herb Sutter
-
d:lwg906
LWG906

NAD Concepts
ObjectType is the wrong concept to constrain initializer_list
https://wg21.link/lwg906




Daniel Krügler
-
d:lwg907
LWG907

C++11
Bitset's immutable element retrieval is inconsistently defined
https://wg21.link/lwg907




Daniel Krügler
-
d:lwg908
LWG908

Resolved
Deleted assignment operators for atomic types must be volatile
https://wg21.link/lwg908




Anthony Williams
-
d:lwg909
LWG909

C++11
regex_token_iterator should use initializer_list
https://wg21.link/lwg909




Daniel Krügler
-
d:lwg91
LWG91

CD1
Description of operator>> and getline() for string<> might cause endless loop
https://wg21.link/lwg91




Nico Josuttis
-
d:lwg910
LWG910

NAD Concepts
Effects of MoveAssignable
https://wg21.link/lwg910




Alberto Ganesh Barbati
-
d:lwg911
LWG911

C++11
I/O streams and move/swap semantic
https://wg21.link/lwg911




Alberto Ganesh Barbati
-
d:lwg912
LWG912

NAD Concepts
Array swap needs to be conceptualized
https://wg21.link/lwg912




Daniel Krügler
-
d:lwg913
LWG913

NAD Concepts
Superfluous requirements for replace algorithms
https://wg21.link/lwg913




Daniel Krügler
-
d:lwg914
LWG914

NAD Concepts
Superfluous requirement for unique
https://wg21.link/lwg914




Daniel Krügler
-
d:lwg915
LWG915

NAD Editorial
minmax with initializer_list should return pair of T, not pair of const T&
https://wg21.link/lwg915




Daniel Krügler
-
d:lwg916
LWG916

NAD
Redundant move-assignment operator of pair should be removed
https://wg21.link/lwg916




Daniel Krügler
-
d:lwg917
LWG917

NAD
Redundant move-assignment operator of tuple should be removed
https://wg21.link/lwg917




Daniel Krügler
-
d:lwg918
LWG918

NAD Concepts
Swap for tuple needs to be conceptualized
https://wg21.link/lwg918




Daniel Krügler
-
d:lwg919
LWG919

NAD
(forward_)list specialized remove algorithms are over constrained
https://wg21.link/lwg919




Daniel Krügler
-
d:lwg92
LWG92

CD1
Incomplete Algorithm Requirements
https://wg21.link/lwg92




Nico Josuttis
-
d:lwg920
LWG920

C++11
Ref-qualification support in the library
https://wg21.link/lwg920




Bronek Kozicki
-
d:lwg921
LWG921

C++11
Rational Arithmetic should use template aliases
https://wg21.link/lwg921




Pablo Halpern
-
d:lwg922
LWG922

C++11
§[func.bind.place] Number of placeholders
https://wg21.link/lwg922




Sohail Somani
-
d:lwg923
LWG923

Resolved
atomics with floating-point
https://wg21.link/lwg923




Herb Sutter
-
d:lwg924
LWG924

Resolved
structs with internal padding
https://wg21.link/lwg924




Herb Sutter
-
d:lwg925
LWG925

C++11
shared_ptr's explicit conversion from unique_ptr
https://wg21.link/lwg925




Rodolfo Lima
-
d:lwg926
LWG926

NAD Editorial
Sequentially consistent fences, relaxed operations and modification order
https://wg21.link/lwg926




Anthony Williams
-
d:lwg927
LWG927

NAD Concepts
Dereferenceable should be HasDereference
https://wg21.link/lwg927




Pablo Halpern
-
d:lwg928
LWG928

NAD Concepts
Wrong concepts used for tuple's comparison operators
https://wg21.link/lwg928




Joe Gottman
-
d:lwg929
LWG929

C++11
Thread constructor
https://wg21.link/lwg929




Anthony Williams
-
d:lwg93
LWG93

NAD
Incomplete Valarray Subset Definitions
https://wg21.link/lwg93




Nico Josuttis
-
d:lwg930
LWG930

NAD
Access to std::array data as built-in array type
https://wg21.link/lwg930




Niels Dekker
-
d:lwg931
LWG931

C++11
type trait extent<T, I>
https://wg21.link/lwg931




Yechezkel Mett
-
d:lwg932
LWG932

Resolved
unique_ptr(pointer p) for pointer deleter types
https://wg21.link/lwg932




Howard Hinnant
-
d:lwg933
LWG933

NAD
Unique_ptr defect
https://wg21.link/lwg933




Alisdair Meredith
-
d:lwg934
LWG934

C++11
duration is missing operator%
https://wg21.link/lwg934




Terry Golubiewski
-
d:lwg935
LWG935

NAD
clock error handling needs to be specified
https://wg21.link/lwg935




Beman Dawes
-
d:lwg936
LWG936

LEWG
Mutex type overspecified
https://wg21.link/lwg936




Pete Becker
-
d:lwg937
LWG937

NAD Editorial
Atomics for standard typedef types
https://wg21.link/lwg937




Clark Nelson
-
d:lwg938
LWG938

C++11
default_delete<T[]>::operator() should only accept T*
https://wg21.link/lwg938




Howard Hinnant
-
d:lwg939
LWG939

C++11
Problem with std::identity and reference-to-temporaries
https://wg21.link/lwg939




Alisdair Meredith
-
d:lwg94
LWG94

NAD
May library implementors add template parameters to Standard Library classes?
https://wg21.link/lwg94




Matt Austern
-
d:lwg940
LWG940

Resolved
std::distance
https://wg21.link/lwg940




Thomas
-
d:lwg941
LWG941

NAD
Ref-qualifiers for assignment operators
https://wg21.link/lwg941




Niels Dekker
-
d:lwg942
LWG942

Dup
Atomics synopsis typo
https://wg21.link/lwg942




Holger Grund
-
d:lwg943
LWG943

C++11
ssize_t undefined
https://wg21.link/lwg943




Holger Grund
-
d:lwg944
LWG944

Resolved
atomic<bool> derive from atomic_bool?
https://wg21.link/lwg944




Holger Grund
-
d:lwg945
LWG945

NAD Editorial
system_clock::rep not specified
https://wg21.link/lwg945




Pete Becker
-
d:lwg946
LWG946

NAD
duration_cast improperly specified
https://wg21.link/lwg946




Pete Becker
-
d:lwg947
LWG947

Resolved
duration arithmetic: contradictory requirements
https://wg21.link/lwg947




Pete Becker
-
d:lwg948
LWG948

C++11
ratio arithmetic tweak
https://wg21.link/lwg948




Howard Hinnant
-
d:lwg949
LWG949

C++11
owner_less
https://wg21.link/lwg949




Thomas Plum
-
d:lwg95
LWG95

NAD
Members added by the implementation
https://wg21.link/lwg95




AFNOR
-
d:lwg950
LWG950

Resolved
unique_ptr converting ctor shouldn't accept array form
https://wg21.link/lwg950




Howard Hinnant
-
d:lwg951
LWG951

C++11
Various threading bugs #1
https://wg21.link/lwg951




Pete Becker
-
d:lwg952
LWG952

NAD Editorial
Various threading bugs #2
https://wg21.link/lwg952




Pete Becker
-
d:lwg953
LWG953

Resolved
Various threading bugs #3
https://wg21.link/lwg953




Pete Becker
-
d:lwg954
LWG954

C++11
Various threading bugs #4
https://wg21.link/lwg954




Pete Becker
-
d:lwg955
LWG955

NAD
Various threading bugs #5
https://wg21.link/lwg955




Pete Becker
-
d:lwg956
LWG956

C++11
Various threading bugs #6
https://wg21.link/lwg956




Pete Becker
-
d:lwg957
LWG957

C++11
Various threading bugs #7
https://wg21.link/lwg957




Pete Becker
-
d:lwg958
LWG958

Resolved
Various threading bugs #8
https://wg21.link/lwg958




Pete Becker
-
d:lwg959
LWG959

NAD
Various threading bugs #9
https://wg21.link/lwg959




Pete Becker
-
d:lwg96
LWG96

NAD
Vector<bool> is not a container
https://wg21.link/lwg96




AFNOR
-
d:lwg960
LWG960

C++11
Various threading bugs #10
https://wg21.link/lwg960




Pete Becker
-
d:lwg961
LWG961

LEWG
Various threading bugs #11
https://wg21.link/lwg961




Pete Becker
-
d:lwg962
LWG962

C++11
Various threading bugs #12
https://wg21.link/lwg962




Pete Becker
-
d:lwg963
LWG963

C++11
Various threading bugs #13
https://wg21.link/lwg963




Pete Becker
-
d:lwg964
LWG964

Resolved
Various threading bugs #14
https://wg21.link/lwg964




Pete Becker
-
d:lwg965
LWG965

C++11
Various threading bugs #15
https://wg21.link/lwg965




Pete Becker
-
d:lwg966
LWG966

Resolved
Various threading bugs #16
https://wg21.link/lwg966




Pete Becker
-
d:lwg967
LWG967

C++11
Various threading bugs #17
https://wg21.link/lwg967




Pete Becker
-
d:lwg968
LWG968

C++11
Various threading bugs #18
https://wg21.link/lwg968




Pete Becker
-
d:lwg969
LWG969

NAD Editorial
What happened to Library Issue 475?
https://wg21.link/lwg969




Stephan T. Lavavej
-
d:lwg97
LWG97

NAD
Insert inconsistent definition
https://wg21.link/lwg97




AFNOR
-
d:lwg970
LWG970

C++11
addressof overload unneeded
https://wg21.link/lwg970




Howard Hinnant
-
d:lwg971
LWG971

NAD
Spurious diagnostic conversion function
https://wg21.link/lwg971




Beman Dawes
-
d:lwg972
LWG972

NAD Editorial
The term "Assignable" undefined but still in use
https://wg21.link/lwg972




Niels Dekker
-
d:lwg973
LWG973

NAD Editorial
auto_ptr characteristics
https://wg21.link/lwg973




Maarten Hilferink
-
d:lwg974
LWG974

C++11
duration<double> should not implicitly convert to duration<int>
https://wg21.link/lwg974




Howard Hinnant
-
d:lwg975
LWG975

C++11
is_convertible cannot be instantiated for non-convertible types
https://wg21.link/lwg975




Daniel Krügler
-
d:lwg976
LWG976

Resolved
Class template std::stack should be movable
https://wg21.link/lwg976




Daniel Krügler
-
d:lwg977
LWG977

NAD
insert iterators inefficient for expensive to move types
https://wg21.link/lwg977




Howard Hinnant
-
d:lwg978
LWG978

C++11
Hashing smart pointers
https://wg21.link/lwg978




Alisdair Meredith
-
d:lwg979
LWG979

NAD Editorial
Bad example
https://wg21.link/lwg979




Howard Hinnant
-
d:lwg98
LWG98

CD1
Input iterator requirements are badly written
https://wg21.link/lwg98




AFNOR
-
d:lwg980
LWG980

NAD
mutex lock() missing error conditions
https://wg21.link/lwg980




Ion Gaztañaga
-
d:lwg981
LWG981

C++11
Unordered container requirements should add initializer_list support
https://wg21.link/lwg981




Daniel Krügler
-
d:lwg982
LWG982

C++11
Wrong complexity for initializer_list assignment in Table 85
https://wg21.link/lwg982




Daniel Krügler
-
d:lwg983
LWG983

Resolved
unique_ptr reference deleters should not be moved from
https://wg21.link/lwg983




Howard Hinnant
-
d:lwg984
LWG984

C++11
Does <cinttypes> have macro guards?
https://wg21.link/lwg984




Howard Hinnant
-
d:lwg985
LWG985

Resolved
Allowing throwing move
https://wg21.link/lwg985




Rani Sharoni
-
d:lwg986
LWG986

C++11
Generic try_lock contradiction
https://wg21.link/lwg986




Chris Fairles
-
d:lwg987
LWG987

C++11
reference_wrapper and function types
https://wg21.link/lwg987




Howard Hinnant
-
d:lwg988
LWG988

NAD
Reflexivity meaningless?
https://wg21.link/lwg988




Alisdair Meredith
-
d:lwg989
LWG989

NAD Concepts
late_check and library
https://wg21.link/lwg989




Alisdair Meredith
-
d:lwg99
LWG99

NAD
Reverse_iterator comparisons completely wrong
https://wg21.link/lwg99




AFNOR
-
d:lwg990
LWG990

C++11
monotonic_clock::is_monotonic must be true
https://wg21.link/lwg990




Howard Hinnant
-
d:lwg991
LWG991

C++11
Provide allocator for wstring_convert
https://wg21.link/lwg991




P.J. Plauger
-
d:lwg992
LWG992

NAD
Allow implementations to implement C library in the global namespace
https://wg21.link/lwg992




P.J. Plauger
-
d:lwg993
LWG993

C++11
_Exit needs better specification
https://wg21.link/lwg993




P.J. Plauger
-
d:lwg994
LWG994

C++11
quick_exit should terminate well-defined
https://wg21.link/lwg994




P.J. Plauger
-
d:lwg995
LWG995

NAD
Operational Semantics Unclear
https://wg21.link/lwg995




David Abrahams
-
d:lwg996
LWG996

NAD
Move operation not well specified
https://wg21.link/lwg996




David Abrahams
-
d:lwg997
LWG997

C++11
"Effects: Equivalent to" is underspecified
https://wg21.link/lwg997




Thomas Plum
-
d:lwg998
LWG998

C++11
Smart pointer referencing its owner
https://wg21.link/lwg998




Pavel Minaev
-
d:lwg999
LWG999

C++11
Taking the address of a function
https://wg21.link/lwg999




Peter Dimov
-
