C++ Standard Core Language Issue Index by Status, Revision 30


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.




Index by Status




Issues with "Ready" Status:

IssueSectionTitle
545.2.9 Static_cast from private base to derived class
3193.5 Use of names without linkage in declaring entities with linkage
3813.4.5 Incorrect example of base class member lookup
38511.5 How does protected member check of 11.5 interact with using-declarations?
3893.5 Unnamed types in entities with linkage
39416 identifier-list is never defined
40914.6 Obsolete paragraph missed by changes for issue 224
41014.5.3 Paragraph missed in changes for issue 166
41613.3.1.2 Class must be complete to allow operator lookup?
4179.1 Using derived-class qualified name in out-of-class nested class definition
4275.2.9 static_cast ambiguity: conversion versus cast to derived
4295.3.4 Matching deallocation function chosen based on syntax or signature?
4369.6 Problem in example in 9.6 paragraph 4


Issues with "Review" Status:

IssueSectionTitle
3910.2 Conflicting ambiguity rules
2918.5.3 Overload resolution needed when binding reference to class rvalue
30610.2 Ambiguity by class name injection
3503.9 signed char underlying representation for objects
4357 Change "declararation or definition" to "declaration"
4379.2 Is type of class allowed in member function exception specification?
4395.2.9 Guarantees on casting pointer back to cv-qualified version of original type
4413.6.2 Ordering of static reference initialization
4425.3.5 Incorrect use of null pointer constant in description of delete operator
4538.3.2 References may only bind to "valid" objects


Issues with "Drafting" Status:

IssueSectionTitle
214.6.4 How can dependent names be used in member declarations that appear outside of the class template definition?
8612.2 Lifetime of temporaries in query expressions
9614.2 Syntactic disambiguation using the template keyword
1387.3.1.2 Friend declaration name lookup
1563.4.5 Name lookup for conversion functions
1704.11 Pointer-to-member conversions
1892.12 Definition of operator and punctuator
1955.2.10 Converting between function and object pointers
19714.6.4.2 Issues with two-stage lookup of dependent names
20514 Templates and static data members
21214.7.1 Implicit instantiation is not described clearly enough
21514.1 Template parameters are not allowed in nested-name-specifiers
2183.4.2 Specification of Koenig lookup
2225 Sequence points and lvalue-returning operators
2253.4.2 Koenig lookup and fundamental types
2325.3.1 Is indirection through a null pointer undefined behavior?
2338.5.3 References vs pointers in UDC overload resolution
26013.6 User-defined conversions and built-in operator=
2766.6 Order of destruction of parameters and temporaries
28714.6.4.1 Order dependencies in template instantiation
30114.2 Syntax for template-name
3053.4.5 Name lookup in destructor call
31414.2 template in base class specifier
3417.5 extern "C" namespace member function versus global variable
3483.7.3.2 delete and user-written deallocation functions
3675.19 throw operator allowed in constant expression?
37016.2 Can #include <...> form be used other than for standard C++ headers?
37214.3 Is access granted by base class specifiers available in following base class specifiers?
3748.3 Can explicit specialization outside namespace use qualified name?
38214.6 Allow typename outside of templates
3918.5.3 Require direct binding of short-lived references to rvalues
3938.3.5 Pointer to array of unknown bound in template argument list in parameter
3977.1.2 Same address for string literals from default arguments in inline functions?
39912.4 Destructor lookup redux
40114.1 When is access for template parameter default arguments checked?
40814.5.1.3 sizeof applied to unknown-bound array static data member of template
4139 Definition of "empty class"
4143.4.5 Multiple types found on destructor lookup
41514.8.3 Template deduction does not cause instantiation
42013.5.6 postfixexpression->scalar_type_dtor() inconsistent
4263.5 Identically-named variables, one internally and one externally linked, allowed?
43114.2 Defect in wording in 14.2
4348.5.3 Unclear suppression of standard conversions while binding reference to lvalue
44312.2 Wording nit in description of lifetime of temporaries
4465.16 Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?
44814.6.1 Set of template functions in call with dependent explicit argument
4508.5.3 Binding a reference to const to a cv-qualified array rvalue
4549.4.2 When is definition of static data member required?
4575.19 Wording nit on use of const variables in constant expressions
45814.6.1 Hiding of member template parameters by other members
4607.3.3 Can a using-declaration name a namespace?


