d:cwg1
CWG1

TC1
What if two using-declarations refer to the same function but the declarations introduce different default-arguments?
https://wg21.link/cwg1




Bill Gibbons
-
d:cwg10
CWG10

CD1
Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?
https://wg21.link/cwg10




Josee Lajoie
-
d:cwg100
CWG100
9 March 1999
TC1
Clarify why string literals are not allowed as template arguments
https://wg21.link/cwg100




Mike Miller
-
d:cwg1000
CWG1000
20 November 2009
CD2
Mistaking member typedefs for constructors
https://wg21.link/cwg1000




Jason Merrill
-
d:cwg1001
CWG1001
8 November 2009
drafting
Parameter type adjustment in dependent parameter types
https://wg21.link/cwg1001




Jason Merrill
-
d:cwg1002
CWG1002
16 November 2009
NAD
Pack expansion for function arguments
https://wg21.link/cwg1002




Daniel Krügler
-
d:cwg1003
CWG1003
17 November 2009
CD3
Acceptable definitions of main
https://wg21.link/cwg1003




Daniel Krügler
-
d:cwg1004
CWG1004
19 November 2009
C++11
Injected-class-names as arguments for template template parameters
https://wg21.link/cwg1004




Jason Merrill
-
d:cwg1005
CWG1005
19 November 2009
NAD
Qualified name resolution in member functions of class templates
https://wg21.link/cwg1005




Doug Gregor
-
d:cwg1006
CWG1006
20 November 2009
C++11
std::nullptr_t as a non-type template parameter
https://wg21.link/cwg1006




Mike Miller
-
d:cwg1007
CWG1007
24 November 2009
NAD
Protected access and pointers to members
https://wg21.link/cwg1007




Johannes Schaub
-
d:cwg1008
CWG1008
27 November 2009
extension
Querying the alignment of an object
https://wg21.link/cwg1008




Steve Clamage
-
d:cwg1009
CWG1009
28 November 2009
C++11
Missing cases in the declarator-id of a function template declaration
https://wg21.link/cwg1009




Johannes Schaub
-
d:cwg101
CWG101
10 March 1999
TC1
Redeclaration of extern "C" names via using-declarations
https://wg21.link/cwg101




Mike Miller
-
d:cwg1010
CWG1010
2 December 2009
CD2
Address of object with dynamic storage duration in constant expression
https://wg21.link/cwg1010




Adamczyk
-
d:cwg1011
CWG1011
3 December 2009
C++11
Standard conversions that cannot be inverted
https://wg21.link/cwg1011




John Spicer
-
d:cwg1012
CWG1012
9 December 2009
C++11
Undeprecating static
https://wg21.link/cwg1012




Ville Voutilainen
-
d:cwg1013
CWG1013
10 December 2009
CD3
Uninitialized std::nullptr_t objects
https://wg21.link/cwg1013




Miller
-
d:cwg1014
CWG1014
17 December 2009
NAD
Overload resolution between const T& and T&&
https://wg21.link/cwg1014




Steve Adamczyk
-
d:cwg1015
CWG1015
24 December 2009
C++11
Template arguments and argument-dependent lookup
https://wg21.link/cwg1015




Jason Merrill
-
d:cwg1016
CWG1016
27 December 2009
C++11
Overloadable declarations, function templates, and references
https://wg21.link/cwg1016




Johannes Schaub
-
d:cwg1017
CWG1017
20091230
C++11
Member access transformation in unevaluated operands
https://wg21.link/cwg1017




Johannes Schaub
-
d:cwg1018
CWG1018
4 January 2010
C++11
Ambiguity between simple-declaration and attribute-declaration
https://wg21.link/cwg1018




Mike Miller
-
d:cwg1019
CWG1019
12 January 2010
dup
Dependent simple-template-ids in base-specifiers and mem-initializers
https://wg21.link/cwg1019




Doug Gregor
-
d:cwg102
CWG102
15 October 1998
NAD
Operator lookup rules do not work well with parts of the library
https://wg21.link/cwg102




Herb Sutter
-
d:cwg1020
CWG1020
12 January 2010
C++11
Implicitly-defined copy constructors and explicit base class constructors
https://wg21.link/cwg1020




Niels Dekker
-
d:cwg1021
CWG1021
14 January 2010
CD4
Definitions of namespace members
https://wg21.link/cwg1021




Michael Wong
-
d:cwg1022
CWG1022
22 January 2010
C++11
Can an enumeration variable have values outside the values of the enumeration?
https://wg21.link/cwg1022




Jason Merrill
-
d:cwg1023
CWG1023
28 January 2010
dup
thread_local objects as non-type template arguments
https://wg21.link/cwg1023




Jeffrey Yasskin
-
d:cwg1024
CWG1024
20100131
CD3
Limits on multicharacter literals
https://wg21.link/cwg1024




Alisdair Meredith
-
d:cwg1025
CWG1025
20100131
C++11
Use of a reference as a non-type template argument
https://wg21.link/cwg1025




Mike Miller
-
d:cwg1026
CWG1026
1 February 2010
NAD
Cv-qualified non-class rvalues
https://wg21.link/cwg1026




Jerry Coffin
-
d:cwg1027
CWG1027
3 February 2010
drafting
Type consistency and reallocation of scalar types
https://wg21.link/cwg1027




Gabriel Dos Reis
-
d:cwg1028
CWG1028
3 February 2010
open
Dependent names in non-defining declarations
https://wg21.link/cwg1028




Sean Hunt
-
d:cwg1029
CWG1029
8 February 2010
C++11
Type of a destructor call
https://wg21.link/cwg1029




Johannes Schaub
-
d:cwg103
CWG103
20 March 1999
TC1
Is it extended-namespace-definition or extension-namespace-definition ?
https://wg21.link/cwg103




Herb Sutter
-
d:cwg1030
CWG1030
9 February 2010
C++11
Evaluation order in initializer-lists used in aggregate initialization
https://wg21.link/cwg1030




Scott Meyers
-
d:cwg1031
CWG1031
10 February 2010
C++11
Optional elements in attributes
https://wg21.link/cwg1031




Daveed Vandevoorde
-
d:cwg1032
CWG1032
16 February 2010
C++11
Empty pack expansions
https://wg21.link/cwg1032




James Widman
-
d:cwg1033
CWG1033
17 February 2010
C++11
Restrictions on alignment attributes
https://wg21.link/cwg1033




Daveed Vandevoorde
-
d:cwg1034
CWG1034
18 February 2010
C++11
Attributes for return statements in lambdas
https://wg21.link/cwg1034




Daveed Vandevoorde
-
d:cwg1035
CWG1035
25 February 2010
C++11
Omitted and required decl-specifiers
https://wg21.link/cwg1035




Daveed Vandevoorde
-
d:cwg1036
CWG1036
26 February 2010
C++11
Alignment attribute in an exception-declaration
https://wg21.link/cwg1036




Daveed Vandevoorde
-
d:cwg1037
CWG1037
1 March 2010
C++11
Requirements for operands of delete-expressions and deallocation functions
https://wg21.link/cwg1037




Daniel Krügler
-
d:cwg1038
CWG1038
2 March 2010
open
Overload resolution of &x.static_func
https://wg21.link/cwg1038




Mike Miller
-
d:cwg1039
CWG1039
3 March 2010
dup
Coordinating C and C++ alignment specifications
https://wg21.link/cwg1039




Steve Adamczyk
-
d:cwg104
CWG104
21 March 1999
NAD
Destroying the exception temp when no handler is found
https://wg21.link/cwg104




Jonathan Schilling
-
d:cwg1040
CWG1040
3 March 2010
NAD
Memory model issues
https://wg21.link/cwg1040




Paul McKinney
-
d:cwg1041
CWG1041
4 March 2010
dup
alias-declarations as class members
https://wg21.link/cwg1041




Daveed Vandevoorde
-
d:cwg1042
CWG1042
4 March 2010
C++11
Attributes in alias-declarations
https://wg21.link/cwg1042




Daveed Vandevoorde
-
d:cwg1043
CWG1043
5 March 2010
C++11
Qualified name lookup in the current instantiation
https://wg21.link/cwg1043




Doug Gregor
-
d:cwg1044
CWG1044
5 March 2010
C++11
Point of declaration for an alias-declaration
https://wg21.link/cwg1044




Daveed Vandevoorde
-
d:cwg1045
CWG1045
5 March 2010
NAD
Requiring explicit instantiation declarations
https://wg21.link/cwg1045




Doug Gregor
-
d:cwg1046
CWG1046
8 March 2010
open
What is a “use” of a class specialization?
https://wg21.link/cwg1046




Michael Wong
-
d:cwg1047
CWG1047
8 March 2010
C++11
When is typeid value-dependent?
https://wg21.link/cwg1047




Steve Adamczyk
-
d:cwg1048
CWG1048
9 March 2010
CD3
auto deduction and lambda return type deduction.
https://wg21.link/cwg1048




Jason Merrill
-
d:cwg1049
CWG1049
10 March 2010
open
Copy elision through reference parameters of inline functions
https://wg21.link/cwg1049




Jason Merrill
-
d:cwg105
CWG105
16 April 1999
TC1
Meaning of "template function"
https://wg21.link/cwg105




Daveed Vandevoorde
-
d:cwg1050
CWG1050
11 March 2010
NAD
Effects of thread support on object lifetime
https://wg21.link/cwg1050




Hans Boehm
-
d:cwg1051
CWG1051
11 March 2010
C++11
Reference members and generated copy constructors
https://wg21.link/cwg1051




Steve Adamczyk
-
d:cwg1052
CWG1052
12 March 2010
dup
const non-static data member and PODness
https://wg21.link/cwg1052




Jason Merrill
-
d:cwg1053
CWG1053
12 March 2010
NAD
Terminate vs undefined behavior for noexcept violation
https://wg21.link/cwg1053




Dave Abrahams
-
d:cwg1054
CWG1054
16 March 2010
C++11
Lvalue-to-rvalue conversions in expression statements
https://wg21.link/cwg1054




Hans Boehm
-
d:cwg1055
CWG1055
17 March 2010
C++11
Permissible uses of void
https://wg21.link/cwg1055




Nikolay Ivchenkov
-
d:cwg1056
CWG1056
17 March 2010
C++11
Template aliases, member definitions, and the current instantiation
https://wg21.link/cwg1056




John Spicer
-
d:cwg1057
CWG1057
18 March 2010
C++11
decltype and the current instantiation
https://wg21.link/cwg1057




Mike Miller
-
d:cwg1058
CWG1058
20 March 2010
NAD
Reference binding of incompatible array types
https://wg21.link/cwg1058




Johannes Schaub
-
d:cwg1059
CWG1059
20 March 2010
CD3
Cv-qualified array types (with rvalues)
https://wg21.link/cwg1059




Nikolay Ivchenkov
-
d:cwg106
CWG106

CD1
Creating references to references during template deduction/instantiation
https://wg21.link/cwg106




Bjarne Stroustrup
-
d:cwg1060
CWG1060
21 March 2010
C++11
Scoped enumerators in integral constant expressions
https://wg21.link/cwg1060




Jonathan Caves
-
d:cwg1061
CWG1061
23 March 2010
C++11
Negative array bounds in a new-expression
https://wg21.link/cwg1061




Sean Hunt
-
d:cwg1062
CWG1062
23 March 2010
C++11
Syntax of attribute-specifiers in lambdas
https://wg21.link/cwg1062




Peter Sommerlad
-
d:cwg1063
CWG1063
23 March 2010
C++11
[[hiding]] with non-attribute declarations
https://wg21.link/cwg1063




Daveed Vandevoorde
-
d:cwg1064
CWG1064
23 March 2010
C++11
Defaulted move constructor for a union
https://wg21.link/cwg1064




Mike Miller
-
d:cwg1065
CWG1065
24 March 2010
C++11
[[hiding]] with [[override]]
https://wg21.link/cwg1065




Daveed Vandevoorde
-
d:cwg1066
CWG1066
24 March 2010
C++11
When is a copy/move assignment operator implicitly defined?
https://wg21.link/cwg1066




Mike Miller
-
d:cwg1067
CWG1067
26 March 2010
NAD
[[hiding]], using-declarations, and multiple inheritance
https://wg21.link/cwg1067




Daveed Vandevoorde
-
d:cwg1068
CWG1068
27 March 2010
C++11
Template aliases with default arguments and template parameter packs
https://wg21.link/cwg1068




Nikolay Ivchenkov
-
d:cwg1069
CWG1069
20100430
C++11
Incorrect function type with trailing-return-type
https://wg21.link/cwg1069




James Widman
-
d:cwg107
CWG107
21 April 1999
NAD
Linkage of operator functions
https://wg21.link/cwg107




Stephen Clamage
-
d:cwg1070
CWG1070
1 June 2010
C++11
Missing initializer clauses in aggregate initialization
https://wg21.link/cwg1070




Jason Merrill
-
d:cwg1071
CWG1071
2 June 2010
C++11
Literal class types and trivial default constructors
https://wg21.link/cwg1071




Daniel Krügler
-
d:cwg1072
CWG1072
2 June 2010
C++11
Scoped enumerator with the same name as its containing class
https://wg21.link/cwg1072




Pavel Minaev
-
d:cwg1073
CWG1073
2 June 2010
C++11
Merging dynamic-exception-specifications and noexcept-specifications
https://wg21.link/cwg1073




Jason Merrill
-
d:cwg1074
CWG1074
4 June 2010
C++11
Value-dependent noexcept-expressions
https://wg21.link/cwg1074




Jason Merrill
-
d:cwg1075
CWG1075
6 June 2010
C++11
Grammar does not allow template alias in type-name
https://wg21.link/cwg1075




Jason Merrill
-
d:cwg1076
CWG1076
10 June 2010
DRWP
Value categories and lvalue temporaries
https://wg21.link/cwg1076




Daniel Krügler
-
d:cwg1077
CWG1077
13 June 2010
extension
Explicit specializations in non-containing namespaces
https://wg21.link/cwg1077




Mike Spertus
-
d:cwg1078
CWG1078
14 June 2010
NAD
Narrowing and the usual arithmetic conversions
https://wg21.link/cwg1078




Jason Merrill
-
d:cwg1079
CWG1079
15 June 2010
C++11
Overload resolution involving aggregate initialization
https://wg21.link/cwg1079




Jason Merrill
-
d:cwg108
CWG108
14 April 1999
TC1
Are classes nested in templates dependent?
https://wg21.link/cwg108




Mark Mitchell
-
d:cwg1080
CWG1080
19 June 2010
C++11
Confusing relationship between templates and copy constructors
https://wg21.link/cwg1080




Jason Merrill
-
d:cwg1081
CWG1081
22 June 2010
C++11
Defaulted destructor and unusable operator delete
https://wg21.link/cwg1081




Jason Merrill
-
d:cwg1082
CWG1082
22 June 2010
C++11
Implicit copy function if subobject has none?
https://wg21.link/cwg1082




Jason Merrill
-
d:cwg1083
CWG1083
22 June 2010
C++11
Passing an object to ellipsis with non-trivial move constructor
https://wg21.link/cwg1083




Jason Merrill
-
d:cwg1084
CWG1084
22 June 2010
NAD
Conditions for a deleted move function
https://wg21.link/cwg1084




Jason Merrill
-
d:cwg1085
CWG1085
22 June 2010
NAD
Move assignment operators and virtual bases
https://wg21.link/cwg1085




Jason Merrill
-
d:cwg1086
CWG1086
25 June 2010
C++11
const_cast to rvalue reference to function type
https://wg21.link/cwg1086




Steve Adamczyk
-
d:cwg1087
CWG1087
25 June 2010
C++11
Additional applications of issue 899
https://wg21.link/cwg1087




Jason Merrill
-
d:cwg1088
CWG1088
28 June 2010
C++11
Dependent non-type template arguments
https://wg21.link/cwg1088




Jason Merrill
-
d:cwg1089
CWG1089
29 June 2010
drafting
Template parameters in member selections
https://wg21.link/cwg1089




Daveed Vandevoorde
-
d:cwg109
CWG109
6 April 1999
NAD
Allowing ::template in using-declarations
https://wg21.link/cwg109




Daveed Vandevoorde
-
d:cwg1090
CWG1090
23 June 2010
C++11
Alignment of subobjects
https://wg21.link/cwg1090




Daveed Vandevoorde
-
d:cwg1091
CWG1091
10 July 2010
C++11
Inconsistent use of the term “object expression”
https://wg21.link/cwg1091




Tom Plum
-
d:cwg1092
CWG1092
15 July 2010
drafting
Cycles in overload resolution during instantiation
https://wg21.link/cwg1092




Jason Merrill
-
d:cwg1093
CWG1093
17 July 2010
CD3
Value-initializing non-objects
https://wg21.link/cwg1093




Daniel Krügler
-
d:cwg1094
CWG1094
17 July 2010
C++11
Converting floating-point values to scoped enumeration types
https://wg21.link/cwg1094




Daniel Krügler
-
d:cwg1095
CWG1095
26 July 2010
C++11
List-initialization of references
https://wg21.link/cwg1095




Daniel Krügler
-
d:cwg1096
CWG1096
28 July 2010
C++11
Missing requirement for template definitions
https://wg21.link/cwg1096




Daniel Krügler
-
d:cwg1097
CWG1097
29 July 2010
NAD
Aggregate initialization of function parameters
https://wg21.link/cwg1097




Daniel Krügler
-
d:cwg1098
CWG1098
1 August 2010
C++11
Pointer conversions in constant expressions
https://wg21.link/cwg1098




Jason Merrill
-
d:cwg1099
CWG1099
1 August 2010
C++11
Infinite recursion in constexpr functions
https://wg21.link/cwg1099




Jason Merrill
-
d:cwg11
CWG11

CD1
How do the keywords typename/template interact with using-declarations?
https://wg21.link/cwg11




Bill Gibbons
-
d:cwg110
CWG110
28 April 1999
open
Can template functions and classes be declared in the same scope?
https://wg21.link/cwg110




John Spicer
-
d:cwg1100
CWG1100
1 August 2010
C++11
constexpr conversion functions and non-type template arguments
https://wg21.link/cwg1100




Jason Merrill
-
d:cwg1101
CWG1101
2 August 2010
C++11
Non-integral initialized static data members
https://wg21.link/cwg1101




Jason Merrill
-
d:cwg1102
CWG1102
2 August 2010
C++11
Better example of undefined behavior
https://wg21.link/cwg1102




GB
-
d:cwg1103
CWG1103
2 August 2010
C++11
Reversion of phase 1 and 2 transformations in raw string literals
https://wg21.link/cwg1103




US
-
d:cwg1104
CWG1104
2 August 2010
C++11
Global-scope template arguments vs the <: digraph
https://wg21.link/cwg1104




US
-
d:cwg1105
CWG1105
2 August 2010
C++11
Issues relating to TR 10176:2003
https://wg21.link/cwg1105




CA
-
d:cwg1106
CWG1106
2 August 2010
C++11
Need more detail in nullptr keyword description
https://wg21.link/cwg1106




DE
-
d:cwg1107
CWG1107
2 August 2010
C++11
Overload resolution for user-defined integer literals
https://wg21.link/cwg1107




US
-
d:cwg1108
CWG1108
2 August 2010
NAD
User-defined literals have not been implemented
https://wg21.link/cwg1108




US
-
d:cwg1109
CWG1109
2 August 2010
C++11
When is “use” a reference to the ODR meaning?
https://wg21.link/cwg1109




US
-
d:cwg111
CWG111
4 May 1999
NAD
Copy constructors and cv-qualifiers
https://wg21.link/cwg111




Jack Rouse
-
d:cwg1110
CWG1110
2 August 2010
NAD
Incomplete return type should be allowed in decltype operand
https://wg21.link/cwg1110




DE
-
d:cwg1111
CWG1111
2 August 2010
C++11
Remove dual-scope lookup of member template names
https://wg21.link/cwg1111




US
-
d:cwg1112
CWG1112
2 August 2010
C++11
constexpr variables should have internal linkage like const
https://wg21.link/cwg1112




US
-
d:cwg1113
CWG1113
2 August 2010
C++11
Linkage of namespace member of unnamed namespace
https://wg21.link/cwg1113




DE
-
d:cwg1114
CWG1114
2 August 2010
C++11
Incorrect use of placement new in example
https://wg21.link/cwg1114




GB
-
d:cwg1115
CWG1115
2 August 2010
C++11
C-compatible alignment specification
https://wg21.link/cwg1115




US
-
d:cwg1116
CWG1116
2 August 2010
CD4
Aliasing of union members
https://wg21.link/cwg1116




US
-
d:cwg1117
CWG1117
2 August 2010
C++11
Incorrect note about xvalue member access expressions
https://wg21.link/cwg1117




JP
-
d:cwg1118
CWG1118
2 August 2010
NAD
Implicit lambda capture via explicit copy constructor
https://wg21.link/cwg1118




FI
-
d:cwg1119
CWG1119
2 August 2010
C++11
Missing case in description of member access ambiguity
https://wg21.link/cwg1119




US
-
d:cwg112
CWG112
4 May 1999
CD1
Array types and cv-qualifiers
https://wg21.link/cwg112




Steve Clamage
-
d:cwg1120
CWG1120
2 August 2010
C++11
reinterpret_cast and void*
https://wg21.link/cwg1120




GB
-
d:cwg1121
CWG1121
2 August 2010
C++11
Unnecessary ambiguity error in formation of pointer to member
https://wg21.link/cwg1121




US
-
d:cwg1122
CWG1122
2 August 2010
C++11
Circular definition of std::size_t
https://wg21.link/cwg1122




GB
-
d:cwg1123
CWG1123
2 August 2010
C++11
Destructors should be noexcept by default
https://wg21.link/cwg1123




FI
-
d:cwg1124
CWG1124
2 August 2010
NAD
Error in description of value category of pointer-to-member expression
https://wg21.link/cwg1124




JP
-
d:cwg1125
CWG1125
2 August 2010
C++11
Unclear definition of “potential constant expression”
https://wg21.link/cwg1125




DE
-
d:cwg1126
CWG1126
2 August 2010
C++11
constexpr functions in const initializers
https://wg21.link/cwg1126




GB
-
d:cwg1127
CWG1127
2 August 2010
C++11
Overload resolution in constexpr functions
https://wg21.link/cwg1127




GB
-
d:cwg1128
CWG1128
2 August 2010
C++11
attribute-specifiers in decl-specifier-seqs
https://wg21.link/cwg1128




US
-
d:cwg1129
CWG1129
2 August 2010
C++11
Default nothrow for constexpr functions
https://wg21.link/cwg1129




GB
-
d:cwg113
CWG113
5 May 1999
CD1
Visibility of called function
https://wg21.link/cwg113




Christophe de Dinechin
-
d:cwg1130
CWG1130
2 August 2010
C++11
Function parameter type adjustments and decltype
https://wg21.link/cwg1130




US
-
d:cwg1131
CWG1131
2 August 2010
C++11
Template aliases in elaborated-type-specifiers
https://wg21.link/cwg1131




US
-
d:cwg1132
CWG1132
2 August 2010
NAD
Keyword vs attribute for noreturn
https://wg21.link/cwg1132




GB
-
d:cwg1133
CWG1133
2 August 2010
C++11
Keywords vs attributes for control of hiding and overriding
https://wg21.link/cwg1133




US
-
d:cwg1134
CWG1134
2 August 2010
C++11
When is an explicitly-defaulted function defined?
https://wg21.link/cwg1134




US
-
d:cwg1135
CWG1135
2 August 2010
C++11
Explicitly-defaulted non-public special member functions
https://wg21.link/cwg1135




FI
-
d:cwg1136
CWG1136
2 August 2010
C++11
Explicitly-defaulted explicit constructors
https://wg21.link/cwg1136




FI
-
d:cwg1137
CWG1137
2 August 2010
C++11
Explicitly-defaulted virtual special member functions
https://wg21.link/cwg1137




FI
-
d:cwg1138
CWG1138
2 August 2010
C++11
Rvalue-ness check for rvalue reference binding is wrong
https://wg21.link/cwg1138




US
-
d:cwg1139
CWG1139
2 August 2010
C++11
Rvalue reference binding to scalar xvalues
https://wg21.link/cwg1139




US
-
d:cwg114
CWG114
7 May 1999
NAD
Virtual overriding by template member function specializations
https://wg21.link/cwg114




Bill Gibbons
-
d:cwg1140
CWG1140
2 August 2010
C++11
Incorrect redefinition of POD class
https://wg21.link/cwg1140




US
-
d:cwg1141
CWG1141
2 August 2010
NAD
Non-static data member initializers have not been implemented
https://wg21.link/cwg1141




US
-
d:cwg1142
CWG1142
2 August 2010
C++11
friend declaration of member function of containing class
https://wg21.link/cwg1142




US
-
d:cwg1143
CWG1143
2 August 2010
NAD
Move semantics for *this have not been implemented
https://wg21.link/cwg1143




US
-
d:cwg1144
CWG1144
3 August 2010
C++11
Remove access declarations
https://wg21.link/cwg1144




US
-
d:cwg1145
CWG1145
3 August 2010
C++11
Defaulting and triviality
https://wg21.link/cwg1145




FI
-
d:cwg1146
CWG1146
3 August 2010
C++11
exception-specifications of defaulted functions
https://wg21.link/cwg1146




GB
-
d:cwg1147
CWG1147
3 August 2010
C++11
Destructors should be default nothrow
https://wg21.link/cwg1147




GB
-
d:cwg1148
CWG1148
3 August 2010
C++11
Copy elision and move construction of function parameters
https://wg21.link/cwg1148




DE
-
d:cwg1149
CWG1149
3 August 2010
C++11
Trivial non-public copy operators in subobjects
https://wg21.link/cwg1149




FI
-
d:cwg115
CWG115
7 May 1999
CD1
Address of template-id
https://wg21.link/cwg115




John Spicer
-
d:cwg1150
CWG1150
3 August 2010
NAD
Inheriting constructors have not been implemented
https://wg21.link/cwg1150




US
-
d:cwg1151
CWG1151
3 August 2010
C++11
Overload resolution with initializer-list and non-list constructors
https://wg21.link/cwg1151




US
-
d:cwg1152
CWG1152
3 August 2010
C++11
Rules for determining existence of implicit conversion sequence
https://wg21.link/cwg1152




US
-
d:cwg1153
CWG1153
3 August 2010
C++11
Type matching in address of overloaded function
https://wg21.link/cwg1153




US
-
d:cwg1154
CWG1154
3 August 2010
C++11
Address of thread_local variable as non-type template argument
https://wg21.link/cwg1154




US
-
d:cwg1155
CWG1155
3 August 2010
C++11
Internal-linkage non-type template arguments
https://wg21.link/cwg1155




US
-
d:cwg1156
CWG1156
3 August 2010
C++11
Partial ordering in a non-call context
https://wg21.link/cwg1156




US
-
d:cwg1157
CWG1157
3 August 2010
open
Partial ordering of function templates is still underspecified
https://wg21.link/cwg1157




CA
-
d:cwg1158
CWG1158
3 August 2010
C++11
Recursive instantiation via alias template
https://wg21.link/cwg1158




US
-
d:cwg1159
CWG1159
3 August 2010
C++11
Class and enumeration definitions in template aliases
https://wg21.link/cwg1159




US
-
d:cwg116
CWG116
11 May 1999
TC1
Equivalent and functionally-equivalent function templates
https://wg21.link/cwg116




Mike Miller
-
d:cwg1160
CWG1160
3 August 2010
C++11
Definitions of template members and the current instantiation
https://wg21.link/cwg1160




GB
-
d:cwg1161
CWG1161
3 August 2010
C++11
Dependent nested-name-specifier in a pointer-to-member declarator
https://wg21.link/cwg1161




GB
-
d:cwg1162
CWG1162
3 August 2010
NAD
Dependent elaborated-type-specifiers in non-deduced contexts
https://wg21.link/cwg1162




CA
-
d:cwg1163
CWG1163
3 August 2010
NAD
extern template prevents inlining functions not marked inline
https://wg21.link/cwg1163




US
-
d:cwg1164
CWG1164
3 August 2010
C++11
Partial ordering of f(T&) and f(T&&)
https://wg21.link/cwg1164




US
-
d:cwg1165
CWG1165
3 August 2010
C++11
Exceptions when destroying array elements
https://wg21.link/cwg1165




US
-
d:cwg1166
CWG1166
3 August 2010
C++11
exception-declarations that do not declare objects
https://wg21.link/cwg1166




US
-
d:cwg1167
CWG1167
3 August 2010
C++11
function-try-blocks for destructors
https://wg21.link/cwg1167




GB
-
d:cwg1168
CWG1168
3 August 2010
C++11
Additional reasons to call std::terminate
https://wg21.link/cwg1168




GB
-
d:cwg1169
CWG1169
3 August 2010
C++11
Missing feature macro for strict pointer safety
https://wg21.link/cwg1169




GB
-
d:cwg117
CWG117
14 May 1999
NAD
Timing of destruction of temporaries
https://wg21.link/cwg117




Mike Miller
-
d:cwg1170
CWG1170
3 August 2010
C++11
Access checking during template argument deduction
https://wg21.link/cwg1170




Adamczyk
-
d:cwg1171
CWG1171
4 August 2010
C++11
Partial stack unwinding with noexcept violation
https://wg21.link/cwg1171




Merrill
-
d:cwg1172
CWG1172
5 August 2010
drafting
“instantiation-dependent” constructs
https://wg21.link/cwg1172




Adamczyk
-
d:cwg1173
CWG1173
6 August 2010
C++11
Unclear specification of effects of signal handling
https://wg21.link/cwg1173




GB
-
d:cwg1174
CWG1174
7 August 2010
C++11
When is a pure virtual function “used?”
https://wg21.link/cwg1174




Daniel Krügler
-
d:cwg1175
CWG1175
10 August 2010
C++11
Disambiguating user-defined literals
https://wg21.link/cwg1175




Sebastian Gesemann
-
d:cwg1176
CWG1176
10 August 2010
C++11
Definition of release sequence
https://wg21.link/cwg1176




CA, GB
-
d:cwg1177
CWG1177
10 August 2010
C++11
Intra-thread dependency-ordered-before
https://wg21.link/cwg1177




CA
-
d:cwg1178
CWG1178
19 August 2010
C++11
Deduction failure matching placement new
https://wg21.link/cwg1178




Mike Miller
-
d:cwg1179
CWG1179
19 August 2010
NAD
Cv-qualification of non-type template parameters
https://wg21.link/cwg1179




Daniel Krügler
-
d:cwg118
CWG118
17 May 1999
CD1
Calls via pointers to virtual member functions
https://wg21.link/cwg118




Martin O'Riordan
-
d:cwg1180
CWG1180
25 August 2010
C++11
Over-aligned class types
https://wg21.link/cwg1180




Clark Nelson
-
d:cwg1181
CWG1181
26 August 2010
C++11
What is a “built-in type?”
https://wg21.link/cwg1181




Barry Hedquist
-
d:cwg1182
CWG1182
26 August 2010
C++11
Incorrect description of pack expansion syntax
https://wg21.link/cwg1182




Daveed Vandevoorde
-
d:cwg1183
CWG1183
26 August 2010
C++11
Expansion of parameter packs in declarators
https://wg21.link/cwg1183




Daveed Vandevoorde
-
d:cwg1184
CWG1184
29 August 2010
C++11
Argument conversions to nondeduced parameter types
https://wg21.link/cwg1184




Daniel Krügler
-
d:cwg1185
CWG1185
29 August 2010
C++11
Misleading description of language linkage and member function types
https://wg21.link/cwg1185




Mike Miller
-
d:cwg1186
CWG1186
20100830
C++11
Non-dependent constexpr violations in function templates
https://wg21.link/cwg1186




Jason Merrill
-
d:cwg1187
CWG1187
20100831
C++11
Problems in initialization example
https://wg21.link/cwg1187




Jason Merrill
-
d:cwg1188
CWG1188
20100831
C++11
Type punning in constant expressions
https://wg21.link/cwg1188




Jason Merrill
-
d:cwg1189
CWG1189
20100831
C++11
Address of distinct base class subobjects
https://wg21.link/cwg1189




Gabriel Dos Reis
-
d:cwg119
CWG119
20 May 1999
CD1
Object lifetime and aggregate initialization
https://wg21.link/cwg119




Jack Rouse
-
d:cwg1190
CWG1190
1 September 2010
C++11
Operations on non-safely-derived pointers
https://wg21.link/cwg1190




Hans Boehm
-
d:cwg1191
CWG1191
2 September 2010
C++11
Deleted subobject destructors and implicitly-defined constructors
https://wg21.link/cwg1191




Jason Merrill
-
d:cwg1192
CWG1192
3 September 2010
C++11
Inadvertent change to ODR and templates
https://wg21.link/cwg1192




Daniel Krügler
-
d:cwg1193
CWG1193
2 September 2010
C++11
Use of address-constant pointers in constant expressions
https://wg21.link/cwg1193




Daniel Krügler
-
d:cwg1194
CWG1194
4 September 2010
C++11
Constexpr references
https://wg21.link/cwg1194




Daniel Krügler
-
d:cwg1195
CWG1195
5 September 2010
C++11
References to non-literal types in constexpr functions
https://wg21.link/cwg1195




Daniel Krügler
-
d:cwg1196
CWG1196
8 September 2010
C++11
Definition required for explicit instantiation after explicit specialization?
https://wg21.link/cwg1196




Mike Miller
-
d:cwg1197
CWG1197
8 September 2010
C++11
Constexpr arrays
https://wg21.link/cwg1197




Jason Merrill
-
d:cwg1198
CWG1198
16 September 2010
C++11
Literal types and copy constructors
https://wg21.link/cwg1198




Jason Merrill
-
d:cwg1199
CWG1199
17 September 2010
C++11
Deleted constexpr functions
https://wg21.link/cwg1199




Daniel Krügler
-
d:cwg12
CWG12

dup
Default arguments on different declarations for the same function and the Koenig lookup
https://wg21.link/cwg12




Daveed Vandevoorde
-
d:cwg120
CWG120
28 May 1999
TC1
Nonexistent non-terminal qualified-name
https://wg21.link/cwg120




Bill Gibbons
-
d:cwg1200
CWG1200
18 September 2010
open
Lookup rules for template parameters
https://wg21.link/cwg1200




Johannes Schaub
-
d:cwg1201
CWG1201
20 September 2010
C++11
Are deleted and defaulted functions definitions?
https://wg21.link/cwg1201




Daniel Krügler
-
d:cwg1202
CWG1202
21 September 2010
C++11
Calling virtual functions during destruction
https://wg21.link/cwg1202




Bjarne Stroustrup
-
d:cwg1203
CWG1203
20100930
dup
Misleading note regarding initialized static data members
https://wg21.link/cwg1203




Jason Merrill
-
d:cwg1204
CWG1204
1 October 2010
C++11
Specifiers in a for-range-declaration
https://wg21.link/cwg1204




Jason Merrill
-
d:cwg1205
CWG1205
6 October 2010
dup
Lvalue reference binding and function viability
https://wg21.link/cwg1205




Steve Clamage
-
d:cwg1206
CWG1206
6 October 2010
C++11
Defining opaque enumeration members of class templates
https://wg21.link/cwg1206




Jason Merrill
-
d:cwg1207
CWG1207
6 October 2010
C++11
Type of class member in trailing-return-type
https://wg21.link/cwg1207




Jason Merrill
-
d:cwg1208
CWG1208
7 October 2010
C++11
Explicit noexcept in defaulted definition
https://wg21.link/cwg1208




Daniel Krügler
-
d:cwg1209
CWG1209
8 October 2010
open
Is a potentially-evaluated expression in a template definition a “use?”
https://wg21.link/cwg1209




Johannes Schaub
-
d:cwg121
CWG121
28 May 1999
TC1
Dependent type names with non-dependent nested-name-specifiers
https://wg21.link/cwg121




Bill Gibbons
-
d:cwg1210
CWG1210
13 October 2010
C++11
Injection of elaborated-type-specifier in enumeration scope
https://wg21.link/cwg1210




Johannes Schaub
-
d:cwg1211
CWG1211
20 October 2010
drafting
Misaligned lvalues
https://wg21.link/cwg1211




David Svoboda
-
d:cwg1212
CWG1212
21 October 2010
C++11
Non-function-call xvalues and decltype
https://wg21.link/cwg1212




Daniel Krügler
-
d:cwg1213
CWG1213
24 October 2010
CD3
Array subscripting and xvalues
https://wg21.link/cwg1213




Jason Merrill
-
d:cwg1214
CWG1214
20101030
C++11
Kinds of initializers
https://wg21.link/cwg1214




Johannes Schaub
-
d:cwg1215
CWG1215
28 October 2010
C++11
Definition of POD struct
https://wg21.link/cwg1215




Daniel Krügler
-
d:cwg1216
CWG1216
2 November 2010
C++11
Exceptions “allowed” by a noexcept-specification
https://wg21.link/cwg1216




Jens Maurer
-
d:cwg1217
CWG1217
10 November 2010
NAD
Are deleted functions implicitly noexcept?
https://wg21.link/cwg1217




Daniel Krügler
-
d:cwg1218
CWG1218
12 November 2010
C++11
What is the “currently-handled exception” in a multi-threaded program?
https://wg21.link/cwg1218




CA
-
d:cwg1219
CWG1219
13 November 2010
C++11
Non-static data member initializers in constant expressions
https://wg21.link/cwg1219




Jens Maurer
-
d:cwg122
CWG122
3 June 1999
CD1
template-ids as unqualified-ids
https://wg21.link/cwg122




Mike Miller
-
d:cwg1220
CWG1220
13 November 2010
C++11
Looking up conversion-type-ids
https://wg21.link/cwg1220




Mike Miller
-
d:cwg1221
CWG1221
8 November 2010
open
Partial ordering and reference collapsing
https://wg21.link/cwg1221




Michael Wong
-
d:cwg1222
CWG1222
8 November 2010
NAD
Unnecessary restriction on auto array types
https://wg21.link/cwg1222




Michael Wong
-
d:cwg1223
CWG1223
8 November 2010
drafting
Syntactic disambiguation and trailing-return-types
https://wg21.link/cwg1223




Michael Wong
-
d:cwg1224
CWG1224
25 October 2010
C++11
constexpr defaulted copy constructors
https://wg21.link/cwg1224




Jason Merrill
-
d:cwg1225
CWG1225
26 October 2010
C++11
constexpr constructors and virtual bases
https://wg21.link/cwg1225




Jason Merrill
-
d:cwg1226
CWG1226
19 November 2010
CD3
Converting a braced-init-list default argument
https://wg21.link/cwg1226




Mike Miller
-
d:cwg1227
CWG1227
27 November 2010
CD3
Mixing immediate and non-immediate contexts in deduction failure
https://wg21.link/cwg1227




Daniel Krügler
-
d:cwg1228
CWG1228
3 December 2010
NAD
Copy-list-initialization and explicit constructors
https://wg21.link/cwg1228




Daniel Krügler
-
d:cwg1229
CWG1229
9 December 2010
C++11
Overload resolution with empty braced-init-list argument
https://wg21.link/cwg1229




Johannes Schaub
-
d:cwg123
CWG123
3 June 1999
TC1
Bad cross-reference
https://wg21.link/cwg123




Mike Miller
-
d:cwg1230
CWG1230
13 December 2010
open
Confusing description of ambiguity of destructor name
https://wg21.link/cwg1230




Johannes Schaub
-
d:cwg1231
CWG1231
20 December 2010
C++11
Variadic templates requiring an empty pack expansion
https://wg21.link/cwg1231




John Spicer
-
d:cwg1232
CWG1232
3 January 2011
C++11
Creation of array temporaries using a braced-init-list
https://wg21.link/cwg1232




Andrew Koenig
-
d:cwg1233
CWG1233
11 January 2011
C++11
Pack expansions and dependent calls
https://wg21.link/cwg1233




John Spicer
-
d:cwg1234
CWG1234
18 January 2011
C++11
abstract-declarator does not permit ... after ptr-operator
https://wg21.link/cwg1234




Johannes Schaub
-
d:cwg1235
CWG1235
18 January 2011
C++11
“Unused” ellipsis and default arguments in partial ordering
https://wg21.link/cwg1235




James Widman
-
d:cwg1236
CWG1236
20 January 2011
C++11
Inconsistently-interrelated examples
https://wg21.link/cwg1236




Doug Gregor
-
d:cwg1237
CWG1237
25 January 2011
C++11
Deprecated implicit copy assignment in example
https://wg21.link/cwg1237




Ryou Ezoe
-
d:cwg1238
CWG1238
25 January 2011
C++11
Overloading ambiguity binding reference to function
https://wg21.link/cwg1238




Doug Gregor
-
d:cwg1239
CWG1239
28 January 2011
C++11
Hexadecimal floating-point literals vs user-defined literals
https://wg21.link/cwg1239




Howard Hinnant
-
d:cwg124
CWG124
3 June 1999
CD1
Lifetime of temporaries in default initialization of class arrays
https://wg21.link/cwg124




Jack Rouse
-
d:cwg1240
CWG1240
2 February 2011
C++11
constexpr defaulted constructors
https://wg21.link/cwg1240




Jens Maurer
-
d:cwg1241
CWG1241
8 February 2011
C++11
Which members does a destructor destroy?
https://wg21.link/cwg1241




Ryou Ezoe
-
d:cwg1242
CWG1242
8 February 2011
C++11
Initializing variant class members
https://wg21.link/cwg1242




Ryou Ezoe
-
d:cwg1243
CWG1243
8 February 2011
C++11
Misleading footnote regarding multiple-declarator declarations
https://wg21.link/cwg1243




Johannes Schaub
-
d:cwg1244
CWG1244
22 February 2011
C++11
Equivalence of alias templates and class templates
https://wg21.link/cwg1244




Johannes Schaub
-
d:cwg1245
CWG1245
22 February 2011
C++11
Matching declarations involving decltype
https://wg21.link/cwg1245




Jason Merrill
-
d:cwg1246
CWG1246
23 February 2011
C++11
Non-deduced non-final parameter packs
https://wg21.link/cwg1246




John Spicer
-
d:cwg1247
CWG1247
26 February 2011
CD4
Restriction on alias name appearing in type-id
https://wg21.link/cwg1247




James Widman
-
d:cwg1248
CWG1248
28 February 2011
open
Updating Annex C to C99
https://wg21.link/cwg1248




Jonathan Wakely
-
d:cwg1249
CWG1249
2 March 2011
drafting
Cv-qualification of nested lambda capture
https://wg21.link/cwg1249




James Widman
-
d:cwg125
CWG125
7 June 1999
CD1
Ambiguity in friend declaration syntax
https://wg21.link/cwg125




Martin von Loewis
-
d:cwg1250
CWG1250
3 March 2011
CD3
Cv-qualification of incomplete virtual function return types
https://wg21.link/cwg1250




Jonathan Wakely
-
d:cwg1251
CWG1251
4 March 2011
CD3
C compatibility: casting to unqualified void*
https://wg21.link/cwg1251




Johannes Schaub
-
d:cwg1252
CWG1252
6 March 2011
drafting
Overloading member function templates based on dependent return type
https://wg21.link/cwg1252




Nikolay Ivchenkov
-
d:cwg1253
CWG1253
6 March 2011
drafting
Generic non-template members
https://wg21.link/cwg1253




Nikolay Ivchenkov
-
d:cwg1254
CWG1254
8 March 2011
NAD
odr-use vs template arguments and constexpr functions
https://wg21.link/cwg1254




Nikolay Ivchenkov
-
d:cwg1255
CWG1255
8 March 2011
drafting
Definition problems with constexpr functions
https://wg21.link/cwg1255




Nikolay Ivchenkov
-
d:cwg1256
CWG1256
8 March 2011
open
Unevaluated operands are not necessarily constant expressions
https://wg21.link/cwg1256




Nikolay Ivchenkov
-
d:cwg1257
CWG1257
9 March 2011
open
Instantiation via non-dependent references in uninstantiated templates
https://wg21.link/cwg1257




Johannes Schaub
-
d:cwg1258
CWG1258
10 March 2011
drafting
“Instantiation context” differs from dependent lookup rules
https://wg21.link/cwg1258




Nikolay Ivchenkov
-
d:cwg1259
CWG1259
10 March 2011
NAD
Deleting a POD via a pointer to base
https://wg21.link/cwg1259




Herb Sutter
-
d:cwg126
CWG126
8 June 1999
TC1
Exception specifications and const
https://wg21.link/cwg126




Martin von Loewis
-
d:cwg1260
CWG1260
11 March 2011
CD3
Incorrect use of term “overloaded” in description of odr-use
https://wg21.link/cwg1260




Nikolay Ivchenkov
-
d:cwg1261
CWG1261
12 March 2011
CD3
Explicit handling of cv-qualification with non-class prvalues
https://wg21.link/cwg1261




Nikolay Ivchenkov
-
d:cwg1262
CWG1262
16 March 2011
CD3
Default template arguments and deduction failure
https://wg21.link/cwg1262




Nikolay Ivchenkov
-
d:cwg1263
CWG1263
18 March 2011
NAD
Mismatch between rvalue reference binding and overload resolution
https://wg21.link/cwg1263




Johannes Schaub
-
d:cwg1264
CWG1264
18 March 2011
CD3
Use of this in constexpr constructor
https://wg21.link/cwg1264




Jason Merrill
-
d:cwg1265
CWG1265
20 March 2011
CD3
Mixed use of the auto specifier
https://wg21.link/cwg1265




Michael Wong
-
d:cwg1266
CWG1266
20 March 2011
open
user-defined-integer-literal overflow
https://wg21.link/cwg1266




Michael Wong
-
d:cwg1267
CWG1267
21 March 2011
CD3
Rvalue reference types in exception-specifications
https://wg21.link/cwg1267




Michael Wong
-
d:cwg1268
CWG1268
21 March 2011
CD3
reinterpret_cast of an xvalue operand
https://wg21.link/cwg1268




Michael Wong
-
d:cwg1269
CWG1269
21 March 2011
CD3
dynamic_cast of an xvalue operand
https://wg21.link/cwg1269




Michael Wong
-
d:cwg127
CWG127
8 June 1999
TC1
Ambiguity in description of matching deallocation function
https://wg21.link/cwg127




Alexander Schiemann
-
d:cwg1270
CWG1270
23 March 2011
CD3
Brace elision in array temporary initialization
https://wg21.link/cwg1270




Jason Merrill
-
d:cwg1271
CWG1271
24 March 2011
DR
Imprecise wording regarding dependent types
https://wg21.link/cwg1271




Daveed Vandevoorde
-
d:cwg1272
CWG1272
18 March 2011
NAD
Implicit definition of static data member of const literal type
https://wg21.link/cwg1272




Nikolay Ivchenkov
-
d:cwg1273
CWG1273
24 March 2011
NAD
Accessibility and function signatures
https://wg21.link/cwg1273




Jason Merrill
-
d:cwg1274
CWG1274
25 March 2011
CD4
Common nonterminal for expression and braced-init-list
https://wg21.link/cwg1274




Daniel Krügler
-
d:cwg1275
CWG1275
25 March 2011
CD3
Incorrect comment in example of template parameter pack restriction
https://wg21.link/cwg1275




Johannes Schaub
-
d:cwg1276
CWG1276
26 March 2011
NAD
Reference to stdint.h
https://wg21.link/cwg1276




Daniel Krügler
-
d:cwg1277
CWG1277
26 March 2011
NAD
Lax definition of intmax_t and uintmax_t
https://wg21.link/cwg1277




Daniel Krügler
-
d:cwg1278
CWG1278
27 March 2011
drafting
Incorrect treatment of contrived object
https://wg21.link/cwg1278




Nikolay Ivchenkov
-
d:cwg1279
CWG1279
27 March 2011
drafting
Additional differences between C++ 2003 and C++ 2011
https://wg21.link/cwg1279




Nikolay Ivchenkov
-
d:cwg128
CWG128
10 June 1999
TC1
Casting between enum types
https://wg21.link/cwg128




Clark Nelson
-
d:cwg1280
CWG1280
27 March 2011
NAD
Object reallocation and reference members
https://wg21.link/cwg1280




Nikolay Ivchenkov
-
d:cwg1281
CWG1281
28 March 2011
NAD
Virtual and dependent base classes
https://wg21.link/cwg1281




Johannes Schaub
-
d:cwg1282
CWG1282
28 March 2011
CD3
Underspecified destructor exception-specification
https://wg21.link/cwg1282




Daniel Krügler
-
d:cwg1283
CWG1283
29 March 2011
drafting
Static data members of classes with typedef name for linkage purposes
https://wg21.link/cwg1283




Mike Miller
-
d:cwg1284
CWG1284
2 April 2011
CD4
Should the lifetime of an array be independent of that of its elements?
https://wg21.link/cwg1284




Gabriel Dos Reis
-
d:cwg1285
CWG1285
2 April 2011
open
Trivial destructors and object lifetime
https://wg21.link/cwg1285




Johannes Schaub
-
d:cwg1286
CWG1286
3 April 2011
drafting
Equivalence of alias templates
https://wg21.link/cwg1286




Gabriel Dos Reis
-
d:cwg1287
CWG1287
6 April 2011
C++14
Direct initialization vs “implicit” conversion in reference binding
https://wg21.link/cwg1287




Daniel Krügler
-
d:cwg1288
CWG1288
6 April 2011
CD3
Reference list initialization
https://wg21.link/cwg1288




Daniel Krügler
-
d:cwg1289
CWG1289
6 April 2011
NAD
Can an alias template name the current instantiation?
https://wg21.link/cwg1289




James Widman
-
d:cwg129
CWG129
26 June 1999
CD3
Stability of uninitialized auto variables
https://wg21.link/cwg129




Nathan Myers
-
d:cwg1290
CWG1290
8 April 2011
CD3
Lifetime of the underlying array of an initializer_list member
https://wg21.link/cwg1290




James Dennett
-
d:cwg1291
CWG1291
10 April 2011
drafting
Looking up a conversion-type-id
https://wg21.link/cwg1291




Daveed Vandevoorde
-
d:cwg1292
CWG1292
10 April 2011
CD4
Dependent calls with braced-init-lists containing a pack expansion
https://wg21.link/cwg1292




James Widman
-
d:cwg1293
CWG1293
11 April 2011
CD3
String literals in constant expressions
https://wg21.link/cwg1293




Daniel Krügler
-
d:cwg1294
CWG1294
8 April 2011
drafting
Side effects in dynamic/static initialization
https://wg21.link/cwg1294




Daniel Krügler
-
d:cwg1295
CWG1295
14 April 2011
CD3
Binding a reference to an rvalue bit-field
https://wg21.link/cwg1295




Nikolay Ivchenkov
-
d:cwg1296
CWG1296
14 April 2011
CD3
Ill-formed template declarations (not just definitions)
https://wg21.link/cwg1296




Nikolay Ivchenkov
-
d:cwg1297
CWG1297
14 April 2011
CD3
Misplaced function attribute-specifier
https://wg21.link/cwg1297




Nikolay Ivchenkov
-
d:cwg1298
CWG1298
15 April 2011
CD3
Incorrect example in overload resolution
https://wg21.link/cwg1298




Nikolay Ivchenkov
-
d:cwg1299
CWG1299
16 April 2011
DRWP
“Temporary objects” vs “temporary expressions”
https://wg21.link/cwg1299




Johannes Schaub
-
d:cwg13
CWG13

NAD
extern "C" for Parameters of Function Templates
https://wg21.link/cwg13




John Spicer
-
d:cwg130
CWG130
20 June 1999
NAD
Sequence points and new-expressions
https://wg21.link/cwg130




Herb Sutter
-
d:cwg1300
CWG1300
18 April 2011
dup
T() for array types
https://wg21.link/cwg1300




Daniel Krügler
-
d:cwg1301
CWG1301
18 April 2011
CD3
Value initialization of union
https://wg21.link/cwg1301




Jason Merrill
-
d:cwg1302
CWG1302
22 April 2011
CD3
noexcept applied to expression of type void
https://wg21.link/cwg1302




Nikolay Ivchenkov
-
d:cwg1303
CWG1303
23 April 2011
NAD
C language linkage for template with internal linkage
https://wg21.link/cwg1303




Johannes Schaub
-
d:cwg1304
CWG1304
26 April 2011
drafting
Omitted array bound with string initialization
https://wg21.link/cwg1304




Nikolay Ivchenkov
-
d:cwg1305
CWG1305
26 April 2011
CD3
alignof applied to array of unknown size
https://wg21.link/cwg1305




Nikolay Ivchenkov
-
d:cwg1306
CWG1306
26 April 2011
CD3
Modifying an object within a const member function
https://wg21.link/cwg1306




James Kanze
-
d:cwg1307
CWG1307
20110430
C++14
Overload resolution based on size of array initializer-list
https://wg21.link/cwg1307




Johannes Schaub
-
d:cwg1308
CWG1308
3 May 2011
CD3
Completeness of class type within an exception-specification
https://wg21.link/cwg1308




Nikolay Ivchenkov
-
d:cwg1309
CWG1309
5 May 2011
CD4
Incorrect note regarding lookup of a member of the current instantiation
https://wg21.link/cwg1309




Johannes Schaub
-
d:cwg131
CWG131
23 June 1999
TC1
Typo in Lao characters
https://wg21.link/cwg131




John Spicer
-
d:cwg1310
CWG1310
6 May 2011
CD3
What is an “acceptable lookup result?”
https://wg21.link/cwg1310




Jason Merrill
-
d:cwg1311
CWG1311
6 May 2011
CD3
Volatile lvalues in constant expressions
https://wg21.link/cwg1311




Nikolay Ivchenkov
-
d:cwg1312
CWG1312
6 May 2011
CD3
Simulated reinterpret_cast in constant expressions
https://wg21.link/cwg1312




Nikolay Ivchenkov
-
d:cwg1313
CWG1313
7 May 2011
CD3
Undefined pointer arithmetic in constant expressions
https://wg21.link/cwg1313




Jens Maurer
-
d:cwg1314
CWG1314
6 May 2011
NAD
Pointer arithmetic within standard-layout objects
https://wg21.link/cwg1314




Nikolay Ivchenkov
-
d:cwg1315
CWG1315
12 May 2011
CD4
Restrictions on non-type template arguments in partial specializations
https://wg21.link/cwg1315




Johannes Schaub
-
d:cwg1316
CWG1316
20110512
NAD
constexpr function requirements and class scope
https://wg21.link/cwg1316




Jason Merrill
-
d:cwg1317
CWG1317
12 May 2011
NAD
Unnamed scoped enumerations
https://wg21.link/cwg1317




John Spicer
-
d:cwg1318
CWG1318
14 May 2011
CD3
Syntactic ambiguities with final
https://wg21.link/cwg1318




Johannes Schaub
-
d:cwg1319
CWG1319
17 May 2011
NAD
Error in pack expansion example
https://wg21.link/cwg1319




Mike Miller
-
d:cwg132
CWG132
25 June 1999
NAD
Local types and linkage
https://wg21.link/cwg132




Daveed Vandevoorde
-
d:cwg1320
CWG1320
18 May 2011
CD3
Converting scoped enumerations to bool
https://wg21.link/cwg1320




Jonathan Wakely
-
d:cwg1321
CWG1321
18 May 2011
CD3
Equivalency of dependent calls
https://wg21.link/cwg1321




Jason Merrill
-
d:cwg1322
CWG1322
19 May 2011
drafting
Function parameter type decay in templates
https://wg21.link/cwg1322




Jason Merrill
-
d:cwg1323
CWG1323
19 May 2011
NAD
Nonexistent nonterminal in alignment-specifier grammar
https://wg21.link/cwg1323




Alisdair Meredith
-
d:cwg1324
CWG1324
22 May 2011
CD3
Value initialization and defaulted constructors
https://wg21.link/cwg1324




Daniel Krügler
-
d:cwg1325
CWG1325
27 May 2011
NAD
Omitted declarator in friend declarations
https://wg21.link/cwg1325




Johannes Schaub
-
d:cwg1326
CWG1326
28 May 2011
extension
Deducing an array bound from an initializer-list
https://wg21.link/cwg1326




Faisal Vali
-
d:cwg1327
CWG1327
29 May 2011
CD3
virt-specifier in a defaulted definition
https://wg21.link/cwg1327




Ryou Ezoe
-
d:cwg1328
CWG1328
20110531
CD3
Conflict in reference binding vs overload resolution
https://wg21.link/cwg1328




Johannes Schaub
-
d:cwg1329
CWG1329
2 June 2011
CD3
Recursive deduction substitutions
https://wg21.link/cwg1329




Jason Merrill
-
d:cwg133
CWG133
25 June 1999
dup
Exception specifications and checking
https://wg21.link/cwg133




Daveed Vandevoorde
-
d:cwg1330
CWG1330
5 June 2011
CD3
Delayed instantiation of noexcept specifiers
https://wg21.link/cwg1330




Jason Merrill
-
d:cwg1331
CWG1331
15 June 2011
extension
const mismatch with defaulted copy constructor
https://wg21.link/cwg1331




Daniel Krügler
-
d:cwg1332
CWG1332
20 June 2011
drafting
Handling of invalid universal-character-names
https://wg21.link/cwg1332




Mike Miller
-
d:cwg1333
CWG1333
21 June 2011
CD3
Omission of const in a defaulted copy constructor
https://wg21.link/cwg1333




Daniel Krügler
-
d:cwg1334
CWG1334
23 June 2011
NAD
Layout compatibility and cv-qualification
https://wg21.link/cwg1334




Daniel Krügler
-
d:cwg1335
CWG1335
3 July 2011
drafting
Stringizing, extended characters, and universal-character-names
https://wg21.link/cwg1335




Johannes Schaub
-
d:cwg1336
CWG1336
3 July 2011
CD3
Definition of “converting constructor”
https://wg21.link/cwg1336




Niels Dekker
-
d:cwg1337
CWG1337
5 July 2011
dup
Partial ordering and non-deduced parameters
https://wg21.link/cwg1337




Jason Merrill
-
d:cwg1338
CWG1338
3 August 2011
CD4
Aliasing and allocation functions
https://wg21.link/cwg1338




Jason Merrill
-
d:cwg1339
CWG1339
3 August 2011
NAD
Parenthesized braced-init-list and arrays
https://wg21.link/cwg1339




Jason Merrill
-
d:cwg134
CWG134
17 June 1999
TC1
Template classes and declarator-ids
https://wg21.link/cwg134




Mike Miller
-
d:cwg1340
CWG1340
10 August 2011
CD3
Complete type in member pointer expressions
https://wg21.link/cwg1340




Daniel Krügler
-
d:cwg1341
CWG1341
10 August 2011
NAD
Bit-field initializers
https://wg21.link/cwg1341




James Widman
-
d:cwg1342
CWG1342
11 August 2011
drafting
Order of initialization with multiple declarators
https://wg21.link/cwg1342




Alberto Ganesh Barbati
-
d:cwg1343
CWG1343
12 August 2011
C++17
Sequencing of non-class initialization
https://wg21.link/cwg1343




Johannes Schaub
-
d:cwg1344
CWG1344
16 August 2011
C++14
Adding new special member functions to a class via default arguments
https://wg21.link/cwg1344




Sean Hunt
-
d:cwg1345
CWG1345
16 August 2011
CD3
Initialization of anonymous union class members
https://wg21.link/cwg1345




Sean Hunt
-
d:cwg1346
CWG1346
16 August 2011
CD3
expression-list initializers and the auto specifier
https://wg21.link/cwg1346




Richard Smith
-
d:cwg1347
CWG1347
16 August 2011
CD3
Consistency of auto in multiple-declarator declarations
https://wg21.link/cwg1347




Richard Smith
-
d:cwg1348
CWG1348
16 August 2011
drafting
Use of auto in a trailing-return-type
https://wg21.link/cwg1348




Richard Smith
-
d:cwg1349
CWG1349
16 August 2011
dup
Consistency of alias template redeclarations
https://wg21.link/cwg1349




Richard Smith
-
d:cwg135
CWG135
1 July 1999
TC1
Class type in in-class member function definitions
https://wg21.link/cwg135




Gabriel Netterdag
-
d:cwg1350
CWG1350
16 August 2011
CD3
Incorrect exception specification for inherited constructors
https://wg21.link/cwg1350




-
d:cwg1351
CWG1351
16 August 2011
CD4
Problems with implicitly-declared exception-specifications
https://wg21.link/cwg1351




Richard Smith
-
d:cwg1352
CWG1352
16 August 2011
CD3
Inconsistent class scope and completeness rules
https://wg21.link/cwg1352




Richard Smith
-
d:cwg1353
CWG1353
16 August 2011
drafting
Array and variant members and deleted special member functions
https://wg21.link/cwg1353




Sean Hunt
-
d:cwg1354
CWG1354
16 August 2011
CD3
Destructor exceptions for temporaries in noexcept expressions
https://wg21.link/cwg1354




Sebastian Redl
-
d:cwg1355
CWG1355
16 August 2011
CD3
Aggregates and “user-provided” constructors
https://wg21.link/cwg1355




Sean Hunt
-
d:cwg1356
CWG1356
16 August 2011
CD4
Exception specifications of copy assignment operators with virtual bases
https://wg21.link/cwg1356




Sean Hunt
-
d:cwg1357
CWG1357
16 August 2011
CD3
brace-or-equal-initializers for function and typedef members
https://wg21.link/cwg1357




Richard Smith
-
d:cwg1358
CWG1358
16 August 2011
CD3
Unintentionally ill-formed constexpr function template instances
https://wg21.link/cwg1358




Richard Smith
-
d:cwg1359
CWG1359
16 August 2011
CD3
constexpr union constructors
https://wg21.link/cwg1359




Richard Smith
-
d:cwg136
CWG136
9 July 1999
CD1
Default arguments and friend declarations
https://wg21.link/cwg136




Daveed Vandevoorde
-
d:cwg1360
CWG1360
16 August 2011
drafting
constexpr defaulted default constructors
https://wg21.link/cwg1360




Richard Smith
-
d:cwg1361
CWG1361
16 August 2011
CD3
Requirement on brace-or-equal-initializers of literal types
https://wg21.link/cwg1361




Richard Smith
-
d:cwg1362
CWG1362
16 August 2011
CD3
Complete type required for implicit conversion to T&
https://wg21.link/cwg1362




Richard Smith
-
d:cwg1363
CWG1363
16 August 2011
CD3
Triviality vs multiple default constructors
https://wg21.link/cwg1363




Sean Hunt
-
d:cwg1364
CWG1364
17 August 2011
CD3
constexpr function parameters
https://wg21.link/cwg1364




Sean Hunt
-
d:cwg1365
CWG1365
17 August 2011
CD3
Calling undefined constexpr functions
https://wg21.link/cwg1365




Sean Hunt
-
d:cwg1366
CWG1366
17 August 2011
CD3
Deleted constexpr constructors and virtual base classes
https://wg21.link/cwg1366




Sean Hunt
-
d:cwg1367
CWG1367
17 August 2011
CD3
Use of this in a constant expression
https://wg21.link/cwg1367




Jason Merrill
-
d:cwg1368
CWG1368
28 June 2011
CD3
Value initialization and defaulted constructors (part 2)
https://wg21.link/cwg1368




Jason Merrill
-
d:cwg1369
CWG1369
18 August 2011
CD3
Function invocation substitution of this
https://wg21.link/cwg1369




Jens Maurer
-
d:cwg137
CWG137
13 July 1999
TC1
static_cast of cv void*
https://wg21.link/cwg137




Mike Miller
-
d:cwg1370
CWG1370
14 August 2011
CD3
identifier-list cannot contain ellipsis
https://wg21.link/cwg1370




Nikolay Ivchenkov
-
d:cwg1371
CWG1371
15 August 2011
NAD
Deduction from T&& in return types
https://wg21.link/cwg1371




Michael Wong
-
d:cwg1372
CWG1372
15 August 2011
CD3
Cross-references incorrect in conversion function template argument deduction
https://wg21.link/cwg1372




Michael Wong
-
d:cwg1373
CWG1373
15 August 2011
dup
Overload resolution changes matching reference-binding changes
https://wg21.link/cwg1373




Michael Wong
-
d:cwg1374
CWG1374
15 August 2011
CD3
Qualification conversion vs difference in reference binding
https://wg21.link/cwg1374




Michael Wong
-
d:cwg1375
CWG1375
16 August 2011
CD3
Reference to anonymous union?
https://wg21.link/cwg1375




Daveed Vandevoorde
-
d:cwg1376
CWG1376
17 August 2011
C++14
static_cast of temporary to rvalue reference
https://wg21.link/cwg1376




Michael Wong
-
d:cwg1377
CWG1377
18 August 2011
dup
Access declarations not mentioned in Annex C
https://wg21.link/cwg1377




Daveed Vandevoorde
-
d:cwg1378
CWG1378
18 August 2011
open
When is an instantiation required?
https://wg21.link/cwg1378




Jason Merrill
-
d:cwg1379
CWG1379
21 August 2011
NAD
Is std::initializer_list an aggregate?
https://wg21.link/cwg1379




Daniel Krügler
-
d:cwg138
CWG138
14 July 1999
drafting
Friend declaration name lookup
https://wg21.link/cwg138




Martin von Loewis
-
d:cwg1380
CWG1380
22 August 2011
CD3
Type definitions in template-parameter parameter-declarations
https://wg21.link/cwg1380




Daniel Krügler
-
d:cwg1381
CWG1381
26 August 2011
CD3
Implicitly-declared special member functions and default nothrow
https://wg21.link/cwg1381




David Svoboda
-
d:cwg1382
CWG1382
27 August 2011
CD3
Dead code for constructor names
https://wg21.link/cwg1382




Johannes Schaub
-
d:cwg1383
CWG1383
20110830
CD3
Clarifying discarded-value expressions
https://wg21.link/cwg1383




Lawrence Crowl
-
d:cwg1384
CWG1384
20110830
NAD
reinterpret_cast in constant expressions
https://wg21.link/cwg1384




Daniel Krügler
-
d:cwg1385
CWG1385
20110831
CD3
Syntactic forms of conversion functions for surrogate call functions
https://wg21.link/cwg1385




Daniel Krügler
-
d:cwg1386
CWG1386
1 September 2011
NAD
Explicitly-specified partial argument list with multiple parameter packs
https://wg21.link/cwg1386




James Widman
-
d:cwg1387
CWG1387
2 September 2011
CD3
Missing non-deduced context for decltype
https://wg21.link/cwg1387




James Widman
-
d:cwg1388
CWG1388
2 September 2011
CD3
Missing non-deduced context following a function parameter pack
https://wg21.link/cwg1388




James Widman
-
d:cwg1389
CWG1389
4 September 2011
NAD
Recursive reference in trailing-return-type
https://wg21.link/cwg1389




Daniel Krügler
-
d:cwg139
CWG139
14 July 1999
CD1
Error in friend lookup example
https://wg21.link/cwg139




Mike Miller
-
d:cwg1390
CWG1390
4 September 2011
drafting
Dependency of alias template specializations
https://wg21.link/cwg1390




Johannes Schaub
-
d:cwg1391
CWG1391
8 September 2011
CD4
Conversions to parameter types with non-deduced template arguments
https://wg21.link/cwg1391




Jason Merrill
-
d:cwg1392
CWG1392
8 September 2011
CD3
Explicit conversion functions for references and non-references
https://wg21.link/cwg1392




Jason Merrill
-
d:cwg1393
CWG1393
10 September 2011
extension
Pack expansions in using-declarations
https://wg21.link/cwg1393




Daniel Krügler
-
d:cwg1394
CWG1394
11 September 2011
CD3
Incomplete types as parameters of deleted functions
https://wg21.link/cwg1394




Johannes Schaub
-
d:cwg1395
CWG1395
21 September 2011
C++17
Partial ordering of variadic templates reconsidered
https://wg21.link/cwg1395




John Spicer
-
d:cwg1396
CWG1396
22 September 2011
drafting
Deferred instantiation and checking of non-static data member initializers
https://wg21.link/cwg1396




Jason Merrill
-
d:cwg1397
CWG1397
23 September 2011
CD4
Class completeness in non-static data member initializers
https://wg21.link/cwg1397




Jason Merrill
-
d:cwg1398
CWG1398
27 September 2011
CD3
Non-type template parameters of type std::nullptr_t
https://wg21.link/cwg1398




Daniel Krügler
-
d:cwg1399
CWG1399
29 September 2011
CD3
Deduction with multiple function parameter packs
https://wg21.link/cwg1399




Jason Merrill
-
d:cwg14
CWG14

NAD
extern "C" functions and declarations in different namespaces
https://wg21.link/cwg14




Erwin Unruh
-
d:cwg140
CWG140
15 July 1999
CD1
Agreement of parameter declarations
https://wg21.link/cwg140




Steve Clamage
-
d:cwg1400
CWG1400
20110930
NAD
Function pointer equality
https://wg21.link/cwg1400




Nikolay Ivchenkov
-
d:cwg1401
CWG1401
3 October 2011
CD3
Similar types and reference compatibility
https://wg21.link/cwg1401




Daniel Krügler
-
d:cwg1402
CWG1402
3 October 2011
CD3
Move functions too often deleted
https://wg21.link/cwg1402




Daniel Krügler
-
d:cwg1403
CWG1403
5 October 2011
open
Universal-character-names in comments
https://wg21.link/cwg1403




David Krauss
-
d:cwg1404
CWG1404
19 October 2011
drafting
Object reallocation in unions
https://wg21.link/cwg1404




Nikolay Ivchenkov
-
d:cwg1405
CWG1405
21 October 2011
CD3
constexpr and mutable members of literal types
https://wg21.link/cwg1405




Richard Smith
-
d:cwg1406
CWG1406
21 October 2011
CD3
ref-qualifiers and added parameters of non-static member function templates
https://wg21.link/cwg1406




Richard Smith
-
d:cwg1407
CWG1407
21 October 2011
NAD
Integral to bool conversion in converted constant expressions
https://wg21.link/cwg1407




Richard Smith
-
d:cwg1408
CWG1408
24 October 2011
CD3
What is “the same aggregate initialization?”
https://wg21.link/cwg1408




Sebastian Redl
-
d:cwg1409
CWG1409
24 October 2011
CD3
What is the second standard conversion sequence of a list-initialization sequence?
https://wg21.link/cwg1409




Sebastian Redl
-
d:cwg141
CWG141
31 July 1999
CD1
Non-member function templates in member access expressions
https://wg21.link/cwg141




fvali
-
d:cwg1410
CWG1410
26 October 2011
CD3
Reference overload tiebreakers should apply to rvalue references
https://wg21.link/cwg1410




Michael Wong
-
d:cwg1411
CWG1411
28 October 2011
CD3
More on global scope :: in nested-name-specifier
https://wg21.link/cwg1411




David Blaikie
-
d:cwg1412
CWG1412
1 November 2011
CD3
Problems in specifying pointer conversions
https://wg21.link/cwg1412




Nikolay Ivchenkov
-
d:cwg1413
CWG1413
9 November 2011
CD3
Missing cases of value-dependency
https://wg21.link/cwg1413




Richard Smith
-
d:cwg1414
CWG1414
9 November 2011
drafting
Binding an rvalue reference to a reference-unrelated lvalue
https://wg21.link/cwg1414




Mike Miller
-
d:cwg1415
CWG1415
13 November 2011
CD3
Missing prohibition of block-scope definition of extern object
https://wg21.link/cwg1415




Richard Smith
-
d:cwg1416
CWG1416
17 November 2011
CD3
Function cv-qualifiers and typeid
https://wg21.link/cwg1416




Daniel Krügler
-
d:cwg1417
CWG1417
17 November 2011
C++14
Pointers/references to functions with cv-qualifiers or ref-qualifier
https://wg21.link/cwg1417




Daniel Krügler
-
d:cwg1418
CWG1418
19 November 2011
CD3
Type of initializer_list backing array
https://wg21.link/cwg1418




Johannes Schaub
-
d:cwg1419
CWG1419
22 November 2011
NAD
Evaluation order in aggregate initialization
https://wg21.link/cwg1419




Jason Merrill
-
d:cwg142
CWG142
16 July 1999
TC1
Injection-related errors in access example
https://wg21.link/cwg142




Steve Adamczyk
-
d:cwg1420
CWG1420
20111130
NAD
Abstract final classes
https://wg21.link/cwg1420




Richard Smith
-
d:cwg1421
CWG1421
3 December 2011
NAD
Full expressions and aggregate initialization
https://wg21.link/cwg1421




Jason Merrill
-
d:cwg1422
CWG1422
3 December 2011
dup
Type of character literals containing universal-character-names
https://wg21.link/cwg1422




Dave Abrahams
-
d:cwg1423
CWG1423
4 December 2011
CD3
Convertibility of nullptr to bool
https://wg21.link/cwg1423




Dave Abrahams
-
d:cwg1424
CWG1424
7 December 2011
C++14
When must sub-object destructors be accessible?
https://wg21.link/cwg1424




Daniel Krügler
-
d:cwg1425
CWG1425
7 December 2011
CD3
Base-class subobjects of standard-layout structs
https://wg21.link/cwg1425




Ville Voutilainen
-
d:cwg1426
CWG1426
8 December 2011
extension
Allowing additional parameter types in defaulted functions
https://wg21.link/cwg1426




Nikolay Ivchenkov
-
d:cwg1427
CWG1427
8 December 2011
NAD
Default constructor and deleted or inaccessible destructors
https://wg21.link/cwg1427




Daniel Krügler
-
d:cwg1428
CWG1428
8 December 2011
CD3
Dynamic const objects
https://wg21.link/cwg1428




Daniel Krügler
-
d:cwg1429
CWG1429
9 December 2011
NAD
Scope of a member template's template parameter
https://wg21.link/cwg1429




James Widman
-
d:cwg143
CWG143
21 July 1999
CD1
Friends and Koenig lookup
https://wg21.link/cwg143




Mike Miller
-
d:cwg1430
CWG1430
13 December 2011
drafting
Pack expansion into fixed alias template parameter list
https://wg21.link/cwg1430




Jason Merrill
-
d:cwg1431
CWG1431
16 December 2011
CD3
Exceptions from other than throw-expressions
https://wg21.link/cwg1431




Nikolay Ivchenkov
-
d:cwg1432
CWG1432
17 December 2011
drafting
Newly-ambiguous variadic template expansions
https://wg21.link/cwg1432




Daniel Krügler
-
d:cwg1433
CWG1433
20 December 2011
extension
trailing-return-type and point of declaration
https://wg21.link/cwg1433




Jason Merrill
-
d:cwg1434
CWG1434
21 December 2011
NAD
Parenthesized braced-init-list
https://wg21.link/cwg1434




Daniel Krügler
-
d:cwg1435
CWG1435
24 December 2011
CD3
template-id as the declarator for a class template constructor
https://wg21.link/cwg1435




Johannes Schaub
-
d:cwg1436
CWG1436
2 January 2012
drafting
Interaction of constant expression changes with preprocessor expressions
https://wg21.link/cwg1436




Richard Smith
-
d:cwg1437
CWG1437
2 January 2012
CD3
alignas in alias-declaration
https://wg21.link/cwg1437




Daveed Vandevoorde
-
d:cwg1438
CWG1438
3 January 2012
CD3
Non-dereference use of invalid pointers
https://wg21.link/cwg1438




Anthony Williams
-
d:cwg1439
CWG1439
4 January 2012
CD3
Lookup and friend template declarations
https://wg21.link/cwg1439




Richard Smith
-
d:cwg144
CWG144
22 July 1999
open
Position of friend specifier
https://wg21.link/cwg144




Daveed Vandevoorde
-
d:cwg1440
CWG1440
5 January 2012
CD3
Acceptable decltype-specifiers used as nested-name-specifiers
https://wg21.link/cwg1440




Mike Miller
-
d:cwg1441
CWG1441
6 January 2012
C++14
Unclear wording for signal handler restrictions
https://wg21.link/cwg1441




Alisdair Meredith
-
d:cwg1442
CWG1442
16 January 2012
CD3
Argument-dependent lookup in the range-based for
https://wg21.link/cwg1442




Mike Miller
-
d:cwg1443
CWG1443
13 January 2012
NAD
Default arguments and non-static data members
https://wg21.link/cwg1443




Jason Merrill
-
d:cwg1444
CWG1444
15 January 2012
drafting
Type adjustments of non-type template parameters
https://wg21.link/cwg1444




Johannes Schaub
-
d:cwg1445
CWG1445
16 January 2012
dup
Argument-dependent lookup of begin and end
https://wg21.link/cwg1445




Mike Miller
-
d:cwg1446
CWG1446
7 February 2012
CD4
Member function with no ref-qualifier and non-member function with rvalue reference
https://wg21.link/cwg1446




Jason Merrill
-
d:cwg1447
CWG1447
16 January 2012
CD3
static_cast of bit-field lvalue to rvalue reference
https://wg21.link/cwg1447




Jason Merrill
-
d:cwg1448
CWG1448
19 January 2012
NAD
Integral values of type bool
https://wg21.link/cwg1448




Johannes Schaub
-
d:cwg1449
CWG1449
28 January 2012
CD3
Narrowing conversion of negative value to unsigned type
https://wg21.link/cwg1449




Richard Smith
-
d:cwg145
CWG145
23 July 1999
TC1
Deprecation of prefix ++
https://wg21.link/cwg145




Mike Miller
-
d:cwg1450
CWG1450
20120131
CD3
INT_MIN % -1
https://wg21.link/cwg1450




Richard Smith
-
d:cwg1451
CWG1451
1 February 2012
extension
Objects with no linkage in non-type template arguments
https://wg21.link/cwg1451




Daniel Krügler
-
d:cwg1452
CWG1452
24 December 2011
drafting
Value-initialized objects may be constants
https://wg21.link/cwg1452




Richard Smith
-
d:cwg1453
CWG1453
2 January 2012
CD3
Volatile members in literal classes?
https://wg21.link/cwg1453




Richard Smith
-
d:cwg1454
CWG1454
27 December 2011
CD3
Passing constants through constexpr functions via references
https://wg21.link/cwg1454




Richard Smith
-
d:cwg1455
CWG1455
14 January 2012
CD3
Lvalue converted constant expressions
https://wg21.link/cwg1455




Richard Smith
-
d:cwg1456
CWG1456
14 January 2012
CD3
Address constant expression designating the one-past-the-end address
https://wg21.link/cwg1456




Richard Smith
-
d:cwg1457
CWG1457
4 February 2012
CD3
Undefined behavior in left-shift
https://wg21.link/cwg1457




Howard Hinnant
-
d:cwg1458
CWG1458
7 February 2012
CD3
Address of incomplete type vs operator&()
https://wg21.link/cwg1458




Richard Smith
-
d:cwg1459
CWG1459
7 February 2012
open
Reference-binding tiebreakers in overload resolution
https://wg21.link/cwg1459




Jason Merrill
-
d:cwg146
CWG146
23 July 1999
open
Floating-point zero
https://wg21.link/cwg146




Andy Sawyer
-
d:cwg1460
CWG1460
8 February 2012
C++14
What is an empty union?
https://wg21.link/cwg1460




Jason Merrill
-
d:cwg1461
CWG1461
8 February 2012
NAD
Narrowing conversions to bit-fields
https://wg21.link/cwg1461




Richard Corden
-
d:cwg1462
CWG1462
8 February 2012
CD3
Deduction failure vs “ill-formed, no diagnostic required”
https://wg21.link/cwg1462




John Spicer
-
d:cwg1463
CWG1463
19 August 2011
extension
extern "C" alias templates
https://wg21.link/cwg1463




Daveed Vandevoorde
-
d:cwg1464
CWG1464
12 February 2012
CD3
Negative array bound in a new-expression
https://wg21.link/cwg1464




Mike Miller
-
d:cwg1465
CWG1465
12 February 2012
CD4
noexcept and std::bad_array_new_length
https://wg21.link/cwg1465




Daniel Krügler
-
d:cwg1466
CWG1466
21 February 2012
C++14
Visible sequences of side effects are redundant
https://wg21.link/cwg1466




Mark Batty
-
d:cwg1467
CWG1467
6 February 2012
CD4
List-initialization of aggregate from same-type object
https://wg21.link/cwg1467




Jason Merrill
-
d:cwg1468
CWG1468
8 February 2012
drafting
typeid, overload resolution, and implicit lambda capture
https://wg21.link/cwg1468




Doug Gregor
-
d:cwg1469
CWG1469
12 February 2012
extension
Omitted bound in array new-expression
https://wg21.link/cwg1469




Johannes Schaub
-
d:cwg147
CWG147
21 February 1999
TC1
Naming the constructor
https://wg21.link/cwg147




John Spicer
-
d:cwg1470
CWG1470
14 February 2012
NAD
Thread migration
https://wg21.link/cwg1470




Detlef Vollman
-
d:cwg1471
CWG1471
26 February 2012
CD3
Nested type of non-dependent base
https://wg21.link/cwg1471




Johannes Schaub
-
d:cwg1472
CWG1472
1 March 2012
CD3
odr-use of reference variables
https://wg21.link/cwg1472




Richard Smith
-
d:cwg1473
CWG1473
5 March 2012
CD3
Syntax of literal-operator-id
https://wg21.link/cwg1473




Richard Smith
-
d:cwg1474
CWG1474
5 March 2012
NAD
User-defined literals and <inttypes.h> format macros
https://wg21.link/cwg1474




Richard Smith
-
d:cwg1475
CWG1475
6 March 2012
CD3
Errors in [[carries_dependency]] example
https://wg21.link/cwg1475




Stephan Lavavej
-
d:cwg1476
CWG1476
8 March 2012
CD3
Definition of user-defined type
https://wg21.link/cwg1476




Loïc Joly
-
d:cwg1477
CWG1477
9 March 2012
CD3
Definition of a friend outside its namespace
https://wg21.link/cwg1477




John Spicer
-
d:cwg1478
CWG1478
10 March 2012
drafting
template keyword for dependent template template arguments
https://wg21.link/cwg1478




Johannes Schaub
-
d:cwg1479
CWG1479
13 March 2012
CD3
Literal operators and default arguments
https://wg21.link/cwg1479




Jason Merrill
-
d:cwg148
CWG148
31 July 1999
TC1
POD classes and pointers to members
https://wg21.link/cwg148




Nathan Sidwell
-
d:cwg1480
CWG1480
17 March 2012
CD3
Constant initialization via non-constant temporary
https://wg21.link/cwg1480




Daniel Krügler
-
d:cwg1481
CWG1481
20 March 2012
CD3
Increment/decrement operators with reference parameters
https://wg21.link/cwg1481




Ryou Ezoe
-
d:cwg1482
CWG1482
20 March 2012
CD3
Point of declaration of enumeration
https://wg21.link/cwg1482




Daveed Vandevoorde
-
d:cwg1483
CWG1483
23 March 2012
NAD
Non-dependent static_assert-declarations
https://wg21.link/cwg1483




Mike Miller
-
d:cwg1484
CWG1484
25 March 2012
CD4
Unused local classes of function templates
https://wg21.link/cwg1484




Johannes Schaub
-
d:cwg1485
CWG1485
26 March 2012
drafting
Out-of-class definition of member unscoped opaque enumeration
https://wg21.link/cwg1485




Richard Smith
-
d:cwg1486
CWG1486
26 March 2012
drafting
Base-derived conversion in member pointer deduction
https://wg21.link/cwg1486




John Spicer
-
d:cwg1487
CWG1487
27 March 2012
CD3
When are inheriting constructors declared?
https://wg21.link/cwg1487




Richard Smith
-
d:cwg1488
CWG1488
28 March 2012
drafting
abstract-pack-declarators in type-ids
https://wg21.link/cwg1488




Richard Smith
-
d:cwg1489
CWG1489
29 March 2012
CD3
Is value-initialization of an array constant initialization?
https://wg21.link/cwg1489




Steve Adamczyk
-
d:cwg149
CWG149
31 July 1999
TC1
Accessibility and ambiguity
https://wg21.link/cwg149




Nathan Sidwell
-
d:cwg1490
CWG1490
29 March 2012
CD4
List-initialization from a string literal
https://wg21.link/cwg1490




Daveed Vandevoorde
-
d:cwg1491
CWG1491
20120330
CD3
Move construction and rvalue reference members
https://wg21.link/cwg1491




Richard Smith
-
d:cwg1492
CWG1492
1 April 2012
CD4
Exception specifications on template destructors
https://wg21.link/cwg1492




Jason Merrill
-
d:cwg1493
CWG1493
2 April 2012
C++14
Criteria for move-construction
https://wg21.link/cwg1493




John Spicer
-
d:cwg1494
CWG1494
12 April 2012
CD3
Temporary initialization for reference binding in list-initialization
https://wg21.link/cwg1494




Steve Adamczyk
-
d:cwg1495
CWG1495
16 April 2012
CD3
Partial specialization of variadic class template
https://wg21.link/cwg1495




Jason Merrill
-
d:cwg1496
CWG1496
25 April 2012
CD4
Triviality with deleted and missing default constructors
https://wg21.link/cwg1496




Daniel Krügler
-
d:cwg1497
CWG1497
25 April 2012
NAD
Aggregate initialization with parenthesized string literal
https://wg21.link/cwg1497




Daveed Vandevoorde
-
d:cwg1498
CWG1498
26 April 2012
dup
Lifetime of temporaries in range-based for
https://wg21.link/cwg1498




Beman Dawes
-
d:cwg1499
CWG1499
27 April 2012
drafting
Missing case for deleted move assignment operator
https://wg21.link/cwg1499




John Spicer
-
d:cwg15
CWG15

dup
Default arguments for parameters of function templates
https://wg21.link/cwg15




unknown
-
d:cwg150
CWG150
3 August 1999
C++17
Template template parameters and default arguments
https://wg21.link/cwg150




Mike Miller
-
d:cwg1500
CWG1500
27 April 2012
open
Name lookup of dependent conversion function
https://wg21.link/cwg1500




Johannes Schaub
-
d:cwg1501
CWG1501
4 May 2012
NAD
Nested braces in list-initialization
https://wg21.link/cwg1501




Steve Adamczyk
-
d:cwg1502
CWG1502
6 May 2012
CD3
Value initialization of unions with member initializers
https://wg21.link/cwg1502




Richard Smith
-
d:cwg1503
CWG1503
11 May 2012
CD3
Exceptions during copy to exception object
https://wg21.link/cwg1503




Daniel Krügler
-
d:cwg1504
CWG1504
20 May 2012
CD3
Pointer arithmetic after derived-base conversion
https://wg21.link/cwg1504




Loïc Joly
-
d:cwg1505
CWG1505
27 May 2012
dup
Direct binding of reference to temporary in list-initialization
https://wg21.link/cwg1505




Steve Adamczyk
-
d:cwg1506
CWG1506
29 May 2012
CD3
Value category of initializer_list object
https://wg21.link/cwg1506




Steve Adamczyk
-
d:cwg1507
CWG1507
1 June 2012
CD3
Value initialization with trivial inaccessible default constructor
https://wg21.link/cwg1507




Johannes Schaub
-
d:cwg1508
CWG1508
6 June 2012
C++14
Template initializer-list constructors
https://wg21.link/cwg1508




Daveed Vandevoorde
-
d:cwg1509
CWG1509
8 June 2012
C++14
Definition of “non-template function”
https://wg21.link/cwg1509




Johannes Schaub
-
d:cwg151
CWG151
4 August 1999
TC1
Terminology of zero-initialization
https://wg21.link/cwg151




Valentin Bonnard
-
d:cwg1510
CWG1510
14 June 2012
CD3
cv-qualified references via decltype
https://wg21.link/cwg1510




Richard Smith
-
d:cwg1511
CWG1511
18 June 2012
CD3
const volatile variables and the one-definition rule
https://wg21.link/cwg1511




Richard Smith
-
d:cwg1512
CWG1512
22 June 2012
CD3
Pointer comparison vs qualification conversions
https://wg21.link/cwg1512




Steve Clamage
-
d:cwg1513
CWG1513
28 June 2012
drafting
initializer_list deduction failure
https://wg21.link/cwg1513




Steve Adamczyk
-
d:cwg1514
CWG1514
3 July 2012
C++14
Ambiguity between enumeration definition and zero-length bit-field
https://wg21.link/cwg1514




John Spicer
-
d:cwg1515
CWG1515
3 July 2012
CD3
Modulo 2n arithmetic for implicitly-unsigned types
https://wg21.link/cwg1515




Sean Hunt
-
d:cwg1516
CWG1516
5 July 2012
CD3
Definition of “virtual function call”
https://wg21.link/cwg1516




Nikolay Ivchenkov
-
d:cwg1517
CWG1517
7 July 2012
drafting
Unclear/missing description of behavior during construction/destruction
https://wg21.link/cwg1517




Daniel Krügler
-
d:cwg1518
CWG1518
8 July 2012
CD4
Explicit default constructors and copy-list-initialization
https://wg21.link/cwg1518




Richard Smith
-
d:cwg1519
CWG1519
9 July 2012
NAD
Conflicting default and variadic constructors
https://wg21.link/cwg1519




Ville Voutilainen
-
d:cwg152
CWG152
4 August 1999
TC1
explicit copy constructors
https://wg21.link/cwg152




Steve Adamczyk
-
d:cwg1520
CWG1520
9 July 2012
NAD
Alias template specialization vs pack expansion
https://wg21.link/cwg1520




Eric Niebler
-
d:cwg1521
CWG1521
10 July 2012
drafting
T{expr} with reference types
https://wg21.link/cwg1521




Steve Adamczyk
-
d:cwg1522
CWG1522
12 July 2012
CD3
Access checking for initializer_list array initialization
https://wg21.link/cwg1522




John Spicer
-
d:cwg1523
CWG1523
16 July 2012
DRWP
Point of declaration in range-based for
https://wg21.link/cwg1523




John Spicer
-
d:cwg1524
CWG1524
17 July 2012
drafting
Incompletely-defined class template base
https://wg21.link/cwg1524




Jason Merrill
-
d:cwg1525
CWG1525
18 July 2012
NAD
Array bound inference in temporary array
https://wg21.link/cwg1525




Steve Adamczyk
-
d:cwg1526
CWG1526
22 July 2012
dup
Dependent-class lookup in the current instantiation
https://wg21.link/cwg1526




Johannes Schaub
-
d:cwg1527
CWG1527
23 July 2012
CD3
Assignment from braced-init-list
https://wg21.link/cwg1527




Mike Miller
-
d:cwg1528
CWG1528
23 July 2012
CD3
Repeated cv-qualifiers in declarators
https://wg21.link/cwg1528




Richard Smith
-
d:cwg1529
CWG1529
24 July 2012
drafting
Nomenclature for variable vs reference non-static data member
https://wg21.link/cwg1529




Daniel Krügler
-
d:cwg153
CWG153
6 August 1999
TC1
Misleading wording (rank of conversion)
https://wg21.link/cwg153




Valentin Bonnard
-
d:cwg1530
CWG1530
26 July 2012
drafting
Member access in out-of-lifetime objects
https://wg21.link/cwg1530




Howard Hinnant
-
d:cwg1531
CWG1531
27 July 2012
CD3
Definition of “access” (verb)
https://wg21.link/cwg1531




Mike Miller
-
d:cwg1532
CWG1532
4 August 2012
CD3
Explicit instantiation and member templates
https://wg21.link/cwg1532




Johannes Schaub
-
d:cwg1533
CWG1533
6 August 2012
CD3
Function pack expansion for member initialization
https://wg21.link/cwg1533




Jonathan Caves
-
d:cwg1534
CWG1534
9 August 2012
dup
cv-qualification of prvalue of type “array of class”
https://wg21.link/cwg1534




Daveed Vandevoorde
-
d:cwg1535
CWG1535
10 August 2012
CD3
typeid in core constant expressions
https://wg21.link/cwg1535




Richard Smith
-
d:cwg1536
CWG1536
14 August 2012
drafting
Overload resolution with temporary from initializer list
https://wg21.link/cwg1536




Mike Miller
-
d:cwg1537
CWG1537
14 August 2012
CD3
Optional compile-time evaluation of constant expressions
https://wg21.link/cwg1537




John Spicer
-
d:cwg1538
CWG1538
14 August 2012
CD3
C-style cast in braced-init-list assignment
https://wg21.link/cwg1538




Daniel Krügler
-
d:cwg1539
CWG1539
15 August 2012
CD3
Definition of “character type”
https://wg21.link/cwg1539




Beman Dawes
-
d:cwg154
CWG154
9 August 1999
NAD
Anonymous unions in unnamed namespaces
https://wg21.link/cwg154




Greg Comeau
-
d:cwg1540
CWG1540
16 August 2012
NAD
Use of address constants in constant expressions
https://wg21.link/cwg1540




Bjarne Stroustrup
-
d:cwg1541
CWG1541
21 August 2012
CD3
cv void return types
https://wg21.link/cwg1541




Sean Hunt
-
d:cwg1542
CWG1542
21 August 2012
drafting
Compound assignment of braced-init-list
https://wg21.link/cwg1542




Mike Miller
-
d:cwg1543
CWG1543
21 August 2012
CD3
Implicit conversion sequence for empty initializer list
https://wg21.link/cwg1543




Steve Adamczyk
-
d:cwg1544
CWG1544
24 August 2012
CD3
Linkage of member of unnamed namespace
https://wg21.link/cwg1544




Nikolay Ivchenkov
-
d:cwg1545
CWG1545
25 August 2012
drafting
friend function templates defined in class templates
https://wg21.link/cwg1545




Daniel Krügler
-
d:cwg1546
CWG1546
27 August 2012
NAD
Errors in function template default arguments
https://wg21.link/cwg1546




Jason Merrill
-
d:cwg1547
CWG1547
1 September 2012
NAD
typename keyword in alias-declarations
https://wg21.link/cwg1547




Daniel Krügler
-
d:cwg1548
CWG1548
2 September 2012
drafting
Copy/move construction and conversion functions
https://wg21.link/cwg1548




Nikolay Ivchenkov
-
d:cwg1549
CWG1549
4 September 2012
open
Overloaded comma operator with void operand
https://wg21.link/cwg1549




Nikolay Ivchenkov
-
d:cwg155
CWG155
12 August 1999
dup
Brace initializer for scalar
https://wg21.link/cwg155




Steve Clamage
-
d:cwg1550
CWG1550
4 September 2012
CD3
Parenthesized throw-expression operand of conditional-expression
https://wg21.link/cwg1550




Nikolay Ivchenkov
-
d:cwg1551
CWG1551
6 September 2012
C++14
Wording problems in using-declaration specification
https://wg21.link/cwg1551




Richard Smith
-
d:cwg1552
CWG1552
7 September 2012
CD4
exception-specifications and defaulted special member functions
https://wg21.link/cwg1552




Daveed Vandevoorde
-
d:cwg1553
CWG1553
13 September 2012
CD3
sizeof and xvalue bit-fields
https://wg21.link/cwg1553




Richard Smith
-
d:cwg1554
CWG1554
17 September 2012
drafting
Access and alias templates
https://wg21.link/cwg1554




Jason Merrill
-
d:cwg1555
CWG1555
18 September 2012
extension
Language linkage and function type compatibility
https://wg21.link/cwg1555




Daniel Krügler
-
d:cwg1556
CWG1556
18 September 2012
CD3
Constructors and explicit conversion functions in direct initialization
https://wg21.link/cwg1556




Edward Catmur
-
d:cwg1557
CWG1557
19 September 2012
CD3
Language linkage of converted lambda function pointer
https://wg21.link/cwg1557




Scott Meyers
-
d:cwg1558
CWG1558
19 September 2012
CD4
Unused arguments in alias template specializations
https://wg21.link/cwg1558




Nikolay Ivchenkov
-
d:cwg1559
CWG1559
21 September 2012
CD3
String too long in initializer list of new-expression
https://wg21.link/cwg1559




John Spicer
-
d:cwg156
CWG156
18 August 1999
drafting
Name lookup for conversion functions
https://wg21.link/cwg156




Derek Inglis
-
d:cwg1560
CWG1560
4 September 2012
CD3
Gratuitous lvalue-to-rvalue conversion in conditional-expression with throw-expression operand
https://wg21.link/cwg1560




Nikolay Ivchenkov
-
d:cwg1561
CWG1561
29 September 2012
extension
Aggregates with empty base classes
https://wg21.link/cwg1561




Gabriel Dos Reis
-
d:cwg1562
CWG1562
1 October 2012
C++14
Non-static data member initializers and union ctor-initializer
https://wg21.link/cwg1562




Richard Smith
-
d:cwg1563
CWG1563
8 October 2012
CD3
List-initialization and overloaded function disambiguation
https://wg21.link/cwg1563




Daniel Krügler
-
d:cwg1564
CWG1564
9 October 2012
NAD
Template argument deduction from an initializer list
https://wg21.link/cwg1564




Faisal Vali
-
d:cwg1565
CWG1565
10 October 2012
NAD
Copy elision and lifetime of initializer_list underlying array
https://wg21.link/cwg1565




Steve Adamczyk
-
d:cwg1566
CWG1566
10 October 2012
NAD
Should new std::initializer_list<T> be ill-formed?
https://wg21.link/cwg1566




Steve Adamczyk
-
d:cwg1567
CWG1567
10 October 2012
C++14
Inheriting constructors and copy/move constructors
https://wg21.link/cwg1567




Jason Merrill
-
d:cwg1568
CWG1568
11 October 2012
dup
Temporary lifetime extension with intervening cast
https://wg21.link/cwg1568




Steve Adamczyk
-
d:cwg1569
CWG1569
6 February 2012
C++14
Deducing a function parameter pack before ellipsis
https://wg21.link/cwg1569




Michael Wong
-
d:cwg157
CWG157
19 August 1999
open
Omitted typedef declarator
https://wg21.link/cwg157




Daveed Vandevoorde
-
d:cwg1570
CWG1570
6 February 2012
C++14
Address of subobject as non-type template argument
https://wg21.link/cwg1570




Michael Wong
-
d:cwg1571
CWG1571
6 February 2012
CD4
cv-qualification for indirect reference binding via conversion function
https://wg21.link/cwg1571




Michael Wong
-
d:cwg1572
CWG1572
15 October 2012
CD4
Incorrect example for rvalue reference binding via conversion function
https://wg21.link/cwg1572




Michael Wong
-
d:cwg1573
CWG1573
15 October 2012
CD4
Inherited constructor characteristics
https://wg21.link/cwg1573




Jason Merrill
-
d:cwg1574
CWG1574
16 October 2012
NAD
Explicitly-defaulted constexpr functions in wrapper templates
https://wg21.link/cwg1574




Daniel Krügler
-
d:cwg1575
CWG1575
17 October 2012
C++14
Incorrect definition of “strict pointer safety”
https://wg21.link/cwg1575




Matt Austern
-
d:cwg1576
CWG1576
18 October 2012
C++14
Discarded-value volatile xvalues
https://wg21.link/cwg1576




Michael Wong
-
d:cwg1577
CWG1577
19 October 2012
NAD
Unnecessary restrictions on partial specializations
https://wg21.link/cwg1577




Jeremiah Wilcox
-
d:cwg1578
CWG1578
21 October 2012
NAD
Value-initialization of aggregates
https://wg21.link/cwg1578




Alisdair Meredith
-
d:cwg1579
CWG1579
23 October 2012
C++14
Return by converting move constructor
https://wg21.link/cwg1579




Jeffrey Yasskin
-
d:cwg158
CWG158
20 August 1999
CD1
Aliasing and qualification conversions
https://wg21.link/cwg158




Mike Stump
-
d:cwg1580
CWG1580
29 October 2012
drafting
Default arguments in explicit instantiations
https://wg21.link/cwg1580




Daveed Vandevoorde
-
d:cwg1581
CWG1581
29 October 2012
drafting
When are constexpr member functions defined?
https://wg21.link/cwg1581




Richard Smith
-
d:cwg1582
CWG1582
20121031
drafting
Template default arguments and deduction failure
https://wg21.link/cwg1582




John Spicer
-
d:cwg1583
CWG1583
3 November 2012
C++14
Incorrect example of unspecified behavior
https://wg21.link/cwg1583




Alisdair Meredith
-
d:cwg1584
CWG1584
4 November 2012
drafting
Deducing function types from cv-qualified types
https://wg21.link/cwg1584




Daniel Krügler
-
d:cwg1585
CWG1585
13 November 2012
NAD
Value category of member access of rvalue reference member
https://wg21.link/cwg1585




Daniel Krügler
-
d:cwg1586
CWG1586
14 November 2012
NAD
Naming a destructor via decltype
https://wg21.link/cwg1586




Steve Clamage
-
d:cwg1587
CWG1587
16 November 2012
C++14
constexpr initialization and nested anonymous unions
https://wg21.link/cwg1587




Daveed Vandvoorde
-
d:cwg1588
CWG1588
18 November 2012
CD3
Deducing cv-qualified auto
https://wg21.link/cwg1588




Jens Maurer
-
d:cwg1589
CWG1589
21 November 2012
CD4
Ambiguous ranking of list-initialization sequences
https://wg21.link/cwg1589




Johannes Schaub
-
d:cwg159
CWG159
23 August 1999
TC1
Namespace qualification in declarators
https://wg21.link/cwg159




John Spicer
-
d:cwg1590
CWG1590
26 November 2012
drafting
Bypassing non-copy/move constructor copying
https://wg21.link/cwg1590




Richard Smith
-
d:cwg1591
CWG1591
1 December 2012
CD4
Deducing array bound and element type from initializer list
https://wg21.link/cwg1591




Peter Dimov
-
d:cwg1592
CWG1592
3 December 2012
C++14
When do template parameters match?
https://wg21.link/cwg1592




Richard Smith
-
d:cwg1593
CWG1593
3 December 2012
C++14
“Parameter type” of special member functions
https://wg21.link/cwg1593




Richard Smith
-
d:cwg1594
CWG1594
6 December 2012
drafting
Lazy declaration of special members vs overload errors
https://wg21.link/cwg1594




Richard Smith
-
d:cwg1595
CWG1595
19 December 2012
C++14
Constructors “involved in” subobject initialization
https://wg21.link/cwg1595




Daveed Vandevoorde
-
d:cwg1596
CWG1596
20 December 2012
CD4
Non-array objects as array[1]
https://wg21.link/cwg1596




Daniel Krügler
-
d:cwg1597
CWG1597
21 December 2012
CD3
Misleading constexpr example
https://wg21.link/cwg1597




John Spicer
-
d:cwg1598
CWG1598
21 December 2012
C++14
Criterion for equality of pointers to members
https://wg21.link/cwg1598




Richard Smith
-
d:cwg1599
CWG1599
10 February 2012
open
Lifetime of initializer_list underlying array
https://wg21.link/cwg1599




Johannes Schaub
-
d:cwg16
CWG16

CD1
Access to members of indirect private base classes
https://wg21.link/cwg16




unknown
-
d:cwg160
CWG160
23 August 1999
CD1
Missing std:: qualification
https://wg21.link/cwg160




Al Stevens
-
d:cwg1600
CWG1600
20121230
CD4
Erroneous reference initialization in example
https://wg21.link/cwg1600




Niels Dekker
-
d:cwg1601
CWG1601
9 January 2013
C++14
Promotion of enumeration with fixed underlying type
https://wg21.link/cwg1601




Ville Voutilainen
-
d:cwg1602
CWG1602
9 January 2013
open
Linkage of specialization vs linkage of template arguments
https://wg21.link/cwg1602




Richard Smith
-
d:cwg1603
CWG1603
9 January 2013
CD4
Errors resulting from giving unnamed namespaces internal linkage
https://wg21.link/cwg1603




Richard Smith
-
d:cwg1604
CWG1604
10 January 2013
C++14
Double temporaries in reference initialization
https://wg21.link/cwg1604




Nikolay Ivchenkov
-
d:cwg1605
CWG1605
13 January 2013
CD3
Misleading parenthetical comment for explicit destructor call
https://wg21.link/cwg1605




Mike Miller
-
d:cwg1606
CWG1606
18 January 2013
NAD
sizeof closure class
https://wg21.link/cwg1606




John Spicer
-
d:cwg1607
CWG1607
19 January 2013
C++14
Lambdas in template parameters
https://wg21.link/cwg1607




Daniel Krügler
-
d:cwg1608
CWG1608
23 January 2013
C++14
Operator lookup in trailing return type
https://wg21.link/cwg1608




Johannes Schaub
-
d:cwg1609
CWG1609
25 January 2013
open
Default arguments and function parameter packs
https://wg21.link/cwg1609




Jonathan Caves
-
d:cwg161
CWG161
26 August 1999
TC1
Access to protected nested type
https://wg21.link/cwg161




Steve Adamczyk
-
d:cwg1610
CWG1610
28 January 2013
drafting
Cv-qualification in deduction of reference to array
https://wg21.link/cwg1610




Richard Smith
-
d:cwg1611
CWG1611
20130131
C++14
Deleted default constructor for abstract class
https://wg21.link/cwg1611




Ville Voutilainen
-
d:cwg1612
CWG1612
20130131
C++14
Implicit lambda capture and anonymous unions
https://wg21.link/cwg1612




Michael Wong
-
d:cwg1613
CWG1613
20130131
C++14
Constant expressions and lambda capture
https://wg21.link/cwg1613




Michael Wong
-
d:cwg1614
CWG1614
20130131
CD4
Address of pure virtual function vs odr-use
https://wg21.link/cwg1614




Richard Smith
-
d:cwg1615
CWG1615
1 February 2013
CD4
Alignment of types, variables, and members
https://wg21.link/cwg1615




Richard Smith
-
d:cwg1616
CWG1616
1 February 2013
drafting
Disambiguation parsing and template parameters
https://wg21.link/cwg1616




Johannes Schaub
-
d:cwg1617
CWG1617
2 February 2012
open
alignas and non-defining declarations
https://wg21.link/cwg1617




Richard Smith
-
d:cwg1618
CWG1618
3 February 2013
C++14
Gratuitously-unsigned underlying enum type
https://wg21.link/cwg1618




Daniel Krügler
-
d:cwg1619
CWG1619
4 February 2013
open
Definition of current instantiation
https://wg21.link/cwg1619




Johannes Schaub
-
d:cwg162
CWG162
26 August 1999
CD1
(&C::f)() with nonstatic members
https://wg21.link/cwg162




Steve Adamczyk
-
d:cwg1620
CWG1620
12 February 2013
open
User-defined literals and extended integer types
https://wg21.link/cwg1620




Jason Merrill
-
d:cwg1621
CWG1621
12 February 2013
drafting
Member initializers in anonymous unions
https://wg21.link/cwg1621




Daveed Vandevoorde
-
d:cwg1622
CWG1622
14 February 2013
C++17
Empty aggregate initializer for union
https://wg21.link/cwg1622




Daveed Vandevoorde
-
d:cwg1623
CWG1623
15 February 2013
drafting
Deleted default union constructor and member initializers
https://wg21.link/cwg1623




Vinny Romano
-
d:cwg1624
CWG1624
15 February 2013
NAD
Destruction of union members with member initializers
https://wg21.link/cwg1624




Vinny Romano
-
d:cwg1625
CWG1625
18 February 2013
open
Adding spaces between tokens in stringizing
https://wg21.link/cwg1625




Chandler Carruth
-
d:cwg1626
CWG1626
19 February 2013
drafting
constexpr member functions in brace-or-equal-initializers
https://wg21.link/cwg1626




Daveed Vandevoorde
-
d:cwg1627
CWG1627
22 February 2013
NAD
Agreement of dependent alignas specifiers
https://wg21.link/cwg1627




Richard Smith
-
d:cwg1628
CWG1628
22 February 2013
open
Deallocation function templates
https://wg21.link/cwg1628




Richard Smith
-
d:cwg1629
CWG1629
22 February 2012
C++14
Can a closure class be a literal type?
https://wg21.link/cwg1629




John Spicer
-
d:cwg163
CWG163
12 August 1999
TC1
Description of subaggregate initializer
https://wg21.link/cwg163




Mike Miller
-
d:cwg1630
CWG1630
1 March 2013
CD4
Multiple default constructor templates
https://wg21.link/cwg1630




Nikolay Ivchenkov
-
d:cwg1631
CWG1631
3 March 2013
CD4
Incorrect overload resolution for single-element initializer-list
https://wg21.link/cwg1631




Johannes Schaub
-
d:cwg1632
CWG1632
4 March 2013
open
Lambda capture in member initializers
https://wg21.link/cwg1632




Vinny Romano
-
d:cwg1633
CWG1633
4 March 2013
CD4
Copy-initialization in member initialization
https://wg21.link/cwg1633




Vinny Romano
-
d:cwg1634
CWG1634
4 March 2013
drafting
Temporary storage duration
https://wg21.link/cwg1634




Richard Smith
-
d:cwg1635
CWG1635
6 March 2013
drafting
How similar are template default arguments to function default arguments?
https://wg21.link/cwg1635




Richard Smith
-
d:cwg1636
CWG1636
7 March 2013
drafting
Bits required for negative enumerator values
https://wg21.link/cwg1636




Hyman Rosen
-
d:cwg1637
CWG1637
11 March 2013
NAD
Recursion in constexpr template default constructor
https://wg21.link/cwg1637




Daveed Vandevoorde
-
d:cwg1638
CWG1638
12 March 2013
CD4
Declaring an explicit specialization of a scoped enumeration
https://wg21.link/cwg1638




Richard Smith
-
d:cwg1639
CWG1639
12 February 2013
CD4
exception-specifications and pointer/pointer-to-member expressions
https://wg21.link/cwg1639




Steve Adamczyk
-
d:cwg164
CWG164
3 September 1999
TC1
Overlap between Koenig and normal lookup
https://wg21.link/cwg164




Derek Inglis
-
d:cwg1640
CWG1640
14 March 2013
drafting
Array of abstract instance of class template
https://wg21.link/cwg1640




Richard Smith
-
d:cwg1641
CWG1641
15 March 2013
NAD
Assignment in member initializer
https://wg21.link/cwg1641




John Spicer
-
d:cwg1642
CWG1642
15 March 2013
open
Missing requirements for prvalue operands
https://wg21.link/cwg1642




Joseph Mansfield
-
d:cwg1643
CWG1643
17 March 2013
extension
Default arguments for template parameter packs
https://wg21.link/cwg1643




Vinny Romano
-
d:cwg1644
CWG1644
17 March 2013
open
Equivalent exception-specifications in function template declarations
https://wg21.link/cwg1644




Richard Smith
-
d:cwg1645
CWG1645
18 March 2013
CD4
Identical inheriting constructors via default arguments
https://wg21.link/cwg1645




Richard Smith
-
d:cwg1646
CWG1646
28 March 2013
drafting
decltype-specifiers, abstract classes, and deduction failure
https://wg21.link/cwg1646




Jason Merrill
-
d:cwg1647
CWG1647
4 April 2013
drafting
Type agreement of non-type template arguments in partial specializations
https://wg21.link/cwg1647




John Spicer
-
d:cwg1648
CWG1648
12 April 2013
C++14
thread_local vs block extern declarations
https://wg21.link/cwg1648




Richard Smith
-
d:cwg1649
CWG1649
13 April 2013
C++14
Error in the syntax of mem-initializer-list
https://wg21.link/cwg1649




Daniel Krügler
-
d:cwg165
CWG165
7 September 1999
NAD
Definitions of friends and block-scope externs
https://wg21.link/cwg165




Derek Inglis
-
d:cwg1650
CWG1650
15 April 2013
NAD
Class prvalues in reference initialization
https://wg21.link/cwg1650




Michael Wong
-
d:cwg1651
CWG1651
15 April 2013
drafting
Lifetime extension of temporary via reference to subobject
https://wg21.link/cwg1651




Richard Smith
-
d:cwg1652
CWG1652
15 April 2013
CD4
Object addresses in constexpr expressions
https://wg21.link/cwg1652




Richard Smith
-
d:cwg1653
CWG1653
19 April 2013
CD4
Removing deprecated increment of bool
https://wg21.link/cwg1653




Bjarne Stroustrup
-
d:cwg1654
CWG1654
20 April 2013
dup
Literal types and constexpr defaulted constructors
https://wg21.link/cwg1654




Richard Smith
-
d:cwg1655
CWG1655
26 April 2013
drafting
Line endings in raw string literals
https://wg21.link/cwg1655




Mike Miller
-
d:cwg1656
CWG1656
20130430
drafting
Encoding of numerically-escaped characters
https://wg21.link/cwg1656




Mike Miller
-
d:cwg1657
CWG1657
26 August 2013
CD4
Attributes for namespaces and enumerators
https://wg21.link/cwg1657




Richard Smith
-
d:cwg1658
CWG1658
26 August 2013
C++14
Deleted default constructor for abstract class via destructor
https://wg21.link/cwg1658




Richard Smith
-
d:cwg1659
CWG1659
14 April 2013
open
Initialization order of thread_local template static data members
https://wg21.link/cwg1659




Richard Smith
-
d:cwg166
CWG166
8 September 1999
TC1
Friend declarations of template-ids
https://wg21.link/cwg166




John Spicer
-
d:cwg1660
CWG1660
15 April 2013
C++14
member-declaration requirements and unnamed bit-fields
https://wg21.link/cwg1660




Richard Smith
-
d:cwg1661
CWG1661
15 April 2013
NAD
Preservation of infinite loops
https://wg21.link/cwg1661




Daniel Krügler
-
d:cwg1662
CWG1662
15 April 2013
C++14
Capturing function parameter packs
https://wg21.link/cwg1662




Michael Wong
-
d:cwg1663
CWG1663
15 April 2013
NAD
Capturing an empty pack expansion
https://wg21.link/cwg1663




Michael Wong
-
d:cwg1664
CWG1664
15 April 2013
C++14
Argument-dependent lookup of lambdas used in default arguments
https://wg21.link/cwg1664




Michael Wong
-
d:cwg1665
CWG1665
19 April 2013
drafting
Declaration matching in explicit instantiations
https://wg21.link/cwg1665




Richard Smith
-
d:cwg1666
CWG1666
24 April 2013
C++14
Address constant expressions
https://wg21.link/cwg1666




Daniel Krügler
-
d:cwg1667
CWG1667
25 April 2013
NAD
Function exiting via exception called by destructor during unwinding
https://wg21.link/cwg1667




Ryou Ezoe
-
d:cwg1668
CWG1668
25 April 2013
drafting
Parameter type determination still not clear enough
https://wg21.link/cwg1668




Daniel Krügler
-
d:cwg1669
CWG1669
26 April 2013
C++14
auto return type for main
https://wg21.link/cwg1669




Richard Smith
-
d:cwg167
CWG167
8 September 1999
NAD
Deprecating static functions
https://wg21.link/cwg167




Darin Adler
-
d:cwg1670
CWG1670
26 April 2013
drafting
auto as conversion-type-id
https://wg21.link/cwg1670




Richard Smith
-
d:cwg1671
CWG1671
26 April 2013
NAD
Unclear rules for deduction with cv-qualification
https://wg21.link/cwg1671




Steve Clamage
-
d:cwg1672
CWG1672
27 April 2013
CD4
Layout compatibility with multiple empty bases
https://wg21.link/cwg1672




Richard Smith
-
d:cwg1673
CWG1673
29 April 2013
C++14
Clarifying overload resolution for the second step of copy-initialization
https://wg21.link/cwg1673




Vinny Romano
-
d:cwg1674
CWG1674
2 May 2013
C++14
Return type deduction for address of function
https://wg21.link/cwg1674




Richard Smith
-
d:cwg1675
CWG1675
3 May 2013
NAD
Size limit for automatic array object
https://wg21.link/cwg1675




Jason Merrill
-
d:cwg1676
CWG1676
4 May 2013
drafting
auto return type for allocation and deallocation functions
https://wg21.link/cwg1676




Richard Smith
-
d:cwg1677
CWG1677
5 May 2013
C++17
Constant initialization via aggregate initialization
https://wg21.link/cwg1677




Daniel Krügler
-
d:cwg1678
CWG1678
8 May 2013
NAD
Naming the type of an array of runtime bound
https://wg21.link/cwg1678




Mike Miller
-
d:cwg1679
CWG1679
9 May 2013
NAD
Range-based for and array of runtime bound
https://wg21.link/cwg1679




Jason Merrill
-
d:cwg168
CWG168
9 September 1999
NAD
C linkage for static member functions
https://wg21.link/cwg168




Darin Adler
-
d:cwg1680
CWG1680
13 May 2013
drafting
Including <initializer_list> for range-based for
https://wg21.link/cwg1680




Richard Smith
-
d:cwg1681
CWG1681
14 May 2013
C++14
init-captures and nested lambdas
https://wg21.link/cwg1681




Richard Smith
-
d:cwg1682
CWG1682
3 March 2009
open
Overly-restrictive rules on function templates as allocation functions
https://wg21.link/cwg1682




Jason Merrill
-
d:cwg1683
CWG1683
15 May 2013
CD4
Incorrect example after constexpr changes
https://wg21.link/cwg1683




Daniel Krügler
-
d:cwg1684
CWG1684
15 May 2013
C++14
Static constexpr member functions for non-literal classes
https://wg21.link/cwg1684




Richard Smith
-
d:cwg1685
CWG1685
16 May 2013
NAD
Value category of noexcept expression
https://wg21.link/cwg1685




Daniel Krügler
-
d:cwg1686
CWG1686
17 May 2013
CD4
Which variables are “explicitly declared const?”
https://wg21.link/cwg1686




Daniel Krügler
-
d:cwg1687
CWG1687
17 May 2013
C++14
Conversions of operands of built-in operators
https://wg21.link/cwg1687




Richard Smith
-
d:cwg1688
CWG1688
18 May 2013
NAD
Volatile constexpr variables
https://wg21.link/cwg1688




Daniel Krügler
-
d:cwg1689
CWG1689
26 May 2013
C++14
Syntactic nonterminal for operand of alignas
https://wg21.link/cwg1689




Richard Smith
-
d:cwg169
CWG169
16 September 1999
NAD
template-ids in using-declarations
https://wg21.link/cwg169




Valentin Bonnard
-
d:cwg1690
CWG1690
27 May 2013
C++14
Associated namespace for local type
https://wg21.link/cwg1690




Ville Voutilainen
-
d:cwg1691
CWG1691
27 May 2013
C++14
Argument-dependent lookup and opaque enumerations
https://wg21.link/cwg1691




David Krauss
-
d:cwg1692
CWG1692
29 May 2013
C++14
Associated namespaces of doubly-nested classes
https://wg21.link/cwg1692




David Krauss
-
d:cwg1693
CWG1693
29 May 2013
C++14
Superfluous semicolons in class definitions
https://wg21.link/cwg1693




Richard Smith
-
d:cwg1694
CWG1694
20130530
CD4
Restriction on reference to temporary as a constant expression
https://wg21.link/cwg1694




Richard Smith
-
d:cwg1695
CWG1695
20130531
NAD
Lifetime extension via init-capture
https://wg21.link/cwg1695




Richard Smith
-
d:cwg1696
CWG1696
20130531
CD4
Temporary lifetime and non-static data member initializers
https://wg21.link/cwg1696




Richard Smith
-
d:cwg1697
CWG1697
1 June 2013
drafting
Lifetime extension and copy elision
https://wg21.link/cwg1697




Richard Smith
-
d:cwg1698
CWG1698
10 June 2013
open
Files ending in \
https://wg21.link/cwg1698




David Krauss
-
d:cwg1699
CWG1699
12 June 2013
drafting
Does befriending a class befriend its friends?
https://wg21.link/cwg1699




David Krauss
-
d:cwg17
CWG17

NAD
Footnote 99 should discuss the naming class when describing members that can be accessed from friends
https://wg21.link/cwg17




unknown
-
d:cwg170
CWG170
16 September 1999
drafting
Pointer-to-member conversions
https://wg21.link/cwg170




Mike Stump
-
d:cwg1700
CWG1700
14 June 2013
NAD
Does the special rvalue-reference deduction apply to alias templates?
https://wg21.link/cwg1700




Daveed Vandevoorde
-
d:cwg1701
CWG1701
14 June 2013
drafting
Array vs sequence in object representation
https://wg21.link/cwg1701




Lawrence Crowl
-
d:cwg1702
CWG1702
17 June 2013
drafting
Rephrasing the definition of “anonymous union”
https://wg21.link/cwg1702




Richard Smith
-
d:cwg1703
CWG1703
17 June 2013
NAD
Language linkage of names of functions with internal linkage
https://wg21.link/cwg1703




Richard Smith
-
d:cwg1704
CWG1704
20 June 2013
DRWP
Type checking in explicit instantiation of variable templates
https://wg21.link/cwg1704




Richard Smith
-
d:cwg1705
CWG1705
26 June 2013
CD4
Unclear specification of “more specialized”
https://wg21.link/cwg1705




Johannes Schaub
-
d:cwg1706
CWG1706
26 June 2013
drafting
alignas pack expansion syntax
https://wg21.link/cwg1706




Daveed Vandevoorde
-
d:cwg1707
CWG1707
27 June 2013
C++14
template in elaborated-type-specifier without nested-name-specifier
https://wg21.link/cwg1707




Richard Smith
-
d:cwg1708
CWG1708
29 June 2013
CD4
overly-strict requirements for names with C language linkage
https://wg21.link/cwg1708




Richard Smith
-
d:cwg1709
CWG1709
1 July 2013
drafting
Stringizing raw string literals containing newline
https://wg21.link/cwg1709




David Krauss
-
d:cwg171
CWG171
19 September 1999
TC1
Global namespace scope
https://wg21.link/cwg171




Greg Lutz
-
d:cwg1710
CWG1710
3 July 2013
C++17
Missing template keyword in class-or-decltype
https://wg21.link/cwg1710




Richard Smith
-
d:cwg1711
CWG1711
8 July 2013
drafting
Missing specification of variable template partial specializations
https://wg21.link/cwg1711




Richard Smith
-
d:cwg1712
CWG1712
8 July 2013
CD4
constexpr variable template declarations
https://wg21.link/cwg1712




Richard Smith
-
d:cwg1713
CWG1713
8 July 2013
drafting
Linkage of variable template specializations
https://wg21.link/cwg1713




Richard Smith
-
d:cwg1714
CWG1714
10 July 2013
NAD
odr-use of this from a local class
https://wg21.link/cwg1714




David Krauss
-
d:cwg1715
CWG1715
16 July 2013
CD4
Access and inherited constructor templates
https://wg21.link/cwg1715




Daveed Vandevoorde
-
d:cwg1716
CWG1716
17 July 2013
C++14
When are default arguments evaluated?
https://wg21.link/cwg1716




David Krauss
-
d:cwg1717
CWG1717
23 July 2013
C++14
Missing specification of type of binary literal
https://wg21.link/cwg1717




Richard Smith
-
d:cwg1718
CWG1718
23 July 2013
drafting
Macro invocation spanning end-of-file
https://wg21.link/cwg1718




David Krauss
-
d:cwg1719
CWG1719
24 July 2013
CD4
Layout compatibility and cv-qualification revisited
https://wg21.link/cwg1719




Jeffrey Yasskin
-
d:cwg172
CWG172
26 September 1999
CD1
Unsigned int as underlying type of enum
https://wg21.link/cwg172




Bjarne Stroustrup
-
d:cwg1720
CWG1720
24 July 2013
NAD
Macro invocation in #include directive
https://wg21.link/cwg1720




David Krauss
-
d:cwg1721
CWG1721
20130731
drafting
Diagnosing ODR violations for static data members
https://wg21.link/cwg1721




Mike Miller
-
d:cwg1722
CWG1722
20130731
CD4
Should lambda to function pointer conversion function be noexcept?
https://wg21.link/cwg1722




Ville Voutilainen
-
d:cwg1723
CWG1723
20130731
drafting
Multicharacter user-defined character literals
https://wg21.link/cwg1723




Mike Miller
-
d:cwg1724
CWG1724
20130731
drafting
Unclear rules for deduction failure
https://wg21.link/cwg1724




James Widman
-
d:cwg1725
CWG1725
1 August 2013
NAD
Trailing return type with nested function declarator
https://wg21.link/cwg1725




Richard Smith
-
d:cwg1726
CWG1726
2 August 2013
drafting
Declarator operators and conversion function
https://wg21.link/cwg1726




James Widman
-
d:cwg1727
CWG1727
5 August 2013
NAD
Type of a specialization of a variable template
https://wg21.link/cwg1727




Larisse Voufo
-
d:cwg1728
CWG1728
5 August 2013
DRWP
Type of an explicit instantiation of a variable template
https://wg21.link/cwg1728




Larisse Voufo
-
d:cwg1729
CWG1729
5 August 2013
drafting
Matching declarations and definitions of variable templates
https://wg21.link/cwg1729




Larisse Voufo
-
d:cwg173
CWG173
27 September 1999
TC1
Constraints on execution character set
https://wg21.link/cwg173




Markus Mauhart
-
d:cwg1730
CWG1730
5 August 2013
drafting
Can a variable template have an unnamed type?
https://wg21.link/cwg1730




Larisse Voufo
-
d:cwg1731
CWG1731
7 August 2013
NAD
is_trivially_X and definitions of special member functions
https://wg21.link/cwg1731




James Widman
-
d:cwg1732
CWG1732
8 August 2013
C++14
Defining types in conditions and range-based for statements
https://wg21.link/cwg1732




Richard Smith
-
d:cwg1733
CWG1733
9 August 2013
drafting
Return type and value for operator= with ref-qualifier
https://wg21.link/cwg1733




James Widman
-
d:cwg1734
CWG1734
9 August 2013
CD4
Nontrivial deleted copy functions
https://wg21.link/cwg1734




James Widman
-
d:cwg1735
CWG1735
12 August 2013
drafting
Out-of-range literals in user-defined-literals
https://wg21.link/cwg1735




Mike Miller
-
d:cwg1736
CWG1736
13 August 2013
CD4
Inheriting constructor templates in a local class
https://wg21.link/cwg1736




Daveed Vandevoorde
-
d:cwg1737
CWG1737
14 August 2013
C++14
Type dependence of call to a member of the current instantiation
https://wg21.link/cwg1737




Richard Smith
-
d:cwg1738
CWG1738
16 August 2013
C++14
Explicit instantiation/specialization of inheriting constructor templates
https://wg21.link/cwg1738




Daveed Vandevoorde
-
d:cwg1739
CWG1739
18 August 2013
C++14
Conversion of floating point to enumeration
https://wg21.link/cwg1739




Ville Voutilainen
-
d:cwg174
CWG174
25 October 1999
NAD
Undeprecating global static
https://wg21.link/cwg174




Lawrence Crowl
-
d:cwg1740
CWG1740
13 August 2013
C++14
Disambiguation of noexcept
https://wg21.link/cwg1740




Richard Smith
-
d:cwg1741
CWG1741
21 August 2013
C++14
odr-use of class object in lvalue-to-rvalue conversion
https://wg21.link/cwg1741




Richard Smith
-
d:cwg1742
CWG1742
28 August 2013
open
using-declarations and scoped enumerators
https://wg21.link/cwg1742




Richard Smith
-
d:cwg1743
CWG1743
20130830
NAD
init-captures in nested lambdas
https://wg21.link/cwg1743




Faisal Vali
-
d:cwg1744
CWG1744
3 September 2013
CD4
Unordered initialization for variable template specializations
https://wg21.link/cwg1744




Richard Smith
-
d:cwg1745
CWG1745
5 September 2013
NAD
thread_local constexpr variable
https://wg21.link/cwg1745




John Spicer
-
d:cwg1746
CWG1746
6 September 2013
C++14
Are volatile scalar types trivially copyable?
https://wg21.link/cwg1746




Walter Brown
-
d:cwg1747
CWG1747
10 September 2013
C++14
Constant initialization of reference to function
https://wg21.link/cwg1747




Daniel Krügler
-
d:cwg1748
CWG1748
11 September 2013
CD4
Placement new with a null pointer
https://wg21.link/cwg1748




Marc Glisse
-
d:cwg1749
CWG1749
12 September 2013
NAD
Confusing definition for constant initializer
https://wg21.link/cwg1749




Daniel Krügler
-
d:cwg175
CWG175
21 February 1999
CD1
Class name injection and base name access
https://wg21.link/cwg175




John Spicer
-
d:cwg1750
CWG1750
13 September 2013
CD4
“Argument” vs “parameter”
https://wg21.link/cwg1750




Mike Miller
-
d:cwg1751
CWG1751
15 September 2013
CD4
Non-trivial operations vs non-trivial initialization
https://wg21.link/cwg1751




Nico Josuttis
-
d:cwg1752
CWG1752
16 September 2013
CD4
Right-recursion in mem-initializer-list
https://wg21.link/cwg1752




Christof Meerwald
-
d:cwg1753
CWG1753
18 September 2013
CD4
decltype-specifier in nested-name-specifier of destructor
https://wg21.link/cwg1753




John Spicer
-
d:cwg1754
CWG1754
19 September 2013
NAD
Declaration of partial specialization of static data member template
https://wg21.link/cwg1754




Richard Smith
-
d:cwg1755
CWG1755
19 September 2013
drafting
Out-of-class partial specializations of member templates
https://wg21.link/cwg1755




Richard Smith
-
d:cwg1756
CWG1756
20 September 2013
CD4
Direct-list-initialization of a non-class object
https://wg21.link/cwg1756




Richard Smith
-
d:cwg1757
CWG1757
20 September 2013
CD4
Const integral subobjects
https://wg21.link/cwg1757




Richard Smith
-
d:cwg1758
CWG1758
21 September 2013
CD4
Explicit conversion in copy/move list initialization
https://wg21.link/cwg1758




Richard Smith
-
d:cwg1759
CWG1759
23 September 2013
C++14
UTF-8 code units in plain char
https://wg21.link/cwg1759




United Kingdom
-
d:cwg176
CWG176
21 February 1999
TC1
Name injection and templates
https://wg21.link/cwg176




John Spicer
-
d:cwg1760
CWG1760
23 September 2013
C++14
Access of member corresponding to init-capture
https://wg21.link/cwg1760




United Kingdom
-
d:cwg1761
CWG1761
23 September 2013
NAD
Runtime check on size of automatic array
https://wg21.link/cwg1761




USA
-
d:cwg1762
CWG1762
23 September 2013
C++14
Reserved identifier used in literal-operator-id example
https://wg21.link/cwg1762




Switzerland
-
d:cwg1763
CWG1763
23 September 2013
open
Length mismatch in template type deduction
https://wg21.link/cwg1763




Canada
-
d:cwg1764
CWG1764
23 September 2013
C++14
Hiding of function from using-declaration by signature
https://wg21.link/cwg1764




Canada
-
d:cwg1765
CWG1765
23 September 2013
C++14
Overflow of enumeration used as enumerator value
https://wg21.link/cwg1765




Canada
-
d:cwg1766
CWG1766
23 September 2013
CD4
Values outside the range of the values of an enumeration
https://wg21.link/cwg1766




CWG
-
d:cwg1767
CWG1767
23 September 2013
C++14
Scoped enumeration in a switch statement
https://wg21.link/cwg1767




Canada
-
d:cwg1768
CWG1768
24 September 2013
NAD
Zero-element array of runtime bound
https://wg21.link/cwg1768




USA
-
d:cwg1769
CWG1769
24 September 2013
C++14
Catching a base class of the exception object
https://wg21.link/cwg1769




Canada
-
d:cwg177
CWG177
25 October 1999
CD1
Lvalues vs rvalues in copy-initialization
https://wg21.link/cwg177




Steve Adamczyk
-
d:cwg1770
CWG1770
24 September 2013
C++14
Type matching of non-type template parameters and arguments
https://wg21.link/cwg1770




Canada
-
d:cwg1771
CWG1771
24 September 2013
open
Restricted lookup in nested-name-specifier
https://wg21.link/cwg1771




Canada
-
d:cwg1772
CWG1772
24 September 2013
C++14
__func__ in a lambda body
https://wg21.link/cwg1772




Switzerland/Canada
-
d:cwg1773
CWG1773
24 September 2013
C++14
Out-of-lifetime lvalue-to-rvalue conversion
https://wg21.link/cwg1773




Canada
-
d:cwg1774
CWG1774
24 September 2013
CD4
Discrepancy between subobject destruction and stack unwinding
https://wg21.link/cwg1774




Canada
-
d:cwg1775
CWG1775
24 September 2013
C++14
Undefined behavior of line splice in raw string literal
https://wg21.link/cwg1775




Canada
-
d:cwg1776
CWG1776
24 September 2013
CD4
Replacement of class objects containing reference members
https://wg21.link/cwg1776




Finland
-
d:cwg1777
CWG1777
24 September 2013
CD4
Empty pack expansion in dynamic-exception-specification
https://wg21.link/cwg1777




Richard Smith
-
d:cwg1778
CWG1778
25 September 2013
C++14
exception-specification in explicitly-defaulted functions
https://wg21.link/cwg1778




USA
-
d:cwg1779
CWG1779
25 September 2013
CD4
Type dependency of __func__
https://wg21.link/cwg1779




John Spicer
-
d:cwg178
CWG178
25 October 1999
TC1
More on value-initialization
https://wg21.link/cwg178




Andrew Koenig
-
d:cwg1780
CWG1780
26 September 2013
CD4
Explicit instantiation/specialization of generic lambda operator()
https://wg21.link/cwg1780




Hubert Tong
-
d:cwg1781
CWG1781
26 September 2013
open
Converting from nullptr_t to bool in overload resolution
https://wg21.link/cwg1781




Hubert Tong
-
d:cwg1782
CWG1782
26 February 2013
CD4
Form of initialization for nullptr_t to bool conversion
https://wg21.link/cwg1782




Hubert Tong
-
d:cwg1783
CWG1783
26 September 2013
NAD
Why are virtual destructors non-trivial?
https://wg21.link/cwg1783




Jeffrey Yasskin
-
d:cwg1784
CWG1784
27 September 2013
C++17
Concurrent execution during static local initialization
https://wg21.link/cwg1784




Jens Maurer
-
d:cwg1785
CWG1785
28 September 2013
NAD
Conflicting diagnostic requirements for template definitions
https://wg21.link/cwg1785




CWG
-
d:cwg1786
CWG1786
28 September 2013
C++14
Effect of merging allocations on memory leakage
https://wg21.link/cwg1786




United Kingdom
-
d:cwg1787
CWG1787
28 September 2013
C++14
Uninitialized unsigned char values
https://wg21.link/cwg1787




United Kingdom
-
d:cwg1788
CWG1788
29 September 2013
CD4
Sized deallocation of array of non-class type
https://wg21.link/cwg1788




Richard Smith
-
d:cwg1789
CWG1789
1 October 2013
drafting
Array reference vs array decay in overload resolution
https://wg21.link/cwg1789




Faisal Vali
-
d:cwg179
CWG179
November 1999
TC1
Function pointers and subtraction
https://wg21.link/cwg179




Mike Miller
-
d:cwg1790
CWG1790
1 October 2013
extension
Ellipsis following function parameter pack
https://wg21.link/cwg1790




Daryle Walker
-
d:cwg1791
CWG1791
1 October 2013
CD4
Incorrect restrictions on cv-qualifier-seq and ref-qualifier
https://wg21.link/cwg1791




David Krauss
-
d:cwg1792
CWG1792
1 October 2013
NAD
Incorrect example of explicit specialization of member enumeration
https://wg21.link/cwg1792




John Spicer
-
d:cwg1793
CWG1793
2 October 2013
CD4
thread_local in explicit specializations
https://wg21.link/cwg1793




Mike Herrick
-
d:cwg1794
CWG1794
4 October 2013
C++17
template keyword and alias templates
https://wg21.link/cwg1794




Jonathan Caves
-
d:cwg1795
CWG1795
4 October 2013
CD4
Disambiguating original-namespace-definition and extension-namespace-definition
https://wg21.link/cwg1795




Richard Smith
-
d:cwg1796
CWG1796
2 October 2013
CD4
Is all-bits-zero for null characters a meaningful requirement?
https://wg21.link/cwg1796




Tony van Eerd
-
d:cwg1797
CWG1797
2 October 2013
CD4
Are all bit patterns of unsigned char distinct numbers?
https://wg21.link/cwg1797




Tony van Eerd
-
d:cwg1798
CWG1798
16 October 2013
NAD
exception-specifications of template arguments
https://wg21.link/cwg1798




Gabriel Dos Reis
-
d:cwg1799
CWG1799
21 October 2013
CD4
mutable and non-explicit const qualification
https://wg21.link/cwg1799




Richard Smith
-
d:cwg18
CWG18

NAD
f(TYPE) where TYPE is void should be allowed
https://wg21.link/cwg18




unknown
-
d:cwg180
CWG180
21 December 1999
CD1
typename and elaborated types
https://wg21.link/cwg180




Mike Miller
-
d:cwg1800
CWG1800
22 October 2013
CD4
Pointer to member of nested anonymous union
https://wg21.link/cwg1800




Richard Smith
-
d:cwg1801
CWG1801
24 October 2013
drafting
Kind of expression referring to member of anonymous union
https://wg21.link/cwg1801




David Majnemer
-
d:cwg1802
CWG1802
20131030
CD4
char16_t string literals and surrogate pairs
https://wg21.link/cwg1802




Jeffrey Yasskin
-
d:cwg1803
CWG1803
20131031
drafting
opaque-enum-declaration as member-declaration
https://wg21.link/cwg1803




Peter Sommerlad
-
d:cwg1804
CWG1804
1 November 2013
CD4
Partial specialization and friendship
https://wg21.link/cwg1804




Steve Clamage
-
d:cwg1805
CWG1805
2 November 2013
CD4
Conversions of array operands in conditional-expressions
https://wg21.link/cwg1805




Richard Smith
-
d:cwg1806
CWG1806
4 November 2013
CD4
Virtual bases and move-assignment
https://wg21.link/cwg1806




Richard Smith
-
d:cwg1807
CWG1807
11 November 2013
CD4
Order of destruction of array elements after an exception
https://wg21.link/cwg1807




Thomas Koeppe
-
d:cwg1808
CWG1808
12 November 2013
drafting
Constructor templates vs default constructors
https://wg21.link/cwg1808




Richard Smith
-
d:cwg1809
CWG1809
12 November 2013
CD4
Narrowing and template argument deduction
https://wg21.link/cwg1809




Richard Smith
-
d:cwg181
CWG181
4 November 1999
TC1
Errors in template template-parameter example
https://wg21.link/cwg181




John Spicer
-
d:cwg1810
CWG1810
13 November 2013
CD4
Invalid ud-suffixes
https://wg21.link/cwg1810




Gabriel Dos Reis
-
d:cwg1811
CWG1811
18 November 2013
CD4
Lookup of deallocation function in a virtual destructor definition
https://wg21.link/cwg1811




Richard Smith
-
d:cwg1812
CWG1812
18 November 2013
C++17
Omission of template in a typename-specifier
https://wg21.link/cwg1812




Daveed Vandevoorde
-
d:cwg1813
CWG1813
20 November 2013
CD4
Direct vs indirect bases in standard-layout classes
https://wg21.link/cwg1813




Daveed Vandevoorde
-
d:cwg1814
CWG1814
21 November 2013
CD4
Default arguments in lambda-expressions
https://wg21.link/cwg1814




Jonathan Caves
-
d:cwg1815
CWG1815
22 November 2013
CD4
Lifetime extension in aggregate initialization
https://wg21.link/cwg1815




Dinka Ranns
-
d:cwg1816
CWG1816
2 December 2013
CD4
Unclear specification of bit-field values
https://wg21.link/cwg1816




Hubert Tong
-
d:cwg1817
CWG1817
4 December 2013
drafting
Linkage specifications and nested scopes
https://wg21.link/cwg1817




Richard Smith
-
d:cwg1818
CWG1818
4 December 2013
open
Visibility and inherited language linkage
https://wg21.link/cwg1818




Richard Smith
-
d:cwg1819
CWG1819
5 December 2013
CD4
Acceptable scopes for definition of partial specialization
https://wg21.link/cwg1819




Richard Smith
-
d:cwg182
CWG182
8 November 1999
NAD
Access checking on explicit specializations
https://wg21.link/cwg182




John Spicer
-
d:cwg1820
CWG1820
5 December 2013
open
Qualified typedef names
https://wg21.link/cwg1820




Richard Smith
-
d:cwg1821
CWG1821
20131205
open
Qualified redeclarations in a class member-specification
https://wg21.link/cwg1821




Richard Smith
-
d:cwg1822
CWG1822
10 December 2013
open
Lookup of parameter names in lambda-expressions
https://wg21.link/cwg1822




Steve Clamage
-
d:cwg1823
CWG1823
17 December 2013
CD4
String literal uniqueness in inline functions
https://wg21.link/cwg1823




Richard Smith
-
d:cwg1824
CWG1824
19 December 2013
CD4
Completeness of return type vs point of instantiation
https://wg21.link/cwg1824




Steve Clamage
-
d:cwg1825
CWG1825
20131230
C++17
Partial ordering between variadic and non-variadic function templates
https://wg21.link/cwg1825




Steve Clamage
-
d:cwg1826
CWG1826
4 January 2014
NAD
const floating-point in constant expressions
https://wg21.link/cwg1826




Ville Voutilainen
-
d:cwg1827
CWG1827
7 January 2014
drafting
Reference binding with ambiguous conversions
https://wg21.link/cwg1827




Hubert Tong
-
d:cwg1828
CWG1828
8 January 2014
drafting
nested-name-specifier ambiguity
https://wg21.link/cwg1828




Richard Smith
-
d:cwg1829
CWG1829
8 January 2014
open
Dependent unnamed types
https://wg21.link/cwg1829




Hubert Tong
-
d:cwg183
CWG183
9 November 1999
TC1
typename in explicit specializations
https://wg21.link/cwg183




John Spicer
-
d:cwg1830
CWG1830
10 January 2014
CD4
Repeated specifiers
https://wg21.link/cwg1830




Ville Voutilainen
-
d:cwg1831
CWG1831
13 January 2014
NAD
Explicitly vs implicitly deleted move constructors
https://wg21.link/cwg1831




Vinny Romano
-
d:cwg1832
CWG1832
16 January 2014
CD4
Casting to incomplete enumeration
https://wg21.link/cwg1832




Richard Smith
-
d:cwg1833
CWG1833
13 January 2014
NAD
friend declarations naming implicitly-declared member functions
https://wg21.link/cwg1833




Richard Smith
-
d:cwg1834
CWG1834
13 January 2014
CD4
Constant initialization binding a reference to an xvalue
https://wg21.link/cwg1834




Richard Smith
-
d:cwg1835
CWG1835
17 January 2014
drafting
Dependent member lookup before <
https://wg21.link/cwg1835




Richard Smith
-
d:cwg1836
CWG1836
17 January 2014
DRWP
Use of class type being defined in trailing-return-type
https://wg21.link/cwg1836




Mike Miller
-
d:cwg1837
CWG1837
13 January 2014
drafting
Use of this in friend and local class declarations
https://wg21.link/cwg1837




Hubert Tong
-
d:cwg1838
CWG1838
17 January 2014
CD4
Definition via unqualified-id and using-declaration
https://wg21.link/cwg1838




Richard Smith
-
d:cwg1839
CWG1839
18 January 2014
drafting
Lookup of block-scope extern declarations
https://wg21.link/cwg1839




Hubert Tong
-
d:cwg184
CWG184
11 November 1999
CD1
Default arguments in template template-parameters
https://wg21.link/cwg184




John Spicer
-
d:cwg1840
CWG1840
19 January 2014
drafting
Non-deleted explicit specialization of deleted function template
https://wg21.link/cwg1840




Richard Smith
-
d:cwg1841
CWG1841
23 January 2014
drafting
< following template injected-class-name
https://wg21.link/cwg1841




Ismail Pazarbasi
-
d:cwg1842
CWG1842
23 January 2014
concurrency
Unevaluated operands and “carries a dependency”
https://wg21.link/cwg1842




Hans Boehm
-
d:cwg1843
CWG1843
25 January 2014
CD4
Bit-field in conditional operator with throw operand
https://wg21.link/cwg1843




Richard Smith
-
d:cwg1844
CWG1844
28 January 2014
drafting
Defining “immediate context”
https://wg21.link/cwg1844




Richard Smith
-
d:cwg1845
CWG1845
28 January 2014
drafting
Point of instantiation of a variable template specialization
https://wg21.link/cwg1845




Richard Smith
-
d:cwg1846
CWG1846
20140130
CD4
Declaring explicitly-defaulted implicitly-deleted functions
https://wg21.link/cwg1846




Richard Smith
-
d:cwg1847
CWG1847
20140130
CD4
Clarifying compatibility during partial ordering
https://wg21.link/cwg1847




Jason Merrill
-
d:cwg1848
CWG1848
3 February 2014
CD4
Parenthesized constructor and destructor declarators
https://wg21.link/cwg1848




Richard Smith
-
d:cwg1849
CWG1849
3 February 2014
drafting
Variable templates and the ODR
https://wg21.link/cwg1849




Richard Smith
-
d:cwg185
CWG185
11 November 1999
TC1
"Named" temporaries and copy elision
https://wg21.link/cwg185




Bill Wade
-
d:cwg1850
CWG1850
4 February 2014
CD4
Differences between definition context and point of instantiation
https://wg21.link/cwg1850




Richard Smith
-
d:cwg1851
CWG1851
4 February 2014
CD4
decltype(auto) in new-expressions
https://wg21.link/cwg1851




Daveed Vandevoorde
-
d:cwg1852
CWG1852
4 February 2014
CD4
Wording issues regarding decltype(auto)
https://wg21.link/cwg1852




Daveed Vandevoorde
-
d:cwg1853
CWG1853
9 February 2014
drafting
Defining “allocated storage”
https://wg21.link/cwg1853




Jeffrey Yasskin
-
d:cwg1854
CWG1854
11 February 2014
drafting
Disallowing use of implicitly-deleted functions
https://wg21.link/cwg1854




Richard Smith
-
d:cwg1855
CWG1855
11 February 2014
dup
Out-of-lifetime access to nonstatic data members
https://wg21.link/cwg1855




Mike Miller
-
d:cwg1856
CWG1856
11 February 2014
open
Indirect nested classes of class templates
https://wg21.link/cwg1856




Richard Smith
-
d:cwg1857
CWG1857
12 February 2014
drafting
Additional questions about bits
https://wg21.link/cwg1857




Tony Van Eerd
-
d:cwg1858
CWG1858
12 February 2014
CD4
Comparing pointers to union members
https://wg21.link/cwg1858




Richard Smith
-
d:cwg1859
CWG1859
12 February 2014
drafting
UTF-16 in char16_t string literals
https://wg21.link/cwg1859




Richard Smith
-
d:cwg186
CWG186
11 November 1999
open
Name hiding and template template-parameters
https://wg21.link/cwg186




John Spicer
-
d:cwg1860
CWG1860
13 February 2014
C++17
What is a “direct member?”
https://wg21.link/cwg1860




Dawn Perchik
-
d:cwg1861
CWG1861
13 February 2014
CD4
Values of a bit-field
https://wg21.link/cwg1861




Hubert Tong
-
d:cwg1862
CWG1862
13 February 2014
DR
Determining “corresponding members” for friendship
https://wg21.link/cwg1862




Richard Smith
-
d:cwg1863
CWG1863
22 September 2013
CD4
Requirements on thrown object type to support std::current_exception()
https://wg21.link/cwg1863




Canada
-
d:cwg1864
CWG1864
15 February 2014
extension
List-initialization of array objects
https://wg21.link/cwg1864




Alisdair Meredith
-
d:cwg1865
CWG1865
15 February 2014
CD4
Pointer arithmetic and multi-level qualification conversions
https://wg21.link/cwg1865




Geoffrey Romer
-
d:cwg1866
CWG1866
12 February 2014
CD4
Initializing variant members with non-trivial destructors
https://wg21.link/cwg1866




Vinny Romano
-
d:cwg1867
CWG1867
12 February 2014
NAD
Function/expression ambiguity with qualified parameter name
https://wg21.link/cwg1867




Richard Smith
-
d:cwg1868
CWG1868
13 February 2014
drafting
Meaning of “placeholder type”
https://wg21.link/cwg1868




Dawn Perchik
-
d:cwg1869
CWG1869
14 February 2014
NAD
thread_local vs linkage-specifications
https://wg21.link/cwg1869




Richard Smith
-
d:cwg187
CWG187
15 November 1999
TC1
Scope of template parameter names
https://wg21.link/cwg187




John Spicer
-
d:cwg1870
CWG1870
15 February 2014
CD4
Contradictory wording about definitions vs explicit specialization/instantiation
https://wg21.link/cwg1870




Hubert Tong
-
d:cwg1871
CWG1871
17 February 2014
extension
Non-identifier characters in ud-suffix
https://wg21.link/cwg1871




Richard Smith
-
d:cwg1872
CWG1872
17 February 2014
CD4
Instantiations of constexpr templates that cannot appear in constant expressions
https://wg21.link/cwg1872




Richard Smith
-
d:cwg1873
CWG1873
18 February 2014
CD4
Protected member access from derived class friends
https://wg21.link/cwg1873




Richard Smith
-
d:cwg1874
CWG1874
18 February 2014
CD4
Type vs non-type template parameters with class keyword
https://wg21.link/cwg1874




Richard Smith
-
d:cwg1875
CWG1875
19 February 2014
CD4
Reordering declarations in class scope
https://wg21.link/cwg1875




Richard Smith
-
d:cwg1876
CWG1876
19 February 2014
extension
Preventing explicit specialization
https://wg21.link/cwg1876




John Spicer
-
d:cwg1877
CWG1877
20 February 2014
CD4
Return type deduction from return with no operand
https://wg21.link/cwg1877




Daveed Vandevoorde
-
d:cwg1878
CWG1878
20 February 2014
CD4
operator auto template
https://wg21.link/cwg1878




Daveed Vandevoorde
-
d:cwg1879
CWG1879
24 February 2014
NAD
Inadequate definition of alignment requirement
https://wg21.link/cwg1879




Richard Smith
-
d:cwg188
CWG188
20 December 1999
TC1
Comma operator and rvalue conversion
https://wg21.link/cwg188




Mike Miller
-
d:cwg1880
CWG1880
25 February 2014
drafting
When are parameter objects destroyed?
https://wg21.link/cwg1880




Hubert Tong
-
d:cwg1881
CWG1881
25 February 2014
CD4
Standard-layout classes and unnamed bit-fields
https://wg21.link/cwg1881




Dinka Ranns
-
d:cwg1882
CWG1882
26 February 2014
CD4
Reserved names without library use
https://wg21.link/cwg1882




Mike Miller
-
d:cwg1883
CWG1883
26 February 2014
drafting
Protected access to constructors in mem-initializers
https://wg21.link/cwg1883




Daveed Vandevoorde
-
d:cwg1884
CWG1884
27 February 2014
drafting
Unclear requirements for same-named external-linkage entities
https://wg21.link/cwg1884




Richard Smith
-
d:cwg1885
CWG1885
28 February 2014
CD4
Return value of a function is underspecified
https://wg21.link/cwg1885




Jens Maurer
-
d:cwg1886
CWG1886
4 March 2014
CD4
Language linkage for main()
https://wg21.link/cwg1886




Richard Smith
-
d:cwg1887
CWG1887
4 March 2014
CD4
Problems with :: as nested-name-specifier
https://wg21.link/cwg1887




Jeff Snyder
-
d:cwg1888
CWG1888
4 March 2014
CD4
Implicitly-declared default constructors and explicit
https://wg21.link/cwg1888




Daniel Krügler
-
d:cwg1889
CWG1889
5 March 2014
drafting
Unclear effect of #pragma on conformance
https://wg21.link/cwg1889




James Widman
-
d:cwg189
CWG189
20 December 1999
drafting
Definition of operator and punctuator
https://wg21.link/cwg189




Mike Miller
-
d:cwg1890
CWG1890
7 March 2014
drafting
Member type depending on definition of member function
https://wg21.link/cwg1890




Hubert Tong
-
d:cwg1891
CWG1891
10 March 2014
CD4
Move constructor/assignment for closure class
https://wg21.link/cwg1891




Jonathan Caves
-
d:cwg1892
CWG1892
12 March 2014
CD4
Use of auto in function type
https://wg21.link/cwg1892




Richard Smith
-
d:cwg1893
CWG1893
13 March 2014
DR
Function-style cast with braced-init-lists and empty pack expansions
https://wg21.link/cwg1893




Richard Smith
-
d:cwg1894
CWG1894
16 March 2014
open
typedef-names and using-declarations
https://wg21.link/cwg1894




Richard Smith
-
d:cwg1895
CWG1895
17 March 2014
CD4
Deleted conversions in conditional operator operands
https://wg21.link/cwg1895




Richard Smith
-
d:cwg1896
CWG1896
18 March 2014
drafting
Repeated alias templates
https://wg21.link/cwg1896




Mike Miller
-
d:cwg1897
CWG1897
21 March 2014
drafting
ODR vs alternative tokens
https://wg21.link/cwg1897




Hubert Tong
-
d:cwg1898
CWG1898
21 March 2014
drafting
Use of “equivalent” in overload resolution
https://wg21.link/cwg1898




Hubert Tong
-
d:cwg1899
CWG1899
22 March 2014
CD4
Value-dependent constant expressions
https://wg21.link/cwg1899




Richard Smith
-
d:cwg19
CWG19

NAD
Clarify protected member access
https://wg21.link/cwg19




unknown
-
d:cwg190
CWG190
20 December 1999
TC1
Layout-compatible POD-struct types
https://wg21.link/cwg190




Steve Adamczyk
-
d:cwg1900
CWG1900
25 March 2014
drafting
Do friend declarations count as “previous declarations”?
https://wg21.link/cwg1900




Hubert Tong
-
d:cwg1901
CWG1901
25 March 2014
drafting
punctuator referenced but not defined
https://wg21.link/cwg1901




Richard Smith
-
d:cwg1902
CWG1902
26 March 2014
CD4
What makes a conversion “otherwise ill-formed”?
https://wg21.link/cwg1902




Richard Smith
-
d:cwg1903
CWG1903
26 March 2014
CD4
What declarations are introduced by a non-member using-declaration?
https://wg21.link/cwg1903




Richard Smith
-
d:cwg1904
CWG1904
27 March 2014
NAD
Default template arguments for members of class templates
https://wg21.link/cwg1904




John Spicer
-
d:cwg1906
CWG1906
20140330
NAD
Name lookup in member friend declaration
https://wg21.link/cwg1906




Richard Smith
-
d:cwg1907
CWG1907
20140330
drafting
using-declarations and default arguments
https://wg21.link/cwg1907




Richard Smith
-
d:cwg1908
CWG1908
20140331
drafting
Dual destructor lookup and template-ids
https://wg21.link/cwg1908




Hubert Tong
-
d:cwg1909
CWG1909
1 April 2014
CD4
Member class template with the same name as the class
https://wg21.link/cwg1909




Richard Smith
-
d:cwg191
CWG191
29 December 1999
open
Name lookup does not handle complex nesting
https://wg21.link/cwg191




Alan Nash
-
d:cwg1910
CWG1910
12 April 2014
DR
“Shall” requirement applied to runtime behavior
https://wg21.link/cwg1910




Richard Smith
-
d:cwg1911
CWG1911
13 April 2014
CD4
constexpr constructor with non-literal base class
https://wg21.link/cwg1911




Richard Smith
-
d:cwg1912
CWG1912
10 April 2014
extension
exception-specification of defaulted function
https://wg21.link/cwg1912




Ville Voutilainen
-
d:cwg1913
CWG1913
15 April 2014
drafting
decltype((x)) in lambda-expressions
https://wg21.link/cwg1913




Dinka Ranns
-
d:cwg1914
CWG1914
15 April 2014
extension
Duplicate standard attributes
https://wg21.link/cwg1914




Aaron Ballman
-
d:cwg1915
CWG1915
15 April 2014
extension
Potentially-invoked destructors in non-throwing constructors
https://wg21.link/cwg1915




Aaron Ballman
-
d:cwg1916
CWG1916
18 April 2014
CD4
“Same cv-unqualified type”
https://wg21.link/cwg1916




Richard Smith
-
d:cwg1917
CWG1917
25 April 2014
drafting
decltype-qualified enumeration names
https://wg21.link/cwg1917




Daveed Vandevoorde
-
d:cwg1918
CWG1918
27 April 2014
open
friend templates with dependent scopes
https://wg21.link/cwg1918




Richard Smith
-
d:cwg1919
CWG1919
20140430
open
Overload resolution for ! with explicit conversion operator
https://wg21.link/cwg1919




Johannes Schaub
-
d:cwg192
CWG192
6 January 2000
drafting
Name lookup in parameters
https://wg21.link/cwg192




Alan Nash
-
d:cwg1920
CWG1920
1 May 2014
CD4
Qualification mismatch in pseudo-destructor-name
https://wg21.link/cwg1920




David Majnemer
-
d:cwg1921
CWG1921
2 May 2014
NAD
constexpr constructors and point of initialization of const variables
https://wg21.link/cwg1921




Ville Voutilainen
-
d:cwg1922
CWG1922
5 May 2014
CD4
Injected class template names and default arguments
https://wg21.link/cwg1922




Hubert Tong
-
d:cwg1923
CWG1923
6 May 2014
extension
Lvalues of type void
https://wg21.link/cwg1923




Richard Smith
-
d:cwg1924
CWG1924
12 May 2014
review
Definition of “literal” and kinds of literals
https://wg21.link/cwg1924




Saeed Amrollah Boyouki
-
d:cwg1925
CWG1925
12 May 2014
CD4
Bit-field prvalues
https://wg21.link/cwg1925




Richard Smith
-
d:cwg1926
CWG1926
13 May 2014
CD4
Potential results of subscript operator
https://wg21.link/cwg1926




Marcel Wid
-
d:cwg1927
CWG1927
14 May 2014
dup
Lifetime of temporaries in init-captures
https://wg21.link/cwg1927




Daveed Vandevoorde
-
d:cwg1928
CWG1928
15 May 2014
NAD
Triviality of deleted special member functions
https://wg21.link/cwg1928




Richard Smith
-
d:cwg1929
CWG1929
15 May 2014
CD4
template keyword following namespace nested-name-specifier
https://wg21.link/cwg1929




David Krauss
-
d:cwg193
CWG193
7 January 2000
TC1
Order of destruction of local automatics of destructor
https://wg21.link/cwg193




Gerhard Menzl
-
d:cwg1930
CWG1930
19 May 2014
CD4
init-declarator-list vs member-declarator-list
https://wg21.link/cwg1930




Richard Smith
-
d:cwg1931
CWG1931
24 May 2014
extension
Default-constructible and copy-assignable closure types
https://wg21.link/cwg1931




Ryou Ezoe
-
d:cwg1932
CWG1932
21 February 2014
CD4
Bit-field results of conditional operators
https://wg21.link/cwg1932




Richard Smith
-
d:cwg1933
CWG1933
20140530
NAD
Implementation limit for initializer-list elements
https://wg21.link/cwg1933




Daniel Krügler
-
d:cwg1934
CWG1934
3 June 2014
extension
Relaxing exception-specification compatibility requirements
https://wg21.link/cwg1934




Vinny Romano
-
d:cwg1935
CWG1935
4 June 2014
drafting
Reuse of placement arguments in deallocation
https://wg21.link/cwg1935




Hubert Tong
-
d:cwg1936
CWG1936
5 June 2014
drafting
Dependent qualified-ids
https://wg21.link/cwg1936




Richard Smith
-
d:cwg1937
CWG1937
5 June 2014
drafting
Incomplete specification of function pointer from lambda
https://wg21.link/cwg1937




Richard Smith
-
d:cwg1938
CWG1938
9 June 2014
drafting
Should hosted/freestanding be implementation-defined?
https://wg21.link/cwg1938




Richard Smith
-
d:cwg1939
CWG1939
11 June 2014
drafting
Argument conversions to nondeduced parameter types revisited
https://wg21.link/cwg1939




Richard Smith
-
d:cwg194
CWG194
11 January 2000
TC1
Identifying constructors
https://wg21.link/cwg194




Jamie Schmeiser
-
d:cwg1940
CWG1940
12 June 2014
CD4
static_assert in anonymous unions
https://wg21.link/cwg1940




Richard Smith
-
d:cwg1941
CWG1941
12 June 2014
CD4
SFINAE and inherited constructor default arguments
https://wg21.link/cwg1941




David Krauss
-
d:cwg1942
CWG1942
16 June 2014
CD4
Incorrect reference to trailing-return-type
https://wg21.link/cwg1942




Mike Miller
-
d:cwg1943
CWG1943
13 February 2014
open
Unspecified meaning of “bit”
https://wg21.link/cwg1943




Hubert Tong
-
d:cwg1944
CWG1944
18 June 2014
open
New C incompatibilities
https://wg21.link/cwg1944




Mike Miller
-
d:cwg1945
CWG1945
19 June 2014
open
Friend declarations naming members of class templates in non-templates
https://wg21.link/cwg1945




Richard Smith
-
d:cwg1946
CWG1946
21 June 2014
CD4
exception-specifications vs pointer dereference
https://wg21.link/cwg1946




Mike Miller
-
d:cwg1947
CWG1947
12 August 2014
NAD
Digit separators following non-octal prefix
https://wg21.link/cwg1947




Japan
-
d:cwg1948
CWG1948
18 June 2014
NAD
exception-specification of replacement global new
https://wg21.link/cwg1948




Steve Clamage
-
d:cwg1949
CWG1949
18 June 2014
CD4
“sequenced after” instead of “sequenced before”
https://wg21.link/cwg1949




Richard Smith
-
d:cwg195
CWG195
12 January 2000
CD1
Converting between function and object pointers
https://wg21.link/cwg195




Steve Clamage
-
d:cwg1950
CWG1950
18 June 2014
NAD
Restructuring description of ranks of conversion sequences
https://wg21.link/cwg1950




Richard Smith
-
d:cwg1951
CWG1951
19 June 2014
CD4
Cv-qualification and literal types
https://wg21.link/cwg1951




Richard Smith
-
d:cwg1952
CWG1952
22 June 2014
CD4
Constant expressions and library undefined behavior
https://wg21.link/cwg1952




Daniel Krügler
-
d:cwg1953
CWG1953
23 June 2014
open
Data races and common initial sequence
https://wg21.link/cwg1953




Faisal Vali
-
d:cwg1954
CWG1954
23 June 2014
open
typeid null dereference check in subexpressions
https://wg21.link/cwg1954




David Majnemer
-
d:cwg1955
CWG1955
25 June 2014
CD4
#elif with invalid controlling expression
https://wg21.link/cwg1955




Jonathan Wakely
-
d:cwg1956
CWG1956
29 June 2014
CD4
Reuse of storage of automatic variables
https://wg21.link/cwg1956




Daniel Krügler
-
d:cwg1957
CWG1957
20140630
extension
decltype(auto) with direct-list-initialization
https://wg21.link/cwg1957




Vinny Romano
-
d:cwg1958
CWG1958
20140630
CD4
decltype(auto) with parenthesized initializer
https://wg21.link/cwg1958




Vinny Romano
-
d:cwg1959
CWG1959
20140630
CD4
Inadvertently inherited copy constructor
https://wg21.link/cwg1959




David Krauss
-
d:cwg196
CWG196
20 January 2000
open
Arguments to deallocation functions
https://wg21.link/cwg196




Matt Austern
-
d:cwg1960
CWG1960
4 July 2014
NAD
Visibility of entity named in class-scope using-declaration
https://wg21.link/cwg1960




Hubert Tong
-
d:cwg1961
CWG1961
4 July 2014
C++17
Potentially-concurrent actions within a signal handler
https://wg21.link/cwg1961




Faisal Vali
-
d:cwg1962
CWG1962
4 July 2014
drafting
Type of __func__
https://wg21.link/cwg1962




Steve Clamage
-
d:cwg1963
CWG1963
7 July 2014
CD4
Implementation-defined identifier characters
https://wg21.link/cwg1963




Richard Smith
-
d:cwg1964
CWG1964
7 July 2014
NAD
opaque-enum-declaration in alias-declaration?
https://wg21.link/cwg1964




Fedor Sergeev
-
d:cwg1965
CWG1965
7 July 2014
drafting
Explicit casts to reference types
https://wg21.link/cwg1965




Richard Smith
-
d:cwg1966
CWG1966
8 July 2014
CD4
Colon following enumeration elaborated-type-specifier
https://wg21.link/cwg1966




Daveed Vandevoorde
-
d:cwg1967
CWG1967
11 July 2014
CD4
Temporary lifetime and move-elision
https://wg21.link/cwg1967




Richard Smith
-
d:cwg1968
CWG1968
14 July 2014
NAD
Address of typeid in constant expressions
https://wg21.link/cwg1968




Richard Smith
-
d:cwg1969
CWG1969
14 July 2014
open
Missing exclusion of ~S as an ordinary function name
https://wg21.link/cwg1969




Richard Smith
-
d:cwg197
CWG197
26 January 2000
CD1
Issues with two-stage lookup of dependent names
https://wg21.link/cwg197




Derek Inglis
-
d:cwg1970
CWG1970
15 July 2014
NAD
Ambiguity resolution for (T())*x
https://wg21.link/cwg1970




Richard Smith
-
d:cwg1971
CWG1971
15 July 2014
CD4
Unclear disambiguation of destructor and operator~
https://wg21.link/cwg1971




Hubert Tong
-
d:cwg1972
CWG1972
15 July 2014
open
Identifier character restrictions in non-identifiers
https://wg21.link/cwg1972




Richard Smith
-
d:cwg1973
CWG1973
16 July 2014
drafting
Which parameter-declaration-clause in a lambda-expression?
https://wg21.link/cwg1973




Dinka Ranns
-
d:cwg1974
CWG1974
17 July 2014
open
Redundant specification of non-type typename-specifier
https://wg21.link/cwg1974




Hubert Tong
-
d:cwg1975
CWG1975
18 July 2014
CD4
Permissible declarations for exception-specifications
https://wg21.link/cwg1975




Richard Smith
-
d:cwg1976
CWG1976
20 July 2014
NAD
Ambiguity of namespace-aliases
https://wg21.link/cwg1976




Richard Smith
-
d:cwg1977
CWG1977
21 July 2014
drafting
Contradictory results of failed destructor lookup
https://wg21.link/cwg1977




Gabriel Dos Reis
-
d:cwg1978
CWG1978
22 July 2014
CD4
Redundant description of explicit constructor use
https://wg21.link/cwg1978




Geoffrey Romer
-
d:cwg1979
CWG1979
20140731
drafting
Alias template specialization in template member definition
https://wg21.link/cwg1979




Gabriel Dos Reis
-
d:cwg198
CWG198
27 January 2000
CD1
Definition of "use" in local and nested classes
https://wg21.link/cwg198




Erwin Unruh
-
d:cwg1980
CWG1980
4 August 2014
drafting
Equivalent but not functionally-equivalent redeclarations
https://wg21.link/cwg1980




Richard Smith
-
d:cwg1981
CWG1981
8 August 2014
CD4
Implicit contextual conversions and explicit
https://wg21.link/cwg1981




Richard Smith
-
d:cwg1982
CWG1982
9 August 2014
NAD
Deduction extending parameter pack
https://wg21.link/cwg1982




Filip Roséen
-
d:cwg1983
CWG1983
11 August 2014
DR
Inappropriate use of virt-specifier
https://wg21.link/cwg1983




Richard Smith
-
d:cwg1984
CWG1984
13 August 2014
NAD
Lossless narrowing conversions
https://wg21.link/cwg1984




Hubert Tong
-
d:cwg1985
CWG1985
9 August 2014
NAD
Unknown bound array member with brace-or-equal-initializer
https://wg21.link/cwg1985




Hubert Tong
-
d:cwg1986
CWG1986
21 August 2014
drafting
odr-use and delayed initialization
https://wg21.link/cwg1986




Richard Smith
-
d:cwg1987
CWG1987
22 August 2014
NAD
constexpr static data members across translation units
https://wg21.link/cwg1987




Richard Smith
-
d:cwg1988
CWG1988
22 August 2014
CD4
Ambiguity between dependent and non-dependent bases in implicit member access
https://wg21.link/cwg1988




Richard Smith
-
d:cwg1989
CWG1989
20140830
drafting
Insufficient restrictions on parameters of postfix operators
https://wg21.link/cwg1989




Richard Smith
-
d:cwg199
CWG199
27 January 2000
CD1
Order of destruction of temporaries
https://wg21.link/cwg199




Alan Nash
-
d:cwg1990
CWG1990
27 August 2014
CD4
Ambiguity due to optional decl-specifier-seq
https://wg21.link/cwg1990




Hubert Tong
-
d:cwg1991
CWG1991
27 August 2014
CD4
Inheriting constructors vs default arguments
https://wg21.link/cwg1991




Hubert Tong
-
d:cwg1992
CWG1992
27 August 2014
CD4
new (std::nothrow) int[N] can throw
https://wg21.link/cwg1992




Martin Sebor
-
d:cwg1993
CWG1993
20140831
drafting
Use of template<> defining member of explicit specialization
https://wg21.link/cwg1993




Richard Smith
-
d:cwg1994
CWG1994
3 September 2014
dup
Confusing wording regarding multiple template<> prefixes
https://wg21.link/cwg1994




Richard Smith
-
d:cwg1995
CWG1995
3 September 2014
CD4
exception-specifications and non-type template parameters
https://wg21.link/cwg1995




Gabriel Dos Reis
-
d:cwg1996
CWG1996
4 September 2014
drafting
Reference list-initialization ignores conversion functions
https://wg21.link/cwg1996




Richard Smith
-
d:cwg1997
CWG1997
8 September 2014
drafting
Placement new and previous initialization
https://wg21.link/cwg1997




Jason Merrill
-
d:cwg1998
CWG1998
8 September 2014
NAD
Additional sources of xvalue expressions
https://wg21.link/cwg1998




Daveed Vandevoorde
-
d:cwg1999
CWG1999
9 September 2014
CD4
Representation of source characters as universal-character-names
https://wg21.link/cwg1999




Richard Smith
-
d:cwg2
CWG2

drafting
How can dependent names be used in member declarations that appear outside of the class template definition?
https://wg21.link/cwg2




unknown
-
d:cwg20
CWG20

TC1
Some clarifications needed for 12.8 para 15
https://wg21.link/cwg20




unknown
-
d:cwg200
CWG200
28 January 2000
dup
Partial ordering and explicit arguments
https://wg21.link/cwg200




Martin Sebor
-
d:cwg2000
CWG2000
9 September 2014
CD4
header-name outside #include directive
https://wg21.link/cwg2000




Richard Smith
-
d:cwg2001
CWG2001
10 September 2014
CD4
non-directive is underspecified
https://wg21.link/cwg2001




Richard Smith
-
d:cwg2002
CWG2002
10 September 2014
open
White space within preprocessing directives
https://wg21.link/cwg2002




Richard Smith
-
d:cwg2003
CWG2003
12 September 2014
drafting
Zero-argument macros incorrectly specified
https://wg21.link/cwg2003




Richard Smith
-
d:cwg2004
CWG2004
16 September 2014
CD4
Unions with mutable members in constant expressions
https://wg21.link/cwg2004




Richard Smith
-
d:cwg2005
CWG2005
18 September 2014
NAD
Incorrect constexpr reference initialization requirements
https://wg21.link/cwg2005




David Krauss
-
d:cwg2006
CWG2006
16 September 2014
CD4
Cv-qualified void types
https://wg21.link/cwg2006




Richard Smith
-
d:cwg2007
CWG2007
23 September 2014
drafting
Argument-dependent lookup for operator=
https://wg21.link/cwg2007




Richard Smith
-
d:cwg2008
CWG2008
23 September 2014
CD4
Default template-arguments underspecified
https://wg21.link/cwg2008




Andrew Sutton
-
d:cwg2009
CWG2009
23 September 2014
open
Unclear specification of class scope
https://wg21.link/cwg2009




Richard Smith
-
d:cwg201
CWG201
31 January 2000
CD1
Order of destruction of temporaries in initializers
https://wg21.link/cwg201




Alan Nash
-
d:cwg2010
CWG2010
26 September 2014
CD4
exception-specifications and conversion operators
https://wg21.link/cwg2010




Richard Smith
-
d:cwg2011
CWG2011
28 September 2014
C++17
Unclear effect of reference capture of reference
https://wg21.link/cwg2011




Ville Voutilainen
-
d:cwg2012
CWG2012
29 September 2014
CD4
Lifetime of references
https://wg21.link/cwg2012




Mike Miller
-
d:cwg2013
CWG2013
2 October 2014
drafting
Pointer subtraction in large array
https://wg21.link/cwg2013




Jason Merrill
-
d:cwg2014
CWG2014
3 October 2014
NAD
Unneeded deallocation signatures
https://wg21.link/cwg2014




Richard Smith
-
d:cwg2015
CWG2015
5 October 2014
CD4
odr-use of deleted virtual functions
https://wg21.link/cwg2015




David Majnemer
-
d:cwg2016
CWG2016
5 October 2014
CD4
Confusing wording in description of conversion function
https://wg21.link/cwg2016




Daniel Krügler
-
d:cwg2017
CWG2017
6 October 2014
CD4
Flowing off end is not equivalent to no-expression return
https://wg21.link/cwg2017




Richard Smith
-
d:cwg2018
CWG2018
7 October 2014
drafting
Qualification conversion vs reference binding
https://wg21.link/cwg2018




Richard Smith
-
d:cwg2019
CWG2019
8 October 2014
CD4
Member references omitted from description of storage duration
https://wg21.link/cwg2019




David Krauss
-
d:cwg202
CWG202
2 February 2000
TC1
Use of overloaded function name
https://wg21.link/cwg202




Steve Clamage
-
d:cwg2020
CWG2020
8 October 2014
drafting
Inadequate description of odr-use of implicitly-invoked functions
https://wg21.link/cwg2020




Richard Smith
-
d:cwg2021
CWG2021
15 October 2014
dup
Function template redeclaration via alias template
https://wg21.link/cwg2021




Richard Smith
-
d:cwg2022
CWG2022
16 October 2014
CD4
Copy elision in constant expressions
https://wg21.link/cwg2022




Jason Merrill
-
d:cwg2023
CWG2023
16 October 2014
drafting
Composite reference result type of conditional operator
https://wg21.link/cwg2023




Daniel Krügler
-
d:cwg2024
CWG2024
17 October 2014
CD4
Dependent types and unexpanded parameter packs
https://wg21.link/cwg2024




Richard Smith
-
d:cwg2025
CWG2025
17 October 2014
dup
Declaration matching via alias templates
https://wg21.link/cwg2025




Richard Smith
-
d:cwg2026
CWG2026
20 October 2014
CD4
Zero-initialization and constexpr
https://wg21.link/cwg2026




Jason Merrill
-
d:cwg2027
CWG2027
20 October 2014
CD4
Unclear requirements for multiple alignas specifiers
https://wg21.link/cwg2027




Steve Clamage
-
d:cwg2028
CWG2028
25 October 2014
drafting
Converting constructors in rvalue reference initialization
https://wg21.link/cwg2028




Mitsuru Kariya
-
d:cwg2029
CWG2029
27 October 2014
dup
Abstract class return type in decltype operand
https://wg21.link/cwg2029




Mike Miller
-
d:cwg203
CWG203
8 February 2000
NAD
Type of address-of-member expression
https://wg21.link/cwg203




Lisa Lippincott
-
d:cwg2030
CWG2030
27 October 2014
NAD
Access of injected-class-name with template arguments
https://wg21.link/cwg2030




Mike Miller
-
d:cwg2031
CWG2031
20141031
CD4
Missing incompatibility for &&
https://wg21.link/cwg2031




Melissa Mears
-
d:cwg2032
CWG2032
3 November 2014
CD4
Default template-arguments of variable templates
https://wg21.link/cwg2032




CWG
-
d:cwg2033
CWG2033
4 November 2014
CD4
Redundant restriction on partial specialization argument
https://wg21.link/cwg2033




CWG
-
d:cwg2034
CWG2034
6 November 2014
NAD
Deprecating uncaught_exception()
https://wg21.link/cwg2034




CWG
-
d:cwg2035
CWG2035
6 November 2014
CD3
Multi-section example is confusing
https://wg21.link/cwg2035




CWG
-
d:cwg2036
CWG2036
5 November 2014
NAD
Refactoring parameters-and-qualifiers
https://wg21.link/cwg2036




Jonathan Caves
-
d:cwg2037
CWG2037
6 November 2014
drafting
Alias templates and template declaration matching
https://wg21.link/cwg2037




Richard Smith
-
d:cwg2038
CWG2038
8 November 2014
CD4
Document C++14 incompatibility of new braced deduction rule
https://wg21.link/cwg2038




Jonathan Caves
-
d:cwg2039
CWG2039
9 November 2014
CD4
Constant conversions to bool
https://wg21.link/cwg2039




Richard Smith
-
d:cwg204
CWG204
11 February 2000
CD1
Exported class templates
https://wg21.link/cwg204




Robert Klarer
-
d:cwg2040
CWG2040
9 November 2014
CD4
trailing-return-type no longer ambiguous
https://wg21.link/cwg2040




Jens Maurer
-
d:cwg2041
CWG2041
11 November 2014
CD4
Namespace for explicit class template specialization
https://wg21.link/cwg2041




Jason Merrill
-
d:cwg2042
CWG2042
13 November 2014
drafting
Exceptions and deallocation functions
https://wg21.link/cwg2042




Richard Smith
-
d:cwg2043
CWG2043
13 November 2014
drafting
Generalized template arguments and array-to-pointer decay
https://wg21.link/cwg2043




Richard Smith
-
d:cwg2044
CWG2044
14 November 2014
CD4
decltype(auto) and void
https://wg21.link/cwg2044




Richard Smith
-
d:cwg2045
CWG2045
14 November 2014
drafting
“Identical” template parameter lists
https://wg21.link/cwg2045




Faisal Vali
-
d:cwg2046
CWG2046
17 November 2014
C++17
Incomplete thread specifications
https://wg21.link/cwg2046




Dinka Ranns
-
d:cwg2047
CWG2047
18 November 2014
CD4
Coordinating “throws anything” specifications
https://wg21.link/cwg2047




Richard Smith
-
d:cwg2048
CWG2048
19 November 2014
open
C-style casts that cast away constness vs static_cast
https://wg21.link/cwg2048




Richard Smith
-
d:cwg2049
CWG2049
20 November 2014
drafting
List initializer in non-type template default argument
https://wg21.link/cwg2049




Ville Voutilainen
-
d:cwg205
CWG205
11 February 2000
drafting
Templates and static data members
https://wg21.link/cwg205




Mike Miller
-
d:cwg2050
CWG2050
26 November 2014
NAD
Consolidate specification of linkage
https://wg21.link/cwg2050




Alisdair Meredith
-
d:cwg2051
CWG2051
3 December 2014
drafting
Simplifying alias rules
https://wg21.link/cwg2051




Richard Smith
-
d:cwg2052
CWG2052
3 December 2014
CD4
Template argument deduction vs overloaded operators
https://wg21.link/cwg2052




Richard Smith
-
d:cwg2053
CWG2053
7 December 2014
drafting
auto in non-generic lambdas
https://wg21.link/cwg2053




Faisal Vali
-
d:cwg2054
CWG2054
7 December 2014
open
Missing description of class SFINAE
https://wg21.link/cwg2054




Ville Voutilainen
-
d:cwg2055
CWG2055
9 December 2014
drafting
Explicitly-specified non-deduced parameter packs
https://wg21.link/cwg2055




Jonathan Caves
-
d:cwg2056
CWG2056
11 December 2014
drafting
Member function calls in partially-initialized class objects
https://wg21.link/cwg2056




Richard Smith
-
d:cwg2057
CWG2057
12 December 2014
drafting
Template template arguments with default arguments
https://wg21.link/cwg2057




Jonathan Caves
-
d:cwg2058
CWG2058
15 December 2014
drafting
More errors from internal-linkage namespaces
https://wg21.link/cwg2058




Richard Smith
-
d:cwg2059
CWG2059
15 December 2014
DR
Linkage and deduced return types
https://wg21.link/cwg2059




Richard Smith
-
d:cwg206
CWG206
23 February 2000
TC1
Semantic constraints on non-dependent names
https://wg21.link/cwg206




Mike Miller
-
d:cwg2060
CWG2060
15 December 2014
NAD
Deduced return type for explicit specialization
https://wg21.link/cwg2060




John Spicer
-
d:cwg2061
CWG2061
18 December 2014
CD4
Inline namespace after simplifications
https://wg21.link/cwg2061




Richard Smith
-
d:cwg2062
CWG2062
19 December 2014
drafting
Class template redeclaration requirements
https://wg21.link/cwg2062




Hubert Tong
-
d:cwg2063
CWG2063
20 December 2014
CD4
Type/nontype hiding in class scope
https://wg21.link/cwg2063




Hubert Tong
-
d:cwg2064
CWG2064
27 December 2014
CD4
Conflicting specifications for dependent decltype-specifiers
https://wg21.link/cwg2064




Richard Smith
-
d:cwg2065
CWG2065
29 December 2014
drafting
Current instantiation of a partial specialization
https://wg21.link/cwg2065




Richard Smith
-
d:cwg2066
CWG2066
9 January 2015
CD4
Does type-dependent imply value-dependent?
https://wg21.link/cwg2066




Richard Smith
-
d:cwg2067
CWG2067
9 January 2015
open
Generated variadic templates requiring empty pack
https://wg21.link/cwg2067




Richard Smith
-
d:cwg2068
CWG2068
12 January 2015
CD4
When can/must a defaulted virtual destructor be defined?
https://wg21.link/cwg2068




Richard Smith
-
d:cwg2069
CWG2069
13 January 2015
CD4
Do destructors have names?
https://wg21.link/cwg2069




Richard Smith
-
d:cwg207
CWG207
28 February 2000
CD1
using-declarations and protected access
https://wg21.link/cwg207




Jason Merrill
-
d:cwg2070
CWG2070
15 January 2015
drafting
using-declaration with dependent nested-name-specifier
https://wg21.link/cwg2070




Richard Smith
-
d:cwg2071
CWG2071
16 January 2014
CD4
typedef with no declarator
https://wg21.link/cwg2071




Richard Smith
-
d:cwg2072
CWG2072
19 January 2015
drafting
Default argument instantiation for member functions of templates
https://wg21.link/cwg2072




Maxim Kartashev
-
d:cwg2073
CWG2073
20 January 2015
drafting
Allocating memory for exception objects
https://wg21.link/cwg2073




Jonathan Wakely
-
d:cwg2074
CWG2074
20 January 2015
drafting
Type-dependence of local class of function template
https://wg21.link/cwg2074




Richard Smith
-
d:cwg2075
CWG2075
27 January 2015
CD4
Passing short initializer lists to array reference parameters
https://wg21.link/cwg2075




Richard Smith
-
d:cwg2076
CWG2076
27 January 2015
CD4
List-initialization of arguments for constructor parameters
https://wg21.link/cwg2076




Richard Smith
-
d:cwg2077
CWG2077
29 January 2015
drafting
Overload resolution and invalid rvalue-reference initialization
https://wg21.link/cwg2077




Richard Smith
-
d:cwg2078
CWG2078
20150131
NAD
Name lookup of mem-initilizer-id
https://wg21.link/cwg2078




Richard Smith
-
d:cwg2079
CWG2079
3 February 2015
CD4
[[ appearing in a balanced-token-seq
https://wg21.link/cwg2079




Jonathan Caves
-
d:cwg208
CWG208
28 February 2000
CD1
Rethrowing exceptions in nested handlers
https://wg21.link/cwg208




Bill Wade
-
d:cwg2080
CWG2080
3 February 2015
drafting
Example with empty anonymous union member
https://wg21.link/cwg2080




John Spicer
-
d:cwg2081
CWG2081
5 February 2015
DR
Deduced return type in redeclaration or specialization of function template
https://wg21.link/cwg2081




John Spicer
-
d:cwg2082
CWG2082
9 February 2015
CD4
Referring to parameters in unevaluated operands of default arguments
https://wg21.link/cwg2082




Faisal Vali
-
d:cwg2083
CWG2083
11 February 2015
drafting
Incorrect cases of odr-use
https://wg21.link/cwg2083




Hubert Tong
-
d:cwg2084
CWG2084
12 February 2015
CD4
NSDMIs and deleted union default constructors
https://wg21.link/cwg2084




Daveed Vandevoorde
-
d:cwg2085
CWG2085
13 February 2015
CD4
Invalid example of adding special member function via default argument
https://wg21.link/cwg2085




Hubert Tong
-
d:cwg2086
CWG2086
14 February 2015
drafting
Reference odr-use vs implicit capture
https://wg21.link/cwg2086




Hubert Tong
-
d:cwg2087
CWG2087
16 February 2015
open
Left shift of negative value by zero bits
https://wg21.link/cwg2087




Mattheus Izvekov
-
d:cwg2088
CWG2088
19 February 2015
DR
Late tiebreakers in partial ordering
https://wg21.link/cwg2088




Richard Smith
-
d:cwg2089
CWG2089
26 February 2015
drafting
Restricting selection of builtin overloaded operators
https://wg21.link/cwg2089




Hubert Tong
-
d:cwg209
CWG209
1 March 2000
NAD
Must friend declaration names be accessible?
https://wg21.link/cwg209




Judy Ward
-
d:cwg2090
CWG2090
27 February 2015
drafting
Dependency via non-dependent base class
https://wg21.link/cwg2090




Maxim Kartashev
-
d:cwg2091
CWG2091
5 March 2015
CD4
Deducing reference non-type template arguments
https://wg21.link/cwg2091




Richard Smith
-
d:cwg2092
CWG2092
6 March 2015
DR
Deduction failure and overload resolution
https://wg21.link/cwg2092




Fedor Sergeev
-
d:cwg2093
CWG2093
6 March 2015
CD4
Qualification conversion for pointer-to-member handler matching
https://wg21.link/cwg2093




David Majnemer
-
d:cwg2094
CWG2094
6 March 2015
C++17
Trivial copy/move constructor for class with volatile member
https://wg21.link/cwg2094




Daveed Vandevoorde
-
d:cwg2095
CWG2095
7 March 2015
CD4
Capturing rvalue references to functions by copy
https://wg21.link/cwg2095




Hubert Tong
-
d:cwg2096
CWG2096
11 March 2015
CD4
Constraints on literal unions
https://wg21.link/cwg2096




Agustín K-ballo Bergé
-
d:cwg2097
CWG2097
12 March 2015
extension
Lambdas and noreturn attribute
https://wg21.link/cwg2097




Jonathan Caves
-
d:cwg2098
CWG2098
14 March 2015
CD4
Is uncaught_exceptions() per-thread?
https://wg21.link/cwg2098




Ville Voutilainen
-
d:cwg2099
CWG2099
15 March 2015
CD4
Inferring the bound of an array static data member
https://wg21.link/cwg2099




Richard Smith
-
d:cwg21
CWG21

TC1
Can a default argument for a template parameter appear in a friend declaration?
https://wg21.link/cwg21




unknown
-
d:cwg210
CWG210
6 March 2000
TC1
What is the type matched by an exception handler?
https://wg21.link/cwg210




Scott Douglass
-
d:cwg2100
CWG2100
16 March 2015
C++17
Value-dependent address of static data member of class template
https://wg21.link/cwg2100




Richard Smith
-
d:cwg2101
CWG2101
16 March 2015
CD4
Incorrect description of type- and value-dependence
https://wg21.link/cwg2101




Maxim Kartashev
-
d:cwg2102
CWG2102
16 March 2015
drafting
Constructor checking in new-expression
https://wg21.link/cwg2102




Richard Smith
-
d:cwg2103
CWG2103
17 March 2015
drafting
Lvalue-to-rvalue conversion is irrelevant in odr-use of a reference
https://wg21.link/cwg2103




Richard Smith
-
d:cwg2104
CWG2104
17 March 2015
CD4
Internal-linkage constexpr references and ODR requirements
https://wg21.link/cwg2104




James Widman
-
d:cwg2105
CWG2105
17 March 2015
open
When do the arguments for a parameter pack end?
https://wg21.link/cwg2105




Hubert Tong
-
d:cwg2106
CWG2106
17 March 2015
CD4
Unclear restrictions on use of function-type template arguments
https://wg21.link/cwg2106




David Krauss
-
d:cwg2107
CWG2107
19 March 2015
CD4
Lifetime of temporaries for default arguments in array copying
https://wg21.link/cwg2107




Hubert Tong
-
d:cwg2108
CWG2108
24 March 2015
drafting
Conversions to non-class prvalues in reference initialization
https://wg21.link/cwg2108




Hubert Tong
-
d:cwg2109
CWG2109
26 March 2015
CD4
Value dependence underspecified
https://wg21.link/cwg2109




Maxim Kartashev
-
d:cwg211
CWG211
8 March 2000
NAD
Constructors should not be allowed to return normally after an exception
https://wg21.link/cwg211




Bruce Mellows
-
d:cwg2110
CWG2110
27 March 2015
drafting
Overload resolution for base class conversion and reference/non-reference
https://wg21.link/cwg2110




Alexander Kulpin
-
d:cwg2111
CWG2111
2 April 2015
extension
Array temporaries in reference binding
https://wg21.link/cwg2111




Vinny Romano
-
d:cwg2112
CWG2112
3 April 2015
drafting
new auto{x}
https://wg21.link/cwg2112




Richard Smith
-
d:cwg2113
CWG2113
8 April 2015
CD4
Incompete specification of types for declarators
https://wg21.link/cwg2113




Richard Smith
-
d:cwg2114
CWG2114
14 April 2015
CD3
Missing description of incompatibility from aggregate NSDMIs
https://wg21.link/cwg2114




Ville Voutilainen
-
d:cwg2115
CWG2115
16 April 2015
drafting
Order of implicit destruction vs release of automatic storage
https://wg21.link/cwg2115




Richard Smith
-
d:cwg2116
CWG2116
22 April 2015
drafting
Direct or copy initialization for omitted aggregate initializers
https://wg21.link/cwg2116




Richard Smith
-
d:cwg2117
CWG2117
26 April 2015
drafting
Explicit specializations and constexpr function templates
https://wg21.link/cwg2117




Faisal Vali
-
d:cwg2118
CWG2118
27 April 2015
open
Stateful metaprogramming via friend injection
https://wg21.link/cwg2118




Richard Smith
-
d:cwg2119
CWG2119
5 May 2015
NAD
Disambiguation of multi-level covariant return type
https://wg21.link/cwg2119




David Majnemer
-
d:cwg212
CWG212
7 March 2000
CD4
Implicit instantiation is not described clearly enough
https://wg21.link/cwg212




Christophe de Dinechin
-
d:cwg2120
CWG2120
6 May 2015
CD4
Array as first non-static data member in standard-layout class
https://wg21.link/cwg2120




Hubert Tong
-
d:cwg2121
CWG2121
6 May 2015
drafting
More flexible lambda syntax
https://wg21.link/cwg2121




EWG
-
d:cwg2122
CWG2122
5 May 2015
CD4
Glvalues of void type
https://wg21.link/cwg2122




CWG
-
d:cwg2123
CWG2123
2 February 2015
open
Omitted constant initialization of local static variables
https://wg21.link/cwg2123




Hubert Tong
-
d:cwg2124
CWG2124
5 May 2015
CD4
Signature of constructor template
https://wg21.link/cwg2124




Hubert Tong
-
d:cwg2125
CWG2125
6 May 2015
extension
Copy elision and comma operator
https://wg21.link/cwg2125




Vinny Romano
-
d:cwg2126
CWG2126
20 May 2015
drafting
Lifetime-extended temporaries in constant expressions
https://wg21.link/cwg2126




Richard Smith
-
d:cwg2127
CWG2127
18 May 2015
drafting
Partial specialization and nullptr
https://wg21.link/cwg2127




Faisal Vali
-
d:cwg2128
CWG2128
19 May 2015
drafting
Imprecise rule for reference member initializer
https://wg21.link/cwg2128




Richard Smith
-
d:cwg2129
CWG2129
20 May 2015
CD4
Non-object prvalues and constant expressions
https://wg21.link/cwg2129




Faisal Vali
-
d:cwg213
CWG213
10 March 2000
TC1
Lookup in dependent base classes
https://wg21.link/cwg213




John Spicer
-
d:cwg2130
CWG2130
28 May 2015
CD4
Over-aligned types in new-expressions
https://wg21.link/cwg2130




Richard Smith
-
d:cwg2131
CWG2131
28 May 2015
drafting
Ambiguity with opaque-enum-declaration
https://wg21.link/cwg2131




Richard Smith
-
d:cwg2132
CWG2132
28 May 2015
extension
Deprecated default generated copy constructors
https://wg21.link/cwg2132




Nico Josuttis
-
d:cwg2133
CWG2133
28 May 2015
open
Converting std::nullptr_t to bool
https://wg21.link/cwg2133




Richard Smith
-
d:cwg2134
CWG2134
3 June 2015
NAD
Objectless references to non-static member functions
https://wg21.link/cwg2134




Aaron Ballman
-
d:cwg2135
CWG2135
6 June 2015
NAD
mem-initializers for virtual bases of abstract classes
https://wg21.link/cwg2135




Vinny Romano
-
d:cwg2136
CWG2136
10 June 2015
NAD
Argument-dependent lookup and initializer lists
https://wg21.link/cwg2136




Ryou Ezoe
-
d:cwg2137
CWG2137
10 June 2015
CD4
List-initialization from object of same type
https://wg21.link/cwg2137




Richard Smith
-
d:cwg2138
CWG2138
11 June 2015
NAD
Explicit member specialization vs implicit instantiation
https://wg21.link/cwg2138




Richard Smith
-
d:cwg2139
CWG2139
12 June 2015
NAD
Floating-point requirements for integer representation
https://wg21.link/cwg2139




Tony Van Eerd
-
d:cwg214
CWG214
13 March 2000
CD1
Partial ordering of function templates is underspecified
https://wg21.link/cwg214




Martin von Loewis/Martin Sebor
-
d:cwg2140
CWG2140
12 June 2015
CD4
Lvalue-to-rvalue conversion of std::nullptr_t
https://wg21.link/cwg2140




Richard Smith
-
d:cwg2141
CWG2141
12 June 2015
CD4
Ambiguity in new-expression with elaborated-type-specifier
https://wg21.link/cwg2141




Hubert Tong
-
d:cwg2142
CWG2142
13 June 2015
NAD
Missing definition of associated classes and namespaces
https://wg21.link/cwg2142




Daniel Krügler
-
d:cwg2143
CWG2143
16 June 2015
C++17
Value-dependency via injected-class-name
https://wg21.link/cwg2143




Maxim Kartashev
-
d:cwg2144
CWG2144
19 June 2015
drafting
Function/variable declaration ambiguity
https://wg21.link/cwg2144




Richard Smith
-
d:cwg2145
CWG2145
19 June 2015
CD4
Parenthesized declarator in function definition
https://wg21.link/cwg2145




Richard Smith
-
d:cwg2146
CWG2146
22 June 2015
CD4
Scalar object vs memory location in definition of “unsequenced”
https://wg21.link/cwg2146




Jens Maurer
-
d:cwg2147
CWG2147
22 June 2015
CD4
Initializer-list arguments and pack deduction
https://wg21.link/cwg2147




Hubert Tong
-
d:cwg2148
CWG2148
22 June 2015
drafting
Thread storage duration and order of initialization
https://wg21.link/cwg2148




Hubert Tong
-
d:cwg2149
CWG2149
25 June 2015
drafting
Brace elision and array length deduction
https://wg21.link/cwg2149




Vinny Romano
-
d:cwg215
CWG215
13 March 2000
CD1
Template parameters are not allowed in nested-name-specifiers
https://wg21.link/cwg215




Martin von Loewis
-
d:cwg2150
CWG2150
26 June 2015
CD3
Initializer list array lifetime
https://wg21.link/cwg2150




Hubert Tong
-
d:cwg2151
CWG2151
26 June 2015
drafting
Exception object is not created
https://wg21.link/cwg2151




Hubert Tong
-
d:cwg2152
CWG2152
28 June 2015
NAD
Can an alternative token be used as a ud-suffix?
https://wg21.link/cwg2152




David Krauss
-
d:cwg2153
CWG2153
20150630
CD4
pure-specifier in friend declaration
https://wg21.link/cwg2153




Richard Smith
-
d:cwg2154
CWG2154
20150630
CD4
Ambiguity of pure-specifier
https://wg21.link/cwg2154




Richard Smith
-
d:cwg2155
CWG2155
5 July 2015
C++17
Defining classes and enumerations via using-declarations
https://wg21.link/cwg2155




Richard Smith
-
d:cwg2156
CWG2156
6 July 2015
CD4
Definition of enumeration declared by using-declaration
https://wg21.link/cwg2156




Richard Smith
-
d:cwg2157
CWG2157
6 July 2015
CD4
Further disambiguation of enumeration elaborated-type-specifier
https://wg21.link/cwg2157




Richard Smith
-
d:cwg2158
CWG2158
13 July 2015
drafting
Polymorphic behavior during destruction
https://wg21.link/cwg2158




Richard Smith
-
d:cwg2159
CWG2159
15 July 2015
NAD
Lambda capture and local thread_local variables
https://wg21.link/cwg2159




Richard Smith
-
d:cwg216
CWG216
13 March 2000
CD1
Linkage of nameless class-scope enumeration types
https://wg21.link/cwg216




Daveed Vandevoorde
-
d:cwg2160
CWG2160
16 July 2015
open
Issues with partial ordering
https://wg21.link/cwg2160




Richard Smith
-
d:cwg2161
CWG2161
22 July 2015
NAD
Explicit instantiation declaration and “preceding initialization”
https://wg21.link/cwg2161




Hubert Tong
-
d:cwg2162
CWG2162
23 July 2015
CD3
Capturing this by reference
https://wg21.link/cwg2162




Brian Bi
-
d:cwg2163
CWG2163
24 July 2015
CD4
Labels in constexpr functions
https://wg21.link/cwg2163




Richard Smith
-
d:cwg2164
CWG2164
26 July 2015
DR
Name hiding and using-directives
https://wg21.link/cwg2164




Richard Smith
-
d:cwg2165
CWG2165
20150730
drafting
Namespaces, declarative regions, and translation units
https://wg21.link/cwg2165




Richard Smith
-
d:cwg2166
CWG2166
5 August 2015
drafting
Unclear meaning of “undefined constexpr function”
https://wg21.link/cwg2166




Howard Hinnant
-
d:cwg2167
CWG2167
11 August 2015
CD4
Non-member references with lifetimes within the current evaluation
https://wg21.link/cwg2167




Richard Smith
-
d:cwg2168
CWG2168
19 August 2015
open
Narrowing conversions and +/- infinity
https://wg21.link/cwg2168




Hubert Tong
-
d:cwg2169
CWG2169
26 August 2015
extension
Narrowing conversions and overload resolution
https://wg21.link/cwg2169




David Krauss
-
d:cwg217
CWG217
22 March 2000
TC1
Default arguments for non-template member functions of class templates
https://wg21.link/cwg217




Martin Sebor
-
d:cwg2170
CWG2170
2 September 2015
drafting
Unclear definition of odr-use for arrays
https://wg21.link/cwg2170




Hubert Tong
-
d:cwg2171
CWG2171
14 September 2015
CD4
Triviality of copy constructor with less-qualified parameter
https://wg21.link/cwg2171




Jason Merrill
-
d:cwg2172
CWG2172
14 September 2015
drafting
Multiple exceptions with one exception object
https://wg21.link/cwg2172




Richard Smith
-
d:cwg2173
CWG2173
14 September 2015
open
Partial specialization with non-deduced contexts
https://wg21.link/cwg2173




Mike Miller
-
d:cwg2174
CWG2174
17 September 2015
C++17
Unclear rules for friend definitions in templates
https://wg21.link/cwg2174




Richard Smith
-
d:cwg2175
CWG2175
17 September 2015
CD4
Ambiguity with attribute in conversion operator declaration
https://wg21.link/cwg2175




Daveed Vandevoorde
-
d:cwg2176
CWG2176
28 September 2015
CD4
Destroying the returned object when a destructor throws
https://wg21.link/cwg2176




Richard Smith
-
d:cwg2177
CWG2177
20150930
DR
Placement operator delete and parameter copies
https://wg21.link/cwg2177




Richard Smith
-
d:cwg2178
CWG2178
6 October 2015
NAD
Substitution of dependent template arguments in default template arguments
https://wg21.link/cwg2178




Richard Smith
-
d:cwg2179
CWG2179
12 October 2015
drafting
Required diagnostic for partial specialization after first use
https://wg21.link/cwg2179




John Spicer
-
d:cwg218
CWG218
28 March 2000
CD1
Specification of Koenig lookup
https://wg21.link/cwg218




Hyman Rosen
-
d:cwg2180
CWG2180
13 October 2015
CD4
Virtual bases in destructors and defaulted assignment operators
https://wg21.link/cwg2180




Vinny Romano
-
d:cwg2181
CWG2181
18 October 2015
drafting
Normative requirements in an informative Annex
https://wg21.link/cwg2181




Sean Hunt
-
d:cwg2182
CWG2182
20 October 2015
drafting
Pointer arithmetic in array-like containers
https://wg21.link/cwg2182




Jonathan Wakely
-
d:cwg2183
CWG2183
21 October 2015
NAD
Problems in description of potential exceptions
https://wg21.link/cwg2183




Hubert Tong
-
d:cwg2184
CWG2184
21 October 2015
CD4
Missing C compatibility entry for decrement of bool
https://wg21.link/cwg2184




CWG
-
d:cwg2185
CWG2185
21 October 2015
open
Cv-qualified numeric types
https://wg21.link/cwg2185




CWG
-
d:cwg2186
CWG2186
24 October 2015
drafting
Unclear point that “preceding initialization” must precede
https://wg21.link/cwg2186




Hubert Tong
-
d:cwg2187
CWG2187
16 October 2015
drafting
Protected members and access via qualified-id
https://wg21.link/cwg2187




Hubert Tong
-
d:cwg2188
CWG2188
21 October 2015
open
empty-declaration ambiguity
https://wg21.link/cwg2188




Jens Maurer
-
d:cwg2189
CWG2189
22 October 2015
open
Surrogate call template
https://wg21.link/cwg2189




Jason Merrill
-
d:cwg219
CWG219
31 March 2000
NAD
Cannot defend against destructors that throw exceptions
https://wg21.link/cwg219




Herb Sutter
-
d:cwg2190
CWG2190
24 October 2015
open
Insufficient specification of __has_include
https://wg21.link/cwg2190




Hubert Tong
-
d:cwg2191
CWG2191
26 October 2015
C++17
Incorrect result for noexcept(typeid(v))
https://wg21.link/cwg2191




Mike Miller
-
d:cwg2192
CWG2192
27 October 2015
open
Constant expressions and order-of-eval undefined behavior
https://wg21.link/cwg2192




Peter Sommerlad
-
d:cwg2193
CWG2193
2 November 2015
NAD
numeric_limits<int>::radix and digits
https://wg21.link/cwg2193




Tony Van Eerd
-
d:cwg2194
CWG2194
4 November 2015
review
Impossible case in list initialization
https://wg21.link/cwg2194




Robert Haberlach
-
d:cwg2195
CWG2195
6 November 2015
open
Unsolicited reading of trailing volatile members
https://wg21.link/cwg2195




Hubert Tong
-
d:cwg2196
CWG2196
6 November 2015
C++17
Zero-initialization with virtual base classes
https://wg21.link/cwg2196




Richard Smith
-
d:cwg2197
CWG2197
11 November 2015
review
Overload resolution and deleted special member functions
https://wg21.link/cwg2197




Maxim Kartashev
-
d:cwg2198
CWG2198
12 November 2015
C++17
Linkage of enumerators
https://wg21.link/cwg2198




Richard Smith
-
d:cwg2199
CWG2199
12 November 2015
drafting
Typedefs and tags
https://wg21.link/cwg2199




Richard Smith
-
d:cwg22
CWG22

TC1
Template parameter with a default argument that refers to itself
https://wg21.link/cwg22




unknown
-
d:cwg220
CWG220
31 March 2000
CD1
All deallocation functions should be required not to throw
https://wg21.link/cwg220




Herb Sutter
-
d:cwg2200
CWG2200
14 November 2015
NAD
Conversions in template argument deduction
https://wg21.link/cwg2200




Vinny Romano
-
d:cwg2201
CWG2201
15 November 2015
C++17
Cv-qualification of array types
https://wg21.link/cwg2201




Robert Haberlach
-
d:cwg2202
CWG2202
19 November 2015
drafting
When does default argument instantiation occur?
https://wg21.link/cwg2202




Richard Smith
-
d:cwg2203
CWG2203
20 November 2015
drafting
Defaulted copy/move constructors and UDCs
https://wg21.link/cwg2203




Vinny Romano
-
d:cwg2204
CWG2204
25 November 2015
NAD
Naming delegated constructors
https://wg21.link/cwg2204




Hubert Tong
-
d:cwg2205
CWG2205
20151130
C++17
Restrictions on use of alignas
https://wg21.link/cwg2205




Richard Smith
-
d:cwg2206
CWG2206
1 December 2015
C++17
Composite type of object and function pointers
https://wg21.link/cwg2206




Mike Miller
-
d:cwg2207
CWG2207
2 December 2015
drafting
Alignment of allocation function return value
https://wg21.link/cwg2207




Richard Smith
-
d:cwg2208
CWG2208
2 December 2015
NAD
static_assert-declaration does not declare a member
https://wg21.link/cwg2208




Stephan Bergmann
-
d:cwg2209
CWG2209
3 December 2015
NAD
Destruction of constructed array elements
https://wg21.link/cwg2209




Robert Haberlach
-
d:cwg221
CWG221
3 April 2000
CD1
Must compound assignment operators be member functions?
https://wg21.link/cwg221




Jim Hyslop
-
d:cwg2210
CWG2210
6 December 2015
NAD
Principal/target constructor confusion
https://wg21.link/cwg2210




Robert Haberlach
-
d:cwg2211
CWG2211
7 December 2015
C++17
Hiding by lambda captures and parameters
https://wg21.link/cwg2211




Ville Voutilainen
-
d:cwg2212
CWG2212
9 December 2015
open
Typedef changing linkage after use
https://wg21.link/cwg2212




Richard Smith
-
d:cwg2213
CWG2213
11 December 2015
drafting
Forward declaration of partial specializations
https://wg21.link/cwg2213




Richard Smith
-
d:cwg2214
CWG2214
15 December 2015
C++17
Missing requirement on representation of integer values
https://wg21.link/cwg2214




Richard Smith
-
d:cwg2215
CWG2215
17 December 2015
review
Redundant description of language linkage in function call
https://wg21.link/cwg2215




Richard Smith
-
d:cwg2216
CWG2216
21 December 2015
NAD
Exception specifications in unevaluated contexts
https://wg21.link/cwg2216




Daniel Krügler
-
d:cwg2217
CWG2217
21 December 2015
NAD
constexpr constructors for non-literal types
https://wg21.link/cwg2217




Daveed Vandevoorde
-
d:cwg2218
CWG2218
29 December 2015
C++17
Ambiguity and namespace aliases
https://wg21.link/cwg2218




Richard Smith
-
d:cwg2219
CWG2219
4 January 2016
drafting
Dynamically-unreachable handlers
https://wg21.link/cwg2219




Richard Smith
-
d:cwg222
CWG222
20 December 1999
CD1
Sequence points and lvalue-returning operators
https://wg21.link/cwg222




Andrew Koenig
-
d:cwg2220
CWG2220
8 January 2016
C++17
Hiding index variable in range-based for
https://wg21.link/cwg2220




Daveed Vandevoorde
-
d:cwg2221
CWG2221
9 January 2016
review
Copying volatile objects
https://wg21.link/cwg2221




Vinny Romano
-
d:cwg2222
CWG2222
11 January 2016
drafting
Additional contexts where instantiation is not required
https://wg21.link/cwg2222




CWG
-
d:cwg2223
CWG2223
12 January 2016
drafting
Multiple alignas specifiers
https://wg21.link/cwg2223




Mike Herrick
-
d:cwg2224
CWG2224
13 January 2016
C++17
Member subobjects and base-class casts
https://wg21.link/cwg2224




Aaron Ballman
-
d:cwg2225
CWG2225
14 January 2016
NAD
reinterpret_cast to same floating-point type
https://wg21.link/cwg2225




Aaron Ballman
-
d:cwg2226
CWG2226
1 February 2016
DR
Xvalues vs lvalues in conditional expressions
https://wg21.link/cwg2226




Richard Smith
-
d:cwg2227
CWG2227
1 February 2016
DR
Destructor access and default member initializers
https://wg21.link/cwg2227




Richard Smith
-
d:cwg2228
CWG2228
2 February 2016
drafting
Ambiguity resolution for cast to function type
https://wg21.link/cwg2228




Richard Smith
-
d:cwg2229
CWG2229
8 February 2016
DR
Volatile unnamed bit-fields
https://wg21.link/cwg2229




David Majnemer
-
d:cwg223
CWG223
19 April 2000
CD3
The meaning of deprecation
https://wg21.link/cwg223




Mike Miller
-
d:cwg2230
CWG2230
9 March 2016
NAD
Linkage of extern "C" function in unnamed namespace
https://wg21.link/cwg2230




Jonathan Wakely
-
d:cwg2231
CWG2231
18 February 2016
NAD
Class member access to static data member template
https://wg21.link/cwg2231




Faisal Vali
-
d:cwg2232
CWG2232
23 February 2016
open
thread_local anonymous unions
https://wg21.link/cwg2232




Mike Herrick
-
d:cwg2233
CWG2233
25 February 2016
tentatively ready
Function parameter packs following default arguments
https://wg21.link/cwg2233




Richard Smith
-
d:cwg2234
CWG2234
25 February 2016
DR
Missing rules for simple-template-id as class-name
https://wg21.link/cwg2234




Richard Smith
-
d:cwg2235
CWG2235
25 February 2016
DR
Partial ordering and non-dependent types
https://wg21.link/cwg2235




Richard Smith
-
d:cwg2236
CWG2236
1 March 2016
drafting
When is an alias template specialization dependent?
https://wg21.link/cwg2236




Maxim Kartashev
-
d:cwg2237
CWG2237
2 March 2016
accepted
Can a template-id name a constructor?
https://wg21.link/cwg2237




Faisal Vali
-
d:cwg2238
CWG2238
3 March 2016
NAD
Contradictory alignment requirements for allocation
https://wg21.link/cwg2238




Jason Merrill
-
d:cwg2239
CWG2239
3 March 2016
NAD
Sized deallocation with a trivial destructor
https://wg21.link/cwg2239




CWG
-
d:cwg224
CWG224
30 November 1999
CD1
Definition of dependent names
https://wg21.link/cwg224




Derek Inglis
-
d:cwg2240
CWG2240
4 March 2016
drafting
this is not odr-used in a constant expression
https://wg21.link/cwg2240




Daveed Vandevoorde
-
d:cwg2241
CWG2241
4 March 2016
DR
Overload resolution is not invoked with a single function
https://wg21.link/cwg2241




CWG
-
d:cwg2242
CWG2242
5 March 2016
drafting
ODR violation with constant initialization possibly omitted
https://wg21.link/cwg2242




Hubert Tong
-
d:cwg2243
CWG2243
8 March 2016
drafting
Incorrect use of implicit conversion sequence
https://wg21.link/cwg2243




Hubert Tong
-
d:cwg2244
CWG2244
8 March 2016
open
Base class access in aggregate initialization
https://wg21.link/cwg2244




Richard Smith
-
d:cwg2245
CWG2245
8 March 2016
drafting
Point of instantiation of incomplete class template
https://wg21.link/cwg2245




Richard Smith
-
d:cwg2246
CWG2246
8 March 2016
drafting
Access of indirect virtual base class constructors
https://wg21.link/cwg2246




Vinny Romano
-
d:cwg2247
CWG2247
11 March 2016
C++17
Lambda capture and variable argument list
https://wg21.link/cwg2247




Aaron Ballman
-
d:cwg2248
CWG2248
14 March 2016
C++17
Problems with sized delete
https://wg21.link/cwg2248




Richard Smith
-
d:cwg2249
CWG2249
17 March 2016
tentatively ready
identifiers and id-expressions
https://wg21.link/cwg2249




Robert Haberlach
-
d:cwg225
CWG225
26 January 2000
NAD
Koenig lookup and fundamental types
https://wg21.link/cwg225




Derek Inglis
-
d:cwg2250
CWG2250
21 March 2016
open
Implicit instantiation, destruction, and TUs
https://wg21.link/cwg2250




Dawn Perchik
-
d:cwg2251
CWG2251
22 March 2016
C++17
Unreachable enumeration list-initialization
https://wg21.link/cwg2251




Richard Smith
-
d:cwg2252
CWG2252
22 March 2016
review
Enumeration list-initialization from the same type
https://wg21.link/cwg2252




Richard Smith
-
d:cwg2253
CWG2253
23 March 2016
DRWP
Unnamed bit-fields and zero-initialization
https://wg21.link/cwg2253




Aaron Ballman
-
d:cwg2254
CWG2254
23 March 2016
ready
Standard-layout classes and bit-fields
https://wg21.link/cwg2254




Richard Smith
-
d:cwg2255
CWG2255
29 March 2016
DR
Instantiated static data member templates
https://wg21.link/cwg2255




Mike Miller
-
d:cwg2256
CWG2256
20160330
drafting
Lifetime of trivially-destructible objects
https://wg21.link/cwg2256




Richard Smith
-
d:cwg2257
CWG2257
7 April 2016
drafting
Lifetime extension of references vs exceptions
https://wg21.link/cwg2257




Hubert Tong
-
d:cwg2258
CWG2258
12 April 2016
open
Storage deallocation during period of destruction
https://wg21.link/cwg2258




Richard Smith
-
d:cwg2259
CWG2259
12 April 2016
C++17
Unclear context describing ambiguity
https://wg21.link/cwg2259




Richard Smith
-
d:cwg226
CWG226
19 April 2000
CD1
Default template arguments for function templates
https://wg21.link/cwg226




Bjarne Stroustrup
-
d:cwg2260
CWG2260
17 April 2016
DR
Explicit specializations of deleted member functions
https://wg21.link/cwg2260




Richard Smith
-
d:cwg2261
CWG2261
28 April 2016
extension
Explicit instantiation of in-class friend definition
https://wg21.link/cwg2261




Jens Maurer
-
d:cwg2262
CWG2262
4 May 2016
C++17
Attributes for asm-definition
https://wg21.link/cwg2262




Richard Smith
-
d:cwg2263
CWG2263
4 May 2016
drafting
Default argument instantiation for friends
https://wg21.link/cwg2263




Hubert Tong
-
d:cwg2264
CWG2264
6 May 2016
drafting
Memberwise copying with indeterminate value
https://wg21.link/cwg2264




Hubert Tong
-
d:cwg2265
CWG2265
11 May 2016
drafting
Delayed pack expansion and member redeclarations
https://wg21.link/cwg2265




Hubert Tong
-
d:cwg2266
CWG2266
20 May 2016
drafting
Has dependent type vs is type-dependent
https://wg21.link/cwg2266




Fedor Sergeev
-
d:cwg2267
CWG2267
25 May 2016
drafting
Copy-initialization of temporary in reference direct-initialization
https://wg21.link/cwg2267




Richard Smith
-
d:cwg2268
CWG2268
26 May 2016
C++17
Unions with mutable members in constant expressions revisited
https://wg21.link/cwg2268




Richard Smith
-
d:cwg2269
CWG2269
7 June 2016
dup
Additional recursive references in aggregate DMIs
https://wg21.link/cwg2269




Vinny Romano
-
d:cwg227
CWG227
21 April 2000
TC1
How many scopes in an if statement?
https://wg21.link/cwg227




Marc Paterno
-
d:cwg2270
CWG2270
10 June 2016
extension
Non-inline functions and explicit instantiation declarations
https://wg21.link/cwg2270




Richard Smith
-
d:cwg2271
CWG2271
20 June 2016
C++17
Aliasing this
https://wg21.link/cwg2271




Richard Smith
-
d:cwg2272
CWG2272
10 June 2016
C++17
Implicit initialization of aggregate members of reference type
https://wg21.link/cwg2272




Vinny Romano
-
d:cwg2273
CWG2273
17 June 2016
DRWP
Inheriting constructors vs implicit default constructor
https://wg21.link/cwg2273




Richard Smith
-
d:cwg2274
CWG2274
20 June 2016
NAD
Generic lambda capture vs constexpr if
https://wg21.link/cwg2274




Richard Smith
-
d:cwg2275
CWG2275
21 June 2016
drafting
Type-dependence of function template
https://wg21.link/cwg2275




Jason Merrill
-
d:cwg2276
CWG2276
23 June 2016
C++17
Dependent noexcept and function type-dependence
https://wg21.link/cwg2276




Maxim Kartashev
-
d:cwg2277
CWG2277
23 June 2016
DRWP
Ambiguity inheriting constructors with default arguments
https://wg21.link/cwg2277




Richard Smith
-
d:cwg2278
CWG2278
27 June 2016
drafting
Copy elision in constant expressions reconsidered
https://wg21.link/cwg2278




Richard Smith
-
d:cwg2279
CWG2279
27 June 2016
NAD
Multiple attribute-specifiers in one attribute-list
https://wg21.link/cwg2279




Richard Smith
-
d:cwg228
CWG228
4 May 2000
CD1
Use of template keyword with non-member templates
https://wg21.link/cwg228




Daveed Vandevoorde
-
d:cwg2280
CWG2280
27 June 2016
review
Matching a usual deallocation function with placement new
https://wg21.link/cwg2280




Richard Smith
-
d:cwg2281
CWG2281
27 June 2016
drafting
Consistency of aligned operator delete replacement
https://wg21.link/cwg2281




Richard Smith
-
d:cwg2282
CWG2282
27 June 2016
drafting
Consistency with mismatched aligned/non-over-aligned allocation/deallocation functions
https://wg21.link/cwg2282




Richard Smith
-
d:cwg2283
CWG2283
27 June 2016
drafting
Missing complete type requirements
https://wg21.link/cwg2283




Richard Smith
-
d:cwg2284
CWG2284
20160630
open
Sequencing of braced-init-list arguments
https://wg21.link/cwg2284




Richard Smith
-
d:cwg2285
CWG2285
1 July 2016
tentatively ready
Issues with structured bindings
https://wg21.link/cwg2285




Richard Smith
-
d:cwg2286
CWG2286
6 July 2016
NAD
Assignment evaluation order
https://wg21.link/cwg2286




Jason Merrill
-
d:cwg2287
CWG2287
6 July 2016
DRWP
Pointer-interconvertibility in non-standard-layout unions
https://wg21.link/cwg2287




Richard Smith
-
d:cwg2288
CWG2288
12 July 2016
NAD
Contradictory optionality in simple-declaration
https://wg21.link/cwg2288




Gabriel Dos Reis
-
d:cwg2289
CWG2289
20 July 2016
drafting
Uniqueness of decomposition declaration names
https://wg21.link/cwg2289




Richard Smith
-
d:cwg229
CWG229
1 April 2000
NAD
Partial specialization of function templates
https://wg21.link/cwg229




Dave Abrahams
-
d:cwg2290
CWG2290
21 July 2016
DRWP
Unclear specification for overload resolution and deleted special member functions
https://wg21.link/cwg2290




Howard Hinnant
-
d:cwg2291
CWG2291
20 June 2016
dup
Implicit conversion sequences in non-call contexts
https://wg21.link/cwg2291




Hubert Tong
-
d:cwg2292
CWG2292
22 June 2016
drafting
simple-template-id is ambiguous between class-name and type-name
https://wg21.link/cwg2292




CWG
-
d:cwg2293
CWG2293
22 June 2016
ready
Requirements for simple-template-id used as a class-name
https://wg21.link/cwg2293




CWG
-
d:cwg2294
CWG2294
22 June 2016
ready
Dependent auto static data members
https://wg21.link/cwg2294




Richard Smith
-
d:cwg2295
CWG2295
24 June 2016
extension
Aggregates with deleted defaulted constructors
https://wg21.link/cwg2295




Thomas Köppe
-
d:cwg2296
CWG2296
25 June 2016
extension
Are default argument instantiation failures in the “immediate context”?
https://wg21.link/cwg2296




Jason Merrill
-
d:cwg2297
CWG2297
21 January 2016
review
Unclear specification of atomic operations
https://wg21.link/cwg2297




Kazutoshi Satoda
-
d:cwg2298
CWG2298
21 January 2016
concurrency
Actions and expression evaluation
https://wg21.link/cwg2298




Kazutoshi Satoda
-
d:cwg2299
CWG2299
11 April 2016
DR
constexpr vararg functions
https://wg21.link/cwg2299




Daveed Vandevoorde
-
d:cwg23
CWG23

NAD
Some questions regarding partial ordering of function templates
https://wg21.link/cwg23




unknown
-
d:cwg230
CWG230
4 May 2000
NAD
Calls to pure virtual functions
https://wg21.link/cwg230




Jim Hill
-
d:cwg2300
CWG2300
11 April 2016
drafting
Lambdas in multiple definitions
https://wg21.link/cwg2300




Robert Haberlach
-
d:cwg2301
CWG2301
18 April 2016
open
Value-initialization and constexpr constructor evaluation
https://wg21.link/cwg2301




Daveed Vandevoorde
-
d:cwg2302
CWG2302
29 April 2016
NAD
Address comparison between different member subobjects
https://wg21.link/cwg2302




Daveed Vandevoorde
-
d:cwg2303
CWG2303
24 May 2016
drafting
Partial ordering and recursive variadic inheritance
https://wg21.link/cwg2303




John Spicer
-
d:cwg2304
CWG2304
5 July 2016
NAD
Incomplete type vs overload resolution
https://wg21.link/cwg2304




John Spicer
-
d:cwg2305
CWG2305
14 July 2016
DR
Explicit instantiation of constexpr or inline variable template
https://wg21.link/cwg2305




John Spicer
-
d:cwg2306
CWG2306
17 July 2016
open
Nested friend templates of class templates
https://wg21.link/cwg2306




John Spicer
-
d:cwg2307
CWG2307
21 July 2016
DR
Unclear definition of “equivalent to a nontype template parameter”
https://wg21.link/cwg2307




Richard Smith
-
d:cwg2308
CWG2308
23 July 2016
NAD
Structured bindings and lambda capture
https://wg21.link/cwg2308




Richard Smith
-
d:cwg2309
CWG2309
20160730
drafting
Restrictions on nested statements within constexpr functions
https://wg21.link/cwg2309




Faisal Vali
-
d:cwg231
CWG231
31 May 2000
NAD
Visibility of names after using-directives
https://wg21.link/cwg231




Jörg Barfurth
-
d:cwg2310
CWG2310
8 August 2016
drafting
Type completeness and derived-to-base pointer conversions
https://wg21.link/cwg2310




Richard Smith
-
d:cwg2311
CWG2311
9 August 2016
open
Missed case for guaranteed copy elision
https://wg21.link/cwg2311




Richard Smith
-
d:cwg2312
CWG2312
11 August 2016
ready
Structured bindings and mutable
https://wg21.link/cwg2312




Richard Smith
-
d:cwg2313
CWG2313
12 August 2016
DR
Redeclaration of structured binding reference variables
https://wg21.link/cwg2313




Richard Smith
-
d:cwg2314
CWG2314
14 August 2016
dup
Structured bindings and lambda capture
https://wg21.link/cwg2314




Richard Smith
-
d:cwg2315
CWG2315
15 August 2016
DR
What is the “corresponding special member” of a variant member?
https://wg21.link/cwg2315




Richard Smith
-
d:cwg2316
CWG2316
16 August 2016
drafting
Simplifying class conversions in conditional expressions
https://wg21.link/cwg2316




S. B. Tam
-
d:cwg2317
CWG2317
29 August 2016
drafting
Self-referential default member initializers
https://wg21.link/cwg2317




Richard Smith
-
d:cwg2318
CWG2318
12 August 2016
drafting
Nondeduced contexts in deduction from a braced-init-list
https://wg21.link/cwg2318




Jonathan Caves
-
d:cwg2319
CWG2319
6 September 2016
drafting
Nested brace initialization from same type
https://wg21.link/cwg2319




Richard Smith
-
d:cwg232
CWG232
5 June 2000
drafting
Is indirection through a null pointer undefined behavior?
https://wg21.link/cwg232




Mike Miller
-
d:cwg2320
CWG2320
6 September 2016
extension
constexpr if and boolean conversions
https://wg21.link/cwg2320




Richard Smith
-
d:cwg2321
CWG2321
6 September 2016
ready
Conditional operator and cv-qualified class prvalues
https://wg21.link/cwg2321




Richard Smith
-
d:cwg2322
CWG2322
6 September 2016
ready
Substitution failure and lexical order
https://wg21.link/cwg2322




Xiang Fan
-
d:cwg2323
CWG2323
27 February 2017
accepted
Expunge POD
https://wg21.link/cwg2323




US
-
d:cwg2324
CWG2324
27 February 2017
drafting
Size of base class subobject
https://wg21.link/cwg2324




GB
-
d:cwg2325
CWG2325
27 February 2017
drafting
std::launder and reuse of character buffers
https://wg21.link/cwg2325




CA
-
d:cwg2326
CWG2326
12 August 2016
dup
Type deduction with initializer list containing ambiguous functions
https://wg21.link/cwg2326




Jonathan Caves
-
d:cwg2327
CWG2327
20160930
drafting
Copy elision for direct-initialization with a conversion function
https://wg21.link/cwg2327




Richard Smith
-
d:cwg2328
CWG2328
11 October 2016
open
Unclear presentation style of template argument deduction rules
https://wg21.link/cwg2328




Richard Smith
-
d:cwg2329
CWG2329
20161031
drafting
Virtual base classes and generated assignment operators
https://wg21.link/cwg2329




Daveed Vandevoorde
-
d:cwg233
CWG233
9 June 2000
open
References vs pointers in UDC overload resolution
https://wg21.link/cwg233




Matthias Meixner
-
d:cwg2330
CWG2330
6 December 2016
drafting
Missing references to variable templates
https://wg21.link/cwg2330




Daveed Vandevoorde
-
d:cwg2331
CWG2331
7 December 2016
drafting
Redundancy in description of class scope
https://wg21.link/cwg2331




Thomas Köppe
-
d:cwg2332
CWG2332
10 December 2016
drafting
template-name as simple-type-name vs injected-class-name
https://wg21.link/cwg2332




Daveed Vandevoorde
-
d:cwg2333
CWG2333
5 January 2017
drafting
Escape sequences in UTF-8 character literals
https://wg21.link/cwg2333




Mike Miller
-
d:cwg2334
CWG2334
20170130
open
Creation of objects by typeid
https://wg21.link/cwg2334




Chris Hallock
-
d:cwg2335
CWG2335
29 January 2017
open
Deduced return types vs member types
https://wg21.link/cwg2335




John Spicer
-
d:cwg2336
CWG2336
28 February 2017
drafting
Destructor characteristics vs potentially-constructed subobjects
https://wg21.link/cwg2336




Nathan Sidwell
-
d:cwg2337
CWG2337
2 March 2017
open
Incorrect implication of logic ladder for conversion sequence tiebreakers
https://wg21.link/cwg2337




Richard Smith
-
d:cwg2338
CWG2338
24 March 2017
DR
Undefined behavior converting to short enums with fixed underlying types
https://wg21.link/cwg2338




Thomas Köppe
-
d:cwg2339
CWG2339
29 March 2017
ready
Underspecified template arguments in structured bindings
https://wg21.link/cwg2339




Daveed Vandevoorde
-
d:cwg234
CWG234
28 June 2000
NAD
Reuse of base class subobjects
https://wg21.link/cwg234




Bill Wade
-
d:cwg2340
CWG2340
29 March 2017
open
Reference collapsing and structured bindings
https://wg21.link/cwg2340




Daveed Vandevoorde
-
d:cwg2341
CWG2341
4 April 2017
extension
Structured bindings with static storage duration
https://wg21.link/cwg2341




John Spicer
-
d:cwg2342
CWG2342
7 April 2017
DR
Reference reinterpret_cast and pointer-interconvertibility
https://wg21.link/cwg2342




Richard Smith
-
d:cwg2343
CWG2343
17 April 2017
extension
void* non-type template parameters
https://wg21.link/cwg2343




Daveed Vandevoorde
-
d:cwg2344
CWG2344
19 April 2017
drafting
Redeclaration of names in init-statements
https://wg21.link/cwg2344




John Spicer
-
d:cwg2345
CWG2345
25 April 2017
review
Jumping across initializers in init-statements and conditions
https://wg21.link/cwg2345




John Spicer
-
d:cwg2346
CWG2346
26 April 2017
DR
Local variables in default arguments
https://wg21.link/cwg2346




Geoffrey Romer
-
d:cwg2347
CWG2347
28 April 2017
open
Passing short scoped enumerations to ellipsis
https://wg21.link/cwg2347




Mike Miller
-
d:cwg2348
CWG2348
1 May 2017
NAD
Non-templated constexpr if
https://wg21.link/cwg2348




John Spicer
-
d:cwg2349
CWG2349
4 May 2017
NAD
Class/enumeration names vs conditions
https://wg21.link/cwg2349




Daveed Vandevoorde
-
d:cwg235
CWG235
16 September 2000
TC1
Assignment vs initialization
https://wg21.link/cwg235




Mike Miller
-
d:cwg2350
CWG2350
3 June 2017
open
Forwarding references and deduction guides
https://wg21.link/cwg2350




Barry Revzin
-
d:cwg2351
CWG2351
26 June 2017
tentatively ready
void{}
https://wg21.link/cwg2351




Peter Dimov
-
d:cwg2352
CWG2352
14 July 2017
drafting
Similar types and reference binding
https://wg21.link/cwg2352




Richard Smith
-
d:cwg2353
CWG2353
18 August 2017
drafting
Potential results of a member access expression for a static data member
https://wg21.link/cwg2353




Richard Smith
-
d:cwg2354
CWG2354
5 September 2017
open
Extended alignment and object representation
https://wg21.link/cwg2354




Mike Miller
-
d:cwg2355
CWG2355
6 September 2017
extension
Deducing noexcept-specifiers
https://wg21.link/cwg2355




John Spicer
-
d:cwg2356
CWG2356
26 February 2018
tentatively ready
Base class copy and move constructors should not be inherited
https://wg21.link/cwg2356




Richard Smith
-
d:cwg2357
CWG2357
7 September 2017
open
Lookup in member function declarations
https://wg21.link/cwg2357




John Spicer
-
d:cwg2358
CWG2358
20 September 2017
drafting
Explicit capture of value
https://wg21.link/cwg2358




Daveed Vandevoorde
-
d:cwg2359
CWG2359
6 October 2017
tentatively ready
Unintended copy initialization with designated initializers
https://wg21.link/cwg2359




Zhihao Yuan
-
d:cwg236
CWG236
19 July 2000
NAD
Explicit temporaries and integral constant expressions
https://wg21.link/cwg236




Mike Miller
-
d:cwg2360
CWG2360
19 October 2017
open
[[maybe_unused]] and structured bindings
https://wg21.link/cwg2360




Michael Wong
-
d:cwg2361
CWG2361
20 October 2017
open
Unclear description of longjmp undefined behavior
https://wg21.link/cwg2361




Zhihao Yuan
-
d:cwg2362
CWG2362
23 October 2017
open
__func__ should be constexpr
https://wg21.link/cwg2362




Anthony Polukhin
-
d:cwg2363
CWG2363
26 October 2017
open
Opaque enumeration friend declarations
https://wg21.link/cwg2363




Mike Miller
-
d:cwg2364
CWG2364
20171031
open
Constant expressions, aggregate initialization, and modifications
https://wg21.link/cwg2364




Mike Miller
-
d:cwg2365
CWG2365
8 February 2017
open
Confusing specification for dynamic_cast
https://wg21.link/cwg2365




Shiyao Ma
-
d:cwg2366
CWG2366
1 November 2017
tentatively ready
Can default initialization be constant initialization?
https://wg21.link/cwg2366




Geoffrey Romer
-
d:cwg2367
CWG2367
10 November 2017
open
Lambdas in default arguments vs the ODR
https://wg21.link/cwg2367




Richard Smith
-
d:cwg2368
CWG2368
11 November 2017
DR
Differences in relational and three-way constant comparisons
https://wg21.link/cwg2368




Richard Smith
-
d:cwg2369
CWG2369
9 October 2017
drafting
Ordering between constraints and substitution
https://wg21.link/cwg2369




Agustin Bergé
-
d:cwg237
CWG237
28 July 2000
CD1
Explicit instantiation and base class members
https://wg21.link/cwg237




Christophe de Dinechin
-
d:cwg2370
CWG2370
4 December 2017
drafting
friend declarations of namespace-scope functions
https://wg21.link/cwg2370




Andrew Marino
-
d:cwg2371
CWG2371
5 December 2017
open
Use of the English term “attributes” is confusing
https://wg21.link/cwg2371




Gabriel Dos Reis
-
d:cwg2372
CWG2372
17 December 2017
DR
Incorrect matching rules for block-scope extern declarations
https://wg21.link/cwg2372




Chen Fuxingi
-
d:cwg2373
CWG2373
14 February 2018
DRWP
Incorrect handling of static member function templates in partial ordering
https://wg21.link/cwg2373




Richard Smith
-
d:cwg2374
CWG2374
18 February 2018
review
Overly permissive specification of enum direct-list-initialization
https://wg21.link/cwg2374




Shafik Yaghmour
-
d:cwg2375
CWG2375
21 February 2018
NAD
Multiple redeclarations of constexpr static data members
https://wg21.link/cwg2375




Mike Miller
-
d:cwg2376
CWG2376
1 March 2018
tentatively ready
Class template argument deduction with array declarator
https://wg21.link/cwg2376




Mike Miller
-
d:cwg2377
CWG2377
5 June 2018
NAD
Explicit copy constructor vs function viability
https://wg21.link/cwg2377




Xiang Fan
-
d:cwg2378
CWG2378
14 June 2018
drafting
Inconsistent grammar for reference init-capture of pack
https://wg21.link/cwg2378




Barry Revzin
-
d:cwg2379
CWG2379
14 June 2018
DR
Missing prohibition against constexpr in friend declaration
https://wg21.link/cwg2379




Richard Smith
-
d:cwg238
CWG238
31 July 2000
CD4
Precision and accuracy constraints on floating point
https://wg21.link/cwg238




Christophe de Dinechin
-
d:cwg2380
CWG2380
14 June 2018
DR
capture-default makes too many references odr-usable
https://wg21.link/cwg2380




Richard Smith
-
d:cwg2381
CWG2381
19 June 2018
DR
Composite pointer type of pointers to plain and noexcept member functions
https://wg21.link/cwg2381




Mike Miller
-
d:cwg2382
CWG2382
16 July 2018
review
Array allocation overhead for non-allocating placement new
https://wg21.link/cwg2382




Paul Sanders
-
d:cwg2383
CWG2383
18 July 2018
NAD
Variadic member functions of variadic class templates
https://wg21.link/cwg2383




Daveed Vandevoorde
-
d:cwg2384
CWG2384
24 July 2018
DR
Conversion function templates and qualification conversions
https://wg21.link/cwg2384




John Spicer
-
d:cwg2385
CWG2385
20180731
DR
Lookup for conversion-function-ids
https://wg21.link/cwg2385




John Spicer
-
d:cwg2386
CWG2386
19 September 2018
DR
tuple_size requirements for structured binding
https://wg21.link/cwg2386




Stephan T. Lavavej
-
d:cwg2387
CWG2387
28 September 2018
DR
Linkage of const-qualified variable template
https://wg21.link/cwg2387




John Spicer
-
d:cwg2388
CWG2388
24 October 2018
NAD
Applicability of contract-attribute-specifiers
https://wg21.link/cwg2388




Aaron Ballman
-
d:cwg2389
CWG2389
24 October 2018
open
Agreement of deduced and explicitly-specified variable types
https://wg21.link/cwg2389




Nina Ranns
-
d:cwg239
CWG239
2 August 2000
CD1
Footnote 116 and Koenig lookup
https://wg21.link/cwg239




Steve Clamage
-
d:cwg2390
CWG2390
14 November 2018
tentatively ready
Is the argument of __has_cpp_attribute macro-expanded?
https://wg21.link/cwg2390




Richard Smith
-
d:cwg2392
CWG2392
5 December 2018
open
new-expression size check and constant evaluation
https://wg21.link/cwg2392




Tam S. B
-
d:cwg2393
CWG2393
7 November 2018
NAD
Pseudo-destructors and object lifetime
https://wg21.link/cwg2393




CWG
-
d:cwg2394
CWG2394
10 July 2018
DR
Const-default-constructible for members
https://wg21.link/cwg2394




Richard Smith
-
d:cwg2395
CWG2395
3 December 2018
open
Parameters following a pack expansion
https://wg21.link/cwg2395




Richard Smith
-
d:cwg2396
CWG2396
3 December 2018
open
Lookup of names in complex conversion-type-ids
https://wg21.link/cwg2396




Richard Smith
-
d:cwg2397
CWG2397
4 February 2019
drafting
auto specifier for pointers and references to arrays
https://wg21.link/cwg2397




Hubert Tong
-
d:cwg2398
CWG2398
3 December 2016
open
Template template parameter matching and deduction
https://wg21.link/cwg2398




Jason Merrill
-
d:cwg2399
CWG2399
13 February 2019
review
Unclear referent of “expression” in assignment-expression
https://wg21.link/cwg2399




Lisa Lippincott
-
d:cwg24
CWG24

TC1
Errors in examples in 14.7.3
https://wg21.link/cwg24




unknown
-
d:cwg240
CWG240
8 August 2000
CD3
Uninitialized values and undefined behavior
https://wg21.link/cwg240




Mike Miller
-
d:cwg2400
CWG2400
8 February 2019
tentatively ready
Constexpr virtual functions and temporary objects
https://wg21.link/cwg2400




Daveed Vandevoorde
-
d:cwg2401
CWG2401
6 February 2019
open
Array decay vs prohibition of subobject non-type arguments
https://wg21.link/cwg2401




John Spicer
-
d:cwg2402
CWG2402
8 January 2019
drafting
When is the restriction to a single c-char in a Unicode literal enforced?
https://wg21.link/cwg2402




Richard Smith
-
d:cwg2403
CWG2403
11 December 2018
open
Temporary materialization and base/member initialization
https://wg21.link/cwg2403




Daveed Vandevoorde
-
d:cwg2404
CWG2404
13 December 2018
tentatively ready
[[no_unique_address]] and allocation order
https://wg21.link/cwg2404




Daveed Vandevoorde
-
d:cwg2405
CWG2405
20 August 2018
drafting
Additional type-dependent expressions
https://wg21.link/cwg2405




Andrey Davydov
-
d:cwg2406
CWG2406
8 March 2019
tentatively ready
[[fallthrough]] attribute and iteration statements
https://wg21.link/cwg2406




Mike Miller
-
d:cwg2407
CWG2407
26 February 2019
review
Missing entry in Annex C for defaulted comparison operators
https://wg21.link/cwg2407




Tomasz Kaminski
-
d:cwg2408
CWG2408
13 March 2019
open
Temporaries and previously-initialized elements in aggregate initialization
https://wg21.link/cwg2408




Daveed Vandevoorde
-
d:cwg2409
CWG2409
29 April 2019
drafting
Explicit specializations of constexpr static data members
https://wg21.link/cwg2409




Mike Miller
-
d:cwg241
CWG241
9 August 2000
TC1
Error in example in 14.8.1
https://wg21.link/cwg241




Mike Miller
-
d:cwg2410
CWG2410
27 March 2019
review
Implicit calls of immediate functions
https://wg21.link/cwg2410




John Spicer
-
d:cwg2411
CWG2411
11 November 2017
open
Comparison of pointers to members in template non-type arguments
https://wg21.link/cwg2411




Jens Maurer
-
d:cwg2412
CWG2412
3 May 2019
open
SFINAE vs undeduced placeholder type
https://wg21.link/cwg2412




Mike Miller
-
d:cwg2413
CWG2413
10 May 2019
drafting
typename in conversion-function-ids
https://wg21.link/cwg2413




Davis Herring
-
d:cwg2414
CWG2414
20 May 2019
drafting
Unclear results if both member and friend operator<=> are declared
https://wg21.link/cwg2414




Daveed Vandevoorde
-
d:cwg2415
CWG2415
29 May 2019
NAD
using-declarations vs copy assignment operators
https://wg21.link/cwg2415




Mike Miller
-
d:cwg2416
CWG2416
7 June 2019
open
Explicit specializations vs constexpr and consteval
https://wg21.link/cwg2416




Mike Miller
-
d:cwg2417
CWG2417
19 June 2019
open
Explicit instantiation and exception specifications
https://wg21.link/cwg2417




John Spicer
-
d:cwg2418
CWG2418
25 November 2018
tentatively ready
Missing cases in definition of “usable in constant expressions”
https://wg21.link/cwg2418




Richard Smith
-
d:cwg2419
CWG2419
15 July 2019
open
Loss of generality treating pointers to objects as one-element arrays
https://wg21.link/cwg2419




Andrey Erokhin
-
d:cwg242
CWG242
30 August 2000
CD4
Interpretation of old-style casts
https://wg21.link/cwg242




Mike Miller
-
d:cwg243
CWG243
5 September 2000
NAD
Weighting of conversion functions in direct-initialization
https://wg21.link/cwg243




Steve Adamczyk
-
d:cwg244
CWG244
6 September 2000
CD1
Destructor lookup
https://wg21.link/cwg244




John Spicer
-
d:cwg245
CWG245
14 September 2000
CD1
Name lookup in elaborated-type-specifiers
https://wg21.link/cwg245




Jack Rouse
-
d:cwg246
CWG246
15 September 2000
CD1
Jumps in function-try-block handlers
https://wg21.link/cwg246




Mike Miller
-
d:cwg247
CWG247
22 September 2000
NAD
Pointer-to-member casts and function overload resolution
https://wg21.link/cwg247




Martin Sebor
-
d:cwg248
CWG248
6 October 2000
C++11
Identifier characters
https://wg21.link/cwg248




John Spicer
-
d:cwg249
CWG249
11 October 2000
TC1
What is a member function template?
https://wg21.link/cwg249




David Thornley
-
d:cwg25
CWG25

TC1
Exception specifications and pointers to members
https://wg21.link/cwg25




unknown
-
d:cwg250
CWG250
10 October 2000
TC1
Address of function template specialization with non-deduced template arguments
https://wg21.link/cwg250




Nikolas Kauer
-
d:cwg251
CWG251
18 October 2000
open
How many signed integer types are there?
https://wg21.link/cwg251




Beman Dawes
-
d:cwg252
CWG252
19 October 2000
CD1
Looking up deallocation functions in virtual destructors
https://wg21.link/cwg252




Steve Clamage
-
d:cwg253
CWG253
11 July 2000
C++17
Why must empty or fully-initialized const objects be initialized?
https://wg21.link/cwg253




Mike Miller
-
d:cwg254
CWG254
26 October 2000
CD1
Definitional problems with elaborated-type-specifiers
https://wg21.link/cwg254




Clark Nelson
-
d:cwg255
CWG255
26 October 2000
drafting
Placement deallocation functions and lookup ambiguity
https://wg21.link/cwg255




Mike Miller
-
d:cwg256
CWG256
15 October 2000
CD1
Overflow in size calculations
https://wg21.link/cwg256




James Kanze
-
d:cwg257
CWG257
1 November 2000
CD2
Abstract base constructors and virtual base initialization
https://wg21.link/cwg257




Mike Miller
-
d:cwg258
CWG258
2 November 2000
CD1
using-declarations and cv-qualifiers
https://wg21.link/cwg258




Liam Fitzpatrick
-
d:cwg259
CWG259
2 November 2000
CD1
Restrictions on explicit specialization and instantiation
https://wg21.link/cwg259




Matt Austern
-
d:cwg26
CWG26
22 September 1997
NAD
Copy constructors and default arguments
https://wg21.link/cwg26




Daveed Vandevoorde
-
d:cwg260
CWG260
4 November 2000
open
User-defined conversions and built-in operator=
https://wg21.link/cwg260




Scott Douglas
-
d:cwg261
CWG261
7 November 2000
CD1
When is a deallocation function "used?"
https://wg21.link/cwg261




Mike Miller
-
d:cwg262
CWG262
13 November 2000
CD1
Default arguments and ellipsis
https://wg21.link/cwg262




Jamie Schmeiser
-
d:cwg263
CWG263
13 November 2000
CD1
Can a constructor be declared a friend?
https://wg21.link/cwg263




Martin Sebor
-
d:cwg264
CWG264
17 November 2000
open
Unusable template constructors and conversion functions
https://wg21.link/cwg264




John Spicer
-
d:cwg265
CWG265
21 November 2000
dup
Destructors, exceptions, and deallocation
https://wg21.link/cwg265




Mike Miller
-
d:cwg266
CWG266
2 December 2000
NAD
No grammar sentence symbol
https://wg21.link/cwg266




Hans Aberg
-
d:cwg267
CWG267
4 December 2000
open
Alignment requirement for new-expressions
https://wg21.link/cwg267




James Kuyper
-
d:cwg268
CWG268
18 January 2001
open
Macro name suppression in rescanned replacement text
https://wg21.link/cwg268




Bjarne Stroustrup
-
d:cwg269
CWG269
8 February 2001
NAD
Order of initialization of multiply-defined static data members of class templates
https://wg21.link/cwg269




Andrei Iltchenko
-
d:cwg27
CWG27
25 September 1997
NAD
Overload ambiguities for builtin ?: prototypes
https://wg21.link/cwg27




Jason Merrill
-
d:cwg270
CWG270
9 February 2001
CD1
Order of initialization of static data members of class templates
https://wg21.link/cwg270




Jonathan H. Lundquist
-
d:cwg271
CWG271
20 February 2001
open
Explicit instantiation and template argument deduction
https://wg21.link/cwg271




John Spicer
-
d:cwg272
CWG272
22 February 2001
CD1
Explicit destructor invocation and qualified-ids
https://wg21.link/cwg272




Mike Miller
-
d:cwg273
CWG273
10 March 2001
CD1
POD classes and operator&()
https://wg21.link/cwg273




Andrei Iltchenko
-
d:cwg274
CWG274
14 March 2001
CD1
Cv-qualification and char-alias access to out-of-lifetime objects
https://wg21.link/cwg274




Mike Miller
-
d:cwg275
CWG275
15 February 2001
CD1
Explicit instantiation/specialization and using-directives
https://wg21.link/cwg275




John Spicer
-
d:cwg276
CWG276
28 March 2001
CD1
Order of destruction of parameters and temporaries
https://wg21.link/cwg276




James Kanze
-
d:cwg277
CWG277
5 April 2001
CD1
Zero-initialization of pointers
https://wg21.link/cwg277




Andrew Sawyer
-
d:cwg278
CWG278
12 April 2000
open
External linkage and nameless entities
https://wg21.link/cwg278




Daveed Vandevoorde
-
d:cwg279
CWG279
4 April 2001
open
Correspondence of "names for linkage purposes"
https://wg21.link/cwg279




Daveed Vandevoorde
-
d:cwg28
CWG28
19 October 1997
CD1
'exit', 'signal' and static object destruction
https://wg21.link/cwg28




Martin J. O'Riordan
-
d:cwg280
CWG280
16 April 2001
CD1
Access and surrogate call functions
https://wg21.link/cwg280




Andrei Iltchenko
-
d:cwg281
CWG281
24 April 2001
CD1
inline specifier in friend declarations
https://wg21.link/cwg281




John Spicer
-
d:cwg282
CWG282
1 May 2001
open
Namespace for extended_type_info
https://wg21.link/cwg282




Jens Maurer
-
d:cwg283
CWG283
1 May 2001
CD1
Template type-parameters are not syntactically type-names
https://wg21.link/cwg283




Clark Nelson
-
d:cwg284
CWG284
1 May 2001
CD1
qualified-ids in class declarations
https://wg21.link/cwg284




Mike Miller
-
d:cwg285
CWG285
1 May 2001
NAD
Identifying a function template being specialized
https://wg21.link/cwg285




Erwin Unruh
-
d:cwg286
CWG286
9 May 2001
CD1
Incorrect example in partial specialization
https://wg21.link/cwg286




Martin Sebor
-
d:cwg287
CWG287
17 May 2001
drafting
Order dependencies in template instantiation
https://wg21.link/cwg287




Martin Sebor
-
d:cwg288
CWG288
19 May 2001
CD1
Misuse of "static type" in describing pointers
https://wg21.link/cwg288




James Kuyper
-
d:cwg289
CWG289
25 May 2001
CD1
Incomplete list of contexts requiring a complete type
https://wg21.link/cwg289




Mike Miller
-
d:cwg29
CWG29
19 March 1998
CD1
Linkage of locally declared functions
https://wg21.link/cwg29




Mike Ball
-
d:cwg290
CWG290
12 June 2001
NAD
Should memcpy be allowed into a POD with a const member?
https://wg21.link/cwg290




Garry Lancaster
-
d:cwg291
CWG291
15 June 2001
CD1
Overload resolution needed when binding reference to class rvalue
https://wg21.link/cwg291




Andrei Iltchenko
-
d:cwg292
CWG292
26 June 2001
CD3
Deallocation on exception in new before arguments evaluated
https://wg21.link/cwg292




Andrei Iltchenko
-
d:cwg293
CWG293
27 June 2001
open
Syntax of explicit instantiation/specialization too permissive
https://wg21.link/cwg293




Mark Mitchell
-
d:cwg294
CWG294
27 June 2001
NAD
Can static_cast drop exception specifications?
https://wg21.link/cwg294




Steve Adamczyk
-
d:cwg295
CWG295
29 June 2001
CD1
cv-qualifiers on function types
https://wg21.link/cwg295




Nathan Sidwell
-
d:cwg296
CWG296
5 July 2001
CD1
Can conversion functions be static?
https://wg21.link/cwg296




Scott Meyers
-
d:cwg297
CWG297
7 July 2001
open
Which template does an explicit specialization specialize?
https://wg21.link/cwg297




Andrei Iltchenko
-
d:cwg298
CWG298
7 July 2001
CD1
T::x when T is cv-qualified
https://wg21.link/cwg298




Steve Adamczyk
-
d:cwg299
CWG299
19 July 2001
CD1
Conversion on array bound expression in new
https://wg21.link/cwg299




Mark Mitchell
-
d:cwg3
CWG3

NAD
The template compilation model rules render some explicit specialization declarations not visible during instantiation
https://wg21.link/cwg3




Bill Gibbons
-
d:cwg30
CWG30
28 May 1998
TC1
Valid uses of "::template"
https://wg21.link/cwg30




Daveed Vandevoorde
-
d:cwg300
CWG300
11 July 2001
CD1
References to functions in template argument deduction
https://wg21.link/cwg300




Andrei Iltchenko
-
d:cwg301
CWG301
24 July 2001
CD1
Syntax for template-name
https://wg21.link/cwg301




Mark Mitchell
-
d:cwg302
CWG302
23 July 2001
CD1
Value-initialization and generation of default constructor
https://wg21.link/cwg302




Steve Adamczyk
-
d:cwg303
CWG303
24 July 2001
NAD
Integral promotions on bit-fields
https://wg21.link/cwg303




Kiril Avdeiv
-
d:cwg304
CWG304
25 July 2001
TC1
Value-initialization of a reference
https://wg21.link/cwg304




Steve Adamczyk
-
d:cwg305
CWG305
19 May 2001
CD1
Name lookup in destructor call
https://wg21.link/cwg305




Mark Mitchell
-
d:cwg306
CWG306
19 July 2001
CD1
Ambiguity by class name injection
https://wg21.link/cwg306




Clark Nelson
-
d:cwg307
CWG307
31 August 2001
NAD
Initialization of a virtual base class subobject
https://wg21.link/cwg307




Andrei Iltchenko
-
d:cwg308
CWG308
4 September 2001
NAD
Catching exceptions with ambiguous base classes
https://wg21.link/cwg308




Sergey P. Derevyago
-
d:cwg309
CWG309
17 September 2001
CD1
Linkage of entities whose names are not simply identifiers, in introduction
https://wg21.link/cwg309




Mike Miller
-
d:cwg31
CWG31
23 June 1998
NAD
Looking up new/delete
https://wg21.link/cwg31




Daveed Vandevoorde
-
d:cwg310
CWG310
29 August 2001
open
Can function templates differing only in parameter cv-qualifiers be overloaded?
https://wg21.link/cwg310




Andrei Iltchenko
-
d:cwg311
CWG311
18 September 2001
NAD
Using qualified name to reopen nested namespace
https://wg21.link/cwg311




Bjarne Stroustrup
-
d:cwg312
CWG312
20 September 2001
CD3
“use” of invalid pointer value not defined
https://wg21.link/cwg312




Martin von Loewis
-
d:cwg313
CWG313
22 October 2001
dup
Class with single conversion function to integral as array size in new
https://wg21.link/cwg313




Bill Gibbons
-
d:cwg314
CWG314
23 August 2001
C++17
template in base class specifier
https://wg21.link/cwg314




Mark Mitchell
-
d:cwg315
CWG315
7 October 2001
NAD
Is call of static member function through null pointer undefined?
https://wg21.link/cwg315




Jason Merrill
-
d:cwg316
CWG316
14 October 2001
NAD
Injected-class-name of template used as template template parameter
https://wg21.link/cwg316




Jason Merrill
-
d:cwg317
CWG317
14 October 2001
CD1
Can a function be declared inline after it has been called?
https://wg21.link/cwg317




Steve Clamage
-
d:cwg318
CWG318
18 October 2001
CD1
struct A::A should not name the constructor of A
https://wg21.link/cwg318




John Spicer
-
d:cwg319
CWG319
29 October 2001
CD1
Use of names without linkage in declaring entities with linkage
https://wg21.link/cwg319




Clark Nelson
-
d:cwg32
CWG32
10 July 1998
TC1
Clarification of explicit instantiation of non-exported templates
https://wg21.link/cwg32




Daveed Vandevoorde
-
d:cwg320
CWG320
2 November 2001
CD1
Question on copy constructor elision example
https://wg21.link/cwg320




Steve Clamage
-
d:cwg321
CWG321
12 November 2001
dup
Associated classes and namespaces for argument-dependent lookup
https://wg21.link/cwg321




Andrei Iltchenko
-
d:cwg322
CWG322
14 November 2001
CD1
Deduction of reference conversions
https://wg21.link/cwg322




Jason Merrill
-
d:cwg323
CWG323
14 November 2001
CD1
Where must export appear?
https://wg21.link/cwg323




Daveed Vandevoorde
-
d:cwg324
CWG324
27 November 2001
CD1
Can "&" be applied to assignment to bit-field?
https://wg21.link/cwg324




Alasdair Grant
-
d:cwg325
CWG325
27 November 2001
drafting
When are default arguments parsed?
https://wg21.link/cwg325




Nathan Sidwell
-
d:cwg326
CWG326
9 December 2001
CD1
Wording for definition of trivial constructor
https://wg21.link/cwg326




James Kanze
-
d:cwg327
CWG327
9 December 2001
CD1
Use of "structure" without definition
https://wg21.link/cwg327




James Kanze
-
d:cwg328
CWG328
10 December 2001
CD1
Missing requirement that class member types be complete
https://wg21.link/cwg328




Michiel Salters
-
d:cwg329
CWG329
19 December 2001
CD1
Evaluation of friends of templates
https://wg21.link/cwg329




John Spicer
-
d:cwg33
CWG33
15 July 1998
TC1
Argument dependent lookup and overloaded functions
https://wg21.link/cwg33




Jason Merrill
-
d:cwg330
CWG330
2 January 2002
CD4
Qualification conversions and pointers to arrays of pointers
https://wg21.link/cwg330




Roger Orr
-
d:cwg331
CWG331
8 January 2002
CD1
Allowed copy constructor signatures
https://wg21.link/cwg331




Richard Smith
-
d:cwg332
CWG332
9 January 2002
CD3
cv-qualified void parameter types
https://wg21.link/cwg332




Michiel Salters
-
d:cwg333
CWG333
14 January 2002
NAD
Ambiguous use of "declaration" in disambiguation section
https://wg21.link/cwg333




Michiel Salters
-
d:cwg334
CWG334
10 January 2002
NAD
Is a comma-expression dependent if its first operand is?
https://wg21.link/cwg334




John Spicer
-
d:cwg335
CWG335
30 January 2002
CD1
Allowing export on template members of nontemplate classes
https://wg21.link/cwg335




John Spicer
-
d:cwg336
CWG336
29 January 2002
CD1
Explicit specialization examples are still incorrect
https://wg21.link/cwg336




Jason Shirk
-
d:cwg337
CWG337
30 January 2002
CD1
Attempt to create array of abtract type should cause deduction to fail
https://wg21.link/cwg337




John Spicer
-
d:cwg338
CWG338
26 February 2002
open
Enumerator name with linkage used as class name in other translation unit
https://wg21.link/cwg338




Daveed Vandevoorde
-
d:cwg339
CWG339
11 March 2002
CD1
Overload resolution in operand of sizeof in constant expression
https://wg21.link/cwg339




Steve Adamczyk
-
d:cwg34
CWG34
15 July 1998
NAD
Argument dependent lookup and points of instantiation
https://wg21.link/cwg34




Daveed Vandevoorde
-
d:cwg340
CWG340
27 February 2002
NAD
Unclear wording in disambiguation section
https://wg21.link/cwg340




Bart v Ingen Schenau
-
d:cwg341
CWG341
1 March 2002
C++11
extern "C" namespace member function versus global variable
https://wg21.link/cwg341




Steve Adamczyk
-
d:cwg342
CWG342
7 October 2001
CD3
Terminology: "indirection" versus "dereference"
https://wg21.link/cwg342




Jason Merrill
-
d:cwg343
CWG343
23 April 2002
C++17
Make template optional in contexts that require a type
https://wg21.link/cwg343




Steve Adamczyk
-
d:cwg344
CWG344
25 April 2002
CD3
Naming destructors
https://wg21.link/cwg344




Jamie Schmeiser
-
d:cwg345
CWG345
18 March 2002
CD1
Misleading comment on example in templates chapter
https://wg21.link/cwg345




Jason Shirk
-
d:cwg346
CWG346
18 March 2002
NAD
Typo in 15.4
https://wg21.link/cwg346




Lois Goldthwaite
-
d:cwg347
CWG347
21 March 2002
NAD
Use of derived class name in defining base class nested class
https://wg21.link/cwg347




Jason Shirk
-
d:cwg348
CWG348
1 April 2002
CD1
delete and user-written deallocation functions
https://wg21.link/cwg348




Ruslan Abdikeev
-
d:cwg349
CWG349
16 April 2002
CD1
Template argument deduction for conversion functions and qualification conversions
https://wg21.link/cwg349




John Spicer
-
d:cwg35
CWG35
29 July 1998
TC1
Definition of default-initialization
https://wg21.link/cwg35




Andrew Koenig
-
d:cwg350
CWG350
16 April 2002
open
signed char underlying representation for objects
https://wg21.link/cwg350




Noah Stein
-
d:cwg351
CWG351
23 April 2002
CD1
Sequence point error: unspecified or undefined?
https://wg21.link/cwg351




Andrew Koenig
-
d:cwg352
CWG352
24 April 2002
CD1
Nondeduced contexts
https://wg21.link/cwg352




Andrei Iltchenko
-
d:cwg353
CWG353
30 April 2002
CD1
Is deallocation routine called if destructor throws exception in delete?
https://wg21.link/cwg353




Duane Smith
-
d:cwg354
CWG354
2 May 2002
CD1
Null as nontype template argument
https://wg21.link/cwg354




John Spicer
-
d:cwg355
CWG355
16 May 2002
C++11
Global-scope :: in nested-name-specifier
https://wg21.link/cwg355




Clark Nelson
-
d:cwg356
CWG356
25 May 2002
NAD
Wording of behavior of generated copy constructor for scalar members
https://wg21.link/cwg356




Steve Clamage
-
d:cwg357
CWG357
26 May 2002
CD1
Definition of signature should include name
https://wg21.link/cwg357




Steve Clamage
-
d:cwg358
CWG358
28 May 2002
NAD
Namespaces and extern "C"
https://wg21.link/cwg358




Steve Clamage
-
d:cwg359
CWG359
31 May 2002
NAD
Type definition in anonymous union
https://wg21.link/cwg359




Al Grant
-
d:cwg36
CWG36
20 August 1998
open
using-declarations in multiple-declaration contexts
https://wg21.link/cwg36




Andrew Koenig
-
d:cwg360
CWG360
4 June 2002
open
Using-declaration that reduces access
https://wg21.link/cwg360




Steve Clamage
-
d:cwg361
CWG361
17 June 2002
open
Forward reference to default argument
https://wg21.link/cwg361




Steve Clamage
-
d:cwg362
CWG362
2 July 2002
CD1
Order of initialization in instantiation units
https://wg21.link/cwg362




Mark Mitchell
-
d:cwg363
CWG363
11 July 2002
NAD
Initialization of class from self
https://wg21.link/cwg363




Sergey P. Derevyago
-
d:cwg364
CWG364
23 July 2002
CD1
Calling overloaded function with static in set, with no object
https://wg21.link/cwg364




Steve Adamczyk
-
d:cwg365
CWG365
24 July 2002
open
Storage duration and temporaries
https://wg21.link/cwg365




James Kanze
-
d:cwg366
CWG366
29 July 2002
CD1
String literal allowed in integral constant expression?
https://wg21.link/cwg366




Martin v. Loewis
-
d:cwg367
CWG367
29 July 2002
CD1
throw operator allowed in constant expression?
https://wg21.link/cwg367




Martin v. Loewis
-
d:cwg368
CWG368
29 July 2002
CD1
Uses of non-type parameters that should cause deduction to fail
https://wg21.link/cwg368




Jason Shirk
-
d:cwg369
CWG369
30 July 2002
drafting
Are new/delete identifiers or preprocessing-op-or-punc?
https://wg21.link/cwg369




Martin v. Loewis
-
d:cwg37
CWG37
10 August 1998
NAD
When is uncaught_exception() true?
https://wg21.link/cwg37




Daveed Vandevoorde
-
d:cwg370
CWG370
1 August 2002
CD1
Can #include <...> form be used other than for standard C++ headers?
https://wg21.link/cwg370




Beman Dawes
-
d:cwg371
CWG371
7 August 2002
open
Interleaving of constructor calls
https://wg21.link/cwg371




Matt Austern
-
d:cwg372
CWG372
13 August 2002
CD1
Is access granted by base class specifiers available in following base class specifiers?
https://wg21.link/cwg372




Clark Nelson
-
d:cwg373
CWG373
15 August 2002
C++11
Lookup on namespace qualified name in using-directive
https://wg21.link/cwg373




Clark Nelson
-
d:cwg374
CWG374
23 August 2002
CD2
Can explicit specialization outside namespace use qualified name?
https://wg21.link/cwg374




Steve Adamczyk
-
d:cwg375
CWG375
23 August 2002
dup
Confusing example on lookup with typename
https://wg21.link/cwg375




Manish Pagey
-
d:cwg376
CWG376
28 August 2002
NAD
Class "definition" versus class "declaration"
https://wg21.link/cwg376




Randy Maddox
-
d:cwg377
CWG377
30 August 2002
CD1
Enum whose enumerators will not fit in any integral type
https://wg21.link/cwg377




Mark Mitchell
-
d:cwg378
CWG378
7 September 2002
CD1
Wording that says temporaries are declared
https://wg21.link/cwg378




Gennaro Prota
-
d:cwg379
CWG379
21 October 2002
CD1
Change "class declaration" to "class definition"
https://wg21.link/cwg379




Jens Maurer
-
d:cwg38
CWG38
17 August 1998
TC1
Explicit template arguments and operator functions
https://wg21.link/cwg38




John Wiegley
-
d:cwg380
CWG380
22 October 2002
open
Definition of "ambiguous base class" missing
https://wg21.link/cwg380




Jason Merrill
-
d:cwg381
CWG381
8 November 2002
CD1
Incorrect example of base class member lookup
https://wg21.link/cwg381




Steve Adamczyk
-
d:cwg382
CWG382
8 November 2002
CD1
Allow typename outside of templates
https://wg21.link/cwg382




Steve Adamczyk
-
d:cwg383
CWG383
18 September 2002
CD1
Is a class with a declared but not defined destructor a POD?
https://wg21.link/cwg383




Gennaro Prota
-
d:cwg384
CWG384
18 September 2002
NAD
Argument-dependent lookup and operator functions
https://wg21.link/cwg384




Herb Sutter
-
d:cwg385
CWG385
24 September 2002
CD1
How does protected member check of 11.5 interact with using-declarations?
https://wg21.link/cwg385




Vincent Korstanje
-
d:cwg386
CWG386
8 October 2002
drafting
Friend declaration of name brought in by using-declaration
https://wg21.link/cwg386




Herb Sutter
-
d:cwg387
CWG387
27 October 2002
CD1
Errors in example in 14.6.5
https://wg21.link/cwg387




Aleksey Gurtovoy
-
d:cwg388
CWG388
28 October 2002
CD3
Catching base*& from a throw of derived*
https://wg21.link/cwg388




John Spicer
-
d:cwg389
CWG389
31 October 2002
CD1
Unnamed types in entities with linkage
https://wg21.link/cwg389




Daveed Vandevoorde
-
d:cwg39
CWG39
20 August 1998
CD1
Conflicting ambiguity rules
https://wg21.link/cwg39




Neal M Gafter
-
d:cwg390
CWG390
14 November 2002
CD1
Pure virtual must be defined when implicitly called
https://wg21.link/cwg390




Daniel Frey
-
d:cwg391
CWG391
14 November 2002
CD1
Require direct binding of short-lived references to rvalues
https://wg21.link/cwg391




Raoul Gough
-
d:cwg392
CWG392
21 November 2002
CD1
Use of full expression lvalue before temporary destruction
https://wg21.link/cwg392




Stephen Clamage
-
d:cwg393
CWG393
12 December 2002
CD4
Pointer to array of unknown bound in template argument list in parameter
https://wg21.link/cwg393




Mark Mitchell
-
d:cwg394
CWG394
16 December 2002
CD1
identifier-list is never defined
https://wg21.link/cwg394




Nicola Musatti
-
d:cwg395
CWG395
18 December 2002
NAD
Conversion operator template syntax
https://wg21.link/cwg395




Daveed Vandevoorde
-
d:cwg396
CWG396
3 January 2003
CD1
Misleading note regarding use of auto for disambiguation
https://wg21.link/cwg396




Herb Sutter
-
d:cwg397
CWG397
13 January 2003
CD1
Same address for string literals from default arguments in inline functions?
https://wg21.link/cwg397




Mark Mitchell
-
d:cwg398
CWG398
16 January 2003
CD1
Ambiguous wording on naming a type in deduction
https://wg21.link/cwg398




Daveed Vandevoorde
-
d:cwg399
CWG399
17 January 2003
drafting
Destructor lookup redux
https://wg21.link/cwg399




John Spicer
-
d:cwg4
CWG4

CD1
Does extern "C" affect the linkage of function names with internal linkage?
https://wg21.link/cwg4




Mike Anderson
-
d:cwg40
CWG40
1 September 1998
TC1
Syntax of declarator-id
https://wg21.link/cwg40




Mike Miller
-
d:cwg400
CWG400
22 January 2003
CD1
Using-declarations and the "struct hack"
https://wg21.link/cwg400




Mark Mitchell
-
d:cwg401
CWG401
27 January 2003
CD1
When is access for template parameter default arguments checked?
https://wg21.link/cwg401




Steve Adamczyk
-
d:cwg402
CWG402
7 April 2003
open
More on partial ordering of function templates
https://wg21.link/cwg402




Nathan Sidwell
-
d:cwg403
CWG403
18 September 2003
CD1
Reference to a type as a template-id
https://wg21.link/cwg403




John Spicer
-
d:cwg404
CWG404
8 April 2003
CD1
Unclear reference to construction with non-trivial constructor
https://wg21.link/cwg404




Mike Miller
-
d:cwg405
CWG405
14 April 2003
open
Unqualified function name lookup
https://wg21.link/cwg405




William M. Miller
-
d:cwg406
CWG406
12 March 2003
CD1
Static data member in class with name for linkage purposes
https://wg21.link/cwg406




Jorgen Bundgaard
-
d:cwg407
CWG407
31 March 2003
C++11
Named class with associated typedef: two names or one?
https://wg21.link/cwg407




Clark Nelson
-
d:cwg408
CWG408
14 April 2003
CD2
sizeof applied to unknown-bound array static data member of template
https://wg21.link/cwg408




Nathan Myers
-
d:cwg409
CWG409
18 April 2003
CD1
Obsolete paragraph missed by changes for issue 224
https://wg21.link/cwg409




John Spicer
-
d:cwg41
CWG41
1 September 1998
TC1
Clarification of lookup of names after declarator-id
https://wg21.link/cwg41




Mike Miller
-
d:cwg410
CWG410
18 April 2003
CD1
Paragraph missed in changes for issue 166
https://wg21.link/cwg410




John Spicer
-
d:cwg411
CWG411
23 April 2003
open
Use of universal-character-name in character versus string literals
https://wg21.link/cwg411




James Kanze
-
d:cwg412
CWG412
23 April 2003
NAD
Can a replacement allocation function be inline?
https://wg21.link/cwg412




Matt Austern
-
d:cwg413
CWG413
30 April 2003
CD1
Definition of "empty class"
https://wg21.link/cwg413




Pete Becker
-
d:cwg414
CWG414
1 May 2003
CD1
Multiple types found on destructor lookup
https://wg21.link/cwg414




John Spicer
-
d:cwg415
CWG415
4 May 2003
CD1
Template deduction does not cause instantiation
https://wg21.link/cwg415




John Spicer
-
d:cwg416
CWG416
22 May 2003
CD1
Class must be complete to allow operator lookup?
https://wg21.link/cwg416




Greg Comeau
-
d:cwg417
CWG417
19 May 2003
CD1
Using derived-class qualified name in out-of-class nested class definition
https://wg21.link/cwg417




Jon Caves
-
d:cwg418
CWG418
27 May 2003
open
Imperfect wording on error on multiple default arguments on a called function
https://wg21.link/cwg418




Chris Bowler
-
d:cwg419
CWG419
2 June 2003
open
Can cast to virtual base class be done on partially-constructed object?
https://wg21.link/cwg419




Judy Ward
-
d:cwg42
CWG42
15 September 1998
NAD
Redefining names from base classes
https://wg21.link/cwg42




Steve Clamage
-
d:cwg420
CWG420
8 June 2003
CD1
postfixexpression->scalar_type_dtor() inconsistent
https://wg21.link/cwg420




Markus Mauhart
-
d:cwg421
CWG421
15 June 2003
CD1
Is rvalue.field an rvalue?
https://wg21.link/cwg421




Gabriel Dos Reis
-
d:cwg422
CWG422
18 June 2003
NAD
Is a typedef redeclaration allowed with a template type that might be the same?
https://wg21.link/cwg422




Steve Adamczyk
-
d:cwg423
CWG423
19 June 2003
NAD
Can a conversion be done on the left operand of a compound assignment?
https://wg21.link/cwg423




Gennaro Prota
-
d:cwg424
CWG424
25 June 2003
CD1
Wording problem with issue 56 resolution on redeclaring typedefs in class scope
https://wg21.link/cwg424




Daveed Vandevoorde
-
d:cwg425
CWG425
30 June 2003
CD1
Set of candidates for overloaded built-in operator with float operand
https://wg21.link/cwg425




Daniel Frey
-
d:cwg426
CWG426
2 July 2003
C++17
Identically-named variables, one internally and one externally linked, allowed?
https://wg21.link/cwg426




Steve Adamczyk
-
d:cwg427
CWG427
5 July 2003
CD1
static_cast ambiguity: conversion versus cast to derived
https://wg21.link/cwg427




Mark Mitchell
-
d:cwg428
CWG428
14 July 2003
CD1
Mention of expression with reference type
https://wg21.link/cwg428




Steve Adamczyk
-
d:cwg429
CWG429
18 July 2003
CD1
Matching deallocation function chosen based on syntax or signature?
https://wg21.link/cwg429




John Wilkinson
-
d:cwg43
CWG43
15 September 1998
TC1
Copying base classes (PODs) using memcpy
https://wg21.link/cwg43




Nathan Myers
-
d:cwg430
CWG430
23 July 2003
CD1
Ordering of expression evaluation in initializer list
https://wg21.link/cwg430




Nathan Sidwell
-
d:cwg431
CWG431
10 August 2003
C++11
Defect in wording in 14.2
https://wg21.link/cwg431




Mat Marcus
-
d:cwg432
CWG432
29 August 2003
CD1
Is injected class name visible in base class specifier list?
https://wg21.link/cwg432




Daveed Vandevoorde
-
d:cwg433
CWG433
2 September 2003
CD1
Do elaborated type specifiers in templates inject into enclosing namespace scope?
https://wg21.link/cwg433




Daveed Vandevoorde
-
d:cwg434
CWG434
14 September 2003
NAD
Unclear suppression of standard conversions while binding reference to lvalue
https://wg21.link/cwg434




Bronek Kozicki
-
d:cwg435
CWG435
27 October 2003
NAD
Change "declararation or definition" to "declaration"
https://wg21.link/cwg435




Jens Maurer
-
d:cwg436
CWG436
10 October 2003
CD1
Problem in example in 9.6 paragraph 4
https://wg21.link/cwg436




Roberto Santos
-
d:cwg437
CWG437
10 October 2003
CD1
Is type of class allowed in member function exception specification?
https://wg21.link/cwg437




Cary Coutant
-
d:cwg438
CWG438
29 October 2003
CD2
Possible flaw in wording for multiple accesses to object between sequence points
https://wg21.link/cwg438




Jason Merrill
-
d:cwg439
CWG439
30 October 2003
CD1
Guarantees on casting pointer back to cv-qualified version of original type
https://wg21.link/cwg439




Mark Mitchell
-
d:cwg44
CWG44
19 September 1998
CD1
Member specializations
https://wg21.link/cwg44




Nathan Myers
-
d:cwg440
CWG440
13 November 2003
open
Allow implicit pointer-to-member conversion on nontype template argument
https://wg21.link/cwg440




David Abrahams
-
d:cwg441
CWG441
1 December 2003
CD1
Ordering of static reference initialization
https://wg21.link/cwg441




Mike Miller
-
d:cwg442
CWG442
2 December 2003
CD1
Incorrect use of null pointer constant in description of delete operator
https://wg21.link/cwg442




Matthias Hofmann
-
d:cwg443
CWG443
2 December 2003
CD1
Wording nit in description of lifetime of temporaries
https://wg21.link/cwg443




Matthias Hofmann
-
d:cwg444
CWG444
26 November 2003
NAD
Overriding and the generated copy assignment operator
https://wg21.link/cwg444




Kerch Holt
-
d:cwg445
CWG445
5 December 2003
NAD
Wording issue on friend declarations
https://wg21.link/cwg445




Risto Lankinen
-
d:cwg446
CWG446
31 December 2003
CD1
Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?
https://wg21.link/cwg446




John Potter
-
d:cwg447
CWG447
7 January 2004
CD1
Is offsetof type-dependent?
https://wg21.link/cwg447




Mark Mitchell
-
d:cwg448
CWG448
4 January 2004
C++11
Set of template functions in call with dependent explicit argument
https://wg21.link/cwg448




Mark Mitchell
-
d:cwg449
CWG449
14 January 2004
NAD
Consistency in use of hyphen with names of "non" entities
https://wg21.link/cwg449




Daveed Vandevoorde
-
d:cwg45
CWG45
29 September 1998
CD1
Access to nested classes
https://wg21.link/cwg45




Daveed Vandevoorde
-
d:cwg450
CWG450
16 January 2004
CD1
Binding a reference to const to a cv-qualified array rvalue
https://wg21.link/cwg450




Steve Adamczyk
-
d:cwg451
CWG451
19 January 2004
CD1
Expressions with invalid results and ill-formedness
https://wg21.link/cwg451




Gennaro Prota
-
d:cwg452
CWG452
8 January 2004
CD1
Wording nit on description of this
https://wg21.link/cwg452




Gennaro Prota
-
d:cwg453
CWG453
18 January 2004
drafting
References may only bind to “valid” objects
https://wg21.link/cwg453




Gennaro Prota
-
d:cwg454
CWG454
18 January 2004
CD1
When is a definition of a static data member required?
https://wg21.link/cwg454




Gennaro Prota
-
d:cwg455
CWG455
19 January 2004
drafting
Partial ordering and non-deduced arguments
https://wg21.link/cwg455




Rani Sharoni
-
d:cwg456
CWG456
31 January 2004
NAD
Is initialized const int or const bool variable a null pointer constant?
https://wg21.link/cwg456




Lloyd Lewins
-
d:cwg457
CWG457
3 February 2004
CD1
Wording nit on use of const variables in constant expressions
https://wg21.link/cwg457




Mark Mitchell
-
d:cwg458
CWG458
2 February 2004
C++11
Hiding of member template parameters by other members
https://wg21.link/cwg458




Gabriel Dos Reis
-
d:cwg459
CWG459
2 February 2004
open
Hiding of template parameters by base class members
https://wg21.link/cwg459




Daveed Vandevoorde
-
d:cwg46
CWG46
28 January 1998
NAD
Explicit instantiation of member templates
https://wg21.link/cwg46




John H. Spicer
-
d:cwg460
CWG460
12 February 2004
CD1
Can a using-declaration name a namespace?
https://wg21.link/cwg460




John Spicer
-
d:cwg461
CWG461
24 May 2004
NAD
Make asm conditionally-supported
https://wg21.link/cwg461




Clark Nelson
-
d:cwg462
CWG462
April 2004
CD3
Lifetime of temporaries bound to comma expressions
https://wg21.link/cwg462




Steve Adamczyk
-
d:cwg463
CWG463
14 February 2004
CD1
reinterpret_cast<T*>(0)
https://wg21.link/cwg463




Gennaro Prota
-
d:cwg464
CWG464
21 February 2004
CD1
Wording nit on lifetime of temporaries to which references are bound
https://wg21.link/cwg464




Allan Odgaard
-
d:cwg465
CWG465
26 February 2004
NAD
May constructors of global objects call exit()?
https://wg21.link/cwg465




Matt Austern
-
d:cwg466
CWG466
18 March 2004
CD1
cv-qualifiers on pseudo-destructor type
https://wg21.link/cwg466




Mark Mitchell
-
d:cwg467
CWG467
31 March 2004
NAD
Jump past initialization of local static variable
https://wg21.link/cwg467




Kerch Holt
-
d:cwg468
CWG468
9 April 2004
CD1
Allow ::template outside of templates
https://wg21.link/cwg468




John Spicer
-
d:cwg469
CWG469
19 March 2004
NAD
Const template specializations and reference arguments
https://wg21.link/cwg469




Matt Austern
-
d:cwg47
CWG47
7 November 1997
NAD
Template friend issues
https://wg21.link/cwg47




John H. Spicer
-
d:cwg470
CWG470
11 May 2004
CD1
Instantiation of members of an explicitly-instantiated class template
https://wg21.link/cwg470




Matt Austern
-
d:cwg471
CWG471
14 June 2004
NAD
Conflicting inherited access specifications
https://wg21.link/cwg471




Mike Miller
-
d:cwg472
CWG472
16 June 2004
drafting
Casting across protected inheritance
https://wg21.link/cwg472




Mike Miller
-
d:cwg473
CWG473
12 July 2004
open
Block-scope declarations of allocator functions
https://wg21.link/cwg473




John Spicer
-
d:cwg474
CWG474
23 July 2004
CD1
Block-scope extern declarations in namespace members
https://wg21.link/cwg474




Daveed Vandevoorde
-
d:cwg475
CWG475
27 September 2004
C++11
When is std::uncaught_exception() true? (take 2)
https://wg21.link/cwg475




Martin Sebor
-
d:cwg476
CWG476
14 September 2004
extension
Determining the buffer size for placement new
https://wg21.link/cwg476




Ben Hutchings
-
d:cwg477
CWG477
23 September 2004
CD1
Can virtual appear in a friend declaration?
https://wg21.link/cwg477




Daveed Vandevoorde
-
d:cwg478
CWG478
28 September 2004
NAD
May a function parameter be an array of an abstract class type?
https://wg21.link/cwg478




Steve Adamczyk
-
d:cwg479
CWG479
7 October 2004
CD1
Copy elision in exception handling
https://wg21.link/cwg479




Mike Miller
-
d:cwg48
CWG48
23 November 1997
TC1
Definitions of unused static members
https://wg21.link/cwg48




Bill Gibbons
-
d:cwg480
CWG480
18 October 2004
CD1
Is a base of a virtual base also virtual?
https://wg21.link/cwg480




Mark Mitchell
-
d:cwg481
CWG481
1 November 2004
CD2
Scope of template parameters
https://wg21.link/cwg481




Gabriel Dos Reis
-
d:cwg482
CWG482
3 November 2004
CD3
Qualified declarators in redeclarations
https://wg21.link/cwg482




Daveed Vandevoorde
-
d:cwg483
CWG483
21 October 2004
CD3
Normative requirements on integral ranges
https://wg21.link/cwg483




Steve Adamczyk
-
d:cwg484
CWG484
21 October 2004
CD1
Can a base-specifier name a cv-qualified class type?
https://wg21.link/cwg484




Richard Corden
-
d:cwg485
CWG485
9 November 2004
CD1
What is a “name”?
https://wg21.link/cwg485




Gabriel Dos Reis
-
d:cwg486
CWG486
16 November 2004
CD1
Invalid return types and template argument deduction
https://wg21.link/cwg486




John Spicer
-
d:cwg487
CWG487
24 November 2004
NAD
Operator overloading in constant expressions
https://wg21.link/cwg487




Steve Adamczyk
-
d:cwg488
CWG488
24 November 2004
CD1
Local types, overload resolution, and template argument deduction
https://wg21.link/cwg488




Mark Mitchell
-
d:cwg489
CWG489
24 November 2004
NAD
Must member function templates be instantiated during overload resolution?
https://wg21.link/cwg489




Daveed Vandevoorde
-
d:cwg49
CWG49
16 October 1998
TC1
Restriction on non-type, non-value template arguments
https://wg21.link/cwg49




Mike Miller
-
d:cwg490
CWG490
7 December 2004
CD2
Name lookup in friend declarations
https://wg21.link/cwg490




Ben Hutchings
-
d:cwg491
CWG491
15 December 2004
CD1
Initializers for empty-class aggregrate members
https://wg21.link/cwg491




Nathan Sidwell
-
d:cwg492
CWG492
15 December 2004
CD1
typeid constness inconsistent with example
https://wg21.link/cwg492




Ron Natalie
-
d:cwg493
CWG493
17 December 2004
CD2
Type deduction from a bool context
https://wg21.link/cwg493




John Spicer
-
d:cwg494
CWG494
17 December 2004
CD1
Problems with the resolution of issue 45
https://wg21.link/cwg494




Lloyd J. Lewins
-
d:cwg495
CWG495
20 December 2004
CD2
Overload resolution with template and non-template conversion functions
https://wg21.link/cwg495




Nathan Sidwell
-
d:cwg496
CWG496
30 December 2004
CD3
Is a volatile-qualified type really a POD?
https://wg21.link/cwg496




John Maddock
-
d:cwg497
CWG497
3 January 2005
CD1
Missing required initialization in example
https://wg21.link/cwg497




Giovanni Bajo
-
d:cwg498
CWG498
13 January 2005
open
Storage class specifiers in definitions of class members
https://wg21.link/cwg498




Matt Austern
-
d:cwg499
CWG499
19 January 2005
CD2
Throwing an array of unknown size
https://wg21.link/cwg499




Mike Miller
-
d:cwg5
CWG5

CD1
CV-qualifiers and type conversions
https://wg21.link/cwg5




Josee Lajoie
-
d:cwg50
CWG50
13 October 1998
NAD
Converting pointer to incomplete type to same type
https://wg21.link/cwg50




Steve Adamczyk
-
d:cwg500
CWG500
25 January 2005
CD1
Access in base-specifiers of friend and nested classes
https://wg21.link/cwg500




Andreas Hommel
-
d:cwg501
CWG501
25 January 2005
NAD
Visibility of friend declarations within the befriending class
https://wg21.link/cwg501




Gabriel Dos Reis
-
d:cwg502
CWG502
5 February 2005
C++11
Dependency of nested enumerations and enumerators
https://wg21.link/cwg502




Mark Mitchell
-
d:cwg503
CWG503
22 February 2005
open
Cv-qualified function types in template argument deduction
https://wg21.link/cwg503




Gabriel Dos Reis
-
d:cwg504
CWG504
14 April 2005
open
Should use of a variable in its own initializer require a diagnostic?
https://wg21.link/cwg504




Bjarne Stroustrup
-
d:cwg505
CWG505
14 April 2005
CD1
Conditionally-supported behavior for unknown character escapes
https://wg21.link/cwg505




Mike Miller
-
d:cwg506
CWG506
14 April 2005
CD1
Conditionally-supported behavior for non-POD objects passed to ellipsis
https://wg21.link/cwg506




Mike Miller
-
d:cwg507
CWG507
9 March 2005
dup
Ambiguity assigning class object to built-in type
https://wg21.link/cwg507




Steve Adamczyk
-
d:cwg508
CWG508
18 March 2005
C++11
Non-constructed value-initialized objects
https://wg21.link/cwg508




Alisdair Meredith
-
d:cwg509
CWG509
18 March 2005
CD1
Dead code in the specification of default initialization
https://wg21.link/cwg509




Mike Miller
-
d:cwg51
CWG51
13 October 1998
TC1
Overloading and user-defined conversions
https://wg21.link/cwg51




Steve Adamczyk
-
d:cwg510
CWG510
18 March 2005
CD1
Default initialization of POD classes?
https://wg21.link/cwg510




Mike Miller
-
d:cwg511
CWG511
19 March 2005
open
POD-structs with template assignment operators
https://wg21.link/cwg511




Alisdair Meredith
-
d:cwg512
CWG512
19 March 2005
NAD
Union members with user-declared non-default constructors
https://wg21.link/cwg512




Alisdair Meredith
-
d:cwg513
CWG513
20 March 2005
CD1
Non-class “most-derived” objects
https://wg21.link/cwg513




Marc Schoolderman
-
d:cwg514
CWG514
24 March 2005
CD1
Is the initializer for a namespace member in the scope of the namespace?
https://wg21.link/cwg514




Mike Miller
-
d:cwg515
CWG515
18 April 2005
CD1
Non-dependent references to base class members
https://wg21.link/cwg515




Mike Miller
-
d:cwg516
CWG516
25 April 2005
CD1
Use of signed in bit-field declarations
https://wg21.link/cwg516




comp.std.c++
-
d:cwg517
CWG517
3 May 2005
CD1
Partial specialization following explicit instantiation
https://wg21.link/cwg517




John Spicer
-
d:cwg518
CWG518
10 May 2005
CD1
Trailing comma following enumerator-list
https://wg21.link/cwg518




Charles Bryant
-
d:cwg519
CWG519
19 May 2005
CD1
Null pointer preservation in void* conversions
https://wg21.link/cwg519




comp.std.c++
-
d:cwg52
CWG52
13 October 1998
TC1
Non-static members, member selection and access checking
https://wg21.link/cwg52




Steve Adamczyk
-
d:cwg520
CWG520
19 May 2005
CD1
Old-style casts between incomplete class types
https://wg21.link/cwg520




comp.std.c++
-
d:cwg521
CWG521
22 May 2005
CD1
Requirements for exceptions thrown by allocation functions
https://wg21.link/cwg521




Alisdair Meredith
-
d:cwg522
CWG522
3 June 2005
CD1
Array-to-pointer decay in template argument deduction
https://wg21.link/cwg522




Daveed Vandevoorde
-
d:cwg523
CWG523
8 July 2005
open
Can a one-past-the-end pointer be invalidated by deleting an adjacent object?
https://wg21.link/cwg523




comp.std.c++
-
d:cwg524
CWG524
19 July 2005
CD1
Can function-notation calls to operator functions be dependent?
https://wg21.link/cwg524




Daveed Vandevoorde
-
d:cwg525
CWG525
25 July 2005
CD1
Missing * in example
https://wg21.link/cwg525




Mike Miller
-
d:cwg526
CWG526
25 July 2005
CD1
Confusing aspects in the specification of non-deduced contexts
https://wg21.link/cwg526




Mike Miller
-
d:cwg527
CWG527
28 July 2005
CD2
Problems with linkage of types
https://wg21.link/cwg527




Daveed Vandevoorde
-
d:cwg528
CWG528
18 May 2005
open
Why are incomplete class types not allowed with typeid?
https://wg21.link/cwg528




Dave Abrahams
-
d:cwg529
CWG529
16 August 2005
drafting
Use of template<> with “explicitly-specialized” class templates
https://wg21.link/cwg529




James Widman
-
d:cwg53
CWG53
13 October 1998
TC1
Lvalue-to-rvalue conversion before certain static_casts
https://wg21.link/cwg53




Steve Adamczyk
-
d:cwg530
CWG530
21 August 2005
CD1
Nontype template arguments in constant expressions
https://wg21.link/cwg530




Mark Mitchell
-
d:cwg531
CWG531
1 October 2005
C++11
Defining members of explicit specializations
https://wg21.link/cwg531




Mike Miller
-
d:cwg532
CWG532
16 September 2005
C++11
Member/nonmember operator template partial ordering
https://wg21.link/cwg532




Nathan Sidwell
-
d:cwg533
CWG533
4 October 2005
NAD
Special treatment for C-style header names
https://wg21.link/cwg533




Jens Maurer
-
d:cwg534
CWG534
5 October 2005
CD1
template-names and operator-function-ids
https://wg21.link/cwg534




Jens Maurer
-
d:cwg535
CWG535
7 October 2005
CD3
Copy construction without a copy constructor
https://wg21.link/cwg535




Mike Miller
-
d:cwg536
CWG536
13 October 2005
drafting
Problems in the description of id-expressions
https://wg21.link/cwg536




Mike Miller
-
d:cwg537
CWG537
12 October 2005
CD1
Definition of “signature”
https://wg21.link/cwg537




Daveed Vandevoorde
-
d:cwg538
CWG538
10 August 2005
CD1
Definition and usage of structure, POD-struct, POD-union, and POD class
https://wg21.link/cwg538




Alisdair Meredith
-
d:cwg539
CWG539
5 October 2005
CD3
Constraints on type-specifier-seq
https://wg21.link/cwg539




Mike Miller
-
d:cwg54
CWG54
13 October 1998
CD1
Static_cast from private base to derived class
https://wg21.link/cwg54




Steve Adamczyk
-
d:cwg540
CWG540
24 September 2005
CD1
Propagation of cv-qualifiers in reference-to-reference collapse
https://wg21.link/cwg540




Russell Yanofsky
-
d:cwg541
CWG541
22 October 2005
CD2
Dependent function types
https://wg21.link/cwg541




Daveed Vandevoorde
-
d:cwg542
CWG542
27 October 2005
CD2
Value initialization of arrays of POD-structs
https://wg21.link/cwg542




Alisdair Meredith
-
d:cwg543
CWG543
27 October 2005
CD1
Value initialization and default constructors
https://wg21.link/cwg543




Mike Miller
-
d:cwg544
CWG544
1 November 2005
NAD
Base class lookup in explicit specialization
https://wg21.link/cwg544




John Spicer
-
d:cwg545
CWG545
31 October 2005
open
User-defined conversions and built-in operator overload resolution
https://wg21.link/cwg545




Steve Clamage
-
d:cwg546
CWG546
29 October 2005
C++11
Explicit instantiation of class template members
https://wg21.link/cwg546




Martin Sebor
-
d:cwg547
CWG547
4 November 2005
C++11
Partial specialization on member function types
https://wg21.link/cwg547




Peter Dimov
-
d:cwg548
CWG548
18 November 2005
dup
qualified-ids in declarations
https://wg21.link/cwg548




Martin Sebor
-
d:cwg549
CWG549
18 November 2005
drafting
Non-deducible parameters in partial specializations
https://wg21.link/cwg549




Martin Sebor
-
d:cwg55
CWG55
13 October 1998
NAD
Adding/subtracting pointer and enumeration value
https://wg21.link/cwg55




Steve Adamczyk
-
d:cwg550
CWG550
22 November 2005
dup
Pointer to array of unknown bound in parameter declarations
https://wg21.link/cwg550




Daveed Vandevoorde
-
d:cwg551
CWG551
7 December 2005
CD1
When is inline permitted in an explicit instantiation?
https://wg21.link/cwg551




Steve Clamage
-
d:cwg552
CWG552
15 December 2005
NAD
Use of typename in the type in a non-type parameter-declaration
https://wg21.link/cwg552




Andre Morozov
-
d:cwg553
CWG553
16 December 2005
NAD
Problems with friend allocation and deallocation functions
https://wg21.link/cwg553




Dmitriy Litskalov
-
d:cwg554
CWG554
29 December 2005
drafting
Definition of “declarative region” and “scope”
https://wg21.link/cwg554




Gabriel Dos Reis
-
d:cwg555
CWG555
26 January 2006
drafting
Pseudo-destructor name lookup
https://wg21.link/cwg555




Krzysztof Zelechowski
-
d:cwg556
CWG556
30 January 2006
CD2
Conflicting requirements for acceptable aliasing
https://wg21.link/cwg556




Mike Miller
-
d:cwg557
CWG557
8 February 2006
CD1
Does argument-dependent lookup cause template instantiation?
https://wg21.link/cwg557




Mike Miller
-
d:cwg558
CWG558
8 February 2006
CD1
Excluded characters in universal character names
https://wg21.link/cwg558




Daveed Vandevoorde
-
d:cwg559
CWG559
11 February 2006
CD1
Editing error in issue 382 resolution
https://wg21.link/cwg559




Mike Miller
-
d:cwg56
CWG56
13 October 1998
TC1
Redeclaring typedefs within classes
https://wg21.link/cwg56




Steve Adamczyk
-
d:cwg560
CWG560
11 February 2006
drafting
Use of the typename keyword in return types
https://wg21.link/cwg560




Greg Comeau
-
d:cwg561
CWG561
17 February 2006
CD2
Internal linkage functions in dependent name lookup
https://wg21.link/cwg561




Joaquín López Muñoz
-
d:cwg562
CWG562
6 April 2006
open
qualified-ids in non-expression contexts
https://wg21.link/cwg562




Mike Miller
-
d:cwg563
CWG563
8 March 2006
open
Linkage specification for objects
https://wg21.link/cwg563




Daveed Vandevoorde
-
d:cwg564
CWG564
8 March 2006
CD2
Agreement of language linkage or linkage-specifications?
https://wg21.link/cwg564




Daveed Vandevoorde
-
d:cwg565
CWG565
9 March 2006
CD3
Conflict rules for using-declarations naming function templates
https://wg21.link/cwg565




Paolo Carlini
-
d:cwg566
CWG566
13 March 2006
NAD
Conversion of negative floating point values to integer type
https://wg21.link/cwg566




Seungbeom Kim
-
d:cwg567
CWG567
14 March 2006
NAD
Can size_t and ptrdiff_t be larger than long?
https://wg21.link/cwg567




Nick MacLaren
-
d:cwg568
CWG568
20 March 2006
CD1
Definition of POD is too strict
https://wg21.link/cwg568




Matt Austern
-
d:cwg569
CWG569
20 March 2006
CD2
Spurious semicolons at namespace scope should be allowed
https://wg21.link/cwg569




Matt Austern
-
d:cwg57
CWG57
13 October 1998
open
Empty unions
https://wg21.link/cwg57




Steve Adamczyk
-
d:cwg570
CWG570
2 April 2006
CD2
Are references subject to the ODR?
https://wg21.link/cwg570




Dave Abrahams
-
d:cwg571
CWG571
31 March 2006
CD2
References declared const
https://wg21.link/cwg571




Dave Abrahams
-
d:cwg572
CWG572
6 April 2006
C++11
Standard conversions for non-built-in types
https://wg21.link/cwg572




Jens Maurer
-
d:cwg573
CWG573
13 April 2006
C++11
Conversions between function pointers and void*
https://wg21.link/cwg573




Steve Adamczyk
-
d:cwg574
CWG574
15 April 2006
NAD
Definition of “copy assignment operator”
https://wg21.link/cwg574




Steve Adamczyk
-
d:cwg575
CWG575
19 April 2006
C++11
Criteria for deduction failure
https://wg21.link/cwg575




James Widman
-
d:cwg576
CWG576
21 April 2006
CD2
Typedefs in function definitions
https://wg21.link/cwg576




Jon Caves
-
d:cwg577
CWG577
22 April 2006
CD3
void in an empty parameter list
https://wg21.link/cwg577




Ben Hutchings
-
d:cwg578
CWG578
7 May 2006
open
Phase 1 replacement of characters with universal-character-names
https://wg21.link/cwg578




Martin Vejnár
-
d:cwg579
CWG579
11 May 2006
open
What is a “nested” > or >>?
https://wg21.link/cwg579




Daveed Vandevoorde
-
d:cwg58
CWG58
13 October 1998
CD1
Signedness of bit fields of enum type
https://wg21.link/cwg58




Steve Adamczyk
-
d:cwg580
CWG580
16 May 2006
C++11
Access in template-parameters of member and friend definitions
https://wg21.link/cwg580




John Spicer
-
d:cwg581
CWG581
19 May 2006
open
Can a templated constructor be explicitly instantiated or specialized?
https://wg21.link/cwg581




Mark Mitchell
-
d:cwg582
CWG582
23 May 2006
CD1
Template conversion functions
https://wg21.link/cwg582




PremAnand Rao
-
d:cwg583
CWG583
24 May 2006
CD3
Relational pointer comparisons against the null pointer constant
https://wg21.link/cwg583




James Widman
-
d:cwg584
CWG584
10 June 2006
NAD
Unions and aliasing
https://wg21.link/cwg584




comp.std.c++
-
d:cwg585
CWG585
15 June 2006
NAD
Friend template template parameters
https://wg21.link/cwg585




James Widman
-
d:cwg586
CWG586
20 June 2006
NAD
Default template-arguments and template argument deduction
https://wg21.link/cwg586




James Widman
-
d:cwg587
CWG587
20 June 2006
CD2
Lvalue operands of a conditional expression differing only in cv-qualification
https://wg21.link/cwg587




Howard Hinnant
-
d:cwg588
CWG588
21 June 2006
CD2
Searching dependent bases of classes local to function templates
https://wg21.link/cwg588




James Widman
-
d:cwg589
CWG589
26 July 2006
CD2
Direct binding of class and array rvalues in reference initialization
https://wg21.link/cwg589




Steve Adamczyk
-
d:cwg59
CWG59
13 October 1998
TC1
Clarification of overloading and UDC to reference type
https://wg21.link/cwg59




Steve Adamczyk
-
d:cwg590
CWG590
23 August 2006
C++11
Nested classes and the “current instantiation”
https://wg21.link/cwg590




James Widman
-
d:cwg591
CWG591
24 August 2006
CD4
When a dependent base class is the current instantiation
https://wg21.link/cwg591




James Widman
-
d:cwg592
CWG592
30 August 2006
CD1
Exceptions during construction of local static objects
https://wg21.link/cwg592




Alisdair Meredith
-
d:cwg593
CWG593
30 August 2006
NAD
Falling off the end of a destructor's function-try-block handler
https://wg21.link/cwg593




Alisdair Meredith
-
d:cwg594
CWG594
30 August 2006
CD1
Coordinating issues 119 and 404 with delegating constructors
https://wg21.link/cwg594




Tom Plum
-
d:cwg595
CWG595
7 September 2006
dup
Exception specifications in templates instantiated from class bodies
https://wg21.link/cwg595




Daveed Vandevoorde
-
d:cwg596
CWG596
12 September 2006
NAD
Replacing an exception object
https://wg21.link/cwg596




Alisdair Meredith
-
d:cwg597
CWG597
27 September 2006
CD3
Conversions applied to out-of-lifetime non-POD lvalues
https://wg21.link/cwg597




Mike Miller
-
d:cwg598
CWG598
27 September 2006
CD2
Associated namespaces of overloaded functions and function templates
https://wg21.link/cwg598




Mike Miller
-
d:cwg599
CWG599
3 October 2006
CD2
Deleting a null function pointer
https://wg21.link/cwg599




Martin Sebor
-
d:cwg6
CWG6

open
Should the optimization that allows a class object to alias another object also allow the case of a parameter in an inline function to alias its argument?
https://wg21.link/cwg6




unknown
-
d:cwg60
CWG60
13 October 1998
CD1
Reference binding and valid conversion sequences
https://wg21.link/cwg60




Steve Adamczyk
-
d:cwg600
CWG600
3 October 2006
open
Does access control apply to members or to names?
https://wg21.link/cwg600




Alisdair Meredith
-
d:cwg601
CWG601
23 October 2006
CD2
Type of literals in preprocessing expressions
https://wg21.link/cwg601




Daveed Vandevoorde
-
d:cwg602
CWG602
23 October 2006
C++11
When is the injected-class-name of a class template a template?
https://wg21.link/cwg602




Daveed Vandevoorde
-
d:cwg603
CWG603
3 November 2006
CD1
Type equivalence and unsigned overflow
https://wg21.link/cwg603




James Widman
-
d:cwg604
CWG604
4 November 2006
CD2
Argument list for overload resolution in copy-initialization
https://wg21.link/cwg604




Dawn Perchik
-
d:cwg605
CWG605
30 November 2006
C++11
Linkage of explicit specializations
https://wg21.link/cwg605




Steve Clamage
-
d:cwg606
CWG606
1 December 2006
CD1
Template argument deduction for rvalue references
https://wg21.link/cwg606




Peter Dimov
-
d:cwg607
CWG607
5 December 2006
open
Lookup of mem-initializer-ids
https://wg21.link/cwg607




Richard Corden
-
d:cwg608
CWG608
7 December 2006
CD2
Determining the final overrider of a virtual function
https://wg21.link/cwg608




Mike Miller
-
d:cwg609
CWG609
5 November 2006
CD4
What is a “top-level” cv-qualifier?
https://wg21.link/cwg609




Dawn Perchik
-
d:cwg61
CWG61
13 October 1998
NAD
Address of static member function "&p->f"
https://wg21.link/cwg61




Steve Adamczyk
-
d:cwg610
CWG610
21 December 2006
NAD
Computing the negative of 0U
https://wg21.link/cwg610




comp.std.c++
-
d:cwg611
CWG611
29 December 2006
CD2
Zero-initializing references
https://wg21.link/cwg611




Alisdair Meredith
-
d:cwg612
CWG612
23 January 2007
CD2
Requirements on a conforming implementation
https://wg21.link/cwg612




Clark Nelson
-
d:cwg613
CWG613
28 October 2006
CD1
Unevaluated uses of non-static class members
https://wg21.link/cwg613




Herb Sutter
-
d:cwg614
CWG614
15 January 2007
CD1
Results of integer / and %
https://wg21.link/cwg614




Gabriel Dos Reis
-
d:cwg615
CWG615
30 January 2007
C++11
Incorrect description of variables that can be initialized
https://wg21.link/cwg615




comp.std.c++
-
d:cwg616
CWG616
2 February 2007
CD3
Definition of “indeterminate value”
https://wg21.link/cwg616




Bjarne Stroustrup
-
d:cwg617
CWG617
6 February 2007
drafting
Lvalue-to-rvalue conversions of uninitialized char objects
https://wg21.link/cwg617




Alan Stokes
-
d:cwg618
CWG618
12 February 2007
CD2
Casts in preprocessor conditional expressions
https://wg21.link/cwg618




Martin Sebor
-
d:cwg619
CWG619
16 February 2007
C++11
Completeness of array types
https://wg21.link/cwg619




Steve Clamage
-
d:cwg62
CWG62
13 October 1998
CD1
Unnamed members of classes used as type parameters
https://wg21.link/cwg62




Steve Adamczyk
-
d:cwg620
CWG620
1 March 2007
CD1
Declaration order in layout-compatible POD structs
https://wg21.link/cwg620




Martin Sebor
-
d:cwg621
CWG621
16 February 2007
C++11
Template argument deduction from function return types
https://wg21.link/cwg621




Richard Corden
-
d:cwg622
CWG622
26 February 2007
NAD
Relational comparisons of arbitrary pointers
https://wg21.link/cwg622




Herb Sutter
-
d:cwg623
CWG623
27 February 2007
CD3
Use of pointers to deallocated storage
https://wg21.link/cwg623




Herb Sutter
-
d:cwg624
CWG624
8 March 2007
CD1
Overflow in calculating size of allocation
https://wg21.link/cwg624




Jens Maurer
-
d:cwg625
CWG625
9 March 2007
CD2
Use of auto as a template-argument
https://wg21.link/cwg625




John Spicer
-
d:cwg626
CWG626
12 September 2006
CD2
Preprocessor string literals
https://wg21.link/cwg626




Gennaro Prota
-
d:cwg627
CWG627
15 March 2007
NAD
Values behaving as types
https://wg21.link/cwg627




Gennaro Prota
-
d:cwg628
CWG628
15 March 2007
CD2
The values of an enumeration with no enumerator
https://wg21.link/cwg628




Gennaro Prota
-
d:cwg629
CWG629
14 March 2007
CD1
auto parsing ambiguity
https://wg21.link/cwg629




Daveed Vandevoorde
-
d:cwg63
CWG63
13 October 1998
CD1
Class instantiation from pointer conversion to void*, null and self
https://wg21.link/cwg63




Steve Adamczyk
-
d:cwg630
CWG630
21 April 2007
CD2
Equality of narrow and wide character values in the basic character set
https://wg21.link/cwg630




Tom Plum
-
d:cwg631
CWG631
24 April 2007
CD3
Jumping into a “then” clause
https://wg21.link/cwg631




James Kanze
-
d:cwg632
CWG632
3 May 2007
CD1
Brace-enclosed initializer for scalar member of aggregate
https://wg21.link/cwg632




Greg Comeau
-
d:cwg633
CWG633
17 May 2007
CD2
Specifications for variables that should also apply to references
https://wg21.link/cwg633




Alisdair Meredith
-
d:cwg634
CWG634
6 June 2007
CD1
Conditionally-supported behavior for non-POD objects passed to ellipsis redux
https://wg21.link/cwg634




Howard Hinnant
-
d:cwg635
CWG635
23 May 2007
NAD
Names of constructors and destructors of templates
https://wg21.link/cwg635




Martin Sebor
-
d:cwg636
CWG636
23 May 2007
CD4
Dynamic type of objects and aliasing
https://wg21.link/cwg636




Gabriel Dos Reis
-
d:cwg637
CWG637
2 June 2007
CD1
Sequencing rules and example disagree
https://wg21.link/cwg637




Ofer Porat
-
d:cwg638
CWG638
6 July 2007
CD2
Explicit specialization and friendship
https://wg21.link/cwg638




Daveed Vandevoorde
-
d:cwg639
CWG639
26 July 2007
CD1
What makes side effects “different” from one another?
https://wg21.link/cwg639




James Widman
-
d:cwg64
CWG64
13 October 1998
TC1
Partial ordering to disambiguate explicit specialization
https://wg21.link/cwg64




Steve Adamczyk
-
d:cwg640
CWG640
30 July 2007
open
Accessing destroyed local objects of static storage duration
https://wg21.link/cwg640




Howard Hinnant
-
d:cwg641
CWG641
2 August 2007
CD2
Overload resolution and conversion-to-same-type operators
https://wg21.link/cwg641




Nathan Sidwell
-
d:cwg642
CWG642
6 August 2007
CD2
Definition and use of “block scope” and “local scope”
https://wg21.link/cwg642




Alisdair Meredith
-
d:cwg643
CWG643
8 August 2007
NAD
Use of decltype in a class member-specification
https://wg21.link/cwg643




Alisdair Meredith
-
d:cwg644
CWG644
8 August 2007
CD1
Should a trivial class type be a literal type?
https://wg21.link/cwg644




Alisdair Meredith
-
d:cwg645
CWG645
9 August 2007
CD2
Are bit-field and non-bit-field members layout compatible?
https://wg21.link/cwg645




Alan Stokes
-
d:cwg646
CWG646
9 August 2007
NAD
Can a class with a constexpr copy constructor be a literal type?
https://wg21.link/cwg646




Jens Maurer
-
d:cwg647
CWG647
12 August 2007
CD1
Non-constexpr instances of constexpr constructor templates
https://wg21.link/cwg647




Mike Miller
-
d:cwg648
CWG648
12 August 2007
CD1
Constant expressions in constexpr initializers
https://wg21.link/cwg648




Mike Miller
-
d:cwg649
CWG649
12 August 2007
CD1
Optionally ill-formed extended alignment requests
https://wg21.link/cwg649




Mike Miller
-
d:cwg65
CWG65
6 October 1998
TC1
Typo in default argument example
https://wg21.link/cwg65




Mike Miller
-
d:cwg650
CWG650
14 August 2007
CD2
Order of destruction for temporaries bound to the returned value of a function
https://wg21.link/cwg650




Mike Miller
-
d:cwg651
CWG651
16 August 2007
CD1
Problems in decltype specification and examples
https://wg21.link/cwg651




Daveed Vandevoorde
-
d:cwg652
CWG652
3 October 2007
CD2
Compile-time evaluation of floating-point expressions
https://wg21.link/cwg652




Jens Maurer
-
d:cwg653
CWG653
3 October 2007
CD2
Copy assignment of unions
https://wg21.link/cwg653




Jens Maurer
-
d:cwg654
CWG654
7 October 2007
CD1
Conversions to and from nullptr_t
https://wg21.link/cwg654




Jason Merrill
-
d:cwg655
CWG655
17 October 2007
C++11
Initialization not specified for forwarding constructors
https://wg21.link/cwg655




Alisdair Meredith
-
d:cwg656
CWG656
23 October 2007
CD2
Direct binding to the result of a conversion operator
https://wg21.link/cwg656




Jason Merrill
-
d:cwg657
CWG657
31 October 2007
CD2
Abstract class parameter in synthesized declaration
https://wg21.link/cwg657




Mike Miller
-
d:cwg658
CWG658
4 November 2007
CD2
Defining reinterpret_cast for pointer types
https://wg21.link/cwg658




Dave Abrahams
-
d:cwg659
CWG659
7 November 2007
CD1
Alignment of function types
https://wg21.link/cwg659




Alisdair Meredith
-
d:cwg66
CWG66
6 October 1998
NAD
Visibility of default args vs overloads added after using-declaration
https://wg21.link/cwg66




Mike Miller
-
d:cwg660
CWG660
15 November 2007
CD1
Unnamed scoped enumerations
https://wg21.link/cwg660




Daveed Vandevoorde
-
d:cwg661
CWG661
27 November 2007
CD1
Semantics of arithmetic comparisons
https://wg21.link/cwg661




Daveed Vandevoorde
-
d:cwg662
CWG662
28 November 2007
NAD
Forming a pointer to a reference type
https://wg21.link/cwg662




Alisdair Meredith
-
d:cwg663
CWG663
30 November 2007
CD1
Valid Cyrillic identifier characters
https://wg21.link/cwg663




Steve Clamage
-
d:cwg664
CWG664
1 December 2007
CD2
Direct binding of references to non-class rvalue references
https://wg21.link/cwg664




Eric Niebler
-
d:cwg665
CWG665
1 December 2007
CD2
Problems in the specification of dynamic_cast
https://wg21.link/cwg665




Daniel Krügler
-
d:cwg666
CWG666
6 December 2007
CD1
Dependent qualified-ids without the typename keyword
https://wg21.link/cwg666




Daveed Vandevoorde
-
d:cwg667
CWG667
14 December 2007
CD2
Trivial special member functions that cannot be implicitly defined
https://wg21.link/cwg667




James Widman
-
d:cwg668
CWG668
16 December 2007
CD2
Throwing an exception from the destructor of a local static object
https://wg21.link/cwg668




Daniel Krügler
-
d:cwg669
CWG669
17 December 2007
NAD
Confusing specification of the meaning of decltype
https://wg21.link/cwg669




Vera Lychagina
-
d:cwg67
CWG67
6 October 1998
TC1
Evaluation of left side of object-expression
https://wg21.link/cwg67




Mike Miller
-
d:cwg670
CWG670
20 December 2007
open
Copy initialization via derived-to-base conversion in the second step
https://wg21.link/cwg670




Jason Merrill
-
d:cwg671
CWG671
22 December 2007
CD1
Explicit conversion from a scoped enumeration type to integral type
https://wg21.link/cwg671




Daveed Vandevoorde
-
d:cwg672
CWG672
11 January 2008
CD2
Sequencing of initialization in new-expressions
https://wg21.link/cwg672




Clark Nelson
-
d:cwg673
CWG673
6 February 2008
NAD
Injection of names from elaborated-type-specifiers in friend declarations
https://wg21.link/cwg673




Mike Miller
-
d:cwg674
CWG674
7 February 2008
C++11
“matching specialization” for a friend declaration
https://wg21.link/cwg674




James Widman
-
d:cwg675
CWG675
11 February 2008
CD3
Signedness of bit-field with typedef or template parameter type
https://wg21.link/cwg675




Richard Corden
-
d:cwg676
CWG676
12 February 2008
C++11
static_assert-declarations and general requirements for declarations
https://wg21.link/cwg676




Alisdair Meredith
-
d:cwg677
CWG677
15 February 2008
CD1
Deleted operator delete and virtual destructors
https://wg21.link/cwg677




Mike Miller
-
d:cwg678
CWG678
15 February 2008
C++11
Language linkage of member function parameter types and the ODR
https://wg21.link/cwg678




James Widman
-
d:cwg679
CWG679
1 March 2008
CD1
Equivalence of template-ids and operator function templates
https://wg21.link/cwg679




Richard Corden
-
d:cwg68
CWG68
17 October 1998
TC1
Grammar does not allow "friend class A<int>;"
https://wg21.link/cwg68




Mike Ball
-
d:cwg680
CWG680
3 March 2008
CD2
What is a move constructor?
https://wg21.link/cwg680




Steve Adamczyk
-
d:cwg681
CWG681
10 March 2008
CD1
Restrictions on declarators with late-specified return types
https://wg21.link/cwg681




Mike Miller
-
d:cwg682
CWG682
1 March 2008
drafting
Missing description of lookup of template aliases
https://wg21.link/cwg682




Daveed Vandevoorde
-
d:cwg683
CWG683
13 March 2008
CD1
Requirements for trivial subobject special functions
https://wg21.link/cwg683




Jens Maurer
-
d:cwg684
CWG684
13 March 2008
CD1
Constant expressions involving the address of an automatic variable
https://wg21.link/cwg684




Jens Maurer
-
d:cwg685
CWG685
6 January 2008
CD2
Integral promotion of enumeration ignores fixed underlying type
https://wg21.link/cwg685




Alberto Ganesh Barbati
-
d:cwg686
CWG686
21 March 2008
CD1
Type declarations/definitions in type-specifier-seqs and type-ids
https://wg21.link/cwg686




Jens Maurer
-
d:cwg687
CWG687
27 February 2008
extension
template keyword with unqualified-ids
https://wg21.link/cwg687




Mihai Rusu
-
d:cwg688
CWG688
26 March 2008
CD1
Constexpr constructors and static initialization
https://wg21.link/cwg688




Peter Dimov
-
d:cwg689
CWG689
30 March 2008
open
Maximum values of signed and unsigned integers
https://wg21.link/cwg689




James Kanze
-
d:cwg69
CWG69
17 October 1998
TC1
Storage class specifiers on template declarations
https://wg21.link/cwg69




Mike Ball
-
d:cwg690
CWG690
7 April 2008
CD2
The dynamic type of an rvalue reference
https://wg21.link/cwg690




Eelis van der Weegen
-
d:cwg691
CWG691
9 April 2008
C++11
Template parameter packs in class template partial specializations
https://wg21.link/cwg691




Doug Gregor
-
d:cwg692
CWG692
16 April 2008
C++11
Partial ordering of variadic class template partial specializations
https://wg21.link/cwg692




Doug Gregor
-
d:cwg693
CWG693
21 April 2008
CD2
New string types and deprecated conversion
https://wg21.link/cwg693




Alisdair Meredith
-
d:cwg694
CWG694
14 May 2008
C++11
Zero- and value-initialization of union objects
https://wg21.link/cwg694




Clark Nelson
-
d:cwg695
CWG695
9 June 2008
CD2
Compile-time calculation errors in constexpr functions
https://wg21.link/cwg695




Mike Miller
-
d:cwg696
CWG696
29 May 2008
C++11
Use of block-scope constants in local classes
https://wg21.link/cwg696




Steve Adamczyk
-
d:cwg697
CWG697
6 June 2008
open
Deduction rules apply to more than functions
https://wg21.link/cwg697




Doug Gregor
-
d:cwg698
CWG698
13 July 2008
open
The definition of “sequenced before” is too narrow
https://wg21.link/cwg698




Jens Maurer
-
d:cwg699
CWG699
26 June 2008
CD2
Must constexpr member functions be defined in the class member-specification?
https://wg21.link/cwg699




Mike Miller
-
d:cwg7
CWG7

NAD
Can a class with a private virtual base class be derived from?
https://wg21.link/cwg7




Jason Merrill
-
d:cwg70
CWG70
29 September 1998
CD1
Is an array bound a nondeduced context?
https://wg21.link/cwg70




Jack Rouse
-
d:cwg700
CWG700
27 June 2008
C++11
Constexpr member functions of class templates
https://wg21.link/cwg700




Jens Maurer
-
d:cwg701
CWG701
13 July 2008
CD2
When is the array-to-pointer conversion applied?
https://wg21.link/cwg701




Eelis van der Weegen
-
d:cwg702
CWG702
2 July 2008
CD2
Preferring conversion to std::initializer_list
https://wg21.link/cwg702




Jason Merrill
-
d:cwg703
CWG703
2 July 2008
CD2
Narrowing for literals that cannot be exactly represented
https://wg21.link/cwg703




Jason Merrill
-
d:cwg704
CWG704
29 July 2008
CD2
To which postfix-expressions does overload resolution apply?
https://wg21.link/cwg704




Jens Maurer
-
d:cwg705
CWG705
29 July 2008
CD2
Suppressing argument-dependent lookup via parentheses
https://wg21.link/cwg705




Mike Miller
-
d:cwg706
CWG706
1 August 2008
NAD
Use of auto with rvalue references
https://wg21.link/cwg706




Jonathan Caves
-
d:cwg707
CWG707
2 August 2008
CD2
Undefined behavior in integral-to-floating conversions
https://wg21.link/cwg707




Alberto Ganesh Barbati
-
d:cwg708
CWG708
8 August 2008
open
Partial specialization of member templates of class templates
https://wg21.link/cwg708




James Widman
-
d:cwg709
CWG709
23 August 2008
C++11
Enumeration names as nested-name-specifiers in deduction failure
https://wg21.link/cwg709




Doug Gregor
-
d:cwg71
CWG71
15 October 1998
NAD
Incorrect cross reference
https://wg21.link/cwg71




Neal Gafter
-
d:cwg710
CWG710
3 May 2008
CD2
Data races during construction
https://wg21.link/cwg710




Jeffrey Yasskin
-
d:cwg711
CWG711
27 August 2008
CD2
auto with braced-init-list
https://wg21.link/cwg711




Jason Merrill
-
d:cwg712
CWG712
9 September 2008
CD3
Are integer constant operands of a conditional-expression “used?”
https://wg21.link/cwg712




Mike Miller
-
d:cwg713
CWG713
11 September 2008
CD2
Unclear note about cv-qualified function types
https://wg21.link/cwg713




Doug Gregor
-
d:cwg714
CWG714
15 September 2008
CD2
Static const data members and braced-init-lists
https://wg21.link/cwg714




Steve Adamczyk
-
d:cwg715
CWG715
17 September 2008
CD2
Class member access constant expressions
https://wg21.link/cwg715




Steve Adamczyk
-
d:cwg716
CWG716
17 September 2008
CD2
Specifications that should apply only to non-static union data members
https://wg21.link/cwg716




Mike Miller
-
d:cwg717
CWG717
17 September 2008
CD2
Unintentional restrictions on the use of thread_local
https://wg21.link/cwg717




Clark Nelson
-
d:cwg718
CWG718
18 September 2008
open
Non-class, non-function friend declarations
https://wg21.link/cwg718




John Spicer
-
d:cwg719
CWG719
19 September 2008
CD2
Specifications for operator-function-id that should also apply to literal-operator-id
https://wg21.link/cwg719




Daveed Vandevoorde
-
d:cwg72
CWG72
19 October 1998
dup
Linkage and storage class specifiers for templates
https://wg21.link/cwg72




Mike Ball
-
d:cwg720
CWG720
20 September 2008
CD2
Need examples of lambda-expressions
https://wg21.link/cwg720




Daveed Vandevoorde
-
d:cwg721
CWG721
22 September 2008
CD2
Where must a variable be initialized to be used in a constant expression?
https://wg21.link/cwg721




James Kanze
-
d:cwg722
CWG722
25 September 2008
CD2
Can nullptr be passed to an ellipsis?
https://wg21.link/cwg722




Alisdair Meredith
-
d:cwg723
CWG723
3 October 2008
concepts
Archetypes in skipped declarations
https://wg21.link/cwg723




Doug Gregor
-
d:cwg724
CWG724
24 September 2008
concepts
Qualified name lookup in a constrained context
https://wg21.link/cwg724




Daniel Krügler
-
d:cwg725
CWG725
30 September 2008
concepts
When should the requirement for std::Returnable<T>, etc., apply?
https://wg21.link/cwg725




Alberto Ganesh Barbati
-
d:cwg726
CWG726
30 September 2008
CD2
Atomic and non-atomic objects in the memory model
https://wg21.link/cwg726




Clark Nelson
-
d:cwg727
CWG727
5 October 2008
C++17
In-class explicit specializations
https://wg21.link/cwg727




Faisal Vali
-
d:cwg728
CWG728
5 October 2008
extension
Restrictions on local classes
https://wg21.link/cwg728




Faisal Vali
-
d:cwg729
CWG729
6 October 2008
CD3
Qualification conversions and handlers of reference-to-pointer type
https://wg21.link/cwg729




John Spicer
-
d:cwg73
CWG73
13 November 1998
TC1
Pointer equality
https://wg21.link/cwg73




Nathan Myers
-
d:cwg730
CWG730
3 October 2008
CD2
Explicit specializations of members of non-template classes
https://wg21.link/cwg730




Bronek Kozicki
-
d:cwg731
CWG731
6 October 2008
CD2
Omitted reference qualification of member function type
https://wg21.link/cwg731




Daniel Krügler
-
d:cwg732
CWG732
7 October 2008
CD2
Late-specified return types in function definitions
https://wg21.link/cwg732




Daniel Krügler
-
d:cwg733
CWG733
9 October 2008
NAD
Reference qualification of copy assignment operators
https://wg21.link/cwg733




Alberto Ganesh Barbati
-
d:cwg734
CWG734
15 October 2008
CD2
Are unique addresses required for namespace-scope variables?
https://wg21.link/cwg734




Daveed Vandevoorde
-
d:cwg735
CWG735
14 October 2008
CD2
Missing case in specification of safely-derived pointers
https://wg21.link/cwg735




Jens Maurer
-
d:cwg736
CWG736
16 October 2008
NAD
Is the & ref-qualifier needed?
https://wg21.link/cwg736




Alberto Ganesh Barbati
-
d:cwg737
CWG737
26 October 2008
CD2
Uninitialized trailing characters in string initialization
https://wg21.link/cwg737




James Kanze
-
d:cwg738
CWG738
27 October 2008
C++11
constexpr not permitted by the syntax of constructor declarations
https://wg21.link/cwg738




James Widman
-
d:cwg739
CWG739
3 November 2008
CD3
Signedness of plain bit-fields
https://wg21.link/cwg739




Mike Miller
-
d:cwg74
CWG74
16 November 1998
TC1
Enumeration value in direct-new-declarator
https://wg21.link/cwg74




Jason Merrill
-
d:cwg740
CWG740
3 November 2008
CD2
Incorrect note on data races
https://wg21.link/cwg740




Wolf Lammen
-
d:cwg741
CWG741
7 November 2008
C++11
“plain” long long bit-fields
https://wg21.link/cwg741




Mike Miller
-
d:cwg742
CWG742
11 November 2008
open
Postfix increment/decrement with long bit-field operands
https://wg21.link/cwg742




Mike Miller
-
d:cwg743
CWG743
12 November 2008
CD2
Use of decltype in a nested-name-specifier
https://wg21.link/cwg743




Jaakko Järvi
-
d:cwg744
CWG744
2 November 2008
CD2
Matching template arguments with template template parameters with parameter packs
https://wg21.link/cwg744




Faisal Vali
-
d:cwg745
CWG745
13 November 2008
open
Effect of ill-formedness resulting from #error
https://wg21.link/cwg745




Clark Nelson
-
d:cwg746
CWG746
18 November 2008
CD2
Use of auto in new-expressions
https://wg21.link/cwg746




Jason Merrill
-
d:cwg747
CWG747
18 November 2008
dup
Access of protected base classes
https://wg21.link/cwg747




Sam Saariste
-
d:cwg748
CWG748
28 November 2008
concepts
Always-complete archetypes
https://wg21.link/cwg748




James Widman
-
d:cwg749
CWG749
9 December 2008
CD2
References to function types with a cv-qualifier or ref-qualifier
https://wg21.link/cwg749




Alberto Ganesh Barbati
-
d:cwg75
CWG75
29 December 1998
TC1
In-class initialized members must be const
https://wg21.link/cwg75




John Wiegley
-
d:cwg750
CWG750
10 December 2008
CD2
Implementation constraints on reference-only closure objects
https://wg21.link/cwg750




Daveed Vandevoorde
-
d:cwg751
CWG751
11 December 2008
CD2
Deriving from closure classes
https://wg21.link/cwg751




Daveed Vandevoorde
-
d:cwg752
CWG752
10 December 2008
CD2
Name lookup in nested lambda-expressions
https://wg21.link/cwg752




Daveed Vandevoorde
-
d:cwg753
CWG753
10 December 2008
CD2
Array names in lambda capture sets
https://wg21.link/cwg753




Daveed Vandevoorde
-
d:cwg754
CWG754
10 December 2008
CD2
Lambda expressions in default arguments of block-scope function declarations
https://wg21.link/cwg754




Daveed Vandevoorde
-
d:cwg755
CWG755
11 December 2008
CD3
Generalized lambda-captures
https://wg21.link/cwg755




John Freeman
-
d:cwg756
CWG756
15 December 2008
CD2
Dropping cv-qualification on members of closure objects
https://wg21.link/cwg756




Daveed Vandevoorde
-
d:cwg757
CWG757
23 December 2008
CD2
Types without linkage in declarations
https://wg21.link/cwg757




John Spicer
-
d:cwg758
CWG758
22 January 2009
C++11
Missing cases of declarations that are not definitions
https://wg21.link/cwg758




Bjarne Stroustrup
-
d:cwg759
CWG759
22 January 2009
CD2
Destruction of closure objects
https://wg21.link/cwg759




Daveed Vandevoorde
-
d:cwg76
CWG76
15 December 1998
TC1
Are const volatile variables considered "constant expressions"?
https://wg21.link/cwg76




Judy Ward
-
d:cwg760
CWG760
3 February 2009
CD2
this inside a nested class of a non-static member function
https://wg21.link/cwg760




Mike Miller
-
d:cwg761
CWG761
5 February 2009
CD2
Inferred return type of closure object call operator
https://wg21.link/cwg761




Daveed Vandevoorde
-
d:cwg762
CWG762
5 February 2009
CD2
Name lookup in the compound-statement of a lambda expression
https://wg21.link/cwg762




John Spicer
-
d:cwg763
CWG763
6 February 2009
CD2
Is a closure object's operator() inline?
https://wg21.link/cwg763




Daveed Vandevoorde
-
d:cwg764
CWG764
6 February 2009
CD2
Capturing unused variables in a lambda expression
https://wg21.link/cwg764




Steve Adamczyk
-
d:cwg765
CWG765
6 February 2009
CD2
Local types in inline functions with external linkage
https://wg21.link/cwg765




Mike Miller
-
d:cwg766
CWG766
6 February 2009
CD2
Where may lambda expressions appear?
https://wg21.link/cwg766




Daveed Vandevoorde
-
d:cwg767
CWG767
5 February 2009
CD2
void and other unnamed lambda-parameters
https://wg21.link/cwg767




Daveed Vandevoorde
-
d:cwg768
CWG768
5 February 2009
CD2
Ellipsis in a lambda parameter list
https://wg21.link/cwg768




Daveed Vandevoorde
-
d:cwg769
CWG769
9 February 2009
CD2
Initialization of closure objects
https://wg21.link/cwg769




Mike Miller
-
d:cwg77
CWG77
15 December 1998
CD1
The definition of friend does not allow nested classes to be friends
https://wg21.link/cwg77




Judy Ward
-
d:cwg770
CWG770
9 February 2009
CD2
Ambiguity in late-specified return type
https://wg21.link/cwg770




Daveed Vandevoorde
-
d:cwg771
CWG771
9 February 2009
CD2
Move-construction of reference members of closure objects
https://wg21.link/cwg771




Jonathan Caves
-
d:cwg772
CWG772
10 February 2009
CD2
capture-default in lambdas in local default arguments
https://wg21.link/cwg772




Steve Adamczyk
-
d:cwg773
CWG773
11 February 2009
C++11
Parentheses in address non-type template arguments
https://wg21.link/cwg773




Doug Gregor
-
d:cwg774
CWG774
11 February 2009
CD2
Can a closure class be a POD?
https://wg21.link/cwg774




John Spicer
-
d:cwg775
CWG775
12 February 2009
CD2
Capturing references to functions
https://wg21.link/cwg775




Steve Adamczyk
-
d:cwg776
CWG776
12 February 2009
CD2
Delegating constructors, destructors, and std::exit
https://wg21.link/cwg776




Michael Wong
-
d:cwg777
CWG777
13 February 2009
CD2
Default arguments and parameter packs
https://wg21.link/cwg777




Michael Wong
-
d:cwg778
CWG778
13 February 2009
C++11
Template parameter packs in non-type template parameters
https://wg21.link/cwg778




Michael Wong
-
d:cwg779
CWG779
26 February 2009
CD2
Rvalue reference members of closure objects?
https://wg21.link/cwg779




Mike Miller
-
d:cwg78
CWG78
15 December 1998
CD1
Section 8.5 paragraph 9 should state it only applies to non-static objects
https://wg21.link/cwg78




Judy Ward
-
d:cwg780
CWG780
10 February 2009
concepts
Questions regarding the point of definition of a concept map
https://wg21.link/cwg780




James Widman
-
d:cwg781
CWG781
1 March 2009
concepts
Missing requirement in constrained function example
https://wg21.link/cwg781




Daniel Krügler
-
d:cwg782
CWG782
1 March 2009
CD2
Lambda expressions and argument-dependent lookup
https://wg21.link/cwg782




Mike Miller
-
d:cwg783
CWG783
3 March 2009
open
Definition of “argument”
https://wg21.link/cwg783




UK
-
d:cwg784
CWG784
3 March 2009
C++11
List of incompatibilities with the previous Standard
https://wg21.link/cwg784




UK
-
d:cwg785
CWG785
3 March 2009
CD2
“Execution sequence” is inappropriate phraseology
https://wg21.link/cwg785




US/UK
-
d:cwg786
CWG786
3 March 2009
CD2
Definition of “thread”
https://wg21.link/cwg786




US
-
d:cwg787
CWG787
3 March 2009
CD2
Unnecessary lexical undefined behavior
https://wg21.link/cwg787




UK
-
d:cwg788
CWG788
3 March 2009
CD2
Relationship between locale and values of the execution character set
https://wg21.link/cwg788




FR
-
d:cwg789
CWG789
3 March 2009
CD2
Deprecating trigraphs
https://wg21.link/cwg789




UK
-
d:cwg79
CWG79
15 December 1998
dup
Alignment and placement new
https://wg21.link/cwg79




Herb Sutter
-
d:cwg790
CWG790
3 March 2009
CD2
Concatenation of raw and non-raw string literals
https://wg21.link/cwg790




JP
-
d:cwg791
CWG791
3 March 2009
concepts
Linkage of concept names
https://wg21.link/cwg791




FR/UK
-
d:cwg792
CWG792
3 March 2009
CD2
Effects of std::quick_exit
https://wg21.link/cwg792




US
-
d:cwg793
CWG793
3 March 2009
CD2
Use of class members during destruction
https://wg21.link/cwg793




US
-
d:cwg794
CWG794
3 March 2009
extension
Base-derived conversion in member type of pointer-to-member conversion
https://wg21.link/cwg794




CH
-
d:cwg795
CWG795
3 March 2009
NAD
Dependency of lambdas on <functional>
https://wg21.link/cwg795




UK
-
d:cwg796
CWG796
3 March 2009
CD2
Lifetime of a closure object with members captured by reference
https://wg21.link/cwg796




UK
-
d:cwg797
CWG797
3 March 2009
CD2
Converting a no-capture lambda to a function type
https://wg21.link/cwg797




UK
-
d:cwg798
CWG798
3 March 2009
C++11
Overloaded subscript operator described in clause 5
https://wg21.link/cwg798




UK
-
d:cwg799
CWG799
3 March 2009
CD2
Can reinterpret_cast be used to cast an operand to its own type?
https://wg21.link/cwg799




UK
-
d:cwg8
CWG8

CD1
Access to template arguments used in a function return type and in the nested name specifier
https://wg21.link/cwg8




Mike Ball
-
d:cwg80
CWG80
5 December 1998
TC1
Class members with same name as class
https://wg21.link/cwg80




Jason Merrill
-
d:cwg800
CWG800
3 March 2009
NAD
Safely-derived pointers and object pointers converted from function pointers
https://wg21.link/cwg800




UK
-
d:cwg801
CWG801
3 March 2009
CD2
Casting away constness in a cast to rvalue reference type
https://wg21.link/cwg801




UK
-
d:cwg802
CWG802
3 March 2009
concepts
Problems with restrictions on taking the address of a member of a concept map
https://wg21.link/cwg802




UK
-
d:cwg803
CWG803
3 March 2009
CD2
sizeof an enumeration type with a fixed underlying type
https://wg21.link/cwg803




UK
-
d:cwg804
CWG804
3 March 2009
CD2
Deducing the type in new auto(x)
https://wg21.link/cwg804




UK
-
d:cwg805
CWG805
3 March 2009
CD2
Which exception to throw for overflow in array size calculation
https://wg21.link/cwg805




UK
-
d:cwg806
CWG806
3 March 2009
CD2
Enumeration types in integral constant expressions
https://wg21.link/cwg806




UK
-
d:cwg807
CWG807
3 March 2009
NAD
typeid expressions in constant expressions
https://wg21.link/cwg807




UK
-
d:cwg808
CWG808
3 March 2009
CD2
Non-type decl-specifiers versus max-munch
https://wg21.link/cwg808




UK
-
d:cwg809
CWG809
3 March 2009
CD2
Deprecation of the register keyword
https://wg21.link/cwg809




UK
-
d:cwg81
CWG81
27 October 1998
NAD
Null pointers and C compatibility
https://wg21.link/cwg81




Steve Clamage
-
d:cwg810
CWG810
3 March 2009
CD2
Block-scope thread_local variables should be implicitly static
https://wg21.link/cwg810




UK
-
d:cwg811
CWG811
3 March 2009
CD2
Unclear implications of const-qualification
https://wg21.link/cwg811




UK
-
d:cwg812
CWG812
3 March 2009
CD2
Duplicate names in inline namespaces
https://wg21.link/cwg812




JP
-
d:cwg813
CWG813
3 March 2009
open
typename in a using-declaration with a non-dependent name
https://wg21.link/cwg813




UK
-
d:cwg814
CWG814
3 March 2009
CD2
Attribute to indicate that a function throws nothing
https://wg21.link/cwg814




US
-
d:cwg815
CWG815
3 March 2009
CD2
Parameter pack expansion inside attributes
https://wg21.link/cwg815




UK
-
d:cwg816
CWG816
3 March 2009
CD2
Diagnosing violations of [[final]]
https://wg21.link/cwg816




UK
-
d:cwg817
CWG817
3 March 2009
CD2
Meaning of [[final]] applied to a class definition
https://wg21.link/cwg817




US
-
d:cwg818
CWG818
3 March 2009
CD2
Function parameter packs in non-final positions
https://wg21.link/cwg818




US
-
d:cwg819
CWG819
3 March 2009
NAD
Access control and deleted implicitly-declared special member functions
https://wg21.link/cwg819




US
-
d:cwg82
CWG82
31 December 1998
dup
Definition of "using" a constant expression
https://wg21.link/cwg82




Bill Gibbons
-
d:cwg820
CWG820
3 March 2009
CD2
Deprecation of export
https://wg21.link/cwg820




UK
-
d:cwg821
CWG821
3 March 2009
concepts
Exported concept map templates?
https://wg21.link/cwg821




UK
-
d:cwg822
CWG822
3 March 2009
NAD
Additional contexts for template aliases
https://wg21.link/cwg822




UK
-
d:cwg823
CWG823
3 March 2009
CD2
Literal types with constexpr conversions as non-type template arguments
https://wg21.link/cwg823




FR
-
d:cwg824
CWG824
3 March 2009
concepts
Constrained special member functions
https://wg21.link/cwg824




US
-
d:cwg825
CWG825
3 March 2009
concepts
TriviallyCopyableType concept
https://wg21.link/cwg825




JP
-
d:cwg826
CWG826
3 March 2009
concepts
Accept boolean constant expressions as constraints
https://wg21.link/cwg826




JP
-
d:cwg827
CWG827
3 March 2009
concepts
Use of && as requirement separator
https://wg21.link/cwg827




US
-
d:cwg828
CWG828
3 March 2009
CD2
Destruction of exception objects
https://wg21.link/cwg828




UK
-
d:cwg829
CWG829
3 March 2009
NAD
At what point is std::unexpected called?
https://wg21.link/cwg829




UK
-
d:cwg83
CWG83
24 January 1999
TC1
Overloading and deprecated conversion of string literal
https://wg21.link/cwg83




Steve Adamczyk
-
d:cwg830
CWG830
3 March 2009
CD2
Deprecating exception specifications
https://wg21.link/cwg830




UK
-
d:cwg831
CWG831
3 March 2009
CD2
Limit on recursively nested template instantiations
https://wg21.link/cwg831




DE
-
d:cwg832
CWG832
3 March 2009
CD2
Value of preprocessing numbers
https://wg21.link/cwg832




UK
-
d:cwg833
CWG833
6 March 2009
CD2
Explicit conversion of a scoped enumeration value to a floating type
https://wg21.link/cwg833




John Spicer
-
d:cwg834
CWG834
6 March 2009
CD2
What is an “ordinary string literal”?
https://wg21.link/cwg834




Mike Miller
-
d:cwg835
CWG835
5 March 2009
CD2
Scoped enumerations and the “usual arithmetic conversions”
https://wg21.link/cwg835




Beman Dawes
-
d:cwg836
CWG836
7 March 2009
NAD
[[noreturn]] applied to function types
https://wg21.link/cwg836




Joseph Myers
-
d:cwg837
CWG837
11 March 2009
C++11
Constexpr functions and return braced-init-list
https://wg21.link/cwg837




Mike Miller
-
d:cwg838
CWG838
12 March 2009
C++11
Use of this in a brace-or-equal-initializer
https://wg21.link/cwg838




Daveed Vandevoorde
-
d:cwg839
CWG839
9 March 2009
dup
sizeof with opaque enumerations
https://wg21.link/cwg839




Alberto Ganesh Barbati
-
d:cwg84
CWG84
10 December 1998
TC1
Overloading and conversion loophole used by auto_ptr
https://wg21.link/cwg84




Steve Adamczyk
-
d:cwg840
CWG840
13 March 2009
CD2
Rvalue references as nontype template parameters
https://wg21.link/cwg840




Steve Adamczyk
-
d:cwg841
CWG841
20 March 2009
concepts
Ill-formed concept refinement example
https://wg21.link/cwg841




James Widman
-
d:cwg842
CWG842
20 March 2009
CD2
Casting to rvalue reference type
https://wg21.link/cwg842




Steve Adamczyk
-
d:cwg843
CWG843
19 March 2009
concepts
Unclear interaction of constraints and special member functions
https://wg21.link/cwg843




Alisdair Meredith
-
d:cwg844
CWG844
20 March 2009
concepts
Is a constrained member function a template?
https://wg21.link/cwg844




Daniel Krügler
-
d:cwg845
CWG845
20 March 2009
CD2
What is the “first declaration” of an explicit specialization?
https://wg21.link/cwg845




Daveed Vandevoorde
-
d:cwg846
CWG846
23 March 2009
CD2
Rvalue references to functions
https://wg21.link/cwg846




Daniel Krügler
-
d:cwg847
CWG847
27 March 2009
CD2
Error in rvalue reference deduction example
https://wg21.link/cwg847




Steve Adamczyk
-
d:cwg848
CWG848
31 March 2009
concepts
Unconstrained template template parameters in constrained contexts
https://wg21.link/cwg848




James Widman
-
d:cwg849
CWG849
31 March 2009
concepts
Constraints and template template parameters
https://wg21.link/cwg849




James Widman
-
d:cwg85
CWG85
25 January 1999
TC1
Redeclaration of member class
https://wg21.link/cwg85




Steve Adamczyk
-
d:cwg850
CWG850
1 April 2009
CD2
Restrictions on use of non-static data members
https://wg21.link/cwg850




Jason Merrill
-
d:cwg851
CWG851
1 April 2009
concepts
Constraints and template aliases
https://wg21.link/cwg851




James Widman
-
d:cwg852
CWG852
2 April 2009
open
using-declarations and dependent base classes
https://wg21.link/cwg852




Michael Wong
-
d:cwg853
CWG853
3 April 2009
CD2
Support for relaxed pointer safety
https://wg21.link/cwg853




Jens Maurer
-
d:cwg854
CWG854
5 April 2009
CD2
Left shift and unsigned extended types
https://wg21.link/cwg854




Daniel Krügler
-
d:cwg855
CWG855
5 April 2009
CD2
Incorrect comments in braced-init-list assignment example
https://wg21.link/cwg855




Daniel Krügler
-
d:cwg856
CWG856
5 April 2009
concepts
Overlapping concept and requirements scopes
https://wg21.link/cwg856




James Widman
-
d:cwg857
CWG857
5 April 2009
concepts
Implying requirements from enclosing scopes
https://wg21.link/cwg857




James Widman
-
d:cwg858
CWG858
6 April 2009
CD2
Example binding an rvalue reference to an lvalue
https://wg21.link/cwg858




Daniel Krügler
-
d:cwg859
CWG859
6 April 2009
concepts
Incomplete comment in late_check example
https://wg21.link/cwg859




Daniel Krügler
-
d:cwg86
CWG86
January 1999
CD1
Lifetime of temporaries in query expressions
https://wg21.link/cwg86




Steve Adamczyk
-
d:cwg860
CWG860
6 April 2009
C++11
Explicit qualification of constexpr member functions
https://wg21.link/cwg860




Daniel Krügler
-
d:cwg861
CWG861
7 April 2009
CD2
Unintended ambiguity in inline namespace lookup
https://wg21.link/cwg861




Michael Wong
-
d:cwg862
CWG862
7 April 2009
CD2
Undefined behavior with enumerator value overflow
https://wg21.link/cwg862




Daniel Krügler
-
d:cwg863
CWG863
7 April 2009
CD2
Rvalue reference cast to incomplete type
https://wg21.link/cwg863




Steve Adamczyk
-
d:cwg864
CWG864
7 April 2009
C++11
braced-init-list in the range-based for statement
https://wg21.link/cwg864




James Widman
-
d:cwg865
CWG865
8 April 2009
CD2
Initializing a std::initializer_list
https://wg21.link/cwg865




James Widman
-
d:cwg866
CWG866
8 April 2009
concepts
Concept maps and the range-based for
https://wg21.link/cwg866




James Widman
-
d:cwg867
CWG867
13 April 2009
concepts
Naming a specialization of a constrained template
https://wg21.link/cwg867




James Widman
-
d:cwg868
CWG868
13 April 2009
concepts
Specifying a concept map in the name of a specialization
https://wg21.link/cwg868




James Widman
-
d:cwg869
CWG869
14 April 2009
CD2
Uninitialized thread_local objects
https://wg21.link/cwg869




Daniel Krügler
-
d:cwg87
CWG87
25 January 1999
CD1
Exception specifications on function parameters
https://wg21.link/cwg87




Steve Adamczyk
-
d:cwg870
CWG870
14 April 2009
concepts
Context of expression when satisfying an associated function requirement
https://wg21.link/cwg870




James Widman
-
d:cwg871
CWG871
15 April 2009
concepts
Satisfying associated functions with built-in operators
https://wg21.link/cwg871




James Widman
-
d:cwg872
CWG872
16 April 2009
CD2
Lexical issues with raw strings
https://wg21.link/cwg872




Joseph Myers
-
d:cwg873
CWG873
16 April 2009
C++11
Deducing rvalue references in declarative contexts
https://wg21.link/cwg873




John Spicer
-
d:cwg874
CWG874
16 April 2009
CD2
Class-scope definitions of enumeration types
https://wg21.link/cwg874




Daniel Krügler
-
d:cwg875
CWG875
19 April 2009
concepts
Associated conversion functions converting to the same type
https://wg21.link/cwg875




Daniel Krügler
-
d:cwg876
CWG876
20 April 2009
CD2
Type references in rvalue reference deduction specification
https://wg21.link/cwg876




Steve Adamczyk
-
d:cwg877
CWG877
23 April 2009
CD2
Viable functions and binding references to rvalues
https://wg21.link/cwg877




Daniel Krügler
-
d:cwg878
CWG878
25 April 2009
concepts
Effective class types in built-in pointer-to-member operator
https://wg21.link/cwg878




Daniel Krügler
-
d:cwg879
CWG879
25 April 2009
CD2
Missing built-in comparison operators for pointer types
https://wg21.link/cwg879




Daniel Krügler
-
d:cwg88
CWG88
20 January 1999
NAD
Specialization of member constant templates
https://wg21.link/cwg88




Jason Merrill
-
d:cwg880
CWG880
25 April 2009
CD2
Built-in conditional operator for scoped enumerations
https://wg21.link/cwg880




Daniel Krügler
-
d:cwg881
CWG881
25 April 2009
concepts
Inconsistent requirement for naming template parameters
https://wg21.link/cwg881




Daniel Krügler
-
d:cwg882
CWG882
27 April 2009
CD2
Defining main as deleted
https://wg21.link/cwg882




Steve Adamczyk
-
d:cwg883
CWG883
29 April 2009
CD2
std::memcpy vs std::memmove
https://wg21.link/cwg883




Lawrence Crowl
-
d:cwg884
CWG884
29 April 2009
CD2
Defining an explicitly-specialized static data member
https://wg21.link/cwg884




Daniel Krügler
-
d:cwg885
CWG885
1 May 2009
NAD
Partial ordering of function templates with unordered parameter pairs
https://wg21.link/cwg885




Mike Miller
-
d:cwg886
CWG886
5 May 2009
CD2
Member initializers and aggregates
https://wg21.link/cwg886




Daniel Krügler
-
d:cwg887
CWG887
6 May 2009
CD2
Move construction of thrown object
https://wg21.link/cwg887




Steve Adamczyk
-
d:cwg888
CWG888
6 May 2009
CD2
Union member initializers
https://wg21.link/cwg888




Alisdair Meredith
-
d:cwg889
CWG889
4 May 2009
concepts
Default implementations of associated functions
https://wg21.link/cwg889




Daniel Krügler
-
d:cwg89
CWG89
27 October 1998
TC1
Object lifetime does not account for reference rebinding
https://wg21.link/cwg89




AFNOR
-
d:cwg890
CWG890
6 May 2009
concepts
Missing requirement in example
https://wg21.link/cwg890




Daniel Krügler
-
d:cwg891
CWG891
8 May 2009
CD2
const_cast to rvalue reference from objectless rvalue
https://wg21.link/cwg891




Steve Adamczyk
-
d:cwg892
CWG892
8 May 2009
C++11
Missing requirements for constexpr constructors
https://wg21.link/cwg892




Alisdair Meredith
-
d:cwg893
CWG893
8 May 2009
NAD
Brace syntax for enumerator-definitions
https://wg21.link/cwg893




Alisdair Meredith
-
d:cwg894
CWG894
8 May 2009
concepts
Incorrect example for constrained overload resolution
https://wg21.link/cwg894




Daniel Krügler
-
d:cwg895
CWG895
8 May 2009
concepts
Missing destructor requirements
https://wg21.link/cwg895




Daniel Krügler
-
d:cwg896
CWG896
9 May 2009
CD2
Rvalue references and rvalue-reference conversion functions
https://wg21.link/cwg896




Steve Adamczyk
-
d:cwg897
CWG897
9 May 2009
open
_Pragma and extended string-literals
https://wg21.link/cwg897




Daniel Krügler
-
d:cwg898
CWG898
9 May 2009
C++11
Declarations in constexpr functions
https://wg21.link/cwg898




Daniel Krügler
-
d:cwg899
CWG899
13 May 2009
CD2
Explicit conversion functions in direct class initialization
https://wg21.link/cwg899




Jason Merrill
-
d:cwg9
CWG9

CD1
Clarification of access to base class members
https://wg21.link/cwg9




unknown
-
d:cwg90
CWG90
2 February 1999
TC1
Should the enclosing class be an "associated class" too?
https://wg21.link/cwg90




John Spicer
-
d:cwg900
CWG900
12 May 2009
extension
Lifetime of temporaries in range-based for
https://wg21.link/cwg900




Thomas J. Gritzan
-
d:cwg901
CWG901
20 May 2009
drafting
Deleted operator delete
https://wg21.link/cwg901




John Spicer
-
d:cwg902
CWG902
21 May 2009
NAD
In-class initialization of non-constant static data members
https://wg21.link/cwg902




Daniel Krügler
-
d:cwg903
CWG903
22 May 2009
CD3
Value-dependent integral null pointer constants
https://wg21.link/cwg903




Doug Gregor
-
d:cwg904
CWG904
23 May 2009
CD2
Parameter packs in lambda-captures
https://wg21.link/cwg904




Faisal Vali
-
d:cwg905
CWG905
27 May 2009
CD2
Explicit defaulted copy constructors and trivial copyability
https://wg21.link/cwg905




Daveed Vandevoorde
-
d:cwg906
CWG906
27 May 2009
CD2
Which special member functions can be defaulted?
https://wg21.link/cwg906




Daveed Vandevoorde
-
d:cwg907
CWG907
28 May 2009
concepts
Default types in requirements in auto concepts
https://wg21.link/cwg907




James Widman
-
d:cwg908
CWG908
2 June 2009
CD2
Deleted global allocation and deallocation functions
https://wg21.link/cwg908




John Spicer
-
d:cwg909
CWG909
2 June 2009
NAD
Old-style casts with conversion functions
https://wg21.link/cwg909




Daniel Krügler
-
d:cwg91
CWG91
2 February 1999
NAD
A union's associated types should include the union itself
https://wg21.link/cwg91




John Spicer
-
d:cwg910
CWG910
4 June 2009
CD2
Move constructors and implicitly-declared copy constructors
https://wg21.link/cwg910




Daveed Vandevoorde
-
d:cwg911
CWG911
6 June 2009
concepts
late_check and concept map templates
https://wg21.link/cwg911




Daniel Krügler
-
d:cwg912
CWG912
7 June 2009
CD3
Character literals and universal-character-names
https://wg21.link/cwg912




Alisdair Meredith
-
d:cwg913
CWG913
10 June 2009
CD2
Deduction rules for array- and function-type conversion functions
https://wg21.link/cwg913




Steve Clamage
-
d:cwg914
CWG914
10 June 2009
extension
Value-initialization of array types
https://wg21.link/cwg914




Gabriel Dos Reis
-
d:cwg915
CWG915
12 June 2009
CD2
Deleted specializations of member function templates
https://wg21.link/cwg915




Daveed Vandevoorde
-
d:cwg916
CWG916
12 June 2009
open
Does a reference type have a destructor?
https://wg21.link/cwg916




James Widman
-
d:cwg917
CWG917
12 June 2009
concepts
Pointer conversions between archetypes
https://wg21.link/cwg917




James Widman
-
d:cwg918
CWG918
19 June 2009
concepts
Declaration/expression ambiguity in associated function expressions
https://wg21.link/cwg918




James Widman
-
d:cwg919
CWG919
19 June 2009
CD2
Contradictions regarding inline namespaces
https://wg21.link/cwg919




Michael Wong
-
d:cwg92
CWG92
2 February 1999
CD4
Should exception-specifications be part of the type system?
https://wg21.link/cwg92




Jonathan Schilling
-
d:cwg920
CWG920
19 June 2009
CD2
Interaction of inline namespaces and using-declarations
https://wg21.link/cwg920




Michael Wong
-
d:cwg921
CWG921
19 June 2009
CD2
Unclear specification of inline namespaces
https://wg21.link/cwg921




Michael Wong
-
d:cwg922
CWG922
19 June 2009
CD2
Implicit default constructor definitions and const variant members
https://wg21.link/cwg922




Daveed Vandevoorde
-
d:cwg923
CWG923
19 June 2009
CD2
Inline explicit specializations
https://wg21.link/cwg923




Daveed Vandevoorde
-
d:cwg924
CWG924
23 June 2009
C++11
alias-declaration as a class member
https://wg21.link/cwg924




Alisdair Meredith
-
d:cwg925
CWG925
29 June 2009
open
Type of character literals in preprocessor expressions
https://wg21.link/cwg925




Michael Wong
-
d:cwg926
CWG926
29 June 2009
CD2
Inline unnamed namespaces
https://wg21.link/cwg926




Michael Wong
-
d:cwg927
CWG927
1 July 2009
CD2
Implicitly-deleted default constructors and member initializers
https://wg21.link/cwg927




Alisdair Meredith
-
d:cwg928
CWG928
1 July 2009
CD2
Defaulting a function that would be implicitly defined as deleted
https://wg21.link/cwg928




Alisdair Meredith
-
d:cwg929
CWG929
2 July 2009
CD2
What is a template alias?
https://wg21.link/cwg929




Alisdair Meredith
-
d:cwg93
CWG93
6 February 1999
TC1
Missing word in 3.8 basic.life paragraph 2
https://wg21.link/cwg93




Mike Miller
-
d:cwg930
CWG930
6 July 2009
CD2
alignof with incomplete array type
https://wg21.link/cwg930




Alisdair Meredith
-
d:cwg931
CWG931
6 July 2009
CD2
Confusing reference to the length of a user-defined string literal
https://wg21.link/cwg931




Alisdair Meredith
-
d:cwg932
CWG932
7 July 2009
CD2
UCNs in closing delimiters of raw string literals
https://wg21.link/cwg932




Alisdair Meredith
-
d:cwg933
CWG933
7 July 2009
CD2
32-bit UCNs with 16-bit wchar_t
https://wg21.link/cwg933




Alisdair Meredith
-
d:cwg934
CWG934
8 July 2009
CD2
List-initialization of references
https://wg21.link/cwg934




Mike Miller
-
d:cwg935
CWG935
9 July 2009
CD2
Missing overloads for character types for user-defined literals
https://wg21.link/cwg935




Alisdair Meredith
-
d:cwg936
CWG936
11 July 2009
CD2
Array initialization with new string literals
https://wg21.link/cwg936




Alisdair Meredith
-
d:cwg937
CWG937
11 July 2009
NAD
Restrictions on values of template arguments in user-defined literals
https://wg21.link/cwg937




Alisdair Meredith
-
d:cwg938
CWG938
12 July 2009
C++11
Initializer lists and array new
https://wg21.link/cwg938




Alisdair Meredith
-
d:cwg939
CWG939
14 July 2009
CD2
Explicitly checking virtual function overriding
https://wg21.link/cwg939




FI/US
-
d:cwg94
CWG94
8 February 1999
TC1
Inconsistencies in the descriptions of constant expressions
https://wg21.link/cwg94




Mike Miller
-
d:cwg940
CWG940
14 July 2009
CD2
Global anonymous unions
https://wg21.link/cwg940




UK
-
d:cwg941
CWG941
14 July 2009
C++11
Explicit specialization of deleted function template
https://wg21.link/cwg941




Spicer
-
d:cwg942
CWG942
14 July 2009
CD2
Is this an entity?
https://wg21.link/cwg942




Maurer
-
d:cwg943
CWG943
14 July 2009
DRWP
Is T() a temporary?
https://wg21.link/cwg943




Miller
-
d:cwg944
CWG944
15 July 2009
extension
reinterpret_cast for all types with the same size and alignment
https://wg21.link/cwg944




Miller
-
d:cwg945
CWG945
18 July 2009
C++11
Use of this in a late-specified return type
https://wg21.link/cwg945




Alisdair Meredith
-
d:cwg946
CWG946
28 July 2009
CD2
Order of destruction of local static objects and calls to std::atexit
https://wg21.link/cwg946




Fraser Ross
-
d:cwg947
CWG947
27 July 2009
NAD
Deducing type template arguments from default function arguments
https://wg21.link/cwg947




Dave Abrahams
-
d:cwg948
CWG948
2 August 2009
C++11
constexpr in conditions
https://wg21.link/cwg948




Gabriel Dos Reis
-
d:cwg949
CWG949
2 August 2009
open
Requirements for freestanding implementations
https://wg21.link/cwg949




Detlef Vollman
-
d:cwg95
CWG95
9 February 1999
NAD
Elaborated type specifiers referencing names declared in friend decls
https://wg21.link/cwg95




John Spicer
-
d:cwg950
CWG950
3 August 2009
CD2
Use of decltype as a class-name
https://wg21.link/cwg950




Alisdair Meredith
-
d:cwg951
CWG951
5 August 2009
CD2
Problems with attribute-specifiers
https://wg21.link/cwg951




Sean Hunt
-
d:cwg952
CWG952
7 August 2009
drafting
Insufficient description of “naming class”
https://wg21.link/cwg952




James Widman
-
d:cwg953
CWG953
18 August 2009
CD2
Rvalue references and function viability
https://wg21.link/cwg953




Mike Miller
-
d:cwg954
CWG954
19 August 2009
open
Overload resolution of conversion operator templates with built-in types
https://wg21.link/cwg954




Steve Clamage
-
d:cwg955
CWG955
19 August 2009
CD2
Can a closure type's operator() be virtual?
https://wg21.link/cwg955




Daniel Krügler
-
d:cwg956
CWG956
21 August 2009
CD2
Function prototype scope with late-specified return types
https://wg21.link/cwg956




Daveed Vandevoorde
-
d:cwg957
CWG957
26 August 2009
CD2
Alternative tokens and attribute-tokens
https://wg21.link/cwg957




Daveed Vandevoorde
-
d:cwg958
CWG958
31 August 2009
NAD
Lambdas and decltype
https://wg21.link/cwg958




Jason Merrill
-
d:cwg959
CWG959
31 August 2009
CD2
Alignment attribute for class and enumeration types
https://wg21.link/cwg959




Daveed Vandevoorde
-
d:cwg96
CWG96
16 February 1999
C++11
Syntactic disambiguation using the template keyword
https://wg21.link/cwg96




John Spicer
-
d:cwg960
CWG960
1 September 2009
CD2
Covariant functions and lvalue/rvalue references
https://wg21.link/cwg960




James Widman
-
d:cwg961
CWG961
2 September 2009
CD2
Overload resolution and conversion of std::nullptr_t to bool
https://wg21.link/cwg961




Mike Miller
-
d:cwg962
CWG962
2 September 2009
CD2
Attributes appertaining to class and enum types
https://wg21.link/cwg962




Daveed Vandevoorde
-
d:cwg963
CWG963
8 September 2009
CD2
Comparing nullptr with 0
https://wg21.link/cwg963




Mike Miller
-
d:cwg964
CWG964
14 September 2009
C++11
Incorrect description of when the lvalue-to-rvalue conversion applies
https://wg21.link/cwg964




Doug Gregor
-
d:cwg965
CWG965
15 September 2009
CD2
Limiting the applicability of the carries_dependency attribute
https://wg21.link/cwg965




Daveed Vandevoorde
-
d:cwg966
CWG966
15 September 2009
CD2
Nested types without linkage
https://wg21.link/cwg966




Jason Merrill
-
d:cwg967
CWG967
15 September 2009
NAD
Exception specification of replacement allocation function
https://wg21.link/cwg967




Steve Clamage
-
d:cwg968
CWG968
23 September 2009
CD2
Syntactic ambiguity of the attribute notation
https://wg21.link/cwg968




Daveed Vandevoorde
-
d:cwg969
CWG969
29 December 2008
CD2
Explicit instantiation declarations of class template specializations
https://wg21.link/cwg969




Jason Merrill
-
d:cwg97
CWG97
18 February 1999
NAD
Use of bool constants in integral constant expressions
https://wg21.link/cwg97




Andy Koenig
-
d:cwg970
CWG970
28 September 2009
CD2
Consistent use of “appertain” and “apply”
https://wg21.link/cwg970




Daveed Vandevoorde
-
d:cwg971
CWG971
28 September 2009
C++11
Incorrect treatment of exception-declarations
https://wg21.link/cwg971




Mike Miller
-
d:cwg972
CWG972
5 October 2009
C++11
Allowing multiple attribute-specifiers
https://wg21.link/cwg972




Daveed Vandevoorde
-
d:cwg973
CWG973
12 October 2009
CD2
Function types in exception-specifications
https://wg21.link/cwg973




Daniel Krügler
-
d:cwg974
CWG974
4 September 2009
CD3
Default arguments for lambdas
https://wg21.link/cwg974




Jason Merrill
-
d:cwg975
CWG975
4 September 2009
CD3
Restrictions on return type deduction for lambdas
https://wg21.link/cwg975




Jason Merrill
-
d:cwg976
CWG976
1 October 2009
CD2
Deduction for const T& conversion operators
https://wg21.link/cwg976




Jens Maurer
-
d:cwg977
CWG977
3 October 2009
CD3
When is an enumeration type complete?
https://wg21.link/cwg977




Daniel Krügler
-
d:cwg978
CWG978
5 October 2009
CD2
Incorrect specification for copy initialization
https://wg21.link/cwg978




Daniel Krügler
-
d:cwg979
CWG979
8 October 2009
CD2
Position of attribute-specifier in declarator syntax
https://wg21.link/cwg979




Daveed Vandevoorde
-
d:cwg98
CWG98
23 February 1999
TC1
Branching into try block
https://wg21.link/cwg98




Jack Rouse
-
d:cwg980
CWG980
14 October 2009
CD2
Explicit instantiation of a member of a class template
https://wg21.link/cwg980




Doug Gregor
-
d:cwg981
CWG981
16 October 2009
C++11
Constexpr constructor templates and literal types
https://wg21.link/cwg981




Gabriel Dos Reis
-
d:cwg982
CWG982
17 October 2009
NAD
Initialization with an empty initializer list
https://wg21.link/cwg982




Daniel Krügler
-
d:cwg983
CWG983
19 October 2009
CD2
Ambiguous pointer-to-member constant
https://wg21.link/cwg983




Daniel Krügler
-
d:cwg984
CWG984
19 October 2009
CD2
“Deduced type” is unclear in auto type deduction
https://wg21.link/cwg984




Michael Wong
-
d:cwg985
CWG985
19 October 2009
C++11
Alternative tokens and user-defined literals
https://wg21.link/cwg985




Michael Wong
-
d:cwg986
CWG986
19 October 2009
CD2
Transitivity of using-directives versus qualified lookup
https://wg21.link/cwg986




Michael Wong
-
d:cwg987
CWG987
19 October 2009
CD4
Which declarations introduce namespace members?
https://wg21.link/cwg987




Michael Wong
-
d:cwg988
CWG988
19 October 2009
CD2
Reference-to-reference collapsing with decltype
https://wg21.link/cwg988




Michael Wong
-
d:cwg989
CWG989
20 October 2009
CD2
Misplaced list-initialization example
https://wg21.link/cwg989




Daniel Krügler
-
d:cwg99
CWG99
5 March 1999
NAD
Partial ordering, references and cv-qualifiers
https://wg21.link/cwg99




Mike Miller
-
d:cwg990
CWG990
20 October 2009
CD2
Value initialization with multiple initializer-list constructors
https://wg21.link/cwg990




Daniel Krügler
-
d:cwg991
CWG991
20 October 2009
CD2
Reference parameters of constexpr functions and constructors
https://wg21.link/cwg991




Gabriel Dos Reis
-
d:cwg992
CWG992
24 October 2009
NAD
Inheriting explicitness
https://wg21.link/cwg992




Lawrence Crowl
-
d:cwg993
CWG993
6 March 2009
C++11
Freedom to perform instantiation at the end of the translation unit
https://wg21.link/cwg993




John Spicer
-
d:cwg994
CWG994
25 October 2009
C++11
braced-init-list as a default argument
https://wg21.link/cwg994




Daniel Krügler
-
d:cwg995
CWG995
27 October 2009
CD2
Incorrect example for using-declaration and explicit instantiation
https://wg21.link/cwg995




Doug Gregor
-
d:cwg996
CWG996
28 October 2009
C++11
Ambiguous partial specializations of member class templates
https://wg21.link/cwg996




Doug Gregor
-
d:cwg997
CWG997
6 November 2009
C++11
Argument-dependent lookup and dependent function template parameter types
https://wg21.link/cwg997




James Widman
-
d:cwg998
CWG998
8 November 2009
dup
Function parameter transformations and template functions
https://wg21.link/cwg998




Jason Merrill
-
d:cwg999
CWG999
20 November 2009
CD2
“Implicit” or “implied” object argument/parameter?
https://wg21.link/cwg999




James Widman
-
