[expr.call] - C++14 → C++17

Files changed (1) hide show

tmp/tmppyp3xh1e/{from.md → to.md} +147 -110

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

@@ -1,151 +1,188 @@
 ### Function call <a id="expr.call">[[expr.call]]</a>
 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
-The postfix expression shall have function type or pointer to function
 type. For a call to a non-member function or to a static member
 function, the postfix expression shall be either 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
-it shall have pointer to function type. Calling a function through an
-expression whose function type has a language linkage that is different
-from the language linkage of the function type of the called function’s
-definition is undefined ([[dcl.link]]). 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`. a member
-function call of the form `f()` is interpreted as `(*this).f()` (see
-[[class.mfct.non-static]]). If a function or member function name is
-used, the name can be overloaded (Clause  [[over]]), in which case the
-appropriate function shall be selected according to the rules in
-[[over.match]]. 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*. 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.
-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.
 If the *postfix-expression* designates a destructor ([[class.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`.
 When a function is called, each parameter ([[dcl.fct]]) shall be
 initialized ([[dcl.init]],  [[class.copy]],  [[class.ctor]]) with its
-corresponding argument. Such initializations are indeterminately
-sequenced with respect to each other ([[intro.execution]]) If the
-function is a non-static member function, the `this` parameter of the
-function ([[class.this]]) shall be initialized with a pointer to the
-object of the call, converted as if by an explicit type conversion (
-[[expr.cast]]). 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]]. When
-a function is called, the parameters that have object type shall have
-completely-defined object type. this still allows a parameter to be a
-pointer or reference to an incomplete class type. However, it prevents a
-passed-by-value parameter to have an incomplete class type. During the
-initialization of a parameter, an implementation may avoid the
-construction of extra temporaries by combining the conversions on the
-associated argument and/or the construction of temporaries with the
-initialization of the parameter (see  [[class.temporary]]). The lifetime
-of a parameter ends when the function in which it is defined returns.
-The initialization and destruction of each parameter occurs within the
-context of the calling function. 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* (Clause  [[except]]) with a handler that could
-handle the exception, this handler is not considered. The value of a
-function call is the value returned by the called function except in a
-virtual function call if the return type of the final overrider is
-different from the return type of the statically chosen function, the
-value returned from the final overrider is converted to the return type
-of the statically chosen function.
-a function can change the values of its non-const 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 nonconstant objects through pointer parameters.
 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]]).
-this implies that, except where the ellipsis (`...`) or a function
-parameter pack is used, a parameter is available for each argument.
 When there is no parameter for a given argument, the argument is passed
 in such a way that the receiving function can obtain the value of the
-argument by invoking `va_arg` ([[support.runtime]]). This paragraph
-does not apply to arguments passed to a function parameter pack.
-Function parameter packs are expanded during template instantiation (
-[[temp.variadic]]), thus each such argument has a corresponding
-parameter when a function template specialization is actually called.
 The lvalue-to-rvalue ([[conv.lval]]), array-to-pointer (
 [[conv.array]]), and function-to-pointer ([[conv.func]]) standard
 conversions are performed on the argument expression. An argument that
-has (possibly cv-qualified) type `std::nullptr_t` is converted to type
-`void*` ([[conv.ptr]]). After these conversions, if the argument does
-not have arithmetic, enumeration, pointer, pointer to member, or class
-type, the program is ill-formed. Passing a potentially-evaluated
-argument of class type (Clause  [[class]]) having a non-trivial copy
-constructor, a non-trivial move constructor, or a non-trivial
-destructor, with no corresponding parameter, is conditionally-supported
-with *implementation-defined* semantics. If the argument has integral or
 enumeration type that is subject to the integral promotions (
-[[conv.prom]]), or a floating point type that is subject to the floating
-point promotion ([[conv.fpprom]]), the value of the argument is
-converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
-The evaluations of the postfix expression and of the arguments are all
-unsequenced relative to one another. All side effects of argument
-evaluations are sequenced before the function is entered (see
-[[intro.execution]]).
 Recursive calls are permitted, except to the `main` function (
 [[basic.start.main]]).
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
 type is an rvalue reference to object type, and a prvalue otherwise.
-If a function call is a prvalue of object type:
-- if the function call is either
-  - the operand of a *decltype-specifier* or
-  - the right operand of a comma operator that is the operand of a
-    *decltype-specifier*,
-  a temporary object is not introduced for the prvalue. The type of the
-  prvalue may be incomplete. as a result, storage is not allocated for
-  the prvalue and it is not destroyed; thus, a class type is not
-  instantiated as a result of being the type of a function call in this
-  context. This is true regardless of whether the expression uses
-  function call notation or operator notation ([[over.match.oper]]).
-  unlike the rule for a *decltype-specifier* that considers whether an
-  *id-expression* is parenthesized ([[dcl.type.simple]]), parentheses
-  have no special meaning in this context.
-- otherwise, the type of the prvalue shall be complete.

 ### Function call <a id="expr.call">[[expr.call]]</a>
 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
