C++ Standard Core Language Issue Index by Status, Revision 74


This document contains a summary listing of all the C++ Core Language Issues grouped by status. It is part of a group of related documents that together describe the issues that have been raised regarding the C++ Standard. The other documents in the group are:

For more information, including a description of the meaning of the issue status codes and instructions on reporting new issues, please see the Active Issues List.

Section references in this document reflect the section numbering of document PL22.16/10-0116 = WG21 N3126.




Index by Status




Issues with "Ready" Status:

Issue Section Title
573 5.2.10 Conversions between function pointers and void*
981 3.9 Constexpr constructor templates and literal types
1022 7.2 Can an enumeration variable have values outside the values of the enumeration?
1071 3.9 Literal class types and trivial default constructors
1073 15.4 Merging dynamic-exception-specifications and noexcept-specifications
1080 12.8 Confusing relationship between templates and copy constructors
1081 12.4 Defaulted destructor and unusable operator delete
1094 5.2.9 Converting floating-point values to scoped enumeration types
1111 3.4.5 Remove dual-scope lookup of member template names
1120 5.2.10 reinterpret_cast and void*
1135 8.4.2 Explicitly-defaulted non-public special member functions
1136 8.4.2 Explicitly-defaulted explicit constructors
1137 8.4.2 Explicitly-defaulted virtual special member functions
1140 9 Incorrect redefinition of POD class
1145 12.1 Defaulting and triviality
1149 12.8 Trivial non-public copy operators in subobjects
1151 13.3.1.7 Overload resolution with initializer-list and non-list constructors
1167 15.4 function-try-blocks for destructors
1187 3.6.2 Problems in initialization example
1193 5.19 Use of address-constant pointers in constant expressions
1198 3.9 Literal types and copy constructors
1208 9.3.1 Explicit noexcept in defaulted definition


Issues with "Tentatively Ready" Status:

Issue Section Title


Issues with "Review" Status:

Issue Section Title
111 12.8 Copy constructors and cv-qualifiers
236 5.19 Explicit temporaries and integral constant expressions
240 4.1 Uninitialized values and undefined behavior
292 5.3.4 Deallocation on exception in new before arguments evaluated
342 5.3 Terminology: "indirection" versus "dereference"
388 15.3 Catching base*& from a throw of derived*
395 12.3.2 Conversion operator template syntax
462 12.2 Lifetime of temporaries bound to comma expressions
482 8.3 Qualified declarators in redeclarations
512 9.5 Union members with user-declared non-default constructors
531 14.7.3 Defining members of explicit specializations
535 12.8 Copy construction without a copy constructor
539 7.1.6 Constraints on type-specifier-seq
547 8.3.5 Partial specialization on member function types
554 3.3 Definition of “declarative region” and “scope”
555 3.4 Pseudo-destructor name lookup
572 4 Standard conversions for non-built-in types
597 3.8 Conversions applied to out-of-lifetime non-POD lvalues
602 14.6.1 When is the injected-class-name of a class template a template?
712 3.2 Are integer constant operands of a conditional-expression “used?”
729 15.3 Qualification conversions and handlers of reference-to-pointer type
758 3.1 Missing cases of declarations that are not definitions
778 14.1 Template parameter packs in non-type template parameters
997 3.4.2 Argument-dependent lookup and dependent function template parameter types
1004 14.6.1 Injected-class-names as arguments for template template parameters
1015 3.4.2 Template arguments and argument-dependent lookup
1054 6.2 Lvalue-to-rvalue conversions in expression statements
1056 14.5.7 Template aliases, member definitions, and the current instantiation
1057 14.6.2.1 decltype and the current instantiation
1058 8.5.3 Reference binding of incompatible array types
1074 14.6.2.3 Value-dependent noexcept-expressions
1079 13.3.3.2 Overload resolution involving aggregate initialization
1088 14.6.2.3 Dependent non-type template arguments
1095 8.5.4 List-initialization of references
1098 5.19 Pointer conversions in constant expressions
1099 5.19 Infinite recursion in constexpr functions
1101 9.4.2 Non-integral initialized static data members
1174 3.2 When is a pure virtual function “used?”
1175 2.14.8 Disambiguating user-defined literals
1176 1.10 Definition of release sequence
1177 1.10 Intra-thread dependency-ordered-before
1178 14.8.2.6 Deduction failure matching placement new
1180 3.11 Over-aligned class types
1182 14.5.3 Incorrect description of pack expansion syntax
1183 8.3.5 Expansion of parameter packs in declarators
1185 7.5 Misleading description of language linkage and member function types
1186 7.1.5 Non-dependent constexpr violations in function templates
1188 5.19 Type punning in constant expressions
1189 1.8 Address of distinct base class subobjects
1190 3.7.4.3 Operations on non-safely-derived pointers
1192 3.2 Inadvertent change to ODR and templates
1194 7.1.5 Constexpr references
1195 7.1.5 References to non-literal types in constexpr functions
1196 14.7.2 Definition required for explicit instantiation after explicit specialization?
1197 5.19 Constexpr arrays
1201 3.1 Are deleted and defaulted functions definitions?
1204 6.5 Specifiers in a for-range-declaration
1206 14.5.1 Defining opaque enumeration members of class templates
1212 7.1.6.2 Non-function-call xvalues and decltype
1215 9 Definition of POD struct
1216 15.4 Exceptions “allowed” by a noexcept-specification
1218 15.3 What is the “currently-handled exception” in a multi-threaded program?
1219 3.9 Non-static data member initializers in constant expressions
1224 12.8 constexpr defaulted copy constructors
1225 7.1.5 constexpr constructors and virtual bases


Issues with "Drafting" Status:

Issue Section Title
2 14.6.4 How can dependent names be used in member declarations that appear outside of the class template definition?
138 7.3.1.2 Friend declaration name lookup
156 3.4.5 Name lookup for conversion functions
170 4.11 Pointer-to-member conversions
189 2.13 Definition of operator and punctuator
205 14 Templates and static data members
212 14.7.1 Implicit instantiation is not described clearly enough
225 3.4.2 Koenig lookup and fundamental types
232 5.3.1 Is indirection through a null pointer undefined behavior?
233 8.5.3 References vs pointers in UDC overload resolution
260 13.6 User-defined conversions and built-in operator=
287 14.6.4.1 Order dependencies in template instantiation
314 14.2 template in base class specifier
355 9 Global-scope :: in nested-name-specifier
369 2.5 Are new/delete identifiers or preprocessing-op-or-punc?
393 8.3.5 Pointer to array of unknown bound in template argument list in parameter
399 12.4 Destructor lookup redux
407 7.1.3 Named class with associated typedef: two names or one?
426 3.5 Identically-named variables, one internally and one externally linked, allowed?
453 8.3.2 References may only bind to “valid” objects
472 11.5 Casting across protected inheritance
529 14.7.3 Use of template<> with “explicitly-specialized” class templates
536 5.1.1 Problems in the description of id-expressions
549 14.5.5.1 Non-deducible parameters in partial specializations
560 14.6 Use of the typename keyword in return types
580 11 Access in template-parameters of member and friend definitions
617 4.1 Lvalue-to-rvalue conversions of uninitialized char objects
636 3.10 Dynamic type of objects and aliasing
682 3.4.5 Missing description of lookup of template aliases
692 14.8.2.5 Partial ordering of variadic class template partial specializations
696 9.8 Use of block-scope constants in local classes
837 7.1.5 Constexpr functions and return braced-init-list
901 5.3.4 Deleted operator delete
938 8.5.1 Initializer lists and array new
952 11.2 Insufficient description of “naming class”
993 14.6.4.1 Freedom to perform instantiation at the end of the translation unit
996 14.5.5 Ambiguous partial specializations of member class templates
1005 9.3.1 Qualified name resolution in member functions of class templates
1017 9.3.1 Member access transformation in unevaluated operands
1018 7 Ambiguity between simple-declaration and attribute-declaration
1027 3.8 Type consistency and reallocation of scalar types
1028 14.6.4 Dependent names in non-defining declarations
1030 8.5.1 Evaluation order in initializer-lists used in aggregate initialization
1031 7.6.1 Optional elements in attributes
1032 14.5.3 Empty pack expansions
1033 7.6.2 Restrictions on alignment attributes
1035 9.2 Omitted and required decl-specifiers
1042 7 Attributes in alias-declarations
1043 14.6.2.1 Qualified name lookup in the current instantiation
1044 3.3.2 Point of declaration for an alias-declaration
1055 3.9.1 Permissible uses of void
1059 3.9.3 Cv-qualified array types (with rvalues)
1060 5.19 Scoped enumerators in integral constant expressions
1068 14.1 Template aliases with default arguments and template parameter packs
1082 12.8 Implicit copy function if subobject has none?
1089 3.4.5 Template parameters in member selections
1090 3.11 Alignment of subobjects
1091 5.5 Inconsistent use of the term “object expression”
1096 14 Missing requirement for template definitions
1100 5.19 constexpr conversion functions and non-type template arguments
1109 3.2 When is “use” a reference to the ODR meaning?
1116 3.8 Aliasing of union members
1127 5.19 Overload resolution in constexpr functions
1170 14.8.2 Access checking during template argument deduction
1172 14.8.2 “instantiation-dependent” constructs
1181 3.9 What is a “built-in type?”
1184 14.8.2.1 Argument conversions to nondeduced parameter types
1191 12.1 Deleted subobject destructors and implicitly-defined constructors
1199 7.1.5 Deleted constexpr functions
1202 12.7 Calling virtual functions during destruction
1207 9.3.1 Type of class member in trailing-return-type
1210 3.3.2 Injection of elaborated-type-specifier in enumeration scope
1211 3.11 Misaligned lvalues
1214 8.5 Kinds of initializers
1220 3.4.5 Looking up conversion-type-ids


