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