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 |
| 257 |
12.6.2 |
Abstract base constructors and virtual base initialization
|
| 527 |
3.5 |
Problems with linkage of types
|
| 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
|
| 601 |
16.1 |
Type of literals in preprocessing expressions
|
| 604 |
13.3.1.3 |
Argument list for overload resolution in copy-initialization
|
| 608 |
10.3 |
Determining the final overrider of a virtual function
|
| 618 |
16.1 |
Casts in preprocessor conditional expressions
|
| 626 |
16.3.2 |
Preprocessor string literals
|
| 630 |
2.3 |
Equality of narrow and wide character values in the basic character set
|
| 657 |
14.9.2 |
Abstract class parameter in synthesized declaration
|
| 672 |
5.3.4 |
Sequencing of initialization in new-expressions
|
| 695 |
5 |
Compile-time calculation errors in constexpr functions
|
| 699 |
7.1.5 |
Must constexpr member functions be defined in the class member-specification?
|
| 703 |
8.5.4 |
Narrowing for literals that cannot be exactly represented
|
| 713 |
8.3.5 |
Unclear note about cv-qualified function types
|
| 715 |
5.19 |
Class member access constant expressions
|
| 717 |
7.1.1 |
Unintentional restrictions on the use of thread_local
|
| 719 |
3 |
Specifications for operator-function-id that should also apply to literal-operator-id
|
| 721 |
5.19 |
Where must a variable be initialized to be used in a constant expression?
|
| 726 |
1.10 |
Atomic and non-atomic objects in the memory model
|
| 730 |
14.8.3 |
Explicit specializations of members of non-template classes
|
| 776 |
3.6.3 |
Delegating constructors, destructors, and std::exit
|
| 799 |
5.2.10 |
Can reinterpret_cast be used to cast an operand to its own type?
|
| 803 |
5.3.3 |
sizeof an enumeration type with a fixed underlying type
|
| 804 |
5.3.4 |
Deducing the type in new auto(x)
|
| 812 |
7.3.1 |
Duplicate names in inline namespaces
|
| 832 |
2.10 |
Value of preprocessing numbers
|
| 833 |
5.2.9 |
Explicit conversion of a scoped enumeration value to a floating type
|
| 835 |
5 |
Scoped enumerations and the “usual arithmetic conversions”
|
| 840 |
14.2 |
Rvalue references as nontype template parameters
|
| 842 |
5.2.10 |
Casting to rvalue reference type
|
| 850 |
5.1.1 |
Restrictions on use of non-static data members
|
| 854 |
5.8 |
Left shift and unsigned extended types
|
| 855 |
5.17 |
Incorrect comments in braced-init-list assignment example
|
| 861 |
3.4.3.2 |
Unintended ambiguity in inline namespace lookup
|
| 862 |
7.2 |
Undefined behavior with enumerator value overflow
|
| 865 |
8.5.4 |
Initializing a std::initializer_list
|
| 874 |
9.2 |
Class-scope definitions of enumeration types
|
| 876 |
14.9.2.1 |
Type references in rvalue reference deduction specification
|
| 877 |
13.3.2 |
Viable functions and binding references to rvalues
|
| 879 |
13.6 |
Missing built-in comparison operators for pointer types
|
| 882 |
3.6.1 |
Defining main as deleted
|
| 883 |
3.9 |
std::memcpy vs std::memmove
|
| 884 |
14.8.3 |
Defining an explicitly-specialized static data member
|
| 888 |
12.6.2 |
Union member initializers
|
| 908 |
8.4 |
Deleted global allocation and deallocation functions
|
| 919 |
7.3.1 |
Contradictions regarding inline namespaces
|
| 920 |
8.3 |
Interaction of inline namespaces and using-declarations
|
| 921 |
7.3.1 |
Unclear specification of inline namespaces
|
| 928 |
8.4 |
Defaulting a function that would be implicitly defined as deleted
|
| 930 |
5.3.6 |
alignof with incomplete array type
|
| 933 |
2.14.3 |
32-bit UCNs with 16-bit wchar_t
|
| 934 |
8.5.4 |
List-initialization of references
|
| 936 |
8.5.2 |
Array initialization with new string literals
|
| Issue |
Section |
Title |
| 2 |
14.7.4 |
How can dependent names be used in member declarations that appear outside of the class template definition?
|
| 96 |
14.3 |
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.13 |
Definition of operator and punctuator
|
| 205 |
14 |
Templates and static data members
|
| 212 |
14.8.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.7.4.1 |
Order dependencies in template instantiation
|
| 314 |
14.3 |
template in base class specifier
|
| 341 |
7.5 |
extern "C" namespace member function versus global variable
|
| 350 |
3.9 |
signed char underlying representation for objects
|
| 369 |
2.5 |
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.6.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.3 |
Defect in wording in 14.2
|
| 448 |
14.7.1 |
Set of template functions in call with dependent explicit argument
|
| 453 |
8.3.2 |
References may only bind to “valid” objects
|
| 458 |
14.7.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)
|
| 481 |
3.3 |
Scope of template parameters
|
| 490 |
3.4.1 |
Name lookup in friend declarations
|
| 493 |
14.9.2.3 |
Type deduction from a bool context
|
| 502 |
14.7.2.1 |
Dependency of nested enumerations and enumerators
|
| 508 |
8.5 |
Non-constructed value-initialized objects
|
| 529 |
14.8.3 |
Use of template<> with “explicitly-specialized” class templates
|
| 531 |
14.8.3 |
Defining members of explicit specializations
|
| 532 |
14.6.6.2 |
Member/nonmember operator template partial ordering
|
| 536 |
5.1.1 |
Problems in the description of id-expressions
|
| 541 |
14.7.2.2 |
Dependent function types
|
| 546 |
14.8.2 |
Explicit instantiation of class template members
|
| 549 |
14.6.5.1 |
Non-deducible parameters in partial specializations
|
| 560 |
14.7 |
Use of the typename keyword in return types
|
| 561 |
14.7.4.2 |
Internal linkage functions in dependent name lookup
|
| 570 |
3.2 |
Are references subject to the ODR?
|
| 573 |
5.2.10 |
Conversions between function pointers and void*
|
| 575 |
14.9.2 |
Criteria for deduction failure
|
| 580 |
11 |
Access in template-parameters of member and friend definitions
|
| 586 |
14.9.2.5 |
Default template-arguments and template argument deduction
|
| 605 |
14.8.3 |
Linkage of explicit specializations
|
| 612 |
1.9 |
Requirements on a conforming implementation
|
| 615 |
8.5 |
Incorrect description of variables that can be initialized
|
| 617 |
4.1 |
Lvalue-to-rvalue conversions of uninitialized char objects
|
| 619 |
3.9 |
Completeness of array types
|
| 621 |
14.8.3 |
Template argument deduction from function return types
|
| 625 |
7.1.6.4 |
Use of auto as a template-argument
|
| 633 |
3 |
Specifications for variables that should also apply to references
|
| 636 |
3.10 |
Dynamic type of objects and aliasing
|
| 638 |
14.6.4 |
Explicit specialization and friendship
|
| 642 |
3.3.3 |
Definition and use of “block scope” and “local scope”
|
| 655 |
12.6.2 |
Initialization not specified for forwarding constructors
|
| 656 |
8.5.3 |
Direct binding to the result of a conversion operator
|
| 664 |
8.5.3 |
Direct binding of references to non-class rvalue references
|
| 667 |
12.8 |
Trivial special member functions that cannot be implicitly defined
|
| 674 |
14.6.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
|
| 682 |
3.4.5 |
Missing description of lookup of template aliases
|
| 690 |
1.3 |
The dynamic type of an rvalue reference
|
| 691 |
14.2 |
Template parameter packs in class template partial specializations
|
| 696 |
9.8 |
Use of block-scope constants in local classes
|
| 700 |
7.1.5 |
Constexpr member functions of class templates
|
| 701 |
8.3.4 |
When is the array-to-pointer conversion applied?
|
| 704 |
13.3.1.1 |
To which postfix-expressions does overload resolution apply?
|
| 705 |
3.4.2 |
Suppressing argument-dependent lookup via parentheses
|
| 709 |
14.9.2 |
Enumeration names as nested-name-specifiers in deduction failure
|
| 710 |
12.7 |
Data races during construction
|
| 712 |
3.2 |
Are integer constant operands of a conditional-expression “used?”
|
| 722 |
5.2.2 |
Can nullptr be passed to an ellipsis?
|
| 731 |
5.2.5 |
Omitted reference qualification of member function type
|
| 734 |
5.2.10 |
Are unique addresses required for namespace-scope variables?
|
| 735 |
3.7.4.3 |
Missing case in specification of safely-derived pointers
|
| 737 |
8.5.2 |
Uninitialized trailing characters in string initialization
|
| 738 |
12.1 |
constexpr not permitted by the syntax of constructor declarations
|
| 740 |
1.10 |
Incorrect note on data races
|
| 741 |
9.6 |
“plain” long long bit-fields
|
| 743 |
5.1.1 |
Use of decltype in a nested-name-specifier
|
| 744 |
14.4.3 |
Matching template arguments with template template parameters with parameter packs
|
| 760 |
5.1.1 |
this inside a nested class of a non-static member function
|
| 765 |
7.1.2 |
Local types in inline functions with external linkage
|
| 773 |
14.4.2 |
Parentheses in address non-type template arguments
|
| 777 |
8.3.6 |
Default arguments and parameter packs
|
| 778 |
14.2 |
Template parameter packs in non-type template parameters
|
| 785 |
1.9 |
“Execution sequence” is inappropriate phraseology
|
| 786 |
1.10 |
Definition of “thread”
|
| 787 |
2.2 |
Unnecessary lexical undefined behavior
|
| 789 |
2.4 |
Deprecating trigraphs
|
| 790 |
2.14.5 |
Concatenation of raw and non-raw string literals
|
| 801 |
5.2.11 |
Casting away constness in a cast to rvalue reference type
|
| 806 |
5.19 |
Enumeration types in integral constant expressions
|
| 809 |
7.1.1 |
Deprecation of the register keyword
|
| 810 |
7.1.1 |
Block-scope thread_local variables should be implicitly static
|
| 814 |
7.6 |
Attribute to indicate that a function throws nothing
|
| 817 |
7.6.4 |
Meaning of [[final]] applied to a class definition
|
| 818 |
8.3.5 |
Function parameter packs in non-final positions
|
| 821 |
14 |
Exported concept map templates?
|
| 823 |
14.4.2 |
Literal types with constexpr conversions as non-type template arguments
|
| 828 |
15.1 |
Destruction of exception objects
|
| 831 |
B |
Limit on recursively nested template instantiations
|
| 834 |
2.14.5 |
What is an “ordinary string literal”?
|
| 837 |
7.1.5 |
Constexpr functions and return braced-init-list
|
| 860 |
7.1.5 |
Explicit qualification of constexpr member functions
|
| 869 |
8.5 |
Uninitialized thread_local objects
|
| 873 |
14.9.2.5 |
Deducing rvalue references in declarative contexts
|
| 886 |
8.5.1 |
Member initializers and aggregates
|
| 892 |
7.1.5 |
Missing requirements for constexpr constructors
|
| 896 |
8.5.3 |
Rvalue references and rvalue-reference conversion functions
|
| 901 |
5.3.4 |
Deleted operator delete
|
| 913 |
14.9.2.3 |
Deduction rules for array- and function-type conversion functions
|
| 915 |
8.4 |
Deleted specializations of member function templates
|
| 923 |
14.8.3 |
Inline explicit specializations
|
| 924 |
9.2 |
alias-declaration as a class member
|
| 926 |
7.3.1.1 |
Inline unnamed namespaces
|
| 929 |
14.6.7 |
What is a template alias?
|
| 932 |
2.14.5 |
UCNs in closing delimiters of raw string literals
|
| 935 |
13.5.8 |
Missing overloads for character types for user-defined literals
|
| 940 |
7.1.1 |
Global anonymous unions
|
| 941 |
14.8.3 |
Explicit specialization of deleted function template
|
| 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.6.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.4.3 |
Template template parameters and default arguments
|
| 157 |
7 |
Omitted typedef declarator
|
| 186 |
14.7.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 |
_N2691_.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
|
| 264 |
14.9.1 |
Unusable template constructors and conversion functions
|
| 267 |
5.3.4 |
Alignment requirement for new-expressions
|
| 268 |
16.3.4 |
Macro name suppression in rescanned replacement text
|
| 271 |
14.9.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.8.2 |
Syntax of explicit instantiation/specialization too permissive
|
| 297 |
14.9.2 |
Which template does an explicit specialization specialize?
|
| 310 |
14.6.6.1 |
Can function templates differing only in parameter cv-qualifiers be overloaded?
|
| 312 |
3.7.4.2 |
“use” of invalid pointer value not defined
|
| 321 |
3.4.2 |
Associated classes and namespaces for argument-dependent lookup
|
| 325 |
8.3.6 |
When are default arguments parsed?
|
| 330 |
4.4 |
Qualification conversions and pointers to arrays of pointers
|
| 332 |
8.3.5 |
cv-qualified void parameter types
|
| 338 |
3.5 |
Enumerator name with linkage used as class name in other translation unit
|
| 343 |
14.3 |
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.6.6.2 |
More on partial ordering of function templates
|
| 405 |
3.4.1 |
Unqualified function name lookup
|
| 411 |
2.14.5 |
Use of universal-character-name in character versus string literals
|
| 418 |
13.3.3 |
Imperfect wording on error on multiple default arguments on a called function
|
| 419 |
3.8 |
Can cast to virtual base class be done on partially-constructed object?
|
| 440 |
14.4 |
Allow implicit pointer-to-member conversion on nontype template argument
|
| 455 |
13.3.3 |
Partial ordering and non-deduced arguments
|
| 459 |
14.7.1 |
Hiding of template parameters by base class members
|
| 473 |
5.3.4 |
Block-scope declarations of allocator functions
|
| 476 |
5.3.4 |
Determining the buffer size for placement new
|
| 483 |
3.9.1 |
Normative requirements on integral ranges
|
| 496 |
3.9 |
Is a volatile-qualified type really a POD?
|
| 498 |
7.1.1 |
Storage class specifiers in definitions of class members
|
| 503 |
14.9.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
|
| 511 |
9 |
POD-structs with template assignment operators
|
| 523 |
3.7.4.2 |
Can a one-past-the-end pointer be invalidated by deleting an adjacent object?
|
| 528 |
5.2.8 |
Why are incomplete class types not allowed with typeid?
|
| 545 |
13.3.1.2 |
User-defined conversions and built-in operator overload resolution
|
| 550 |
8.3.5 |
Pointer to array of unknown bound in parameter declarations
|
| 562 |
3.4.3.1 |
qualified-ids in non-expression contexts
|
| 563 |
7.5 |
Linkage specification for objects
|
| 565 |
7.3.3 |
Conflict rules for using-declarations naming function templates
|
| 577 |
8.3.5 |
void in an empty parameter list
|
| 578 |
2.2 |
Phase 1 replacement of characters with universal-character-names
|
| 579 |
14.3 |
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.7.2.1 |
Nested classes and the “current instantiation”
|
| 591 |
14.7.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.7.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
|
| 640 |
3.6.3 |
Accessing destroyed local objects of static storage duration
|
| 670 |
8.5 |
Copy initialization via derived-to-base conversion in the second step
|
| 675 |
9.6 |
Signedness of bit-field with typedef or template parameter type
|
| 689 |
3.9.1 |
Maximum values of signed and unsigned integers
|
| 693 |
4.2 |
New string types and deprecated conversion
|
| 697 |
14.9.2 |
Deduction rules apply to more than functions
|
| 698 |
1.9 |
The definition of “sequenced before” is too narrow
|
| 708 |
14.6.5 |
Partial specialization of member templates of class templates
|
| 718 |
11.4 |
Non-class, non-function friend declarations
|
| 729 |
15.3 |
Qualification conversions and handlers of reference-to-pointer type
|
| 739 |
9.6 |
Signedness of plain bit-fields
|
| 742 |
5.2.6 |
Postfix increment/decrement with long bit-field operands
|
| 745 |
16.5 |
Effect of ill-formedness resulting from #error
|
| 747 |
11.2 |
Access of protected base classes
|
| 758 |
3.1 |
Missing cases of declarations that are not definitions
|
| 783 |
1.3 |
Definition of “argument”
|
| 784 |
1.5 |
List of incompatibilities with the previous Standard
|
| 788 |
2.3 |
Relationship between locale and values of the execution character set
|
| 793 |
3.8 |
Use of class members during destruction
|
| 794 |
4.11 |
Base-derived conversion in member type of pointer-to-member conversion
|
| 797 |
5.1.2 |
Converting a no-capture lambda to a function type
|
| 798 |
5.2.1 |
Overloaded subscript operator described in clause 5
|
| 808 |
7.1 |
Non-type decl-specifiers versus max-munch
|
| 811 |
7.1.6.1 |
Unclear implications of const-qualification
|
| 813 |
7.3.3 |
typename in a using-declaration with a non-dependent name
|
| 820 |
14 |
Deprecation of export
|
| 829 |
15.4 |
At what point is std::unexpected called?
|
| 830 |
15.4 |
Deprecating exception specifications
|
| 838 |
12.6.2 |
Use of this in a brace-or-equal-initializer
|
| 845 |
8.4 |
What is the “first declaration” of an explicit specialization?
|
| 846 |
3.10 |
Rvalue references to functions
|
| 852 |
7.3.3 |
using-declarations and dependent base classes
|
| 863 |
5.2 |
Rvalue reference cast to incomplete type
|
| 864 |
6.5.4 |
braced-init-list in the range-based for statement
|
| 872 |
2.14.5 |
Lexical issues with raw strings
|
| 880 |
13.6 |
Built-in conditional operator for scoped enumerations
|
| 885 |
14.9.2.4 |
Partial ordering of function templates with unordered parameter pairs
|
| 887 |
12.8 |
Move construction of thrown object
|
| 891 |
5.2.11 |
const_cast to rvalue reference from objectless rvalue
|
| 893 |
7.2 |
Brace syntax for enumerator-definitions
|
| 897 |
16.9 |
_Pragma and extended string-literals
|
| 899 |
13.3.1.4 |
Explicit conversion functions in direct class initialization
|
| 900 |
12.2 |
Lifetime of temporaries in range-based for
|
| 903 |
14.7.2.3 |
Value-dependent integral null pointer constants
|
| 904 |
5.1.2 |
Parameter packs in lambda-captures
|
| 910 |
12.8 |
Move constructors and implicitly-declared copy constructors
|
| 912 |
2.14.3 |
Character literals and universal-character-names
|
| 916 |
14.10.2.1 |
Does a reference type have a destructor?
|
| 922 |
12.1 |
Implicit default contructor definitions and const variant members
|
| 925 |
16.1 |
Type of character literals in preprocessor expressions
|
| 927 |
12.1 |
Implicitly-deleted default constructors and member initializers
|
| 931 |
2.14.8 |
Confusing reference to the length of a user-defined string literal
|
| 938 |
8.5.1 |
Initializer lists and array new
|
| 942 |
3 |
Is this an entity?
|
| 943 |
5.2.3 |
Is T() a temporary?
|
| 944 |
5.2.10 |
reinterpret_cast for all types with the same size and alignment
|
| 945 |
5.1.1 |
Use of this in a late-specified return type
|
| 946 |
3.6.3 |
Order of destruction of local static objects and calls to std::atexit
|
| 947 |
14.9.3 |
Deducing type template arguments from default function arguments
|
| 948 |
6.4 |
constexpr in conditions
|
| Issue |
Section |
Title |
| 3 |
14.8.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.8.1 |
Argument dependent lookup and points of instantiation
|
| 37 |
15.5.3 |
When is uncaught_exception() true?
|
| 42 |
3.3.7 |
Redefining names from base classes
|
| 46 |
14.8.2 |
Explicit instantiation of member templates
|
| 47 |
14.6.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.8.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.9.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.6.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.8.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.6.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.8.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.7.1 |
Injected-class-name of template used as template template parameter
|
| 333 |
8.2 |
Ambiguous use of "declaration" in disambiguation section
|
| 334 |
14.7.2.2 |
Is a comma-expression dependent if its first operand is?
|
| 340 |
8.2 |
Unclear wording in disambiguation section |
| 346 |
15.4 |
Typo in 15.4
|
| 347 |
9.7 |
Use of derived class name in defining base class nested class
|
| 356 |
12.8 |
Wording of behavior of generated copy constructor for scalar members
|
| 358 |
7.5 |
Namespaces and extern "C"
|
| 359 |
9.5 |
Type definition in anonymous union
|
| 363 |
12.6.1 |
Initialization of class from self
|
| 376 |
7.1.2 |
Class "definition" versus class "declaration"
|
| 384 |
3.4.2 |
Argument-dependent lookup and operator functions
|
| 412 |
7.1.2 |
Can a replacement allocation function be inline?
|
| 422 |
7.1.3 |
Is a typedef redeclaration allowed with a template type that might be the same?
|
| 423 |
13.3.1.2 |
Can a conversion be done on the left operand of a compound assignment?
|
| 434 |
8.5.3 |
Unclear suppression of standard conversions while binding reference to lvalue
|
| 435 |
7 |
Change "declararation or definition" to "declaration"
|
| 444 |
12.8 |
Overriding and the generated copy assignment operator
|
| 445 |
11.4 |
Wording issue on friend declarations
|
| 449 |
1.3 |
Consistency in use of hyphen with names of "non" entities
|
| 456 |
4.10 |
Is initialized const int or const bool variable a null pointer constant?
|
| 461 |
7.4 |
Make asm conditionally-supported
|
| 465 |
3.6.2 |
May constructors of global objects call exit()?
|
| 467 |
6.7 |
Jump past initialization of local static variable
|
| 469 |
14.9.2.5 |
Const template specializations and reference arguments
|
| 471 |
11.2 |
Conflicting inherited access specifications
|
| 478 |
8.3.4 |
May a function parameter be an array of an abstract class type?
|
| 487 |
5.19 |
Operator overloading in constant expressions
|
| 489 |
14.8.1 |
Must member function templates be instantiated during overload resolution?
|
| 501 |
11.4 |
Visibility of friend declarations within the befriending class
|
| 533 |
16.2 |
Special treatment for C-style header names
|
| 544 |
14.7.2 |
Base class lookup in explicit specialization
|
| 552 |
14.3 |
Use of typename in the type in a non-type parameter-declaration
|
| 553 |
7.3.1.2 |
Problems with friend allocation and deallocation functions
|
| 566 |
4.9 |
Conversion of negative floating point values to integer type
|
| 567 |
5.7 |
Can size_t and ptrdiff_t be larger than long?
|
| 574 |
12.8 |
Definition of “copy assignment operator”
|
| 584 |
3.10 |
Unions and aliasing
|
| 585 |
11.4 |
Friend template template parameters
|
| 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.9.2 |
Forming a pointer to a reference type
|
| 669 |
7.1.6.2 |
Confusing specification of the meaning of decltype
|
| 673 |
7.3.1.2 |
Injection of names from elaborated-type-specifiers in friend declarations
|
| 706 |
7.1.6.4 |
Use of auto with rvalue references
|
| 733 |
12.8 |
Reference qualification of copy assignment operators
|
| 736 |
8 |
Is the & ref-qualifier needed?
|
| 795 |
5.1.2 |
Dependency of lambdas on <functional>
|
| 807 |
5.19 |
typeid expressions in constant expressions
|
| 819 |
12 |
Access control and deleted implicitly-declared special member functions
|
| 836 |
7.6.3 |
[[noreturn]] applied to function types
|
| 902 |
9.4.2 |
In-class initialization of non-constant static data members
|
| 909 |
5.4 |
Old-style casts with conversion functions
|
| 937 |
2.14.8 |
Restrictions on values of template arguments in user-defined literals
|
| Issue |
Section |
Title |
| 4 |
7.5 |
Does extern "C" affect the linkage of function names with internal linkage?
|
| 5 |
8.5 |
CV-qualifiers and type conversions
|
| 8 |
11 |
Access to template arguments used in a function return type and in the nested name specifier
|
| 9 |
11.2 |
Clarification of access to base class members
|
| 10 |
11.8 |
Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?
|
| 11 |
7.3.3 |
How do the keywords typename/template interact with using-declarations?
|
| 16 |
11.2 |
Access to members of indirect private base classes
|
| 28 |
3.6.3 |
'exit', 'signal' and static object destruction
|
| 29 |
7.5 |
Linkage of locally declared functions
|
| 39 |
10.2 |
Conflicting ambiguity rules
|
| 44 |
14.8.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.4.1 |
Unnamed members of classes used as type parameters
|
| 63 |
14.8.1 |
Class instantiation from pointer conversion to void*, null and self
|
| 70 |
14.9.2.5 |
Is an array bound a nondeduced context?
|
| 77 |
11.4 |
The definition of friend does not allow nested classes to be friends
|
| 78 |
8.5 |
Section 8.5 paragraph 9 should state it only applies to non-static objects
|
| 86 |
12.2 |
Lifetime of temporaries in query expressions
|
| 87 |
15.4 |
Exception specifications on function parameters
|
| 106 |
unknown |
Creating references to references during template deduction/instantiation
|
| 112 |
8.3.4 |
Array types and cv-qualifiers
|
| 113 |
5.2.2 |
Visibility of called function
|
| 115 |
13.4 |
Address of template-id
|
| 118 |
5.2.2 |
Calls via pointers to virtual member functions
|
| 119 |
3.8 |
Object lifetime and aggregate initialization
|
| 122 |
5.1.1 |
template-ids as unqualified-ids
|
| 124 |
12.2 |
Lifetime of temporaries in default initialization of class arrays
|
| 125 |
5.1.1 |
Ambiguity in friend declaration syntax
|
| 136 |
8.3.6 |
Default arguments and friend declarations
|
| 139 |
3.4.1 |
Error in friend lookup example
|
| 140 |
8.3.5 |
Agreement of parameter declarations
|
| 141 |
3.4.5 |
Non-member function templates in member access expressions
|
| 143 |
3.4.2 |
Friends and Koenig lookup
|
| 158 |
3.10 |
Aliasing and qualification conversions
|
| 160 |
8.2 |
Missing std:: qualification
|
| 162 |
13.3.1.1 |
(&C::f)() with nonstatic members
|
| 172 |
7.2 |
Unsigned int as underlying type of enum
|
| 175 |
9 |
Class name injection and base name access
|
| 177 |
8.5 |
Lvalues vs rvalues in copy-initialization
|
| 180 |
14.7 |
typename and elaborated types
|
| 184 |
14.2 |
Default arguments in template template-parameters
|
| 195 |
5.2.10 |
Converting between function and object pointers
|
| 197 |
14.7.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.6.6.2 |
Partial ordering of function templates is underspecified
|
| 215 |
14.2 |
Template parameters are not allowed in nested-name-specifiers
|
| 216 |
3.5 |
Linkage of nameless class-scope enumeration types
|
| 218 |
3.4.2 |
Specification of Koenig lookup
|
| 220 |
3.7.4.2 |
All deallocation functions should be required not to throw
|
| 221 |
13.5.3 |
Must compound assignment operators be member functions?
|
| 222 |
5 |
Sequence points and lvalue-returning operators
|
| 224 |
14.7.2.1 |
Definition of dependent names
|
| 226 |
14.2 |
Default template arguments for function templates
|
| 228 |
14.3 |
Use of template keyword with non-member templates
|
| 237 |
14.8.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.4 |
Jumps in function-try-block handlers
|
| 252 |
12.4 |
Looking up deallocation functions in virtual destructors
|
| 254 |
3.4.4 |
Definitional problems with elaborated-type-specifiers
|
| 256 |
5.3.4 |
Overflow in size calculations
|
| 258 |
7.3.3 |
using-declarations and cv-qualifiers
|
| 259 |
14.8 |
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.8.3 |
Explicit instantiation/specialization and using-directives
|
| 276 |
6.6 |
Order of destruction of parameters and temporaries
|
| 277 |
8.5 |
Zero-initialization of pointers
|
| 280 |
13.3.1.1.2 |
Access and surrogate call functions
|
| 281 |
7.1.2 |
inline specifier in friend declarations
|
| 283 |
7.1.6.2 |
Template type-parameters are not syntactically type-names
|
| 284 |
9 |
qualified-ids in class declarations
|
| 286 |
14.6.5 |
Incorrect example in partial specialization
|
| 288 |
5.3.5 |
Misuse of "static type" in describing pointers
|
| 289 |
3.2 |
Incomplete list of contexts requiring a complete type
|
| 291 |
8.5.3 |
Overload resolution needed when binding reference to class rvalue
|
| 295 |
8.3.5 |
cv-qualifiers on function types
|
| 296 |
12.3.2 |
Can conversion functions be static?
|
| 298 |
3.4.3.1 |
T::x when T is cv-qualified
|
| 299 |
5.3.4 |
Conversion on array bound expression in new
|
| 300 |
14.9.2.5 |
References to functions in template argument deduction
|
| 301 |
14.3 |
Syntax for template-name
|
| 302 |
8.5 |
Value-initialization and generation of default constructor
|
| 305 |
3.4.5 |
Name lookup in destructor call
|
| 306 |
10.2 |
Ambiguity by class name injection
|
| 309 |
3 |
Linkage of entities whose names are not simply identifiers, in introduction
|
| 317 |
7.1.2 |
Can a function be declared inline after it has been called?
|
| 318 |
3.4.3.1 |
struct A::A should not name the constructor of A
|
| 319 |
3.5 |
Use of names without linkage in declaring entities with linkage
|
| 320 |
12.2 |
Question on copy constructor elision example
|
| 322 |
14.9.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.6.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.8.3 |
Explicit specialization examples are still incorrect
|
| 337 |
14.9.2 |
Attempt to create array of abtract type should cause deduction to fail
|
| 339 |
5.19 |
Overload resolution in operand of sizeof in constant expression
|
| 345 |
14.7 |
Misleading comment on example in templates chapter
|
| 348 |
3.7.4.2 |
delete and user-written deallocation functions
|
| 349 |
14.9.2.3 |
Template argument deduction for conversion functions and qualification conversions
|
| 351 |
5 |
Sequence point error: unspecified or undefined?
|
| 352 |
14.9.2.1 |
Nondeduced contexts
|
| 353 |
5.3.5 |
Is deallocation routine called if destructor throws exception in delete?
|
| 354 |
14.4.2 |
Null as nontype template argument
|
| 357 |
1.3 |
Definition of signature should include name
|
| 362 |
2.2 |
Order of initialization in instantiation units
|
| 364 |
13.3.1.1.1 |
Calling overloaded function with static in set, with no object
|
| 366 |
5.19 |
String literal allowed in integral constant expression?
|
| 367 |
5.19 |
throw operator allowed in constant expression?
|
| 368 |
14.9.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.4 |
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.7 |
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.7.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.9.2 |
Ambiguous wording on naming a type in deduction
|
| 400 |
3.4.3.2 |
Using-declarations and the "struct hack"
|
| 401 |
14.2 |
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.7 |
Obsolete paragraph missed by changes for issue 224
|
| 410 |
14.6.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.9.3 |
Template deduction does not cause instantiation
|
| 416 |
13.3.1.2 |
Class must be complete to allow operator lookup?
|
| 417 |
9.1 |
Using derived-class qualified name in out-of-class nested class definition
|
| 420 |
13.5.6 |
postfixexpression->scalar_type_dtor() inconsistent
|
| 421 |
5.2.5 |
Is rvalue.field an rvalue?
|
| 424 |
7.1.3 |
Wording problem with issue 56 resolution on redeclaring typedefs in class scope
|
| 425 |
13.6 |
Set of candidates for overloaded built-in operator with float operand
|
| 427 |
5.2.9 |
static_cast ambiguity: conversion versus cast to derived
|
| 428 |
15.1 |
Mention of expression with reference type
|
| 429 |
5.3.4 |
Matching deallocation function chosen based on syntax or signature?
|
| 430 |
8.5.1 |
Ordering of expression evaluation in initializer list
|
| 432 |
3.3.7 |
Is injected class name visible in base class specifier list?
|
| 433 |
3.3.2 |
Do elaborated type specifiers in templates inject into enclosing namespace scope?
|
| 436 |
9.6 |
Problem in example in 9.6 paragraph 4
|
| 437 |
9.2 |
Is type of class allowed in member function exception specification?
|
| 439 |
5.2.9 |
Guarantees on casting pointer back to cv-qualified version of original type
|
| 441 |
3.6.2 |
Ordering of static reference initialization
|
| 442 |
5.3.5 |
Incorrect use of null pointer constant in description of delete operator
|
| 443 |
12.2 |
Wording nit in description of lifetime of temporaries
|
| 446 |
5.16 |
Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?
|
| 447 |
14.7.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.3 |
Allow ::template outside of templates
|
| 470 |
14.8.2 |
Instantiation of members of an explicitly-instantiated class template
|
| 474 |
3.5 |
Block-scope extern declarations in namespace members
|
| 477 |
7.1.2 |
Can virtual appear in a friend declaration?
|
| 479 |
15.1 |
Copy elision in exception handling
|
| 480 |
4.11 |
Is a base of a virtual base also virtual?
|
| 484 |
10 |
Can a base-specifier name a cv-qualified class type?
|
| 485 |
3 |
What is a “name”?
|
| 486 |
14.9.2 |
Invalid return types and template argument deduction
|
| 488 |
14.9.2 |
Local types, overload resolution, and template argument deduction
|
| 491 |
8.5.1 |
Initializers for empty-class aggregrate members
|
| 492 |
5.2.8 |
typeid constness inconsistent with example
|
| 494 |
11 |
Problems with the resolution of issue 45
|
| 497 |
5.5 |
Missing required initialization in example
|
| 500 |
11.4 |
Access in base-specifiers of friend and nested classes
|
| 505 |
2.14.3 |
Conditionally-supported behavior for unknown character escapes
|
| 506 |
5.2.2 |
Conditionally-supported behavior for non-POD objects passed to ellipsis
|
| 509 |
8.5 |
Dead code in the specification of default initialization
|
| 510 |
12.6 |
Default initialization of POD classes?
|
| 513 |
1.8 |
Non-class “most-derived” objects
|
| 514 |
3.4.1 |
Is the initializer for a namespace member in the scope of the namespace?
|
| 515 |
14.7.2 |
Non-dependent references to base class members
|
| 516 |
7.1.6.2 |
Use of signed in bit-field declarations
|
| 517 |
14.6.5 |
Partial specialization following explicit instantiation
|
| 518 |
7.2 |
Trailing comma following enumerator-list
|
| 519 |
4.10 |
Null pointer preservation in void* conversions
|
| 520 |
5.4 |
Old-style casts between incomplete class types
|
| 521 |
3.7.4.1 |
Requirements for exceptions thrown by allocation functions
|
| 522 |
14.9.2.1 |
Array-to-pointer decay in template argument deduction
|
| 524 |
14.7.2 |
Can function-notation calls to operator functions be dependent?
|
| 525 |
14.8.1 |
Missing * in example
|
| 526 |
14.9.2.5 |
Confusing aspects in the specification of non-deduced contexts
|
| 530 |
5.19 |
Nontype template arguments in constant expressions
|
| 534 |
14 |
template-names and operator-function-ids
|
| 537 |
1.3 |
Definition of “signature”
|
| 538 |
9 |
Definition and usage
of structure, POD-struct, POD-union,
and POD class
|
| 540 |
7.3.1 |
Propagation of cv-qualifiers in reference-to-reference collapse
|
| 543 |
8.5 |
Value initialization and default constructors
|
| 551 |
14.8.2 |
When is inline permitted in an explicit instantiation?
|
| 557 |
3.4.2 |
Does argument-dependent lookup cause template instantiation?
|
| 558 |
2.3 |
Excluded characters in universal character names
|
| 559 |
14.7 |
Editing error in issue 382 resolution
|
| 568 |
9 |
Definition of POD is too strict
|
| 582 |
14.6.2 |
Template conversion functions
|
| 592 |
15.2 |
Exceptions during construction of local static objects
|
| 594 |
3.8 |
Coordinating issues 119 and 404 with delegating constructors
|
| 603 |
14.5 |
Type equivalence and unsigned overflow
|
| 606 |
14.9.2.1 |
Template argument deduction for rvalue references
|
| 613 |
9.2 |
Unevaluated uses of non-static class members
|
| 614 |
5.6 |
Results of integer / and %
|
| 620 |
9.2 |
Declaration order in layout-compatible POD structs
|
| 624 |
5.3.4 |
Overflow in calculating size of allocation
|
| 629 |
7.1.6.4 |
auto parsing ambiguity
|
| 632 |
8.5.1 |
Brace-enclosed initializer for scalar member of aggregate
|
| 634 |
5.2.2 |
Conditionally-supported behavior for non-POD objects passed to ellipsis redux
|
| 637 |
1.9 |
Sequencing rules and example disagree
|
| 639 |
1.9 |
What makes side effects “different” from one another?
|
| 644 |
3.9 |
Should a trivial class type be a literal type?
|
| 647 |
7.1.5 |
Non-constexpr instances of constexpr constructor templates
|
| 648 |
7.1.5 |
Constant expressions in constexpr initializers
|
| 649 |
3.11 |
Optionally ill-formed extended alignment requests
|
| 651 |
7.1.6.2 |
Problems in decltype specification and examples
|
| 654 |
4.10 |
Conversions to and from nullptr_t
|
| 659 |
5.3.6 |
Alignment of function types
|
| 660 |
7.2 |
Unnamed scoped enumerations
|
| 661 |
5.9 |
Semantics of arithmetic comparisons
|
| 663 |
_N2691_.E |
Valid Cyrillic identifier characters
|
| 666 |
14.7 |
Dependent qualified-ids without the typename keyword
|
| 671 |
5.2.9 |
Explicit conversion from a scoped enumeration type to integral type
|
| 677 |
12.4 |
Deleted operator delete and virtual destructors
|
| 679 |
14.5 |
Equivalence of template-ids and operator function templates
|
| 681 |
8.3.5 |
Restrictions on declarators with late-specified return types
|
| 683 |
12.8 |
Requirements for trivial subobject special functions
|
| 684 |
5.19 |
Constant expressions involving the address of an automatic variable
|
| 686 |
8.1 |
Type declarations/definitions in type-specifier-seqs and type-ids
|
| 688 |
3.6.2 |
Constexpr constructors and static initialization
|
| 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.2 |
Can a default argument for a template parameter appear in a friend declaration?
|
| 22 |
14.7.4 |
Template parameter with a default argument that refers to itself
|
| 24 |
14.8.3 |
Errors in examples in 14.7.3
|
| 25 |
15.4 |
Exception specifications and pointers to members
|
| 30 |
14.3 |
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.3 |
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.2 |
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.8.3 |
Partial ordering to disambiguate explicit specialization
|
| 65 |
8.3.6 |
Typo in default argument example
|
| 67 |
9.4 |
Evaluation of left side of object-expression
|
| 68 |
7.1.6.3 |
Grammar does not allow "friend class A<int>;"
|
| 69 |
7.1.1 |
Storage class specifiers on template declarations
|
| 73 |
5.10 |
Pointer equality
|
| 74 |
5.3.4 |
Enumeration value in direct-new-declarator
|
| 75 |
9.2 |
In-class initialized members must be const
|
| 76 |
7.1.6.1 |
Are const volatile variables considered "constant expressions"?
|
| 80 |
9.2 |
Class members with same name as class
|
| 83 |
13.3.3.2 |
Overloading and deprecated conversion of string literal
|
| 84 |
13.3.3.1 |
Overloading and conversion loophole used by auto_ptr
|
| 85 |
3.4.4 |
Redeclaration of member class
|
| 89 |
3.8 |
Object lifetime does not account for reference rebinding
|
| 90 |
3.4.2 |
Should the enclosing class be an "associated class" too?
|
| 93 |
3.8 |
Missing word in 3.8 basic.life paragraph 2
|
| 94 |
5.19 |
Inconsistencies in the descriptions of constant expressions
|
| 98 |
15 |
Branching into try block
|
| 100 |
14.4.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.7.2.1 |
Are classes nested in templates dependent?
|
| 116 |
14.6.6.1 |
Equivalent and functionally-equivalent function templates
|
| 120 |
14.7 |
Nonexistent non-terminal qualified-name
|
| 121 |
14.7 |
Dependent type names with non-dependent nested-name-specifiers
|
| 123 |
5.1.1 |
Bad cross-reference
|
| 126 |
15.4 |
Exception specifications and const
|
| 127 |
5.3.4 |
Ambiguity in description of matching deallocation function
|
| 128 |
5.2.9 |
Casting between enum types
|
| 131 |
_N2691_.E |
Typo in Lao characters
|
| 134 |
14 |
Template classes and declarator-ids
|
| 135 |
8.3.5 |
Class type in in-class member function definitions
|
| 137 |
5.2.9 |
static_cast of cv void*
|
| 142 |
11.2 |
Injection-related errors in access example
|
| 145 |
D.1 |
Deprecation of prefix ++
|
| 147 |
5.1.1 |
Naming the constructor
|
| 148 |
9 |
POD classes and pointers to members
|
| 149 |
4.10 |
Accessibility and ambiguity
|
| 151 |
8.5 |
Terminology of zero-initialization
|
| 152 |
12.3.1 |
explicit copy constructors
|
| 153 |
13.3.3.2 |
Misleading wording (rank of conversion)
|
| 159 |
8.3 |
Namespace qualification in declarators
|
| 161 |
11.5 |
Access to protected nested type
|
| 163 |
8.5.1 |
Description of subaggregate initializer
|
| 164 |
3.4.2 |
Overlap between Koenig and normal lookup
|
| 166 |
7.3.1.2 |
Friend declarations of template-ids
|
| 171 |
7.3 |
Global namespace scope
|
| 173 |
2.3 |
Constraints on execution character set
|
| 176 |
9 |
Name injection and templates
|
| 178 |
8.5 |
More on value-initialization
|
| 179 |
5.7 |
Function pointers and subtraction
|
| 181 |
14.9.2.5 |
Errors in template template-parameter example
|
| 183 |
14.7 |
typename in explicit specializations
|
| 185 |
12.8 |
"Named" temporaries and copy elision
|
| 187 |
14.2 |
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.7.3 |
Semantic constraints on non-dependent names
|
| 210 |
15.3 |
What is the type matched by an exception handler?
|
| 213 |
14.7.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.9.1 |
Error in example in 14.8.1
|
| 249 |
14.6.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
|