Issues with "Open" Status:

Issue Section Title
6 12.8 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?
23 14.5.6.2 Some questions regarding partial ordering of function templates
36 7.3.3 using-declarations in multiple-declaration contexts
57 9.5 Empty unions
92 15.4 Should exception specifications be part of the type system?
110 14 Can template functions and classes be declared in the same scope?
129 1.9 Stability of uninitialized auto variables
144 7.1.6.3 Position of friend specifier
146 3.9.1 Floating-point zero
150 14.3.3 Template template parameters and default arguments
157 7 Omitted typedef declarator
186 14.6.1 Name hiding and template template-parameters
191 3.4.1 Name lookup does not handle complex nesting
192 3.4.1 Name lookup in parameters
196 5.3.5 Arguments to deallocation functions
203 5.3.1 Type of address-of-member expression
219 15.5.1 Cannot defend against destructors that throw exceptions
223 D The meaning of deprecation
230 10.4 Calls to pure virtual functions
238 5 Precision and accuracy constraints on floating point
242 5.4 Interpretation of old-style casts
251 3.9.1 How many signed integer types are there?
253 8.5 Why must empty or fully-initialized const objects be initialized?
255 12.5 Placement deallocation functions and lookup ambiguity
264 14.8.1 Unusable template constructors and conversion functions
267 5.3.4 Alignment requirement for new-expressions
268 16.3.4 Macro name suppression in rescanned replacement text
271 14.8.2 Explicit instantiation and template argument deduction
278 3.5 External linkage and nameless entities
279 3.5 Correspondence of "names for linkage purposes"
282 5.2.8 Namespace for extended_type_info
293 14.7.2 Syntax of explicit instantiation/specialization too permissive
297 14.8.2 Which template does an explicit specialization specialize?
310 14.5.6.1 Can function templates differing only in parameter cv-qualifiers be overloaded?
312 3.7.4.2 “use” of invalid pointer value not defined
321 3.4.2 Associated classes and namespaces for argument-dependent lookup
325 8.3.6 When are default arguments parsed?
330 4.4 Qualification conversions and pointers to arrays of pointers
332 8.3.5 cv-qualified void parameter types
338 3.5 Enumerator name with linkage used as class name in other translation unit
343 14.2 Make template optional in contexts that require a type
344 12.4 Naming destructors
350 3.9 signed char underlying representation for objects
360 11.2 Using-declaration that reduces access
361 8.3.6 Forward reference to default argument
365 3.7 Storage duration and temporaries
371 3.6.2 Interleaving of constructor calls
380 10.2 Definition of "ambiguous base class" missing
386 7.3.3 Friend declaration of name brought in by using-declaration
402 14.5.6.2 More on partial ordering of function templates
405 3.4.1 Unqualified function name lookup
411 2.14.5 Use of universal-character-name in character versus string literals
418 13.3.3 Imperfect wording on error on multiple default arguments on a called function
419 3.8 Can cast to virtual base class be done on partially-constructed object?
440 14.3 Allow implicit pointer-to-member conversion on nontype template argument
455 13.3.3 Partial ordering and non-deduced arguments
459 14.6.1 Hiding of template parameters by base class members
473 5.3.4 Block-scope declarations of allocator functions
476 5.3.4 Determining the buffer size for placement new
483 3.9.1 Normative requirements on integral ranges
496 3.9 Is a volatile-qualified type really a POD?
498 7.1.1 Storage class specifiers in definitions of class members
503 14.8.2.1 Cv-qualified function types in template argument deduction
504 8.3.2 Should use of a reference in its own initializer require a diagnostic?
511 9 POD-structs with template assignment operators
523 3.7.4.2 Can a one-past-the-end pointer be invalidated by deleting an adjacent object?
528 5.2.8 Why are incomplete class types not allowed with typeid?
545 13.3.1.2 User-defined conversions and built-in operator overload resolution
550 8.3.5 Pointer to array of unknown bound in parameter declarations
562 3.4.3.1 qualified-ids in non-expression contexts
563 7.5 Linkage specification for objects
565 7.3.3 Conflict rules for using-declarations naming function templates
577 8.3.5 void in an empty parameter list
578 2.2 Phase 1 replacement of characters with universal-character-names
579 14.2 What is a “nested” > or >>?
581 12.1 Can a templated constructor be explicitly instantiated or specialized?
583 5.9 Relational pointer comparisons against the null pointer constant
590 14.6.2.1 Nested classes and the “current instantiation”
591 14.6.2 When a dependent base class is the current instantiation
595 15.4 Exception specifications in templates instantiated from class bodies
596 15.5.2 Replacing an exception object
600 11 Does access control apply to members or to names?
607 12.6.2 Lookup of mem-initializer-ids
609 7.1.6.1 What is a “top-level” cv-qualifier?
611 8.5 Zero-initializing references
616 1.3 Definition of “indeterminate value”
631 6.4.1 Jumping into a “then” clause
640 3.6.3 Accessing destroyed local objects of static storage duration
670 8.5 Copy initialization via derived-to-base conversion in the second step
675 9.6 Signedness of bit-field with typedef or template parameter type
689 3.9.1 Maximum values of signed and unsigned integers
697 14.8.2 Deduction rules apply to more than functions
698 1.9 The definition of “sequenced before” is too narrow
708 14.5.5 Partial specialization of member templates of class templates
718 11.4 Non-class, non-function friend declarations
739 9.6 Signedness of plain bit-fields
742 5.2.6 Postfix increment/decrement with long bit-field operands
745 16.5 Effect of ill-formedness resulting from #error
747 11.2 Access of protected base classes
783 1.3 Definition of “argument”
784 1.5 List of incompatibilities with the previous Standard
798 5.2.1 Overloaded subscript operator described in clause 5
813 7.3.3 typename in a using-declaration with a non-dependent name
838 12.6.2 Use of this in a brace-or-equal-initializer
852 7.3.3 using-declarations and dependent base classes
897 16.9 _Pragma and extended string-literals
903 14.6.2.3 Value-dependent integral null pointer constants
912 2.14.3 Character literals and universal-character-names
916 _N2914_.14.10.2.1 Does a reference type have a destructor?
925 16.1 Type of character literals in preprocessor expressions
943 5.2.3 Is T() a temporary?
944 5.2.10 reinterpret_cast for all types with the same size and alignment
945 5.1.1 Use of this in a late-specified return type
949 1.4 Requirements for freestanding implementations
954 13.6 Overload resolution of conversion operator templates with built-in types
967 3.7.4 Exception specification of replacement allocation function
971 15.3 Incorrect treatment of exception-declarations
974 5.1.2 Default arguments for lambdas
975 5.1.2 Restrictions on return type deduction for lambdas
977 7.2 When is an enumeration type complete?
985 2.6 Alternative tokens and user-defined literals
987 7.3 Which declarations introduce namespace members?
1003 3.6.1 Acceptable definitions of main
1013 4.1 Uninitialized std::nullptr_t objects
1021 7.3.1.2 Definitions of namespace members
1024 2.14.3 Limits on multicharacter literals
1038 13.4 Overload resolution of &x.static_func
1046 14.7.2 What is a “use” of a class specialization?
1049 12.8 Copy elision through reference parameters of inline functions
1063 7.6.5 [[hiding]] with non-attribute declarations
1076 3.10 Value categories and lvalue temporaries
1092 12.8 Cycles in overload resolution during instantiation
1093 8.5 Value-initializing non-objects
1108 2.14.8 User-defined literals have not been implemented
1115 3.11 C-compatible alignment specification
1133 7.6.5 Keywords vs attributes for control of hiding and overriding
1141 9.2 Non-static data member initializers have not been implemented
1143 9.3.1 Move semantics for *this have not been implemented
1150 12.9 Inheriting constructors have not been implemented
1157 14.5.6.2 Partial ordering of function templates is still underspecified
1166 15.3 exception-declarations that do not declare objects
1200 3.4.1 Lookup rules for template parameters
1209 3.2 Is a potentially-evaluated expression in a template definition a “use?”
1213 5.2.1 Array subscripting and xvalues
1221 14.8.2.4 Partial ordering and reference collapsing
1222 8.3.4 Unnecessary restriction on auto array types
1223 6.8 Syntactic disambiguation and trailing-return-types
1226 8.3.6 Converting a braced-init-list default argument