Issues with "Open" Status:

IssueSectionTitle
2314.5.5.2 Some questions regarding partial ordering of function templates
283.6.3 'exit', 'signal' and static object destruction
367.3.3 using-declarations in multiple-declaration contexts
579.5 Empty unions
589.6 Signedness of bit fields of enum type
9215.4 Should exception specifications be part of the type system?
11014 Can template functions and classes be declared in the same scope?
11112.8 Copy constructors and cv-qualifiers
1185.2.2 Calls via pointers to virtual member functions
1291.9 Stability of uninitialized auto variables
1413.4.5 Non-member function templates in member access expressions
1447.1.5.3 Position of friend specifier
1463.9.1 Floating-point zero
1558.5 Brace initializer for scalar
1577 Omitted typedef declarator
18214.7.3 Access checking on explicit specializations
18614.6.1 Name hiding and template template-parameters
1913.4.1 Name lookup does not handle complex nesting
1923.4.1 Name lookup in parameters
1965.3.5 Arguments to deallocation functions
19912.2 Order of destruction of temporaries
2035.3.1 Type of address-of-member expression
21915.5.1 Cannot defend against destructors that throw exceptions
223D The meaning of deprecation
22914.5.4 Partial specialization of function templates
23010.4 Calls to pure virtual functions
2365.19 Explicit temporaries and integral constant expressions
23714.7.2 Explicit instantiation and base class members
2385 Precision and accuracy constraints on floating point
2404.1 Uninitialized values and undefined behavior
2425.4 Interpretation of old-style casts
248E Identifier characters
2513.9.1 How many signed integer types are there?
2538.5 Why must empty or fully-initialized const objects be initialized?
25512.5 Placement deallocation functions and lookup ambiguity
25712.6.2 Abstract base constructors and virtual base initialization
26414.8.1 Unusable template constructors and conversion functions
2655.3.5 Destructors, exceptions, and deallocation
2675.3.4 Alignment requirement for new-expressions
26816.3.4 Macro name suppression in rescanned replacement text
27114.8.2 Explicit instantiation and template argument deduction
2783.5 External linkage and nameless entities
2793.5 Correspondence of "names for linkage purposes"
2825.2.8 Namespace for extended_type_info
2885.3.5 Misuse of "static type" in describing pointers
2903.9 Should memcpy be allowed into a POD with a const member?
2925.3.4 Deallocation on exception in new before arguments evaluated
29314.7.2 Syntax of explicit instantiation/specialization too permissive
29714.8.2 Which template does an explicit specialization specialize?
2995.3.4 Conversion on array bound expression in new
3093 Linkage of entities whose names are not simply identifiers, in introduction
31014.5.5.1 Can function templates differing only in parameter cv-qualifiers be overloaded?
3123.7.3.2 "use" of invalid pointer value not defined
3135.3.4 Class with single conversion function to integral as array size in new
3177.1.2 Can a function be declared inline after it has been called?
32012.2 Question on copy constructor elision example
3213.4.2 Associated classes and namespaces for argument-dependent lookup
3258.3.6 When are default arguments parsed?
3279 Use of "structure" without definition
3304.4 Qualification conversions and pointers to arrays of pointers
3328.3.5 cv-qualified void parameter types
33414.6.2.2 Is a comma-expression dependent if its first operand is?
3383.5 Enumerator name with linkage used as class name in other translation unit
3395.19 Overload resolution in operand of sizeof in constant expression
3425.3 Terminology: "indirection" versus "dereference"
34314.2 Make template optional in contexts that require a type
34412.4 Naming destructors
3479.7 Use of derived class name in defining base class nested class
35414.3.2 Null as nontype template argument
3559 Global-scope :: in elaborated-type-specifier
3571.3.10 Definition of signature should include name
36011.2 Using-declaration that reduces access
3618.3.6 Forward reference to default argument
3653.7 Storage duration and temporaries
3692.4 Are new/delete identifiers or preprocessing-op-or-punc?
3713.6.2 Interleaving of constructor calls
3733.4.6 Lookup on namespace qualified name in using-directive
3786.6 Wording that says temporaries are declared
38010.2 Definition of "ambiguous base class" missing
3867.3.3 Friend declaration of name brought in by using-declaration
38815.3 Catching base*& from a throw of derived*
39512.3.2 Conversion operator template syntax
40214.5.5.2 More on partial ordering of function templates
4053.4.1 Unqualified function name lookup
4077.1.3 Named class with associated typedef: two names or one?
4112.13.4 Use of universal-character-name in character versus string literals
41813.3.3 Imperfect wording on error on multiple default arguments on a called function
4193.8 Can cast to virtual base class be done on partially-constructed object?
4308.5.1 Ordering of expression evaluation in initializer list
4385 Possible flaw in wording for multiple accesses to object between sequence points
44014.3 Allow implicit pointer-to-member conversion on nontype template argument
44714.6.2.3 Is offsetof type-dependent?
4529.3.2 Wording nit on description of this
45513.3.3 Partial ordering and non-deduced arguments
45914.6.1 Hiding of template parameters by base class members
4617.4 Make asm conditionally-supported
46212.2 Lifetime of temporaries bound to comma expressions
4635.2.10 reinterpret_cast<T*>(0)
46412.2 Wording nit on lifetime of temporaries to which references are bound
4653.6.2 May constructors of global objects call exit()?
4665.2.4 cv-qualifiers on pseudo-destructor type
4676.7 Jump past initialization of local static variable
46814.2 Allow ::template outside of templates
46914.8.2.5 Const template specializations and reference arguments


