[expr.call] - C++20 → C++23

Files changed (1) hide show

tmp/tmp10tyrmoz/{from.md → to.md} +34 -37

tmp/tmp10tyrmoz/{from.md → to.md} RENAMED Viewed

@@ -13,72 +13,69 @@ type. For a call to a non-member function or to a static member
 function, the postfix expression shall either be an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
 [[conv.func]] is suppressed on the postfix expression), or have function
 pointer type.
-For a call to a non-static member function, the postfix expression shall
-be an implicit ([[class.mfct.non-static]], [[class.static]]) or
-explicit class member access [[expr.ref]] whose *id-expression* is a
-function member name, or a pointer-to-member expression
-[[expr.mptr.oper]] selecting a function member; the call is as a member
-of the class object referred to by the object expression. In the case of
-an implicit class member access, the implied object is the one pointed
-to by `this`.
-[*Note 2*: A member function call of the form `f()` is interpreted as
-`(*this).f()` (see  [[class.mfct.non-static]]). — *end note*]
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
 *virtual function call*.
-[*Note 3*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
-[*Note 4*: If a function or member function name is used, and name
 lookup [[basic.lookup]] does not find a declaration of that name, the
 program is ill-formed. No function is implicitly declared by such a
 call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
 `virtual` keyword), even if the type of the function actually called is
-different. This return type shall be an object type, a reference type or
-cv `void`. If the *postfix-expression* names a pseudo-destructor (in
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
-denoted by the object expression of the class member access (
-[[expr.ref]], [[basic.life]]).
-Calling a function through an expression whose function type is
-different from the function type of the called function’s definition
-results in undefined behavior.
-When a function is called, each parameter [[dcl.fct]] is initialized (
-[[dcl.init]], [[class.copy.ctor]]) with its corresponding argument. If
-there is no corresponding argument, the default argument for the
-parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
-If the function is a non-static member function, the `this` parameter of
-the function [[class.this]] is initialized with a pointer to the object
-of the call, converted as if by an explicit type conversion
-[[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
 [[class.access.base]], and  [[expr.ref]]. — *end note*]
@@ -96,14 +93,14 @@ enclosing full-expression. The initialization and destruction of each
 parameter occurs within the context of the calling function.
 [*Example 2*: The access of the constructor, conversion functions or
 destructor is checked at the point of call in the calling function. If a
 constructor or destructor for a function parameter throws an exception,
-the search for a handler starts in the scope of the calling function; in
-particular, if the function called has a *function-try-block*
-[[except.pre]] with a handler that could handle the exception, this
-handler is not considered. — *end example*]
 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
@@ -159,14 +156,14 @@ statically chosen function.
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
 reference is to a const-qualified type, `const_cast` is required to be
 used to cast away the constness in order to modify the argument’s value.
 Where a parameter is of `const` reference type a temporary object is
-introduced if needed ([[dcl.type]], [[lex.literal]], [[lex.string]],
-[[dcl.array]], [[class.temporary]]). In addition, it is possible to
-modify the values of non-constant objects through pointer
-parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
 default arguments [[dcl.fct.default]]) or more arguments (by using the
 ellipsis, `...`, or a function parameter pack [[dcl.fct]]) than the
 number of parameters in the function definition [[dcl.fct.def]].

 function, the postfix expression shall either be an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
 [[conv.func]] is suppressed on the postfix expression), or have function
 pointer type.
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
 *virtual function call*.
+[*Note 2*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
+[*Note 3*: If a function or member function name is used, and name
 lookup [[basic.lookup]] does not find a declaration of that name, the
 program is ill-formed. No function is implicitly declared by such a
 call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
 `virtual` keyword), even if the type of the function actually called is
+different. If the *postfix-expression* names a pseudo-destructor (in
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
+denoted by the object expression of the class member access
+[[expr.ref]], [[basic.life]].
+Calling a function through an expression whose function type `E` is
+different from the function type `F` of the called function’s definition
+results in undefined behavior unless the type “pointer to `F`” can be
+converted to the type “pointer to `E`” via a function pointer conversion
+[[conv.fctptr]].
+[*Note 4*: The exception applies when the expression has the type of a
+potentially-throwing function, but the called function has a
+non-throwing exception specification, and the function types are
+otherwise the same. — *end note*]
+When a function is called, each parameter [[dcl.fct]] is initialized
+[[dcl.init]], [[class.copy.ctor]] with its corresponding argument. If
+the function is an explicit object member function and there is an
+implied object argument [[over.call.func]], the list of provided
+arguments is preceded by the implied object argument for the purposes of
+this correspondence. If there is no corresponding argument, the default
+argument for the parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
+If the function is an implicit object member function, the `this`
+parameter of the function [[expr.prim.this]] is initialized with a
+pointer to the object of the call, converted as if by an explicit type
+conversion [[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
 [[class.access.base]], and  [[expr.ref]]. — *end note*]
 parameter occurs within the context of the calling function.
 [*Example 2*: The access of the constructor, conversion functions or
 destructor is checked at the point of call in the calling function. If a
 constructor or destructor for a function parameter throws an exception,
+the search for a handler starts in the calling function; in particular,
+if the function called has a *function-try-block* [[except.pre]] with a
+handler that can handle the exception, this handler is not
+considered. — *end example*]
 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
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
 reference is to a const-qualified type, `const_cast` is required to be
 used to cast away the constness in order to modify the argument’s value.
 Where a parameter is of `const` reference type a temporary object is
+introduced if needed
+[[dcl.type]], [[lex.literal]], [[lex.string]], [[dcl.array]], [[class.temporary]].
+In addition, it is possible to modify the values of non-constant objects
+through pointer parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
 default arguments [[dcl.fct.default]]) or more arguments (by using the
 ellipsis, `...`, or a function parameter pack [[dcl.fct]]) than the
 number of parameters in the function definition [[dcl.fct.def]].

Diff to HTML by rtfpessoa