Issues with "Dup" Status:

Issue Section Title
12 3.4.2 Default arguments on different declarations for the same function and the Koenig lookup
15 8.3.6 Default arguments for parameters of function templates
72 14 Linkage and storage class specifiers for templates
79 18.6.1.3 Alignment and placement new
82 3.2 Definition of "using" a constant expression
133 15.4 Exception specifications and checking
155 8.5 Brace initializer for scalar
200 14.5.6.2 Partial ordering and explicit arguments
265 5.3.5 Destructors, exceptions, and deallocation
313 5.3.4 Class with single conversion function to integral as array size in new
375 14.6 Confusing example on lookup with typename
507 13.6 Ambiguity assigning class object to built-in type
548 8.3 qualified-ids in declarations
839 5.3.3 sizeof with opaque enumerations
998 8.3.5 Function parameter transformations and template functions
1019 10 Dependent simple-template-ids in base-specifiers and mem-initializers
1041 9.2 alias-declarations as class members


Issues with "NAD" Status:

Issue Section Title
3 14.7.3 The template compilation model rules render some explicit specialization declarations not visible during instantiation
7 11.2 Can a class with a private virtual base class be derived from?
14 7.5 extern "C" functions and declarations in different namespaces
17 11.2 Footnote 99 should discuss the naming class when describing members that can be accessed from friends
18 8.3.5 f(TYPE) where TYPE is void should be allowed
19 11.5 Clarify protected member access
26 12.8 Copy constructors and default arguments
27 13.6 Overload ambiguities for builtin ?: prototypes
31 5.3.4 Looking up new/delete
34 14.7.1 Argument dependent lookup and points of instantiation
37 15.5.3 When is uncaught_exception() true?
42 3.3.7 Redefining names from base classes
46 14.7.2 Explicit instantiation of member templates
47 14.5.4 Template friend issues
50 3.2 Converting pointer to incomplete type to same type
55 5.7 Adding/subtracting pointer and enumeration value
61 13.4 Address of static member function "&p->f"
66 8.3.6 Visibility of default args vs overloads added after using-declaration
71 5 Incorrect cross reference
81 C Null pointers and C compatability
88 14.7.3 Specialization of member constant templates
91 3.4.2 A union's associated types should include the union itself
95 7.3.1.2 Elaborated type specifiers referencing names declared in friend decls
97 5.19 Use of bool constants in integral constant expressions
99 14.8.2.1 Partial ordering, references and cv-qualifiers
102 13.3.1.2 Operator lookup rules do not work well with parts of the library
104 15.1 Destroying the exception temp when no handler is found
107 7.5 Linkage of operator functions
109 7.3.3 Allowing ::template in using-declarations
114 14.5.2 Virtual overriding by template member function specializations
117 12.2 Timing of destruction of temporaries
130 5.3.4 Sequence points and new-expressions
132 3.5 Local types and linkage
154 7.1.1 Anonymous unions in unnamed namespaces
165 7.3.1.2 Definitions of friends and block-scope externs
167 D.2 Deprecating static functions
168 7.5 C linkage for static member functions
169 7.3.3 template-ids in using-declarations
174 D.2 Undeprecating global static
182 14.7.3 Access checking on explicit specializations
209 11.4 Must friend declaration names be accessible?
211 15 Constructors should not be allowed to return normally after an exception
229 14.5.5 Partial specialization of function templates
231 3.4.1 Visibility of names after using-directives
234 3.8 Reuse of base class subobjects
243 13.3.3.1.2 Weighting of conversion functions in direct-initialization
247 13.4 Pointer-to-member casts and function overload resolution
266 A No grammar sentence symbol
269 3.6.2 Order of initialization of multiply-defined static data members of class templates
285 14.7.3 Identifying a function template being specialized
290 3.9 Should memcpy be allowed into a POD with a const member?
294 5.2.9 Can static_cast drop exception specifications?
303 4.5 Integral promotions on bit-fields
307 12.7 Initialization of a virtual base class subobject
308 15.3 Catching exceptions with ambiguous base classes
311 7.3.1 Using qualified name to reopen nested namespace
315 9.4.1 Is call of static member function through null pointer undefined?
316 14.6.1 Injected-class-name of template used as template template parameter
333 8.2 Ambiguous use of "declaration" in disambiguation section
334 14.6.2.2 Is a comma-expression dependent if its first operand is?
340 8.2 Unclear wording in disambiguation section
346 15.4 Typo in 15.4
347 9.7 Use of derived class name in defining base class nested class
356 12.8 Wording of behavior of generated copy constructor for scalar members
358 7.5 Namespaces and extern "C"
359 9.5 Type definition in anonymous union
363 12.6.1 Initialization of class from self
376 7.1.2 Class "definition" versus class "declaration"
384 3.4.2 Argument-dependent lookup and operator functions
412 7.1.2 Can a replacement allocation function be inline?
422 7.1.3 Is a typedef redeclaration allowed with a template type that might be the same?
423 13.3.1.2 Can a conversion be done on the left operand of a compound assignment?
434 8.5.3 Unclear suppression of standard conversions while binding reference to lvalue
435 7 Change "declararation or definition" to "declaration"
444 12.8 Overriding and the generated copy assignment operator
445 11.4 Wording issue on friend declarations
449 1.3 Consistency in use of hyphen with names of "non" entities
456 4.10 Is initialized const int or const bool variable a null pointer constant?
461 7.4 Make asm conditionally-supported
465 3.6.2 May constructors of global objects call exit()?
467 6.7 Jump past initialization of local static variable
469 14.8.2.5 Const template specializations and reference arguments
471 11.2 Conflicting inherited access specifications
478 8.3.4 May a function parameter be an array of an abstract class type?
487 5.19 Operator overloading in constant expressions
489 14.7.1 Must member function templates be instantiated during overload resolution?
501 11.4 Visibility of friend declarations within the befriending class
533 16.2 Special treatment for C-style header names
544 14.6.2 Base class lookup in explicit specialization
552 14.2 Use of typename in the type in a non-type parameter-declaration
553 7.3.1.2 Problems with friend allocation and deallocation functions
566 4.9 Conversion of negative floating point values to integer type
567 5.7 Can size_t and ptrdiff_t be larger than long?
574 12.8 Definition of “copy assignment operator”
584 3.10 Unions and aliasing
585 11.4 Friend template template parameters
586 14.8.2.5 Default template-arguments and template argument deduction
593 15.3 Falling off the end of a destructor's function-try-block handler
610 5.3.1 Computing the negative of 0U
627 3.9.1 Values behaving as types
635 3.4.3.1 Names of constructors and destructors of templates
643 7.1.6.2 Use of decltype in a class member-specification
646 3.9 Can a class with a constexpr copy constructor be a literal type?
662 14.8.2 Forming a pointer to a reference type
669 7.1.6.2 Confusing specification of the meaning of decltype
673 7.3.1.2 Injection of names from elaborated-type-specifiers in friend declarations
706 7.1.6.4 Use of auto with rvalue references
733 12.8 Reference qualification of copy assignment operators
736 8 Is the & ref-qualifier needed?
795 5.1.2 Dependency of lambdas on <functional>
800 5.2.10 Safely-derived pointers and object pointers converted from function pointers
807 5.19 typeid expressions in constant expressions
819 12 Access control and deleted implicitly-declared special member functions
829 15.4 At what point is std::unexpected called?
836 7.6.3 [[noreturn]] applied to function types
885 14.8.2.4 Partial ordering of function templates with unordered parameter pairs
893 7.2 Brace syntax for enumerator-definitions
900 12.2 Lifetime of temporaries in range-based for
902 9.4.2 In-class initialization of non-constant static data members
909 5.4 Old-style casts with conversion functions
937 2.14.8 Restrictions on values of template arguments in user-defined literals
958 5.1.2 Lambdas and decltype
982 8.5.4 Initialization with an empty initializer list
992 12.8 Inheriting explicitness
1001 8.3.5 Parameter type adjustment in dependent parameter types
1002 14.5.3 Pack expansion for function arguments
1007 11.5 Protected access and pointers to members
1014 14.8.2.1 Overload resolution between const T& and T&&
1026 3.10 Cv-qualified non-class rvalues
1040 1.10 Memory model issues
1045 14.7.2 Requiring explicit instantiation declarations
1050 3.8 Effects of thread support on object lifetime
1053 15.4 Terminate vs undefined behavior for noexcept violation
1067 7.6.5 [[hiding]], using-declarations, and multiple inheritance
1078 8.5.4 Narrowing and the usual arithmetic conversions
1084 12.8 Conditions for a deleted move function
1085 12.8 Move assignment operators and virtual bases
1097 8.5.1 Aggregate initialization of function parameters
1110 3.2 Incomplete return type should be allowed in decltype operand
1118 5.1.2 Implicit lambda capture via explicit copy constructor
1124 5.5 Error in description of value category of pointer-to-member expression
1132 7.6.3 Keyword vs attribute for noreturn
1162 14.6 Dependent elaborated-type-specifiers in non-deduced contexts
1163 14.7.2 extern template prevents inlining functions not marked inline
1179 14.1 Cv-qualification of non-type template parameters
1217 8.4.3 Are deleted functions implicitly noexcept?


