2172. Multiple exceptions with one exception object

Section: 14.4 [except.handle] Status: drafting Submitter: Richard Smith Date: 2015-09-14

During the discussion of it was observed that multiple exceptions may share a single exception object via std::exception_ptr. It is not clear that the current wording handles that case correctly.

2219. Dynamically-unreachable handlers

Section: 14.4 [except.handle] Status: drafting Submitter: 2016-01-04 Date: Richard Smith

Consider the following example:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

54

According to the Standard, this should print unwound and exit. Current optimizing implementations call terminate(), because:

• f() obviously never unwinds (all paths out of it call exit)
• Therefore the catch(int) clause is unreachable
• Therefore the catch(int) clause is removed
• When countering the throw 0; statement, the search for a handler finds nothing, so terminate is called without unwinding the stack.

More abstractly, before calling terminate, we're required to check whether there is an active handler for an exception of type int, and in some sense there is not (because the handler in main is dynamically unreachable).

There seem to be three possible solutions:

1. Change the standard to say that terminate() is a valid response to this situation [this seems problematic, as any non-returning destructor now risks program termination, but is in fact the status quo on multiple implementations and does not seem to have resulted in any bug reports]
2. Always fully unwind before calling terminate() [this significantly harms debugability of exceptions]
3. Teach the compilers to not optimize out unreachable exception handlers [for some implementations, this is “remove, redesign and reimplement middle-end support for EH”-level difficult, and harms the ability to optimize code involving catch handlers]

1718. Macro invocation spanning end-of-file

Section: 15.6 [cpp.replace] Status: drafting Submitter: David Krauss Date: 2013-07-23 Liaison: WG14

Although it seems to be common implementation practice to reject a macro invocation that begins in a header file and whose closing right parenthesis appears in the file that included it, there does not seem to be a prohibition of this case in the specification of function-style macros. Should this be accepted?

Notes from the February, 2014 meeting:

CWG agreed that macro invocations spanning file boundaries should be prohibited. Resolution of this issue should be coordinated with WG14.

2003. Zero-argument macros incorrectly specified

Section: 15.6 [cpp.replace] Status: drafting Submitter: Richard Smith Date: 2014-09-12

According to 15.6 [] paragraph 4,

If the identifier-list in the macro definition does not end with an ellipsis, the number of arguments (including those arguments consisting of no preprocessing tokens) in an invocation of a function-like macro shall equal the number of parameters in the macro definition.

That is, a sequence of no preprocessing tokens counts as an argument. That phrasing has problems with zero-argument function-like macros, e.g.,

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

55

M is defined as having no parameters but the invocation has one (empty) argument, which does not match the number of parameters in the definition.

1709. Stringizing raw string literals containing newline

Section: 15.6.3 [cpp.stringize] Status: drafting Submitter: David Krauss Date: 2013-07-01

Stringizing a raw string literal containing a newline produces an invalid (unterminated) string literal and hence results in undefined behavior. It should be specified that a newline in a string literal is transformed to the two characters '\' 'n' in the resulting string literal.

A slightly related case involves stringizing a bare backslash character: because backslashes are only escaped within a string or character literal, a stringized bare backslash becomes "\", which is invalid and hence results in undefined behavior.

1889. Unclear effect of

pragma on conformance

Section: 15.9 [cpp.pragma] Status: drafting Submitter: James Widman Date: 2014-03-05

According to 15.9 [] paragraph 1, the effect of a

pragma is to cause

the implementation to behave in an implementation-defined manner. The behavior might cause translation to fail or cause the translator or the resulting program to behave in a non-conforming manner.

It should be clarified that the extent of the non-conformance is limited to the implementation-defined behavior.

2181. Normative requirements in an informative Annex

Section: Clause Annex B [implimits] Status: drafting Submitter: Sean Hunt Date: 2015-10-18

According to Clause Annex B [] paragraph 1,

Because computers are finite, C++ implementations are inevitably limited in the size of the programs they can successfully process. Every implementation shall document those limitations where known.

Because Annex Clause Annex B [implimits] is informative, not normative, it should not use “shall.”

1279. Additional differences between C++ 2003 and C++ 2011

Section: C.6 [diff.cpp03] Status: drafting Submitter: Nikolay Ivchenkov Date: 2011-03-27

A number of differences between C++03 and C++11 were omitted from C.6 [diff.cpp03]:

• New keywords. Although these are said in C.6.2 [diff.cpp03.lex] only to invalidate C++03 code, they can also change the meaning, e.g., thread_local x(y), which would declare a variable thread_local initialized with y in C++03 and a thread-local variable y in C++11.
• New deduction rules.
• Removal of the deprecated string literal conversion.
• When a friend function defined in a class template is actually defined (i.e., with each instantiation or only when odr-used).
• Removal of access declarations.
• Use of the injected-class-name of a class template as a template template-argument.

Additional note (January, 2012):

In addition to the items previously mentioned, access declarations were removed from C++11 but are not mentioned in C.6 [diff.cpp03].

Proposed (partial) resolution (February, 2012):

Add the following as a new section in C.6 [diff.cpp03]:

C.2.5 11.8 [class.access]: member access control pdiff.cpp03.class.access

Change: Remove access declarations.

Rationale: Removal of feature deprecated since C++ 1998.

Effect on original feature: Valid C++ 2003 code that uses access declarations is ill-formed in this International Standard. Instead, using-declarations (9.9 [namespace.udecl]) can be used.

Issues with "Open" Status

783. Definition of “argument”

Section: Clause 3 [intro.defs] Status: open Submitter: UK Date: 3 March, 2009

The definition of an argument does not seem to cover many assumed use cases, and we believe that is not intentional. There should be answers to questions such as: Are lambda-captures arguments? Are type names in a throw-spec arguments? “Argument” to casts, typeid, alignof, alignas, decltype and sizeof? why in x[arg] arg is not an argument, but the value forwarded to operator[]() is? Does not apply to operators as call-points not bounded by parentheses? Similar for copy initialization and conversion? What are deduced template “arguments?” what are “default arguments?” can attributes have arguments? What about concepts, requires clauses and concept_map instantiations? What about user-defined literals where parens are not used?

2632. 'user-declared' is not defined

Section: Clause 3 [intro.defs] Status: open Submitter: Anoop Rana Date: 2022-09-07

The term "user-declared" is used 30 times throughout the standard, but it is not defined.

Possible resolution:

Add a new entry after 3.66 [defns.unspecified] as follows:

user-declared [defns.user.declared]

declared in a translation unit using a declarator-id

[ Note 1 to entry: In contrast, some special member functions can be implicitly declared by the implementation. -- end note]

949. Requirements for freestanding implementations

Section: 4.1 [intro.compliance] Status: open Submitter: Detlef Vollman Date: 2 August, 2009

According to 4.1 [] paragraph 7,

A freestanding implementation is one in which execution may take place without the benefit of an operating system, and has an implementation-defined set of libraries that includes certain language-support libraries (16.4.2.5 [compliance]).

This definition links two relatively separate topics: the lack of an operating system and the minimal set of libraries. Furthermore, 6.9.3.1 [] paragraph 1 says:

[Note: in a freestanding environment, start-up and termination is implementation-defined; start-up contains the execution of constructors for objects of namespace scope with static storage duration; termination contains the execution of destructors for objects with static storage duration. —end note]

It would be helpful if the two characteristics (lack of an operating system and restricted set of libraries) were named separately and if these statements were clarified to identify exactly what is implementation-defined.

Notes from the October, 2009 meeting:

The CWG felt that it needed a specific proposal in a paper before attempting to resolve this issue.

2776. Substitution failure and implementation limits

Section: 4.1.1 [intro.compliance.general] Status: open Submitter: Corentin Jabot Date: 2023-07-27

Are there behavioral bounds in case an implementation limit is encountered? For example, a constant expression may fail to be recognized as such due to an implementation limit (e.g. a recursion or step limit), causing overload resolution to pick a different overload. Is that acceptable?

Possible resolution:

1. Change in 4.1.1 [] paragraph 2 as follows:

   Although this document states only requirements on C++ implementations, those requirements are often easier to understand if they are phrased as requirements on programs, parts of programs, or execution of programs as specified in the rules in Clause 5 [lex] through Clause 33 [thread] and Annex D. Such requirements have the following meaning: If a program contains a violation of a rule for which no diagnostic is required, this document places no requirement on implementations with respect to that program. Otherwise, if an implementation limit (Annex B) is reached during translation, an implementation shall reject the program.

   Recommended practice: An implementation should document limits where they are known, and should issue a diagnostic in cases where it can reasonably detect that the implementation limit is reached.

   If a program contains no violations of the rules in Clause 5 [lex] through Clause 33 [thread] and Annex D, a conforming implementation shall, within its resource limits as described in Annex B, accept and correctly execute [ Footnote: ... ] that program. If a program contains a violation of a rule for which no diagnostic is required, this document places no requirement on implementations with respect to that program. Otherwise, if a that program contains a violation of any diagnosable rule or an occurrence of a construct described in this document as “conditionally-supported” when the implementation does not support that construct, a conforming implementation shall issue at least one diagnostic message. Otherwise, a conforming implementation shall accept and correctly execute that program. [ Note: "Correct execution" can include undefined behavior, depending on the data being processed; see Clause 3 [intro.defs] and 4.1.2 [intro.abstract]. end note ]

2. Add a new paragraph after 4.1.2 [] paragraph 6 as follows: [Note 2 : More stringent correspondences between abstract and actual semantics can be defined by each implementation. end note]

If an implementation limit (Annex B) is reached, the behavior is undefined.

Recommended practice: An implementation should document limits where they are known and abort the execution of the program in cases where it can reasonably detect that the implementation limit is reached.

