ID	Title
1	What if two using-declarations refer to the same function but the declarations introduce different default-arguments?
2	How can dependent names be used in member declarations that appear outside of the class template definition?
3	The template compilation model rules render some explicit specialization declarations not visible during instantiation
4	Does extern "C" affect the linkage of function names with internal linkage?
5	CV-qualifiers and type conversions
6	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?
7	Can a class with a private virtual base class be derived from?
8	Access to template arguments used in a function return type and in the nested name specifier
9	Clarification of access to base class members
10	Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?
11	How do the keywords typename/template interact with using-declarations?
12	Default arguments on different declarations for the same function and the Koenig lookup
13	extern "C" for Parameters of Function Templates
14	extern "C" functions and declarations in different namespaces
15	Default arguments for parameters of function templates
16	Access to members of indirect private base classes
17	Footnote 99 should discuss the naming class when describing members that can be accessed from friends
18	f(TYPE) where TYPE is void should be allowed
19	Clarify protected member access
20	Some clarifications needed for 12.8 para 15
21	Can a default argument for a template parameter appear in a friend declaration?
22	Template parameter with a default argument that refers to itself
23	Some questions regarding partial ordering of function templates
24	Errors in examples in 14.7.3
25	Exception specifications and pointers to members
26	Copy constructors and default arguments
27	Overload ambiguities for builtin ?: prototypes
28	'exit', 'signal' and static object destruction
29	Linkage of locally declared functions
30	Valid uses of "::template"
31	Looking up new/delete
32	Clarification of explicit instantiation of non-exported templates
33	Argument dependent lookup and overloaded functions
34	Argument dependent lookup and points of instantiation
35	Definition of default-initialization
36	using-declarations in multiple-declaration contexts
37	When is uncaught_exception() true?
38	Explicit template arguments and operator functions
39	Conflicting ambiguity rules
40	Syntax of declarator-id
41	Clarification of lookup of names after declarator-id
42	Redefining names from base classes
43	Copying base classes (PODs) using memcpy
44	Member specializations
45	Access to nested classes
46	Explicit instantiation of member templates
47	Template friend issues
48	Definitions of unused static members
49	Restriction on non-type, non-value template arguments
50	Converting pointer to incomplete type to same type
51	Overloading and user-defined conversions
52	Non-static members, member selection and access checking
53	Lvalue-to-rvalue conversion before certain static_casts
54	Static_cast from private base to derived class
55	Adding/subtracting pointer and enumeration value
56	Redeclaring typedefs within classes
57	Empty unions
58	Signedness of bit fields of enum type
59	Clarification of overloading and UDC to reference type
60	Reference binding and valid conversion sequences
61	Address of static member function "&p->f"
62	Unnamed members of classes used as type parameters
63	Class instantiation from pointer conversion to void*, null and self
64	Partial ordering to disambiguate explicit specialization
65	Typo in default argument example
66	Visibility of default args vs overloads added after using-declaration
67	Evaluation of left side of object-expression
68	Grammar does not allow "friend class A<int>;"
69	Storage class specifiers on template declarations
70	Is an array bound a nondeduced context?
71	Incorrect cross reference
72	Linkage and storage class specifiers for templates
73	Pointer equality
74	Enumeration value in direct-new-declarator
75	In-class initialized members must be const
76	Are const volatile variables considered "constant expressions"?
77	The definition of friend does not allow nested classes to be friends
78	Section 8.5 paragraph 9 should state it only applies to non-static objects
79	Alignment and placement new
80	Class members with same name as class
81	Null pointers and C compatibility
82	Definition of "using" a constant expression
83	Overloading and deprecated conversion of string literal
84	Overloading and conversion loophole used by auto_ptr
85	Redeclaration of member class
86	Lifetime of temporaries in query expressions
87	Exception specifications on function parameters
88	Specialization of member constant templates
89	Object lifetime does not account for reference rebinding
90	Should the enclosing class be an "associated class" too?
91	A union's associated types should include the union itself
92	Should exception-specifications be part of the type system?
93	Missing word in 3.8 basic.life paragraph 2
94	Inconsistencies in the descriptions of constant expressions
95	Elaborated type specifiers referencing names declared in friend decls
96	Syntactic disambiguation using the template keyword
97	Use of bool constants in integral constant expressions
98	Branching into try block
99	Partial ordering, references and cv-qualifiers
100	Clarify why string literals are not allowed as template arguments
101	Redeclaration of extern "C" names via using-declarations
102	Operator lookup rules do not work well with parts of the library
103	Is it extended-namespace-definition or extension-namespace-definition ?
104	Destroying the exception temp when no handler is found
105	Meaning of "template function"
106	Creating references to references during template deduction/instantiation
107	Linkage of operator functions
108	Are classes nested in templates dependent?
109	Allowing ::template in using-declarations
110	Can template functions and classes be declared in the same scope?
111	Copy constructors and cv-qualifiers
112	Array types and cv-qualifiers
113	Visibility of called function
114	Virtual overriding by template member function specializations
115	Address of template-id
116	Equivalent and functionally-equivalent function templates
117	Timing of destruction of temporaries
118	Calls via pointers to virtual member functions
119	Object lifetime and aggregate initialization
120	Nonexistent non-terminal qualified-name
121	Dependent type names with non-dependent nested-name-specifiers
122	template-ids as unqualified-ids
123	Bad cross-reference
124	Lifetime of temporaries in default initialization of class arrays
125	Ambiguity in friend declaration syntax
126	Exception specifications and const
127	Ambiguity in description of matching deallocation function
128	Casting between enum types
129	Stability of uninitialized auto variables
130	Sequence points and new-expressions
131	Typo in Lao characters
132	Local types and linkage
133	Exception specifications and checking
134	Template classes and declarator-ids
135	Class type in in-class member function definitions
136	Default arguments and friend declarations
137	static_cast of cv void*
138	Friend declaration name lookup
139	Error in friend lookup example
140	Agreement of parameter declarations
141	Non-member function templates in member access expressions
142	Injection-related errors in access example
143	Friends and Koenig lookup
144	Position of friend specifier
145	Deprecation of prefix ++
146	Floating-point zero
147	Naming the constructor
148	POD classes and pointers to members
149	Accessibility and ambiguity
150	Template template parameters and default arguments
151	Terminology of zero-initialization
152	explicit copy constructors
153	Misleading wording (rank of conversion)
154	Anonymous unions in unnamed namespaces
155	Brace initializer for scalar
156	Name lookup for conversion functions
157	Omitted typedef declarator
158	Aliasing and qualification conversions
159	Namespace qualification in declarators
160	Missing std:: qualification
161	Access to protected nested type
162	(&C::f)() with nonstatic members
163	Description of subaggregate initializer
164	Overlap between Koenig and normal lookup
165	Definitions of friends and block-scope externs
166	Friend declarations of template-ids
167	Deprecating static functions
168	C linkage for static member functions
169	template-ids in using-declarations
170	Pointer-to-member conversions
171	Global namespace scope
172	Unsigned int as underlying type of enum
173	Constraints on execution character set
174	Undeprecating global static
175	Class name injection and base name access
176	Name injection and templates
177	Lvalues vs rvalues in copy-initialization
178	More on value-initialization
179	Function pointers and subtraction
180	typename and elaborated types
181	Errors in template template-parameter example
182	Access checking on explicit specializations
183	typename in explicit specializations
184	Default arguments in template template-parameters
185	"Named" temporaries and copy elision
186	Name hiding and template template-parameters
187	Scope of template parameter names
188	Comma operator and rvalue conversion
189	Definition of operator and punctuator
190	Layout-compatible POD-struct types
191	Name lookup does not handle complex nesting
192	Name lookup in parameters
193	Order of destruction of local automatics of destructor
194	Identifying constructors
195	Converting between function and object pointers
196	Arguments to deallocation functions
197	Issues with two-stage lookup of dependent names
198	Definition of "use" in local and nested classes
199	Order of destruction of temporaries
200	Partial ordering and explicit arguments
201	Order of destruction of temporaries in initializers
202	Use of overloaded function name
203	Type of address-of-member expression
204	Exported class templates
205	Templates and static data members
206	Semantic constraints on non-dependent names
207	using-declarations and protected access
208	Rethrowing exceptions in nested handlers
209	Must friend declaration names be accessible?
210	What is the type matched by an exception handler?
211	Constructors should not be allowed to return normally after an exception
212	Implicit instantiation is not described clearly enough
213	Lookup in dependent base classes
214	Partial ordering of function templates is underspecified
215	Template parameters are not allowed in nested-name-specifiers
216	Linkage of nameless class-scope enumeration types
217	Default arguments for non-template member functions of class templates
218	Specification of Koenig lookup
219	Cannot defend against destructors that throw exceptions
220	All deallocation functions should be required not to throw
221	Must compound assignment operators be member functions?
222	Sequence points and lvalue-returning operators
223	The meaning of deprecation
224	Definition of dependent names
225	Koenig lookup and fundamental types
226	Default template arguments for function templates
227	How many scopes in an if statement?
228	Use of template keyword with non-member templates
229	Partial specialization of function templates
230	Calls to pure virtual functions
231	Visibility of names after using-directives
232	Is indirection through a null pointer undefined behavior?
233	References vs pointers in UDC overload resolution
234	Reuse of base class subobjects
235	Assignment vs initialization
236	Explicit temporaries and integral constant expressions
237	Explicit instantiation and base class members
238	Precision and accuracy constraints on floating point
239	Footnote 116 and Koenig lookup
240	Uninitialized values and undefined behavior
241	Error in example in 14.8.1
242	Interpretation of old-style casts
243	Weighting of conversion functions in direct-initialization
244	Destructor lookup
245	Name lookup in elaborated-type-specifiers
246	Jumps in function-try-block handlers
247	Pointer-to-member casts and function overload resolution
248	Identifier characters
249	What is a member function template?
250	Address of function template specialization with non-deduced template arguments
251	How many signed integer types are there?
252	Looking up deallocation functions in virtual destructors
253	Why must empty or fully-initialized const objects be initialized?
254	Definitional problems with elaborated-type-specifiers
255	Placement deallocation functions and lookup ambiguity
256	Overflow in size calculations
257	Abstract base constructors and virtual base initialization
258	using-declarations and cv-qualifiers
259	Restrictions on explicit specialization and instantiation
260	User-defined conversions and built-in operator=
261	When is a deallocation function "used?"
262	Default arguments and ellipsis
263	Can a constructor be declared a friend?
264	Unusable template constructors and conversion functions
265	Destructors, exceptions, and deallocation
266	No grammar sentence symbol
267	Alignment requirement for new-expressions
268	Macro name suppression in rescanned replacement text
269	Order of initialization of multiply-defined static data members of class templates
270	Order of initialization of static data members of class templates
271	Explicit instantiation and template argument deduction
272	Explicit destructor invocation and qualified-ids
273	POD classes and operator&()
274	Cv-qualification and char-alias access to out-of-lifetime objects
275	Explicit instantiation/specialization and using-directives
276	Order of destruction of parameters and temporaries
277	Zero-initialization of pointers
278	External linkage and nameless entities
279	Correspondence of "names for linkage purposes"
280	Access and surrogate call functions
281	inline specifier in friend declarations
282	Namespace for extended_type_info
283	Template type-parameters are not syntactically type-names
284	qualified-ids in class declarations
285	Identifying a function template being specialized
286	Incorrect example in partial specialization
287	Order dependencies in template instantiation
288	Misuse of "static type" in describing pointers
289	Incomplete list of contexts requiring a complete type
290	Should memcpy be allowed into a POD with a const member?
291	Overload resolution needed when binding reference to class rvalue
292	Deallocation on exception in new before arguments evaluated
293	Syntax of explicit instantiation/specialization too permissive
294	Can static_cast drop exception specifications?
295	cv-qualifiers on function types
296	Can conversion functions be static?
297	Which template does an explicit specialization specialize?
298	T::x when T is cv-qualified
299	Conversion on array bound expression in new
300	References to functions in template argument deduction
301	Syntax for template-name
302	Value-initialization and generation of default constructor
303	Integral promotions on bit-fields
304	Value-initialization of a reference
305	Name lookup in destructor call
306	Ambiguity by class name injection
307	Initialization of a virtual base class subobject
308	Catching exceptions with ambiguous base classes
309	Linkage of entities whose names are not simply identifiers, in introduction
310	Can function templates differing only in parameter cv-qualifiers be overloaded?
311	Using qualified name to reopen nested namespace
312	“use” of invalid pointer value not defined
313	Class with single conversion function to integral as array size in new
314	template in base class specifier
315	Is call of static member function through null pointer undefined?
316	Injected-class-name of template used as template template parameter
317	Can a function be declared inline after it has been called?
318	struct A::A should not name the constructor of A
319	Use of names without linkage in declaring entities with linkage
320	Question on copy constructor elision example
321	Associated classes and namespaces for argument-dependent lookup
322	Deduction of reference conversions
323	Where must export appear?
324	Can "&" be applied to assignment to bit-field?
325	When are default arguments parsed?
326	Wording for definition of trivial constructor
327	Use of "structure" without definition
328	Missing requirement that class member types be complete
329	Evaluation of friends of templates
330	Qualification conversions and pointers to arrays of pointers
331	Allowed copy constructor signatures
332	cv-qualified void parameter types
333	Ambiguous use of "declaration" in disambiguation section
334	Is a comma-expression dependent if its first operand is?
335	Allowing export on template members of nontemplate classes
336	Explicit specialization examples are still incorrect
337	Attempt to create array of abtract type should cause deduction to fail
338	Enumerator name with linkage used as class name in other translation unit
339	Overload resolution in operand of sizeof in constant expression
340	Unclear wording in disambiguation section
341	extern "C" namespace member function versus global variable
342	Terminology: "indirection" versus "dereference"
343	Make template optional in contexts that require a type
344	Naming destructors
345	Misleading comment on example in templates chapter
346	Typo in 15.4
347	Use of derived class name in defining base class nested class
348	delete and user-written deallocation functions
349	Template argument deduction for conversion functions and qualification conversions
350	signed char underlying representation for objects
351	Sequence point error: unspecified or undefined?
352	Nondeduced contexts
353	Is deallocation routine called if destructor throws exception in delete?
354	Null as nontype template argument
355	Global-scope :: in nested-name-specifier
356	Wording of behavior of generated copy constructor for scalar members
357	Definition of signature should include name
358	Namespaces and extern "C"
359	Type definition in anonymous union
360	Using-declaration that reduces access
361	Forward reference to default argument
362	Order of initialization in instantiation units
363	Initialization of class from self
364	Calling overloaded function with static in set, with no object
365	Storage duration and temporaries
366	String literal allowed in integral constant expression?
367	throw operator allowed in constant expression?
368	Uses of non-type parameters that should cause deduction to fail
369	Are new/delete identifiers or preprocessing-op-or-punc?
370	Can #include <...> form be used other than for standard C++ headers?
371	Interleaving of constructor calls
372	Is access granted by base class specifiers available in following base class specifiers?
373	Lookup on namespace qualified name in using-directive
374	Can explicit specialization outside namespace use qualified name?
375	Confusing example on lookup with typename
376	Class "definition" versus class "declaration"
377	Enum whose enumerators will not fit in any integral type
378	Wording that says temporaries are declared
379	Change "class declaration" to "class definition"
380	Definition of "ambiguous base class" missing
381	Incorrect example of base class member lookup
382	Allow typename outside of templates
383	Is a class with a declared but not defined destructor a POD?
384	Argument-dependent lookup and operator functions
385	How does protected member check of 11.5 interact with using-declarations?
386	Friend declaration of name brought in by using-declaration
387	Errors in example in 14.6.5
388	Catching base*& from a throw of derived*
389	Unnamed types in entities with linkage
390	Pure virtual must be defined when implicitly called
391	Require direct binding of short-lived references to rvalues
392	Use of full expression lvalue before temporary destruction
393	Pointer to array of unknown bound in template argument list in parameter
394	identifier-list is never defined
395	Conversion operator template syntax
396	Misleading note regarding use of auto for disambiguation
397	Same address for string literals from default arguments in inline functions?
398	Ambiguous wording on naming a type in deduction
399	Destructor lookup redux
400	Using-declarations and the "struct hack"
401	When is access for template parameter default arguments checked?
402	More on partial ordering of function templates
403	Reference to a type as a template-id
404	Unclear reference to construction with non-trivial constructor
405	Unqualified function name lookup
406	Static data member in class with name for linkage purposes
407	Named class with associated typedef: two names or one?
408	sizeof applied to unknown-bound array static data member of template
409	Obsolete paragraph missed by changes for issue 224
410	Paragraph missed in changes for issue 166
411	Use of universal-character-name in character versus string literals
412	Can a replacement allocation function be inline?
413	Definition of "empty class"
414	Multiple types found on destructor lookup
415	Template deduction does not cause instantiation
416	Class must be complete to allow operator lookup?
417	Using derived-class qualified name in out-of-class nested class definition
418	Imperfect wording on error on multiple default arguments on a called function
419	Can cast to virtual base class be done on partially-constructed object?
420	postfixexpression->scalar_type_dtor() inconsistent
421	Is rvalue.field an rvalue?
422	Is a typedef redeclaration allowed with a template type that might be the same?
423	Can a conversion be done on the left operand of a compound assignment?
424	Wording problem with issue 56 resolution on redeclaring typedefs in class scope
425	Set of candidates for overloaded built-in operator with float operand
426	Identically-named variables, one internally and one externally linked, allowed?
427	static_cast ambiguity: conversion versus cast to derived
428	Mention of expression with reference type
429	Matching deallocation function chosen based on syntax or signature?
430	Ordering of expression evaluation in initializer list
431	Defect in wording in 14.2
432	Is injected class name visible in base class specifier list?
433	Do elaborated type specifiers in templates inject into enclosing namespace scope?
434	Unclear suppression of standard conversions while binding reference to lvalue
435	Change "declararation or definition" to "declaration"
436	Problem in example in 9.6 paragraph 4
437	Is type of class allowed in member function exception specification?
438	Possible flaw in wording for multiple accesses to object between sequence points
439	Guarantees on casting pointer back to cv-qualified version of original type
440	Allow implicit pointer-to-member conversion on nontype template argument
441	Ordering of static reference initialization
442	Incorrect use of null pointer constant in description of delete operator
443	Wording nit in description of lifetime of temporaries
444	Overriding and the generated copy assignment operator
445	Wording issue on friend declarations
446	Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?
447	Is offsetof type-dependent?
448	Set of template functions in call with dependent explicit argument
449	Consistency in use of hyphen with names of "non" entities
450	Binding a reference to const to a cv-qualified array rvalue
451	Expressions with invalid results and ill-formedness
452	Wording nit on description of this
453	References may only bind to “valid” objects
454	When is a definition of a static data member required?
455	Partial ordering and non-deduced arguments
456	Is initialized const int or const bool variable a null pointer constant?
457	Wording nit on use of const variables in constant expressions
458	Hiding of member template parameters by other members
459	Hiding of template parameters by base class members
460	Can a using-declaration name a namespace?
461	Make asm conditionally-supported
462	Lifetime of temporaries bound to comma expressions
463	reinterpret_cast<T*>(0)
464	Wording nit on lifetime of temporaries to which references are bound
465	May constructors of global objects call exit()?
466	cv-qualifiers on pseudo-destructor type
467	Jump past initialization of local static variable
468	Allow ::template outside of templates
469	Const template specializations and reference arguments
470	Instantiation of members of an explicitly-instantiated class template
471	Conflicting inherited access specifications
472	Casting across protected inheritance
473	Block-scope declarations of allocator functions
474	Block-scope extern declarations in namespace members
475	When is std::uncaught_exception() true? (take 2)
476	Determining the buffer size for placement new
477	Can virtual appear in a friend declaration?
478	May a function parameter be an array of an abstract class type?
479	Copy elision in exception handling
480	Is a base of a virtual base also virtual?
481	Scope of template parameters
482	Qualified declarators in redeclarations
483	Normative requirements on integral ranges
484	Can a base-specifier name a cv-qualified class type?
485	What is a “name”?
486	Invalid return types and template argument deduction
487	Operator overloading in constant expressions
488	Local types, overload resolution, and template argument deduction
489	Must member function templates be instantiated during overload resolution?
490	Name lookup in friend declarations
491	Initializers for empty-class aggregrate members
492	typeid constness inconsistent with example
493	Type deduction from a bool context
494	Problems with the resolution of issue 45
495	Overload resolution with template and non-template conversion functions
496	Is a volatile-qualified type really a POD?
497	Missing required initialization in example
498	Storage class specifiers in definitions of class members
499	Throwing an array of unknown size
500	Access in base-specifiers of friend and nested classes
501	Visibility of friend declarations within the befriending class
502	Dependency of nested enumerations and enumerators
503	Cv-qualified function types in template argument deduction
504	Should use of a variable in its own initializer require a diagnostic?
505	Conditionally-supported behavior for unknown character escapes
506	Conditionally-supported behavior for non-POD objects passed to ellipsis
507	Ambiguity assigning class object to built-in type
508	Non-constructed value-initialized objects
509	Dead code in the specification of default initialization
510	Default initialization of POD classes?
511	POD-structs with template assignment operators
512	Union members with user-declared non-default constructors
513	Non-class “most-derived” objects
514	Is the initializer for a namespace member in the scope of the namespace?
515	Non-dependent references to base class members
516	Use of signed in bit-field declarations
517	Partial specialization following explicit instantiation
518	Trailing comma following enumerator-list
519	Null pointer preservation in void* conversions
520	Old-style casts between incomplete class types
521	Requirements for exceptions thrown by allocation functions
522	Array-to-pointer decay in template argument deduction
523	Can a one-past-the-end pointer be invalidated by deleting an adjacent object?
524	Can function-notation calls to operator functions be dependent?
525	Missing * in example
526	Confusing aspects in the specification of non-deduced contexts
527	Problems with linkage of types
528	Why are incomplete class types not allowed with typeid?
529	Use of template<> with “explicitly-specialized” class templates
530	Nontype template arguments in constant expressions
531	Defining members of explicit specializations
532	Member/nonmember operator template partial ordering
533	Special treatment for C-style header names
534	template-names and operator-function-ids
535	Copy construction without a copy constructor
536	Problems in the description of id-expressions
537	Definition of “signature”
538	Definition and usage of structure, POD-struct, POD-union, and POD class
539	Constraints on type-specifier-seq
540	Propagation of cv-qualifiers in reference-to-reference collapse
541	Dependent function types
542	Value initialization of arrays of POD-structs
543	Value initialization and default constructors
544	Base class lookup in explicit specialization
545	User-defined conversions and built-in operator overload resolution
546	Explicit instantiation of class template members
547	Partial specialization on member function types
548	qualified-ids in declarations
549	Non-deducible parameters in partial specializations
550	Pointer to array of unknown bound in parameter declarations
551	When is inline permitted in an explicit instantiation?
552	Use of typename in the type in a non-type parameter-declaration
553	Problems with friend allocation and deallocation functions
554	Definition of “declarative region” and “scope”
555	Pseudo-destructor name lookup
556	Conflicting requirements for acceptable aliasing
557	Does argument-dependent lookup cause template instantiation?
558	Excluded characters in universal character names
559	Editing error in issue 382 resolution
560	Use of the typename keyword in return types
561	Internal linkage functions in dependent name lookup
562	qualified-ids in non-expression contexts
563	Linkage specification for objects
564	Agreement of language linkage or linkage-specifications?
565	Conflict rules for using-declarations naming function templates
566	Conversion of negative floating point values to integer type
567	Can size_t and ptrdiff_t be larger than long?
568	Definition of POD is too strict
569	Spurious semicolons at namespace scope should be allowed
570	Are references subject to the ODR?
571	References declared const
572	Standard conversions for non-built-in types
573	Conversions between function pointers and void*
574	Definition of “copy assignment operator”
575	Criteria for deduction failure
576	Typedefs in function definitions
577	void in an empty parameter list
578	Phase 1 replacement of characters with universal-character-names
579	What is a “nested” > or >>?
580	Access in template-parameters of member and friend definitions
581	Can a templated constructor be explicitly instantiated or specialized?
582	Template conversion functions
583	Relational pointer comparisons against the null pointer constant
584	Unions and aliasing
585	Friend template template parameters
586	Default template-arguments and template argument deduction
587	Lvalue operands of a conditional expression differing only in cv-qualification
588	Searching dependent bases of classes local to function templates
589	Direct binding of class and array rvalues in reference initialization
590	Nested classes and the “current instantiation”
591	When a dependent base class is the current instantiation
592	Exceptions during construction of local static objects
593	Falling off the end of a destructor's function-try-block handler
594	Coordinating issues 119 and 404 with delegating constructors
595	Exception specifications in templates instantiated from class bodies
596	Replacing an exception object
597	Conversions applied to out-of-lifetime non-POD lvalues
598	Associated namespaces of overloaded functions and function templates
599	Deleting a null function pointer
600	Does access control apply to members or to names?
601	Type of literals in preprocessing expressions
602	When is the injected-class-name of a class template a template?
603	Type equivalence and unsigned overflow
604	Argument list for overload resolution in copy-initialization
605	Linkage of explicit specializations
606	Template argument deduction for rvalue references
607	Lookup of mem-initializer-ids
608	Determining the final overrider of a virtual function
609	What is a “top-level” cv-qualifier?
610	Computing the negative of 0U
611	Zero-initializing references
612	Requirements on a conforming implementation
613	Unevaluated uses of non-static class members
614	Results of integer / and %
615	Incorrect description of variables that can be initialized
616	Definition of “indeterminate value”
617	Lvalue-to-rvalue conversions of uninitialized char objects
618	Casts in preprocessor conditional expressions
619	Completeness of array types
620	Declaration order in layout-compatible POD structs
621	Template argument deduction from function return types
622	Relational comparisons of arbitrary pointers
623	Use of pointers to deallocated storage
624	Overflow in calculating size of allocation
625	Use of auto as a template-argument
626	Preprocessor string literals
627	Values behaving as types
628	The values of an enumeration with no enumerator
629	auto parsing ambiguity
630	Equality of narrow and wide character values in the basic character set
631	Jumping into a “then” clause
632	Brace-enclosed initializer for scalar member of aggregate
633	Specifications for variables that should also apply to references
634	Conditionally-supported behavior for non-POD objects passed to ellipsis redux
635	Names of constructors and destructors of templates
636	Dynamic type of objects and aliasing
637	Sequencing rules and example disagree
638	Explicit specialization and friendship
639	What makes side effects “different” from one another?
640	Accessing destroyed local objects of static storage duration
641	Overload resolution and conversion-to-same-type operators
642	Definition and use of “block scope” and “local scope”
643	Use of decltype in a class member-specification
644	Should a trivial class type be a literal type?
645	Are bit-field and non-bit-field members layout compatible?
646	Can a class with a constexpr copy constructor be a literal type?
647	Non-constexpr instances of constexpr constructor templates
648	Constant expressions in constexpr initializers
649	Optionally ill-formed extended alignment requests
650	Order of destruction for temporaries bound to the returned value of a function
651	Problems in decltype specification and examples
652	Compile-time evaluation of floating-point expressions
653	Copy assignment of unions
654	Conversions to and from nullptr_t
655	Initialization not specified for forwarding constructors
656	Direct binding to the result of a conversion operator
657	Abstract class parameter in synthesized declaration
658	Defining reinterpret_cast for pointer types
659	Alignment of function types
660	Unnamed scoped enumerations
661	Semantics of arithmetic comparisons
662	Forming a pointer to a reference type
663	Valid Cyrillic identifier characters
664	Direct binding of references to non-class rvalue references
665	Problems in the specification of dynamic_cast
666	Dependent qualified-ids without the typename keyword
667	Trivial special member functions that cannot be implicitly defined
668	Throwing an exception from the destructor of a local static object
669	Confusing specification of the meaning of decltype
670	Copy initialization via derived-to-base conversion in the second step
671	Explicit conversion from a scoped enumeration type to integral type
672	Sequencing of initialization in new-expressions
673	Injection of names from elaborated-type-specifiers in friend declarations
674	“matching specialization” for a friend declaration
675	Signedness of bit-field with typedef or template parameter type
676	static_assert-declarations and general requirements for declarations
677	Deleted operator delete and virtual destructors
678	Language linkage of member function parameter types and the ODR
679	Equivalence of template-ids and operator function templates
680	What is a move constructor?
681	Restrictions on declarators with late-specified return types
682	Missing description of lookup of template aliases
683	Requirements for trivial subobject special functions
684	Constant expressions involving the address of an automatic variable
685	Integral promotion of enumeration ignores fixed underlying type
686	Type declarations/definitions in type-specifier-seqs and type-ids
687	template keyword with unqualified-ids
688	Constexpr constructors and static initialization
689	Maximum values of signed and unsigned integers
690	The dynamic type of an rvalue reference
691	Template parameter packs in class template partial specializations
692	Partial ordering of variadic class template partial specializations
693	New string types and deprecated conversion
694	Zero- and value-initialization of union objects
695	Compile-time calculation errors in constexpr functions
696	Use of block-scope constants in local classes
697	Deduction rules apply to more than functions
698	The definition of “sequenced before” is too narrow
699	Must constexpr member functions be defined in the class member-specification?
700	Constexpr member functions of class templates
701	When is the array-to-pointer conversion applied?
702	Preferring conversion to std::initializer_list
703	Narrowing for literals that cannot be exactly represented
704	To which postfix-expressions does overload resolution apply?
705	Suppressing argument-dependent lookup via parentheses
706	Use of auto with rvalue references
707	Undefined behavior in integral-to-floating conversions
708	Partial specialization of member templates of class templates
709	Enumeration names as nested-name-specifiers in deduction failure
710	Data races during construction
711	auto with braced-init-list
712	Are integer constant operands of a conditional-expression “used?”
713	Unclear note about cv-qualified function types
714	Static const data members and braced-init-lists
715	Class member access constant expressions
716	Specifications that should apply only to non-static union data members
717	Unintentional restrictions on the use of thread_local
718	Non-class, non-function friend declarations
719	Specifications for operator-function-id that should also apply to literal-operator-id
720	Need examples of lambda-expressions
721	Where must a variable be initialized to be used in a constant expression?
722	Can nullptr be passed to an ellipsis?
723	Archetypes in skipped declarations
724	Qualified name lookup in a constrained context
725	When should the requirement for std::Returnable<T>, etc., apply?
726	Atomic and non-atomic objects in the memory model
727	In-class explicit specializations
728	Restrictions on local classes
729	Qualification conversions and handlers of reference-to-pointer type
730	Explicit specializations of members of non-template classes
731	Omitted reference qualification of member function type
732	Late-specified return types in function definitions
733	Reference qualification of copy assignment operators
734	Are unique addresses required for namespace-scope variables?
735	Missing case in specification of safely-derived pointers
736	Is the & ref-qualifier needed?
737	Uninitialized trailing characters in string initialization
738	constexpr not permitted by the syntax of constructor declarations
739	Signedness of plain bit-fields
740	Incorrect note on data races
741	“plain” long long bit-fields
742	Postfix increment/decrement with long bit-field operands
743	Use of decltype in a nested-name-specifier
744	Matching template arguments with template template parameters with parameter packs
745	Effect of ill-formedness resulting from #error
746	Use of auto in new-expressions
747	Access of protected base classes
748	Always-complete archetypes
749	References to function types with a cv-qualifier or ref-qualifier
750	Implementation constraints on reference-only closure objects
751	Deriving from closure classes
752	Name lookup in nested lambda-expressions
753	Array names in lambda capture sets
754	Lambda expressions in default arguments of block-scope function declarations
755	Generalized lambda-captures
756	Dropping cv-qualification on members of closure objects
757	Types without linkage in declarations
758	Missing cases of declarations that are not definitions
759	Destruction of closure objects
760	this inside a nested class of a non-static member function
761	Inferred return type of closure object call operator
762	Name lookup in the compound-statement of a lambda expression
763	Is a closure object's operator() inline?
764	Capturing unused variables in a lambda expression
765	Local types in inline functions with external linkage
766	Where may lambda expressions appear?
767	void and other unnamed lambda-parameters
768	Ellipsis in a lambda parameter list
769	Initialization of closure objects
770	Ambiguity in late-specified return type
771	Move-construction of reference members of closure objects
772	capture-default in lambdas in local default arguments
773	Parentheses in address non-type template arguments
774	Can a closure class be a POD?
775	Capturing references to functions
776	Delegating constructors, destructors, and std::exit
777	Default arguments and parameter packs
778	Template parameter packs in non-type template parameters
779	Rvalue reference members of closure objects?
780	Questions regarding the point of definition of a concept map
781	Missing requirement in constrained function example
782	Lambda expressions and argument-dependent lookup
783	Definition of “argument”
784	List of incompatibilities with the previous Standard
785	“Execution sequence” is inappropriate phraseology
786	Definition of “thread”
787	Unnecessary lexical undefined behavior
788	Relationship between locale and values of the execution character set
789	Deprecating trigraphs
790	Concatenation of raw and non-raw string literals
791	Linkage of concept names
792	Effects of std::quick_exit
793	Use of class members during destruction
794	Base-derived conversion in member type of pointer-to-member conversion
795	Dependency of lambdas on <functional>
796	Lifetime of a closure object with members captured by reference
797	Converting a no-capture lambda to a function type
798	Overloaded subscript operator described in clause 5
799	Can reinterpret_cast be used to cast an operand to its own type?
800	Safely-derived pointers and object pointers converted from function pointers
801	Casting away constness in a cast to rvalue reference type
802	Problems with restrictions on taking the address of a member of a concept map
803	sizeof an enumeration type with a fixed underlying type
804	Deducing the type in new auto(x)
805	Which exception to throw for overflow in array size calculation
806	Enumeration types in integral constant expressions
807	typeid expressions in constant expressions
808	Non-type decl-specifiers versus max-munch
809	Deprecation of the register keyword
810	Block-scope thread_local variables should be implicitly static
811	Unclear implications of const-qualification
812	Duplicate names in inline namespaces
813	typename in a using-declaration with a non-dependent name
814	Attribute to indicate that a function throws nothing
815	Parameter pack expansion inside attributes
816	Diagnosing violations of [[final]]
817	Meaning of [[final]] applied to a class definition
818	Function parameter packs in non-final positions
819	Access control and deleted implicitly-declared special member functions
820	Deprecation of export
821	Exported concept map templates?
822	Additional contexts for template aliases
823	Literal types with constexpr conversions as non-type template arguments
824	Constrained special member functions
825	TriviallyCopyableType concept
826	Accept boolean constant expressions as constraints
827	Use of && as requirement separator
828	Destruction of exception objects
829	At what point is std::unexpected called?
830	Deprecating exception specifications
831	Limit on recursively nested template instantiations
832	Value of preprocessing numbers
833	Explicit conversion of a scoped enumeration value to a floating type
834	What is an “ordinary string literal”?
835	Scoped enumerations and the “usual arithmetic conversions”
836	[[noreturn]] applied to function types
837	Constexpr functions and return braced-init-list
838	Use of this in a brace-or-equal-initializer
839	sizeof with opaque enumerations
840	Rvalue references as nontype template parameters
841	Ill-formed concept refinement example
842	Casting to rvalue reference type
843	Unclear interaction of constraints and special member functions
844	Is a constrained member function a template?
845	What is the “first declaration” of an explicit specialization?
846	Rvalue references to functions
847	Error in rvalue reference deduction example
848	Unconstrained template template parameters in constrained contexts
849	Constraints and template template parameters
850	Restrictions on use of non-static data members
851	Constraints and template aliases
852	using-declarations and dependent base classes
853	Support for relaxed pointer safety
854	Left shift and unsigned extended types
855	Incorrect comments in braced-init-list assignment example
856	Overlapping concept and requirements scopes
857	Implying requirements from enclosing scopes
858	Example binding an rvalue reference to an lvalue
859	Incomplete comment in late_check example
860	Explicit qualification of constexpr member functions
861	Unintended ambiguity in inline namespace lookup
862	Undefined behavior with enumerator value overflow
863	Rvalue reference cast to incomplete type
864	braced-init-list in the range-based for statement
865	Initializing a std::initializer_list
866	Concept maps and the range-based for
867	Naming a specialization of a constrained template
868	Specifying a concept map in the name of a specialization
869	Uninitialized thread_local objects
870	Context of expression when satisfying an associated function requirement
871	Satisfying associated functions with built-in operators
872	Lexical issues with raw strings
873	Deducing rvalue references in declarative contexts
874	Class-scope definitions of enumeration types
875	Associated conversion functions converting to the same type
876	Type references in rvalue reference deduction specification
877	Viable functions and binding references to rvalues
878	Effective class types in built-in pointer-to-member operator
879	Missing built-in comparison operators for pointer types
880	Built-in conditional operator for scoped enumerations
881	Inconsistent requirement for naming template parameters
882	Defining main as deleted
883	std::memcpy vs std::memmove
884	Defining an explicitly-specialized static data member
885	Partial ordering of function templates with unordered parameter pairs
886	Member initializers and aggregates
887	Move construction of thrown object
888	Union member initializers
889	Default implementations of associated functions
890	Missing requirement in example
891	const_cast to rvalue reference from objectless rvalue
892	Missing requirements for constexpr constructors
893	Brace syntax for enumerator-definitions
894	Incorrect example for constrained overload resolution
895	Missing destructor requirements
896	Rvalue references and rvalue-reference conversion functions
897	_Pragma and extended string-literals
898	Declarations in constexpr functions
899	Explicit conversion functions in direct class initialization
900	Lifetime of temporaries in range-based for
901	Deleted operator delete
902	In-class initialization of non-constant static data members
903	Value-dependent integral null pointer constants
904	Parameter packs in lambda-captures
905	Explicit defaulted copy constructors and trivial copyability
906	Which special member functions can be defaulted?
907	Default types in requirements in auto concepts
908	Deleted global allocation and deallocation functions
909	Old-style casts with conversion functions
910	Move constructors and implicitly-declared copy constructors
911	late_check and concept map templates
912	Character literals and universal-character-names
913	Deduction rules for array- and function-type conversion functions
914	Value-initialization of array types
915	Deleted specializations of member function templates
916	Does a reference type have a destructor?
917	Pointer conversions between archetypes
918	Declaration/expression ambiguity in associated function expressions
919	Contradictions regarding inline namespaces
920	Interaction of inline namespaces and using-declarations
921	Unclear specification of inline namespaces
922	Implicit default constructor definitions and const variant members
923	Inline explicit specializations
924	alias-declaration as a class member
925	Type of character literals in preprocessor expressions
926	Inline unnamed namespaces
927	Implicitly-deleted default constructors and member initializers
928	Defaulting a function that would be implicitly defined as deleted
929	What is a template alias?
930	alignof with incomplete array type
931	Confusing reference to the length of a user-defined string literal
932	UCNs in closing delimiters of raw string literals
933	32-bit UCNs with 16-bit wchar_t
934	List-initialization of references
935	Missing overloads for character types for user-defined literals
936	Array initialization with new string literals
937	Restrictions on values of template arguments in user-defined literals
938	Initializer lists and array new
939	Explicitly checking virtual function overriding
940	Global anonymous unions
941	Explicit specialization of deleted function template
942	Is this an entity?
943	Is T() a temporary?
944	reinterpret_cast for all types with the same size and alignment
945	Use of this in a late-specified return type
946	Order of destruction of local static objects and calls to std::atexit
947	Deducing type template arguments from default function arguments
948	constexpr in conditions
949	Requirements for freestanding implementations
950	Use of decltype as a class-name
951	Problems with attribute-specifiers
952	Insufficient description of “naming class”
953	Rvalue references and function viability
954	Overload resolution of conversion operator templates with built-in types
955	Can a closure type's operator() be virtual?
956	Function prototype scope with late-specified return types
957	Alternative tokens and attribute-tokens
958	Lambdas and decltype
959	Alignment attribute for class and enumeration types
960	Covariant functions and lvalue/rvalue references
961	Overload resolution and conversion of std::nullptr_t to bool
962	Attributes appertaining to class and enum types
963	Comparing nullptr with 0
964	Incorrect description of when the lvalue-to-rvalue conversion applies
965	Limiting the applicability of the carries_dependency attribute
966	Nested types without linkage
967	Exception specification of replacement allocation function
968	Syntactic ambiguity of the attribute notation
969	Explicit instantiation declarations of class template specializations
970	Consistent use of “appertain” and “apply”
971	Incorrect treatment of exception-declarations
972	Allowing multiple attribute-specifiers
973	Function types in exception-specifications
974	Default arguments for lambdas
975	Restrictions on return type deduction for lambdas
976	Deduction for const T& conversion operators
977	When is an enumeration type complete?
978	Incorrect specification for copy initialization
979	Position of attribute-specifier in declarator syntax
980	Explicit instantiation of a member of a class template
981	Constexpr constructor templates and literal types
982	Initialization with an empty initializer list
983	Ambiguous pointer-to-member constant
984	“Deduced type” is unclear in auto type deduction
985	Alternative tokens and user-defined literals
986	Transitivity of using-directives versus qualified lookup
987	Which declarations introduce namespace members?
988	Reference-to-reference collapsing with decltype
989	Misplaced list-initialization example
990	Value initialization with multiple initializer-list constructors
991	Reference parameters of constexpr functions and constructors
992	Inheriting explicitness
993	Freedom to perform instantiation at the end of the translation unit
994	braced-init-list as a default argument
995	Incorrect example for using-declaration and explicit instantiation
996	Ambiguous partial specializations of member class templates
997	Argument-dependent lookup and dependent function template parameter types
998	Function parameter transformations and template functions
999	“Implicit” or “implied” object argument/parameter?
1000	Mistaking member typedefs for constructors
1001	Parameter type adjustment in dependent parameter types
1002	Pack expansion for function arguments
1003	Acceptable definitions of main
1004	Injected-class-names as arguments for template template parameters
1005	Qualified name resolution in member functions of class templates
1006	std::nullptr_t as a non-type template parameter
1007	Protected access and pointers to members
1008	Querying the alignment of an object
1009	Missing cases in the declarator-id of a function template declaration
1010	Address of object with dynamic storage duration in constant expression
1011	Standard conversions that cannot be inverted
1012	Undeprecating static
1013	Uninitialized std::nullptr_t objects
1014	Overload resolution between const T& and T&&
1015	Template arguments and argument-dependent lookup
1016	Overloadable declarations, function templates, and references
1017	Member access transformation in unevaluated operands
1018	Ambiguity between simple-declaration and attribute-declaration
1019	Dependent simple-template-ids in base-specifiers and mem-initializers
1020	Implicitly-defined copy constructors and explicit base class constructors
1021	Definitions of namespace members
1022	Can an enumeration variable have values outside the values of the enumeration?
1023	thread_local objects as non-type template arguments
1024	Limits on multicharacter literals
1025	Use of a reference as a non-type template argument
1026	Cv-qualified non-class rvalues
1027	Type consistency and reallocation of scalar types
1028	Dependent names in non-defining declarations
1029	Type of a destructor call
1030	Evaluation order in initializer-lists used in aggregate initialization
1031	Optional elements in attributes
1032	Empty pack expansions
1033	Restrictions on alignment attributes
1034	Attributes for return statements in lambdas
1035	Omitted and required decl-specifiers
1036	Alignment attribute in an exception-declaration
1037	Requirements for operands of delete-expressions and deallocation functions
1038	Overload resolution of &x.static_func
1039	Coordinating C and C++ alignment specifications
1040	Memory model issues
1041	alias-declarations as class members
1042	Attributes in alias-declarations
1043	Qualified name lookup in the current instantiation
1044	Point of declaration for an alias-declaration
1045	Requiring explicit instantiation declarations
1046	What is a “use” of a class specialization?
1047	When is typeid value-dependent?
1048	auto deduction and lambda return type deduction.
1049	Copy elision through reference parameters of inline functions
1050	Effects of thread support on object lifetime
1051	Reference members and generated copy constructors
1052	const non-static data member and PODness
1053	Terminate vs undefined behavior for noexcept violation
1054	Lvalue-to-rvalue conversions in expression statements
1055	Permissible uses of void
1056	Template aliases, member definitions, and the current instantiation
1057	decltype and the current instantiation
1058	Reference binding of incompatible array types
1059	Cv-qualified array types (with rvalues)
1060	Scoped enumerators in integral constant expressions
1061	Negative array bounds in a new-expression
1062	Syntax of attribute-specifiers in lambdas
1063	[[hiding]] with non-attribute declarations
1064	Defaulted move constructor for a union
1065	[[hiding]] with [[override]]
1066	When is a copy/move assignment operator implicitly defined?
1067	[[hiding]], using-declarations, and multiple inheritance
1068	Template aliases with default arguments and template parameter packs
1069	Incorrect function type with trailing-return-type
1070	Missing initializer clauses in aggregate initialization
1071	Literal class types and trivial default constructors
1072	Scoped enumerator with the same name as its containing class
1073	Merging dynamic-exception-specifications and noexcept-specifications
1074	Value-dependent noexcept-expressions
1075	Grammar does not allow template alias in type-name
1076	Value categories and lvalue temporaries
1077	Explicit specializations in non-containing namespaces
1078	Narrowing and the usual arithmetic conversions
1079	Overload resolution involving aggregate initialization
1080	Confusing relationship between templates and copy constructors
1081	Defaulted destructor and unusable operator delete
1082	Implicit copy function if subobject has none?
1083	Passing an object to ellipsis with non-trivial move constructor
1084	Conditions for a deleted move function
1085	Move assignment operators and virtual bases
1086	const_cast to rvalue reference to function type
1087	Additional applications of issue 899
1088	Dependent non-type template arguments
1089	Template parameters in member selections
1090	Alignment of subobjects
1091	Inconsistent use of the term “object expression”
1092	Cycles in overload resolution during instantiation
1093	Value-initializing non-objects
1094	Converting floating-point values to scoped enumeration types
1095	List-initialization of references
1096	Missing requirement for template definitions
1097	Aggregate initialization of function parameters
1098	Pointer conversions in constant expressions
1099	Infinite recursion in constexpr functions
1100	constexpr conversion functions and non-type template arguments
1101	Non-integral initialized static data members
1102	Better example of undefined behavior
1103	Reversion of phase 1 and 2 transformations in raw string literals
1104	Global-scope template arguments vs the <: digraph
1105	Issues relating to TR 10176:2003
1106	Need more detail in nullptr keyword description
1107	Overload resolution for user-defined integer literals
1108	User-defined literals have not been implemented
1109	When is “use” a reference to the ODR meaning?
1110	Incomplete return type should be allowed in decltype operand
1111	Remove dual-scope lookup of member template names
1112	constexpr variables should have internal linkage like const
1113	Linkage of namespace member of unnamed namespace
1114	Incorrect use of placement new in example
1115	C-compatible alignment specification
1116	Aliasing of union members
1117	Incorrect note about xvalue member access expressions
1118	Implicit lambda capture via explicit copy constructor
1119	Missing case in description of member access ambiguity
1120	reinterpret_cast and void*
1121	Unnecessary ambiguity error in formation of pointer to member
1122	Circular definition of std::size_t
1123	Destructors should be noexcept by default
1124	Error in description of value category of pointer-to-member expression
1125	Unclear definition of “potential constant expression”
1126	constexpr functions in const initializers
1127	Overload resolution in constexpr functions
1128	attribute-specifiers in decl-specifier-seqs
1129	Default nothrow for constexpr functions
1130	Function parameter type adjustments and decltype
1131	Template aliases in elaborated-type-specifiers
1132	Keyword vs attribute for noreturn
1133	Keywords vs attributes for control of hiding and overriding
1134	When is an explicitly-defaulted function defined?
1135	Explicitly-defaulted non-public special member functions
1136	Explicitly-defaulted explicit constructors
1137	Explicitly-defaulted virtual special member functions
1138	Rvalue-ness check for rvalue reference binding is wrong
1139	Rvalue reference binding to scalar xvalues
1140	Incorrect redefinition of POD class
1141	Non-static data member initializers have not been implemented
1142	friend declaration of member function of containing class
1143	Move semantics for *this have not been implemented
1144	Remove access declarations
1145	Defaulting and triviality
1146	exception-specifications of defaulted functions
1147	Destructors should be default nothrow
1148	Copy elision and move construction of function parameters
1149	Trivial non-public copy operators in subobjects
1150	Inheriting constructors have not been implemented
1151	Overload resolution with initializer-list and non-list constructors
1152	Rules for determining existence of implicit conversion sequence
1153	Type matching in address of overloaded function
1154	Address of thread_local variable as non-type template argument
1155	Internal-linkage non-type template arguments
1156	Partial ordering in a non-call context
1157	Partial ordering of function templates is still underspecified
1158	Recursive instantiation via alias template
1159	Class and enumeration definitions in template aliases
1160	Definitions of template members and the current instantiation
1161	Dependent nested-name-specifier in a pointer-to-member declarator
1162	Dependent elaborated-type-specifiers in non-deduced contexts
1163	extern template prevents inlining functions not marked inline
1164	Partial ordering of f(T&) and f(T&&)
1165	Exceptions when destroying array elements
1166	exception-declarations that do not declare objects
1167	function-try-blocks for destructors
1168	Additional reasons to call std::terminate
1169	Missing feature macro for strict pointer safety
1170	Access checking during template argument deduction
1171	Partial stack unwinding with noexcept violation
1172	“instantiation-dependent” constructs
1173	Unclear specification of effects of signal handling
1174	When is a pure virtual function “used?”
1175	Disambiguating user-defined literals
1176	Definition of release sequence
1177	Intra-thread dependency-ordered-before
1178	Deduction failure matching placement new
1179	Cv-qualification of non-type template parameters
1180	Over-aligned class types
1181	What is a “built-in type?”
1182	Incorrect description of pack expansion syntax
1183	Expansion of parameter packs in declarators
1184	Argument conversions to nondeduced parameter types
1185	Misleading description of language linkage and member function types
1186	Non-dependent constexpr violations in function templates
1187	Problems in initialization example
1188	Type punning in constant expressions
1189	Address of distinct base class subobjects
1190	Operations on non-safely-derived pointers
1191	Deleted subobject destructors and implicitly-defined constructors
1192	Inadvertent change to ODR and templates
1193	Use of address-constant pointers in constant expressions
1194	Constexpr references
1195	References to non-literal types in constexpr functions
1196	Definition required for explicit instantiation after explicit specialization?
1197	Constexpr arrays
1198	Literal types and copy constructors
1199	Deleted constexpr functions
1200	Lookup rules for template parameters
1201	Are deleted and defaulted functions definitions?
1202	Calling virtual functions during destruction
1203	Misleading note regarding initialized static data members
1204	Specifiers in a for-range-declaration
1205	Lvalue reference binding and function viability
1206	Defining opaque enumeration members of class templates
1207	Type of class member in trailing-return-type
1208	Explicit noexcept in defaulted definition
1209	Is a potentially-evaluated expression in a template definition a “use?”
1210	Injection of elaborated-type-specifier in enumeration scope
1211	Misaligned lvalues
1212	Non-function-call xvalues and decltype
1213	Array subscripting and xvalues
1214	Kinds of initializers
1215	Definition of POD struct
1216	Exceptions “allowed” by a noexcept-specification
1217	Are deleted functions implicitly noexcept?
1218	What is the “currently-handled exception” in a multi-threaded program?
1219	Non-static data member initializers in constant expressions
1220	Looking up conversion-type-ids
1221	Partial ordering and reference collapsing
1222	Unnecessary restriction on auto array types
1223	Syntactic disambiguation and trailing-return-types
1224	constexpr defaulted copy constructors
1225	constexpr constructors and virtual bases
1226	Converting a braced-init-list default argument
1227	Mixing immediate and non-immediate contexts in deduction failure
1228	Copy-list-initialization and explicit constructors
1229	Overload resolution with empty braced-init-list argument
1230	Confusing description of ambiguity of destructor name
1231	Variadic templates requiring an empty pack expansion
1232	Creation of array temporaries using a braced-init-list
1233	Pack expansions and dependent calls
1234	abstract-declarator does not permit ... after ptr-operator
1235	“Unused” ellipsis and default arguments in partial ordering
1236	Inconsistently-interrelated examples
1237	Deprecated implicit copy assignment in example
1238	Overloading ambiguity binding reference to function
1239	Hexadecimal floating-point literals vs user-defined literals
1240	constexpr defaulted constructors
1241	Which members does a destructor destroy?
1242	Initializing variant class members
1243	Misleading footnote regarding multiple-declarator declarations
1244	Equivalence of alias templates and class templates
1245	Matching declarations involving decltype
1246	Non-deduced non-final parameter packs
1247	Restriction on alias name appearing in type-id
1248	Updating Annex C to C99 and C23
1249	Cv-qualification of nested lambda capture
1250	Cv-qualification of incomplete virtual function return types
1251	C compatibility: casting to unqualified void*
1252	Overloading member function templates based on dependent return type
1253	Generic non-template members
1254	odr-use vs template arguments and constexpr functions
1255	Definition problems with constexpr functions
1256	Unevaluated operands are not necessarily constant expressions
1257	Instantiation via non-dependent references in uninstantiated templates
1258	“Instantiation context” differs from dependent lookup rules
1259	Deleting a POD via a pointer to base
1260	Incorrect use of term “overloaded” in description of odr-use
1261	Explicit handling of cv-qualification with non-class prvalues
1262	Default template arguments and deduction failure
1263	Mismatch between rvalue reference binding and overload resolution
1264	Use of this in constexpr constructor
1265	Mixed use of the auto specifier
1266	user-defined-integer-literal overflow
1267	Rvalue reference types in exception-specifications
1268	reinterpret_cast of an xvalue operand
1269	dynamic_cast of an xvalue operand
1270	Brace elision in array temporary initialization
1271	Imprecise wording regarding dependent types
1272	Implicit definition of static data member of const literal type
1273	Accessibility and function signatures
1274	Common nonterminal for expression and braced-init-list
1275	Incorrect comment in example of template parameter pack restriction
1276	Reference to stdint.h
1277	Lax definition of intmax_t and uintmax_t
1278	Incorrect treatment of contrived object
1279	Additional differences between C++ 2003 and C++ 2011
1280	Object reallocation and reference members
1281	Virtual and dependent base classes
1282	Underspecified destructor exception-specification
1283	Static data members of classes with typedef name for linkage purposes
1284	Should the lifetime of an array be independent of that of its elements?
1285	Trivial destructors and object lifetime
1286	Equivalence of alias templates
1287	Direct initialization vs “implicit” conversion in reference binding
1288	Reference list initialization
1289	Can an alias template name the current instantiation?
1290	Lifetime of the underlying array of an initializer_list member
1291	Looking up a conversion-type-id
1292	Dependent calls with braced-init-lists containing a pack expansion
1293	String literals in constant expressions
1294	Side effects in dynamic/static initialization
1295	Binding a reference to an rvalue bit-field
1296	Ill-formed template declarations (not just definitions)
1297	Misplaced function attribute-specifier
1298	Incorrect example in overload resolution
1299	“Temporary objects” vs “temporary expressions”
1300	T() for array types
1301	Value initialization of union
1302	noexcept applied to expression of type void
1303	C language linkage for template with internal linkage
1304	Omitted array bound with string initialization
1305	alignof applied to array of unknown size
1306	Modifying an object within a const member function
1307	Overload resolution based on size of array initializer-list
1308	Completeness of class type within an exception-specification
1309	Incorrect note regarding lookup of a member of the current instantiation
1310	What is an “acceptable lookup result?”
1311	Volatile lvalues in constant expressions
1312	Simulated reinterpret_cast in constant expressions
1313	Undefined pointer arithmetic in constant expressions
1314	Pointer arithmetic within standard-layout objects
1315	Restrictions on non-type template arguments in partial specializations
1316	constexpr function requirements and class scope
1317	Unnamed scoped enumerations
1318	Syntactic ambiguities with final
1319	Error in pack expansion example
1320	Converting scoped enumerations to bool
1321	Equivalency of dependent calls
1322	Function parameter type decay in templates
1323	Nonexistent nonterminal in alignment-specifier grammar
1324	Value initialization and defaulted constructors
1325	Omitted declarator in friend declarations
1326	Deducing an array bound from an initializer-list
1327	virt-specifier in a defaulted definition
1328	Conflict in reference binding vs overload resolution
1329	Recursive deduction substitutions
1330	Delayed instantiation of noexcept specifiers
1331	const mismatch with defaulted copy constructor
1332	Handling of invalid universal-character-names
1333	Omission of const in a defaulted copy constructor
1334	Layout compatibility and cv-qualification
1335	Stringizing, extended characters, and universal-character-names
1336	Definition of “converting constructor”
1337	Partial ordering and non-deduced parameters
1338	Aliasing and allocation functions
1339	Parenthesized braced-init-list and arrays
1340	Complete type in member pointer expressions
1341	Bit-field initializers
1342	Order of initialization with multiple declarators
1343	Sequencing of non-class initialization
1344	Adding new special member functions to a class via default arguments
1345	Initialization of anonymous union class members
1346	expression-list initializers and the auto specifier
1347	Consistency of auto in multiple-declarator declarations
1348	Use of auto in a trailing-return-type
1349	Consistency of alias template redeclarations
1350	Incorrect exception specification for inherited constructors
1351	Problems with implicitly-declared exception-specifications
1352	Inconsistent class scope and completeness rules
1353	Array and variant members and deleted special member functions
1354	Destructor exceptions for temporaries in noexcept expressions
1355	Aggregates and “user-provided” constructors
1356	Exception specifications of copy assignment operators with virtual bases
1357	brace-or-equal-initializers for function and typedef members
1358	Unintentionally ill-formed constexpr function template instances
1359	constexpr union constructors
1360	constexpr defaulted default constructors
1361	Requirement on brace-or-equal-initializers of literal types
1362	Complete type required for implicit conversion to T&
1363	Triviality vs multiple default constructors
1364	constexpr function parameters
1365	Calling undefined constexpr functions
1366	Deleted constexpr constructors and virtual base classes
1367	Use of this in a constant expression
1368	Value initialization and defaulted constructors (part 2)
1369	Function invocation substitution of this
1370	identifier-list cannot contain ellipsis
1371	Deduction from T&& in return types
1372	Cross-references incorrect in conversion function template argument deduction
1373	Overload resolution changes matching reference-binding changes
1374	Qualification conversion vs difference in reference binding
1375	Reference to anonymous union?
1376	static_cast of temporary to rvalue reference
1377	Access declarations not mentioned in Annex C
1378	When is an instantiation required?
1379	Is std::initializer_list an aggregate?
1380	Type definitions in template-parameter parameter-declarations
1381	Implicitly-declared special member functions and default nothrow
1382	Dead code for constructor names
1383	Clarifying discarded-value expressions
1384	reinterpret_cast in constant expressions
1385	Syntactic forms of conversion functions for surrogate call functions
1386	Explicitly-specified partial argument list with multiple parameter packs
1387	Missing non-deduced context for decltype
1388	Missing non-deduced context following a function parameter pack
1389	Recursive reference in trailing-return-type
1390	Dependency of alias template specializations
1391	Conversions to parameter types with non-deduced template arguments
1392	Explicit conversion functions for references and non-references
1393	Pack expansions in using-declarations
1394	Incomplete types as parameters of deleted functions
1395	Partial ordering of variadic templates reconsidered
1396	Deferred instantiation and checking of non-static data member initializers
1397	Class completeness in non-static data member initializers
1398	Non-type template parameters of type std::nullptr_t
1399	Deduction with multiple function parameter packs
1400	Function pointer equality
1401	Similar types and reference compatibility
1402	Move functions too often deleted
1403	Universal-character-names in comments
1404	Object reallocation in unions
1405	constexpr and mutable members of literal types
1406	ref-qualifiers and added parameters of non-static member function templates
1407	Integral to bool conversion in converted constant expressions
1408	What is “the same aggregate initialization?”
1409	What is the second standard conversion sequence of a list-initialization sequence?
1410	Reference overload tiebreakers should apply to rvalue references
1411	More on global scope :: in nested-name-specifier
1412	Problems in specifying pointer conversions
1413	Missing cases of value-dependency
1414	Binding an rvalue reference to a reference-unrelated lvalue
1415	Missing prohibition of block-scope definition of extern object
1416	Function cv-qualifiers and typeid
1417	Pointers/references to functions with cv-qualifiers or ref-qualifier
1418	Type of initializer_list backing array
1419	Evaluation order in aggregate initialization
1420	Abstract final classes
1421	Full expressions and aggregate initialization
1422	Type of character literals containing universal-character-names
1423	Convertibility of nullptr to bool
1424	When must sub-object destructors be accessible?
1425	Base-class subobjects of standard-layout structs
1426	Allowing additional parameter types in defaulted functions
1427	Default constructor and deleted or inaccessible destructors
1428	Dynamic const objects
1429	Scope of a member template's template parameter
1430	Pack expansion into fixed alias template parameter list
1431	Exceptions from other than throw-expressions
1432	Newly-ambiguous variadic template expansions
1433	trailing-return-type and point of declaration
1434	Parenthesized braced-init-list
1435	template-id as the declarator for a class template constructor
1436	Interaction of constant expression changes with preprocessor expressions
1437	alignas in alias-declaration
1438	Non-dereference use of invalid pointers
1439	Lookup and friend template declarations
1440	Acceptable decltype-specifiers used as nested-name-specifiers
1441	Unclear wording for signal handler restrictions
1442	Argument-dependent lookup in the range-based for
1443	Default arguments and non-static data members
1444	Type adjustments of non-type template parameters
1445	Argument-dependent lookup of begin and end
1446	Member function with no ref-qualifier and non-member function with rvalue reference
1447	static_cast of bit-field lvalue to rvalue reference
1448	Integral values of type bool
1449	Narrowing conversion of negative value to unsigned type
1450	INT_MIN % -1
1451	Objects with no linkage in non-type template arguments
1452	Value-initialized objects may be constants
1453	Volatile members in literal classes?
1454	Passing constants through constexpr functions via references
1455	Lvalue converted constant expressions
1456	Address constant expression designating the one-past-the-end address
1457	Undefined behavior in left-shift
1458	Address of incomplete type vs operator&()
1459	Reference-binding tiebreakers in overload resolution
1460	What is an empty union?
1461	Narrowing conversions to bit-fields
1462	Deduction failure vs “ill-formed, no diagnostic required”
1463	extern "C" alias templates
1464	Negative array bound in a new-expression
1465	noexcept and std::bad_array_new_length
1466	Visible sequences of side effects are redundant
1467	List-initialization of aggregate from same-type object
1468	typeid, overload resolution, and implicit lambda capture
1469	Omitted bound in array new-expression
1470	Thread migration
1471	Nested type of non-dependent base
1472	odr-use of reference variables
1473	Syntax of literal-operator-id
1474	User-defined literals and <inttypes.h> format macros
1475	Errors in [[carries_dependency]] example
1476	Definition of user-defined type
1477	Definition of a friend outside its namespace
1478	template keyword for dependent template template arguments
1479	Literal operators and default arguments
1480	Constant initialization via non-constant temporary
1481	Increment/decrement operators with reference parameters
1482	Point of declaration of enumeration
1483	Non-dependent static_assert-declarations
1484	Unused local classes of function templates
1485	Out-of-class definition of member unscoped opaque enumeration
1486	Base-derived conversion in member pointer deduction
1487	When are inheriting constructors declared?
1488	abstract-pack-declarators in type-ids
1489	Is value-initialization of an array constant initialization?
1490	List-initialization from a string literal
1491	Move construction and rvalue reference members
1492	Exception specifications on template destructors
1493	Criteria for move-construction
1494	Temporary initialization for reference binding in list-initialization
1495	Partial specialization of variadic class template
1496	Triviality with deleted and missing default constructors
1497	Aggregate initialization with parenthesized string literal
1498	Lifetime of temporaries in range-based for
1499	Missing case for deleted move assignment operator
1500	Name lookup of dependent conversion function
1501	Nested braces in list-initialization
1502	Value initialization of unions with member initializers
1503	Exceptions during copy to exception object
1504	Pointer arithmetic after derived-base conversion
1505	Direct binding of reference to temporary in list-initialization
1506	Value category of initializer_list object
1507	Value initialization with trivial inaccessible default constructor
1508	Template initializer-list constructors
1509	Definition of “non-template function”
1510	cv-qualified references via decltype
1511	const volatile variables and the one-definition rule
1512	Pointer comparison vs qualification conversions
1513	initializer_list deduction failure
1514	Ambiguity between enumeration definition and zero-length bit-field
1515	Modulo 2n arithmetic for implicitly-unsigned types
1516	Definition of “virtual function call”
1517	Unclear/missing description of behavior during construction/destruction
1518	Explicit default constructors and copy-list-initialization
1519	Conflicting default and variadic constructors
1520	Alias template specialization vs pack expansion
1521	T{expr} with reference types
1522	Access checking for initializer_list array initialization
1523	Point of declaration in range-based for
1524	Incompletely-defined class template base
1525	Array bound inference in temporary array
1526	Dependent-class lookup in the current instantiation
1527	Assignment from braced-init-list
1528	Repeated cv-qualifiers in declarators
1529	Nomenclature for variable vs reference non-static data member
1530	Member access in out-of-lifetime objects
1531	Definition of “access” (verb)
1532	Explicit instantiation and member templates
1533	Function pack expansion for member initialization
1534	cv-qualification of prvalue of type “array of class”
1535	typeid in core constant expressions
1536	Overload resolution with temporary from initializer list
1537	Optional compile-time evaluation of constant expressions
1538	C-style cast in braced-init-list assignment
1539	Definition of “character type”
1540	Use of address constants in constant expressions
1541	cv void return types
1542	Compound assignment of braced-init-list
1543	Implicit conversion sequence for empty initializer list
1544	Linkage of member of unnamed namespace
1545	friend function templates defined in class templates
1546	Errors in function template default arguments
1547	typename keyword in alias-declarations
1548	Copy/move construction and conversion functions
1549	Overloaded comma operator with void operand
1550	Parenthesized throw-expression operand of conditional-expression
1551	Wording problems in using-declaration specification
1552	exception-specifications and defaulted special member functions
1553	sizeof and xvalue bit-fields
1554	Access and alias templates
1555	Language linkage and function type compatibility
1556	Constructors and explicit conversion functions in direct initialization
1557	Language linkage of converted lambda function pointer
1558	Unused arguments in alias template specializations
1559	String too long in initializer list of new-expression
1560	Gratuitous lvalue-to-rvalue conversion in conditional-expression with throw-expression operand
1561	Aggregates with empty base classes
1562	Non-static data member initializers and union ctor-initializer
1563	List-initialization and overloaded function disambiguation
1564	Template argument deduction from an initializer list
1565	Copy elision and lifetime of initializer_list underlying array
1566	Should new std::initializer_list<T> be ill-formed?
1567	Inheriting constructors and copy/move constructors
1568	Temporary lifetime extension with intervening cast
1569	Deducing a function parameter pack before ellipsis
1570	Address of subobject as non-type template argument
1571	cv-qualification for indirect reference binding via conversion function
1572	Incorrect example for rvalue reference binding via conversion function
1573	Inherited constructor characteristics
1574	Explicitly-defaulted constexpr functions in wrapper templates
1575	Incorrect definition of “strict pointer safety”
1576	Discarded-value volatile xvalues
1577	Unnecessary restrictions on partial specializations
1578	Value-initialization of aggregates
1579	Return by converting move constructor
1580	Default arguments in explicit instantiations
1581	When are constexpr member functions defined?
1582	Template default arguments and deduction failure
1583	Incorrect example of unspecified behavior
1584	Deducing function types from cv-qualified types
1585	Value category of member access of rvalue reference member
1586	Naming a destructor via decltype
1587	constexpr initialization and nested anonymous unions
1588	Deducing cv-qualified auto
1589	Ambiguous ranking of list-initialization sequences
1590	Bypassing non-copy/move constructor copying
1591	Deducing array bound and element type from initializer list
1592	When do template parameters match?
1593	“Parameter type” of special member functions
1594	Lazy declaration of special members vs overload errors
1595	Constructors “involved in” subobject initialization
1596	Non-array objects as array[1]
1597	Misleading constexpr example
1598	Criterion for equality of pointers to members
1599	Lifetime of initializer_list underlying array
1600	Erroneous reference initialization in example
1601	Promotion of enumeration with fixed underlying type
1602	Linkage of specialization vs linkage of template arguments
1603	Errors resulting from giving unnamed namespaces internal linkage
1604	Double temporaries in reference initialization
1605	Misleading parenthetical comment for explicit destructor call
1606	sizeof closure class
1607	Lambdas in template parameters
1608	Operator lookup in trailing return type
1609	Default arguments and function parameter packs
1610	Cv-qualification in deduction of reference to array
1611	Deleted default constructor for abstract class
1612	Implicit lambda capture and anonymous unions
1613	Constant expressions and lambda capture
1614	Address of pure virtual function vs odr-use
1615	Alignment of types, variables, and members
1616	Disambiguation parsing and template parameters
1617	alignas and non-defining declarations
1618	Gratuitously-unsigned underlying enum type
1619	Definition of current instantiation
1620	User-defined literals and extended integer types
1621	Member initializers in anonymous unions
1622	Empty aggregate initializer for union
1623	Deleted default union constructor and member initializers
1624	Destruction of union members with member initializers
1625	Adding spaces between tokens in stringizing
1626	constexpr member functions in brace-or-equal-initializers
1627	Agreement of dependent alignas specifiers
1628	Deallocation function templates
1629	Can a closure class be a literal type?
1630	Multiple default constructor templates
1631	Incorrect overload resolution for single-element initializer-list
1632	Lambda capture in member initializers
1633	Copy-initialization in member initialization
1634	Temporary storage duration
1635	How similar are template default arguments to function default arguments?
1636	Bits required for negative enumerator values
1637	Recursion in constexpr template default constructor
1638	Declaring an explicit specialization of a scoped enumeration
1639	exception-specifications and pointer/pointer-to-member expressions
1640	Array of abstract instance of class template
1641	Assignment in member initializer
1642	Missing requirements for prvalue operands
1643	Default arguments for template parameter packs
1644	Equivalent exception-specifications in function template declarations
1645	Identical inheriting constructors via default arguments
1646	decltype-specifiers, abstract classes, and deduction failure
1647	Type agreement of non-type template arguments in partial specializations
1648	thread_local vs block extern declarations
1649	Error in the syntax of mem-initializer-list
1650	Class prvalues in reference initialization
1651	Lifetime extension of temporary via reference to subobject
1652	Object addresses in constexpr expressions
1653	Removing deprecated increment of bool
1654	Literal types and constexpr defaulted constructors
1655	Line endings in raw string literals
1656	Encoding of numerically-escaped characters
1657	Attributes for namespaces and enumerators
1658	Deleted default constructor for abstract class via destructor
1659	Initialization order of thread_local template static data members
1660	member-declaration requirements and unnamed bit-fields
1661	Preservation of infinite loops
1662	Capturing function parameter packs
1663	Capturing an empty pack expansion
1664	Argument-dependent lookup of lambdas used in default arguments
1665	Declaration matching in explicit instantiations
1666	Address constant expressions
1667	Function exiting via exception called by destructor during unwinding
1668	Parameter type determination still not clear enough
1669	auto return type for main
1670	auto as conversion-type-id
1671	Unclear rules for deduction with cv-qualification
1672	Layout compatibility with multiple empty bases
1673	Clarifying overload resolution for the second step of copy-initialization
1674	Return type deduction for address of function
1675	Size limit for automatic array object
1676	auto return type for allocation and deallocation functions
1677	Constant initialization via aggregate initialization
1678	Naming the type of an array of runtime bound
1679	Range-based for and array of runtime bound
1680	Including <initializer_list> for range-based for
1681	init-captures and nested lambdas
1682	Overly-restrictive rules on function templates as allocation functions
1683	Incorrect example after constexpr changes
1684	Static constexpr member functions for non-literal classes
1685	Value category of noexcept expression
1686	Which variables are “explicitly declared const?”
1687	Conversions of operands of built-in operators
1688	Volatile constexpr variables
1689	Syntactic nonterminal for operand of alignas
1690	Associated namespace for local type
1691	Argument-dependent lookup and opaque enumerations
1692	Associated namespaces of doubly-nested classes
1693	Superfluous semicolons in class definitions
1694	Restriction on reference to temporary as a constant expression
1695	Lifetime extension via init-capture
1696	Temporary lifetime and non-static data member initializers
1697	Lifetime extension and copy elision
1698	Files ending in \
1699	Does befriending a class befriend its friends?
1700	Does the special rvalue-reference deduction apply to alias templates?
1701	Array vs sequence in object representation
1702	Rephrasing the definition of “anonymous union”
1703	Language linkage of names of functions with internal linkage
1704	Type checking in explicit instantiation of variable templates
1705	Unclear specification of “more specialized”
1706	alignas pack expansion syntax
1707	template in elaborated-type-specifier without nested-name-specifier
1708	overly-strict requirements for names with C language linkage
1709	Stringizing raw string literals containing newline
1710	Missing template keyword in class-or-decltype
1711	Missing specification of variable template partial specializations
1712	constexpr variable template declarations
1713	Linkage of variable template specializations
1714	odr-use of this from a local class
1715	Access and inherited constructor templates
1716	When are default arguments evaluated?
1717	Missing specification of type of binary literal
1718	Macro invocation spanning end-of-file
1719	Layout compatibility and cv-qualification revisited
1720	Macro invocation in #include directive
1721	Diagnosing ODR violations for static data members
1722	Should lambda to function pointer conversion function be noexcept?
1723	Multicharacter user-defined character literals
1724	Unclear rules for deduction failure
1725	Trailing return type with nested function declarator
1726	Declarator operators and conversion function
1727	Type of a specialization of a variable template
1728	Type of an explicit instantiation of a variable template
1729	Matching declarations and definitions of variable templates
1730	Can a variable template have an unnamed type?
1731	is_trivially_X and definitions of special member functions
1732	Defining types in conditions and range-based for statements
1733	Return type and value for operator= with ref-qualifier
1734	Nontrivial deleted copy functions
1735	Out-of-range literals in user-defined-literals
1736	Inheriting constructor templates in a local class
1737	Type dependence of call to a member of the current instantiation
1738	Explicit instantiation/specialization of inheriting constructor templates
1739	Conversion of floating point to enumeration
1740	Disambiguation of noexcept
1741	odr-use of class object in lvalue-to-rvalue conversion
1742	using-declarations and scoped enumerators
1743	init-captures in nested lambdas
1744	Unordered initialization for variable template specializations
1745	thread_local constexpr variable
1746	Are volatile scalar types trivially copyable?
1747	Constant initialization of reference to function
1748	Placement new with a null pointer
1749	Confusing definition for constant initializer
1750	“Argument” vs “parameter”
1751	Non-trivial operations vs non-trivial initialization
1752	Right-recursion in mem-initializer-list
1753	decltype-specifier in nested-name-specifier of destructor
1754	Declaration of partial specialization of static data member template
1755	Out-of-class partial specializations of member templates
1756	Direct-list-initialization of a non-class object
1757	Const integral subobjects
1758	Explicit conversion in copy/move list initialization
1759	UTF-8 code units in plain char
1760	Access of member corresponding to init-capture
1761	Runtime check on size of automatic array
1762	Reserved identifier used in literal-operator-id example
1763	Length mismatch in template type deduction
1764	Hiding of function from using-declaration by signature
1765	Overflow of enumeration used as enumerator value
1766	Values outside the range of the values of an enumeration
1767	Scoped enumeration in a switch statement
1768	Zero-element array of runtime bound
1769	Catching a base class of the exception object
1770	Type matching of non-type template parameters and arguments
1771	Restricted lookup in nested-name-specifier
1772	__func__ in a lambda body
1773	Out-of-lifetime lvalue-to-rvalue conversion
1774	Discrepancy between subobject destruction and stack unwinding
1775	Undefined behavior of line splice in raw string literal
1776	Replacement of class objects containing reference members
1777	Empty pack expansion in dynamic-exception-specification
1778	exception-specification in explicitly-defaulted functions
1779	Type dependency of __func__
1780	Explicit instantiation/specialization of generic lambda operator()
1781	Converting from nullptr_t to bool in overload resolution
1782	Form of initialization for nullptr_t to bool conversion
1783	Why are virtual destructors non-trivial?
1784	Concurrent execution during static local initialization
1785	Conflicting diagnostic requirements for template definitions
1786	Effect of merging allocations on memory leakage
1787	Uninitialized unsigned char values
1788	Sized deallocation of array of non-class type
1789	Array reference vs array decay in overload resolution
1790	Ellipsis following function parameter pack
1791	Incorrect restrictions on cv-qualifier-seq and ref-qualifier
1792	Incorrect example of explicit specialization of member enumeration
1793	thread_local in explicit specializations
1794	template keyword and alias templates
1795	Disambiguating original-namespace-definition and extension-namespace-definition
1796	Is all-bits-zero for null characters a meaningful requirement?
1797	Are all bit patterns of unsigned char distinct numbers?
1798	exception-specifications of template arguments
1799	mutable and non-explicit const qualification
1800	Pointer to member of nested anonymous union
1801	Kind of expression referring to member of anonymous union
1802	char16_t string literals and surrogate pairs
1803	opaque-enum-declaration as member-declaration
1804	Partial specialization and friendship
1805	Conversions of array operands in conditional-expressions
1806	Virtual bases and move-assignment
1807	Order of destruction of array elements after an exception
1808	Constructor templates vs default constructors
1809	Narrowing and template argument deduction
1810	Invalid ud-suffixes
1811	Lookup of deallocation function in a virtual destructor definition
1812	Omission of template in a typename-specifier
1813	Direct vs indirect bases in standard-layout classes
1814	Default arguments in lambda-expressions
1815	Lifetime extension in aggregate initialization
1816	Unclear specification of bit-field values
1817	Linkage specifications and nested scopes
1818	Visibility and inherited language linkage
1819	Acceptable scopes for definition of partial specialization
1820	Qualified typedef names
1821	Qualified redeclarations in a class member-specification
1822	Lookup of parameter names in lambda-expressions
1823	String literal uniqueness in inline functions
1824	Completeness of return type vs point of instantiation
1825	Partial ordering between variadic and non-variadic function templates
1826	const floating-point in constant expressions
1827	Reference binding with ambiguous conversions
1828	nested-name-specifier ambiguity
1829	Dependent unnamed types
1830	Repeated specifiers
1831	Explicitly vs implicitly deleted move constructors
1832	Casting to incomplete enumeration
1833	friend declarations naming implicitly-declared member functions
1834	Constant initialization binding a reference to an xvalue
1835	Dependent member lookup before <
1836	Use of class type being defined in trailing-return-type
1837	Use of this in friend and local class declarations
1838	Definition via unqualified-id and using-declaration
1839	Lookup of block-scope extern declarations
1840	Non-deleted explicit specialization of deleted function template
1841	< following template injected-class-name
1842	Unevaluated operands and “carries a dependency”
1843	Bit-field in conditional operator with throw operand
1844	Defining “immediate context”
1845	Point of instantiation of a variable template specialization
1846	Declaring explicitly-defaulted implicitly-deleted functions
1847	Clarifying compatibility during partial ordering
1848	Parenthesized constructor and destructor declarators
1849	Variable templates and the ODR
1850	Differences between definition context and point of instantiation
1851	decltype(auto) in new-expressions
1852	Wording issues regarding decltype(auto)
1853	Defining “allocated storage”
1854	Disallowing use of implicitly-deleted functions
1855	Out-of-lifetime access to nonstatic data members
1856	Indirect nested classes of class templates
1857	Additional questions about bits
1858	Comparing pointers to union members
1859	UTF-16 in char16_t string literals
1860	What is a “direct member?”
1861	Values of a bit-field
1862	Determining “corresponding members” for friendship
1863	Requirements on thrown object type to support std::current_exception()
1864	List-initialization of array objects
1865	Pointer arithmetic and multi-level qualification conversions
1866	Initializing variant members with non-trivial destructors
1867	Function/expression ambiguity with qualified parameter name
1868	Meaning of “placeholder type”
1869	thread_local vs linkage-specifications
1870	Contradictory wording about definitions vs explicit specialization/instantiation
1871	Non-identifier characters in ud-suffix
1872	Instantiations of constexpr templates that cannot appear in constant expressions
1873	Protected member access from derived class friends
1874	Type vs non-type template parameters with class keyword
1875	Reordering declarations in class scope
1876	Preventing explicit specialization
1877	Return type deduction from return with no operand
1878	operator auto template
1879	Inadequate definition of alignment requirement
1880	When are parameter objects destroyed?
1881	Standard-layout classes and unnamed bit-fields
1882	Reserved names without library use
1883	Protected access to constructors in mem-initializers
1884	Unclear requirements for same-named external-linkage entities
1885	Return value of a function is underspecified
1886	Language linkage for main()
1887	Problems with :: as nested-name-specifier
1888	Implicitly-declared default constructors and explicit
1889	Unclear effect of #pragma on conformance
1890	Member type depending on definition of member function
1891	Move constructor/assignment for closure class
1892	Use of auto in function type
1893	Function-style cast with braced-init-lists and empty pack expansions
1894	typedef-names and using-declarations
1895	Deleted conversions in conditional operator operands
1896	Repeated alias templates
1897	ODR vs alternative tokens
1898	Use of “equivalent” in overload resolution
1899	Value-dependent constant expressions
1900	Do friend declarations count as “previous declarations”?
1901	punctuator referenced but not defined
1902	What makes a conversion “otherwise ill-formed”?
1903	What declarations are introduced by a non-member using-declaration?
1904	Default template arguments for members of class templates
1905	Dependent types and injected-class-names
1906	Name lookup in member friend declaration
1907	using-declarations and default arguments
1908	Dual destructor lookup and template-ids
1909	Member class template with the same name as the class
1910	“Shall” requirement applied to runtime behavior
1911	constexpr constructor with non-literal base class
1912	exception-specification of defaulted function
1913	decltype((x)) in lambda-expressions
1914	Duplicate standard attributes
1915	Potentially-invoked destructors in non-throwing constructors
1916	“Same cv-unqualified type”
1917	decltype-qualified enumeration names
1918	friend templates with dependent scopes
1919	Overload resolution for ! with explicit conversion operator
1920	Qualification mismatch in pseudo-destructor-name
1921	constexpr constructors and point of initialization of const variables
1922	Injected class template names and default arguments
1923	Lvalues of type void
1924	Definition of “literal” and kinds of literals
1925	Bit-field prvalues
1926	Potential results of subscript operator
1927	Lifetime of temporaries in init-captures
1928	Triviality of deleted special member functions
1929	template keyword following namespace nested-name-specifier
1930	init-declarator-list vs member-declarator-list
1931	Default-constructible and copy-assignable closure types
1932	Bit-field results of conditional operators
1933	Implementation limit for initializer-list elements
1934	Relaxing exception-specification compatibility requirements
1935	Reuse of placement arguments in deallocation
1936	Dependent qualified-ids
1937	Incomplete specification of function pointer from lambda
1938	Should hosted/freestanding be implementation-defined?
1939	Argument conversions to nondeduced parameter types revisited
1940	static_assert in anonymous unions
1941	SFINAE and inherited constructor default arguments
1942	Incorrect reference to trailing-return-type
1943	Unspecified meaning of “bit”
1944	New C incompatibilities
1945	Friend declarations naming members of class templates in non-templates
1946	exception-specifications vs pointer dereference
1947	Digit separators following non-octal prefix
1948	exception-specification of replacement global new
1949	“sequenced after” instead of “sequenced before”
1950	Restructuring description of ranks of conversion sequences
1951	Cv-qualification and literal types
1952	Constant expressions and library undefined behavior
1953	Data races and common initial sequence
1954	typeid null dereference check in subexpressions
1955	#elif with invalid controlling expression
1956	Reuse of storage of automatic variables
1957	decltype(auto) with direct-list-initialization
1958	decltype(auto) with parenthesized initializer
1959	Inadvertently inherited copy constructor
1960	Visibility of entity named in class-scope using-declaration
1961	Potentially-concurrent actions within a signal handler
1962	Type of __func__
1963	Implementation-defined identifier characters
1964	opaque-enum-declaration in alias-declaration?
1965	Explicit casts to reference types
1966	Colon following enumeration elaborated-type-specifier
1967	Temporary lifetime and move-elision
1968	Address of typeid in constant expressions
1969	Missing exclusion of ~S as an ordinary function name
1970	Ambiguity resolution for (T())*x
1971	Unclear disambiguation of destructor and operator~
1972	Identifier character restrictions in non-identifiers
1973	Which parameter-declaration-clause in a lambda-expression?
1974	Redundant specification of non-type typename-specifier
1975	Permissible declarations for exception-specifications
1976	Ambiguity of namespace-aliases
1977	Contradictory results of failed destructor lookup
1978	Redundant description of explicit constructor use
1979	Alias template specialization in template member definition
1980	Equivalent but not functionally-equivalent redeclarations
1981	Implicit contextual conversions and explicit
1982	Deduction extending parameter pack
1983	Inappropriate use of virt-specifier
1984	Lossless narrowing conversions
1985	Unknown bound array member with brace-or-equal-initializer
1986	odr-use and delayed initialization
1987	constexpr static data members across translation units
1988	Ambiguity between dependent and non-dependent bases in implicit member access
1989	Insufficient restrictions on parameters of postfix operators
1990	Ambiguity due to optional decl-specifier-seq
1991	Inheriting constructors vs default arguments
1992	new (std::nothrow) int[N] can throw
1993	Use of template<> defining member of explicit specialization
1994	Confusing wording regarding multiple template<> prefixes
1995	exception-specifications and non-type template parameters
1996	Reference list-initialization ignores conversion functions
1997	Placement new and previous initialization
1998	Additional sources of xvalue expressions
1999	Representation of source characters as universal-character-names
2000	header-name outside #include directive
2001	non-directive is underspecified
2002	White space within preprocessing directives
2003	Zero-argument macros incorrectly specified
2004	Unions with mutable members in constant expressions
2005	Incorrect constexpr reference initialization requirements
2006	Cv-qualified void types
2007	Argument-dependent lookup for operator=
2008	Default template-arguments underspecified
2009	Unclear specification of class scope
2010	exception-specifications and conversion operators
2011	Unclear effect of reference capture of reference
2012	Lifetime of references
2013	Pointer subtraction in large array
2014	Unneeded deallocation signatures
2015	odr-use of deleted virtual functions
2016	Confusing wording in description of conversion function
2017	Flowing off end is not equivalent to no-expression return
2018	Qualification conversion vs reference binding
2019	Member references omitted from description of storage duration
2020	Inadequate description of odr-use of implicitly-invoked functions
2021	Function template redeclaration via alias template
2022	Copy elision in constant expressions
2023	Composite reference result type of conditional operator
2024	Dependent types and unexpanded parameter packs
2025	Declaration matching via alias templates
2026	Zero-initialization and constexpr
2027	Unclear requirements for multiple alignas specifiers
2028	Converting constructors in rvalue reference initialization
2029	Abstract class return type in decltype operand
2030	Access of injected-class-name with template arguments
2031	Missing incompatibility for &&
2032	Default template-arguments of variable templates
2033	Redundant restriction on partial specialization argument
2034	Deprecating uncaught_exception()
2035	Multi-section example is confusing
2036	Refactoring parameters-and-qualifiers
2037	Alias templates and template declaration matching
2038	Document C++14 incompatibility of new braced deduction rule
2039	Constant conversions to bool
2040	trailing-return-type no longer ambiguous
2041	Namespace for explicit class template specialization
2042	Exceptions and deallocation functions
2043	Generalized template arguments and array-to-pointer decay
2044	decltype(auto) and void
2045	“Identical” template parameter lists
2046	Incomplete thread specifications
2047	Coordinating “throws anything” specifications
2048	C-style casts that cast away constness vs static_cast
2049	List initializer in non-type template default argument
2050	Consolidate specification of linkage
2051	Simplifying alias rules
2052	Template argument deduction vs overloaded operators
2053	auto in non-generic lambdas
2054	Missing description of class SFINAE
2055	Explicitly-specified non-deduced parameter packs
2056	Member function calls in partially-initialized class objects
2057	Template template arguments with default arguments
2058	More errors from internal-linkage namespaces
2059	Linkage and deduced return types
2060	Deduced return type for explicit specialization
2061	Inline namespace after simplifications
2062	Class template redeclaration requirements
2063	Type/nontype hiding in class scope
2064	Conflicting specifications for dependent decltype-specifiers
2065	Current instantiation of a partial specialization
2066	Does type-dependent imply value-dependent?
2067	Generated variadic templates requiring empty pack
2068	When can/must a defaulted virtual destructor be defined?
2069	Do destructors have names?
2070	using-declaration with dependent nested-name-specifier
2071	typedef with no declarator
2072	Default argument instantiation for member functions of templates
2073	Allocating memory for exception objects
2074	Type-dependence of local class of function template
2075	Passing short initializer lists to array reference parameters
2076	List-initialization of arguments for constructor parameters
2077	Overload resolution and invalid rvalue-reference initialization
2078	Name lookup of mem-initilizer-id
2079	[[ appearing in a balanced-token-seq
2080	Example with empty anonymous union member
2081	Deduced return type in redeclaration or specialization of function template
2082	Referring to parameters in unevaluated operands of default arguments
2083	Incorrect cases of odr-use
2084	NSDMIs and deleted union default constructors
2085	Invalid example of adding special member function via default argument
2086	Reference odr-use vs implicit capture
2087	Left shift of negative value by zero bits
2088	Late tiebreakers in partial ordering
2089	Restricting selection of builtin overloaded operators
2090	Dependency via non-dependent base class
2091	Deducing reference non-type template arguments
2092	Deduction failure and overload resolution
2093	Qualification conversion for pointer-to-member handler matching
2094	Trivial copy/move constructor for class with volatile member
2095	Capturing rvalue references to functions by copy
2096	Constraints on literal unions
2097	Lambdas and noreturn attribute
2098	Is uncaught_exceptions() per-thread?
2099	Inferring the bound of an array static data member
2100	Value-dependent address of static data member of class template
2101	Incorrect description of type- and value-dependence
2102	Constructor checking in new-expression
2103	Lvalue-to-rvalue conversion is irrelevant in odr-use of a reference
2104	Internal-linkage constexpr references and ODR requirements
2105	When do the arguments for a parameter pack end?
2106	Unclear restrictions on use of function-type template arguments
2107	Lifetime of temporaries for default arguments in array copying
2108	Conversions to non-class prvalues in reference initialization
2109	Value dependence underspecified
2110	Overload resolution for base class conversion and reference/non-reference
2111	Array temporaries in reference binding
2112	new auto{x}
2113	Incompete specification of types for declarators
2114	Missing description of incompatibility from aggregate NSDMIs
2115	Order of implicit destruction vs release of automatic storage
2116	Direct or copy initialization for omitted aggregate initializers
2117	Explicit specializations and constexpr function templates
2118	Stateful metaprogramming via friend injection
2119	Disambiguation of multi-level covariant return type
2120	Array as first non-static data member in standard-layout class
2121	More flexible lambda syntax
2122	Glvalues of void type
2123	Omitted constant initialization of local static variables
2124	Signature of constructor template
2125	Copy elision and comma operator
2126	Lifetime-extended temporaries in constant expressions
2127	Partial specialization and nullptr
2128	Imprecise rule for reference member initializer
2129	Non-object prvalues and constant expressions
2130	Over-aligned types in new-expressions
2131	Ambiguity with opaque-enum-declaration
2132	Deprecated default generated copy constructors
2133	Converting std::nullptr_t to bool
2134	Objectless references to non-static member functions
2135	mem-initializers for virtual bases of abstract classes
2136	Argument-dependent lookup and initializer lists
2137	List-initialization from object of same type
2138	Explicit member specialization vs implicit instantiation
2139	Floating-point requirements for integer representation
2140	Lvalue-to-rvalue conversion of std::nullptr_t
2141	Ambiguity in new-expression with elaborated-type-specifier
2142	Missing definition of associated classes and namespaces
2143	Value-dependency via injected-class-name
2144	Function/variable declaration ambiguity
2145	Parenthesized declarator in function definition
2146	Scalar object vs memory location in definition of “unsequenced”
2147	Initializer-list arguments and pack deduction
2148	Thread storage duration and order of initialization
2149	Brace elision and array length deduction
2150	Initializer list array lifetime
2151	Exception object is not created
2152	Can an alternative token be used as a ud-suffix?
2153	pure-specifier in friend declaration
2154	Ambiguity of pure-specifier
2155	Defining classes and enumerations via using-declarations
2156	Definition of enumeration declared by using-declaration
2157	Further disambiguation of enumeration elaborated-type-specifier
2158	Polymorphic behavior during destruction
2159	Lambda capture and local thread_local variables
2160	Issues with partial ordering
2161	Explicit instantiation declaration and “preceding initialization”
2162	Capturing this by reference
2163	Labels in constexpr functions
2164	Name hiding and using-directives
2165	Namespaces, declarative regions, and translation units
2166	Unclear meaning of “undefined constexpr function”
2167	Non-member references with lifetimes within the current evaluation
2168	Narrowing conversions and +/- infinity
2169	Narrowing conversions and overload resolution
2170	Unclear definition of odr-use for arrays
2171	Triviality of copy constructor with less-qualified parameter
2172	Multiple exceptions with one exception object
2173	Partial specialization with non-deduced contexts
2174	Unclear rules for friend definitions in templates
2175	Ambiguity with attribute in conversion operator declaration
2176	Destroying the returned object when a destructor throws
2177	Placement operator delete and parameter copies
2178	Substitution of dependent template arguments in default template arguments
2179	Required diagnostic for partial specialization after first use
2180	Virtual bases in destructors and defaulted assignment operators
2181	Normative requirements in an informative Annex
2182	Pointer arithmetic in array-like containers
2183	Problems in description of potential exceptions
2184	Missing C compatibility entry for decrement of bool
2185	Cv-qualified numeric types
2186	Unclear point that “preceding initialization” must precede
2187	Protected members and access via qualified-id
2188	empty-declaration grammar ambiguity
2189	Surrogate call template
2190	Insufficient specification of __has_include
2191	Incorrect result for noexcept(typeid(v))
2192	Constant expressions and order-of-eval undefined behavior
2193	numeric_limits<int>::radix and digits
2194	Impossible case in list initialization
2195	Unsolicited reading of trailing volatile members
2196	Zero-initialization with virtual base classes
2197	Overload resolution and deleted special member functions
2198	Linkage of enumerators
2199	Typedefs and tags
2200	Conversions in template argument deduction
2201	Cv-qualification of array types
2202	When does default argument instantiation occur?
2203	Defaulted copy/move constructors and UDCs
2204	Naming delegated constructors
2205	Restrictions on use of alignas
2206	Composite type of object and function pointers
2207	Alignment of allocation function return value
2208	static_assert-declaration does not declare a member
2209	Destruction of constructed array elements
2210	Principal/target constructor confusion
2211	Hiding by lambda captures and parameters
2212	Typedef changing linkage after use
2213	Forward declaration of partial specializations
2214	Missing requirement on representation of integer values
2215	Redundant description of language linkage in function call
2216	Exception specifications in unevaluated contexts
2217	constexpr constructors for non-literal types
2218	Ambiguity and namespace aliases
2219	Dynamically-unreachable handlers
2220	Hiding index variable in range-based for
2221	Copying volatile objects
2222	Additional contexts where instantiation is not required
2223	Multiple alignas specifiers
2224	Member subobjects and base-class casts
2225	reinterpret_cast to same floating-point type
2226	Xvalues vs lvalues in conditional expressions
2227	Destructor access and default member initializers
2228	Ambiguity resolution for cast to function type
2229	Volatile unnamed bit-fields
2230	Linkage of extern "C" function in unnamed namespace
2231	Class member access to static data member template
2232	thread_local anonymous unions
2233	Function parameter packs following default arguments
2234	Missing rules for simple-template-id as class-name
2235	Partial ordering and non-dependent types
2236	When is an alias template specialization dependent?
2237	Can a template-id name a constructor?
2238	Contradictory alignment requirements for allocation
2239	Sized deallocation with a trivial destructor
2240	this is not odr-used in a constant expression
2241	Overload resolution is not invoked with a single function
2242	ODR violation with constant initialization possibly omitted
2243	Incorrect use of implicit conversion sequence
2244	Base class access in aggregate initialization
2245	Point of instantiation of incomplete class template
2246	Access of indirect virtual base class constructors
2247	Lambda capture and variable argument list
2248	Problems with sized delete
2249	identifiers and id-expressions
2250	Implicit instantiation, destruction, and TUs
2251	Unreachable enumeration list-initialization
2252	Enumeration list-initialization from the same type
2253	Unnamed bit-fields and zero-initialization
2254	Standard-layout classes and bit-fields
2255	Instantiated static data member templates
2256	Lifetime of trivially-destructible objects
2257	Lifetime extension of references vs exceptions
2258	Storage deallocation during period of destruction
2259	Unclear context describing ambiguity
2260	Explicit specializations of deleted member functions
2261	Explicit instantiation of in-class friend definition
2262	Attributes for asm-definition
2263	Default argument instantiation for friends
2264	Memberwise copying with indeterminate value
2265	Delayed pack expansion and member redeclarations
2266	Has dependent type vs is type-dependent
2267	Copy-initialization of temporary in reference direct-initialization
2268	Unions with mutable members in constant expressions revisited
2269	Additional recursive references in aggregate DMIs
2270	Non-inline functions and explicit instantiation declarations
2271	Aliasing this
2272	Implicit initialization of aggregate members of reference type
2273	Inheriting constructors vs implicit default constructor
2274	Generic lambda capture vs constexpr if
2275	Type-dependence of function template
2276	Dependent noexcept and function type-dependence
2277	Ambiguity inheriting constructors with default arguments
2278	Copy elision in constant expressions reconsidered
2279	Multiple attribute-specifiers in one attribute-list
2280	Matching a usual deallocation function with placement new
2281	Consistency of aligned operator delete replacement
2282	Consistency with mismatched aligned/non-over-aligned allocation/deallocation functions
2283	Missing complete type requirements
2284	Sequencing of braced-init-list arguments
2285	Issues with structured bindings
2286	Assignment evaluation order
2287	Pointer-interconvertibility in non-standard-layout unions
2288	Contradictory optionality in simple-declaration
2289	Uniqueness of structured binding names
2290	Unclear specification for overload resolution and deleted special member functions
2291	Implicit conversion sequences in non-call contexts
2292	simple-template-id is ambiguous between class-name and type-name
2293	Requirements for simple-template-id used as a class-name
2294	Dependent auto static data members
2295	Aggregates with deleted defaulted constructors
2296	Are default argument instantiation failures in the “immediate context”?
2297	Unclear specification of atomic operations
2298	Actions and expression evaluation
2299	constexpr vararg functions
2300	Lambdas in multiple definitions
2301	Value-initialization and constexpr constructor evaluation
2302	Address comparison between different member subobjects
2303	Partial ordering and recursive variadic inheritance
2304	Incomplete type vs overload resolution
2305	Explicit instantiation of constexpr or inline variable template
2306	Nested friend templates of class templates
2307	Unclear definition of “equivalent to a nontype template parameter”
2308	Structured bindings and lambda capture
2309	Restrictions on nested statements within constexpr functions
2310	Type completeness and derived-to-base pointer conversions
2311	Missed case for guaranteed copy elision
2312	Structured bindings and mutable
2313	Redeclaration of structured binding reference variables
2314	Structured bindings and lambda capture
2315	What is the “corresponding special member” of a variant member?
2316	Simplifying class conversions in conditional expressions
2317	Self-referential default member initializers
2318	Nondeduced contexts in deduction from a braced-init-list
2319	Nested brace initialization from same type
2320	constexpr if and boolean conversions
2321	Conditional operator and cv-qualified class prvalues
2322	Substitution failure and lexical order
2323	Expunge POD
2324	Size of base class subobject
2325	std::launder and reuse of character buffers
2326	Type deduction with initializer list containing ambiguous functions
2327	Copy elision for direct-initialization with a conversion function
2328	Unclear presentation style of template argument deduction rules
2329	Virtual base classes and generated assignment operators
2330	Missing references to variable templates
2331	Redundancy in description of class scope
2332	template-name as simple-type-name vs injected-class-name
2333	Escape sequences in UTF-8 character literals
2334	Creation of objects by typeid
2335	Deduced return types vs member types
2336	Destructor characteristics vs potentially-constructed subobjects
2337	Incorrect implication of logic ladder for conversion sequence tiebreakers
2338	Undefined behavior converting to short enums with fixed underlying types
2339	Underspecified template arguments in structured bindings
2340	Reference collapsing and structured bindings
2341	Structured bindings with static storage duration
2342	Reference reinterpret_cast and pointer-interconvertibility
2343	void* non-type template parameters
2344	Redeclaration of names in init-statements
2345	Jumping across initializers in init-statements and conditions
2346	Local variables in default arguments
2347	Passing short scoped enumerations to ellipsis
2348	Non-templated constexpr if
2349	Class/enumeration names vs conditions
2350	Forwarding references and deduction guides
2351	void{}
2352	Similar types and reference binding
2353	Potential results of a member access expression for a static data member
2354	Extended alignment and object representation
2355	Deducing noexcept-specifiers
2356	Base class copy and move constructors should not be inherited
2357	Lookup in member function declarations
2358	Explicit capture of value
2359	Unintended copy initialization with designated initializers
2360	[[maybe_unused]] and structured bindings
2361	Unclear description of longjmp undefined behavior
2362	__func__ should be constexpr
2363	Opaque enumeration friend declarations
2364	Constant expressions, aggregate initialization, and modifications
2365	Confusing specification for dynamic_cast
2366	Can default initialization be constant initialization?
2367	Lambdas in default arguments vs the ODR
2368	Differences in relational and three-way constant comparisons
2369	Ordering between constraints and substitution
2370	friend declarations of namespace-scope functions
2371	Use of the English term “attributes” is confusing
2372	Incorrect matching rules for block-scope extern declarations
2373	Incorrect handling of static member function templates in partial ordering
2374	Overly permissive specification of enum direct-list-initialization
2375	Multiple redeclarations of constexpr static data members
2376	Class template argument deduction with array declarator
2377	Explicit copy constructor vs function viability
2378	Inconsistent grammar for reference init-capture of pack
2379	Missing prohibition against constexpr in friend declaration
2380	capture-default makes too many references odr-usable
2381	Composite pointer type of pointers to plain and noexcept member functions
2382	Array allocation overhead for non-allocating placement new
2383	Variadic member functions of variadic class templates
2384	Conversion function templates and qualification conversions
2385	Lookup for conversion-function-ids
2386	tuple_size requirements for structured binding
2387	Linkage of const-qualified variable template
2388	Applicability of contract-attribute-specifiers
2389	Agreement of deduced and explicitly-specified variable types
2390	Is the argument of __has_cpp_attribute macro-expanded?
2391	Additional template parameters following pack expansion
2392	new-expression size check and constant evaluation
2393	Pseudo-destructors and object lifetime
2394	Const-default-constructible for members
2395	Parameters following a pack expansion
2396	Lookup of names in complex conversion-type-ids
2397	auto specifier for pointers and references to arrays
2398	Template template parameter matching and deduction
2399	Unclear referent of “expression” in assignment-expression
2400	Constexpr virtual functions and temporary objects
2401	Array decay vs prohibition of subobject non-type arguments
2402	When is the restriction to a single c-char in a Unicode literal enforced?
2403	Temporary materialization and base/member initialization
2404	[[no_unique_address]] and allocation order
2405	Additional type-dependent expressions
2406	[[fallthrough]] attribute and iteration statements
2407	Missing entry in Annex C for defaulted comparison operators
2408	Temporaries and previously-initialized elements in aggregate initialization
2409	Explicit specializations of constexpr static data members
2410	Implicit calls of immediate functions
2411	Comparison of pointers to members in template non-type arguments
2412	SFINAE vs undeduced placeholder type
2413	typename in conversion-function-ids
2414	Unclear results if both member and friend operator<=> are declared
2415	using-declarations vs copy assignment operators
2416	Explicit specializations vs constexpr and consteval
2417	Explicit instantiation and exception specifications
2418	Missing cases in definition of “usable in constant expressions”
2419	Loss of generality treating pointers to objects as one-element arrays
2420	Exception specifications in explicit instantiation
2421	Explicit instantiation of constrained member functions
2422	Incorrect grammar for deduction-guide
2423	Typedefs, names, and entities
2424	constexpr initialization requirements for variant members
2425	Confusing wording for deduction from a type
2426	Reference to destructor that cannot be invoked
2427	Deprecation of volatile operands and unevaluated contexts
2428	Deprecating a concept
2429	Initialization of thread_local variables referenced by lambdas
2430	Completeness of return and parameter types of member functions
2431	Full-expressions and temporaries bound to references
2432	Return types for defaulted <=>
2433	Variable templates in the ODR
2434	Mandatory copy elision vs non-class objects
2435	Alias template specializations
2436	Copy semantics of coroutine parameters
2437	Conversion of std::strong_ordering in a defaulted operator<=>
2438	Problems in the specification of qualification conversions
2439	Undefined term in definition of “usable in constant expressions”
2440	Allocation in core constant expressions
2441	Inline function parameters
2442	Incorrect requirement for default arguments
2443	Meaningless template exports
2444	Constant expressions in initialization odr-use
2445	Partial ordering with rewritten candidates
2446	Questionable type-dependency of concept-ids
2447	Unintended description of abbreviated function templates
2448	Cv-qualification of arithmetic types and deprecation of volatile
2449	Thunks as an implementation technique for pointers to virtual functions
2450	braced-init-list as a template-argument
2451	promise.unhandled_exception() and final suspend point
2452	Flowing off the end of a coroutine
2453	Deduced return types and coroutine lambdas
2454	Tail recursion and coroutine symmetric transfer
2455	Concatenation of string literals vs translation phases 5 and 6
2456	Viable user-defined conversions in converted constant expressions
2457	Unexpanded parameter packs don't make a function type dependent
2458	Value category of expressions denoting non-static member functions
2459	Template parameter initialization
2460	C language linkage and constrained non-template friends
2461	Diagnosing non-bool type constraints
2462	Problems with the omission of the typename keyword
2463	Trivial copyability and unions with non-trivial members
2464	Constexpr launder and unions
2465	Coroutine parameters passed to a promise constructor
2466	co_await should be a single evaluation
2467	CTAD for alias templates and the deducible check
2468	Omission of the typename keyword in a member template parameter list
2469	Implicit object creation vs constant expressions
2470	Multiple array objects providing storage for one object
2471	Nested class template argument deduction
2472	Value categories in await-expressions
2473	Parentheses in pseudo-destructor calls
2474	Cv-qualification and deletion
2475	Object declarations of type cv void
2476	placeholder-type-specifiers and function declarators
2477	Defaulted vs deleted copy constructors/assignment operators
2478	Properties of explicit specializations of implicitly-instantiated class templates
2479	Missing specifications for consteval and constinit
2480	Lookup for enumerators in modules
2481	Cv-qualification of temporary to which a reference is bound
2482	bit_cast and indeterminate values
2483	Language linkage of static member functions
2484	char8_t and char16_t in integral promotions
2485	Bit-fields in integral promotions
2486	Call to noexcept function via noexcept(false) pointer/lvalue
2487	Type dependence of function-style cast to incomplete array type
2488	Overloading virtual functions and functions with trailing requires-clauses
2489	Storage provided by array of char
2490	Restrictions on destruction in constant expressions
2491	Export of typedef after its first declaration
2492	Comparing user-defined conversion sequences in list-initialization
2493	auto as a conversion-type-id
2494	Multiple definitions of non-odr-used entities
2495	Glvalue result of a function call
2496	ref-qualifiers and virtual overriding
2497	Points of instantiation for constexpr function templates
2498	Partial specialization failure and the immediate context
2499	Inconsistency in definition of pointer-interconvertibility
2500	noexcept(false) functions and noexcept expressions
2501	Explicit instantiation and trailing requires-clauses
2502	Unintended declaration conflicts in nested statement scopes
2503	Unclear relationship among name, qualified name, and unqualified name
2504	Inheriting constructors from virtual base classes
2505	Nested unnamed namespace of inline unnamed namespace
2506	Structured bindings and array cv-qualifiers
2507	Default arguments for operator[]
2508	Restrictions on uses of template parameter names
2509	decl-specifier-seq in lambda-specifiers
2510	noexcept-specifier of friend function vs class completeness
2511	cv-qualified bit-fields
2512	typeid and incomplete class types
2513	Ambiguity with requires-clause and operator-function-id
2514	Modifying const subobjects
2515	Result of a function call
2516	Locus of enum-specifier or opaque-enum-declaration
2517	Useless restriction on use of parameter in constraint-expression
2518	Conformance requirements and #error/#warning
2519	Object representation of a bit-field
2520	Template signature and default template arguments
2521	User-defined literals and reserved identifiers
2522	Removing placemarker tokens and retention of whitespace
2523	Undefined behavior via omitted destructor call in constant expressions
2524	Distinguishing user-defined conversion sequences by ref-qualifier
2525	Incorrect definition of implicit conversion sequence
2526	Relational comparison of void* pointers
2527	Non-class potentially-overlapping objects
2528	Three-way comparison and the usual arithmetic conversions
2529	Constant destruction of constexpr references
2530	Multiple definitions of enumerators
2531	Static data members redeclared as constexpr
2532	Kind of pointer value returned by new T[0]
2533	Storage duration of implicitly created objects
2534	Value category of pseudo-destructor expression
2535	Type punning in class member access
2536	Partially initialized variables during constant initialization
2537	Overbroad grammar for parameter-declaration
2538	Can standard attributes be syntactically ignored?
2539	Three-way comparison requiring strong ordering for floating-point types
2540	Unspecified interpretation of numeric-escape-sequence
2541	Linkage specifications, module purview, and module attachment
2542	Is a closure type a structural type?
2543	constinit and optimized dynamic initialization
2544	Address of past-the-end of a potentially-overlapping subobject
2545	Transparently replacing objects in constant expressions
2546	Defaulted secondary comparison operators defined as deleted
2547	Defaulted comparison operator function for non-classes
2548	Array prvalues and additive operators
2549	Implicitly moving the operand of a throw-expression in unevaluated contexts
2550	Type "reference to cv void" outside of a declarator
2551	"Refers to allocated storage" has no meaning
2552	Constant evaluation of non-defining variable declarations
2553	Restrictions on explicit object member functions
2554	Overriding virtual functions, also with explicit object parameters
2555	Ineffective redeclaration prevention for using-declarators
2556	Unusable promise::return_void
2557	Class member access referring to an unrelated class
2558	Uninitialized subobjects as a result of an immediate invocation
2559	Defaulted consteval functions
2560	Parameter type determination in a requirement-parameter-list
2561	Conversion to function pointer for lambda with explicit object parameter
2562	Exceptions thrown during coroutine startup
2563	Initialization of coroutine result object
2564	Conversion to function pointer with an explicit object parameter
2565	Invalid types in the parameter-declaration-clause of a requires-expression
2566	Matching deallocation for uncaught exception
2567	Operator lookup ambiguity
2568	Access checking during synthesis of defaulted comparison operator
2569	Use of decltype(capture) in a lambda's parameter-declaration-clause
2570	Clarify constexpr for defaulted functions
2571	Evaluation order for subscripting
2572	Address of overloaded function with no target
2573	Undefined behavior when splicing results in a universal-character-name
2574	Undefined behavior when lexing unmatched quotes
2575	Undefined behavior when macro-replacing "defined" operator
2576	Undefined behavior with macro-expanded #include directives
2577	Undefined behavior for preprocessing directives in macro arguments
2578	Undefined behavior when creating an invalid string literal via stringizing
2579	Undefined behavior when token pasting does not create a preprocessing token
2580	Undefined behavior with #line
2581	Undefined behavior for predefined macros
2582	Differing member lookup from nested classes
2583	Common initial sequence should consider over-alignment
2584	Equivalent types in function template declarations
2585	Name lookup for coroutine allocation
2586	Explicit object parameter for assignment and comparison
2587	Visible side effects and initial value of an object
2588	friend declarations and module linkage
2589	Context of access checks during constraint satisfaction checking
2590	Underlying type should determine size and alignment requirements of an enum
2591	Implicit change of active union member for anonymous union in union
2592	Missing definition for placement allocation/deallocation function
2593	Insufficient base class restriction for pointer-to-member expression
2594	Disallowing a global function template main
2595	"More constrained" for eligible special member functions
2596	Instantiation of constrained non-template friends
2597	Replaceable allocation and deallocation functions in the global module
2598	Unions should not require a non-static data member of literal type
2599	What does initializing a parameter include?
2600	Type dependency of placeholder types
2601	Tracking of created and destroyed subobjects
2602	consteval defaulted functions
2603	Holistic functional equivalence for function templates
2604	Attributes for an explicit specialization
2605	Implicit-lifetime aggregates
2606	static_cast from "pointer to void" does not handle similar types
2607	Visibility of enumerator names
2608	Omitting an empty template argument list
2609	Padding in class types
2610	Indirect private base classes in aggregates
2611	Missing parentheses in expansion of fold-expression could cause syntactic reinterpretation
2612	Incorrect comment in example
2613	Incomplete definition of resumer
2614	Unspecified results for class member access
2615	Missing __has_cpp_attribute(assume)
2616	Imprecise restrictions on break and continue
2617	Default template arguments for template members of non-template classes
2618	Substitution during deduction should exclude exception specifications
2619	Kind of initialization for a designated-initializer-list
2620	Nonsensical disambiguation rule
2621	Kind of lookup for using enum declarations
2622	Compounding types from function and pointer-to-member types
2623	Invoking destroying operator delete for constructor failure
2624	Array delete expression with no array cookie
2625	Deletion of pointer to out-of-lifetime object
2626	Rephrase ones' complement using base-2 representation
2627	Bit-fields and narrowing conversions
2628	Implicit deduction guides should propagate constraints
2629	Variables of floating-point type as switch conditions
2630	Syntactic specification of class completeness
2631	Immediate function evaluations in default arguments
2632	'user-declared' is not defined
2633	typeid of constexpr-unknown dynamic type
2634	Avoid circularity in specification of scope for friend class declarations
2635	Constrained structured bindings
2636	Update Annex E based on Unicode 15.0 UAX #31
2637	Injected-class-name as a simple-template-id
2638	Improve the example for initializing by initializer list
2639	new-lines after phase 1
2640	Allow more characters in an n-char sequence
2641	Redundant specification of value category of literals
2642	Inconsistent use of T and C
2643	Completing a pointer to array of unknown bound
2644	Incorrect comment in example
2645	Unused term "default argument promotions"
2646	Defaulted special member functions
2647	Fix for "needed for constant evaluation"
2648	Correspondence of surrogate call function and conversion function
2649	Incorrect note about implicit conversion sequence
2650	Incorrect example for ill-formed non-type template arguments
2651	Conversion function templates and "noexcept"
2652	Overbroad definition of __STDCPP_BFLOAT16_T__
2653	Can an explicit object parameter have a default argument?
2654	Un-deprecation of compound volatile assignments
2655	Instantiation of default arguments in lambda-expressions
2656	Converting consteval lambda to function pointer in non-immediate context
2657	Cv-qualification adjustment when binding reference to temporary
2658	Trivial copying of unions in core constant expressions
2659	Missing feature-test macro for lifetime extension in range-for loop
2660	Confusing term "this parameter"
2661	Missing disambiguation rule for pure-specifier vs. brace-or-equal-initializer
2662	Example for member access control vs. overload resolution
2663	Example for member redeclarations with using-declarations
2664	Deduction failure in CTAD for alias templates
2665	Replacing a subobject with a complete object
2666	Lifetime extension through static_cast
2667	Named module imports do not import macros
2668	co_await in a lambda-expression
2669	Lifetime extension for aggregate initialization
2670	Programs and translation units
2671	friend named by a template-id
2672	Lambda body SFINAE is still required, contrary to intent and note
2673	User-declared spaceship vs. built-in operators
2674	Prohibit explicit object parameters for constructors
2675	start_lifetime_as, placement-new, and active union members
2676	Replacing a complete object having base subobjects
2677	Replacing union subobjects
2678	std::source_location::current is unimplementable
2679	Implicit conversion sequence with a null pointer constant
2680	Class template argument deduction for aggregates with designated initializers
2681	Deducing member array type from string literal
2682	Templated function vs. function template
2683	Default arguments for member functions of templated nested classes
2684	thread_local dynamic initialization
2685	Aggregate CTAD, string, and brace elision
2686	Pack expansion into a non-pack parameter of a concept
2687	Calling an explicit object member function via an address-of-overload-set
2688	Calling explicit object member functions
2689	Are cv-qualified std::nullptr_t fundamental types?
2690	Semantics of defaulted move assignment operator for unions
2691	hexadecimal-escape-sequence is too greedy
2692	Static and explicit object member functions with the same parameter-type-lists
2693	Escape sequences for the string-literal of #line
2694	string-literals of the _Pragma operator
2695	Semantic ignorability of attributes
2696	Relational comparisons of pointers to void
2697	Deduction guides using abbreviated function syntax
2698	Using extended integer types with z suffix
2699	Inconsistency of throw-expression specification
2700	#error disallows existing implementation practice
2701	Default arguments in multiple scopes / inheritance of array bounds in the same scope
2702	Constant destruction of reference members
2703	Three-way comparison requiring strong ordering for floating-point types, take 2
2704	Clarify meaning of "bind directly"
2705	Accessing ambiguous subobjects
2706	Repeated structured binding declarations
2707	Deduction guides cannot have a trailing requires-clause
2708	Parenthesized initialization of arrays
2709	Parenthesized initialization of reference-to-aggregate
2710	Loops in constant expressions
2711	Source for copy-initializing the exception object
2712	Simplify restrictions on built-in assignment operator candidates
2713	Initialization of reference-to-aggregate from designated initializer list
2714	Implicit deduction guides omit properties from the parameter-declaration-clause of a constructor
2715	"calling function" for parameter initialization may not exist
2716	Rule about self-or-base conversion is normatively redundant
2717	Pack expansion for alignment-specifier
2718	Type completeness for derived-to-base conversions
2719	Creating objects in misaligned storage
2720	Template validity rules for templated entities and alias templates
2721	When exactly is storage reused?
2722	Temporary materialization conversion for noexcept operator
2723	Range of representable values for floating-point types
2724	Clarify rounding for arithmetic right shift
2725	Overload resolution for non-call of class member access
2726	Alternative tokens appearing as attribute-tokens
2727	Importing header units synthesized from source files
2728	Evaluation of conversions in a delete-expression
2729	Meaning of new-type-id
2730	Comparison templates on enumeration types
2731	List-initialization sequence with a user-defined conversion
2732	Can importable headers react to preprocessor state from point of import?
2733	Applying [[maybe_unused]] to a label
2734	Immediate forward-declared function templates
2735	List-initialization and conversions in overload resolution
2736	Standard layout class with empty base class also in first member
2737	Temporary lifetime extension for reference init-captures
2738	"denotes a destructor" is missing specification
2739	Nested requirement not a constant expression
2740	Too many objects have constexpr-unknown type
2741	Implicit conversion sequence from empty list to array of unknown bound
2742	Guaranteed copy elision for brace-initialization from prvalue
2743	Copying non-trivial objects nested within a union
2744	Multiple objects of the same type at the same address
2745	Dependent odr-use in generic lambdas
2746	Checking of default template arguments
2747	Cannot depend on an already-deleted splice
2748	Accessing static data members via null pointer
2749	Treatment of "pointer to void" for relational comparisons
2750	construct_at without constructor call
2751	Order of destruction for parameters for operator functions
2752	Excess-precision floating-point literals
2753	Storage reuse for string literal objects and backing arrays
2754	Using *this in explicit object member functions that are coroutines
2755	Incorrect wording applied by P2738R1
2756	Completion of initialization by delegating constructor
2757	Deleting or deallocating storage of an object during its construction
2758	What is "access and ambiguity control"?
2759	[[no_unique_address] and common initial sequence
2760	Defaulted constructor that is an immediate function
2761	Implicitly invoking the deleted destructor of an anonymous union member
2762	Type of implicit object parameter
2763	Ignorability of [[noreturn]] during constant evaluation
2764	Use of placeholders affecting name mangling
2765	Address comparisons between potentially non-unique objects during constant evaluation
2766	Repeated evaluation of a string-literal may yield different objects
2767	Non-defining declarations of anonymous unions
2768	Assignment to enumeration variable with a braced-init-list
2769	Substitution into template parameters and default template arguments should be interleaved
2770	Trailing requires-clause can refer to function parameters before they are substituted into
2771	Transformation for unqualified-ids in address operator
2772	Missing Annex C entry for linkage effects of linkage-specification
2773	Naming anonymous union members as class members
2774	Value-dependence of requires-expressions
2775	Unclear argument type for copy of exception object
2776	Substitution failure and implementation limits
2777	Type of id-expression denoting a template parameter object
2778	Trivial destructor does not imply constant destruction
2779	Restrictions on the ordinary literal encoding
2780	reinterpret_cast to reference to function types
2781	Unclear recursion in the one-definition rule
2782	Treatment of closure types in the one-definition rule
2783	Handling of deduction guides in global-module-fragment
2784	Unclear definition of member-designator for offsetof
2785	Type-dependence of requires-expression
2786	Comparing pointers to complete objects
2787	Kind of explicit object copy/move assignment function
2788	Correspondence and redeclarations
2789	Overload resolution with implicit and explicit object member functions
2790	Aggregate initialization and user-defined conversion sequence
2791	Unclear phrasing about "returning to the caller"
2792	Clean up specification of noexcept operator
2793	Block-scope declaration conflicting with parameter name
2794	Uniqueness of lambdas in alias templates
2795	Overlapping empty subobjects with different cv-qualification
2796	Function pointer conversions for relational operators
2797	Meaning of "corresponds" for rewritten operator candidates
2798	Manifestly constant evaluation of the static_assert message
2799	Inheriting default constructors
2800	Instantiating constexpr variables for potential constant evaluation
2801	Reference binding with reference-related types
2802	Constrained auto and redeclaration with non-abbreviated syntax
2803	Overload resolution for reference binding of similar types
2804	Lookup for determining rewrite targets
2805	Underspecified selection of deallocation function
2806	Make a type-requirement a type-only context
2807	Destructors declared consteval
2808	Explicit specialization of defaulted special member function
2809	An implicit definition does not redeclare a function
2810	Requiring the absence of diagnostics for templates
2811	Clarify "use" of main
2812	Allocation with explicit alignment
2813	Class member access with prvalues
2814	Alignment requirement of incomplete class type
2815	Overload resolution for references/pointers to noexcept functions
2816	Unclear phrasing "may assume ... eventually"
2817	sizeof(abstract class) is underspecified
2818	Use of predefined reserved identifiers
2819	Cast from null pointer value in a constant expression
2820	Value-initialization and default constructors
2821	Lifetime, zero-initialization, and dynamic initialization
2822	Side-effect-free pointer zap
2823	Implicit undefined behavior when dereferencing pointers
2824	Copy-initialization of arrays
2825	Range-based for statement using a braced-init-list
2826	Missing definition of "temporary expression"
2827	Representation of unsigned integral types
2828	Ambiguous interpretation of C-style cast
2829	Redundant case in restricting user-defined conversion sequences
2830	Top-level cv-qualification should be ignored for list-initialization
2831	Non-templated function definitions and requires-clauses
2832	Invented temporary variables and temporary objects
2833	Evaluation of odr-use
2834	Partial ordering and explicit object parameters
2835	Name-independent declarations
2836	Conversion rank of long double and extended floating-point types
2837	Instantiating and inheriting by-value copy constructors
2838	Declaration conflicts in lambda-expressions
2839	Explicit destruction of base classes
2840	Missing requirements for fundamental alignments
2841	When do const objects start being const?
2842	Preferring an initializer_list over a single value
2843	Undated reference to Unicode makes C++ a moving target
2844	Enumerating a finite set of built-in candidates
2845	Make the closure type of a captureless lambda a structural type
2846	Out-of-class definitions of explicit object member functions
2847	Constrained explicit specializations of function templates at class scope
2848	Omitting an empty template argument list for explicit instantiation
2849	Parameter objects are not temporary objects
2850	Unclear storage duration for function parameter objects
2851	Allow floating-point conversions in converted constant expressions
2852	Complete-class contexts and class-scope lambdas
2853	Pointer arithmetic with pointer to hypothetical element
2854	Storage duration of exception objects
2855	Undefined behavior in postfix increment
2856	Copy-list-initialization with explicit default constructors
2857	Argument-dependent lookup with incomplete class types
2858	Declarative nested-name-specifiers and pack-index-specifiers
2859	Value-initialization with multiple default constructors
2860	Remove and fix the term "vacuous initialization"
2861	dynamic_cast on bad pointer value
2862	Unclear boundaries of template declarations
2863	Unclear synchronization requirements for object lifetime rules
2864	Narrowing floating-point conversions
2865	Regression on result of conditional operator
2866	Observing the effects of [[no_unique_address]]
2867	Order of initialization for structured bindings
2868	Self-references in trivially copyable objects as function return values
2869	this in local classes
2870	Combining absent encoding-prefixes
2871	User-declared constructor templates inhibiting default constructors
2872	Linkage and unclear "can be referred to"
2873	Taking the address of a function involving template argument deduction
2874	Qualified declarations of partial specializations
2875	Missing support for round-tripping null pointer values through indirection/address operators
2876	Disambiguation of T x = delete("text")
2877	Type-only lookup for using-enum-declarator
2878	C-style casts to reference types
2879	Undesired outcomes with const_cast
2880	Accessibility check for destructor of incomplete class type
2881	Type restrictions for the explicit object parameter of a lambda
2882	Unclear treatment of conversion to void
2883	Definition of "odr-usable" ignores lambda scopes
2884	Qualified declarations of partial specializations
2885	Non-eligible trivial default constructors
2886	Temporaries and trivial potentially-throwing special member functions
2887	Missing compatibility entries for xvalues
2888	Missing cases for reference and array types for argument-dependent lookup
2889	Requiring an accessible destructor for destroying operator delete
2890	Defining members of local classes
2891	Normative status of implementation limits
2892	Unclear usual arithmetic conversions
2893	Instantiations in discarded if constexpr substatements
2894	Functional casts create prvalues of reference type
2895	Initialization should ignore the destination type's cv-qualification
2896	Template argument deduction involving exception specifications
2897	Copying potentially-overlapping union subobjects
2898	Clarify implicit conversion sequence from cv T to T
2899	Bad value representations should cause undefined behavior
2900	Deduction of non-type template arguments with placeholder types
2901	Unclear semantics for near-match aliased access
2902	Implicit this transformation outside of permitted contexts
2903	Can we omit the template disambiguator in nested-name-specifiers in type-only contexts?
2904	Introducing template-names
2905	Value-dependence of noexcept-expression
2906	Lvalue-to-rvalue conversion of class types for conditional operator
2907	Constant lvalue-to-rvalue conversion on uninitialized std::nullptr_t
2908	Counting physical source lines for __LINE__
2909	Subtle difference between constant-initialized and constexpr
2910	Effect of requirement-parameter-lists on odr-usability
2911	Unclear meaning of expressions "appearing within" subexpressions
2912	Too-large value for size in array new
2913	Grammar for deduction-guide has requires-clause in the wrong position
2914	Unclear order of initialization of static and thread-local variables
2915	Explicit object parameters of type void
2916	Variable template partial specializations should not be declared static
2917	Disallow multiple friend-type-specifiers for a friend template
2918	Consideration of constraints for address of overloaded function
2919	Conversion function candidates for initialization of const lvalue reference
2920	The template keyword for base classes
2921	Exporting redeclarations of entities not attached to a named module
2922	constexpr placement-new is too permissive
2923	Note about infinite loops and execution steps
2924	Undefined behavior during constant evaluation
2925	Deleting a pointer to an incomplete enumeration type
2926	Lookup context for dependent qualified names
2927	Unclear status of translation unit with module keyword
2928	No ordering for initializing thread-local variables
2929	Lifetime of trivially-destructible static or thread-local objects
2930	Unclear term "copy/move operation" in specification of copy elision
2931	Restrictions on operator functions that are explicit object member functions
2932	Value range of empty enumeration
2933	Dangling references
2934	Unclear semantics of exception escaping from unhandled_exception
2935	Destroying the coroutine state when initial-await-resume-called is false
2936	Local classes of templated functions should be part of the current instantiation
2937	Grammar for preprocessing-file has no normative effect
2938	Inheriting linkage from a previous declaration
2939	Do not allow reinterpret_cast from prvalue to rvalue reference
2940	Definition of "object"
2941	Lifetime extension for function-style cast to reference type
2942	Packs in a function's parameter-type-list
2943	Discarding a void return value
2944	Unsequenced throw-expressions
2945	Redundant constraints on matching function template declarations
2946	Dependent call equivalence in non-ADL cases
2947	Limiting macro expansion in pp-module
2948	Late ambiguity for partial template specialization
2949	Treatment of ellipsis during partial ordering
2950	Value preservation in enumeration vs. integer bit-fields
2951	Distinguishing a primary template
2952	Vacuous initialization for subobjects
2953	Value representation for non-trivially-copyable types
2954	Simultaneous modifications of an atomic object
2955	Unify rules about conflicting unordered accesses
2956	Missing allowance for pseudo-destructors in qualified lookup
2957	Evaluating a reference member should constitute access
2958	Overload resolution involving lvalue transformation and qualification conversion
2959	Naming enumerators in class member access expressions
2960	Introduce discontiguous object lifetime
2961	Checking of ill-formed types in constraint-expressions

---

Sort on

- nothing - activity creation drafting id messages priority section status submitter superseder title

Descending

- nothing - activity creation drafting id messages priority section status submitter superseder title

Descending

Group on

- nothing - activity creation drafting id messages priority section status submitter superseder title

Descending

- nothing - activity creation drafting id messages priority section status submitter superseder title

Descending