Issues with "Concepts" Status:

Issue Section Title
723 6.7 Archetypes in skipped declarations
724 3.4.3 Qualified name lookup in a constrained context
725 8.3.5 When should the requirement for std::Returnable<T>, etc., apply?
748 _N2914_.14.11.2.1 Always-complete archetypes
780 _N2914_.14.10.2 Questions regarding the point of definition of a concept map
781 _N2914_.14.11.2 Missing requirement in constrained function example
791 3.5 Linkage of concept names
802 5.3.1 Problems with restrictions on taking the address of a member of a concept map
821 14 Exported concept map templates?
824 14.5.1 Constrained special member functions
825 _N2914_.14.10.4 TriviallyCopyableType concept
826 _N2914_.14.11.1 Accept boolean constant expressions as constraints
827 _N2914_.14.11.1 Use of && as requirement separator
841 _N2914_.14.10.3.2 Ill-formed concept refinement example
843 14.5.1 Unclear interaction of constraints and special member functions
844 9.2 Is a constrained member function a template?
848 _N2914_.14.11 Unconstrained template template parameters in constrained contexts
849 14.3.3 Constraints and template template parameters
851 14.5.7 Constraints and template aliases
856 _N2960_.3.3.9 Overlapping concept and requirements scopes
857 _N2914_.14.11.1.2 Implying requirements from enclosing scopes
859 _N2960_.6.9 Incomplete comment in late_check example
866 6.5.4 Concept maps and the range-based for
867 14.2 Naming a specialization of a constrained template
868 14.2 Specifying a concept map in the name of a specialization
870 _N2914_.14.10.2.1 Context of expression when satisfying an associated function requirement
871 _N2914_.14.10.2.1 Satisfying associated functions with built-in operators
875 12.3.2 Associated conversion functions converting to the same type
878 13.6 Effective class types in built-in pointer-to-member operator
881 14.1 Inconsistent requirement for naming template parameters
889 _N2914_.14.10.1.1 Default implementations of associated functions
890 _N2914_.14.11.1.1 Missing requirement in example
894 _N2914_.14.11.4 Incorrect example for constrained overload resolution
895 _N2914_.14.11.2.1 Missing destructor requirements
907 _N2914_.14.10.2.2 Default types in requirements in auto concepts
911 _N2914_.14.10.2 late_check and concept map templates
917 4.10 Pointer conversions between archetypes
918 _N2914_.14.10.2.1 Declaration/expression ambiguity in associated function expressions


Issues with "Extension" Status:

Issue Section Title
13 7.5 extern "C" for Parameters of Function Templates
622 5.9 Relational comparisons of arbitrary pointers
623 3.7.4.2 Use of pointers to deallocated storage
687 5.1.1 template keyword with unqualified-ids
727 14.7.3 In-class explicit specializations
728 14 Restrictions on local classes
755 5.1.2 Generalized lambda-captures
794 4.11 Base-derived conversion in member type of pointer-to-member conversion
822 14 Additional contexts for template aliases
898 7.1.5 Declarations in constexpr functions
914 5.2.3 Value-initialization of array types
947 14.8.3 Deducing type template arguments from default function arguments
1008 5.3.6 Querying the alignment of an object
1048 5.1.2 auto deduction and lambda return type deduction.
1077 7.3.1.2 Explicit specializations in non-containing namespaces


Issues with "DR" Status:

Issue Section Title
248 _N2691_.E Identifier characters
341 7.5 extern "C" namespace member function versus global variable
694 8.5 Zero- and value-initialization of union objects
964 3.10 Incorrect description of when the lvalue-to-rvalue conversion applies
972 7.6.1 Allowing multiple attribute-specifiers
994 8.3.5 braced-init-list as a default argument
1006 14.1 std::nullptr_t as a non-type template parameter
1009 14 Missing cases in the declarator-id of a function template declaration
1011 5.2.9 Standard conversions that cannot be inverted
1012 7.3.1.1 Undeprecating static
1016 13 Overloadable declarations, function templates, and references
1020 12.8 Implicitly-defined copy constructors and explicit base class constructors
1025 14.3.2 Use of a reference as a non-type template argument
1029 12.4 Type of a destructor call
1034 5.1.2 Attributes for return statements in lambdas
1036 7.6.2 Alignment attribute in an exception-declaration
1037 5.3.5 Requirements for operands of delete-expressions and deallocation functions
1047 14.6.2.3 When is typeid value-dependent?
1051 12.8 Reference members and generated copy constructors
1061 5.3.4 Negative array bounds in a new-expression
1062 5.1.2 Syntax of attribute-specifiers in lambdas
1064 12.8 Defaulted move constructor for a union
1065 7.6.5 [[hiding]] with [[override]]
1066 12.8 When is a copy/move assignment operator implicitly defined?
1069 8.3.5 Incorrect function type with trailing-return-type
1070 8.5.1 Missing initializer clauses in aggregate initialization
1072 9.2 Scoped enumerator with the same name as its containing class
1075 7.1.6.2 Grammar does not allow template alias in type-name
1083 5.2.2 Passing an object to ellipsis with non-trivial move constructor
1086 5.2.11 const_cast to rvalue reference to function type
1087 13.3.1.4 Additional applications of issue 899
1102 1.9 Better example of undefined behavior
1103 2.2 Reversion of phase 1 and 2 transformations in raw string literals
1104 2.6 Global-scope template arguments vs the <: digraph
1105 2.11 Issues relating to TR 10176:2003
1106 2.14.7 Need more detail in nullptr keyword description
1107 2.14.8 Overload resolution for user-defined integer literals
1112 3.5 constexpr variables should have internal linkage like const
1113 3.5 Linkage of namespace member of unnamed namespace
1114 3.8 Incorrect use of placement new in example
1117 5 Incorrect note about xvalue member access expressions
1119 5.2.5 Missing case in description of member access ambiguity
1121 5.3.1 Unnecessary ambiguity error in formation of pointer to member
1122 5.3.3 Circular definition of std::size_t
1123 5.3.7 Destructors should be noexcept by default
1125 5.19 Unclear definition of “potential constant expression”
1126 5.19 constexpr functions in const initializers
1128 7.1 attribute-specifiers in decl-specifier-seqs
1129 7.1.5 Default nothrow for constexpr functions
1130 7.1.6.2 Function parameter type adjustments and decltype
1131 7.1.6.3 Template aliases in elaborated-type-specifiers
1134 8.4.2 When is an explicitly-defaulted function defined?
1138 8.5.3 Rvalue-ness check for rvalue reference binding is wrong
1139 8.5.3 Rvalue reference binding to scalar xvalues
1142 9.3 friend declaration of member function of containing class
1144 11.3 Remove access declarations
1146 12.4 exception-specifications of defaulted functions
1147 12.4 Destructors should be default nothrow
1148 12.8 Copy elision and move construction of function parameters
1152 13.3.2 Rules for determining existence of implicit conversion sequence
1153 13.4 Type matching in address of overloaded function
1154 14.3.2 Address of thread_local variable as non-type template argument
1155 14.3.2 Internal-linkage non-type template arguments
1156 14.5.6.2 Partial ordering in a non-call context
1158 14.5.7 Recursive instantiation via alias template
1159 14.5.7 Class and enumeration definitions in template aliases
1160 14.6.2.1 Definitions of template members and the current instantiation
1161 14.6 Dependent nested-name-specifier in a pointer-to-member declarator
1164 14.8.2.1 Partial ordering of f(T&) and f(T&&)
1165 15.2 Exceptions when destroying array elements
1168 15.5.1 Additional reasons to call std::terminate
1169 16.8 Missing feature macro for strict pointer safety
1171 15.5.1 Partial stack unwinding with noexcept violation
1173 1.9 Unclear specification of effects of signal handling