Issues with "Dup" Status:

IssueSectionTitle
123.4.2 Default arguments on different declarations for the same function and the Koenig lookup
158.3.6 Default arguments for parameters of function templates
7214 Linkage and storage class specifiers for templates
7918.4.1.3 Alignment and placement new
823.2 Definition of "using" a constant expression
13315.4 Exception specifications and checking
20014.5.5.2 Partial ordering and explicit arguments
37514.6 Confusing example on lookup with typename


Issues with "NAD" Status:

IssueSectionTitle
314.7.3 The template compilation model rules render some explicit specialization declarations not visible during instantiation
711.2 Can a class with a private virtual base class be derived from?
147.5 extern "C" functions and declarations in different namespaces
1711.2 Footnote 99 should discuss the naming class when describing members that can be accessed from friends
188.3.5 f(TYPE) where TYPE is void should be allowed
1911.5 Clarify protected member access
2612.8 Copy constructors and default arguments
2713.6 Overload ambiguities for builtin ?: prototypes
315.3.4 Looking up new/delete
3414.7.1 Argument dependent lookup and points of instantiation
3715.5.3 When is uncaught_exception() true?
423.3.6 Redefining names from base classes
4614.7.2 Explicit instantiation of member templates
4714.5.3 Template friend issues
503.2 Converting pointer to incomplete type to same type
555.7 Adding/subtracting pointer and enumeration value
6113.4 Address of static member function "&p->f"
668.3.6 Visibility of default args vs overloads added after using-declaration
715 Incorrect cross reference
81C Null pointers and C compatability
8814.7.3 Specialization of member constant templates
913.4.2 A union's associated types should include the union itself
957.3.1.2 Elaborated type specifiers referencing names declared in friend decls
975.19 Use of bool constants in integral constant expressions
9914.8.2.1 Partial ordering, references and cv-qualifiers
10213.3.1.2 Operator lookup rules do not work well with parts of the library
10415.1 Destroying the exception temp when no handler is found
1097.3.3 Allowing ::template in using-declarations
11414.5.2 Virtual overriding by template member function specializations
11712.2 Timing of destruction of temporaries
1305.3.4 Sequence points and new-expressions
1323.5 Local types and linkage
1547.1.1 Anonymous unions in unnamed namespaces
1657.3.1.2 Definitions of friends and block-scope externs
167D.2 Deprecating static functions
1697.3.3 template-ids in using-declarations
174D.2 Undeprecating global static
20911.4Must friend declaration names be accessible?
21115 Constructors should not be allowed to return normally after an exception
2313.4.1 Visibility of names after using-directives
2343.8 Reuse of base class subobjects
24313.3.3.1.2 Weighting of conversion functions in direct-initialization
24713.4 Pointer-to-member casts and function overload resolution
266A No grammar sentence symbol
2693.6.2 Order of initialization of multiply-defined static data members of class templates
28514.7.3 Identifying a function template being specialized
3034.5 Integral promotions on bit-fields
30712.7 Initialization of a virtual base class subobject
30815.3 Catching exceptions with ambiguous base classes
3117.3.1 Using qualified name to reopen nested namespace
3159.4.1 Is call of static member function through null pointer undefined?
31614.6.1 Injected-class-name of template used as template template parameter
3338.2 Ambiguous use of "declaration" in disambiguation section
3408.2 Unclear wording in disambiguation section
34615.4 Typo in 15.4
35612.8 Wording of behavior of generated copy constructor for scalar members
3587.5 Namespaces and extern "C"
36312.6.1 Initialization of class from self
3767.1.2 Class "definition" versus class "declaration"
3843.4.2 Argument-dependent lookup and operator functions
4127.1.2 Can a replacement allocation function be inline?
4227.1.3 Is a typedef redeclaration allowed with a template type that might be the same?
42313.3.1.2 Can a conversion be done on the left operand of a compound assignment?
44412.8 Overriding and the generated copy assignment operator
44511.4 Wording issue on friend declarations
4491.3 Consistency in use of hyphen with names of "non" entities
4515 Expressions with invalid results and ill-formedness
4564.10 Is initialized const int or const bool variable a null pointer constant?


