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 |
| 111 |
12.8 |
Copy constructors and cv-qualifiers
|
| 220 |
3.7.3.2 |
All deallocation functions should be required not to throw
|
| 236 |
5.19 |
Explicit temporaries and integral constant expressions
|
| 240 |
4.1 |
Uninitialized values and undefined behavior
|
| 257 |
12.6.2 |
Abstract base constructors and virtual base initialization
|
| 292 |
5.3.4 |
Deallocation on exception in new before arguments evaluated
|
| 341 |
7.5 |
extern "C" namespace member function versus global variable
|
| 342 |
5.3 |
Terminology: "indirection" versus "dereference"
|
| 347 |
9.7 |
Use of derived class name in defining base class nested class
|
| 355 |
9 |
Global-scope :: in nested-name-specifier
|
| 373 |
3.4.6 |
Lookup on namespace qualified name in using-directive
|
| 378 |
6.6 |
Wording that says temporaries are declared
|
| 462 |
12.2 |
Lifetime of temporaries bound to comma expressions
|
| 482 |
8.3 |
Qualified declarators in redeclarations
|
| 495 |
13.3.3 |
Overload resolution with template and non-template conversion functions
|
| 499 |
15.1 |
Throwing an array of unknown size
|
| 512 |
9.5 |
Union members with user-declared non-default constructors
|
| 533 |
16.2 |
Special treatment for C-style header names
|
| 535 |
12.8 |
Copy construction without a copy constructor
|
| 539 |
7.1.6 |
Constraints on type-specifier-seq
|
| 542 |
12.6 |
Value initialization of arrays of POD-structs
|
| 543 |
8.5 |
Value initialization and default constructors
|
| 547 |
8.3.5 |
Partial specialization on member function types
|
| 554 |
3.3 |
Definition of “declarative region” and “scope”
|
| 555 |
3.4 |
Pseudo-destructor name lookup
|
| 556 |
5.17 |
Conflicting requirements for acceptable aliasing
|
| 564 |
7.5 |
Agreement of language linkage or linkage-specifications?
|
| 569 |
7 |
Spurious semicolons at namespace scope should be allowed
|
| 570 |
3.2 |
Are references subject to the ODR?
|
| 571 |
3.5 |
References declared const
|
| 572 |
4 |
Standard conversions for non-built-in types
|
| 573 |
5.2.10 |
Conversions between function pointers and void*
|
| 574 |
12.8 |
Definition of “copy assignment operator”
|
| 575 |
14.8.2 |
Criteria for deduction failure
|
| 576 |
7.1.3 |
Typedefs in function definitions
|
| 580 |
11 |
Access in template-parameters of member and friend definitions
|
| 585 |
11.4 |
Friend template template parameters
|
| 588 |
14.6.2 |
Searching dependent bases of classes local to function templates
|
| 592 |
15.2 |
Exceptions during construction of local static objects
|
| 597 |
3.8 |
Conversions applied to out-of-lifetime non-POD lvalues
|
| 598 |
3.4.2 |
Associated namespaces of overloaded functions and function templates
|
| 599 |
5.3.5 |
Deleting a null function pointer
|
| 601 |
16.1 |
Type of literals in preprocessing expressions
|
| 606 |
14.8.2.1 |
Template argument deduction for rvalue references
|
| 608 |
10.3 |
Determining the final overrider of a virtual function
|
| 614 |
5.6 |
Results of integer / and %
|
| 615 |
8.5 |
Incorrect description of variables that can be initialized
|
| 619 |
3.9 |
Completeness of array types
|
| 621 |
14.7.3 |
Template argument deduction from function return types
|
| 624 |
5.3.4 |
Overflow in calculating size of allocation
|
| 626 |
16.3.2 |
Preprocessor string literals
|
| 628 |
7.2 |
The values of an enumeration with no enumerator
|
| 633 |
3 |
Specifications for variables that should also apply to references
|
| 641 |
13.3.2 |
Overload resolution and conversion-to-same-type operators
|
| 642 |
3.3.2 |
Definition and use of “block scope” and “local scope”
|
| 645 |
9.2 |
Are bit-field and non-bit-field members layout compatible?
|
| 650 |
12.2 |
Order of destruction for temporaries bound to the returned value of a function
|
| 652 |
5.19 |
Compile-time evaluation of floating-point expressions
|
| 653 |
12.8 |
Copy assignment of unions
|
| 655 |
12.6.2 |
Initialization not specified for forwarding constructors
|
| 657 |
14.8.2 |
Abstract class parameter in synthesized declaration
|
| 658 |
5.2.10 |
Defining reinterpret_cast for pointer types
|
| 665 |
5.2.7 |
Problems in the specification of dynamic_cast
|
| 667 |
12.8 |
Trivial special member functions that cannot be implicitly defined
|
| 668 |
15.5.1 |
Throwing an exception from the destructor of a local static object
|
| 672 |
5.3.4 |
Sequencing of initialization in new-expressions
|
| 681 |
8.3.5 |
Restrictions on declarators with late-specified return types
|
| 683 |
12.8 |
Requirements for trivial subobject special functions
|
| 684 |
5.19 |
Constant expressions involving the address of an automatic variable
|
| 685 |
4.5 |
Integral promotion of enumeration ignores fixed underlying type
|
| 688 |
3.6.2 |
Constexpr constructors and static initialization
|
| 692 |
14.8.2.5 |
Partial ordering of variadic class template partial specializations
|
| 693 |
4.2 |
New string types and deprecated conversion
|
| 694 |
8.5 |
Zero- and value-initialization of union objects
|
| Issue |
Section |
Title |
| 2 |
14.6.4 |
How can dependent names be used in member declarations that appear outside of the class template definition?
|
| 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
|
| 205 |
14 |
Templates and static data members
|
| 212 |
14.7.1 |
Implicit instantiation is not described clearly enough
|
| 225 |
3.4.2 |
Koenig lookup and fundamental types
|
| 232 |
5.3.1 |
Is indirection through a null pointer undefined behavior?
|
| 233 |
8.5.3 |
References vs pointers in UDC overload resolution
|
| 260 |
13.6 |
User-defined conversions and built-in operator=
|
| 287 |
14.6.4.1 |
Order dependencies in template instantiation
|
| 314 |
14.2 |
template in base class specifier
|
| 350 |
3.9 |
signed char underlying representation for objects
|
| 369 |
2.4 |
Are new/delete identifiers or preprocessing-op-or-punc?
|
| 374 |
8.3 |
Can explicit specialization outside namespace use qualified name?
|
| 393 |
8.3.5 |
Pointer to array of unknown bound in template argument list in parameter
|
| 399 |
12.4 |
Destructor lookup redux
|
| 407 |
7.1.3 |
Named class with associated typedef: two names or one?
|
| 408 |
14.5.1.3 |
sizeof applied to unknown-bound array static data member of template
|
| 426 |
3.5 |
Identically-named variables, one internally and one externally linked, allowed?
|
| 431 |
14.2 |
Defect in wording in 14.2
|
| 448 |
14.6.1 |
Set of template functions in call with dependent explicit argument
|
| 453 |
8.3.2 |
References may only bind to “valid” objects
|
| 458 |
14.6.1 |
Hiding of member template parameters by other members
|
| 472 |
11.5 |
Casting across protected inheritance
|
| 475 |
15.5.3 |
When is std::uncaught_exception() true? (take 2)
|
| 490 |
3.4.1 |
Name lookup in friend declarations
|
| 493 |
14.8.2.3 |
Type deduction from a bool context
|
| 508 |
8.5 |
Non-constructed value-initialized objects
|
| 527 |
3.5 |
Problems with linkage of types
|
| 529 |
14.7.3 |
Use of template<> with “explicitly-specialized” class templates
|
| 531 |
14.7.3 |
Defining members of explicit specializations
|
| 532 |
14.5.6.2 |
Member/nonmember operator template partial ordering
|
| 536 |
5.1 |
Problems in the description of id-expressions
|
| 541 |
14.6.2.2 |
Dependent function types
|
| 546 |
14.7.2 |
Explicit instantiation of class template members
|
| 549 |
14.5.5.1 |
Non-deducible parameters in partial specializations
|
| 560 |
14.6 |
Use of the typename keyword in return types
|
| 561 |
14.6.4.2 |
Internal linkage functions in dependent name lookup
|
| 586 |
14.8.2.5 |
Default template-arguments and template argument deduction
|
| 587 |
5.16 |
Lvalue operands of a conditional expression differing only in cv-qualification
|
| 589 |
8.5.3 |
Direct binding of class and array rvalues in reference initialization
|
| 604 |
13.3.1.3 |
Argument list for overload resolution in copy-initialization
|
| 605 |
14.7.3 |
Linkage of explicit specializations
|
| 612 |
1.9 |
Requirements on a conforming implementation
|
| 617 |
4.1 |
Lvalue-to-rvalue conversions of uninitialized char objects
|
| 618 |
16.1 |
Casts in preprocessor conditional expressions
|
| 625 |
7.1.6.4 |
Use of auto as a template-argument
|
| 630 |
2.2 |
Equality of narrow and wide character values in the basic character set
|
| 636 |
3.10 |
Dynamic type of objects and aliasing
|
| 664 |
8.5.3 |
Direct binding of references to non-class rvalue references
|
| 674 |
14.5.4 |
“matching specialization” for a friend declaration
|
| 676 |
3.1 |
static_assert-declarations and general requirements for declarations
|
| 678 |
3.2 |
Language linkage of member function parameter types and the ODR
|
| 680 |
12.8 |
What is a move constructor?
|
| 682 |
3.4.5 |
Missing description of lookup of template aliases
|
| 690 |
1.3 |
The dynamic type of an rvalue reference
|
| 691 |
14.1 |
Template parameter packs in class template partial specializations
|
| Issue |
Section |
Title |
| 6 |
12.8 |
Should the optimization that allows a class object to alias another object also allow the case of a parameter in an inline function to alias its argument?
|
| 23 |
14.5.6.2 |
Some questions regarding partial ordering of function templates
|
| 36 |
7.3.3 |
using-declarations in multiple-declaration contexts
|
| 57 |
9.5 |
Empty unions
|
| 92 |
15.4 |
Should exception specifications be part of the type system?
|
| 110 |
14 |
Can template functions and classes be declared in the same scope?
|
| 129 |
1.9 |
Stability of uninitialized auto variables
|
| 144 |
7.1.6.3 |
Position of friend specifier
|
| 146 |
3.9.1 |
Floating-point zero
|
| 150 |
14.3.3 |
Template template parameters and default arguments
|
| 157 |
7 |
Omitted typedef declarator
|
| 186 |
14.6.1 |
Name hiding and template template-parameters
|
| 191 |
3.4.1 |
Name lookup does not handle complex nesting
|
| 192 |
3.4.1 |
Name lookup in parameters
|
| 196 |
5.3.5 |
Arguments to deallocation functions |
| 203 |
5.3.1 |
Type of address-of-member expression
|
| 219 |
15.5.1 |
Cannot defend against destructors that throw exceptions
|
| 223 |
D |
The meaning of deprecation
|
| 230 |
10.4 |
Calls to pure virtual functions
|
| 238 |
5 |
Precision and accuracy constraints on floating point
|
| 242 |
5.4 |
Interpretation of old-style casts
|
| 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
|
| 256 |
5.3.4 |
Overflow in size calculations
|
| 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
|
| 293 |
14.7.2 |
Syntax of explicit instantiation/specialization too permissive
|
| 297 |
14.8.2 |
Which template does an explicit specialization specialize?
|
| 310 |
14.5.6.1 |
Can function templates differing only in parameter cv-qualifiers be overloaded?
|
| 312 |
3.7.3.2 |
“use” of invalid pointer value not defined
|
| 321 |
3.4.2 |
Associated classes and namespaces for argument-dependent lookup
|
| 325 |
8.3.6 |
When are default arguments parsed?
|
| 330 |
4.4 |
Qualification conversions and pointers to arrays of pointers
|
| 332 |
8.3.5 |
cv-qualified void parameter types
|
| 338 |
3.5 |
Enumerator name with linkage used as class name in other translation unit
|
| 343 |
14.2 |
Make template optional in contexts that require a type
|
| 344 |
12.4 |
Naming destructors
|
| 360 |
11.2 |
Using-declaration that reduces access
|
| 361 |
8.3.6 |
Forward reference to default argument
|
| 365 |
3.7 |
Storage duration and temporaries
|
| 371 |
3.6.2 |
Interleaving of constructor calls
|
| 380 |
10.2 |
Definition of "ambiguous base class" missing
|
| 386 |
7.3.3 |
Friend declaration of name brought in by using-declaration
|
| 388 |
15.3 |
Catching base*& from a throw of derived*
|
| 395 |
12.3.2 |
Conversion operator template syntax
|
| 402 |
14.5.6.2 |
More on partial ordering of function templates
|
| 405 |
3.4.1 |
Unqualified function name lookup
|
| 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?
|
| 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
|
| 455 |
13.3.3 |
Partial ordering and non-deduced arguments
|
| 459 |
14.6.1 |
Hiding of template parameters by base class members
|
| 469 |
14.8.2.5 |
Const template specializations and reference arguments
|
| 473 |
5.3.4 |
Block-scope declarations of allocator functions
|
| 476 |
5.3.4 |
Determining the buffer size for placement new
|
| 481 |
3.3 |
Scope of template parameters
|
| 483 |
3.9.1 |
Normative requirements on integral ranges
|
| 496 |
3.9 |
Is a volatile-qualified type really a POD?
|
| 498 |
7.1.1 |
Storage class specifiers in definitions of class members
|
| 502 |
14.6.2.1 |
Dependency of nested enumerations and enumerators
|
| 503 |
14.8.2.1 |
Cv-qualified function types in template argument deduction
|
| 504 |
8.3.2 |
Should use of a reference in its own initializer require a diagnostic?
|
| 507 |
13.6 |
Ambiguity assigning class object to built-in type
|
| 509 |
8.5 |
Dead code in the specification of default initialization
|
| 511 |
9 |
POD-structs with template assignment operators
|
| 523 |
3.7.3.2 |
Can a one-past-the-end pointer be invalidated by deleting an adjacent object?
|
| 528 |
5.2.8 |
Why are incomplete class types not allowed with typeid?
|
| 545 |
13.3.1.2 |
User-defined conversions and built-in operator overload resolution
|
| 550 |
8.3.5 |
Pointer to array of unknown bound in parameter declarations
|
| 562 |
3.4.3.1 |
qualified-ids in non-expression contexts
|
| 563 |
7.5 |
Linkage specification for objects
|
| 565 |
7.3.3 |
Conflict rules for using-declarations naming function templates
|
| 577 |
8.3.5 |
void in an empty parameter list
|
| 578 |
2.1 |
Phase 1 replacement of characters with universal-character-names
|
| 579 |
14.2 |
What is a “nested” > or >>?
|
| 581 |
12.1 |
Can a templated constructor be explicitly instantiated or specialized?
|
| 583 |
5.9 |
Relational pointer comparisons against the null pointer constant
|
| 590 |
14.6.2.1 |
Nested classes and the “current instantiation”
|
| 591 |
14.6.2 |
When a dependent base class is the current instantiation
|
| 595 |
15.4 |
Exception specifications in templates instantiated from class bodies
|
| 596 |
15.5.2 |
Replacing an exception object
|
| 600 |
11 |
Does access control apply to members or to names?
|
| 602 |
14.6.1 |
When is the injected-class-name of a class template a template?
|
| 607 |
12.6.2 |
Lookup of mem-initializer-ids
|
| 609 |
7.1.6.1 |
What is a “top-level” cv-qualifier?
|
| 611 |
8.5 |
Zero-initializing references
|
| 616 |
1.3 |
Definition of “indeterminate value”
|
| 631 |
6.4.1 |
Jumping into a “then” clause
|
| 638 |
14.5.4 |
Explicit specialization and friendship
|
| 640 |
3.6.3 |
Accessing destroyed local objects of static storage duration
|
| 656 |
8.5.3 |
Direct binding to the result of a conversion operator
|
| 670 |
8.5 |
Copy initialization via derived-to-base conversion in the second step
|
| 673 |
7.3.1.2 |
Injection of names from elaborated-type-specifiers in friend declarations
|
| 675 |
9.6 |
Signedness of bit-field with typedef or template parameter type
|
| 687 |
5.1 |
template keyword with unqualified-ids
|
| 689 |
3.9.1 |
Maximum values of signed and unsigned integers
|
| 695 |
5 |
Compile-time calculation errors in constexpr functions
|
| 696 |
9.8 |
Use of block-scope constants in local classes
|
| 697 |
14.8.2 |
Deduction rules apply to more than functions
|
| 698 |
1.9 |
The definition of “sequenced before” is too narrow
|
| 699 |
7.1.5 |
Must constexpr member functions be defined in the class member-specification?
|
| 700 |
7.1.5 |
Constexpr member functions of class templates
|
| 701 |
8.3.4 |
When is the array-to-pointer conversion applied?
|
| 702 |
13.3.4.1 |
Preferring conversion to std::initializer_list
|
| 703 |
8.5.4 |
Narrowing for literals that cannot be exactly represented
|
| 704 |
13.3.1.1 |
To which postfix-expressions does overload resolution apply?
|
| 705 |
3.4.2 |
Suppressing argument-dependent lookup via parentheses
|
| 706 |
7.1.6.4 |
Use of auto with rvalue references
|
| 707 |
4.9 |
Undefined behavior in integral-to-floating conversions
|
| 708 |
14.5.5 |
Partial specialization of member templates of class templates
|
| 709 |
14.8.2 |
Enumeration names as nested-name-specifiers in deduction failure
|
| 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.4 |
Template friend issues
|
| 50 |
3.2 |
Converting pointer to incomplete type to same type
|
| 55 |
5.7 |
Adding/subtracting pointer and enumeration value
|
| 61 |
13.4 |
Address of static member function "&p->f"
|
| 66 |
8.3.6 |
Visibility of default args vs overloads added after using-declaration
|
| 71 |
5 |
Incorrect cross reference
|
| 81 |
C |
Null pointers and C compatability
|
| 88 |
14.7.3 |
Specialization of member constant templates
|
| 91 |
3.4.2 |
A union's associated types should include the union itself
|
| 95 |
7.3.1.2 |
Elaborated type specifiers referencing names declared in friend decls
|
| 97 |
5.19 |
Use of bool constants in integral constant expressions
|
| 99 |
14.8.2.1 |
Partial ordering, references and cv-qualifiers
|
| 102 |
13.3.1.2 |
Operator lookup rules do not work well with parts of the library
|
| 104 |
15.1 |
Destroying the exception temp when no handler is found
|
| 107 |
7.5 |
Linkage of operator functions
|
| 109 |
7.3.3 |
Allowing ::template in using-declarations
|
| 114 |
14.5.2 |
Virtual overriding by template member function specializations
|
| 117 |
12.2 |
Timing of destruction of temporaries
|
| 130 |
5.3.4 |
Sequence points and new-expressions
|
| 132 |
3.5 |
Local types and linkage
|
| 154 |
7.1.1 |
Anonymous unions in unnamed namespaces
|
| 165 |
7.3.1.2 |
Definitions of friends and block-scope externs
|
| 167 |
D.2 |
Deprecating static functions
|
| 168 |
7.5 |
C linkage for static member functions
|
| 169 |
7.3.3 |
template-ids in using-declarations
|
| 174 |
D.2 |
Undeprecating global static
|
| 182 |
14.7.3 |
Access checking on explicit specializations
|
| 209 |
11.4 |
Must friend declaration names be
accessible? |
| 211 |
15 |
Constructors should not be allowed to return normally after an exception
|
| 229 |
14.5.5 |
Partial specialization of function templates
|
| 231 |
3.4.1 |
Visibility of names after using-directives
|
| 234 |
3.8 |
Reuse of base class subobjects
|
| 243 |
13.3.3.1.2 |
Weighting of conversion functions in direct-initialization
|
| 247 |
13.4 |
Pointer-to-member casts and function overload resolution
|
| 266 |
A |
No grammar sentence symbol
|
| 269 |
3.6.2 |
Order of initialization of multiply-defined static data members
of class templates
|
| 285 |
14.7.3 |
Identifying a function template being specialized
|
| 290 |
3.9 |
Should memcpy be allowed into a POD with a const member?
|
| 294 |
5.2.9 |
Can static_cast drop exception specifications?
|
| 303 |
4.5 |
Integral promotions on bit-fields
|
| 307 |
12.7 |
Initialization of a virtual base class subobject
|
| 308 |
15.3 |
Catching exceptions with ambiguous base classes
|
| 311 |
7.3.1 |
Using qualified name to reopen nested namespace
|
| 315 |
9.4.1 |
Is call of static member function through null pointer undefined?
|
| 316 |
14.6.1 |
Injected-class-name of template used as template template parameter
|
| 333 |
8.2 |
Ambiguous use of "declaration" in disambiguation section
|
| 334 |
14.6.2.2 |
Is a comma-expression dependent if its first operand is?
|
| 340 |
8.2 |
Unclear wording in disambiguation section |
| 346 |
15.4 |
Typo in 15.4
|
| 356 |
12.8 |
Wording of behavior of generated copy constructor for scalar members
|
| 358 |
7.5 |
Namespaces and extern "C"
|
| 359 |
9.5 |
Type definition in anonymous union
|
| 363 |
12.6.1 |
Initialization of class from self
|
| 376 |
7.1.2 |
Class "definition" versus class "declaration"
|
| 384 |
3.4.2 |
Argument-dependent lookup and operator functions
|
| 412 |
7.1.2 |
Can a replacement allocation function be inline?
|
| 422 |
7.1.3 |
Is a typedef redeclaration allowed with a template type that might be the same?
|
| 423 |
13.3.1.2 |
Can a conversion be done on the left operand of a compound assignment?
|
| 434 |
8.5.3 |
Unclear suppression of standard conversions while binding reference to lvalue
|
| 435 |
7 |
Change "declararation or definition" to "declaration"
|
| 444 |
12.8 |
Overriding and the generated copy assignment operator
|
| 445 |
11.4 |
Wording issue on friend declarations
|
| 449 |
1.3 |
Consistency in use of hyphen with names of "non" entities
|
| 456 |
4.10 |
Is initialized const int or const bool variable a null pointer constant?
|
| 461 |
7.4 |
Make asm conditionally-supported
|
| 465 |
3.6.2 |
May constructors of global objects call exit()?
|
| 467 |
6.7 |
Jump past initialization of local static variable
|
| 471 |
11.2 |
Conflicting inherited access specifications
|
| 478 |
8.3.4 |
May a function parameter be an array of an abstract class type?
|
| 487 |
5.19 |
Operator overloading in constant expressions
|
| 489 |
14.7.1 |
Must member function templates be instantiated during overload resolution?
|
| 501 |
11.4 |
Visibility of friend declarations within the befriending class
|
| 544 |
14.6.2 |
Base class lookup in explicit specialization
|
| 552 |
14.2 |
Use of typename in the type in a non-type parameter-declaration
|
| 553 |
7.3.1.2 |
Problems with friend allocation and deallocation functions
|
| 566 |
4.9 |
Conversion of negative floating point values to integer type
|
| 567 |
5.7 |
Can size_t and ptrdiff_t be larger than long?
|
| 584 |
3.10 |
Unions and aliasing
|
| 593 |
15.3 |
Falling off the end of a destructor's function-try-block handler
|
| 610 |
5.3.1 |
Computing the negative of 0U
|
| 627 |
3.9.1 |
Values behaving as types
|
| 635 |
3.4.3.1 |
Names of constructors and destructors of templates
|
| 643 |
7.1.6.2 |
Use of decltype in a class member-specification
|
| 646 |
3.9 |
Can a class with a constexpr copy constructor be a literal type?
|
| 662 |
14.8.2 |
Forming a pointer to a reference type
|
| 669 |
7.1.6.2 |
Confusing specification of the meaning of decltype
|
| 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
|
| 39 |
10.2 |
Conflicting ambiguity rules
|
| 44 |
14.7.3 |
Member specializations
|
| 45 |
11.8 |
Access to nested classes
|
| 54 |
5.2.9 |
Static_cast from private base to derived class
|
| 58 |
9.6 |
Signedness of bit fields of enum type
|
| 60 |
13.3.3.1.4 |
Reference binding and valid conversion sequences
|
| 62 |
14.3.1 |
Unnamed members of classes used as type parameters
|
| 63 |
14.7.1 |
Class instantiation from pointer conversion to void*, null and self
|
| 70 |
14.8.2.5 |
Is an array bound a nondeduced context?
|
| 77 |
11.4 |
The definition of friend does not allow nested classes to be friends
|
| 78 |
8.5 |
Section 8.5 paragraph 9 should state it only applies to non-static objects
|
| 86 |
12.2 |
Lifetime of temporaries in query expressions
|
| 87 |
15.4 |
Exception specifications on function parameters
|
| 106 |
unknown |
Creating references to references during template deduction/instantiation
|
| 112 |
8.3.4 |
Array types and cv-qualifiers
|
| 113 |
5.2.2 |
Visibility of called function
|
| 115 |
13.4 |
Address of template-id
|
| 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
|
| 195 |
5.2.10 |
Converting between function and object pointers
|
| 197 |
14.6.4.2 |
Issues with two-stage lookup of dependent names
|
| 198 |
9.8 |
Definition of "use" in local and nested classes
|
| 199 |
12.2 |
Order of destruction of temporaries
|
| 201 |
12.2 |
Order of destruction of temporaries in initializers
|
| 204 |
14 |
Exported class templates
|
| 207 |
11.2 |
using-declarations and protected access
|
| 208 |
15.1 |
Rethrowing exceptions in nested handlers
|
| 214 |
14.5.6.2 |
Partial ordering of function templates is underspecified
|
| 215 |
14.1 |
Template parameters are not allowed in nested-name-specifiers
|
| 216 |
3.5 |
Linkage of nameless class-scope enumeration types
|
| 218 |
3.4.2 |
Specification of Koenig lookup
|
| 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
|
| 237 |
14.7.2 |
Explicit instantiation and base class members
|
| 239 |
13.3.1.1.1 |
Footnote 116 and Koenig lookup
|
| 244 |
12.4 |
Destructor lookup
|
| 245 |
3.4.4 |
Name lookup in elaborated-type-specifiers
|
| 246 |
14.3 |
Jumps in function-try-block handlers
|
| 252 |
12.4 |
Looking up deallocation functions in virtual destructors
|
| 254 |
3.4.4 |
Definitional problems with elaborated-type-specifiers
|
| 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.6.2 |
Template type-parameters are not syntactically type-names
|
| 284 |
9 |
qualified-ids in class declarations
|
| 286 |
14.5.5 |
Incorrect example in partial specialization
|
| 289 |
3.2 |
Incomplete list of contexts requiring a complete type
|
| 291 |
8.5.3 |
Overload resolution needed when binding reference to class rvalue
|
| 295 |
8.3.5 |
cv-qualifiers on function types
|
| 296 |
12.3.2 |
Can conversion functions be static?
|
| 298 |
3.4.3.1 |
T::x when T is cv-qualified
|
| 299 |
5.3.4 |
Conversion on array bound expression in new
|
| 300 |
14.8.2.5 |
References to functions in template argument deduction
|
| 301 |
14.2 |
Syntax for template-name
|
| 302 |
8.5 |
Value-initialization and generation of default constructor
|
| 305 |
3.4.5 |
Name lookup in destructor call
|
| 306 |
10.2 |
Ambiguity by class name injection
|
| 317 |
7.1.2 |
Can a function be declared inline after it has been called?
|
| 318 |
3.4.3.1 |
struct A::A should not name the constructor of A
|
| 319 |
3.5 |
Use of names without linkage in declaring entities with linkage
|
| 320 |
12.2 |
Question on copy constructor elision example
|
| 322 |
14.8.2.3 |
Deduction of reference conversions
|
| 323 |
14 |
Where must export appear?
|
| 324 |
5.3.1 |
Can "&" be applied to assignment to bit-field?
|
| 326 |
12.1 |
Wording for definition of trivial constructor
|
| 327 |
9 |
Use of "structure" without definition
|
| 328 |
9.2 |
Missing requirement that class member types be complete
|
| 329 |
14.5.4 |
Evaluation of friends of templates
|
| 331 |
12.1 |
Allowed copy constructor signatures
|
| 335 |
14 |
Allowing export on template members of nontemplate classes
|
| 336 |
14.7.3 |
Explicit specialization examples are still incorrect
|
| 337 |
14.8.2 |
Attempt to create array of abtract type should cause deduction to fail
|
| 345 |
14.6 |
Misleading comment on example in templates chapter
|
| 348 |
3.7.3.2 |
delete and user-written deallocation functions
|
| 349 |
14.8.2.3 |
Template argument deduction for conversion functions and qualification conversions
|
| 351 |
5 |
Sequence point error: unspecified or undefined?
|
| 352 |
14.8.2.1 |
Nondeduced contexts
|
| 353 |
5.3.5 |
Is deallocation routine called if destructor throws exception in delete?
|
| 354 |
14.3.2 |
Null as nontype template argument
|
| 357 |
1.3 |
Definition of signature should include name
|
| 362 |
2.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?
|
| 367 |
5.19 |
throw operator allowed in constant expression?
|
| 368 |
14.8.2 |
Uses of non-type parameters that should cause deduction to fail
|
| 370 |
16.2 |
Can #include <...> form be used other than for standard C++ headers?
|
| 372 |
14.3 |
Is access granted by base class specifiers available in following base class specifiers?
|
| 377 |
7.2 |
Enum whose enumerators will not fit in any integral type
|
| 379 |
9 |
Change "class declaration" to "class definition"
|
| 381 |
3.4.5 |
Incorrect example of base class member lookup
|
| 382 |
14.6 |
Allow typename outside of templates
|
| 383 |
9 |
Is a class with a declared but not defined destructor a POD?
|
| 385 |
11.5 |
How does protected member check of 11.5 interact with using-declarations?
|
| 387 |
14.6.5 |
Errors in example in 14.6.5
|
| 389 |
3.5 |
Unnamed types in entities with linkage
|
| 390 |
10.4 |
Pure virtual must be defined when implicitly called
|
| 391 |
8.5.3 |
Require direct binding of short-lived references to rvalues
|
| 392 |
12.2 |
Use of full expression lvalue before temporary destruction
|
| 394 |
16 |
identifier-list is never defined
|
| 396 |
7.1.2 |
Misleading note regarding use of auto for disambiguation
|
| 397 |
7.1.2 |
Same address for string literals from default arguments in inline functions?
|
| 398 |
14.8.2 |
Ambiguous wording on naming a type in deduction
|
| 400 |
3.4.3.2 |
Using-declarations and the "struct hack"
|
| 401 |
14.1 |
When is access for template parameter default arguments checked?
|
| 403 |
3.4.2 |
Reference to a type as a template-id
|
| 404 |
3.8 |
Unclear reference to construction with non-trivial constructor
|
| 406 |
9.4.2 |
Static data member in class with name for linkage purposes
|
| 409 |
14.6 |
Obsolete paragraph missed by changes for issue 224
|
| 410 |
14.5.4 |
Paragraph missed in changes for issue 166
|
| 413 |
9 |
Definition of "empty class"
|
| 414 |
3.4.5 |
Multiple types found on destructor lookup
|
| 415 |
14.8.3 |
Template deduction does not cause instantiation
|
| 416 |
13.3.1.2 |
Class must be complete to allow operator lookup?
|
| 417 |
9.1 |
Using derived-class qualified name in out-of-class nested class definition
|
| 420 |
13.5.6 |
postfixexpression->scalar_type_dtor() inconsistent
|
| 421 |
5.2.5 |
Is rvalue.field an rvalue?
|
| 424 |
7.1.3 |
Wording problem with issue 56 resolution on redeclaring typedefs in class scope
|
| 425 |
13.6 |
Set of candidates for overloaded built-in operator with float operand
|
| 427 |
5.2.9 |
static_cast ambiguity: conversion versus cast to derived
|
| 428 |
15.1 |
Mention of expression with reference type
|
| 429 |
5.3.4 |
Matching deallocation function chosen based on syntax or signature?
|
| 430 |
8.5.1 |
Ordering of expression evaluation in initializer list
|
| 432 |
3.3.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?
|
| 436 |
9.6 |
Problem in example in 9.6 paragraph 4
|
| 437 |
9.2 |
Is type of class allowed in member function exception specification?
|
| 439 |
5.2.9 |
Guarantees on casting pointer back to cv-qualified version of original type
|
| 441 |
3.6.2 |
Ordering of static reference initialization
|
| 442 |
5.3.5 |
Incorrect use of null pointer constant in description of delete operator
|
| 443 |
12.2 |
Wording nit in description of lifetime of temporaries
|
| 446 |
5.16 |
Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?
|
| 447 |
14.6.2.3 |
Is offsetof type-dependent?
|
| 450 |
8.5.3 |
Binding a reference to const to a cv-qualified array rvalue
|
| 451 |
5 |
Expressions with invalid results and ill-formedness
|
| 452 |
9.3.2 |
Wording nit on description of this
|
| 454 |
9.4.2 |
When is a definition of a static data member required?
|
| 457 |
5.19 |
Wording nit on use of const variables in constant expressions
|
| 460 |
7.3.3 |
Can a using-declaration name a namespace?
|
| 463 |
5.2.10 |
reinterpret_cast<T*>(0)
|
| 464 |
12.2 |
Wording nit on lifetime of temporaries to which references are bound
|
| 466 |
5.2.4 |
cv-qualifiers on pseudo-destructor type
|
| 468 |
14.2 |
Allow ::template outside of templates
|
| 470 |
14.7.2 |
Instantiation of members of an explicitly-instantiated class template
|
| 474 |
3.5 |
Block-scope extern declarations in namespace members
|
| 477 |
7.1.2 |
Can virtual appear in a friend declaration?
|
| 479 |
15.1 |
Copy elision in exception handling
|
| 480 |
4.11 |
Is a base of a virtual base also virtual?
|
| 484 |
10 |
Can a base-specifier name a cv-qualified class type?
|
| 486 |
14.8.2 |
Invalid return types and template argument deduction
|
| 491 |
8.5.1 |
Initializers for empty-class aggregrate members
|
| 492 |
5.2.8 |
typeid constness inconsistent with example
|
| 494 |
11 |
Problems with the resolution of issue 45
|
| 497 |
5.5 |
Missing required initialization in example
|
| 500 |
11.4 |
Access in base-specifiers of friend and nested classes
|
| 505 |
2.13.2 |
Conditionally-supported behavior for unknown character escapes
|
| 506 |
5.2.2 |
Conditionally-supported behavior for non-POD objects passed to ellipsis
|
| 510 |
12.6 |
Default initialization of POD classes?
|
| 513 |
1.8 |
Non-class “most-derived” objects
|
| 514 |
3.4.1 |
Is the initializer for a namespace member in the scope of the namespace?
|
| 515 |
14.6.2 |
Non-dependent references to base class members
|
| 516 |
7.1.6.2 |
Use of signed in bit-field declarations
|
| 517 |
14.5.5 |
Partial specialization following explicit instantiation
|
| 518 |
7.2 |
Trailing comma following enumerator-list
|
| 519 |
4.10 |
Null pointer preservation in void* conversions
|
| 520 |
5.4 |
Old-style casts between incomplete class types
|
| 521 |
3.7.3.1 |
Requirements for exceptions thrown by allocation functions
|
| 522 |
14.8.2.1 |
Array-to-pointer decay in template argument deduction
|
| 524 |
14.6.2 |
Can function-notation calls to operator functions be dependent?
|
| 525 |
14.7.1 |
Missing * in example
|
| 526 |
14.8.2.5 |
Confusing aspects in the specification of non-deduced contexts
|
| 530 |
5.19 |
Nontype template arguments in constant expressions
|
| 534 |
14 |
template-names and operator-function-ids
|
| 537 |
1.3 |
Definition of “signature”
|
| 538 |
9 |
Definition and usage
of structure, POD-struct, POD-union,
and POD class
|
| 540 |
7.3.1 |
Propagation of cv-qualifiers in reference-to-reference collapse
|
| 551 |
14.7.2 |
When is inline permitted in an explicit instantiation?
|
| 557 |
3.4.2 |
Does argument-dependent lookup cause template instantiation?
|
| 558 |
2.2 |
Excluded characters in universal character names
|
| 559 |
14.6 |
Editing error in issue 382 resolution
|
| 568 |
9 |
Definition of POD is too strict
|
| 582 |
14.5.2 |
Template conversion functions
|
| 603 |
14.4 |
Type equivalence and unsigned overflow
|
| 613 |
9.2 |
Unevaluated uses of non-static class members
|
| 620 |
9.2 |
Declaration order in layout-compatible POD structs
|
| 629 |
7.1.6.4 |
auto parsing ambiguity
|
| Issue |
Section |
Title |
| 1 |
8.3.6 |
What if two using-declarations refer to the same function but the declarations introduce different default-arguments?
|
| 20 |
12.8 |
Some clarifications needed for 12.8 para 15
|
| 21 |
14.1 |
Can a default argument for a template parameter appear in a friend declaration?
|
| 22 |
14.6.4 |
Template parameter with a default argument that refers to itself
|
| 24 |
14.7.3 |
Errors in examples in 14.7.3
|
| 25 |
15.4 |
Exception specifications and pointers to members
|
| 30 |
14.2 |
Valid uses of "::template"
|
| 32 |
14 |
Clarification of explicit instantiation of non-exported templates
|
| 33 |
3.4.2 |
Argument dependent lookup and overloaded functions
|
| 35 |
8.5 |
Definition of default-initialization
|
| 38 |
14.2 |
Explicit template arguments and operator functions
|
| 40 |
8.3 |
Syntax of declarator-id
|
| 41 |
3.4.1 |
Clarification of lookup of names after declarator-id
|
| 43 |
3.9 |
Copying base classes (PODs) using memcpy
|
| 48 |
9.4.2 |
Definitions of unused static members
|
| 49 |
14.1 |
Restriction on non-type, non-value template arguments
|
| 51 |
13.3.3 |
Overloading and user-defined conversions
|
| 52 |
5.2.5 |
Non-static members, member selection and access checking
|
| 53 |
5.2.9 |
Lvalue-to-rvalue conversion before certain static_casts
|
| 56 |
7.1.3 |
Redeclaring typedefs within classes
|
| 59 |
13.3.1.4 |
Clarification of overloading and UDC to reference type
|
| 64 |
14.7.3 |
Partial ordering to disambiguate explicit specialization
|
| 65 |
8.3.6 |
Typo in default argument example
|
| 67 |
9.4 |
Evaluation of left side of object-expression
|
| 68 |
7.1.6.3 |
Grammar does not allow "friend class A<int>;"
|
| 69 |
7.1.1 |
Storage class specifiers on template declarations
|
| 73 |
5.10 |
Pointer equality
|
| 74 |
5.3.4 |
Enumeration value in direct-new-declarator
|
| 75 |
9.2 |
In-class initialized members must be const
|
| 76 |
7.1.6.1 |
Are const volatile variables considered "constant expressions"?
|
| 80 |
9.2 |
Class members with same name as class
|
| 83 |
13.3.4.1 |
Overloading and deprecated conversion of string literal
|
| 84 |
13.3.3.1 |
Overloading and conversion loophole used by auto_ptr
|
| 85 |
3.4.4 |
Redeclaration of member class
|
| 89 |
3.8 |
Object lifetime does not account for reference rebinding
|
| 90 |
3.4.2 |
Should the enclosing class be an "associated class" too?
|
| 93 |
3.8 |
Missing word in 3.8 basic.life paragraph 2
|
| 94 |
5.19 |
Inconsistencies in the descriptions of constant expressions
|
| 98 |
15 |
Branching into try block
|
| 100 |
14.3.2 |
Clarify why string literals are not allowed as template arguments
|
| 101 |
7.3.3 |
Redeclaration of extern "C" names via using-declarations
|
| 103 |
7.3.4 |
Is it extended-namespace-definition or extension-namespace-definition ?
|
| 105 |
14 |
Meaning of "template function"
|
| 108 |
14.6.2.1 |
Are classes nested in templates dependent?
|
| 116 |
14.5.6.1 |
Equivalent and functionally-equivalent function templates
|
| 120 |
14.6 |
Nonexistent non-terminal qualified-name
|
| 121 |
14.6 |
Dependent type names with non-dependent nested-name-specifiers
|
| 123 |
5.1 |
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.4.1 |
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
|