Issues with "WP" Status:

Issue Section Title
96 14.2 Syntactic disambiguation using the template keyword
373 3.4.6 Lookup on namespace qualified name in using-directive
431 14.2 Defect in wording in 14.2
448 14.6.1 Set of template functions in call with dependent explicit argument
458 14.6.1 Hiding of member template parameters by other members
475 15.5.3 When is std::uncaught_exception() true? (take 2)
502 14.6.2.1 Dependency of nested enumerations and enumerators
508 8.5 Non-constructed value-initialized objects
532 14.5.6.2 Member/nonmember operator template partial ordering
546 14.7.2 Explicit instantiation of class template members
575 14.8.2 Criteria for deduction failure
605 14.7.3 Linkage of explicit specializations
615 8.5 Incorrect description of variables that can be initialized
619 3.9 Completeness of array types
621 14.7.3 Template argument deduction from function return types
655 12.6.2 Initialization not specified for forwarding constructors
674 14.5.4 “matching specialization” for a friend declaration
676 3.1 static_assert-declarations and general requirements for declarations
678 3.2 Language linkage of member function parameter types and the ODR
691 14.1 Template parameter packs in class template partial specializations
700 7.1.5 Constexpr member functions of class templates
709 14.8.2 Enumeration names as nested-name-specifiers in deduction failure
738 12.1 constexpr not permitted by the syntax of constructor declarations
741 9.6 “plain” long long bit-fields
773 14.3.2 Parentheses in address non-type template arguments
860 7.1.5 Explicit qualification of constexpr member functions
864 6.5.4 braced-init-list in the range-based for statement
873 14.8.2.5 Deducing rvalue references in declarative contexts
892 7.1.5 Missing requirements for constexpr constructors
924 9.2 alias-declaration as a class member
941 14.7.3 Explicit specialization of deleted function template
948 6.4 constexpr in conditions


Issues with "CD1" Status:

Issue Section Title
4 7.5 Does extern "C" affect the linkage of function names with internal linkage?
5 8.5 CV-qualifiers and type conversions
8 11 Access to template arguments used in a function return type and in the nested name specifier
9 11.2 Clarification of access to base class members
10 11.8 Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?
11 7.3.3 How do the keywords typename/template interact with using-declarations?
16 11.2 Access to members of indirect private base classes
28 3.6.3 'exit', 'signal' and static object destruction
29 7.5 Linkage of locally declared functions
39 10.2 Conflicting ambiguity rules
44 14.7.3 Member specializations
45 11.8 Access to nested classes
54 5.2.9 Static_cast from private base to derived class
58 9.6 Signedness of bit fields of enum type
60 13.3.3.1.4 Reference binding and valid conversion sequences
62 14.3.1 Unnamed members of classes used as type parameters
63 14.7.1 Class instantiation from pointer conversion to void*, null and self
70 14.8.2.5 Is an array bound a nondeduced context?
77 11.4 The definition of friend does not allow nested classes to be friends
78 8.5 Section 8.5 paragraph 9 should state it only applies to non-static objects
86 12.2 Lifetime of temporaries in query expressions
87 15.4 Exception specifications on function parameters
106 unknown Creating references to references during template deduction/instantiation
112 8.3.4 Array types and cv-qualifiers
113 5.2.2 Visibility of called function
115 13.4 Address of template-id
118 5.2.2 Calls via pointers to virtual member functions
119 3.8 Object lifetime and aggregate initialization
122 5.1.1 template-ids as unqualified-ids
124 12.2 Lifetime of temporaries in default initialization of class arrays
125 5.1.1 Ambiguity in friend declaration syntax
136 8.3.6 Default arguments and friend declarations
139 3.4.1 Error in friend lookup example
140 8.3.5 Agreement of parameter declarations
141 3.4.5 Non-member function templates in member access expressions
143 3.4.2 Friends and Koenig lookup
158 3.10 Aliasing and qualification conversions
160 8.2 Missing std:: qualification
162 13.3.1.1 (&C::f)() with nonstatic members
172 7.2 Unsigned int as underlying type of enum
175 9 Class name injection and base name access
177 8.5 Lvalues vs rvalues in copy-initialization
180 14.6 typename and elaborated types
184 14.1 Default arguments in template template-parameters
195 5.2.10 Converting between function and object pointers
197 14.6.4.2 Issues with two-stage lookup of dependent names
198 9.8 Definition of "use" in local and nested classes
199 12.2 Order of destruction of temporaries
201 12.2 Order of destruction of temporaries in initializers
204 14 Exported class templates
207 11.2 using-declarations and protected access
208 15.1 Rethrowing exceptions in nested handlers
214 14.5.6.2 Partial ordering of function templates is underspecified
215 14.1 Template parameters are not allowed in nested-name-specifiers
216 3.5 Linkage of nameless class-scope enumeration types
218 3.4.2 Specification of Koenig lookup
220 3.7.4.2 All deallocation functions should be required not to throw
221 13.5.3 Must compound assignment operators be member functions?
222 5 Sequence points and lvalue-returning operators
224 14.6.2.1 Definition of dependent names
226 14.1 Default template arguments for function templates
228 14.2 Use of template keyword with non-member templates
237 14.7.2 Explicit instantiation and base class members
239 13.3.1.1.1 Footnote 116 and Koenig lookup
244 12.4 Destructor lookup
245 3.4.4 Name lookup in elaborated-type-specifiers
246 14.3 Jumps in function-try-block handlers
252 12.4 Looking up deallocation functions in virtual destructors
254 3.4.4 Definitional problems with elaborated-type-specifiers
256 5.3.4 Overflow in size calculations
258 7.3.3 using-declarations and cv-qualifiers
259 14.7 Restrictions on explicit specialization and instantiation
261 3.2 When is a deallocation function "used?"
262 8.3.5 Default arguments and ellipsis
263 12.1 Can a constructor be declared a friend?
270 3.6.2 Order of initialization of static data members of class templates
272 12.4 Explicit destructor invocation and qualified-ids
273 9 POD classes and operator&()
274 3.8 Cv-qualification and char-alias access to out-of-lifetime objects
275 14.7.3 Explicit instantiation/specialization and using-directives
276 6.6 Order of destruction of parameters and temporaries
277 8.5 Zero-initialization of pointers
280 13.3.1.1.2 Access and surrogate call functions
281 7.1.2 inline specifier in friend declarations
283 7.1.6.2 Template type-parameters are not syntactically type-names
284 9 qualified-ids in class declarations
286 14.5.5 Incorrect example in partial specialization
288 5.3.5 Misuse of "static type" in describing pointers
289 3.2 Incomplete list of contexts requiring a complete type
291 8.5.3 Overload resolution needed when binding reference to class rvalue
295 8.3.5 cv-qualifiers on function types
296 12.3.2 Can conversion functions be static?
298 3.4.3.1 T::x when T is cv-qualified
299 5.3.4 Conversion on array bound expression in new
300 14.8.2.5 References to functions in template argument deduction
301 14.2 Syntax for template-name
302 8.5 Value-initialization and generation of default constructor
305 3.4.5 Name lookup in destructor call
306 10.2 Ambiguity by class name injection
309 3 Linkage of entities whose names are not simply identifiers, in introduction
317 7.1.2 Can a function be declared inline after it has been called?
318 3.4.3.1 struct A::A should not name the constructor of A
319 3.5 Use of names without linkage in declaring entities with linkage
320 12.2 Question on copy constructor elision example
322 14.8.2.3 Deduction of reference conversions
323 14 Where must export appear?
324 5.3.1 Can "&" be applied to assignment to bit-field?
326 12.1 Wording for definition of trivial constructor
327 9 Use of "structure" without definition
328 9.2 Missing requirement that class member types be complete
329 14.5.4 Evaluation of friends of templates
331 12.1 Allowed copy constructor signatures
335 14 Allowing export on template members of nontemplate classes
336 14.7.3 Explicit specialization examples are still incorrect
337 14.8.2 Attempt to create array of abtract type should cause deduction to fail
339 5.19 Overload resolution in operand of sizeof in constant expression
345 14.6 Misleading comment on example in templates chapter
348 3.7.4.2 delete and user-written deallocation functions
349 14.8.2.3 Template argument deduction for conversion functions and qualification conversions
351 5 Sequence point error: unspecified or undefined?
352 14.8.2.1 Nondeduced contexts
353 5.3.5 Is deallocation routine called if destructor throws exception in delete?
354 14.3.2 Null as nontype template argument
357 1.3 Definition of signature should include name
362 2.2 Order of initialization in instantiation units
364 13.3.1.1.1 Calling overloaded function with static in set, with no object
366 5.19 String literal allowed in integral constant expression?
367 5.19 throw operator allowed in constant expression?
368 14.8.2 Uses of non-type parameters that should cause deduction to fail
370 16.2 Can #include <...> form be used other than for standard C++ headers?
372 14.3 Is access granted by base class specifiers available in following base class specifiers?
377 7.2 Enum whose enumerators will not fit in any integral type
378 6.6 Wording that says temporaries are declared
379 9 Change "class declaration" to "class definition"
381 3.4.5 Incorrect example of base class member lookup
382 14.6 Allow typename outside of templates
383 9 Is a class with a declared but not defined destructor a POD?
385 11.5 How does protected member check of 11.5 interact with using-declarations?
387 14.6.5 Errors in example in 14.6.5
389 3.5 Unnamed types in entities with linkage
390 10.4 Pure virtual must be defined when implicitly called
391 8.5.3 Require direct binding of short-lived references to rvalues
392 12.2 Use of full expression lvalue before temporary destruction
394 16 identifier-list is never defined
396 7.1.2 Misleading note regarding use of auto for disambiguation
397 7.1.2 Same address for string literals from default arguments in inline functions?
398 14.8.2 Ambiguous wording on naming a type in deduction
400 3.4.3.2 Using-declarations and the "struct hack"
401 14.1 When is access for template parameter default arguments checked?
403 3.4.2 Reference to a type as a template-id
404 3.8 Unclear reference to construction with non-trivial constructor
406 9.4.2 Static data member in class with name for linkage purposes
409 14.6 Obsolete paragraph missed by changes for issue 224
410 14.5.4 Paragraph missed in changes for issue 166
413 9 Definition of "empty class"
414 3.4.5 Multiple types found on destructor lookup
415 14.8.3 Template deduction does not cause instantiation
416 13.3.1.2 Class must be complete to allow operator lookup?
417 9.1 Using derived-class qualified name in out-of-class nested class definition
420 13.5.6 postfixexpression->scalar_type_dtor() inconsistent
421 5.2.5 Is rvalue.field an rvalue?
424 7.1.3 Wording problem with issue 56 resolution on redeclaring typedefs in class scope
425 13.6 Set of candidates for overloaded built-in operator with float operand
427 5.2.9 static_cast ambiguity: conversion versus cast to derived
428 15.1 Mention of expression with reference type
429 5.3.4 Matching deallocation function chosen based on syntax or signature?
430 8.5.1 Ordering of expression evaluation in initializer list
432 3.3.7 Is injected class name visible in base class specifier list?
433 3.3.2 Do elaborated type specifiers in templates inject into enclosing namespace scope?
436 9.6 Problem in example in 9.6 paragraph 4
437 9.2 Is type of class allowed in member function exception specification?
439 5.2.9 Guarantees on casting pointer back to cv-qualified version of original type
441 3.6.2 Ordering of static reference initialization
442 5.3.5 Incorrect use of null pointer constant in description of delete operator
443 12.2 Wording nit in description of lifetime of temporaries
446 5.16 Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?
447 14.6.2.3 Is offsetof type-dependent?
450 8.5.3 Binding a reference to const to a cv-qualified array rvalue
451 5 Expressions with invalid results and ill-formedness
452 9.3.2 Wording nit on description of this
454 9.4.2 When is a definition of a static data member required?
457 5.19 Wording nit on use of const variables in constant expressions
460 7.3.3 Can a using-declaration name a namespace?
463 5.2.10 reinterpret_cast<T*>(0)
464 12.2 Wording nit on lifetime of temporaries to which references are bound
466 5.2.4 cv-qualifiers on pseudo-destructor type
468 14.2 Allow ::template outside of templates
470 14.7.2 Instantiation of members of an explicitly-instantiated class template
474 3.5 Block-scope extern declarations in namespace members
477 7.1.2 Can virtual appear in a friend declaration?
479 15.1 Copy elision in exception handling
480 4.11 Is a base of a virtual base also virtual?
484 10 Can a base-specifier name a cv-qualified class type?
485 3 What is a “name”?
486 14.8.2 Invalid return types and template argument deduction
488 14.8.2 Local types, overload resolution, and template argument deduction
491 8.5.1 Initializers for empty-class aggregrate members
492 5.2.8 typeid constness inconsistent with example
494 11 Problems with the resolution of issue 45
497 5.5 Missing required initialization in example
500 11.4 Access in base-specifiers of friend and nested classes
505 2.14.3 Conditionally-supported behavior for unknown character escapes
506 5.2.2 Conditionally-supported behavior for non-POD objects passed to ellipsis
509 8.5 Dead code in the specification of default initialization
510 12.6 Default initialization of POD classes?
513 1.8 Non-class “most-derived” objects
514 3.4.1 Is the initializer for a namespace member in the scope of the namespace?
515 14.6.2 Non-dependent references to base class members
516 7.1.6.2 Use of signed in bit-field declarations
517 14.5.5 Partial specialization following explicit instantiation
518 7.2 Trailing comma following enumerator-list
519 4.10 Null pointer preservation in void* conversions
520 5.4 Old-style casts between incomplete class types
521 3.7.4.1 Requirements for exceptions thrown by allocation functions
522 14.8.2.1 Array-to-pointer decay in template argument deduction
524 14.6.2 Can function-notation calls to operator functions be dependent?
525 14.7.1 Missing * in example
526 14.8.2.5 Confusing aspects in the specification of non-deduced contexts
530 5.19 Nontype template arguments in constant expressions
534 14 template-names and operator-function-ids
537 1.3 Definition of “signature”
538 9 Definition and usage of structure, POD-struct, POD-union, and POD class
540 7.3.1 Propagation of cv-qualifiers in reference-to-reference collapse
543 8.5 Value initialization and default constructors
551 14.7.2 When is inline permitted in an explicit instantiation?
557 3.4.2 Does argument-dependent lookup cause template instantiation?
558 2.3 Excluded characters in universal character names
559 14.6 Editing error in issue 382 resolution
568 9 Definition of POD is too strict
582 14.5.2 Template conversion functions
592 15.2 Exceptions during construction of local static objects
594 3.8 Coordinating issues 119 and 404 with delegating constructors
603 14.4 Type equivalence and unsigned overflow
606 14.8.2.1 Template argument deduction for rvalue references
613 9.2 Unevaluated uses of non-static class members
614 5.6 Results of integer / and %
620 9.2 Declaration order in layout-compatible POD structs
624 5.3.4 Overflow in calculating size of allocation
629 7.1.6.4 auto parsing ambiguity
632 8.5.1 Brace-enclosed initializer for scalar member of aggregate
634 5.2.2 Conditionally-supported behavior for non-POD objects passed to ellipsis redux
637 1.9 Sequencing rules and example disagree
639 1.9 What makes side effects “different” from one another?
644 3.9 Should a trivial class type be a literal type?
647 7.1.5 Non-constexpr instances of constexpr constructor templates
648 7.1.5 Constant expressions in constexpr initializers
649 3.11 Optionally ill-formed extended alignment requests
651 7.1.6.2 Problems in decltype specification and examples
654 4.10 Conversions to and from nullptr_t
659 5.3.6 Alignment of function types
660 7.2 Unnamed scoped enumerations
661 5.9 Semantics of arithmetic comparisons
663 _N2691_.E Valid Cyrillic identifier characters
666 14.6 Dependent qualified-ids without the typename keyword
671 5.2.9 Explicit conversion from a scoped enumeration type to integral type
677 12.4 Deleted operator delete and virtual destructors
679 14.4 Equivalence of template-ids and operator function templates
681 8.3.5 Restrictions on declarators with late-specified return types
683 12.8 Requirements for trivial subobject special functions
684 5.19 Constant expressions involving the address of an automatic variable
686 8.1 Type declarations/definitions in type-specifier-seqs and type-ids
688 3.6.2 Constexpr constructors and static initialization


Issues with "CD2" Status:

