C++ Standard Core Language Issue Table of Contents, Revision 58


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

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

Section references in this document reflect the section numbering of document PL22.16/08-0201 = WG21 N2691.



Table of Contents


Issue Section Status Title
1 8.3.6 TC1 What if two using-declarations refer to the same function but the declarations introduce different default-arguments?
2 14.6.4 drafting How can dependent names be used in member declarations that appear outside of the class template definition?
3 14.7.3 NAD The template compilation model rules render some explicit specialization declarations not visible during instantiation
4 7.5 WP Does extern "C" affect the linkage of function names with internal linkage?
5 8.5 WP CV-qualifiers and type conversions
6 12.8 open Should the optimization that allows a class object to alias another object also allow the case of a parameter in an inline function to alias its argument?
7 11.2 NAD Can a class with a private virtual base class be derived from?
8 11 WP Access to template arguments used in a function return type and in the nested name specifier
9 11.2 WP Clarification of access to base class members
10 11.8 WP Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?
11 7.3.3 WP How do the keywords typename/template interact with using-declarations?
12 3.4.2 dup Default arguments on different declarations for the same function and the Koenig lookup
13 7.5 extension extern "C" for Parameters of Function Templates
14 7.5 NAD extern "C" functions and declarations in different namespaces
15 8.3.6 dup Default arguments for parameters of function templates
16 11.2 WP Access to members of indirect private base classes
17 11.2 NAD Footnote 99 should discuss the naming class when describing members that can be accessed from friends
18 8.3.5 NAD f(TYPE) where TYPE is void should be allowed
19 11.5 NAD Clarify protected member access
20 12.8 TC1 Some clarifications needed for 12.8 para 15
21 14.1 TC1 Can a default argument for a template parameter appear in a friend declaration?
22 14.6.4 TC1 Template parameter with a default argument that refers to itself
23 14.5.6.2 open Some questions regarding partial ordering of function templates
24 14.7.3 TC1 Errors in examples in 14.7.3
25 15.4 TC1 Exception specifications and pointers to members
26 12.8 NAD Copy constructors and default arguments
27 13.6 NAD Overload ambiguities for builtin ?: prototypes
28 3.6.3 DR 'exit', 'signal' and static object destruction
29 7.5 WP Linkage of locally declared functions
30 14.2 TC1 Valid uses of "::template"
31 5.3.4 NAD Looking up new/delete
32 14 TC1 Clarification of explicit instantiation of non-exported templates
33 3.4.2 TC1 Argument dependent lookup and overloaded functions
34 14.7.1 NAD Argument dependent lookup and points of instantiation
35 8.5 TC1 Definition of default-initialization
36 7.3.3 open using-declarations in multiple-declaration contexts
37 15.5.3 NAD When is uncaught_exception() true?
38 14.2 TC1 Explicit template arguments and operator functions
39 10.2 WP Conflicting ambiguity rules
40 8.3 TC1 Syntax of declarator-id
41 3.4.1 TC1 Clarification of lookup of names after declarator-id
42 3.3.6 NAD Redefining names from base classes
43 3.9 TC1 Copying base classes (PODs) using memcpy
44 14.7.3 WP Member specializations
45 11.8 WP Access to nested classes
46 14.7.2 NAD Explicit instantiation of member templates
47 14.5.4 NAD Template friend issues
48 9.4.2 TC1 Definitions of unused static members
49 14.1 TC1 Restriction on non-type, non-value template arguments
50 3.2 NAD Converting pointer to incomplete type to same type
51 13.3.3 TC1 Overloading and user-defined conversions
52 5.2.5 TC1 Non-static members, member selection and access checking
53 5.2.9 TC1 Lvalue-to-rvalue conversion before certain static_casts
54 5.2.9 WP Static_cast from private base to derived class
55 5.7 NAD Adding/subtracting pointer and enumeration value
56 7.1.3 TC1 Redeclaring typedefs within classes
57 9.5 open Empty unions
58 9.6 WP Signedness of bit fields of enum type
59 13.3.1.4 TC1 Clarification of overloading and UDC to reference type
60 13.3.3.1.4 WP Reference binding and valid conversion sequences
61 13.4 NAD Address of static member function "&p->f"
62 14.3.1 WP Unnamed members of classes used as type parameters
63 14.7.1 WP Class instantiation from pointer conversion to void*, null and self
64 14.7.3 TC1 Partial ordering to disambiguate explicit specialization
65 8.3.6 TC1 Typo in default argument example
66 8.3.6 NAD Visibility of default args vs overloads added after using-declaration
67 9.4 TC1 Evaluation of left side of object-expression
68 7.1.6.3 TC1 Grammar does not allow "friend class A<int>;"
69 7.1.1 TC1 Storage class specifiers on template declarations
70 14.8.2.5 WP Is an array bound a nondeduced context?
71 5 NAD Incorrect cross reference
72 14 dup Linkage and storage class specifiers for templates
73 5.10 TC1 Pointer equality
74 5.3.4 TC1 Enumeration value in direct-new-declarator
75 9.2 TC1 In-class initialized members must be const
76 7.1.6.1 TC1 Are const volatile variables considered "constant expressions"?
77 11.4 WP The definition of friend does not allow nested classes to be friends
78 8.5 WP Section 8.5 paragraph 9 should state it only applies to non-static objects
79 18.5.1.3 dup Alignment and placement new
80 9.2 TC1 Class members with same name as class
81 C NAD Null pointers and C compatability
82 3.2 dup Definition of "using" a constant expression
83 13.3.4.1 TC1 Overloading and deprecated conversion of string literal
84 13.3.3.1 TC1 Overloading and conversion loophole used by auto_ptr
85 3.4.4 TC1 Redeclaration of member class
86 12.2 WP Lifetime of temporaries in query expressions
87 15.4 WP Exception specifications on function parameters
88 14.7.3 NAD Specialization of member constant templates
89 3.8 TC1 Object lifetime does not account for reference rebinding
90 3.4.2 TC1 Should the enclosing class be an "associated class" too?
91 3.4.2 NAD A union's associated types should include the union itself
92 15.4 open Should exception specifications be part of the type system?
93 3.8 TC1 Missing word in 3.8 basic.life paragraph 2
94 5.19 TC1 Inconsistencies in the descriptions of constant expressions
95 7.3.1.2 NAD Elaborated type specifiers referencing names declared in friend decls
96 14.2 drafting Syntactic disambiguation using the template keyword
97 5.19 NAD Use of bool constants in integral constant expressions
98 15 TC1 Branching into try block
99 14.8.2.1 NAD Partial ordering, references and cv-qualifiers
100 14.3.2 TC1 Clarify why string literals are not allowed as template arguments
101 7.3.3 TC1 Redeclaration of extern "C" names via using-declarations
102 13.3.1.2 NAD Operator lookup rules do not work well with parts of the library
103 7.3.4 TC1 Is it extended-namespace-definition or extension-namespace-definition ?
104 15.1 NAD Destroying the exception temp when no handler is found
105 14 TC1 Meaning of "template function"
106 unknown WP Creating references to references during template deduction/instantiation
107 7.5 NAD Linkage of operator functions
108 14.6.2.1 TC1 Are classes nested in templates dependent?
109 7.3.3 NAD Allowing ::template in using-declarations
110 14 open Can template functions and classes be declared in the same scope?
111 12.8 review Copy constructors and cv-qualifiers
112 8.3.4 WP Array types and cv-qualifiers
113 5.2.2 WP Visibility of called function
114 14.5.2 NAD Virtual overriding by template member function specializations
115 13.4 WP Address of template-id
116 14.5.6.1 TC1 Equivalent and functionally-equivalent function templates
117 12.2 NAD Timing of destruction of temporaries
118 5.2.2 DR Calls via pointers to virtual member functions
119 3.8 WP Object lifetime and aggregate initialization
120 14.6 TC1 Nonexistent non-terminal qualified-name
121 14.6 TC1 Dependent type names with non-dependent nested-name-specifiers
122 5.1 WP template-ids as unqualified-ids
123 5.1 TC1 Bad cross-reference
124 12.2 WP Lifetime of temporaries in default initialization of class arrays
125 5.1 WP Ambiguity in friend declaration syntax
126 15.4 TC1 Exception specifications and const
127 5.3.4 TC1 Ambiguity in description of matching deallocation function
128 5.2.9 TC1 Casting between enum types
129 1.9 open Stability of uninitialized auto variables
130 5.3.4 NAD Sequence points and new-expressions
131 E TC1 Typo in Lao characters
132 3.5 NAD Local types and linkage
133 15.4 dup Exception specifications and checking
134 14 TC1 Template classes and declarator-ids
135 8.3.5 TC1 Class type in in-class member function definitions
136 8.3.6 WP Default arguments and friend declarations
137 5.2.9 TC1 static_cast of cv void*
138 7.3.1.2 drafting Friend declaration name lookup
139 3.4.1 WP Error in friend lookup example
140 8.3.5 WP Agreement of parameter declarations
141 3.4.5 DR Non-member function templates in member access expressions
142 11.2 TC1 Injection-related errors in access example
143 3.4.2 WP Friends and Koenig lookup
144 7.1.6.3 open Position of friend specifier
145 D.1 TC1 Deprecation of prefix ++
146 3.9.1 open Floating-point zero
147 5.1 TC1 Naming the constructor
148 9 TC1 POD classes and pointers to members
149 4.10 TC1 Accessibility and ambiguity
150 14.3.3 open Template template parameters and default arguments
151 8.5 TC1 Terminology of zero-initialization
152 12.3.1 TC1 explicit copy constructors
153 13.3.4.1 TC1 Misleading wording (rank of conversion)
154 7.1.1 NAD Anonymous unions in unnamed namespaces
155 8.5 dup Brace initializer for scalar
156 3.4.5 drafting Name lookup for conversion functions
157 7 open Omitted typedef declarator
158 3.10 WP Aliasing and qualification conversions
159 8.3 TC1 Namespace qualification in declarators
160 8.2 WP Missing std:: qualification
161 11.5 TC1 Access to protected nested type
162 13.3.1.1 WP (&C::f)() with nonstatic members
163 8.5.1 TC1 Description of subaggregate initializer
164 3.4.2 TC1 Overlap between Koenig and normal lookup
165 7.3.1.2 NAD Definitions of friends and block-scope externs
166 7.3.1.2 TC1 Friend declarations of template-ids
167 D.2 NAD Deprecating static functions
168 7.5 NAD C linkage for static member functions
169 7.3.3 NAD template-ids in using-declarations
170 4.11 drafting Pointer-to-member conversions
171 7.3 TC1 Global namespace scope
172 7.2 WP Unsigned int as underlying type of enum
173 2.2 TC1 Constraints on execution character set
174 D.2 NAD Undeprecating global static
175 9 WP Class name injection and base name access
176 9 TC1 Name injection and templates
177 8.5 WP Lvalues vs rvalues in copy-initialization
178 8.5 TC1 More on value-initialization
179 5.7 TC1 Function pointers and subtraction
180 14.6 WP typename and elaborated types
181 14.8.2.5 TC1 Errors in template template-parameter example
182 14.7.3 NAD Access checking on explicit specializations
183 14.6 TC1 typename in explicit specializations
184 14.1 WP Default arguments in template template-parameters
185 12.8 TC1 "Named" temporaries and copy elision
186 14.6.1 open Name hiding and template template-parameters
187 14.1 TC1 Scope of template parameter names
188 5.18 TC1 Comma operator and rvalue conversion
189 2.12 drafting Definition of operator and punctuator
190 9.2 TC1 Layout-compatible POD-struct types
191 3.4.1 open Name lookup does not handle complex nesting
192 3.4.1 open Name lookup in parameters
193 12.4 TC1 Order of destruction of local automatics of destructor
194 12.1 TC1 Identifying constructors
195 5.2.10 WP Converting between function and object pointers
196 5.3.5 open Arguments to deallocation functions
197 14.6.4.2 WP Issues with two-stage lookup of dependent names
198 9.8 WP Definition of "use" in local and nested classes
199 12.2 WP Order of destruction of temporaries
200 14.5.6.2 dup Partial ordering and explicit arguments
201 12.2 WP Order of destruction of temporaries in initializers
202 13.4 TC1 Use of overloaded function name
203 5.3.1 open Type of address-of-member expression
204 14 WP Exported class templates
205 14 drafting Templates and static data members
206 14.6.3 TC1 Semantic constraints on non-dependent names
207 11.2 WP using-declarations and protected access
208 15.1 WP Rethrowing exceptions in nested handlers
209 11.4 NAD Must friend declaration names be accessible?
210 15.3 TC1 What is the type matched by an exception handler?
211 15 NAD Constructors should not be allowed to return normally after an exception
212 14.7.1 drafting Implicit instantiation is not described clearly enough
213 14.6.2 TC1 Lookup in dependent base classes
214 14.5.6.2 WP Partial ordering of function templates is underspecified
215 14.1 WP Template parameters are not allowed in nested-name-specifiers
216 3.5 WP Linkage of nameless class-scope enumeration types
217 8.3.6 TC1 Default arguments for non-template member functions of class templates
218 3.4.2 WP Specification of Koenig lookup
219 15.5.1 open Cannot defend against destructors that throw exceptions
220 3.7.3.2 review All deallocation functions should be required not to throw
221 13.5.3 WP Must compound assignment operators be member functions?
222 5 ready Sequence points and lvalue-returning operators
223 D open The meaning of deprecation
224 14.6.2.1 WP Definition of dependent names
225 3.4.2 drafting Koenig lookup and fundamental types
226 14.1 WP Default template arguments for function templates
227 6.4 TC1 How many scopes in an if statement?
228 14.2 WP Use of template keyword with non-member templates
229 14.5.5 NAD Partial specialization of function templates
230 10.4 open Calls to pure virtual functions
231 3.4.1 NAD Visibility of names after using-directives
232 5.3.1 drafting Is indirection through a null pointer undefined behavior?
233 8.5.3 drafting References vs pointers in UDC overload resolution
234 3.8 NAD Reuse of base class subobjects
235 12.6.2 TC1 Assignment vs initialization
236 5.19 review Explicit temporaries and integral constant expressions
237 14.7.2 WP Explicit instantiation and base class members
238 5 open Precision and accuracy constraints on floating point
239 13.3.1.1.1 WP Footnote 116 and Koenig lookup
240 4.1 review Uninitialized values and undefined behavior
241 14.8.1 TC1 Error in example in 14.8.1
242 5.4 open Interpretation of old-style casts
243 13.3.3.1.2 NAD Weighting of conversion functions in direct-initialization
244 12.4 WP Destructor lookup
245 3.4.4 WP Name lookup in elaborated-type-specifiers
246 14.3 WP Jumps in function-try-block handlers
247 13.4 NAD Pointer-to-member casts and function overload resolution
248 E open Identifier characters
249 14.5.1.1 TC1 What is a member function template?
250 13.4 TC1 Address of function template specialization with non-deduced template arguments
251 3.9.1 open How many signed integer types are there?
252 12.4 WP Looking up deallocation functions in virtual destructors
253 8.5 open Why must empty or fully-initialized const objects be initialized?
254 3.4.4 WP Definitional problems with elaborated-type-specifiers
255 12.5 open Placement deallocation functions and lookup ambiguity
256 5.3.4 open Overflow in size calculations
257 12.6.2 review Abstract base constructors and virtual base initialization
258 7.3.3 WP using-declarations and cv-qualifiers
259 14.7 WP Restrictions on explicit specialization and instantiation
260 13.6 drafting User-defined conversions and built-in operator=
261 3.2 WP When is a deallocation function "used?"
262 8.3.5 WP Default arguments and ellipsis
263 12.1 WP Can a constructor be declared a friend?
264 14.8.1 open Unusable template constructors and conversion functions
265 5.3.5 open Destructors, exceptions, and deallocation
266 A NAD No grammar sentence symbol
267 5.3.4 open Alignment requirement for new-expressions
268 16.3.4 open Macro name suppression in rescanned replacement text
269 3.6.2 NAD Order of initialization of multiply-defined static data members of class templates
270 3.6.2 WP Order of initialization of static data members of class templates
271 14.8.2 open Explicit instantiation and template argument deduction
272 12.4 WP Explicit destructor invocation and qualified-ids
273 9 WP POD classes and operator&()
274 3.8 WP Cv-qualification and char-alias access to out-of-lifetime objects
275 14.7.3 WP Explicit instantiation/specialization and using-directives
276 6.6 DR Order of destruction of parameters and temporaries
277 8.5 WP Zero-initialization of pointers
278 3.5 open External linkage and nameless entities
279 3.5 open Correspondence of "names for linkage purposes"
280 13.3.1.1.2 WP Access and surrogate call functions
281 7.1.2 WP inline specifier in friend declarations
282 5.2.8 open Namespace for extended_type_info
283 7.1.6.2 WP Template type-parameters are not syntactically type-names
284 9 WP qualified-ids in class declarations
285 14.7.3 NAD Identifying a function template being specialized
286 14.5.5 WP Incorrect example in partial specialization
287 14.6.4.1 drafting Order dependencies in template instantiation
288 5.3.5 DR Misuse of "static type" in describing pointers
289 3.2 WP Incomplete list of contexts requiring a complete type
290 3.9 NAD Should memcpy be allowed into a POD with a const member?
291 8.5.3 WP Overload resolution needed when binding reference to class rvalue
292 5.3.4 review Deallocation on exception in new before arguments evaluated
293 14.7.2 open Syntax of explicit instantiation/specialization too permissive
294 5.2.9 NAD Can static_cast drop exception specifications?
295 8.3.5 WP cv-qualifiers on function types
296 12.3.2 WP Can conversion functions be static?
297 14.8.2 open Which template does an explicit specialization specialize?
298 3.4.3.1 WP T::x when T is cv-qualified
299 5.3.4 WP Conversion on array bound expression in new
300 14.8.2.5 WP References to functions in template argument deduction
301 14.2 WP Syntax for template-name
302 8.5 WP Value-initialization and generation of default constructor
303 4.5 NAD Integral promotions on bit-fields
304 8.5 TC1 Value-initialization of a reference
305 3.4.5 WP Name lookup in destructor call
306 10.2 WP Ambiguity by class name injection
307 12.7 NAD Initialization of a virtual base class subobject
308 15.3 NAD Catching exceptions with ambiguous base classes
309 3 DR Linkage of entities whose names are not simply identifiers, in introduction
310 14.5.6.1 open Can function templates differing only in parameter cv-qualifiers be overloaded?
311 7.3.1 NAD Using qualified name to reopen nested namespace
312 3.7.3.2 open “use” of invalid pointer value not defined
313 5.3.4 dup Class with single conversion function to integral as array size in new
314 14.2 drafting template in base class specifier
315 9.4.1 NAD Is call of static member function through null pointer undefined?
316 14.6.1 NAD Injected-class-name of template used as template template parameter
317 7.1.2 WP Can a function be declared inline after it has been called?
318 3.4.3.1 WP struct A::A should not name the constructor of A
319 3.5 WP Use of names without linkage in declaring entities with linkage
320 12.2 WP Question on copy constructor elision example
321 3.4.2 open Associated classes and namespaces for argument-dependent lookup
322 14.8.2.3 WP Deduction of reference conversions
323 14 WP Where must export appear?
324 5.3.1 WP Can "&" be applied to assignment to bit-field?
325 8.3.6 open When are default arguments parsed?
326 12.1 WP Wording for definition of trivial constructor
327 9 WP Use of "structure" without definition
328 9.2 WP Missing requirement that class member types be complete
329 14.5.4 WP Evaluation of friends of templates
330 4.4 open Qualification conversions and pointers to arrays of pointers
331 12.1 WP Allowed copy constructor signatures
332 8.3.5 open cv-qualified void parameter types
333 8.2 NAD Ambiguous use of "declaration" in disambiguation section
334 14.6.2.2 NAD Is a comma-expression dependent if its first operand is?
335 14 WP Allowing export on template members of nontemplate classes
336 14.7.3 WP Explicit specialization examples are still incorrect
337 14.8.2 WP Attempt to create array of abtract type should cause deduction to fail
338 3.5 open Enumerator name with linkage used as class name in other translation unit
339 5.19 DR Overload resolution in operand of sizeof in constant expression
340 8.2 NAD Unclear wording in disambiguation section
341 7.5 review extern "C" namespace member function versus global variable
342 5.3 review Terminology: "indirection" versus "dereference"
343 14.2 open Make template optional in contexts that require a type
344 12.4 open Naming destructors
345 14.6 WP Misleading comment on example in templates chapter
346 15.4 NAD Typo in 15.4
347 9.7 review Use of derived class name in defining base class nested class
348 3.7.3.2 WP delete and user-written deallocation functions
349 14.8.2.3 WP Template argument deduction for conversion functions and qualification conversions
350 3.9 drafting signed char underlying representation for objects
351 5 WP Sequence point error: unspecified or undefined?
352 14.8.2.1 WP Nondeduced contexts
353 5.3.5 WP Is deallocation routine called if destructor throws exception in delete?
354 14.3.2 WP Null as nontype template argument
355 9 review Global-scope :: in nested-name-specifier
356 12.8 NAD Wording of behavior of generated copy constructor for scalar members
357 1.3 WP Definition of signature should include name
358 7.5 NAD Namespaces and extern "C"
359 9.5 NAD Type definition in anonymous union
360 11.2 open Using-declaration that reduces access
361 8.3.6 open Forward reference to default argument
362 2.1 WP Order of initialization in instantiation units
363 12.6.1 NAD Initialization of class from self
364 13.3.1.1.1 WP Calling overloaded function with static in set, with no object
365 3.7 open Storage duration and temporaries
366 5.19 WP String literal allowed in integral constant expression?
367 5.19 WP throw operator allowed in constant expression?
368 14.8.2 WP Uses of non-type parameters that should cause deduction to fail
369 2.4 drafting Are new/delete identifiers or preprocessing-op-or-punc?
370 16.2 WP Can #include <...> form be used other than for standard C++ headers?
371 3.6.2 open Interleaving of constructor calls
372 14.3 WP Is access granted by base class specifiers available in following base class specifiers?
373 3.4.6 review Lookup on namespace qualified name in using-directive
374 8.3 drafting Can explicit specialization outside namespace use qualified name?
375 14.6 dup Confusing example on lookup with typename
376 7.1.2 NAD Class "definition" versus class "declaration"
377 7.2 WP Enum whose enumerators will not fit in any integral type
378 6.6 review Wording that says temporaries are declared
379 9 WP Change "class declaration" to "class definition"
380 10.2 open Definition of "ambiguous base class" missing
381 3.4.5 WP Incorrect example of base class member lookup
382 14.6 WP Allow typename outside of templates
383 9 WP Is a class with a declared but not defined destructor a POD?
384 3.4.2 NAD Argument-dependent lookup and operator functions
385 11.5 WP How does protected member check of 11.5 interact with using-declarations?
386 7.3.3 open Friend declaration of name brought in by using-declaration
387 14.6.5 WP Errors in example in 14.6.5
388 15.3 open Catching base*& from a throw of derived*
389 3.5 WP Unnamed types in entities with linkage
390 10.4 WP Pure virtual must be defined when implicitly called
391 8.5.3 WP Require direct binding of short-lived references to rvalues
392 12.2 WP Use of full expression lvalue before temporary destruction
393 8.3.5 drafting Pointer to array of unknown bound in template argument list in parameter
394 16 WP identifier-list is never defined
395 12.3.2 open Conversion operator template syntax
396 7.1.2 WP Misleading note regarding use of auto for disambiguation
397 7.1.2 WP Same address for string literals from default arguments in inline functions?
398 14.8.2 WP Ambiguous wording on naming a type in deduction
399 12.4 drafting Destructor lookup redux
400 3.4.3.2 WP Using-declarations and the "struct hack"
401 14.1 WP When is access for template parameter default arguments checked?
402 14.5.6.2 open More on partial ordering of function templates
403 3.4.2 WP Reference to a type as a template-id
404 3.8 WP Unclear reference to construction with non-trivial constructor
405 3.4.1 open Unqualified function name lookup
406 9.4.2 WP Static data member in class with name for linkage purposes
407 7.1.3 drafting Named class with associated typedef: two names or one?
408 14.5.1.3 drafting sizeof applied to unknown-bound array static data member of template
409 14.6 WP Obsolete paragraph missed by changes for issue 224
410 14.5.4 WP Paragraph missed in changes for issue 166
411 2.13.4 open Use of universal-character-name in character versus string literals
412 7.1.2 NAD Can a replacement allocation function be inline?
413 9 WP Definition of "empty class"
414 3.4.5 WP Multiple types found on destructor lookup
415 14.8.3 WP Template deduction does not cause instantiation
416 13.3.1.2 WP Class must be complete to allow operator lookup?
417 9.1 WP Using derived-class qualified name in out-of-class nested class definition
418 13.3.3 open Imperfect wording on error on multiple default arguments on a called function
419 3.8 open Can cast to virtual base class be done on partially-constructed object?
420 13.5.6 WP postfixexpression->scalar_type_dtor() inconsistent
421 5.2.5 WP Is rvalue.field an rvalue?
422 7.1.3 NAD Is a typedef redeclaration allowed with a template type that might be the same?
423 13.3.1.2 NAD Can a conversion be done on the left operand of a compound assignment?
424 7.1.3 WP Wording problem with issue 56 resolution on redeclaring typedefs in class scope
425 13.6 WP Set of candidates for overloaded built-in operator with float operand
426 3.5 drafting Identically-named variables, one internally and one externally linked, allowed?
427 5.2.9 WP static_cast ambiguity: conversion versus cast to derived
428 15.1 WP Mention of expression with reference type
429 5.3.4 WP Matching deallocation function chosen based on syntax or signature?
430 8.5.1 WP Ordering of expression evaluation in initializer list
431 14.2 drafting Defect in wording in 14.2
432 3.3.6 WP Is injected class name visible in base class specifier list?
433 3.3.1 WP Do elaborated type specifiers in templates inject into enclosing namespace scope?
434 8.5.3 NAD Unclear suppression of standard conversions while binding reference to lvalue
435 7 NAD Change "declararation or definition" to "declaration"
436 9.6 WP Problem in example in 9.6 paragraph 4
437 9.2 WP Is type of class allowed in member function exception specification?
438 5 open Possible flaw in wording for multiple accesses to object between sequence points
439 5.2.9 WP Guarantees on casting pointer back to cv-qualified version of original type
440 14.3 open Allow implicit pointer-to-member conversion on nontype template argument
441 3.6.2 WP Ordering of static reference initialization
442 5.3.5 WP Incorrect use of null pointer constant in description of delete operator
443 12.2 WP Wording nit in description of lifetime of temporaries
444 12.8 NAD Overriding and the generated copy assignment operator
445 11.4 NAD Wording issue on friend declarations
446 5.16 WP Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?
447 14.6.2.3 WP Is offsetof type-dependent?
448 14.6.1 drafting Set of template functions in call with dependent explicit argument
449 1.3 NAD Consistency in use of hyphen with names of "non" entities
450 8.5.3 WP Binding a reference to const to a cv-qualified array rvalue
451 5 WP Expressions with invalid results and ill-formedness
452 9.3.2 WP Wording nit on description of this
453 8.3.2 drafting References may only bind to “valid” objects
454 9.4.2 WP When is a definition of a static data member required?
455 13.3.3 open Partial ordering and non-deduced arguments
456 4.10 NAD Is initialized const int or const bool variable a null pointer constant?
457 5.19 WP Wording nit on use of const variables in constant expressions
458 14.6.1 drafting Hiding of member template parameters by other members
459 14.6.1 open Hiding of template parameters by base class members
460 7.3.3 WP Can a using-declaration name a namespace?
461 7.4 NAD Make asm conditionally-supported
462 12.2 review Lifetime of temporaries bound to comma expressions
463 5.2.10 WP reinterpret_cast<T*>(0)
464 12.2 WP Wording nit on lifetime of temporaries to which references are bound
465 3.6.2 NAD May constructors of global objects call exit()?
466 5.2.4 WP cv-qualifiers on pseudo-destructor type
467 6.7 NAD Jump past initialization of local static variable
468 14.2 WP Allow ::template outside of templates
469 14.8.2.5 open Const template specializations and reference arguments
470 14.7.2 WP Instantiation of members of an explicitly-instantiated class template
471 11.2 NAD Conflicting inherited access specifications
472 11.5 drafting Casting across protected inheritance
473 5.3.4 open Block-scope declarations of allocator functions
474 3.5 WP Block-scope extern declarations in namespace members
475 15.5.3 drafting When is std::uncaught_exception() true? (take 2)
476 5.3.4 open Determining the buffer size for placement new
477 7.1.2 WP Can virtual appear in a friend declaration?
478 8.3.4 NAD May a function parameter be an array of an abstract class type?
479 15.1 WP Copy elision in exception handling
480 4.11 WP Is a base of a virtual base also virtual?
481 3.3 open Scope of template parameters
482 8.3 review Qualified declarators in redeclarations
483 3.9.1 open Normative requirements on integral ranges
484 10 WP Can a base-specifier name a cv-qualified class type?
485 3 DR What is a “name”?
486 14.8.2 WP Invalid return types and template argument deduction
487 5.19 NAD Operator overloading in constant expressions
488 14.8.2 DR Local types, overload resolution, and template argument deduction
489 14.7.1 NAD Must member function templates be instantiated during overload resolution?
490 3.4.1 drafting Name lookup in friend declarations
491 8.5.1 WP Initializers for empty-class aggregrate members
492 5.2.8 WP typeid constness inconsistent with example
493 14.8.2.3 drafting Type deduction from a bool context
494 11 WP Problems with the resolution of issue 45
495 13.3.3 review Overload resolution with template and non-template conversion functions
496 3.9 open Is a volatile-qualified type really a POD?
497 5.5 WP Missing required initialization in example
498 7.1.1 open Storage class specifiers in definitions of class members
499 15.1 review Throwing an array of unknown size
500 11.4 WP Access in base-specifiers of friend and nested classes
501 11.4 NAD Visibility of friend declarations within the befriending class
502 14.6.2.1 open Dependency of nested enumerations and enumerators
503 14.8.2.1 open Cv-qualified function types in template argument deduction
504 8.3.2 open Should use of a reference in its own initializer require a diagnostic?
505 2.13.2 WP Conditionally-supported behavior for unknown character escapes
506 5.2.2 WP Conditionally-supported behavior for non-POD objects passed to ellipsis
507 13.6 open Ambiguity assigning class object to built-in type
508 8.5 drafting Non-constructed value-initialized objects
509 8.5 open Dead code in the specification of default initialization
510 12.6 WP Default initialization of POD classes?
511 9 open POD-structs with template assignment operators
512 9.5 review Union members with user-declared non-default constructors
513 1.8 WP Non-class “most-derived” objects
514 3.4.1 WP Is the initializer for a namespace member in the scope of the namespace?
515 14.6.2 WP Non-dependent references to base class members
516 7.1.6.2 WP Use of signed in bit-field declarations
517 14.5.5 WP Partial specialization following explicit instantiation
518 7.2 WP Trailing comma following enumerator-list
519 4.10 WP Null pointer preservation in void* conversions
520 5.4 WP Old-style casts between incomplete class types
521 3.7.3.1 WP Requirements for exceptions thrown by allocation functions
522 14.8.2.1 WP Array-to-pointer decay in template argument deduction
523 3.7.3.2 open