3. Change in 7.7 [] paragraph 5 as follows: ... an expression that would exceed the implementation-defined limits (see Annex B); an operation that would have undefined behavior as specified in Clause 4 [intro] through Clause 15 [cpp], excluding 9.12.3 [dcl.attr.assume] and exceeding an implementation limit (4.1.2 [intro.abstract]); [ Footnote: ... ]

   [ Example: const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() { assert(&r == &a); // allowed not to fail? } 56 -- end example ]

   ...
4. Change in 13.9.2 [] paragraph 16 as follows: There is an implementation-defined quantity that specifies the limit on the total depth of recursive instantiations (Annex B), which could involve more than one template. The result of an infinite recursion in instantiation is undefined.

2573. Undefined behavior when splicing results in a universal-character-name

Section: 5.2 [lex.phases] Status: open Submitter: US Date: 2019-10-23 Liaison: SG12

(From National Body comments US 024 and US 025 on the C++20 DIS.)

Subclause 5.2 [] bullet 1.2 specifies:

Except for splices reverted in a raw string literal, if a splice results in a character sequence that matches the syntax of a universal-character-name, the behavior is undefined.

Undefined behavior during lexing is not acceptable. The behavior ought to be well-defined, ill-formed, or conditionally-supported.

Additional notes (January, 2023):

Forwarded to SG12 with paper issue 1405, by decision of the CWG and SG12 chairs.

2779. Restrictions on the ordinary literal encoding

Section: 5.3 [lex.charset] Status: open Submitter: Jim X Date: 2023-03-28

There are no restrictions on the implementation's choice of ordinary literal encoding. However, there is an implicit assumption that a code unit value must fit into a char.

Tangentially related to that, "cannot be encoded as a single code unit" could be interpreted as referring to the values of the code units as opposed to the fact that multiple code units might be needed.

Possible resolution:

1. Change in 5.3 [] paragraph 8 as follows and add to the index of implementation-defined behavior:

   A code unit is an integer value of character type (6.8.2 [basic.fundamental]). Characters in a character-literal other than a multicharacter or non-encodable character literal or in a string-literal are encoded as a sequence of one or more code units, as determined by the encoding-prefix (5.13.3 [lex.ccon], 5.13.5 [lex.string]); this is termed the respective literal encoding. The ordinary literal encoding is the implementation-defined encoding applied to an ordinary character or string literal; its code units are of type unsigned char. The wide literal encoding is the implementation-defined encoding applied to a wide character or string literal; its code units are of type wchar_t.

2. Change in 5.13.3 [] bullet 3.1 as follows: A character-literal with a c-char-sequence consisting of a single basic-c-char , simple-escape-sequence, or universal-character-name is the code unit value of the specified character as encoded in the literal's associated character encoding. If the specified character lacks representation in the literal's associated character encoding or if it cannot be encoded as a single code unit is encoded with multiple code units, then the program is ill-formed. ...

2574. Undefined behavior when lexing unmatched quotes

Section: 5.4 [lex.pptoken] Status: open Submitter: US Date: 2019-10-23 Liaison: SG12

(From National Body comment US 027 on the C++20 DIS.)

Subclause 5.4 [] paragraph 2 specifies:

If a U+0027 apostrophe or a U+0022 quotation mark character matches the last category, the behavior is undefined.

Undefined behavior during lexing is not acceptable. This ought to be ill-formed.

Additional notes (January, 2023):

Forwarded to SG12 with paper issue 1406, by decision of the CWG and SG12 chairs.

2752. Excess-precision floating-point literals

Section: 5.13.4 [lex.fcon] Status: open Submitter: Peter Dimov Date: 2023-06-29 Liaison: EWG

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

57

Can a conforming implementation represent a floating-point literal with excess precision, causing the comparisons to fail?

Subclause 5.13.4 [] paragraph 3 specifies:

If the scaled value is not in the range of representable values for its type, the program is ill-formed. Otherwise, the value of a floating-point-literal is the scaled value if representable, else the larger or smaller representable value nearest the scaled value, chosen in an implementation-defined manner.

This phrasing leaves little leeway for excess precision. In contrast, C23 (WG14 N3096) specifies in section 6.4.4.2 paragraph 6:

The values of floating constants may be represented in greater range and precision than that required by the type (determined by the suffix); the types are not changed thereby. ...

Subclause 7.1 [] paragraph 6 allows excess precision for floating-point computations (including their operands):

The values of the floating-point operands and the results of floating-point expressions may be represented in greater precision and range than that required by the type; the types are not changed thereby. [ Footnote: The cast and assignment operators must still perform their specific conversions as described in 7.6.1.4 [expr.type.conv], 7.6.3 [expr.cast], 7.6.1.9 [expr.static.cast] and 7.6.19 [expr.ass]. -- end footnote ]

Taken together, that means that 314.f / 100.f can be computed and represented more precisely than 3.14f, which is hard to justify. The footnote appears to imply that (float)3.14f is required to yield a value with float precision, but that conversion (eventually) ends up at 9.4.1 [] bullet 16.9:

... Otherwise, the initial value of the object being initialized is the (possibly converted) value of the initializer expression. ...

This phrasing leaves no permission to discard excess precision when converting from a float value to type float ("... is the value...").

However, if initialization is intended to drop excess precision, then an overloaded operator returning float can never behave like a built-in operation with excess precision, because returning a value means initializing the return value.

The C++ standard library inherits the FLT_EVAL_METHOD macro from the C standard library. C23 (WG14 N3096) specifies it as follows in section 5.2.4.2.2:

0 evaluate all operations and constants just to the range and precision of the type; 1 evaluate operations and constants of type float and double to the range and precision of the double type, evaluate long double operations and constants to the range and precision of the long double type; 2 evaluate all operations and constants to the range and precision of the long double type.

Taken together, a conforming C++ implementation cannot define FLT_EVAL_METHOD to 1 or 2, because literals (= "constants") cannot be represented with excess precision in C++.

Additional notes (June, 2023)

Forwarded to EWG via cplusplus/papers

1584, by decision of the CWG chair.

2766. Repeated evaluation of a string-literal may yield different objects

Section: 5.13.5 [lex.string] Status: open Submitter: Balog Pal Date: 2023-07-15

Prior to the resolution of (incorporated into C++17), the specification required in 9.2.3 [] paragraph 4:

A string literal in the body of an extern inline function is the same object in different translation units.

That was changed to the following specification in 5.13.5 [] paragraph 9:

Evaluating a string-literal results in a string literal object with static storage duration (6.7.5 [basic.stc]). ... whether successive evaluations of a string-literal yield the same or a different object is unspecified.

The treatment of string literal objects was harmonized with backing arrays in P2752R3 (approved in June, 2023) and .

The rationale for the change made by was deviating implementation practice: Implementations do not unify string literal objects in inline functions or template instantiations across different translation units.

However, that was a silent behavior change for examples such as:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

58

The matter should be revisited in light of this new information.

1266. user-defined-integer-literal overflow

Section: 5.13.9 [lex.ext] Status: open Submitter: Michael Wong Date: 2011-03-20

The decimal-literal in a user-defined-integer-literal might be too large for an unsigned long long to represent (in implementations with extended integer types). In such cases, the original intent appears to have been to call a raw literal operator or a literal operator template; however, the existing wording of 5.13.9 [] paragraph 3 always calls the unsigned long long literal operator if it exists, regardless of the value of the decimal-literal.

1209. Is a potentially-evaluated expression in a template definition a “use?”

Section: 6.3 [basic.def.odr] Status: open Submitter: Johannes Schaub Date: 2010-10-08

Consider the following complete program:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

59

Must f() be defined to make this program well-formed? The current wording of 6.3 [basic.def.odr] does not make any special provision for expressions that appear only in uninstantiated template definitions.

(See also issue 1254.)

2745. Dependent odr-use in generic lambdas

Section: 6.3 [basic.def.odr] Status: open Submitter: Shafik Yaghmour Date: 2022-12-13

Default template arguments of generic lambdas can refer to local variables. It is unclear whether the potential odr-use is checked when parsing the template definition or when instantiating the template.

There is wide implementation divergence.

Possible resolution:

Insert a new paragraph before 6.3 [] paragraph 11:

[ Example:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() { assert(&r == &a); // allowed not to fail? }

60

-- end example ]

Every program shall contain at least one definition of every function or variable ...

2488. Overloading virtual functions and functions with trailing requires-clauses

Section: 6.4.1 [basic.scope.scope] Status: open Submitter: Jiang An Date: 2020-08-19

According to 6.4.1 [] paragraph 3,

Two declarations correspond if they (re)introduce the same name, both declare constructors, or both declare destructors, unless ... each declares a function or function template, except when both declare functions with the same parameter-type-list,21 equivalent (13.7.7.2 [temp.over.link]) trailing requires-clauses (if any, except as specified in 13.7.5 [temp.friend]), and, if both are non-static members, the same cv-qualifiers (if any) and ref-qualifier (if both have one), or ...

This would indicate that a virtual function (which cannot have a trailing requires-clause, per 11.7.3 [] paragraph 6) can be overloaded with a non-virtual member function with the same parameter type list but with a trailing requires-clause. However, this is not implementable on some ABIs, since the mangling of the two functions would be the same. For example:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

61

Should such overloading be ill-formed or conditionally-supported, or should the current rules be kept?

Rationale (August, 2021):

CWG felt that the current rules are correct; it simply means that only the virtual function can be called, and all other references are simply ambiguous. (See also for a related question dealing with explicit instantiation.

Notes from the November, 2021 teleconference:

The issue has been reopened in response to additional discussion.

CWG 2022-11-11

This is related to . CWG solicits a paper to address this issue.

2764. Use of placeholders affecting name mangling

Section: 6.4.1 [basic.scope.scope] Status: open Submitter: Hubert Tong Date: 2023-07-05

Paper P2169R4 (A nice placeholder with no name), as approved by WG21 in Varna, added a placeholder facility. The intent was that the use of placeholders is sufficiently limited such that they never need to be mangled. Quote from 6.4.1 [] paragraph 5 as modified by the paper:

A declaration is name-independent if its name is _ and it declares a variable with automatic storage duration, a structured binding not inhabiting a namespace scope, the variable introduced by an init-capture, or a non-static data member.

The following example does not seem to follow that intent:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

62

The preceding example needs handling similar to the following example, which is unrelated to the placeholder feature:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

63

A similar problem may arise for static or thread_local structured bindings at block scope.

Finally, another example involving placeholders in anonymous unions:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

64

Possible resolution:

Change in 6.4.1 [] paragraph 5 and add bullets as follows:

A class is name-dependent if it is an anonymous union declared at namespace scope or with a storage-class-specifier (11.5.2 [class.union.anon]). A declaration is name-independent if its name is _ and it declares a variable with automatic storage duration, a structured binding with no storage-class-specifier and not inhabiting a namespace scope, the variable introduced by an init-capture, or a non-static data member of other than a name-dependent class.

380. Definition of "ambiguous base class" missing

Section: 6.5.2 [class.member.lookup] Status: open Submitter: Jason Merrill Date: 22 Oct 2002

The term "ambiguous base class" doesn't seem to be actually defined anywhere. 6.5.2 [] paragraph 7 seems like the place to do it.

2670. Programs and translation units

Section: 6.6 [basic.link] Status: open Submitter: Gabriel dos Reis Date: 2022-12-21

Subclause 6.6 [] paragraph 1 specifies:

A program consists of one or more translation units (5.1 [lex.separate]) linked together. A translation unit consists of a sequence of declarations.

Subclause 5.1 [] paragraph 1 defines "translation unit":

A source file together with all the headers (16.4.2.3 [headers]) and source files included (15.3 [cpp.include]) via the preprocessing directive

include, less any source lines skipped by any of the conditional inclusion (15.2 [cpp.cond]) preprocessing directives, is called a translation unit.

Subclause 5.2 [] paragraph 7 first mentions the "translation" of translation units:

Whitespace characters separating tokens are no longer significant. Each preprocessing token is converted into a token (5.6 [lex.token]). The resulting tokens are syntactically and semantically analyzed and translated as a translation unit.

However, 5.2 [] paragraph 8 introduces "instantiation units" and 5.2 [] paragraph 9 specifies:

Translated translation units and instantiation units are combined as follows:

and 5.2 [] paragraph 9 specifies:

All external entity references are resolved. Library components are linked to satisfy external references to entities not defined in the current translation. All such translator output is collected into a program image which contains information needed for execution in its execution environment.

The term "linking" in 5.2 [lex.phases] comes after translated translation units and instantiation units are combined, yet 6.6 [] paragraph 1 states that (untranslated) translation units are linked to form a program. That seems inconsistent.

Additional notes (February, 2023)

See also , which introduced the term "preprocessing translation unit" to remove the conflict between 6.6 [] paragraph 1 and 5.1 [] paragraph 1.

2706. Repeated structured binding declarations

Section: 6.6 [basic.link] Status: open Submitter: Jim X Date: 2023-02-13

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

65

A rule is missing to make such repeated structured binding declarations ill-formed.

Suggested resolution:

Change in 6.6 [] paragraph 11 as follows:

For any two declarations of an entity E: If one declares E to be a variable or function, the other shall declare E as one of the same type. If one declares E to be an enumerator, the other shall do so. If one declares E to be a structured binding, the program is ill-formed. ...

1953. Data races and common initial sequence

Section: 6.7.1 [intro.memory] Status: open Submitter: Faisal Vali Date: 2014-06-23

According to 6.7.1 [] paragraph 3,

A memory location is either an object of scalar type or a maximal sequence of adjacent bit-fields all having non-zero width. [Note: Various features of the language, such as references and virtual functions, might involve additional memory locations that are not accessible to programs but are managed by the implementation. —end note] Two or more threads of execution (6.9.2 [intro.multithread]) can update and access separate memory locations without interfering with each other.

It is not clear how this relates to the permission granted in 11.4 [] paragraph 18 to inspect the common initial sequence of standard-layout structs that are members of a standard-layout union. If one thread is writing to the common initial sequence and another is reading from it via a different struct, that should constitute a data race, but the current wording does not clearly state that.

2334. Creation of objects by typeid

Section: 6.7.2 [intro.object] Status: open Submitter: Chris Hallock Date: 2017-01-30

The list of ways that an object may be created in 6.7.2 [] paragraph 1 does not include creation of type_info objects by typeid expressions, but 7.6.1.8 [expr.typeid] does not appear to require that such objects exist before they are referenced. Should the list in 6.7.2 [intro.object] be extended to include this case?

2744. Multiple objects of the same type at the same address

Section: 6.7.2 [intro.object] Status: open Submitter: Chris Hallock Date: 2023-06-08

(From thread beginning here.)

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

66

A::buf provides storage for another A object. Thus, there are now two objects of type A within lifetime, which is inconsistent with the goal expressed by 6.7.2 [] paragraph 9.

Suggested resolution:

Change in 6.7.2 [] paragraph 3 as follows:

If a complete object of type T is created (7.6.2.8 [expr.new]) in storage associated with another object e of type “array of N unsigned char” or of type “array of N std::byte” (17.2.1 [cstddef.syn]), that array provides storage for the created object if: the lifetime of e has begun and not ended, and the storage for the new object fits entirely within e, and e is not and is not nested within an object of type similar (7.3.6 [conv.qual]) to T that is within its lifetime, and there is no array object that satisfies these constraints nested within e.

2765. Address comparisons between potentially non-unique objects during constant evaluation

Section: 6.7.2 [intro.object] Status: open Submitter: CWG Date: 2023-07-14

The (arguably) expanded treatment of backing arrays and string literals as potentially non-unique objects in lead to the question how the resulting address comparisons are treated during constant evaluation.

Subclause 7.7 [] bullet 5.24 specifies:

An expression E is a core constant expression unless the evaluation of E, following the rules of the abstract machine (6.9.1 [intro.execution]), would evaluate one of the following: ... a three-way comparison (7.6.8 [expr.spaceship]), relational (7.6.9 [expr.rel]), or equality (7.6.10 [expr.eq]) operator where the result is unspecified;

• ...

This phrasing is understood to refer to explicitly unspecified outcomes only. The treatment of an example such as

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

67

is unclear, given that identical string literals may or may not yield distinct string literal objects.

The assumption that equality comparison of std::string_view would compare addresses as a short-cut before comparing the character sequence could not be confirmed (23.2.2 [char.traits.require], 23.3.3.8 [] paragraph 12).

419. Can cast to virtual base class be done on partially-constructed object?

Section: 6.7.3 [basic.life] Status: open Submitter: Judy Ward Date: 2 June 2003

Consider

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

68

11.9.5 [] paragraph 2 makes this valid, but 6.7.3 [] paragraph 5 implies that it isn't valid.

Steve Adamczyk: A second issue:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

69

almost, but not quite, says that in evaluating "this->x" you do a cast to the virtual base class A, which would be an error according to 11.9.5 [] paragraph 2 because the base class B constructor hasn't started yet. 7.6.1.5 [expr.ref] should be clarified to say that the cast does need to get done.

James Kanze submitted the same issue via comp.std.c++ on 11 July 2003:

Richard Smith: Nonsense. You can use "this" perfectly happily in a constructor, just be careful that (a) you're not using any members that are not fully initialised, and (b) if you're calling virtual functions you know exactly what you're doing.

In practice, and I think in intent, you are right. However, the standard makes some pretty stringent restrictions in 6.7.3 [basic.life]. To start with, it says (in paragraph 1):

The lifetime of an object is a runtime property of the object. The lifetime of an object of type T begins when: storage with the proper alignment and size for type T is obtained, and if T is a class type with a non-trivial constructor, the constructor calls has COMPLETED.

The lifetime of an object of type T ends when:

if T is a class type with a non-trivial destructor, the destructor call STARTS, or the storage which the object occupies is reused or released.

(Emphasis added.) Then when we get down to paragraph 5, it says:

Before the lifetime of an object has started but after the storage which the object will occupy has been allocated [which sounds to me like it would include in the constructor, given the text above] or, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, any pointer that refers to the storage location where the object will be or was located may be used but only in limited ways. [...] If the object will be or was of a non-POD class type, the program has undefined behavior if:

[...]

• the pointer is implicitly converted to a pointer to a base class type, or [...]

I can't find any exceptions for the this pointer.

Note that calling a non-static function in the base class, or even constructing the base class in initializer list, involves an implicit conversion of this to a pointer to the base class. Thus undefined behavior. I'm sure that this wasn't the intent, but it would seem to be what this paragraph is saying.

2258. Storage deallocation during period of destruction

Section: 6.7.3 [basic.life] Status: open Submitter: Richard Smith Date: 2016-04-12

What happens if the storage for an object is deallocated in its period of destruction? Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

70

This ought to be undefined behavior, but the standard is silent on the matter.

Notes from the December, 2016 teleconference:

The consensus view was that this should be undefined behavior.

Additional notes (July, 2023)

This issue is a subset of .

2676. Replacing a complete object having base subobjects

Section: 6.7.3 [basic.life] Status: open Submitter: Richard Smith Date: 2022-12-06

Base subobjects cannot be transparently replaced with complete objects, as specified in 6.7.3 [] bullet 8.4:

An object o1 is transparently replaceable by an object o2 if: ... neither o1 nor o2 is a potentially-overlapping subobject (6.7.2 [intro.object]), and

• ...

However, that bullet is over-reaching, because it disallows:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

71

See for a suggested resolution.

Additional notes (February, 2023)

Consider this example:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

72

The suggestions do not address this example.

365. Storage duration and temporaries

Section: 6.7.5 [basic.stc] Status: open Submitter: James Kanze Date: 24 July 2002

There are several problems with 6.7.5 [basic.stc]:

• 6.7.5 [] paragraph 2 says that "Static and automatic storage durations are associated with objects introduced by declarations (6.2 [basic.def]) and implicitly created by the implementation (6.7.7 [class.temporary])." In fact, objects "implicitly created by the implementation" are the temporaries described in (6.7.7 [class.temporary]), and have neither static nor automatic storage duration, but a totally different duration, described in 6.7.7 [class.temporary].
• 6.7.5 [basic.stc] uses the expression "local object" in several places, without ever defining it. Presumably, what is meant is "an object declared at block scope", but this should be said explicitly.

  In a recent discussion in comp.lang.c++.moderated, on poster interpreted "local objects" as including temporaries. This would require them to live until the end of the block in which they are created, which contradicts 6.7.7 [class.temporary]. If temporaries are covered by this section, and the statement in 6.7.5 [basic.stc] seems to suggest, and they aren't local objects, then they must have static storage duration, which isn't right either. I propose adding a fourth storage duration to the list after 6.7.5 [] paragraph 1:

  • temporary storage duration And rewriting the second paragraph of this section as follows:

    Temporary storage duration is associated with objects implicitly created by the implementation, and is described in 6.7.7 [class.temporary]. Static and automatic storage durations are associated with objects defined by declarations; in the following, an object defined by a declaration with block scope is a local object. The dynamic storage duration is associated with objects created by the operator new.

Steve Adamczyk: There may well be an issue here, but one should bear in mind the difference between storage duration and object lifetime. As far as I can see, there is no particular problem with temporaries having automatic or static storage duration, as appropriate. The point of 6.7.7 [class.temporary] is that they have an unusual object lifetime.

Notes from Ocrober 2002 meeting:

It might be desirable to shorten the storage duration of temporaries to allow reuse of them. The as-if rule allows some reuse, but such reuse requires analysis, including noting whether the addresses of such temporaries have been taken.

Notes from the August, 2011 meeting:

The CWG decided that further consideration of this issue would be deferred until someone produces a paper explaining the need for action and proposing specific changes.

See also .

1682. Overly-restrictive rules on function templates as allocation functions

Section: 6.7.5.5.2 [basic.stc.dynamic.allocation] Status: open Submitter: Jason Merrill Date: 2009-03-03

Requirements for allocation functions are given in 6.7.5.5.2 [] paragraph 1:

An allocation function can be a function template. Such a template shall declare its return type and first parameter as specified above (that is, template parameter types shall not be used in the return type and first parameter type). Template allocation functions shall have two or more parameters.

There are a couple of problems with this description. First, it is instances of function templates that can be allocation functions, not the templates themselves (cf 6.7.5.5.3 [] paragraph 2, which uses the correct terminology regarding deallocation functions).

More importantly, this specification was written before template metaprogramming was understood and hence prevents use of SFINAE on the return type or parameter type to select among function template specializations. (The parallel passage for deallocation functions in 6.7.5.5.3 [] paragraph 2 shares this deficit.)

(See also .)

523. Can a one-past-the-end pointer be invalidated by deleting an adjacent object?

Section: 6.7.5.5.3 [basic.stc.dynamic.deallocation] Status: open Submitter: comp.std.c++ Date: 8 July 2005

When an object is deleted, 6.7.5.5.3 [basic.stc.dynamic.deallocation] says that the deallocation “[renders] invalid all pointers referring to any part of the deallocated storage.” According to 6.8.4 [] paragraph 3, a pointer whose address is one past the end of an array is considered to point to an unrelated object that happens to reside at that address. Does this need to be clarified to specify that the one-past-the-end pointer of an array is not invalidated by deleting the following object? (See also 7.6.2.9 [] paragraph 4, which also mentions that the system deallocation function renders a pointer invalid.)

2434. Mandatory copy elision vs non-class objects

Section: 6.7.7 [class.temporary] Status: open Submitter: Richard Smith Date: 2019-09-30

In the following example,

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

73

a must be directly initialized in the return statement of f() because the exception permitting temporaries for function arguments and return types in 6.7.7 [] paragraph 3 applies only to certain class types:

When an object of class type X is passed to or returned from a function, if X has at least one eligible copy or move constructor (11.4.4 [special]), each such constructor is trivial, and the destructor of X is either trivial or deleted, implementations are permitted to create a temporary object to hold the function parameter or result object. The temporary object is constructed from the function argument or return value, respectively, and the function's parameter or return object is initialized as if by using the eligible trivial constructor to copy the temporary (even if that constructor is inaccessible or would not be selected by overload resolution to perform a copy or move of the object). [Note: This latitude is granted to allow objects of class type to be passed to or returned from functions in registers. —end note]

This requirement is observable, since the destructor of X in the example could inspect the value of a.

The permissions in this paragraph should also apply to all non-class types.

2666. Lifetime extension through static_cast

Section: 6.7.7 [class.temporary] Status: open Submitter: Brian Bi Date: 2022-10-17

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

74

For

1, a temporary object is materialized and the reference binds to the result of the materialization conversion. This results in lifetime extension per 6.7.7 [] bullet 6.1.

For

2, 6.7.7 [] bullet 6.6 requires the cast to convert "without a user-defined conversion", but S(0) is such.

For

3, a user-defined conversion is clearly required.

However, implementations treat all three cases the same and do extend the lifetime of the temporary.

Suggested resolution:

Change in 6.7.7 [] bullet 6.6 as follows:

... a const_cast (7.6.1.11 [expr.const.cast]), static_cast (7.6.1.9 [expr.static.cast]), dynamic_cast (7.6.1.7 [expr.dynamic.cast]), or reinterpret_cast (7.6.1.10 [expr.reinterpret.cast])

converting, without a user-defined conversion, a glvalue operand that is one of these expressions to a glvalue that refers to the object designated by the operand, or to its complete object or a subobject thereof, where

the cast does not invoke a user-defined conversion, or the cast invokes a user-defined conversion that yields a prvalue, and the glvalue result of the cast is bound directly (9.4.4 [dcl.init.ref]) to that prvalue,

• ...

350. signed char underlying representation for objects

Section: 6.8 [basic.types] Status: open Submitter: Noah Stein Date: 16 April 2002 Liaison: WG14

Sent in by David Abrahams:

Yes, and to add to this tangent, 6.8.2 [] paragraph 1 states "Plain char, signed char, and unsigned char are three distinct types." Strangely, 6.8 [] paragraph 2 talks about how "... the underlying bytes making up the object can be copied into an array of char or unsigned char. If the content of the array of char or unsigned char is copied back into the object, the object shall subsequently hold its original value." I guess there's no requirement that this copying work properly with signed chars!

Notes from October 2002 meeting:

We should do whatever C99 does. 6.5p6 of the C99 standard says "array of character type", and "character type" includes signed char (6.2.5p15), and 6.5p7 says "character type". But see also 6.2.6.1p4, which mentions (only) an array of unsigned char.

Proposed resolution (April 2003):

Change 6.7.3 [] bullet 5.3 from

• the pointer is used as the operand of a static_cast (7.6.1.9 [expr.static.cast]) (except when the conversion is to void*, or to void* and subsequently to char*, or unsigned char*).

to

• the pointer is used as the operand of a static_cast (7.6.1.9 [expr.static.cast]) (except when the conversion is to void*, or to void* and subsequently to a pointer to byte-character type).

Change 6.7.3 [] bullet 6.3 from

• the lvalue is used as the operand of a static_cast (7.6.1.9 [expr.static.cast]) (except when the conversion is ultimately to char& or unsigned char&), or

to

• the lvalue is used as the operand of a static_cast (7.6.1.9 [expr.static.cast]) (except when the conversion is ultimately to a reference to byte-character type), or

Change the beginning of 6.8 [] paragraph 2 from

For any object (other than a base-class subobject) of POD type T, whether or not the object holds a valid value of type T, the underlying bytes (6.7.1 [intro.memory]) making up the object can be copied into an array of char or unsigned char.

to

For any object (other than a base-class subobject) of POD type T, whether or not the object holds a valid value of type T, the underlying bytes (6.7.1 [intro.memory]) making up the object can be copied into an array of byte-character type.

Add the indicated text to 6.8.2 [] paragraph 1:

Objects declared as characters (char) shall be large enough to store any member of the implementation's basic character set. If a character from this set is stored in a character object, the integral value of that character object is equal to the value of the single character literal form of that character. It is implementation-defined whether a char object can hold negative values. Characters can be explicitly declared unsigned or signed. Plain char, signed char, and unsigned char are three distinct types, called the byte-character types. A char, a signed char, and an unsigned char occupy the same amount of storage and have the same alignment requirements (6.8 [basic.types]); that is, they have the same object representation. For byte-character types, all bits of the object representation participate in the value representation. For unsigned byte-character types, all possible bit patterns of the value representation represent numbers. These requirements do not hold for other types. In any particular implementation, a plain char object can take on either the same values as a signed char or an unsigned char; which one is implementation-defined.

Change 7.2.1 [] paragraph 15 last bullet from

• a char or unsigned char type.

to

• a byte-character type.

Notes from October 2003 meeting:

It appears that in C99 signed char may have padding bits but no trap representation, whereas in C++ signed char has no padding bits but may have -0. A memcpy in C++ would have to copy the array preserving the actual representation and not just the value.

March 2004: The liaisons to the C committee have been asked to tell us whether this change would introduce any unnecessary incompatibilities with C.

Notes from October 2004 meeting:

The C99 Standard appears to be inconsistent in its requirements. For example, 6.2.6.1 paragraph 4 says:

The value may be copied into an object of type unsigned char [n] (e.g., by memcpy); the resulting set of bytes is called the object representation of the value.

On the other hand, 6.2 paragraph 6 says,

If a value is copied into an object having no declared type using memcpy or memmove, or is copied as an array of character type, then the effective type of the modified object for that access and for subsequent accesses that do not modify the value is the effective type of the object from which the value is copied, if it has one.

Mike Miller will investigate further.

Proposed resolution (February, 2010):

1. Change 6.7.3 [] bullet 5.4 as follows:

   ...The program has undefined behavior if:

• ...

2. Change 6.7.3 [] bullet 6.4 as follows:

   ...The program has undefined behavior if:

• ...

3. Change 6.8 [] paragraph 2 as follows:

   For any object (other than a base-class subobject) of trivially copyable type T, whether or not the object holds a valid value of type T, the underlying bytes (6.7.1 [intro.memory]) making up the object can be copied into an array of char or unsigned char a byte-character type (6.8.2 [basic.fundamental]).39 If the content of the that array of char or unsigned char is copied back into the object, the object shall subsequently hold its original value. [Example:...

4. Change 6.8.2 [] paragraph 1 as follows:

   ...Characters can be explicitly declared unsigned or signed. Plain char, signed char, and unsigned char are three distinct types, called the byte-character types. A char, a signed char, and an unsigned char occupy the same amount of storage and have the same alignment requirements (6.7.6 [basic.align]); that is, they have the same object representation. For byte-character types, all bits of the object representation participate in the value representation. For unsigned character types unsigned char, all possible bit patterns of the value representation represent numbers...

5. Change 7.2.1 [] paragraph 15 final bullet as follows:

   If a program attempts to access the stored value of an object through an lvalue of other than one of the following types the behavior is undefined 52

6. Change 6.7.6 [] paragraph 6 as follows:

   The alignment requirement of a complete type can be queried using an alignof expression (7.6.2.6 [expr.alignof]). Furthermore, the byte-character types (6.8.2 [basic.fundamental]) char, signed char, and unsigned char shall have the weakest alignment requirement. [Note: this enables the byte-character types to be used as the underlying type for an aligned memory area (9.12.2 [dcl.align]). —end note]

7. Change 7.6.2.8 [] paragraph 10 as follows:

   ...For arrays of char and unsigned char a byte-character type (6.8.2 [basic.fundamental]), the difference between the result of the new-expression and the address returned by the allocation function shall be an integral multiple of the strictest fundamental alignment requirement (6.7.6 [basic.align]) of any object type whose size is no greater than the size of the array being created. [Note: Because allocation functions are assumed to return pointers to storage that is appropriately aligned for objects of any type with fundamental alignment, this constraint on array allocation overhead permits the common idiom of allocating byte-character arrays into which objects of other types will later be placed. —end note]

Notes from the March, 2010 meeting:

The CWG was not convinced that there was a need to change the existing specification at this time. Some were concerned that there might be implementation difficulties with giving signed char the requisite semantics; implementations for which that is true can currently make char equivalent to unsigned char and avoid those problems, but the suggested change would undermine that strategy.

Additional note, November, 2014:

There is now the term “narrow character type” that should be used instead of “byte-character type”.

146. Floating-point zero

Section: 6.8.2 [basic.fundamental] Status: open Submitter: Andy Sawyer Date: 23 Jul 1999

6.8.2 [basic.fundamental] does not impose a requirement on the floating point types that there be an exact representation of the value zero. This omission is significant in 7.3.14 [] paragraph 1, in which any non-zero value converts to the bool value true.

Suggested resolution: require that all floating point types have an exact representation of the value zero.

251. How many signed integer types are there?

Section: 6.8.2 [basic.fundamental] Status: open Submitter: Beman Dawes Date: 18 Oct 2000

6.8.2 [] paragraph 2 says that

There are four signed integer types: "signed char", "short int", "int", and "long int."

This would indicate that const int is not a signed integer type.

Notes from the June, 2016 meeting:

See .

2544. Address of past-the-end of a potentially-overlapping subobject

Section: 6.8.4 [basic.compound] Status: open Submitter: Jiang An Date: 2022-02-20

6.8.4 [] paragraph 3 states:

A value of a pointer type that is a pointer to or past the end of an object represents the address of the first byte in memory (6.7.1 [intro.memory]) occupied by the object [ Footnote: ... ] or the first byte in memory after the end of the storage occupied by the object, respectively.

A potentially-overlapping subobject of type T may occupy fewer bytes than indicated by sizeof(T), yet pointer arithmetic will only consider sizeof(T), not the number of actually occupied bytes. For example,

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

75

On a popular implementation, z is actually put into the tail padding of x, and thus &S().x + 1 does not actually point to "the first byte in memory after the end of the storage occupied by" x.

Suggested resolution (amended 2022-03-10):

Change in 6.8.4 [] paragraph 3 as follows:

A value V of a pointer type that is a pointer to or past the end of an object represents the address of the first byte in memory (6.7.1 [intro.memory]) occupied by the object A as follows: If V is a pointer to an object, A is the address of the object as specified in 6.7.2 [intro.object] [ Footnote: ... ] or the first byte in memory after the end of the storage occupied by the object, respectively. If V is a pointer past the end of an object that is not a potentially-overlapping subobject, A is the address of the first byte in memory after the end of the storage occupied by the object. If V is a pointer past the end of a potentially-overlapping subobject, A is an implementation-defined choice of an address within the complete object or the address of the first byte in memory after the end of the storage occupied by the complete object. If V is a null pointer value or an invalid pointer value, V does not represent an address.

698. The definition of “sequenced before” is too narrow

Section: 6.9.1 [intro.execution] Status: open Submitter: Jens Maurer Date: 13 July, 2008

According to 6.9.1 [] paragraph 14, “sequenced before” is a relation between “evaluations.” However, 6.9.3.3 [] paragraph 3 says,

If the completion of the initialization of a non-local object with static storage duration is sequenced before a call to std::atexit (see , 17.5 [support.start.term]), the call to the function passed to std::atexit is sequenced before the call to the destructor for the object. If a call to std::atexit is sequenced before the completion of the initialization of a non-local object with static storage duration, the call to the destructor for the object is sequenced before the call to the function passed to std::atexit. If a call to std::atexit is sequenced before another call to std::atexit, the call to the function passed to the second std::atexit call is sequenced before the call to the function passed to the first std::atexit call.

Except for the calls to std::atexit, these events do not correspond to “evaluation” of expressions that appear in the program. If the “sequenced before” relation is to be applied to them, a more comprehensive definition is needed.

1842. Unevaluated operands and “carries a dependency”

Section: 6.9.2 [intro.multithread] Status: open Submitter: Hans Boehm Date: 2014-01-23 Liaison: SG1

According to 6.9.2 [] paragraph 9,

An evaluation A carries a dependency to an evaluation B if the value of A is used as an operand of B, unless: ... A is the left operand of a built-in logical AND (&&, see 7.6.14 [expr.log.and]) or logical OR (||, see 7.6.15 [expr.log.or]) operator, or ...

The intent is that this does not apply to the second operands of such operators if the first operand is such that they are not evaluated, but the wording is not clear to that effect. (A similar question applies to the non-selected operand of the conditional operator ?:.)

Notes from the October, 2015 meeting:

It appears likely that the text involved will be removed by a revision to the memory_order_consume specification.

Notes from the February, 2016 meeting:

Action on this issue will be deferred until the specification for memory_order_consume is complete; it should not currently be used.

2297. Unclear specification of atomic operations

Section: 6.9.2.2 [intro.races] Status: open Submitter: Kazutoshi Satoda Date: 2016-01-21

It is not sufficiently clear that the only atomic operations are the ones defined in 33.5 [atomics] by the library. The intent is that no accesses are atomic unless the Standard describes them as such.

An additional problem is that, e.g., new and delete are defined to be synchronization operations, but they are not defined in Clauses 33.5 [atomics] and Clause 33 [thread].

Suggested resolution:

Change 6.9.2.2 [] paragraph 3 as follows:

The library defines a number the set of atomic operations (33.5 [atomics]) and operations on mutexes (Clause 33 [thread]) that. Some of these, and some other library operations, such as those on mutexes ( Clause 33 [thread]) are specially identified as synchronization operations. These operations...

Notes from the April, 2017 teleconference:

CWG determined that this issue should be handled editorially; it will be in "review" status until the change has been made and verified. See editorial issue 1611.

Additional notes, October, 2018:

This is also . SG1 has requested a paper to deal with this issue, so it is no longer considered editorial.

2298. Actions and expression evaluation

Section: 6.9.2.2 [intro.races] Status: open Submitter: Kazutoshi Satoda Date: 2016-01-21 Liaison: SG1

Section 6.9.2.2 [intro.races] uses the terms “action” and “expression evaluation” interchangeably. “Sequenced before” is defined on expression evaluations. Probably none of those is correct.

We should really be talking about individual accesses to “memory locations”. Talking about larger “expression evaluations” is incorrect, since they may include internal synchronization. Thus concurrent evaluation of large conflicting expression evaluations may not actually correspond to a data race. I'm not sure what term we should be using instead of “expression evaluation” to denote such individual accesses. Call it X for now.

There is also an issue with the fact that “sequenced before” is defined on expression evaluation. “Sequenced before” should also be defined on Xs. It doesn't make any sense to talk about “sequenced before” ordering on two evaluations when one includes the other. Whenever we say “A is sequenced before B”, we probably really mean that all Xs in A are sequenced before all Xs in B. We could probably just include a blanket statement to that effect.

Additional notes (April, 2022)

Forwarded to SG1 with paper issue 1234, reflecting the former "concurrency" status of this issue.

371. Interleaving of constructor calls

Section: 6.9.3.2 [basic.start.static] Status: open Submitter: Matt Austern Date: 7 August 2002

Is a compiler allowed to interleave constructor calls when performing dynamic initialization of nonlocal objects? What I mean by interleaving is: beginning to execute a particular constructor, then going off and doing something else, then going back to the original constructor. I can't find anything explicit about this in 6.9.3.2 [basic.start.static].

I'll present a few different examples, some of which get a bit wild. But a lot of what this comes down to is exactly what the standard means when it talks about the order of initialization. If it says that some object x must be initialized before a particular event takes place, does that mean that x's constructor must be entered before that event, or does it mean that it must be exited before that event? If object x must be initialized before object y, does that mean that x's constructor must exit before y's constructor is entered?

(The answer to that question might just be common sense, but I couldn't find an answer in 6.9.3.2 [basic.start.static]. Actually, when I read 6.9.3.2 [basic.start.static] carefully, I find there are a lot of things I took for granted that aren't there.)

OK, so a few specific scenerios.

1. We have a translation unit with nonlocal objects A and B, both of which require dynamic initialization. A comes before B. A must be initialized before B. May the compiler start to construct A, get partway through the constructor, then construct B, and then go back to finishing A?
2. We have a translation unit with nonlocal object A and function f. Construction of A is deferred until after the first statement of main. A must be constructed before the first use of f. Is the compiler permitted to start constructing A, then execute f, then go back to constructing A?
3. We have nonlocal objects A and B, in two different translation units. The order in which A and B are constructed is unspecified by the Standard. Is the compiler permitted to begin constructing A, then construct B, then finish A's constructor? Note the implications of a 'yes' answer. If A's and B's constructor both call some function f, then the call stack might look like this: const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

   assert(&r == &a);   // allowed not to fail?  
   

   } 76 The implication of a 'yes' answer for users is that any function called by a constructor, directly or indirectly, must be reentrant.
4. This last example is to show why a 'no' answer to

   3 might be a problem too. New scenerio: we've got one translation unit containing a nonlocal object A and a function f1, and another translation unit containing a nonlocal object B and a function f2. A's constructor calls f2. Initialization of A and B is deferred until after the first statement of main(). Someone in main calls f1. Question: is the compiler permitted to start constructing A, then go off and construct B at some point before f2 gets called, then go back and finish constructing A? In fact, is the compiler required to do that? We've got an unpleasant tension here between the bad implications of a 'yes' answer to

   3, and the explicit requirement in 6.9.3.2 [] paragraph 3.

At this point, you might be thinking we could avoid all of this nonsense by removing compilers' freedom to defer initialization until after the beginning of main(). I'd resist that, for two reasons. First, it would be a huge change to make after the standard has been out. Second, that freedom is necessary if we want to have support for dynamic libraries. I realize we don't yet say anything about dynamic libraries, but I'd hate to make decisions that would make such support even harder.

1294. Side effects in dynamic/static initialization

Section: 6.9.3.2 [basic.start.static] Status: open Submitter: Daniel Krügler Date: 2011-04-08

According to 6.9.3.2 [] paragraph 3,

An implementation is permitted to perform the initialization of a non-local variable with static storage duration as a static initialization even if such initialization is not required to be done statically, provided that the dynamic version of the initialization does not change the value of any other object of namespace scope prior to its initialization, and the static version of the initialization produces the same value in the initialized variable as would be produced by the dynamic initialization if all variables not required to be initialized statically were initialized dynamically.

This does not consider side effects of the initialization in this determination, only the values of namespace-scope variables.

CWG 2022-11-11

The precise normative identification of side effects relevant for the rule remains open. An approach similar to the constexpr model of considering the transitive hull of evaluations might be applicable.

1659. Initialization order of thread_local template static data members

Section: 6.9.3.2 [basic.start.static] Status: open Submitter: Richard Smith Date: 2013-04-14

According to 6.9.3.2 [] paragraph 5,

It is implementation-defined whether the dynamic initialization of a non-local variable with static or thread storage duration is done before the first statement of the initial function of the thread. If the initialization is deferred to some point in time after the first statement of the initial function of the thread, it shall occur before the first odr-use (6.3 [basic.def.odr]) of any variable with thread storage duration defined in the same translation unit as the variable to be initialized.

This doesn't consider that initialization of instantiations of static data members of class templates (which can be thread_local) are unordered. Presumably odr-use of such a static data member should not trigger the initialization of any thread_local variable other than that one?

2684. thread_local dynamic initialization

Section: 6.9.3.3 [basic.start.dynamic] Status: open Submitter: Jason Merrill Date: 2023-01-06

Subclause 6.9.3.3 [] paragraph 7 specifies:

It is implementation-defined whether the dynamic initialization of a non-block non-inline variable with thread storage duration is sequenced before the first statement of the initial function of a thread or is deferred. If it is deferred, the initialization associated with the entity for thread t is sequenced before the first non-initialization odr-use by t of any non-inline variable with thread storage duration defined in the same translation unit as the variable to be initialized. ...

How does the rule quoted above affect variables declared constinit? For example:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

77

Clang and gcc do not emit suitable wrapper code to allow for deferred initialization of x, which is non-conforming. Should this be allowed?

Suggested resolution:

Change in 6.9.3.3 [] paragraph 7 as follows:

It is implementation-defined whether the dynamic initialization of a non-block non-inline variable with thread storage duration is sequenced before the first statement of the initial function of a thread or is deferred. If it is deferred, the initialization associated with the entity for thread t is sequenced before the first non-initialization odr-use by t of any non-inline variable with thread storage duration and dynamic initialization defined in the same translation unit as the variable to be initialized. ...

2438. Problems in the specification of qualification conversions

Section: 7.3.6 [conv.qual] Status: open Submitter: Richard Smith Date: 2019-08-14

1. A type has multiple cv-decompositions, and 7.3.6 [] paragraph 3 does not say which one to use when determining the cv-combined type. Should this be the longest decomposition that works, i.e., the greatest n for which you can decompose both types? (We used to refer to the cv-qualification signature, which implicitly meant to take the longest decomposition.)
2. When computing the cv-combined types of two types T1 and T2, if U1 and U2 are different, shouldn't we add const to all layers above that in the type?
3. cv03 is left unspecified by the wording in paragraph 3.
4. We are too eager to replace a Pi3 with “array of unknown bound of”. That should only happen if both Pi1 and Pi2 are array types, or we end up not forming a type T3 that is similar to T1. For example, the cv-combined type of int** and const int (*)[], when decomposed with n == 2, is required to be const int (*)[] by the bulleted rules, and that type is not similar to the original T1.
5. In various places, we have operators that say, “if one operand is of pointer type, apply array-to-pointer conversions, pointer conversions, and qualification conversions to bring the two operands to their composite pointer type,” but that doesn't work, because the definition of composite pointer type can't cope with one operand being a pointer and the other being an array. We either need to define the composite pointer type of a pointer and an array (and, if that's done in terms of computing the cv-combined type, be careful to ensure that computing the cv-combined type actually works in that case) or to perform the array-to-pointer conversion before considering the composite pointer type.

2737. Temporary lifetime extension for reference init-captures

Section: 7.5.5.3 [expr.prim.lambda.capture] Status: open Submitter: Tomasz Kamiński Date: 2023-05-23

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

78

Subclause 7.5.5.3 [] paragraph 6 specifies:

An init-capture inhabits the lambda scope (6.4.5 [basic.scope.lambda]) of the lambda-expression. An init-capture without ellipsis behaves as if it declares and explicitly captures a variable of the form “auto init-capture ;”, except that: if the capture is by copy (see below), the non-static data member declared for the capture and the variable are treated as two different ways of referring to the same object, which has the lifetime of the non-static data member, and no additional copy and destruction is performed, and if the capture is by reference, the variable's lifetime ends when the closure object's lifetime ends.

It is unclear whether the temporary returned by f() is lifetime-extended by being bound to a reference init-capture.

There is implementation divergence: gcc rejects the example; clang accepts and extends the lifetime of the temporary; MSVC and EDG accept and do not extend the lifetime.

Possible resolution:

Change in 7.5.5.3 [] paragraph 6 as follows:

An init-capture inhabits the lambda scope (6.4.5 [basic.scope.lambda]) of the lambda-expression. An init-capture without ellipsis behaves as if it declares and explicitly captures a variable of the form “auto init-capture ;”, except that: if the capture is by copy (see below), the non-static data member declared for the capture and the variable are treated as two different ways of referring to the same object, which has the lifetime of the non-static data member, and no additional copy and destruction is performed, and if the capture is by reference and the reference would bind to a temporary, the program is ill-formed, and

• if the capture is by reference, the variable's lifetime ends when the closure object's lifetime ends.

2560. Parameter type determination in a requirement-parameter-list

Section: 7.5.7.1 [expr.prim.req.general] Status: open Submitter: Daveed Vandevoorde Date: 2020-01-21 Liaison: EWG

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

79

This example is only well-formed if the type of the parameter p is adjusted to T*, but the provisions in 9.3.4.6 [] paragraph 5 cover function parameters only.

One option is to specify application of the same adjustments as for function parameters. Another option is to specify rules that arguably are more useful in a requires-expression.

Suggested resolution:

Change in 7.5.7.1 [] paragraph 3 as follows:

A requires-expression may introduce local parameters using a parameter-declaration-clause (9.3.4.6 [dcl.fct]). A local parameter of a requires-expression shall not have a default argument. The type of such a parameter is determined as specified for a function parameter in 9.3.4.6 [dcl.fct]. These parameters have no linkage, storage, or lifetime; they are only used as notation for the purpose of defining requirements. The parameter-declaration-clause of a requirement-parameter-list shall not terminate with an ellipsis.

[Example 2:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() { assert(&r == &a); // allowed not to fail? }

80 —end example]

CWG 2023-06-17

There are arguments in favor of both options. Forwarded to EWG with paper issue 1582.

2739. Nested requirement not a constant expression

Section: 7.5.7.5 [expr.prim.req.nested] Status: open Submitter: Barry Revzin Date: 2022-09-20

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

81

clang accepts; gcc, MSVC, and EDG all consider

1 to be ill-formed. Subclause 7.5.7.5 [] paragraph 1 specifies:

The constraint-expression shall be satisfied (13.5.3 [temp.constr.decl]) by the substituted template arguments, if any. Substitution of template arguments into a nested-requirement does not result in substitution into the constraint-expression other than as specified in 13.5.2 [temp.constr.constr].

Neither C nor C are saisfied, but it is unclear whether those two cases should be treated differently. Subclause 13.5.2.3 [] paragraph 3 might be relevant:

To determine if an atomic constraint is satisfied, the parameter mapping and template arguments are first substituted into its expression. If substitution results in an invalid type or expression, the constraint is not satisfied. Otherwise, the lvalue-to-rvalue conversion (7.3.2 [conv.lval]) is performed if necessary, and E shall be a constant expression of type bool.

An example from the standard library is:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

82

Is the bool_constant part necessary to ensure that G::min() < G::max() is a constant expression?

2284. Sequencing of braced-init-list arguments

Section: 7.6.1.3 [expr.call] Status: open Submitter: Richard Smith Date: 2016-06-30

As of P0400R0 (Wording for Order of Evaluation of Function Arguments), we have in subclause 7.6.1.3 [] paragraph 8:

The postfix-expression is sequenced before each expression in the expression-list and any default argument. The initialization of a parameter, including every associated value computation and side effect, is indeterminately sequenced with respect to that of any other parameter.

What about the case when the element in the expression-list is a braced-init-list rather than an expression? The braced-init-list is certainly evaluated left-to-right, but is that required to happen after we evaluate the postfix-expression?

2515. Result of a function call

Section: 7.6.1.3 [expr.call] Status: open Submitter: Andrey Erokhin Date: 2021-11-06

The editorial change referred to in the resolution of updated the terminology used to describe the return statement to allow for the fact that the operand could be a braced-init-list instead of an expression. A similar problem exists describing the result of a function call in 7.6.1.3 [] paragraph 9:

The result of a function call is the result of the possibly-converted operand of the return statement (8.7.4 [stmt.return]) that transferred control out of the called function

It's incorrect to refer to “converting” the operand when it is a braced-init-list.

2660. Confusing term "this parameter"

Section: 7.6.1.3 [expr.call] Status: open Submitter: Anoop Rana Date: 2022-11-23

Subclause 7.6.1.3 [] paragraph 7 specifies:

If the function is an implicit object member function, the this parameter of the function (7.5.2 [expr.prim.this]) is initialized with a pointer to the object of the call, converted as if by an explicit type conversion (7.6.3 [expr.cast]).

The term "this parameter" is undefined.

Suggested resolution:

Change in 7.6.1.3 [] paragraph 7 as follows:

If the function is an implicit object member function, the this implicit object parameter of the function (7.5.2 [expr.prim.this]) is initialized with a pointer to the object of the call, converted as if by an explicit type conversion (7.6.3 [expr.cast]).

2688. Calling explicit object member functions

Section: 7.6.1.3 [expr.call] Status: open Submitter: Matthew House Date: 2023-01-16

Subclause 7.6.1.3 [expr.call] paragraphs 1 and 2 do not properly handle explicit object member functions. Such a function can be called via a function pointer, via an lvalue obtained by dereferencing a function pointer, and via a class member access expression.

914. Value-initialization of array types

Section: 7.6.1.4 [expr.type.conv] Status: open Submitter: Gabriel Dos Reis Date: 10 June, 2009 Liaison: EWG

Although value-initialization is defined for array types and the () initializer is permitted in a mem-initializer naming an array member of a class, the syntax T() (where is an array type) is explicitly forbidden by 7.6.1.4 [] paragraph 2. This is inconsistent and the syntax should be permitted.

Rationale (July, 2009):

The CWG was not convinced of the utility of this extension, especially in light of questions about handling the lifetime of temporary arrays. This suggestion needs a proposal and analysis by the EWG before it can be considered by the CWG.

EWG 2022-11-11

This is a defect; a paper is needed. This is tracked in github issue cplusplus/papers

1372.

2705. Accessing ambiguous subobjects

Section: 7.6.1.5 [expr.ref] Status: open Submitter: Davis Herring Date: 2023-02-11

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

83

There is a rule that &s be able to "be implicitly converted to a pointer to the naming class of the right operand" (11.8.3 [] paragraph 6), which correctly selects X here, but 7.6.1.5 [] bullet 6.2 merely says that

If E2 is a non-static data member [...], the expression designates the corresponding member subobject of the object designated by the first expression.

E2 (i.e. X::i) and Y::i equally denote A::i (since name lookup produces declarations), but there is no rule that indicates which A::i is selected as the "corresponding member subobject". (Note that s.X::A::i means the same as s.A::i and is ambiguous.)

Suggested resolution:

Change 11.8.3 [] paragraph 6 to actually perform the conversion it requires, possibly moving it to 7.6.1.5 [expr.ref] since it is not about access control; the definition of "naming class" in 11.8.3 [] paragraph 5 would then need to be italicized.

2748. Accessing static data members via null pointer

Section: 7.6.1.5 [expr.ref] Status: open Submitter: Tomasz Kamiński Date: 2023-06-13

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

84

The behavior of (*c).foo is clearly undefined per 7.6.1.5 [] paragraph 1:

The postfix expression before the dot or arrow is evaluated ...

However, the treatment of c->foo is less clear, because the transformation to the form (*(E1)).E2 occurs later.

Suggested resolution:

Move a part of 7.6.1.5 [] paragraph 1 to before paragraph 3 and edit as follows:

A postfix expression followed by a dot . or an arrow ->, optionally followed by the keyword template, and then followed by an id-expression, is a postfix expression. The postfix expression before the dot or arrow is evaluated; [ Footnote: ... ] the result of that evaluation, together with the id-expression, determines the result of the entire postfix expression. [Note 1: If the keyword template is used, the following unqualified name is considered to refer to a template (13.3 [temp.names]). If a simple-template-id results and is followed by a ::, the id-expression is a qualified-id. —end note]

For the first option (dot) the first expression shall be a glvalue. For the second option (arrow) the first expression shall be a prvalue having pointer type. The expression E1->E2 is converted to the equivalent form (*(E1)).E2; the remainder of 7.6.1.5 [expr.ref] will address only the first option (dot). [ Footnote: ... ]

The postfix expression before the dot is evaluated; [ Footnote: ... ] the result of that evaluation, together with the id-expression, determines the result of the entire postfix expression.

742. Postfix increment/decrement with long bit-field operands

Section: 7.6.1.6 [expr.post.incr] Status: open Submitter: Mike Miller Date: 11 November, 2008

Given the following declarations:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

85

the expressions s.sll-- < 0u and s.sll < 0u have different results. The reason for this is that s.sll-- is an rvalue of type signed long long (7.6.1.6 [expr.post.incr]), which means that the usual arithmetic conversions (Clause 7 [] paragraph 10) convert 0u to signed long long and the result is true. s.sll, on the other hand, is a bit-field lvalue, which is promoted (7.3.7 [] paragraph 3) to int; both operands of < have the same rank, so s.sll is converted to unsigned int to match the type of 0u and the result is false. This disparity seems undesirable.

282. Namespace for extended_type_info

Section: 7.6.1.8 [expr.typeid] Status: open Submitter: Jens Maurer Date: 01 May 2001

The original proposed resolution for included changing extended_type_info (7.6.1.8 [] paragraph 1, footnote 61) to std::extended_type_info. There was no consensus on whether this name ought to be part of namespace std or in a vendor-specific namespace, so the question was moved into a separate issue.

1954. typeid null dereference check in subexpressions

Section: 7.6.1.8 [expr.typeid] Status: open Submitter: David Majnemer Date: 2014-06-23

According to 7.6.1.8 [] paragraph 2,

If the glvalue expression is obtained by applying the unary * operator to a pointer69 and the pointer is a null pointer value (7.3.12 [conv.ptr]), the typeid expression throws an exception (14.2 [except.throw]) of a type that would match a handler of type std::bad_typeid exception (17.7.5 [bad.typeid]).

The footnote makes clear that this requirement applies without regard to parentheses, but it is unspecified whether it applies when the dereference occurs in a subexpression of the operand (e.g., in the second operand of the comma operator or the second or third operand of a conditional operator). There is implementation divergence on this question.

2048. C-style casts that cast away constness vs static_cast

Section: 7.6.1.9 [expr.static.cast] Status: open Submitter: Richard Smith Date: 2014-11-19

According to 7.6.1.9 [] paragraph 1,

The static_cast operator shall not cast away constness (7.6.1.11 [expr.const.cast]).

However, this phrasing is problematic in the context of a C-style cast like the following:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

86

The intent of 7.6.3 [expr.cast] is that this should be interpreted as a static_cast followed by a const_cast. However, because int* to const void* is a valid standard conversion, and 7.6.1.9 [] paragraph 7 allows static_cast to perform the inverse of a standard conversion sequence, the C-style cast is interpreted as just a static_cast without a const_cast and is thus ill-formed.

2780. reinterpret_cast to reference to function types

Section: 7.6.1.10 [expr.reinterpret.cast] Status: open Submitter: Lauri Vasama Date: 2023-08-07

Subclause 7.6.1.10 [] paragraph 11 specifies:

A glvalue of type T1, designating an object x, can be cast to the type “reference to T2” if an expression of type “pointer to T1” can be explicitly converted to the type “pointer to T2” using a reinterpret_cast. The result is that of *reinterpret_cast(p) where p is a pointer to x of type “pointer to T1”. No temporary is created, no copy is made, and no constructors (11.4.5 [class.ctor]) or conversion functions (11.4.8 [class.conv]) are called. [ Footnote: ... ]

The wording does not cover references to function type, only references to object types. All major implementations accept the following example:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

87

Possible resolution:

Change in 7.6.1.10 [] paragraph 11 as follows:

A glvalue of type T1, designating an object entity x, can be cast to the type “reference to T2” if an expression of type “pointer to T1” can be explicitly converted to the type “pointer to T2” using a reinterpret_cast. The result is that of *reinterpret_cast(p) where p is a pointer to x of type “pointer to T1”. No temporary is created, no copy is made, and no constructors (11.4.5 [class.ctor]) or conversion functions (11.4.8 [class.conv]) are called. [ Footnote: ... ]

2668. co_await in a lambda-expression

Section: 7.6.2.4 [expr.await] Status: open Submitter: Jim X Date: 2022-12-12

Subclause 7.6.2.4 [] paragraph 2 disallows an await-expression to appear in the body of a lambda-expression:

An await-expression shall appear only in a potentially-evaluated expression within the compound-statement of a function-body outside of a handler (14.1 [except.pre]). ...

This is probably unintended.

Possible resolution:

Change in 7.6.2.4 [] paragraph 2 as follows:

An await-expression shall appear only in as a potentially-evaluated expression within the compound-statement of a function-body or lambda-expression, in either case outside of a handler (14.1 [except.pre]). ...

2609. Padding in class types

Section: 7.6.2.5 [expr.sizeof] Status: open Submitter: Jim X Date: 2022-07-19

Class types may have padding, influencing the result of sizeof. It is unclear whether the placement and amount of padding is implementation-defined, unspecified, or something else. If it is unspecified, the limits of permissible behavior are unclear. Empty classes might need special consideration.

Suggested resolution:

Change in 7.6.2.5 [] paragraph 2

... When applied to a class, the result is the number of bytes in an object of that class including any padding required for placing objects of that type in an array. The amount and placement of padding in a class type is unspecified. The result of applying sizeof to a potentially-overlapping subobject is the size of the type, not the size of the subobject. [ Footnote: ... ]

267. Alignment requirement for new-expressions

Section: 7.6.2.8 [expr.new] Status: open Submitter: James Kuyper Date: 4 Dec 2000

Requirements for the alignment of pointers returned by new-expressions are given in 7.6.2.8 [] paragraph 10:

For arrays of char and unsigned char, the difference between the result of the new-expression and the address returned by the allocation function shall be an integral multiple of the most stringent alignment requirement (6.8 [basic.types]) of any object type whose size is no greater than the size of the array being created.

The intent of this wording is that the pointer returned by the new-expression will be suitably aligned for any data type that might be placed into the allocated storage (since the allocation function is constrained to return a pointer to maximally-aligned storage). However, there is an implicit assumption that each alignment requirement is an integral multiple of all smaller alignment requirements. While this is probably a valid assumption for all real architectures, there's no reason that the Standard should require it.

For example, assume that int has an alignment requirement of 3 bytes and double has an alignment requirement of 4 bytes. The current wording only requires that a buffer that is big enough for an int or a double be aligned on a 4-byte boundary (the more stringent requirement), but that would allow the buffer to be allocated on an 8-byte boundary — which might not be an acceptable location for an int.

Suggested resolution: Change "of any object type" to "of every object type."

A similar assumption can be found in 7.6.1.10 [] paragraph 7:

...converting an rvalue of type "pointer to T1" to the type "pointer to T2" (where ... the alignment requirements of T2 are no stricter than those of T1) and back to its original type yields the original pointer value...

Suggested resolution: Change the wording to

...converting an rvalue of type "pointer to T1" to the type "pointer to T2" (where ... the alignment requirements of T1 are an integer multiple of those of T2) and back to its original type yields the original pointer value...

The same change would also be needed in paragraph 9.

Additional note (June, 2022):

Subclause 6.7.6 [] paragraph 4 specifies:

... Every alignment value shall be a non-negative integral power of two.

Thus, the situation that a stricter alignment is not an integral multiple of a weaker alignment does not arise.

1628. Deallocation function templates

Section: 7.6.2.8 [expr.new] Status: open Submitter: Richard Smith Date: 2013-02-22

According to 7.6.2.8 [expr.new] paragraphs 18-20, an exception thrown during the initialization of an object allocated by a new-expression will cause a deallocation function to be called for the object's storage if a matching deallocation function can be found. The rules deal only with functions, however; nothing is said regarding a mechanism by which a deallocation function template might be instantiated to free the storage, although 6.7.5.5.3 [] paragraph 2 indicates that a deallocation function can be an instance of a function template.

One possibility for this processing might be to perform template argument deduction on any deallocation function templates; if there is a specialization that matches the allocation function, by the criteria listed in paragraph 20, that function template would be instantiated and used, although a matching non-template function would take precedence as is the usual outcome of overloading between function template specializations and non-template functions.

Another possibility might be to match non-template deallocation functions with non-template allocation functions and template deallocation functions with template allocation functions.

There is a slightly related wording problem in 7.6.2.8 [] paragraph 21:

If a placement deallocation function is called, it is passed the same additional arguments as were passed to the placement allocation function, that is, the same arguments as those specified with the new-placement syntax.

This wording ignores the possibility of default arguments in the allocation function, in which case the arguments passed to the deallocation function might be a superset of those specified in the new-placement.

(See also .)

2532. Kind of pointer value returned by new T[0]

Section: 7.6.2.8 [expr.new] Status: open Submitter: Andrey Erokhin Date: 2022-02-17

A pointer value must have one of the kinds specified in 6.8.4 [] paragraph 3:

Every value of pointer type is one of the following: a pointer to an object or function (the pointer is said to point to the object or function), or a pointer past the end of an object (7.6.6 [expr.add]), or the null pointer value for that type, or an invalid pointer value.

When allocating an array with no elements, 7.6.2.8 [] paragraph 10 is silent on the kind of pointer value returned:

When the allocated type is “array of N T” (that is, the noptr-new-declarator syntax is used or the new-type-id or type-id denotes an array type), the new-expression yields a prvalue of type “pointer to T” that points to the initial element (if any) of the array. Otherwise, let T be the allocated type; the new-expression is a prvalue of type “pointer to T” that points to the object created.

Related to that, are p and q allowed to compare equal in the following example?

const char (&r) [] = "foo";

const char a[] = {'f', 'o', 'o', '\0'}; int main() { assert(&r == &a); // allowed not to fail? }

88

Some implementations return a pointer past the array cookie for empty arrays, which can compare equal to a pointer to an object obtained from an unrelated allocation. However, if new T[0] is specified to yield a pointer to an object, this behavior violates the rule that pointers to disjoint objects with overlapping lifetimes must not compare equal.

2592. Missing definition for placement allocation/deallocation function

Section: 7.6.2.8 [expr.new] Status: open Submitter: Jim X Date: 2022-04-14

Subclause 7.6.2.8 [expr.new] has multiple references to "placement allocation function" and "placement deallocation function", but those terms are never defined. The term "usual deallocation function" is defined in 6.7.5.5.3 [] paragraph 3:

... A usual deallocation function is a deallocation function whose parameters after the first are optionally, a parameter of type std::destroying_delete_t, then optionally, a parameter of type std::size_t, [ Footnote: ... ] then

• optionally, a parameter of type std::align_val_t.

Possible resolution:

1. Split 6.7.5.5.2 [] paragraph 1 and change it as follows:

   ... The value of the first parameter is interpreted as the requested size of the allocation. A usual allocation function is an allocation function with no parameters after the first or with a single parameter of type std::align_val_t after the first.

CWG 2023-06-17

Replace "placement allocation / deallocation function" with "not a usual allocation / deallocation function".

196. Arguments to deallocation functions

Section: 7.6.2.9 [expr.delete] Status: open Submitter: Matt Austern Date: 20 Jan 2000

7.6.2.8 [] paragraph 10 says that the result of an array allocation function and the value of the array new-expression from which it was invoked may be different, allowing for space preceding the array to be used for implementation purposes such as saving the number of elements in the array. However, there is no corresponding description of the relationship between the operand of an array delete-expression and the argument passed to its deallocation function.

6.7.5.5.3 [basic.stc.dynamic.deallocation] paragraph 3 does state that

the value supplied to operator delete[](void*) in the standard library shall be one of the values returned by a previous invocation of either operator new[](std::size_t) or operator new[](std::size_t, const std::nothrow_t&) in the standard library.

This statement might be read as requiring an implementation, when processing an array delete-expression and calling the deallocation function, to perform the inverse of the calculation applied to the result of the allocation function to produce the value of the new-expression. (7.6.2.9 [] paragraph 2 requires that the operand of an array delete-expression "be the pointer value which resulted from a previous array new-expression.") However, it is not completely clear whether the "shall" expresses an implementation requirement or a program requirement (or both). Furthermore, there is no direct statement about user-defined deallocation functions.

Suggested resolution: A note should be added to 7.6.2.9 [expr.delete] to clarify that any offset added in an array new-expression must be subtracted in the array delete-expression.

2728. Evaluation of conversions in a delete-expression

Section: 7.6.2.9 [expr.delete] Status: open Submitter: Jiang An Date: 2023-05-05

Subclause 7.6.2.9 [] paragraph 4 specifies:

The cast-expression in a delete-expression shall be evaluated exactly once.

Due to the reference to the syntactic non-terminal cast-expression, it is unclear whether that includes the conversion to pointer type specified in 7.6.2.9 [] paragraph 2.

Possible resolution:

1. Change in 7.6.2.9 [] paragraph 1 and paragraph 2 as follows:

   ... The operand shall be of class type or a prvalue of pointer to object type or of class type. If of class type, the operand is contextually implicitly converted (7.3 [conv]) to a prvalue pointer to object type. [ Footnote: ... ] The converted operand is used in place of the original operand for the remainder of this subclause. The delete-expression has type void.

If the operand has a class type, the operand is converted to a pointer type by calling the above-mentioned conversion function, and the converted operand is used in place of the original operand for the remainder of this subclause. ...

2. Change in 7.6.2.9 [] paragraph 4 as follows: The cast-expression in operand of a delete-expression shall be evaluated exactly once.

2758. What is "access and ambiguity control"?

Section: 7.6.2.9 [expr.delete] Status: open Submitter: CWG Date: 2023-06-12

Subclause 7.6.2.9 [] paragraph 12 specifies:

Access and ambiguity control are done for both the deallocation function and the destructor (11.4.7 [class.dtor], 11.4.11 [class.free]).

It is unclear what that means. In particular, ambiguity checking is part of overload resolution, and access checking requires a point of reference.

Possible resolution:

1. Change in 7.6.2.9 [] paragraph 6 as follows:

   If the value of the operand of the delete-expression is not a null pointer value and the selected deallocation function (see below) is not a destroying operator delete, evaluating the delete-expression will invoke invokes the destructor (if any) for the object or the elements of the array being deleted. The destructor shall be accessible from the point where the delete-expression appears. In the case of an array, the elements will be are destroyed in order of decreasing address (that is, in reverse order of the completion of their constructor; see 11.9.3 [class.base.init]).

2. Change in 7.6.2.9 [] paragraph 10 If more than one deallocation function is found, the The deallocation function to be called is selected as follows:
3. ...

Unless the deallocation function is selected at the point of definition of the dynamic type's virtual destructor, the selected deallocation function shall be accessible from the point where the delete-expression appears.

3. Remove 7.6.2.9 [] paragraph 12: Access and ambiguity control are done for both the deallocation function and the destructor (11.4.7 [class.dtor], 11.4.11 [class.free]).

2768. Assignment to scalar with a braced-init-list

Section: 7.6.19 [expr.ass] Status: open Submitter: Shafik Yaghmour Date: 2023-07-06

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

89

1 first initializes a temporary of type E and then assigns that to e. For

2, 7.6.19 [] bullet 8.1 specifies that

2 is equivalent to

1:

A braced-init-list may appear on the right-hand side of an assignment to a scalar, in which case the initializer list shall have at most a single element. The meaning of x = {v}, where T is the scalar type of the expression x, is that of x = T{v}. The meaning of x = {} is x = T{}. ...

However, there is no syntactic hint that

2 would invoke direct-initialization, and in fact gcc, icc, and MSVC reject

2, but clang accepts.

Possible resolution:

Change in 7.6.19 [] bullet 8.1 as follows:

A braced-init-list may appear on the right-hand side of an assignment to a scalar, in which case the initializer list shall have at most a single element. The meaning of x = {v} braced-init-list is x = t, where t is some invented temporary variable declared and initialized as T t = braced-init-list, where T is the scalar type of the expression x, is that of x = T{v}. The meaning of x = {} is x = T{}. ...

1256. Unevaluated operands are not necessarily constant expressions

Section: 7.7 [expr.const] Status: open Submitter: Nikolay Ivchenkov Date: 2011-03-08

The current definition of constant expressions appears to make unevaluated operands constant expressions; for example, new char[10] would seem to be a constant expression if it appears as the operand of sizeof. This seems wrong.

1626. constexpr member functions in brace-or-equal-initializers

Section: 7.7 [expr.const] Status: open Submitter: Daveed Vandevoorde Date: 2013-02-19

The Standard should make clear that a constexpr member function cannot be used in a constant expression until its class is complete. For example:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

90

Current implementations accept this, although they reject the corresponding non-template case:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

91

Presumably the template case should be handled consistently with the non-template case.

2192. Constant expressions and order-of-eval undefined behavior

Section: 7.7 [expr.const] Status: open Submitter: Peter Sommerlad Date: 2015-10-27

Notes from the November, 2016 meeting:

CWG did not wish to require implementations to detect this kind of undefined behavior in determining whether an expression is constant or not, but an implementation should be permitted to reject such expressions. These should be indeterminately sequenced, not unsequenced.

2301. Value-initialization and constexpr constructor evaluation

Section: 7.7 [expr.const] Status: open Submitter: Daveed Vandevoorde Date: 2016-04-18

Consider the following example:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

92

Value-initialization of the object created by B() zero-initializes the object (9.4 [] bullet 8.2), which should mean that the ++x in the mem-initilizer for A operates on a zero-initialized object, but current implementations reject this code as non-constant. It is not clear what in the current wording justifies this treatment.

2456. Viable user-defined conversions in converted constant expressions

Section: 7.7 [expr.const] Status: open Submitter: Mike Miller Date: 2020-08-17

Consider an example like the following:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

93

According to 9.3.4.5 [] paragraph 1, the array bound expression

shall be a converted constant expression of type std::size_t (7.7 [expr.const]).

The user-defined conversion to float would involve a floating-integral conversion (7.3.11 [conv.fpint]; however, such a conversion is not permitted by the list of acceptable conversions in 7.7 [] paragraph 10:

A converted constant expression of type T is an expression, implicitly converted to type T, where the converted expression is a constant expression and the implicit conversion sequence contains only user-defined conversions, lvalue-to-rvalue conversions (7.3.2 [conv.lval]), array-to-pointer conversions (7.3.3 [conv.array]), function-to-pointer conversions (7.3.4 [conv.func]), qualification conversions (7.3.6 [conv.qual]), integral promotions (7.3.7 [conv.prom]), integral conversions (7.3.9 [conv.integral]) other than narrowing conversions (9.4.5 [dcl.init.list]), null pointer conversions (7.3.12 [conv.ptr]) from std::nullptr_t, null member pointer conversions (7.3.13 [conv.mem]) from std::nullptr_t, and function pointer conversions (7.3.14 [conv.fctptr]), and where the reference binding (if any) binds directly.

It is not clear whether this list is intended to restrict the set of viable user-defined conversions, and there is implementation divergence on this point: clang accepts the example above, while g++ rejects it, presumably on the basis of an ambiguous conversion.

Notes from the August, 2020 teleconference:

No direction was established pending information about why the example is accepted by clang.

Additional note, December, 2020:

The clang behavior turns out to have been an oversight, corrected in the current version, so the example is now rejected by both compilers. However, it is unclear that this is desirable. In particular, given the example above, a can be used without error as a bit-field width, as an enumerator value, and as the operand of alignas. Presumably the difference between these integral constant expression contexts and an array bound is the fact that the target type is known to be size_t. However, both bit-field widths and alignas operands are also required to be non-negative. Furthermore, the definition of an “erroneous” array bound in 7.6.2.8 [] paragraph 9 goes to awkward lengths to check for negative values as the result of user-defined conversions, which might argue in favor of reconsidering the converted constant expression treatment of array bounds.

Notes from the February, 2021 teleconference:

CWG agreed with the considerations in the December, 2020 note, feeling that the difference in treatment between integral constant expressions and a converted constant expression to a specific integral type is somewhat gratuitous. However, it was felt that code like that of the example was unlikely to occur often in real-world code.

2536. Partially initialized variables during constant initialization

Section: 7.7 [expr.const] Status: open Submitter: Barry Revzin Date: 2022-02-21 Liaison: EWG

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

94

The treatment of this example changed with P1331R2 (Permitting trivial default initialization in constexpr contexts), adopted 2019-07. Prior to this paper, the default constructor of A was not constexpr because it left a data member uninitialized. With paper P1331, the restriction was shifted to reading uninitialized objects during constant evaluation, and the variable a now satisfies the requirements for "constant-initialized" in 7.7 [] paragraph 2:

A variable or temporary object o is constant-initialized if either it has an initializer or its default-initialization results in some initialization being performed, and the full-expression of its initialization is a constant expression when interpreted as a constant-expression, except that if o is an object, that full-expression may also invoke constexpr constructors for o and its subobjects even if those objects are of non-literal class types.

Zero-initialization is not performed prior to constant-initialization per 6.9.3.2 [] paragraph 2:

Constant initialization is performed if a variable or temporary object with static or thread storage duration is constant-initialized (7.7 [expr.const]). If constant initialization is not performed, a variable with static storage duration (6.7.5.2 [basic.stc.static]) or thread storage duration (6.7.5.3 [basic.stc.thread]) is zero-initialized (9.4 [dcl.init]). Together, zero-initialization and constant initialization are called static initialization; all other initialization is dynamic initialization.

Thus,

1 is valid and a is statically initialized, but a.y would remain uninitialized, which is surprising for an object with static storage duration.

Current implementations diagnose an error at

1, because the variable a is actually not considered to be constant-initialized.

This issue is closely related to .

Suggested resolution [SUPERSEDED]:

Change in 7.7 [] paragraph 2:

A variable or temporary object o is constant-initialized if either it has an initializer or its default-initialization results in some initialization being performed, and every non-variant non-static data member and base class subobject is initialized (11.9.3 [class.base.init]), and

• the full-expression of its initialization is a constant expression when interpreted as a constant-expression, except that if o is an object, that full-expression may also invoke constexpr constructors for o and its subobjects even if those objects are of non-literal class types.

Alternative suggested resolution (March, 2022) [SUPERSEDED]:

Change in 7.7 [] paragraph 11 as follows:

A constant expression is either a glvalue core constant expression that refers to an entity that is a permitted result of a constant expression (as defined below), or a prvalue core constant expression whose value satisfies the following constraints: if the value is an object of class type, each non-static data member of reference type refers to an entity that is a permitted result of a constant expression, if the value is of pointer type, it contains the address of an object with static storage duration, the address past the end of such an object (7.6.6 [expr.add]), the address of a non-immediate function, or a null pointer value, if the value is of pointer-to-member-function type, it does not designate an immediate function, and if the value is an object of class or array type, each subobject is initialized (11.9.3 [class.base.init]) and satisfies these constraints for the value.

Notes from the November, 2022 meeting

CWG preferred to zero-initialize a.y in the example, and keep

1 well-formed.

Possible resolution:

Change in 6.9.3.2 [] paragraph 2 as follows:

Constant initialization is performed if a variable or temporary object with static or thread storage duration is constant-initialized (7.7 [expr.const]). If constant initialization is not performed, a A variable with static storage duration (6.7.5.2 [basic.stc.static]) or thread storage duration (6.7.5.3 [basic.stc.thread]) or a subobject thereof is zero-initialized (9.4 [dcl.init]) if constant initialization is not performed or if it does not initialize that subobject. Together, zero-initialization and constant initialization are called static initialization; all other initialization is dynamic initialization. All static initialization strongly happens before (6.9.2.2 [intro.races]) any dynamic initialization.

CWG 2022-12-02

The resolution shown above would leave padding bits uninitialized. In contrast, zero-initialization does set padding bits to 0 to possibly facilitate memcmp. Additional example:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

95

2022-12-03

Forwarded to EWG with cplusplus/papers

1380.

Additional notes (January, 2023)

The standard does not guarantee stable results when reading padding bits, i.e. bits that are not part of the value representation of some in-lifetime object. In C, explicit rules keep padding bits stable; they are allowed to change only if a store to any class member occurs.

2545. Transparently replacing objects in constant expressions

Section: 7.7 [expr.const] Status: open Submitter: Richard Smith Date: 2022-03-05

7.7 [] paragraph 6 specifies that std::construct_at can be used during constant evaluation:

Similarly, the evaluation of a call to std::construct_at or std::ranges::construct_at does not disqualify E from being a core constant expression unless the first argument, of type T*, does not point to storage allocated with std::allocator or to an object whose lifetime began within the evaluation of E, or the evaluation of the underlying constructor call disqualifies E from being a core constant expression.

Apparently, implementations are required to track whether an object is transparently replaceable (6.7.3 [] paragraph 8) during constant evaluation to satisfy 7.7 [] bullet 5.8, which requires that undefined behavior be detected and rejected during constant evaluation:

... an operation that would have undefined behavior as specified in Clause 4 through Clause 15;

• ...

For example,

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

96

No known implementation diagnoses the violation of the rules for transparently replaceable in the following example, but there is implementation divergence for the results of f():

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

97

2559. Defaulted consteval functions

Section: 7.7 [expr.const] Status: open Submitter: Aaron Ballman Date: 2022-03-29

Consider:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

98

A consteval function should always be evaluated at compile time and never fall back to runtime, thus all four cases should be rejected. is related.

2633. typeid of constexpr-unknown dynamic type

Section: 7.7 [expr.const] Status: open Submitter: Jim X Date: 2022-09-18

Consider the example in 7.7 [] paragraph 7:

const char (&r) [] = "foo"; const char a[] = {'f', 'o', 'o', '\0'}; int main() {

assert(&r == &a);   // allowed not to fail?

99

The comment in the example seems not to be backed by normative text. In particular, the dynamic type of dc is constexpr-unknown per 7.7 [] paragraph 7:

During the evaluation of an expression E as a core constant expression, all id-expressions and uses of *this that refer to an object or reference whose lifetime did not begin with the evaluation of E are treated as referring to a specific instance of that object or reference whose lifetime and that of all subobjects (including all union members) includes the entire constant evaluation. For such an object that is not usable in constant expressions, the dynamic type of the object is constexpr-unknown. ...

Thus, typeid(dc) is not a core constant expression per 7.7 [] bullet 5.26:

* a dynamic_cast (7.6.1.7 [expr.dynamic.cast]) or typeid (7.6.1.8 [expr.typeid]) expression on a glvalue that refers to an object whose dynamic type is constexpr-unknown or that would throw an exception;

2656. Converting consteval lambda to function pointer in non-immediate context

Section: 7.7 [expr.const] Status: open Submitter: Hubert Tong Date: 2022-11-11

Converting a consteval lambda to a function pointer in a non-immediate context should be immediately-escalating.

Currently, this is well-formed:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

00

Suggested resolution:

Make the conversion function of a lambda whose call operator is an immediate function also an immediate function.

2702. Constant destruction of reference members

Section: 7.7 [expr.const] Status: open Submitter: Richard Smith Date: 2023-02-13

says that a constexpr reference bound to a lifetime-extended temporary is required to have constant destruction. However, that rule overlooks constexpr objects with a reference member bound to a lifetime-extended temporary, recursively, and the case for std::initializer_list lifetime extension.

2734. Immediate forward-declared function templates

Section: 7.7 [expr.const] Status: open Submitter: Corentin Jabot Date: 2023-05-10

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

01

The standard is silent as to what happen if no function body is available at the point where we need to determine whether a constexpr function template is an immediate function template.

Furthermore, there is no wording that taking the address of a constexpr function template specialization instantiates its body to determine whether it is an immediate function, unlike the handling of auto return types.

Subclause 13.9.2 [] paragraph 5 specifies:

Unless a function template specialization is a declared specialization, the function template specialization is implicitly instantiated when the specialization is referenced in a context that requires a function definition to exist or if the existence of the definition affects the semantics of the program. ...

See also .

2740. Too many objects have constexpr-unknown type

Section: 7.7 [expr.const] Status: open Submitter: Richard Smith Date: 2023-02-10

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

02

The example had been valid, but became invalid under P2280. The same happened for dynamic_cast. Furthermore, P2280 seems to be missing a change for static_cast from base to derived and for pointer-to-member access expressions, which both depend on the dynamic type and have historically been required to work.

Maybe a better rule would be that objects (not references) whose lifetime did not begin within E are treated as having a dynamic type that is their declared type.

2760. Defaulted constructor that is an immediate function

Section: 7.7 [expr.const] Status: open Submitter: Corentin Jabot Date: 2023-07-08

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

03

Is S an immediate function?

The relevant specification is in 7.7 [] paragraph 18:

An immediate function is a function or constructor that is declared with the consteval specifier, or an immediate-escalating function F whose function body contains an immediate-escalating expression E such that E's innermost enclosing non-block scope is F's function parameter scope.

Suggested resolution:

Change in 7.7 [] paragraph 18 as follows:

An immediate function is a function or constructor that is declared with the consteval specifier, or an immediate-escalating function F whose function body contains an immediate-escalating expression E such that E's innermost enclosing non-block scope is F's function parameter scope, or

• an immediate-escalating default constructor of a class which has at least one non-static data member with an immediate-escalating default member initializer.

Alternative possible resolution:

1. Change in 7.7 [] paragraph 18 as follows:

   An immediate function is a function or constructor that is declared with the consteval specifier, or an immediate-escalating function F whose function body contains an immediate-escalating expression E such that E's innermost enclosing non-block scope is F's function parameter scope. [ Note: Default member initializers used to initialize a base or member subobject (11.9.3 [class.base.init]) are considered to be part of the function body (9.5.1 [dcl.fct.def.general]). -- end note ]

2. Change in 9.5.1 [] paragraph 1 as follows: Any informal reference to the body of a function should be interpreted as a reference to the non-terminal function-body, including default member initializers or default initialization used to initialize a base or member subobject in the absence of a mem-initializer-id (11.9.3 [class.base.init]).

2778. Trivial destructor does not imply constant destruction

Section: 7.7 [expr.const] Status: open Submitter: Jiang An Date: 2023-07-27

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

04

In C++20, Foo and Bar are literal types, and

1 is well-formed. In C++23, the requirement for the variable b changed to "constant destruction". However, Bar does not have constant destruction, because its mutable member violates 7.7 [] bullet 5.17:

... an invocation of a destructor (11.4.7 [class.dtor]) or a function call whose postfix-expression names a pseudo-destructor (7.6.1.3 [expr.call]), in either case for an object whose lifetime did not begin within the evaluation of E;

• ...

This is because the mutable member is considered to have its lifetime begin outside of E per 7.7 [] paragraph 9:

An object a is said to have constant destruction if: it is not of class type nor (possibly multidimensional) array thereof, or it is of class type or (possibly multidimensional) array thereof, that class type has a constexpr destructor, and for a hypothetical expression E whose only effect is to destroy a, E would be a core constant expression if the lifetime of a and its non-mutable subobjects (but not its mutable subobjects) were considered to start within E.

Possible resolution:

Change in 7.7 [] paragraph 9 as follows:

An object a is said to have constant destruction if: it is not of class type nor (possibly multidimensional) array thereof, or it is of class type or (possibly multidimensional) array thereof, that class type has a constexpr destructor, any mutable member has a trivial destructor, and for a hypothetical expression E whose only effect is to destroy a, E would be a core constant expression if any mutable members were ignored and if the lifetime of a and its non-mutable subobjects (but not its mutable subobjects) were considered to start within E.

2495. Glvalue result of a function call

Section: 8.7.4 [stmt.return] Status: open Submitter: Jim X Date: 2021-07-04

According to 8.7.4 [] paragraph 1,

A return statement with any other operand shall be used only in a function whose return type is not cv void; the return statement initializes the glvalue result or prvalue result object of the (explicit or implicit) function call by copy-initialization (9.4 [dcl.init]) from the operand.

It is not clear what a “glvalue result” is or what it means to initialize it.

Suggested resolution:

A return statement with any other operand shall be used only in a function whose return type is not cv void;. If the function call is a prvalue, the return statement initializes the glvalue result or prvalue result object of the (explicit or implicit) function call by copy-initialization (9.4 [dcl.init]) from the operand. Otherwise, the return statement is equivalent to the following hypothetical declaration

T t = e;

If the operand of the return statement, X, is a comma expression without parentheses, e is (X), otherwise e is X. T is the return type of the function call; the invented variable t is the result of the function call.

Notes from the August, 2021 teleconference:

A simpler approach would be simply to use a phrase like “returned object or reference” in place of the current wording referring to glvalues and prvalues. This change was regarded as editorial. The issue will remain in "review" status until CWG can look over the wording change.

2123. Omitted constant initialization of local static variables

Section: 8.8 [stmt.dcl] Status: open Submitter: Hubert Tong Date: 2015-02-02

According to 8.8 [] paragraph 4,

The zero-initialization (9.4 [dcl.init]) of all block-scope variables with static storage duration (6.7.5.2 [basic.stc.static]) or thread storage duration (6.7.5.3 [basic.stc.thread]) is performed before any other initialization takes place. Constant initialization (6.9.3.2 [basic.start.static]) of a block-scope entity with static storage duration, if applicable, is performed before its block is first entered.

The fact that a variable need not be constant-initialized if its block is not entered appears to allow inspection of the variable after zero-initialization but before constant initialization:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

05

For a related example, consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

06

Here, b may or may not have constant initialization, but we don't have an ODR violation.

If we want to support such code, the nicest option would be to say that the ODR requires us to act as if we pick one of the definitions of the inline function, which requires us to make a consistent choice for all static storage duration variables within a given function. Alternatively, we could say that if multiple definitions of a variable disagree over whether it has constant initialization, then it does not, allowing more implementation simplicity and no functional change outside of pathological cases.

Notes from the February, 2016 meeting:

The second example will be dealt with separately under . For the first example, the Standard should require that local types can be used outside their function only via a returned object. It was still to be decided whether this should be undefined behavior or an error on use of such a type. It was also noted that the same issue can arise with static member functions.

2751. Order of destruction for parameters for operator functions

Section: 8.8 [stmt.dcl] Status: open Submitter: Richard Smith Date: 2020-06-10 Liaison: EWG

Subclause 8.8 [] paragraph 2 specifies:

Upon each transfer of control (including sequential execution of statements) within a function from point P to point Q, all variables with automatic storage duration that are active at P and not at Q are destroyed in the reverse order of their construction. ... when a function returns, Q is after its body.

Another description of the same rule is in a note in 8.7.1 [] paragraph 2:

[Note 1: On exit from a scope (however accomplished), objects with automatic storage duration (6.7.5.4 [basic.stc.auto]) that have been constructed in that scope are destroyed in the reverse order of their construction. ... —end note]

However, 12.2.2.3 [] paragraph 2 specifies:

... Therefore, the operator notation is first transformed to the equivalent function-call notation as summarized in Table 18 (where @ denotes one of the operators covered in the specified subclause). However, the operands are sequenced in the order prescribed for the built-in operator (7.6 [expr.compound]).

For operator+= (for example), 7.6.19 [] paragraph 1 requires:

... The right operand is sequenced before the left operand. ...

Now, consider an ABI with callee-cleanup and this example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

07

In A() << B(), A() is sequenced before B(). In A() += B(), B() is sequenced before A(). For an ABI with callee-cleanup, this means that operator<< must destroy the B parameter before the A parameter, and operator+= must destroy the A parameter before the B parameter.

But this means we have a problem emitting a call to p(A(), B()): no order of parameter initialization guarantees that parameters are destroyed in reverse construction order.

A possible implementation strategy would be to emit a second definition of operator+= with the opposite parameter destruction order that is used when naming the function operator+=, e.g. when taking the address or using function call notation (as opposed to using operator notation).

Another alternative is to relax the rules about destruction of parameters in the reverse order of construction for the case of binary operator functions and operator new and operator delete.

Additional notes (June, 2023)

Forwarded to EWG via paper issue 1583, per decision of the CWG chair, to either affirm the intent of the rules (requiring a more involved implementation strategy as outlined above) or agree on a relaxation of the rules for the order of destruction of parameters.

157. Omitted typedef declarator

Section: 9.1 [dcl.pre] Status: open Submitter: Daveed Vandevoorde Date: 19 Aug 1999

9.1 [] paragraph 3 reads,

In a simple-declaration, the optional init-declarator-list can be omitted only when... the decl-specifier-seq contains either a class-specifier, an elaborated-type-specifier with a class-key (11.3 [class.name] ), or an enum-specifier. In these cases and whenever a class-specifier or enum-specifier is present in the decl-specifier-seq, the identifiers in those specifiers are among the names being declared by the declaration... In such cases, and except for the declaration of an unnamed bit-field (11.4.10 [class.bit] ), the decl-specifier-seq shall introduce one or more names into the program, or shall redeclare a name introduced by a previous declaration. [Example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

08 —end example]

In the absence of any explicit restrictions in 9.2.4 [dcl.typedef] , this paragraph appears to allow declarations like the following:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

09 In fact, the final example in 9.1 [] paragraph 3 would seem to indicate that this is intentional: since it is illustrating the requirement that the decl-specifier-seq must introduce a name in declarations in which the init-declarator-list is omitted, presumably the addition of a class name would have made the example well-formed.

On the other hand, there is no good reason to allow such declarations; the only reasonable scenario in which they might occur is a mistake on the programmer's part, and it would be a service to the programmer to require that such errors be diagnosed.

498. Storage class specifiers in definitions of class members

Section: 9.2.2 [dcl.stc] Status: open Submitter: Matt Austern Date: 13 Jan 2005

Suppose we've got this class definition:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

10

I think I can deduce from the existing standard that the following member definitions are ill-formed:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

11

To come to that conclusion, however, I have to put together several things in different parts of the standard. I would have expected to find an explicit statement of this somewhere; in particular, I would have expected to find it in 9.2.2 [dcl.stc]. I don't see it there, or anywhere.

Gabriel Dos Reis: Or in 6.6 [basic.link] which is about linkage. I would have expected that paragraph to say that that members of class types have external linkage when the enclosing class has an external linkage. Otherwise 6.6 [] paragraph 8:

Names not covered by these rules have no linkage.

might imply that such members do not have linkage.

Notes from the April, 2005 meeting:

The question about the linkage of class members is already covered by 6.6 [] paragraph 5.

2232. thread_local anonymous unions

Section: 9.2.2 [dcl.stc] Status: open Submitter: Mike Herrick Date: 2016-02-23

It is not clear from the current wording whether the thread_local specifier can be applied to anonymous unions or not. According to 9.2.2 [] paragraph 3,

The thread_local specifier indicates that the named entity has thread storage duration (6.7.5.3 [basic.stc.thread]). It shall be applied only to the names of variables of namespace or block scope and to the names of static data members.

One might think that an anonymous union object would be a “variable,” but the next paragraph seems to treat variables and anonymous unions as distinct:

The static specifier can be applied only to names of variables and functions and to anonymous unions (11.5.2 [class.union.anon]).

2195. Unsolicited reading of trailing volatile members

Section: 9.2.9.2 [dcl.type.cv] Status: open Submitter: Hubert Tong Date: 2015-11-06

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

12

Is it okay for the memory associated with bp->i to be accessed by foo?

See also 9.2.9.2 [] paragraph 5

The semantics of an access through a volatile glvalue are implementation-defined. If an attempt is made to access an object defined with a volatile-qualified type through the use of a non-volatile glvalue, the behavior is undefined.

Additional notes from the November, 2016 meeting:

See also national body comment CH2, addressed in March, 2017 by P0612R0.

144. Position of friend specifier

Section: 9.2.9.4 [dcl.type.elab] Status: open Submitter: Daveed Vandevoorde Date: 22 Jul 1999

9.2.9.4 [] paragraph 1 seems to impose an ordering constraint on the elements of friend class declarations. However, the general rule is that declaration specifiers can appear in any order. Should

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

13 be well-formed?

2634. Avoid circularity in specification of scope for friend class declarations

Section: 9.2.9.4 [dcl.type.elab] Status: open Submitter: Jim X Date: 2022-07-04

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

14

The target scope for

2 is f's block scope, making ::X not a friend of f::D. Thus the access at

2 is ill-formed. Clang disagrees.

Subclause 9.2.9.4 [] paragraph 3 specifies:

... If E contains an identifier but no nested-name-specifier and (unqualified) lookup for the identifier finds nothing, E shall not be introduced by the enum keyword and declares the identifier as a class-name. The target scope of E is the nearest enclosing namespace or block scope.

If an elaborated-type-specifier appears with the friend specifier as an entire member-declaration, the member-declaration shall have one of the following forms:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

15 Any unqualified lookup for the identifier (in the first case) does not consider scopes that contain the target scope; no name is bound.

This specification is circular in that the target scope that limits unqualified lookup is defined only if the identifier is actually declared, but the identifier is declared only if lookup finds nothing.

Possible resolution:

Change in 9.2.9.4 [] paragraph 4 as follows:

... Any unqualified lookup for the identifier (in the first case) does not consider scopes that contain the target nearest enclosing namespace or block scope; no name is bound. [ Note: ... ]

2228. Ambiguity resolution for cast to function type

Section: 9.3.3 [dcl.ambig.res] Status: open Submitter: Richard Smith Date: 2016-02-02 Liaison: EWG

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

16

This is ill-formed, because 9.3.3 [] paragraph 2 specifies:

An ambiguity can arise from the similarity between a function-style cast and a type-id. The resolution is that any construct that could possibly be a type-id in its syntactic context shall be considered a type-id.

and thus int() is interpreted as a type-id instead of as a function-style cast, so this is an ill-formed cast to a function type.

This seems to be the wrong disambiguation for all cases where there is a choice between a C-style cast and a parenthesized expression: in all those cases, the C-style cast interpretation results in a cast to a function type, which is always ill-formed.

Further, there is implementation divergence in the handling of this example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

17

EWG 2022-11-11

This is tracked in github issue cplusplus/papers

1376.

2671. friend named by a template-id

Section: 9.3.4.1 [dcl.meaning.general] Status: open Submitter: Davis Herring Date: 2022-11-18

Subclause 9.3.4.1 [] paragraph 1 specifies:

... If the unqualified-id occurring in a declarator-id is a template-id, the declarator shall appear in the declaration of a template-declaration (13.7 [temp.decls]), explicit-specialization (13.9.4 [temp.expl.spec]), or explicit-instantiation (13.9.3 [temp.explicit]).

However, that is too restrictive and prevents befriending template specializations, for example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

18

1790. Ellipsis following function parameter pack

Section: 9.3.4.6 [dcl.fct] Status: open Submitter: Daryle Walker Date: 2013-10-01 Liaison: WG14

Although the current wording permits an ellipsis to immediately follow a function parameter pack, it is not clear that the facilities permit access to the ellipsis arguments.

Rationale (June, 2014):

CWG felt that this is a question of language design and thus should be considered by EWG before any action.

EWG 2022-11-11

C23 removes the requirement that the last parameter be named for va_start. This is tracked in github issue cplusplus/papers

1374.

361. Forward reference to default argument

Section: 9.3.4.7 [dcl.fct.default] Status: open Submitter: Steve Clamage Date: 17 June 2002

Is this program well-formed?

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

19

A class member function can in general refer to class members that are declared lexically later. But what about referring to default arguments of member functions that haven't yet been declared?

It seems to me that if f2 can refer to f1, it can also refer to the default argument of f1, but at least one compiler disagrees.

Notes from the February, 2012 meeting:

Implementations seem to have come to agreement that this example is ill-formed.

Additional note (March, 2013):

Additional discussion has occurred suggesting the following examples as illustrations of this issue:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

20

as well as

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

21

(See also .)

Additional note (October, 2013):

treats exception-specifications like default arguments, evaluated in the completed class type. That raises the same questions regarding self-referential noexcept clauses that apply to default arguments.

Additional note (November, 2020):

Paper P1787R6, adopted at the November, 2020 meeting, partially addresses this issue.

1609. Default arguments and function parameter packs

Section: 9.3.4.7 [dcl.fct.default] Status: open Submitter: Jonathan Caves Date: 2013-01-25

It is not clear from 9.3.4.7 [dcl.fct.default] whether the following is well-formed or not:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

22

(T... b is a non-deduced context per 13.10.3.6 [] paragraph 5, so the template arguments must be specified explicitly.)

Notes from the April, 2013 meeting:

CWG agreed that the example should be ill-formed.

Additional note (August, 2013):

9.3.4.7 [] paragraph 4 explicitly allows for a function parameter pack to follow a parameter with a default argument:

In a given function declaration, each parameter subsequent to a parameter with a default argument shall have a default argument supplied in this or a previous declaration or shall be a function parameter pack.

However, any instantiation of such a function template with a non-empty pack expansion would result in a function declaration in which one or more parameters without default arguments (from the pack expansion) would follow a parameter with a default argument and thus would be ill-formed. Such a function template declaration thus violates 13.8 [] paragraph 8:

If every valid specialization of a variadic template requires an empty template parameter pack, the template is ill-formed, no diagnostic required.

Although the drafting review teleconference of 2013-08-26 suggested closing the issue as NAD, it is being kept open to discuss and resolve this apparent contradiction.

Notes from the September, 2013 meeting:

CWG agreed that this example should be accepted; the restriction on default arguments applies to the template declaration itself, not to its specializations.

2701. Default arguments in multiple scopes / inheritance of array bounds in the same scope

Section: 9.3.4.7 [dcl.fct.default] Status: open Submitter: Richard Smith Date: 2020-11-20

It appears that P1787R6 has inadvertently changed the rules for where default arguments can be (re-)declared for a parameter. Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

23

Subclause 9.3.4.7 [] paragraph 4 specifies:

For non-template functions, default arguments can be added in later declarations of a function that inhabit the same scope. Declarations that inhabit different scopes have completely distinct sets of default arguments. ...

The problem is that the out-of-line declaration of N::f inhabits the global namespace scope, not the scope of namespace N.

A similar problem exists for inheriting array bounds per 9.3.4.5 [] paragraph 8:

Furthermore, if there is a reachable declaration of the entity that inhabits the same scope in which the bound was specified, an omitted array bound is taken to be the same as in that earlier declaration, and similarly for the definition of a static data member of a class.

Possible resolution:

1. Change in 6.4.1 [] paragraph 2 as follows:

   ... The host scope of a declaration is the inhabited scope if that scope is a block scope and the target scope otherwise. An entity belongs to a scope S if S is the target scope of a declaration of the entity.

2. Change in 9.3.4.5 [] paragraph 8 as follows: Furthermore, if there is a reachable declaration of the entity that inhabits has the same host scope in which the bound was specified, an omitted array bound is taken to be the same as in that earlier declaration, and similarly for the definition of a static data member of a class.
3. Change in 9.3.4.7 [] paragraph 4 as follows: For non-template functions, default arguments can be added in later declarations of a function that inhabit have the same host scope. Declarations that inhabit have different host scopes have completely distinct sets of default arguments. ...
4. Change in 9.3.4.7 [] paragraph 9 as follows: When an overload set contains a declaration of a function that inhabits a whose host scope is S, any default argument associated with any reachable declaration that inhabits whose host scope is S is available to the call.
5. Change in 12.2.4.1 [] paragraph 4 as follows: If the best viable function resolves to a function for which multiple declarations were found, and if any two of these declarations inhabit have different host scopes and specify a default argument that made the function viable, the program is ill-formed. [ Example: ...

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

24

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

2657. Cv-qualification adjustment when binding reference to temporary

Section: 9.4.4 [dcl.init.ref] Status: open Submitter: Brian Bi Date: 2022-11-10

was resolved by clarifying that the temporary object in p5.4.2 is cv-qualified if the reference being initialized is cv-qualified. However, this is not the right bullet point for the example given,

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

26

Such an initialization would actually use bullet 5.3.1 instead. (5.4.2 would be used if the initializer were, for example, 3.14.) We therefore need to make a similar clarification in bullet 5.3, and ideally using the same language.

Suggested resolution:

1. Change in 9.4.4 [] bullet 5.3 as follows:

   Otherwise, if the initializer expression is an rvalue (but not a bit-field) or function lvalue and “cv1 T1” is reference-compatible with “cv2 T2”, or has a class type (i.e., T2 is a class type), where T1 is not reference-related to T2, and can be converted to an rvalue or function lvalue of type “cv3 T3”, where “cv1 T1” is reference-compatible with “cv3 T3” (see 12.2.2.7 [over.match.ref]), then the initializer expression in the first case and the converted expression in the second case is called the converted initializer. If the converted initializer is a prvalue, let its type be denoted by T4; the temporary materialization conversion (7.3.5 [conv.rval]) is applied, considering the type of the prvalue to be is adjusted to type “cv1 T4” (7.3.6 [conv.qual]) and the temporary materialization conversion (7.3.5 [conv.rval]) is applied. In any case, the reference binds to the resulting glvalue (or to an appropriate base class subobject).

2. Append to the example in 9.4.4 [] bullet 5.3 as follows: static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true 27
3. Change the example in 9.4.4 [] bullet 5.4 as follows: static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true 28

2704. Clarify meaning of "bind directly"

Section: 9.4.4 [dcl.init.ref] Status: open Submitter: Brian Bi Date: 2022-11-11

Currently, 9.4.4 [] paragraph 5 specifies:

In all cases except the last (i.e., implicitly converting the initializer expression to the referenced type), the reference is said to bind directly to the initializer expression.

This is intended to refer to both sub-bullets of the last bullet (see ), but the presentation is unclear.

Suggested resolution:

1. Change in 9.4.4 [] bullet 5.4 as follows:

   Otherwise, the reference is said to bind indirectly to the initializer expression: If T1 or T2 is a class type and T1 is not reference-related to T2, user-defined conversions are considered using the rules for copy-initialization of an object of type “cv1 T1” by user-defined conversion (9.4 [dcl.init], 12.2.2.5 [over.match.copy], 12.2.2.6 [over.match.conv]); the program is ill-formed if the corresponding non-reference copy-initialization would be ill-formed. The result of the call to the conversion function, as described for the non-reference copy-initialization, is then used to direct-initialize the reference. For this direct-initialization, user-defined conversions are not considered. Otherwise, the initializer expression is implicitly converted to a prvalue of type “T1”. The temporary materialization conversion is applied, considering the type of the prvalue to be “cv1 T1”, and the reference is bound to the result.

   If T1 is reference-related to T2:

   cv1 shall be the same cv-qualification as, or greater cv-qualification than, cv2; and if the reference is an rvalue reference, the initializer expression shall not be an lvalue. [Note 3: This can be affected by whether the initializer expression is move-eligible (7.5.4.2 [expr.prim.id.unqual]). —end note]

2. Change in 9.4.4 [] paragraph 5 as follows: In all cases except the last (i.e., implicitly converting the initializer expression to the referenced type), the The reference is said to bind directly to the initializer expression if it does not bind indirectly. [ Example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

2168. Narrowing conversions and +/- infinity

Section: 9.4.5 [dcl.init.list] Status: open Submitter: Hubert Tong Date: 2015-08-19

The intended treatment of a floating point infinity with respect to narrowing conversions is not clear. Is std::numeric_limits::infinity() usable in a constant expression, for example, and should that be different from a calculation that results in an infinity?

Notes from the October, 2015 meeting:

CWG requests the assistance of SG6 in resolving this issue.

Notes from the November, 2016 meeting:

SG6 said that arithmetic operations (not conversions) that produce infinity are not allowed in a constant expression. However, using std::numeric_limits::infinity() is okay, but it can't be used as a subexpression. Conversions that produce infinity from non-infinity values are considered to be narrowing conversions.

2638. Improve the example for initializing by initializer list

Section: 9.4.5 [dcl.init.list] Status: open Submitter: Shafik Yaghmour Date: 2022-10-26

amended the rules for initialization by initializer list, but neglected to add an example.

Suggested resolution:

Change the example in 9.4.5 [] bullet 3.7 as follows:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

30

2742. Guaranteed copy elision for brace-initialization from prvalue

Section: 9.4.5 [dcl.init.list] Status: open Submitter: Jim X Date: 2023-06-06

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

31

1 is well-formed per 9.4.1 [] bullet 16.6.1. However, even though

2 is intended to have a similar effect, the relevant rule excludes non-aggregates, making the example ill-formed (because the relevant constructor is deleted); see 9.4.5 [] bullet 3.2:

If T is an aggregate class and the initializer list has a single element of type cv U, where U is T or a class derived from T, the object is initialized from that element (by copy-initialization for copy-list-initialization, or by direct-initialization for direct-list-initialization).

There is implementation divergence: gcc and clang accept, MSVC rejects.

See also .

Suggested resolution:

Change in 9.4.5 [] bullet 3.2 as follows:

If T is an aggregate class a class type and the initializer list has a single element of type cv U, where U is T or a class derived from T, the object is initialized from that element (by copy-initialization for copy-list-initialization, or by direct-initialization for direct-list-initialization).

1962. Type of __func__

Section: 9.5.1 [dcl.fct.def.general] Status: open Submitter: Steve Clamage Date: 2014-07-04 Liaison: EWG

Two questions have arisen regarding the treatment of the type of the __func__ built-in variable. First, some implementations accept

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

32

even though T is specified to be an array type.

In a related question, it was noted that __func__ is implicitly required to be unique in each function, and that not only the value but the type of __func__ are implementation-defined; e.g., in something like

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

33

the function type is implementation-specific. These concerns could be addressed by making the value a prvalue of type const char* instead of an array lvalue.

Notes from the May, 2015 meeting:

CWG agreed with the suggested direction.

Rationale (November, 2018):

See also , which asks for the ability to use __func__ in a constexpr function. These two goals are incompatible, so EWG input is requested.

EWG 2022-11-11

Paper requested. This is tracked in github issue cplusplus/papers

1375.

2362. __func__ should be constexpr

Section: 9.5.1 [dcl.fct.def.general] Status: open Submitter: Anthony Polukhin Date: 2017-10-23 Liaison: EWG

The definition of __func__ in 9.5.1 [] paragraph 8 is:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

34

This prohibits its use in constant expressions, e.g.,

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

35

Notes from the October, 2018 teleconference:

CWG agreed with the proposed change.

Rationale (November, 2018):

See also , which asks that the type of __func__ be const char*. These two goals are incompatible, so EWG input is requested.

EWG 2022-11-11

This is tracked in github issue cplusplus/papers

1378.

2562. Exceptions thrown during coroutine startup

Section: 9.5.4 [dcl.fct.def.coroutine] Status: open Submitter: Tomasz Kamiński Date: 2022-04-06

Subclause 9.5.4 [dcl.fct.def.coroutine] seems to miss specification about the behavior of coroutines when an exception is thrown during the early phases of a coroutine evaluation. It is unclear at what point the ownership of the coroutine frame is passed from the compiler to the user, who then needs to call std::coroutine_handle::destroy to destroy and free the coroutine frame, including the parameter copies. The following situations arise:

• Allocation fails, and get_return_object_on_allocation_failure() is returned.
• Allocation succeeds, but an exception is thrown before the return object is initialized (e.g. when initializing the promise or evaluating get_return_object). The coroutine state ought to be deallocated automatically and the exception propagated.
• The return object is successfully initialized, but an exception would leave the coroutine before it would first suspend, either because initial-suspend's await_ready or await_suspend exits via an exception, or because unhandled_exception rethrows. The coroutine ought to be suspended at its final suspend point, the return object destroyed, and the exception propagated; the return object's destructor is responsible for ensuring the coroutine is destroyed.
• The coroutine ever suspends, or the coroutine terminates normally without ever suspending. The return object is returned to the caller, carrying with it ownership of the coroutine state.

See also .

2340. Reference collapsing and structured bindings

Section: 9.6 [dcl.struct.bind] Status: open Submitter: Daveed Vandevoorde Date: 2017-03-29

According to 9.6 [] paragraph 3,

Given the type Ti designated by std::tuple_element::type, each vi is a variable of type “reference to Ti” initialized with the initializer, where the reference is an lvalue reference if the initializer is an lvalue and an rvalue reference otherwise; the referenced type is Ti.

If Ti is already a reference type, should this do reference collapsing? Presumably yes, but reference collapsing is specified in terms of a typedef-name or decltype-specifier, which are not used in this description.

See also .

813. typename in a using-declaration with a non-dependent name

Section: 9.9 [namespace.udecl] Status: open Submitter: UK Date: 3 March, 2009

9.9 [] paragraph 20 says,

If a using-declaration uses the keyword typename and specifies a dependent name (13.8.3 [temp.dep]), the name introduced by the using-declaration is treated as a typedef-name (9.2.4 [dcl.typedef]).

This wording does not address use of typename in a using-declaration with a non-dependent name; the primary specification of the typename keyword in 13.8 [temp.res] does not appear to describe this case, either.

Additional notes (March, 2022):

The relevant wording is now in 13.8.1 [temp.res.general] paragraph 5:

A name that refers to a using-declarator whose terminal name is dependent is interpreted as a typedef-name if the using-declarator uses the keyword typename.

1617. alignas and non-defining declarations

Section: 9.12.2 [dcl.align] Status: open Submitter: Richard Smith Date: 2012-02-02

According to 9.12.2 [] paragraph 6,

If the defining declaration of an entity has an alignment-specifier, any non-defining declaration of that entity shall either specify equivalent alignment or have no alignment-specifier. Conversely, if any declaration of an entity has an alignment-specifier, every defining declaration of that entity shall specify an equivalent alignment. No diagnostic is required if declarations of an entity have different alignment-specifiers in different translation units.

Because this is phrased in terms of the definition of an entity, an example like the following is presumably well-formed (even though there can be no definition of n):

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

36

Is this intentional?

2541. Linkage specifications, module purview, and module attachment

Section: 10.1 [module.unit] Status: open Submitter: Nathan Sidwell Date: 2022-02-28

The interaction between linkage specifications (9.11 [dcl.link]) and named or global module purview and attachment (10.1 [module.unit]) is confusing. The addition of linkage declarations attaching their contents to the global module is not fully integrated into the wording and examples would also help.

• Module purview and attachment are not necessarily the same. This is never explicitly mentioned.
• 10.1 [] paragraph 7 explicitly calls out replaceable allocation and deallocation functions as being (implicitly) attached to the global module. This is unnecessary.
• 6.9.3.1 [] paragraph 1 specifies that there shall be a main function in the global namespace, but only in paragraph 3 do we specify that not attaching it to the global module is ill-formed.

Suggested resolution:

1. Change 6.9.3.1 [] paragraph 1 as follows:

   A program shall contain exactly one function called main that belongs to the global scope and is attached to the global module. Executing a program starts a main thread of execution (6.9.2 [intro.multithread], 33.4 [thread.threads]) in which the main function is invoked. It is implementation-defined whether a program in a freestanding environment is required to define a main function.

2. Change 10.1 [] bullet 7.2 as follows: ... Otherwise, if the declaration is a replaceable global allocation or deallocation function (17.6.3.2 [new.delete.single], 17.6.3.3 [new.delete.array]), or is a namespace-definition with external linkage, or appears within a linkage-specification,

   it is attached to the global module.

   Otherwise, ...
3. Add an example at the end of 10.1 [] paragraph 7: [ Example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

37

Both g and h have external linkage, are attached to the global module, and can thus also be redeclared in other translation units:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

38

-- end example ]

A module-declaration that contains neither...

4. Change in 10.2 [] paragraph 6 as follows: A redeclaration of an entity X is implicitly exported if X was introduced by an exported declaration; otherwise it shall not be exported unless it has external linkage..

2727. Importing header units synthesized from source files

Section: 10.3 [module.import] Status: open Submitter: Jim X Date: 2023-05-04

Subclause 10.3 [] paragraph 5 specifies:

A module-import-declaration that specifies a header-name H imports a synthesized header unit, which is a translation unit formed by applying phases 1 to 7 of translation (5.2 [lex.phases]) to the source file or header nominated by H, which shall not contain a module-declaration. ... An importable header is a member of an implementation-defined set of headers that includes all importable C++ library headers (16.4.2.3 [headers]). H shall identify an importable header. ...

This text seems to recognize that header units may be synthesized from non-headers (i.e. source files), yet a module-import-declaration of the form import header-name is required to name an (importable) header, not an arbitrary source file turned into header unit.

Possible resolution:

Change in 10.3 [] paragraph 5 as follows:

H shall identify an importable header. If H nominates a header, that header shall be an importable header.

2637. Injected-class-name as a simple-template-id

Section: 11.1 [class.pre] Status: open Submitter: Shafik Yaghmour Date: 2022-10-26

sought to disallow simple-template-ids as constructor names, by referring to the injected-class-name. However, 11.1 [] paragraph 2 specifies:

The class-name is also bound in the scope of the class (template) itself; this is known as the injected-class-name.

The grammar non-terminal class-name includes the option of a simple-template-id (for declaring a partial specialization).

Suggested resolution:

Change in 11.1 [] paragraph 2 as follows:

The terminal name of the class-name is also bound in the scope of the class (template) itself; this is known as the injected-class-name. ...

511. POD-structs with template assignment operators

Section: 11.2 [class.prop] Status: open Submitter: Alisdair Meredith Date: 19 Mar 2005

A POD-struct is not permitted to have a user-declared copy assignment operator (11.2 [] paragraph 1). However, a template assignment operator is not considered a copy assignment operator, even though its specializations can be selected by overload resolution for performing copy operations (11.4.6 [] paragraph 12). Consequently, X in the following code is a POD, notwithstanding the fact that copy assignment (for a non-const operand) is a member function call rather than a bitwise copy:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

39

Is this intentional?

2463. Trivial copyability and unions with non-trivial members

Section: 11.2 [class.prop] Status: open Submitter: Daveed Vandevoorde Date: 2020-11-30 Liaison: EWG

According to 11.2 [] paragraph 1,

A trivially copyable class is a class: that has at least one eligible copy constructor, move constructor, copy assignment operator, or move assignment operator (11.4.4 [special], 11.4.5.3 [class.copy.ctor], 11.4.6 [class.copy.assign]), where each eligible copy constructor, move constructor, copy assignment operator, and move assignment operator is trivial, and

• that has a trivial, non-deleted destructor (11.4.7 [class.dtor]).

This definition has surprising effects in a union whose members are not trivial. For example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

40

In this case, S is not trivially copyable because its assignment operator is non-trivial, although its copy constructor is trivial. U, however, is trivially copyable because its assignment operator is not eligible (11.4.4 [] paragraph 6) because it is deleted, but its copy constructor is trivial, thus satisfying the second bullet.

It is unclear why, for example, a complete object of type S cannot be memcpyed but such an object can be memcpyed when embedded in a union.

There is implementation divergence in the handling of this example.

CWG 2022-11-10

Traditionally, the rule for trivial copyability has been that each of the potentially user-written ways of copying a class (copy/move constructors, copy/move assignment operators) have to be trivial (or deleted). See C++17 subclause 12p6:

A trivially copyable class is a class: where each copy constructor, move constructor, copy assignment operator, and move assignment operator (15.8, 16.5.3) is either deleted or trivial, that has at least one non-deleted copy constructor, move constructor, copy assignment operator, or move assignment operator, and

• that has a trivial, non-deleted destructor (15.4).

That seems unhelpful. The rule should instead be that if there is any way of copying the class such that the compiler will generate a memcpy (because the corresponding operation is trivial), the user should be allowed to perform memcpy, too. In terms of wording, this amounts to striking the first bullet and adding "trivial" to the second bullet. (The wording in the current working draft considers eligibility, which complicates the treatment slightly in terms unrelated to the present issue.)

CWG is seeking EWG advice on this issue via cplusplus/papers

1363.

Additional notes (March, 2023)

std::tuple with trivially-copyable element types and with no elements (std::tuple<>) ought to be trivially copyable, but the recent addition of const-qualified assignment operators makes that not so under the status quo core language rules.

2736. Standard layout class with empty base class also in first member

Section: 11.2 [class.prop] Status: open Submitter: Lénárd Szolnoki Date: 2023-05-10

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

41

Class C satisfies all the conditions to be considered standard-layout, including 11.2 [] bullet 3.7:

• M(C) is the union of {B} and M(B) per 11.2 [] bullet 3.7.2.
• M(B) is the union of {char} and M(char) per 11.2 [] bullet 3.7.2.
• M(char) is an empty set per 11.2 [] bullet 3.7.5.

Thus, M(C) is {char,B}, neither of which is a base class of C, and thus C is standard-layout, contrary to popular ABI rules that do not provide pointer interconvertibility between C::b and C.

Suggested resolution:

Change in 11.2 [] bullet 3.7 as follows:

... has no element of the set M(S) of types as a base class, where for any type X, M(X) is defined as follows, where B(S) is a set of types consisting of S and each direct and indirect base class of S. [Footnote: ...] [Note 2: M(X) is the set of the types of all non-base-class subobjects that can be at a zero offset in X. —end note] If X is a non-union class type with no non-static data members, the set M(X) is empty. If X is a non-union class type with a non-static data member of type X0 that is either of zero size or is the first non-static data member of X (where said member may be an anonymous union), the set M(X) consists of X0 is the union of B(X0) and the elements of M(X0). If X is a union type, the set M(X) is the union of all M(Ui) and the set containing all Ui B(Ui), where each Ui is the type of the ith non-static data member of X. If X is an array type with element type Xe, the set M(X) consists of Xe is the union of B(Xe) and the elements of M(Xe).

• If X is a non-class, non-array type, the set M(X) is empty.

2188. empty-declaration grammar ambiguity

Section: 11.4.1 [class.mem.general] Status: open Submitter: Jens Maurer Date: 2015-10-21

(The originally reported ambiguity between simple-declaration and empty-declaration does not seem to exist.)

There is a grammar ambiguity between

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

42

and

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

43

2661. Missing disambiguation rule for pure-specifier vs. brace-or-equal-initializer

Section: 11.4.1 [class.mem.general] Status: open Submitter: Richard Smith Date: 2022-10-07

Subclause 11.4.1 [class.mem.general] has this grammar:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

44

The primary issue is that foo = 0 matches both member-declarator productions. Secondarily, a declarator by itself is also ambiguous.

Code such as virtual FunctionType f = 0; can be valid, so disambiguation on the syntactic form of the declarator is not possible.

Suggested resolution:

Change and add before 11.4.1 [] paragraph 1 as follows:

static const char test1 = 'x';

static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

45

The token sequence = 0 is treated as a pure-specifier if the type of the declarator-id (9.3.4.1 [dcl.meaning.general]) is a function type, and is otherwise treated as a brace-or-equal-initializer. [ Note: If the member declaration acquires a function type through template instantiation, the program is ill-formed; see 13.9.1 [temp.spec.general]. --end note ]

2759. [[no_unique_address] and common initial sequence

Section: 11.4.1 [class.mem.general] Status: open Submitter: Richard Smith Date: 2020-11-10

The interaction of [[no_unique_address]] and the definition of common initial sequence is still problematic. Subclause 11.4.1 [] bullet 23.3 specifies that corresponding members in a common initial sequence are not allowed to differ with respect to the presence or absence of a [[no_unique_address]] attribute. However, the Itanium ABI will not allocate two successive data members of the same empty class type at the same address, causing non-conforming behavior for the following example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

46

See Itanium ABI issue 108.

Since "common initial sequence" and "layout compatible" are concepts mostly used for C compatibility, but [[no_unique_address]] does not exist in C, it seems reasonable to terminate a common initial sequence at the first data member that is declared [[no_unique_address]].

Another concern is the behavior of std::is_layout_compatible on implementations that ignore [[no_unique_address]]. On such an implementation, the following example would be considered layout-compatible, although it actually is not:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

47

Suggested resolution:

Change in 11.4.1 [] paragraph 23 as follows:

The common initial sequence of two standard-layout struct (11.2 [class.prop]) types is the longest sequence of non-static data members and bit-fields in declaration order, starting with the first such entity in each of the structs, such that corresponding entities have layout-compatible types (6.8 [basic.types]), corresponding entities have the same alignment requirements (6.7.6 [basic.align]), either both entities are declared with the no_unique_address attribute (9.12.11 [dcl.attr.nouniqueaddr]) or neither is, if a has-attribute-expression (15.2 [cpp.cond]) is not 0 for the no_unique_address attribute, then neither entity is declared with the no_unique_address attribute (9.12.11 [dcl.attr.nouniqueaddr]), and either both entities are bit-fields with the same width or neither is a bit-field.

Alternative possible resolution:

Change in 11.4.1 [] paragraph 23 as follows:

The common initial sequence of two standard-layout struct (11.2 [class.prop]) types is the longest sequence of non-static data members and bit-fields in declaration order, starting with the first such entity in each of the structs, such that corresponding entities have layout-compatible types (6.8 [basic.types]), corresponding entities have the same alignment requirements (6.7.6 [basic.align]), either both entities are declared with the no_unique_address attribute (9.12.11 [dcl.attr.nouniqueaddr]) or neither is, neither entity is declared with the no_unique_address attribute (9.12.11 [dcl.attr.nouniqueaddr]), and either both entities are bit-fields with the same width or neither is a bit-field.

2771. Transformation for unqualified-ids in address operator

Section: 11.4.3 [class.mfct.non.static] Status: open Submitter: Jim X Date: 2023-07-16

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

48

According to 11.4.3 [] paragraph 2, the transformation to class member access does not happen for the id-expression a, because it is the unparenthesized operand of &:

When an id-expression (7.5.4 [expr.prim.id]) that is neither part of a class member access syntax (7.6.1.5 [expr.ref]) nor the un-parenthesized operand of the unary & operator (7.6.2.2 [expr.unary.op]) is used where the current class is X (7.5.2 [expr.prim.this]), if name lookup (6.5 [basic.lookup]) resolves the name in the id-expression to a non-static non-type member of some class C, and if either the id-expression is potentially evaluated or C is X or a base class of X, the id-expression is transformed into a class member access expression (7.6.1.5 [expr.ref]) using (*this) as the postfix-expression to the left of the . operator. [Note 1: If C is not X or a base class of X, the class member access expression is ill-formed. —end note] This transformation does not apply in the template definition context (13.8.3.2 [temp.dep.type]).

Possible resolution:

This resolution moves the transformation to 7.5.4.1 [expr.prim.id.general], where the similar transformation for anonymous unions is already described.

1. Change in 6.3 [] paragraph 7 as follows:

   *this is odr-used if this appears as a potentially-evaluated expression (including as the result of the any implicit transformation in the body of a non-static member function to a class member access expression (11.4.3 [class.mfct.non.static] 7.5.4.1 [expr.prim.id.general])).

2. Add a new paragraph before 7.5.4.1 [] paragraph 2: If an id-expression E denotes a non-static non-type member of some class C at a point where the current class (7.5.2 [expr.prim.this]) is X and

3. Change in 7.5.4.1 [] paragraph 3 as follows:

   An id-expression that denotes a non-static data member or implicit object member function of a class can only be used:

   as part of a class member access (7.6.1.5 [expr.ref]after any implicit transformation (see above)) in which the object expression refers to the member's class [ Footnote: This also applies when the object expression is an implicit (*this) (11.4.3 [class.mfct.non.static]).] or a class derived from that class, or
4. ...
5. Change in 7.5.4.2 [] paragraph 1 as follows: ... [ Note: ... Within the definition of a non-static member function, an identifier that names a non-static member is transformed to a class member access expression (11.4.3 [class.mfct.non.static]). —end note]
6. Remove 11.4.3 [] paragraph 2, including the example: When an id-expression (7.5.4 [expr.prim.id]) that is neither part of a class member access syntax (7.6.1.5 [expr.ref]) nor the un-parenthesized operand of the unary & operator (7.6.2.2 [expr.unary.op]) is used where the current class is X (7.5.2 [expr.prim.this]), if name lookup (6.5 [basic.lookup]) resolves the name in the id-expression to a non-static non-type member of some class C, and if either the id-expression is potentially evaluated or C is X or a base class of X, the id-expression is transformed into a class member access expression (7.6.1.5 [expr.ref]) using (*this) as the postfix-expression to the left of the . operator. [Note 1: If C is not X or a base class of X, the class member access expression is ill-formed. —end note] This transformation does not apply in the template definition context (13.8.3.2 [temp.dep.type]). [ Example: ... ]
7. Change in 13.8.3.1 [] paragraph 6 as follows: [ Example: ...

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

2743. Copying non-trivial objects nested within a union

Section: 11.4.5.3 [class.copy.ctor] Status: open Submitter: Jiang An Date: 2023-06-05

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

50

Subclause 11.4.5.3 [] paragraph 15 specifies:

The implicitly-defined copy/move constructor for a union X copies the object representation (6.8.1 [basic.types.general]) of X. For each object nested within (6.7.2 [intro.object]) the object that is the source of the copy, a corresponding object o nested within the destination is identified (if the object is a subobject) or created (otherwise), and the lifetime of o begins before the copy is performed.

Thus, the rule seems to require that

1 creates an object of type A inside v.buf (without invoking a constructor of A), and then a copy of the object representation is performed. Creating an object out of thin air can plausibly work only for implicit-lifetime types (11.2 [] paragraph 9), and meaningfully copying the object representation works only for trivially copyable types (6.8.1 [] paragraph 3). The rule about nested objects should be suitably limited.

Subclause 11.4.6 [] paragraph 13 has a similar rule for copy/move assignment:

The implicitly-defined copy/move assignment operator for a union X copies the object representation (6.8.1 [basic.types.general]) of X. If the source and destination of the assignment are not the same object, then for each object nested within (6.7.2 [intro.object]) the object that is the source of the copy, a corresponding object o nested within the destination is created, and the lifetime of o begins before the copy is performed.

Possible resolution:

1. Change in 11.4.5.3 [] paragraph 15 as follows:

   The implicitly-defined copy/move constructor for a union X copies the object representation (6.8.1 [basic.types.general]) of X. For each object of implicit-lifetime type (6.8.1 [basic.types.general]) nested within (6.7.2 [intro.object]) the object that is the source of the copy, a corresponding object o nested within the destination is identified (if the object is a subobject) or created (otherwise), and the lifetime of o begins before the copy is performed.

2. Change in 11.4.6 [] paragraph 13 as follows: The implicitly-defined copy/move assignment operator for a union X copies the object representation (6.8.1 [basic.types.general]) of X. If the source and destination of the assignment are not the same object, then for each object of implicit-lifetime type (6.8.1 [basic.types.general]) nested within (6.7.2 [intro.object]) the object that is the source of the copy, a corresponding object o nested within the destination is created, and the lifetime of o begins before the copy is performed.

2761. Implicitly invoking the deleted destructor of an anonymous union member

Section: 11.4.7 [class.dtor] Status: open Submitter: Corentin Jabot Date: 2023-07-11

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

51

Does the destructor of A attempt to destroy the (unnamed) data member that is the anonymous union? The latter has a deleted destructor per 11.4.7 [class.dtor]. For the default constructor, 11.9.3 [] paragraph 9.2 prevents the corresponding construction.

Possible resolution:

1. Change in 9.4.2 [] paragraph 9 as follows:

   The destructor for each element of class type other than an anonymous union member is potentially invoked (11.4.7 [class.dtor]) from the context where the aggregate initialization occurs

2. Change in 11.4.7 [] paragraph 13 as follows: After executing the body of the destructor and destroying any objects with automatic storage duration allocated within the body, a destructor for class X calls the destructors for X's direct non-variant non-static data members other than anonymous unions, the destructors for X's non-virtual direct base classes and, if X is the most derived class (11.9.3 [class.base.init]), its destructor calls the destructors for X's virtual base classes. All destructors are called as if they were referenced with a qualified name, that is, ignoring any possible virtual overriding destructors in more derived classes. Bases and members are destroyed in the reverse order of the completion of their constructor (see 11.9.3 [class.base.init]).
3. Change in 14.3 [] paragraph 3 as follows:

   A subobject is known to be initialized if it is not an anonymous union member and its initialization is specified

   in 11.9.3 [class.base.init] for initialization by constructor, in 11.4.5.3 [class.copy.ctor] for initialization by defaulted copy/move constructor, in 11.9.4 [class.inhctor.init] for initialization by inherited constructor, in 9.4.2 [dcl.init.aggr] for aggregate initialization, in 7.5.5.3 [expr.prim.lambda.capture] for the initialization of the closure object when evaluating a lambda-expression, in 9.4.1 [dcl.init.general] for default-initialization, value-initialization, or direct-initialization of an array.

2513. Ambiguity with requires-clause and operator-function-id

Section: 11.4.8.3 [class.conv.fct] Status: open Submitter: Richard Smith Date: 2021-12-09

An ambiguity can occur with a requires-clause that ends in an operator-function-id:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

52

Such cases are always ill-formed, because they involve an atomic constraint of non-bool type.

57. Empty unions

Section: 11.5 [class.union] Status: open Submitter: Steve Adamczyk Date: 13 Oct 1998

There doesn't seem to be a prohibition in 11.5 [class.union] against a declaration like

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

53 Should that be valid? If so, 9.4 [dcl.init] paragraph 5 third bullet, which deals with default-initialization of unions, should say that no initialization is done if there are no data members.

What about:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

54 If the first example is well-formed, should either or both of these cases be well-formed as well?

(See also the resolution for .)

Notes from 10/00 meeting: The resolution to , which was accepted as a DR, addresses the first point above (default initialization). The other questions have not yet been decided, however.

2675. start_lifetime_as, placement-new, and active union members

Section: 11.5.1 [class.union.general] Status: open Submitter: Nina Ranns Date: 2022-12-06

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

55

It is unclear which of these constructs changes the active member of the union, and whether a union might have more than one active member. Subclause 11.5.1 [] paragraph 2 appears contradictory if several members can be in-lifetime:

In a union, a non-static data member is active if its name refers to an object whose lifetime has begun and has not ended (6.7.3 [basic.life]). At most one of the non-static data members of an object of union type can be active at any time, that is, the value of at most one of the non-static data members can be stored in a union at any time.

Similar questions arise for placement-new and for construct_at; for the latter also during constant evaluation.

2767. Non-defining declarations of anonymous unions

Section: 11.5.2 [class.union.anon] Status: open Submitter: Hubert Tong Date: 2023-07-06

Currently, the specification permits this example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

56

However, those non-defining declarations seem to be mostly useless, because any definition attempt would violate the one-definition rule (6.3 [basic.def.odr]).

Possible resolution:

This resolution also addresses .

1. Split 11.5.2 [] paragraph 1 and change as follows:

   A union of the form A simple-declaration or member-declaration of the form

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

57 where one of the decl-specifiers is a class-specifier of the form

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

58 is called declares an anonymous union; it defines an unnamed type T and an unnamed object of that type cv T called an anonymous union member if it is a non-static data member or an anonymous union variable otherwise, where cv is determined from the cv-qualifiers of the declaration. The storage-class-specifier extern (9.2.2 [dcl.stc]) shall not be among the decl-specifiers declaring an anonymous union. The declaration of an anonymous union shall not be the name-declaration of a linkage-specification (9.11 [dcl.link]).

Each member-declaration in the member-specification of an anonymous union shall either define one or more public non-static data members or be a static_assert-declaration. Nested types, anonymous unions, and functions shall not be declared within an anonymous union. The names of the members of an anonymous union are bound in the scope inhabited by the union declaration.

2. Change in 11.5.2 [] paragraph 2 as follows: Anonymous unions declared in the scope of An anonymous union whose declaration inhabits a namespace scope with external linkage shall be declared static. Anonymous unions declared at block scope shall be declared with any storage class allowed for a block variable, or with no storage class. A storage class is not allowed in a declaration of an anonymous union in a class scope. An anonymous union whose declaration inhabits a class scope shall not be declared with a storage-class-specifier.

2773. Naming anonymous union members as class members

Section: 11.5.2 [class.union.anon] Status: open Submitter: Hubert Tong Date: 2023-07-16

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

59

According to 11.5.2 [] paragraph 1:

... The names of the members of an anonymous union are bound in the scope inhabited by the union declaration.

Thus, the example above is ill-formed, because the member names are not bound in the scope of the class of the anonymous union. However, there is implementation divergence: clang and gcc accept the example (contrary to the wording), icc rejects. Notwithstanding, this refers to the anonymous union itself, not to an enclosing class, per 7.5.2 [expr.prim.this]. This rule causes rejection of

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

60

Alternatively, this could be made to refer to the enclosing class object (already the status quo for some implementations). However, that would cause inconsistent treatment for examples like the following:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

61 vs.

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

62

Possible resolution:

tbd

1699. Does befriending a class befriend its friends?

Section: 11.8.4 [class.friend] Status: open Submitter: David Krauss Date: 2013-06-12 Liaison: EWG

According to 11.8.4 [] paragraph 2,

Declaring a class to be a friend implies that the names of private and protected members from the class granting friendship can be accessed in the base-specifiers and member declarations of the befriended class.

A friend declaration is a member-declaration, but it is not clear how far the granting of friendship goes in a friend declaration. For example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

63

In particular, if a friend function is defined inside the class definition, as in

3, does its definition have access to the private and protected members of the befriending class? Implementations vary on this point.

Additional note (June, 2021):

The initial opinion of CWG (at the September, 2013 meeting) was that “member declarations” was intended to be the English equivalent of the syntactic nonterminal member-declaration, including a friend declaration/definition inside the member-specification of a class, making

3 well-formed. However, recent discussion has expressed concern over the different treatment of in-class and out-of-class definitions of friend functions and observed that there is still divergence among implementations.

Rationale (November, 2021):

There are two lines of analysis that lead to opposite conclusions. The first is that a friend defined within the member-specification is written by the class author and is effectively part of the class, not subject to hijacking by other declarations, and thus should be afforded the same access as all other declarations that are part of the class. The second is that giving different access to a friend function based simply on whether it was defined inside or outside of its befriending class is confusing.

CWG considered this to be a design-level question, not simply to be determined by the usual relationship between English and grammar terms, and thus is asking EWG for its opinion.

Additional note (May, 2023)

Forwarded to EWG via cplusplus/papers

1573.

2244. Base class access in aggregate initialization

Section: 11.8.5 [class.protected] Status: open Submitter: Richard Smith Date: 2016-03-08

The rules in 11.8.5 [class.protected] assume an object expression, perhaps implicit, that can be used to determine whether access to protected members is permitted or not. It is not clear how that applies to aggregates and constructors. For example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

64

Notes from the December, 2016 teleconference:

The consensus favored accepting f and g while rejecting h.

Notes from the March, 2018 meeting:

CWG affirmed the earlier direction and felt that there should be an implicit object expression assumed for these cases.

1915. Potentially-invoked destructors in non-throwing constructors

Section: 11.9.3 [class.base.init] Status: open Submitter: Aaron Ballman Date: 2014-04-15 Liaison: EWG

The requirement in 11.9.3 [] paragraph 10,

In a non-delegating constructor, the destructor for each potentially constructed subobject of class type is potentially invoked (11.4.7 [class.dtor]). [Note: This provision ensures that destructors can be called for fully-constructed sub-objects in case an exception is thrown (14.3 [except.ctor]). —end note]

is needlessly restrictive, preventing otherwise-reasonable code like

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

65

Since the derived class constructor is non-throwing, the deleted base class destructor need not be referenced.

Suggested resolution:

Change 11.9.3 [] paragraph 10 as follows:

In a non-delegating constructor without a non-throwing exception-specification (14.5 [except.spec]), the destructor for each potentially constructed subobject of class type is potentially invoked (11.4.7 [class.dtor]). [Note: This provision ensures that destructors can be called for fully-constructed sub-objects in case an exception is thrown (14.3 [except.ctor]) but does not prevent explicitly deleted destructors in the presence of a non-throwing constructor. —end note]

Rationale (June, 2014):

This request for a language change should be evaluated by EWG before any action is taken.

EWG 2022-11-11

This is a defect, but has ABI impact that should be explored in a paper to EWG. This is tracked in github issue cplusplus/papers

1371.

2669. Lifetime extension for aggregate initialization

Section: 11.9.3 [class.base.init] Status: open Submitter: Ed Catmur Date: 2022-12-18 Liaison: EWG

presented a subset of the following examples:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

66

was adopted, ostensibly resolving , but the wording changes in 11.9.3 [] paragraph 11 affected only the behavior of constructors, not of aggregate initialization:

A temporary expression bound to a reference member from a default member initializer is ill-formed. [ Example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

67 -- end example]

There is considerable implementation variance:

1 is rejected by clang, but accepted by gcc and EDG (with early destruction of the temporary);

2 is uniformly accepted and the lifetime of the temporary is extended;

3 is uniformly accepted, but only gcc, clang, and MSVC extend the lifetime of the temporary, whereas EDG does not.

Note that 9.4.1 [] paragraph 7 specifies that default-initialization of aggregates is as-if the initializer () is used:

To default-initialize an object of type T means: If T is a (possibly cv-qualified) class type (Clause 11 [class]), constructors are considered. The applicable constructors are enumerated (12.2.2.4 [over.match.ctor]), and the best one for the initializer () is chosen through overload resolution (12.2 [over.match]). The constructor thus selected is called, with an empty argument list, to initialize the object. If T is an array type, each element is default-initialized.

• Otherwise, no initialization is performed.

Such treatment causes early destruction of temporaries per 6.7.7 [] bullet 6.10:

The exceptions to this lifetime rule are: ... A temporary object bound to a reference element of an aggregate of class type initialized from a parenthesized expression-list (9.4 [dcl.init]) persists until the completion of the full-expression containing the expression-list.

CWG 2023-05-12

CWG is soliciting the design guidance of EWG to resolve this issue, in particular for examples

3 and

6. For each of the presented examples, the standard should say whether the use is well-formed or not and whether the lifetime of the temporary is extended. It is also conceivable to implicitly delete the constructor being invoked (if any).

• 1 is default-initialization, invoking the default constructor of B. This is ill-formed per 11.9.3 [] paragraph 11. The rationale is that the temporary would not be lifetime-extended, causing a dangling reference as soon as the constructor returns. The presence of a hypothetically lifetime-extended temporary cannot be persisted from the constructor invocation to the eventual destruction of the object.

• 2 is aggregate initialization; the temporary in the braced-init-list is lifetime-extended per 6.7.7 [] paragraph 6. Since the temporary is created in the initializer and not inside a constructor invocation, tracking the lifetime of the temporary is equivalent to tracking the lifetime of the variable b2, so extending the lifetime of the temporary is feasible and avoids a dangling reference.

• 3 might be perceived as value-initialization, but is in fact also aggregate initialization; the status quo wording lifetime-extend the temporary per 6.7.7 [] paragraph 6. However, that is inconsistent with

  4.

• 4 is value-initialization; the default constructor is invoked per 9.4.1 [] bullet 16.6.2.1, which is ill-formed similar to

  1.

• 5 is aggregate-by-parentheses initialization. Consistent with other parenthesized initialization, the lifetime of temporaries is not extended (6.7.7 [] bullet 6.10).

• 6 is also aggregate-by-parentheses initialization; a constructor is not invoked and the lifetime of the temporary is not extended per 6.7.7 [] bullet 6.10, causing a dangling reference. However, despite the hidden temporary, this use is not ill-formed, because 11.9.3 [class.base.init] does not apply to aggregate initialization.

• Finally,

  7 shows a situation where, unlike

  6, the short lifetime of the hidden temporary is not an issue.

  CWG recommends to leave

  3 as-is and to make

  6 (and thus

  7) ill-formed. The trigger is the use of a default member initializer for a reference member that causes binding a temporary to that reference.

Forwarded to EWG via cplusplus/papers

1511.

2757. Deleting or deallocating storage of an object during its construction

Section: 11.9.5 [class.cdtor] Status: open Submitter: Jiang An Date: 2023-06-14

Subclause 6.7.3 [] paragraph 6 specifies:

... For an object under construction or destruction, see 11.9.5 [class.cdtor]. Otherwise, ...

However, the referenced subclause does not discuss deleting the object or deallocating its storage.

See also .

Possible resolution:

Insert before 11.9.5 [] paragraph 2 as follows:

During the construction or destruction of an object, evaluating a delete-expression with an operand that points to the object or releasing or reusing (6.7.3 [basic.life]) the storage which the object occupies is undefined behavior. [ Note: Creating an object nested within some object o does not reuse the storage for o. end note ] [ Example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

68

\ end example ] During the construction of an object, if the value of the object ...

1049. Copy elision through reference parameters of inline functions

Section: 11.9.6 [class.copy.elision] Status: open Submitter: Jason Merrill Date: 2010-03-10

Consider the following example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

69

Here we would like to be able to avoid the copy and just construct the A() directly into the A subobject of B. But we can't, because it isn't allowed by 11.4.5.3 [] bullet 34.3:

• when a temporary class object that has not been bound to a reference (6.7.7 [class.temporary]) would be copied/moved to a class object with the same cv-unqualified type, the copy/move operation can be omitted by constructing the temporary object directly into the target of the omitted copy/move

The part about not being bound to a reference was added for an unrelated reason by . If that resolution were recast to require that the temporary object is not accessed after the copy, rather than banning the reference binding, this optimization could be applied.

The similar example using pass by value is also not one of the allowed cases, which could be considered part of .

CWG 2023-05-12

This is a plausible optimization opportunity whose detailed specification requires a paper.

2762. Type of implicit object parameter

Section: 12.2.2.1 [over.match.funcs.general] Status: open Submitter: Jim X Date: 2023-07-11

Subclause 12.2.2.1 [] paragraph 4 specifies:

For implicit object member functions, the type of the implicit object parameter is “lvalue reference to cv X” for functions declared without a ref-qualifier or with the & ref-qualifier “rvalue reference to cv X” for functions declared with the && ref-qualifier where X is the class of which the function is a member and cv is the cv-qualification on the member function declaration.

Since a member of some class C is also a member of any class derived from C, this specification is unclear.

Possible resolution:

Change in 12.2.2.1 [] paragraph 4 as follows:

For implicit object member functions, the type of the implicit object parameter is “lvalue reference to cv X” for functions declared without a ref-qualifier or with the & ref-qualifier “rvalue reference to cv X” for functions declared with the && ref-qualifier where X is the class of which the function is a direct member and cv is the cv-qualification on the member function declaration.

2189. Surrogate call template

Section: 12.2.2.2.3 [over.call.object] Status: open Submitter: Jason Merrill Date: 2015-10-22

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

70 12.2.2.2.3 [over.call.object] describes how conversion functions to pointer/reference to function work in overload resolution, but is silent about conversion function templates. Generalizing the wording there, in this case we could generate a surrogate conversion template

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

71 which would work as expected. But it seems that implementations don't actually do this currently.

545. User-defined conversions and built-in operator overload resolution

Section: 12.2.2.3 [over.match.oper] Status: open Submitter: Steve Clamage Date: 31 October 2005

Consider the following example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

72

According to 12.5 [] paragraph 16, there is an operator== for PD (“For every pointer to member type...”), so why wouldn't it be used for this comparison?

Mike Miller: The problem, as I understand it, is that 12.2.2.3 [] paragraph 3, bullet 3, sub-bullet 3 is broader than it was intended to be. It says that candidate built-in operators must “accept operand types to which the given operand or operands can be converted according to 12.2.4.2 [over.best.ics].” 12.2.4.2.3 [over.ics.user] describes user-defined conversions as having a second standard conversion sequence, and there is nothing to restrict that second standard conversion sequence.

My initial thought on addressing this would be to say that user-defined conversion sequences whose second standard conversion sequence contains a pointer conversion or a pointer-to-member conversion are not considered when selecting built-in candidate operator functions. They would still be applicable after the hand-off to Clause 5 (e.g., in bringing the operands to their common type, 7.6.10 [expr.eq], or composite pointer type, 7.6.9 [expr.rel]), just not in constructing the list of built-in candidate operator functions.

I started to suggest restricting the second standard conversion sequence to conversions having Promotion or Exact Match rank, but that would exclude the Boolean conversions, which are needed for !, &&, and ||. (It would have also restricted the floating-integral conversions, though, which might be a good idea. They can't be used implicitly, I think, because there would be an ambiguity among all the promoted integral types; however, none of the compilers I tested even tried those conversions because the errors I got were not ambiguities but things like “floating point operands not allowed for %”.)

Bill Gibbons: I recall seeing this problem before, though possibly not in committee discussions. As written this rule makes the set of candidate functions dependent on what classes have been defined, including classes not otherwise required to have been defined in order for "==" to be meaningful. For templates this implies that the set is dependent on what templates have been instantiated, e.g.

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

73

There may be other places where the existence of a class definition, or worse, a template instantiation, changes the semantics of an otherwise valid program (e.g. pointer conversions?) but it seems like something to be avoided.

(See also .)

1919. Overload resolution for ! with explicit conversion operator

Section: 12.2.2.3 [over.match.oper] Status: open Submitter: Johannes Schaub Date: 2014-04-30

Although the intent is that the ! operator should be usable with an operand that is a class object having an explicit conversion to bool (i.e., its operand is “contextually converted to bool”), the selection of the conversion operator is done via 12.2.2.3 [over.match.oper], 12.2.3 [over.match.viable], and 12.2.4 [over.match.best], which do not make specific allowance for this special characteristic of the ! operator and thus will not select the explicit conversion function.

Notes from the June, 2014 meeting:

CWG noted that this same issue affects && and ||.

2730. Comparison templates on enumeration types

Section: 12.2.2.3 [over.match.oper] Status: open Submitter: Tobias Loew Date: 2023-05-11

Equality and relational comparisons are supported for all enumeration types, even for scoped enumerations, as specified in 12.5 [] paragraph 15 and 7.6.9 [] paragraph 6:

If both operands (after conversions) are of arithmetic or enumeration type, each of the operators shall yield true if the specified relationship is true and false if it is false.

The comparisons can be overloaded using a non-template function, for example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

74

However, using a function template does not work:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

75

The reason is that the built-in operator candidates are not suppressed if they compete with a template specialization.

Suggested resolution:

Change in 12.2.2.3 [] bullet 3.3.4 as follows:

* do not have the same parameter-type-list as any non-member candidate or rewritten non-member candidate that is not a function template specialization.

2311. Missed case for guaranteed copy elision

Section: 12.2.2.8 [over.match.list] Status: open Submitter: Richard Smith Date: 2016-08-09

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

76

We reach 9.4.5 [] bullet 3.7:

Otherwise, if T is a class type, constructors are considered. The applicable constructors are enumerated and the best one is chosen through overload resolution (12.2 [over.match], 12.2.2.8 [over.match.list]).

This means we perform a redundant copy. If T were an aggregate, 9.4.5 [] bullet 3.2 would avoid the redundant copy:

If T is an aggregate class and the initializer list has a single element of type cv U, where U is T or a class derived from T, the object is initialized from that element (by copy-initialization for copy-list-initialization, or by direct-initialization for direct-list-initialization).

See also issues and .

2425. Confusing wording for deduction from a type

Section: 12.2.2.9 [over.match.class.deduct] Status: open Submitter: Dawn Perchik Date: 2019-08-06

In 12.2.2.9 [] paragraph 3 we read:

The arguments of a template A are said to be deducible from a type T if, given a class template

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

77

with a single partial specialization whose template parameter list is that of A and whose template argument list is a specialization of A with the template argument list of A (13.8.3.2 [temp.dep.type]), AA matches the partial specialization.

The relationship between A, AA and its partial specialization, and the argument list of A is not clear. An example would be very helpful here. Also, using a different name than A would help, since A is used in close proximity to this wording to denote an alias template, while this wording applies to both class and alias templates. Finally, there should be a cross-reference to 13.7.6.2 [temp.spec.partial.match] for matching the partial specialization.

2628. Implicit deduction guides should propagate constraints

Section: 12.2.2.9 [over.match.class.deduct] Status: open Submitter: Roy Jacobson Date: 2022-09-11

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

78

According to 12.2.2.9 [] bullet 1.1, the requires-clause of the constructor is not propagated to the function template synthesized for the implicit deduction guide, making the implicit deduction guide ambiguous with the user-provided one. The example ought to be valid.

Possible resolution:

Change in 12.2.2.9 [] bullet 1.1 as follows:

If C is defined, for each constructor of C, a function template with the following properties: The template parameters are the template parameters of C followed by the template parameters (including default template arguments) of the constructor, if any. The associated constraints (13.5.3 [temp.constr.decl]) are the conjunction of the associated constraints of C and the associated constraints of the constructor. The types of the function parameters are those of the constructor.

• The return type is the class template specialization designated by C and template arguments corresponding to the template parameters of C.

2680. Class template argument deduction for aggregates with designated initializers

Section: 12.2.2.9 [over.match.class.deduct] Status: open Submitter: Christof Meerwald Date: 2023-01-09

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

79

and

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

80

Class template argument deduction does not limit deduction to the aggregate deduction candidate when a designated initializer list is used.

Suggested resolution:

1. Change in 12.2.2.9 [] paragraph 1 as follows:

   ... If the initializer has a designated-initializer-list, any guide that is not an aggregate deduction candidate is not viable; for an aggregate deduction candidate, the designated-initializer-list is replaced by an initializer-list with the same elements. In addition, if C is defined and inherits constructors (9.9 [namespace.udecl]) from a direct base class ...

2. Change in 12.2.2.9 [] bullet 3.5 as follows: ... If f was generated from a deduction-guide (13.7.2.3 [temp.deduct.guide]), then f' is considered to be so as well.
3. If f was generated from an aggregate deduction guide, then f' is considered to be so as well.

2714. Implicit deduction guides omit properties from the parameter-declaration-clause of a constructor

Section: 12.2.2.9 [over.match.class.deduct] Status: open Submitter: Richard Smith Date: 2017-02-13

Subclause 12.2.2.9 [] bullet 1.1.2 specifies:

* The types of the function parameters are those of the constructor.

However, this does not consider default arguments or variadic constructors.

Proposed resolution (approved by CWG 2023-04-28):

(This also resolves .)

Change in 12.2.2.9 [] paragraph 1 as follows:

If C is defined, for each constructor of C, a function template with the following properties: The template parameters are the template parameters of C followed by the template parameters (including default template arguments) of the constructor, if any. The associated constraints (13.5.3 [temp.constr.decl]) are the conjunction of the associated constraints of C and the associated constraints of the constructor, if any. [ Note: A constraint-expression in the template-head of C is checked for satisfaction before any constraints from the template-head or trailing-requires-clause of the constructor. -- end note ] The types of the function parameters are those parameter-declaration-clause is that of the constructor. The return type is the class template specialization designated by C and template arguments corresponding to the template parameters of C. If C is not defined or does not declare any constructors, an additional function template derived as above from a hypothetical constructor C(). An additional function template derived as above from a hypothetical constructor C(C), called the copy deduction candidate. For each deduction-guide, a function or function template with the following properties: The template parameters template-head, if any, and function parameters parameter-declaration-clause are those of the deduction-guide. The return type is the simple-template-id of the deduction-guide.

2735. List-initialization and conversions in overload resolution

Section: 12.2.4 [over.match.best] Status: open Submitter: Jason Merrill Date: 2023-03-23

There is implementation divergence in handling the following example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

81

The following example is ambiguous per :

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

82

The copy constructor of wrap<...> becomes viable, by way of constructing another wrap object from the given initializer list using the explicit constructor template. It looks like a deleted copy constructor is used to remove a level of braces, and then picking an explicit constructor to construct the source of the copy.

Another example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

83

The intent is to construct the map with a single key-value pair, but the list-initialization is ambiguous with invoking the copy constructor and creating a map from a pair of iterators given by {"foo", "bar"}.

And another example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

84

The ambiguity is between

• calling the X(const Z&) constructor with {} and
• calling the X(const X&) constructor and using the explicit default constructor to construct a temporary X.

Core is also related.

Suggested resolution:

Insert before 12.2.4.1 [] bullet 2.4 as follows:

... F2 is a copy or move special member function where the implicit conversion sequence for its (non-object) argument is a user-defined conversion sequence specified by a non-converting constructor (considered under 12.2.2.8 [over.match.list]) and F1 is not, or, if not that, [ Example: static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char s = "x";

static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true 85 -- end example ]

F1 is not a function template specialization and F2 is a function template specialization, or, if not that,

• ...

2679. Implicit conversion sequence with a null pointer constant

Section: 12.2.4.2.1 [over.best.ics.general] Status: open Submitter: Lénárd Szolnoki Date: 2023-01-07

Subclause 12.2.4.2.1 [] paragraph 1, as modified by , claims that only the type, cv-qualification, and value category of the argument are relevant in forming an implicit conversion sequence. This is inaccurate for the following situations:

• A literal 0 can be implicitly converted to a parameter of type void* (and in practice, an implicit conversion sequence does exist), yet the literal 0 has the same type, cv-qualification, and value category as the literal 1 despite no such implicit conversion being allowed for the latter.
• An initializer list does not have a type, cv-qualification, or value category at all.
• An overload set does not have a single (function) type.

2731. List-initialization sequence with a user-defined conversion

Section: 12.2.4.2.3 [over.ics.user] Status: open Submitter: Brian Bi Date: 2023-05-11

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

86

Subclause 12.2.4.2.3 [] paragraph 1 specifies:

A user-defined conversion sequence consists of an initial standard conversion sequence followed by a user-defined conversion (11.4.8 [class.conv]) followed by a second standard conversion sequence. If the user-defined conversion is specified by a constructor (11.4.8.2 [class.conv.ctor]), the initial standard conversion sequence converts the source type to the type of the first parameter of that constructor. ...

However, there is no "source type" for an initializer list, making the treatment of the example unclear.

Suggested resolution:

Change in 12.2.4.2.6 [] bullet 7.2 as follows:

... Otherwise, the implicit conversion sequence is a user-defined conversion sequence whose user-defined conversion is specified by the constructor C and whose first and second standard conversion sequence is an sequences are identity conversion conversions.

2169. Narrowing conversions and overload resolution

Section: 12.2.4.2.6 [over.ics.list] Status: open Submitter: David Krauss Date: 2015-08-26

Current implementations ignore narrowing conversions during overload resolution, emitting a diagnostic if calling the selected function would involve narrowing. For example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

87

However, the current wording of 12.2.4.2.6 [] paragraph 7 says,

Otherwise, if the parameter has an aggregate type which can be initialized from the initializer list according to the rules for aggregate initialization (9.4.2 [dcl.init.aggr]), the implicit conversion sequence is a user-defined conversion sequence with the second standard conversion sequence an identity conversion.

In the example above, ss cannot be initialized from { 1000000 } because of the narrowing conversion, so presumably f(ss) should not be considered. If this is not the intended outcome, paragraph 7 should be restated in terms of having an implicit conversion sequence, as in, e.g., bullet 9.1, instead of a valid initialization.

Rationale (March, 2016):

This is a question of language design and thus more suited to consideration by EWG.

EWG (January, 2021):

Adjust the standard to follow existing implementations. See .

Additional notes (March, 2023)

A narrowing conversion is but one of the many circumstances that could make a conversion ill-formed despite the existence of an implicit conversion sequence. Other examples (with implementation divergence) are invoking a private or deleted function, binding a non-const reference to a bit-field, invoking an explicit constructor in list-initialization, invoking a consteval constructor with unsuitable arguments, or initializing an aggregate with incorrectly-ordered designated initializers. A resolution of this issue should thus not be focused on narrow conversions.

2741. Implicit conversion sequence from empty list to array of unknown bound

Section: 12.2.4.2.6 [over.ics.list] Status: open Submitter: Richard Smith Date: 2023-06-01

Consider:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

88

Subclause 12.2.4.2.6 [] paragraph 6 specifies:

Otherwise, if the parameter type is “array of N X” or “array of unknown bound of X”, if there exists an implicit conversion sequence from each element of the initializer list (and from {} in the former case if N exceeds the number of elements in the initializer list) to X, the implicit conversion sequence is the worst such implicit conversion sequence.

What is the "worst [...] implicit conversion sequence" when the initializer list is empty? Should

1 even be viable for this call, given that it's not valid to initialize an int const (&)[] from {}?

There is implementation divergence: Clang and MSVC treat

1 as being non-viable; GCC calls

1 and creates a temporary of type `int[0]` (even in -pedantic-errors mode). Should the "worst conversion sequence" over an empty set be the identity conversion, selecting

1 and then failing the parameter initialization?

1459. Reference-binding tiebreakers in overload resolution

Section: 12.2.4.3 [over.ics.rank] Status: open Submitter: Jason Merrill Date: 2012-02-07

Both paragraph 3 and paragraph 4 of 12.2.4.3 [over.ics.rank] have overload resolution tiebreakers for reference binding. It might be possible to merge those into a single treatment.

1789. Array reference vs array decay in overload resolution

Section: 12.2.4.3 [over.ics.rank] Status: open Submitter: Faisal Vali Date: 2013-10-01

The current rules make an example like

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

89

ambiguous, even though the first is an identity match and the second requires an lvalue transformation. Is this desirable?

Proposed resolution (June, 2021):

Add the following as a new bullet following 12.2.4.3 [over.ics.rank] bullet 3.2.6:

Two implicit conversion sequences of the same form are indistinguishable conversion sequences unless one of the following rules applies: List-initialization sequence L1 is a better conversion sequence... Standard conversion sequence S1 is a better conversion sequence than standard conversion sequence S2 if ... S1 and S2 include reference bindings (9.4.4 [dcl.init.ref]), and the types to which the references refer are the same type except for top-level cv-qualifiers, and the type to which the reference initialized by S2 refers is more cv-qualified than the type to which the reference initialized by S1 refers. [Example 6:...

• S1 is a reference binding to an array and S2 is an array-to-pointer conversion (7.3.3 [conv.array]). [Example 7: static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true 90 —end example]

CWG 2023-02-06

The proposed resolution prefers the T& overload over the T* overload in the example below, which is undesirable. The wording needs to be amended to limit the tiebreaker to situations where the array declarator appears in the signature.

static const char test1 = 'x';

static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

91

2337. Incorrect implication of logic ladder for conversion sequence tiebreakers

Section: 12.2.4.3 [over.ics.rank] Status: open Submitter: Richard Smith Date: 2017-03-02

The bulleted list of 12.2.4.3 [] paragraph 3 consists of a logic ladder of the form “A is better than B if [some predicate relating A to B], or, if not that, ...” For example, bullet 3.1 says,

• List-initialization sequence L1 is a better conversion sequence than list-initialization sequence L2 if
  • L1 converts to std::initializer_list for some X and L2 does not, or, if not that,
  • L1 converts to type “array of N1 T”, L2 converts to type “array of N2 T”, and N1 is smaller than N2 ,

The intent is not to fall into the array case if L2 converts to std::initializer_list and L1 does not — i.e., the inverse predicate holds — but that intent is not well reflected in the actual wording.

1549. Overloaded comma operator with void operand

Section: 12.4.3 [over.binary] Status: open Submitter: Nikolay Ivchenkov Date: 2012-09-04

Even though a function cannot take a parameter of type void, the current rules for overload resolution require consideration of overloaded operators when one operand has a user-defined or enumeration type and the other has type void. This can result in side effects and possibly errors, for example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

92

260. User-defined conversions and built-in operator=

Section: 12.5 [over.built] Status: open Submitter: Scott Douglas Date: 4 Nov 2000

According to the Standard (although not implemented this way in most implementations), the following code exhibits non-intuitive behavior:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

93

The reason for this choice is 12.5 [] paragraph 18:

For every triple (L, VQ, R), where L is an arithmetic type, VQ is either volatile or empty, and R is a promoted arithmetic type, there exist candidate operator functions of the form VQ L& operator=(VQ L&, R);

Because R is a "promoted arithmetic type," the second argument to the built-in assignment operator is int, causing the unexpected choice of conversion function.

Suggested resolution: Provide built-in assignment operators for the unpromoted arithmetic types.

Related to the preceding, but not resolved by the suggested resolution, is the following problem. Given:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

94

I believe the standard requires the following assignment to be ambiguous (even though I expect that would surprise the user):

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

95

The problem is that both of these built-in operator=()s exist (12.5 [] paragraph 18):

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

96

Both are an exact match on the first argument and a user conversion on the second. There is no rule that says one is a better match than the other.

The compilers that I have tried (even in their strictest setting) do not give a peep. I think they are not following the standard. They pick double& operator=(double&, double) and use T::operator double() const.

I hesitate to suggest changes to overload resolution, but a possible resolution might be to introduce a rule that, for built-in operator= only, also considers the conversion sequence from the second to the first type. This would also resolve the earlier question.

It would still leave x += t etc. ambiguous -- which might be the desired behavior and is the current behavior of some compilers.

Notes from the 04/01 meeting:

The difference between initialization and assignment is disturbing. On the other hand, promotion is ubiquitous in the language, and this is the beginning of a very slippery slope (as the second report above demonstrates).

Additional note (August, 2010):

See for a similar example involving comparison operators.

954. Overload resolution of conversion operator templates with built-in types

Section: 12.5 [over.built] Status: open Submitter: Steve Clamage Date: 19 August, 2009

Consider the following example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

97

The comparison at

1 is, according to the current Standard, ambiguous. According to 12.5 [] paragraph 12, the candidates for operator==(L, R) include functions “for every pair of promoted arithmetic types,” so L could be either int or long, and the conversion operator template will provide an exact match for either.

Some implementations unambiguously choose the int candidate. Perhaps the overload resolution rules could be tweaked to prefer candidates in which L and R are the same type?

(See also .)

1620. User-defined literals and extended integer types

Section: 12.6 [over.literal] Status: open Submitter: Jason Merrill Date: 2013-02-12

Although numeric literals can have extended integer types, user-defined literal operators cannot have a parameter of an extended integer type. This seems like an oversight.

2777. Type of id-expression denoting a template parameter object

Section: 13.2 [temp.param] Status: open Submitter: Jim X Date: 2023-07-26

The type of a template parameter object is specified to be const T in 13.2 [] paragraph 8:

An id-expression naming a non-type template-parameter of class type T denotes a static storage duration object of type const T, known as a template parameter object, whose value is that of the corresponding template argument after it has been converted to the type of the template-parameter. ...

However, it is unclear what the type of an id-expression is that refers to such an object. There is implementation divergence in the treatment of the following example:

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

98

Note that non-type template parameters are handled specially for decltype, as specified in 9.2.9.5 [] paragraph 1:

For an expression E, the type denoted by decltype(E) is defined as follows: ... otherwise, if E is an unparenthesized id-expression naming a non-type template-parameter (13.2 [temp.param]), decltype(E) is the type of the template-parameter after performing any necessary type deduction (9.2.9.6 [dcl.spec.auto], 9.2.9.7 [dcl.type.class.deduct]);

• ...

Possible resolution:

Change in 7.5.4.2 [] paragraph 3 as follows:

[Note 4: If the entity is a template parameter object for a template parameter of type T (13.2 [temp.param]), the type of the expression is const T. —end note] In all other case, the type of the expression is the type of the entity.

579. What is a “nested” > or >>?

Section: 13.3 [temp.names] Status: open Submitter: Daveed Vandevoorde Date: 11 May 2006

The Standard does not normatively define which > and >> tokens are to be taken as closing a template-argument-list; instead, 13.3 [] paragraph 3 uses the undefined and imprecise term “non-nested:”

When parsing a template-id, the first non-nested > is taken as the end of the template-argument-list rather than a greater-than operator. Similarly, the first non-nested >> is treated as two consecutive but distinct > tokens, the first of which is taken as the end of the template-argument-list and completes the template-id.

The (non-normative) footnote clarifies that

A > that encloses the type-id of a dynamic_cast, static_cast, reinterpret_cast or const_cast, or which encloses the template-arguments of a subsequent template-id, is considered nested for the purpose of this description.

Aside from the questionable wording of this footnote (e.g., in what sense does a single terminating character “enclose” anything, and is a nested template-id “subsequent?”) and the fact that it is non-normative, it does not provide a complete definition of what “nesting” is intended to mean. For example, is the first > in this putative template-id “nested” or not?

static const char test1 = 'x'; static const char test2 = 'x'; const bool b = &test1 != &test2; // always true static const char (&r) [] = "x"; static const char *s = "x"; static std::initializer_list il = { 'x' }; const bool b2 = r != il.begin(); // unspecified result const bool b3 = r != s; // unspecified result const bool b4 = il.begin() != &test1; // always true const bool b5 = r != &test1; // always true

99

Additional note (January, 2014):

A similar problem exists for an operator> template:

template concept C = requires (typename T::type x) {

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;

x + 1;