Issue Section Title
257 12.6.2 Abstract base constructors and virtual base initialization
374 8.3 Can explicit specialization outside namespace use qualified name?
408 14.5.1.3 sizeof applied to unknown-bound array static data member of template
438 5 Possible flaw in wording for multiple accesses to object between sequence points
481 3.3 Scope of template parameters
490 3.4.1 Name lookup in friend declarations
493 14.8.2.3 Type deduction from a bool context
495 13.3.3 Overload resolution with template and non-template conversion functions
499 15.1 Throwing an array of unknown size
527 3.5 Problems with linkage of types
541 14.6.2.2 Dependent function types
542 12.6 Value initialization of arrays of POD-structs
556 5.17 Conflicting requirements for acceptable aliasing
561 14.6.4.2 Internal linkage functions in dependent name lookup
564 7.5 Agreement of language linkage or linkage-specifications?
569 7 Spurious semicolons at namespace scope should be allowed
570 3.2 Are references subject to the ODR?
571 3.5 References declared const
576 7.1.3 Typedefs in function definitions
587 5.16 Lvalue operands of a conditional expression differing only in cv-qualification
588 14.6.2 Searching dependent bases of classes local to function templates
589 8.5.3 Direct binding of class and array rvalues in reference initialization
598 3.4.2 Associated namespaces of overloaded functions and function templates
599 5.3.5 Deleting a null function pointer
601 16.1 Type of literals in preprocessing expressions
604 13.3.1.3 Argument list for overload resolution in copy-initialization
608 10.3 Determining the final overrider of a virtual function
612 1.9 Requirements on a conforming implementation
618 16.1 Casts in preprocessor conditional expressions
625 7.1.6.4 Use of auto as a template-argument
626 16.3.2 Preprocessor string literals
628 7.2 The values of an enumeration with no enumerator
630 2.3 Equality of narrow and wide character values in the basic character set
633 3 Specifications for variables that should also apply to references
638 14.5.4 Explicit specialization and friendship
641 13.3.2 Overload resolution and conversion-to-same-type operators
642 3.3.3 Definition and use of “block scope” and “local scope”
645 9.2 Are bit-field and non-bit-field members layout compatible?
650 12.2 Order of destruction for temporaries bound to the returned value of a function
652 5.19 Compile-time evaluation of floating-point expressions
653 12.8 Copy assignment of unions
656 8.5.3 Direct binding to the result of a conversion operator
657 14.8.2 Abstract class parameter in synthesized declaration
658 5.2.10 Defining reinterpret_cast for pointer types
664 8.5.3 Direct binding of references to non-class rvalue references
665 5.2.7 Problems in the specification of dynamic_cast
667 12.8 Trivial special member functions that cannot be implicitly defined
668 15.5.1 Throwing an exception from the destructor of a local static object
672 5.3.4 Sequencing of initialization in new-expressions
680 12.8 What is a move constructor?
685 4.5 Integral promotion of enumeration ignores fixed underlying type
690 1.3 The dynamic type of an rvalue reference
693 4.2 New string types and deprecated conversion
695 5 Compile-time calculation errors in constexpr functions
699 7.1.5 Must constexpr member functions be defined in the class member-specification?
701 8.3.4 When is the array-to-pointer conversion applied?
702 13.3.3.2 Preferring conversion to std::initializer_list
703 8.5.4 Narrowing for literals that cannot be exactly represented
704 13.3.1.1 To which postfix-expressions does overload resolution apply?
705 3.4.2 Suppressing argument-dependent lookup via parentheses
707 4.9 Undefined behavior in integral-to-floating conversions
710 12.7 Data races during construction
711 7.1.6.4 auto with braced-init-list
713 8.3.5 Unclear note about cv-qualified function types
714 9.4.2 Static const data members and braced-init-lists
715 5.19 Class member access constant expressions
716 9.5 Specifications that should apply only to non-static union data members
717 7.1.1 Unintentional restrictions on the use of thread_local
719 3 Specifications for operator-function-id that should also apply to literal-operator-id
720 5.1.2 Need examples of lambda-expressions
721 5.19 Where must a variable be initialized to be used in a constant expression?
722 5.2.2 Can nullptr be passed to an ellipsis?
726 1.10 Atomic and non-atomic objects in the memory model
730 14.7.3 Explicit specializations of members of non-template classes
731 5.2.5 Omitted reference qualification of member function type
732 8.4 Late-specified return types in function definitions
734 5.2.10 Are unique addresses required for namespace-scope variables?
735 3.7.4.3 Missing case in specification of safely-derived pointers
737 8.5.2 Uninitialized trailing characters in string initialization
740 1.10 Incorrect note on data races
743 5.1.1 Use of decltype in a nested-name-specifier
744 14.3.3 Matching template arguments with template template parameters with parameter packs
746 7.1.6.4 Use of auto in new-expressions
749 13.6 References to function types with a cv-qualifier or ref-qualifier
750 5.1.2 Implementation constraints on reference-only closure objects
751 5.1.2 Deriving from closure classes
752 5.1.2 Name lookup in nested lambda-expressions
753 5.1.2 Array names in lambda capture sets
754 5.1.2 Lambda expressions in default arguments of block-scope function declarations
756 5.1.2 Dropping cv-qualification on members of closure objects
757 3.5 Types without linkage in declarations
759 5.1.2 Destruction of closure objects
760 5.1.1 this inside a nested class of a non-static member function
761 5.1.2 Inferred return type of closure object call operator
762 5.1.2 Name lookup in the compound-statement of a lambda expression
763 5.1.2 Is a closure object's operator() inline?
764 5.1.2 Capturing unused variables in a lambda expression
765 7.1.2 Local types in inline functions with external linkage
766 5.1.2 Where may lambda expressions appear?
767 5.1.2 void and other unnamed lambda-parameters
768 5.1.2 Ellipsis in a lambda parameter list
769 5.1.2 Initialization of closure objects
770 8 Ambiguity in late-specified return type
771 5.1.2 Move-construction of reference members of closure objects
772 5.1.2 capture-default in lambdas in local default arguments
774 5.1.2 Can a closure class be a POD?
775 5.1.2 Capturing references to functions
776 3.6.3 Delegating constructors, destructors, and std::exit
777 8.3.6 Default arguments and parameter packs
779 5.1.2 Rvalue reference members of closure objects?
782 5.1.2 Lambda expressions and argument-dependent lookup
785 1.9 “Execution sequence” is inappropriate phraseology
786 1.10 Definition of “thread”
787 2.2 Unnecessary lexical undefined behavior
788 2.3 Relationship between locale and values of the execution character set
789 2.4 Deprecating trigraphs
790 2.14.5 Concatenation of raw and non-raw string literals
792 3.6.1 Effects of std::quick_exit
793 3.8 Use of class members during destruction
796 5.1.2 Lifetime of a closure object with members captured by reference
797 5.1.2 Converting a no-capture lambda to a function type
799 5.2.10 Can reinterpret_cast be used to cast an operand to its own type?
801 5.2.11 Casting away constness in a cast to rvalue reference type
803 5.3.3 sizeof an enumeration type with a fixed underlying type
804 5.3.4 Deducing the type in new auto(x)
805 5.3.4 Which exception to throw for overflow in array size calculation
806 5.19 Enumeration types in integral constant expressions
808 7.1 Non-type decl-specifiers versus max-munch
809 7.1.1 Deprecation of the register keyword
810 7.1.1 Block-scope thread_local variables should be implicitly static
811 7.1.6.1 Unclear implications of const-qualification
812 7.3.1 Duplicate names in inline namespaces
814 7.6 Attribute to indicate that a function throws nothing
815 7.6.1 Parameter pack expansion inside attributes
816 7.6.4 Diagnosing violations of [[final]]
817 7.6.4 Meaning of [[final]] applied to a class definition
818 8.3.5 Function parameter packs in non-final positions
820 14 Deprecation of export
823 14.3.2 Literal types with constexpr conversions as non-type template arguments
828 15.1 Destruction of exception objects
830 15.4 Deprecating exception specifications
831 B Limit on recursively nested template instantiations
832 2.10 Value of preprocessing numbers
833 5.2.9 Explicit conversion of a scoped enumeration value to a floating type
834 2.14.5 What is an “ordinary string literal”?
835 5 Scoped enumerations and the “usual arithmetic conversions”
840 14.1 Rvalue references as nontype template parameters
842 5.2.10 Casting to rvalue reference type
845 8.4 What is the “first declaration” of an explicit specialization?
846 3.10 Rvalue references to functions
847 14.8.2.1 Error in rvalue reference deduction example
850 5.1.1 Restrictions on use of non-static data members
853 3.7.4.3 Support for relaxed pointer safety
854 5.8 Left shift and unsigned extended types
855 5.17 Incorrect comments in braced-init-list assignment example
858 5 Example binding an rvalue reference to an lvalue
861 3.4.3.2 Unintended ambiguity in inline namespace lookup
862 7.2 Undefined behavior with enumerator value overflow
863 5.2 Rvalue reference cast to incomplete type
865 8.5.4 Initializing a std::initializer_list
869 8.5 Uninitialized thread_local objects
872 2.14.5 Lexical issues with raw strings
874 9.2 Class-scope definitions of enumeration types
876 14.8.2.1 Type references in rvalue reference deduction specification
877 13.3.2 Viable functions and binding references to rvalues
879 13.6 Missing built-in comparison operators for pointer types
880 13.6 Built-in conditional operator for scoped enumerations
882 3.6.1 Defining main as deleted
883 3.9 std::memcpy vs std::memmove
884 14.7.3 Defining an explicitly-specialized static data member
886 8.5.1 Member initializers and aggregates
887 12.8 Move construction of thrown object
888 12.6.2 Union member initializers
891 5.2.11 const_cast to rvalue reference from objectless rvalue
896 8.5.3 Rvalue references and rvalue-reference conversion functions
899 13.3.1.4 Explicit conversion functions in direct class initialization
904 5.1.2 Parameter packs in lambda-captures
905 9 Explicit defaulted copy constructors and trivial copyability
906 8.4 Which special member functions can be defaulted?
908 8.4 Deleted global allocation and deallocation functions
910 12.8 Move constructors and implicitly-declared copy constructors
913 14.8.2.3 Deduction rules for array- and function-type conversion functions
919 7.3.1 Contradictions regarding inline namespaces
920 8.3 Interaction of inline namespaces and using-declarations
921 7.3.1 Unclear specification of inline namespaces
922 12.1 Implicit default constructor definitions and const variant members
923 14.7.3 Inline explicit specializations
926 7.3.1.1 Inline unnamed namespaces
927 12.1 Implicitly-deleted default constructors and member initializers
928 8.4 Defaulting a function that would be implicitly defined as deleted
929 14.5.7 What is a template alias?
930 5.3.6 alignof with incomplete array type
931 2.14.8 Confusing reference to the length of a user-defined string literal
932 2.14.5 UCNs in closing delimiters of raw string literals
933 2.14.3 32-bit UCNs with 16-bit wchar_t
934 8.5.4 List-initialization of references
935 13.5.8 Missing overloads for character types for user-defined literals
936 8.5.2 Array initialization with new string literals
939 10.3 Explicitly checking virtual function overriding
940 7.1.1 Global anonymous unions
942 3 Is this an entity?
946 3.6.3 Order of destruction of local static objects and calls to std::atexit
950 7.1.6.2 Use of decltype as a class-name
951 7.6 Problems with attribute-specifiers
953 13.3.3.1.4 Rvalue references and function viability
955 5.1.2 Can a closure type's operator() be virtual?
956 8.3.5 Function prototype scope with late-specified return types
957 7.6.1 Alternative tokens and attribute-tokens
959 7.6.2 Alignment attribute for class and enumeration types
960 10.3 Covariant functions and lvalue/rvalue references
961 13.3.3.2 Overload resolution and conversion of std::nullptr_t to bool
962 7.1.6.3 Attributes appertaining to class and enum types
963 5.9 Comparing nullptr with 0
965 7.6.6 Limiting the applicability of the carries_dependency attribute
966 3.5 Nested types without linkage
968 7.6.1 Syntactic ambiguity of the attribute notation
969 14.7.2 Explicit instantiation declarations of class template specializations
970 7.6 Consistent use of “appertain” and “apply”
973 15.4 Function types in exception-specifications
976 14.8.2.3 Deduction for const T& conversion operators
978 13.3.3.1 Incorrect specification for copy initialization
979 8 Position of attribute-specifier in declarator syntax
980 14.7.2 Explicit instantiation of a member of a class template
983 5.3.1 Ambiguous pointer-to-member constant
984 7.1.6.4 “Deduced type” is unclear in auto type deduction
986 7.3.4 Transitivity of using-directives versus qualified lookup
988 7.1.6.2 Reference-to-reference collapsing with decltype
989 8.5.4 Misplaced list-initialization example
990 8.5.4 Value initialization with multiple initializer-list constructors
991 7.1.5 Reference parameters of constexpr functions and constructors
995 14.7.2 Incorrect example for using-declaration and explicit instantiation
999 13.3 “Implicit” or “implied” object argument/parameter?
1000 3.4.3.1 Mistaking member typedefs for constructors
1010 5.19 Address of object with dynamic storage duration in constant expression