+The postfix expression shall have function type or function pointer
 type. For a call to a non-member function or to a static member
 function, the postfix expression shall be either 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
+it shall have function pointer type. 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 (
+[[dcl.link]]). 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 1*: A member function call of the form `f()` is interpreted as
+`(*this).f()` (see  [[class.mfct.non-static]]). — *end note*]
+If a function or member function name is used, the name can be
+overloaded (Clause  [[over]]), in which case the appropriate function
+shall be selected according to the rules in  [[over.match]]. 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* designates a destructor ([[class.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`.
 When a function is called, each parameter ([[dcl.fct]]) shall be
 initialized ([[dcl.init]],  [[class.copy]],  [[class.ctor]]) with its
+corresponding argument. If the function is a non-static member function,
+the `this` parameter of the function ([[class.this]]) shall be
+initialized with a pointer to the object of the call, converted as if by
+an explicit type conversion ([[expr.cast]]).
+[*Note 4*: 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*]
+When a function is called, the parameters that have object type shall
+have completely-defined object type.
+[*Note 5*: this still allows a parameter to be a pointer or reference
+to an incomplete class type. However, it prevents a passed-by-value
+parameter to have an incomplete class type. — *end note*]
+It is *implementation-defined* whether the lifetime of a parameter ends
+when the function in which it is defined returns or at the end of the
+enclosing full-expression. The initialization and destruction of each
+parameter occurs within the context of the calling function.
+[*Example 1*: 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* (Clause
+[[except]]) 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
+parameter.
+[*Note 6*: All side effects of argument evaluations are sequenced
+before the function is entered (see
+[[intro.execution]]). — *end note*]
+[*Example 2*:
+``` cpp
+void f() {
+  std::string s = "but I have heard it works even if you don't believe in it";
+  s.replace(0, 4, "").replace(s.find("even"), 4, "only").replace(s.find(" don't"), 6, "");
+  assert(s == "I have heard it works only if you believe in it"); // OK
+}
+```
+— *end example*]
+[*Note 7*: If an operator function is invoked using operator notation,
+argument evaluation is sequenced as specified for the built-in operator;
+see  [[over.match.oper]]. — *end note*]
+[*Example 3*:
+``` cpp
+struct S {
+  S(int);
+};
+int operator<<(S, int);
+int i, j;
+int x = S(i=1) << (i=2);
+int y = operator<<(S(j=1), j=2);
+```
+After performing the initializations, the value of `i` is 2 (see
+[[expr.shift]]), but it is unspecified whether the value of `j` is 1 or
+2.
+— *end example*]
+The result of a function call is the result of the operand of the
+evaluated `return` statement ([[stmt.return]]) in the called function
+(if any), except in a virtual function call if the return type of the
+final overrider is different from the return type of the statically
+chosen function, the value returned from the final overrider is
+converted to the return type of the statically chosen function.
+[*Note 8*:  A function can change the values of its non-const
+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]]).
+[*Note 9*: This implies that, except where the ellipsis (`...`) or a
+function parameter pack is used, a parameter is available for each
+argument. — *end note*]
 When there is no parameter for a given argument, the argument is passed
 in such a way that the receiving function can obtain the value of the
+argument by invoking `va_arg` ([[support.runtime]]).
+[*Note 10*: This paragraph does not apply to arguments passed to a
+function parameter pack. Function parameter packs are expanded during
+template instantiation ([[temp.variadic]]), thus each such argument has
+a corresponding parameter when a function template specialization is
+actually called. — *end note*]
 The lvalue-to-rvalue ([[conv.lval]]), array-to-pointer (
 [[conv.array]]), and function-to-pointer ([[conv.func]]) standard
 conversions are performed on the argument expression. An argument that
+has type cv `std::nullptr_t` is converted to type `void*` (
+[[conv.ptr]]). After these conversions, if the argument does not have
+arithmetic, enumeration, pointer, pointer to member, or class type, the
+program is ill-formed. Passing a potentially-evaluated argument of class
+type (Clause  [[class]]) having a non-trivial copy constructor, a
+non-trivial move constructor, or a non-trivial destructor, with no
+corresponding parameter, is conditionally-supported with
+*implementation-defined* semantics. If the argument has integral or
 enumeration type that is subject to the integral promotions (
+[[conv.prom]]), or a floating-point type that is subject to the
+floating-point promotion ([[conv.fpprom]]), the value of the argument
+is converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
 Recursive calls are permitted, except to the `main` function (
 [[basic.start.main]]).
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
 type is an rvalue reference to object type, and a prvalue otherwise.

Diff to HTML by rtfpessoa