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

Files changed (1) hide show

tmp/tmpb9pt5szu/{from.md → to.md} +37 -36

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

@@ -1,49 +1,50 @@
 ### Function call <a id="expr.call">[[expr.call]]</a>
-There are two kinds of function call: ordinary function call and member
-function[^6] ([[class.mfct]]) call. A function call is a postfix
-expression followed by parentheses containing a possibly empty,
-comma-separated list of expressions which constitute the arguments to
-the function. For an ordinary function call, 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 member function call, 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. 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 type shall be an
-object type, a reference type or the type `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
@@ -116,16 +117,16 @@ 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 argument
-expressions are all unsequenced relative to one another. All side
-effects of argument expression evaluations are sequenced before the
-function is entered (see  [[intro.execution]]).
-Recursive calls are permitted, except to the function named `main` (
 [[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.

 ### 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
 [[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.

Diff to HTML by rtfpessoa