Issues with "TC1" Status:

Issue Section Title
1 8.3.6 What if two using-declarations refer to the same function but the declarations introduce different default-arguments?
20 12.8 Some clarifications needed for 12.8 para 15
21 14.1 Can a default argument for a template parameter appear in a friend declaration?
22 14.6.4 Template parameter with a default argument that refers to itself
24 14.7.3 Errors in examples in 14.7.3
25 15.4 Exception specifications and pointers to members
30 14.2 Valid uses of "::template"
32 14 Clarification of explicit instantiation of non-exported templates
33 3.4.2 Argument dependent lookup and overloaded functions
35 8.5 Definition of default-initialization
38 14.2 Explicit template arguments and operator functions
40 8.3 Syntax of declarator-id
41 3.4.1 Clarification of lookup of names after declarator-id
43 3.9 Copying base classes (PODs) using memcpy
48 9.4.2 Definitions of unused static members
49 14.1 Restriction on non-type, non-value template arguments
51 13.3.3 Overloading and user-defined conversions
52 5.2.5 Non-static members, member selection and access checking
53 5.2.9 Lvalue-to-rvalue conversion before certain static_casts
56 7.1.3 Redeclaring typedefs within classes
59 13.3.1.4 Clarification of overloading and UDC to reference type
64 14.7.3 Partial ordering to disambiguate explicit specialization
65 8.3.6 Typo in default argument example
67 9.4 Evaluation of left side of object-expression
68 7.1.6.3 Grammar does not allow "friend class A<int>;"
69 7.1.1 Storage class specifiers on template declarations
73 5.10 Pointer equality
74 5.3.4 Enumeration value in direct-new-declarator
75 9.2 In-class initialized members must be const
76 7.1.6.1 Are const volatile variables considered "constant expressions"?
80 9.2 Class members with same name as class
83 13.3.3.2 Overloading and deprecated conversion of string literal
84 13.3.3.1 Overloading and conversion loophole used by auto_ptr
85 3.4.4 Redeclaration of member class
89 3.8 Object lifetime does not account for reference rebinding
90 3.4.2 Should the enclosing class be an "associated class" too?
93 3.8 Missing word in 3.8 basic.life paragraph 2
94 5.19 Inconsistencies in the descriptions of constant expressions
98 15 Branching into try block
100 14.3.2 Clarify why string literals are not allowed as template arguments
101 7.3.3 Redeclaration of extern "C" names via using-declarations
103 7.3.4 Is it extended-namespace-definition or extension-namespace-definition ?
105 14 Meaning of "template function"
108 14.6.2.1 Are classes nested in templates dependent?
116 14.5.6.1 Equivalent and functionally-equivalent function templates
120 14.6 Nonexistent non-terminal qualified-name
121 14.6 Dependent type names with non-dependent nested-name-specifiers
123 5.1.1 Bad cross-reference
126 15.4 Exception specifications and const
127 5.3.4 Ambiguity in description of matching deallocation function
128 5.2.9 Casting between enum types
131 _N2691_.E Typo in Lao characters
134 14 Template classes and declarator-ids
135 8.3.5 Class type in in-class member function definitions
137 5.2.9 static_cast of cv void*
142 11.2 Injection-related errors in access example
145 D.1 Deprecation of prefix ++
147 5.1.1 Naming the constructor
148 9 POD classes and pointers to members
149 4.10 Accessibility and ambiguity
151 8.5 Terminology of zero-initialization
152 12.3.1 explicit copy constructors
153 13.3.3.2 Misleading wording (rank of conversion)
159 8.3 Namespace qualification in declarators
161 11.5 Access to protected nested type
163 8.5.1 Description of subaggregate initializer
164 3.4.2 Overlap between Koenig and normal lookup
166 7.3.1.2 Friend declarations of template-ids
171 7.3 Global namespace scope
173 2.3 Constraints on execution character set
176 9 Name injection and templates
178 8.5 More on value-initialization
179 5.7 Function pointers and subtraction
181 14.8.2.5 Errors in template template-parameter example
183 14.6 typename in explicit specializations
185 12.8 "Named" temporaries and copy elision
187 14.1 Scope of template parameter names
188 5.18 Comma operator and rvalue conversion
190 9.2 Layout-compatible POD-struct types
193 12.4 Order of destruction of local automatics of destructor
194 12.1 Identifying constructors
202 13.4 Use of overloaded function name
206 14.6.3 Semantic constraints on non-dependent names
210 15.3 What is the type matched by an exception handler?
213 14.6.2 Lookup in dependent base classes
217 8.3.6 Default arguments for non-template member functions of class templates
227 6.4 How many scopes in an if statement?
235 12.6.2 Assignment vs initialization
241 14.8.1 Error in example in 14.8.1
249 14.5.1.1 What is a member function template?
250 13.4 Address of function template specialization with non-deduced template arguments
304 8.5 Value-initialization of a reference