Issues with "Extension" Status:

IssueSectionTitle
612.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?
137.5 extern "C" for Parameters of Function Templates
1077.5 Linkage of operator functions
15014.3.3 Template template parameters and default arguments
1687.5 C linkage for static member functions
2203.7.3.2 All deallocation functions should be required not to throw
2565.3.4 Overflow in size calculations
2945.2.9 Can static_cast drop exception specifications?
3599.5 Type definition in anonymous union


Issues with "DR" Status:

IssueSectionTitle


Issues with "WP" Status:

IssueSectionTitle
47.5 Does extern "C" affect the linkage of function names with internal linkage?
58.5 CV-qualifiers and type conversions
811 Access to template arguments used in a function return type and in the nested name specifier
911.2 Clarification of access to base class members
1011.8 Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?
117.3.3 How do the keywords typename/template interact with using-declarations?
1611.2 Access to members of indirect private base classes
297.5 Linkage of locally declared functions
4414.7.3 Member specializations
4511.8 Access to nested classes
6013.3.3.1.4 Reference binding and valid conversion sequences
6214.3.1 Unnamed members of classes used as type parameters
6314.7.1 Class instantiation from pointer conversion to void*, null and self
7014.8.2.5 Is an array bound a nondeduced context?
7711.4 The definition of friend does not allow nested classes to be friends
8715.4 Exception specifications on function parameters
106unknown Creating references to references during template deduction/instantiation
1128.3.4 Array types and cv-qualifiers
1135.2.2 Visibility of called function
11513.4 Address of template-id
1193.8 Object lifetime and aggregate initialization
1225.1 template-ids as unqualified-ids
12412.2 Lifetime of temporaries in default initialization of class arrays
1255.1 Ambiguity in friend declaration syntax
1368.3.6 Default arguments and friend declarations
1393.4.1 Error in friend lookup example
1408.3.5 Agreement of parameter declarations
1433.4.2 Friends and Koenig lookup
1583.10 Aliasing and qualification conversions
1608.2 Missing std:: qualification
16213.3.1.1 (&C::f)() with nonstatic members
1727.2 Unsigned int as underlying type of enum
1759 Class name injection and base name access
1778.5 Lvalues vs rvalues in copy-initialization
18014.6 typename and elaborated types
18414.1 Default arguments in template template-parameters
1989.8 Definition of "use" in local and nested classes
20112.2 Order of destruction of temporaries in initializers
20414 Exported class templates
20711.2 using-declarations and protected access
20815.1 Rethrowing exceptions in nested handlers
21414.5.5.2 Partial ordering of function templates is underspecified
2163.5 Linkage of nameless class-scope enumeration types
22113.5.3 Must compound assignment operators be member functions?
22414.6.2.1 Definition of dependent names
22614.1 Default template arguments for function templates
22814.2 Use of template keyword with non-member templates
23913.3.1.1.1 Footnote 116 and Koenig lookup
24412.4 Destructor lookup
2453.4.4 Name lookup in elaborated-type-specifiers
24614.3 Jumps in function-try-block handlers
25212.4 Looking up deallocation functions in virtual destructors
2543.4.4 Definitional problems with elaborated-type-specifiers
2587.3.3 using-declarations and cv-qualifiers
25914.7 Restrictions on explicit specialization and instantiation
2613.2 When is a deallocation function "used?"
2628.3.5 Default arguments and ellipsis
26312.1 Can a constructor be declared a friend?
2703.6.2 Order of initialization of static data members of class templates
27212.4 Explicit destructor invocation and qualified-ids
2739 POD classes and operator&()
2743.8 Cv-qualification and char-alias access to out-of-lifetime objects
27514.7.3 Explicit instantiation/specialization and using-directives
2778.5 Zero-initialization of pointers
28013.3.1.1.2 Access and surrogate call functions
2817.1.2 inline specifier in friend declarations
2837.1.5.2 Template type-parameters are not syntactically type-names
2849 qualified-ids in class declarations
28614.5.4 Incorrect example in partial specialization
2893.2 Incomplete list of contexts requiring a complete type
2958.3.5 cv-qualifiers on function types
29612.3.2 Can conversion functions be static?
2983.4.3.1 T::x when T is cv-qualified
30014.8.2.5 References to functions in template argument deduction
3028.5 Value-initialization and generation of default constructor
3183.4.3.1 struct A::A should not name the constructor of A
32214.8.2.3 Deduction of reference conversions
32314 Where must export appear?
3245.3.1 Can "&" be applied to assignment to bit-field?
32612.1 Wording for definition of trivial constructor
3289.2 Missing requirement that class member types be complete
32914.5.3 Evaluation of friends of templates
33112.1 Allowed copy constructor signatures
33514 Allowing export on template members of nontemplate classes
33614.7.3 Explicit specialization examples are still incorrect
33714.8.2 Attempt to create array of abtract type should cause deduction to fail
34514.6 Misleading comment on example in templates chapter
34914.8.2.3 Template argument deduction for conversion functions and qualification conversions
3515 Sequence point error: unspecified or undefined?
35214.8.2.1 Nondeduced contexts
3535.3.5 Is deallocation routine called if destructor throws exception in delete?
3622.1 Order of initialization in instantiation units
36413.3.1.1.1 Calling overloaded function with static in set, with no object
3665.19 String literal allowed in integral constant expression?
36814.8.2 Uses of non-type parameters that should cause deduction to fail
3777.2 Enum whose enumerators will not fit in any integral type
3799 Change "class declaration" to "class definition"
3839 Is a class with a declared but not defined destructor a POD?
38714.6.5 Errors in example in 14.6.5
39010.4 Pure virtual must be defined when implicitly called
39212.2 Use of full expression lvalue before temporary destruction
3967.1.2 Misleading note regarding use of auto for disambiguation
39814.8.2 Ambiguous wording on naming a type in deduction
4003.4.3.2 Using-declarations and the "struct hack"
4033.4.2 Reference to a type as a template-id
4043.8 Unclear reference to construction with non-trivial constructor
4069.4.2 Static data member in class with name for linkage purposes
4215.2.5 Is rvalue.field an rvalue?
4247.1.3 Wording problem with issue 56 resolution on redeclaring typedefs in class scope
42513.6 Set of candidates for overloaded built-in operator with float operand
42815.1 Mention of expression with reference type
4323.3.6 Is injected class name visible in base class specifier list?
4333.3.1 Do elaborated type specifiers in templates inject into enclosing namespace scope?


Issues with "TC1" Status:

IssueSectionTitle
18.3.6 What if two using-declarations refer to the same function but the declarations introduce different default-arguments?
2012.8 Some clarifications needed for 12.8 para 15
2114.1 Can a default argument for a template parameter appear in a friend declaration?
2214.6.4 Template parameter with a default argument that refers to itself
2414.7.3 Errors in examples in 14.7.3
2515.4 Exception specifications and pointers to members
3014.2 Valid uses of "::template"
3214 Clarification of explicit instantiation of non-exported templates
333.4.2 Argument dependent lookup and overloaded functions
358.5 Definition of default-initialization
3814.2 Explicit template arguments and operator functions
408.3 Syntax of declarator-id
413.4.1 Clarification of lookup of names after declarator-id
433.9 Copying base classes (PODs) using memcpy
489.4.2 Definitions of unused static members
4914.1 Restriction on non-type, non-value template arguments
5113.3.3 Overloading and user-defined conversions
525.2.5 Non-static members, member selection and access checking
535.2.9 Lvalue-to-rvalue conversion before certain static_casts
567.1.3 Redeclaring typedefs within classes
5913.3.1.4 Clarification of overloading and UDC to reference type
6414.7.3 Partial ordering to disambiguate explicit specialization
658.3.6 Typo in default argument example
679.4 Evaluation of left side of object-expression
687.1.5.3 Grammar does not allow "friend class A<int>;"
697.1.1 Storage class specifiers on template declarations
735.10 Pointer equality
745.3.4 Enumeration value in direct-new-declarator
759.2 In-class initialized members must be const
767.1.5.1 Are const volatile variables considered "constant expressions"?
788.5 Section 8.5 paragraph 9 should state it only applies to non-static objects
809.2 Class members with same name as class
8313.3.3.2 Overloading and deprecated conversion of string literal
8413.3.3.1 Overloading and conversion loophole used by auto_ptr
853.4.4 Redeclaration of member class
893.8 Object lifetime does not account for reference rebinding
903.4.2 Should the enclosing class be an "associated class" too?
933.8 Missing word in 3.8 basic.life paragraph 2
945.19 Inconsistencies in the descriptions of constant expressions
9815 Branching into try block
10014.3.2 Clarify why string literals are not allowed as template arguments
1017.3.3 Redeclaration of extern "C" names via using-declarations
1037.3.4 Is it extended-namespace-definition or extension-namespace-definition ?
10514 Meaning of "template function"
10814.6.2.1 Are classes nested in templates dependent?
11614.5.5.1 Equivalent and functionally-equivalent function templates
12014.6 Nonexistent non-terminal qualified-name
12114.6 Dependent type names with non-dependent nested-name-specifiers
1235.1 Bad cross-reference
12615.4 Exception specifications and const
1275.3.4 Ambiguity in description of matching deallocation function
1285.2.9 Casting between enum types
131E Typo in Lao characters
13414 Template classes and declarator-ids
1358.3.5 Class type in in-class member function definitions
1375.2.9 static_cast of cv void*
14211.2 Injection-related errors in access example
145D.1 Deprecation of prefix ++
1475.1 Naming the constructor
1489 POD classes and pointers to members
1494.10 Accessibility and ambiguity
1518.5 Terminology of zero-initialization
15212.3.1 explicit copy constructors
15313.3.3.2 Misleading wording (rank of conversion)
1598.3 Namespace qualification in declarators
16111.5 Access to protected nested type
1638.5.1 Description of subaggregate initializer
1643.4.2 Overlap between Koenig and normal lookup
1667.3.1.2 Friend declarations of template-ids
1717.3 Global namespace scope
1732.2 Constraints on execution character set
1769 Name injection and templates
1788.5 More on value-initialization
1795.7 Function pointers and subtraction
18114.8.2.5 Errors in template template-parameter example
18314.6 typename in explicit specializations
18512.8 "Named" temporaries and copy elision
18714.1 Scope of template parameter names
1885.18 Comma operator and rvalue conversion
1909.2 Layout-compatible POD-struct types
19312.4 Order of destruction of local automatics of destructor
19412.1 Identifying constructors
20213.4 Use of overloaded function name
20614.6.3 Semantic constraints on non-dependent names
21015.3 What is the type matched by an exception handler?
21314.6.2 Lookup in dependent base classes
2178.3.6 Default arguments for non-template member functions of class templates
2276.4 How many scopes in an if statement?
23512.6.2 Assignment vs initialization
24114.8.1 Error in example in 14.8.1
24914.5.1.1 What is a member function template?
25013.4 Address of function template specialization with non-deduced template arguments
3048.5 Value-initialization of a reference