[class.mfct.non-static] - C++17 → C++20

Files changed (1) hide show

tmp/tmpjidaw8o4/{from.md → to.md} +48 -57

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

@@ -1,40 +1,35 @@
 ### Non-static member functions <a id="class.mfct.non-static">[[class.mfct.non-static]]</a>
 A non-static member function may be called for an object of its class
-type, or for an object of a class derived (Clause  [[class.derived]])
-from its class type, using the class member access syntax (
-[[expr.ref]],  [[over.match.call]]). A non-static member function may
-also be called directly using the function call syntax ([[expr.call]],
-[[over.match.call]]) from within the body of a member function of its
-class or of a class derived from its class.
 If a non-static member function of a class `X` is called for an object
 that is not of type `X`, or of a type derived from `X`, the behavior is
 undefined.
-When an *id-expression* ([[expr.prim]]) that is not part of a class
-member access syntax ([[expr.ref]]) and not used to form a pointer to
-member ([[expr.unary.op]]) is used in a member of class `X` in a
-context where `this` can be used ([[expr.prim.this]]), if name lookup (
-[[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 ([[expr.ref]]) using `(*this)` ([[class.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*]
-Similarly during name lookup, when an *unqualified-id* ([[expr.prim]])
-used in the definition of a member function for class `X` resolves to a
-static member, an enumerator or a nested type of class `X` or of a base
-class of `X`, the *unqualified-id* is transformed into a
-*qualified-id* ([[expr.prim]]) in which the *nested-name-specifier*
-names the class of the member function. These transformations do not
-apply in the template definition context ([[temp.dep.type]]).
 [*Example 1*:
 ``` cpp
 struct tnode {
@@ -63,55 +58,52 @@ void f(tnode n1, tnode n2) {
 In the body of the member function `tnode::set`, the member names
 `tword`, `count`, `left`, and `right` refer to members of the object for
 which the function is called. Thus, in the call `n1.set("abc",&n2,0)`,
 `tword` refers to `n1.tword`, and in the call `n2.set("def",0,0)`, it
 refers to `n2.tword`. The functions `strlen`, `perror`, and `strcpy` are
-not members of the class `tnode` and should be declared elsewhere.[^4]
 — *end example*]
 A non-static member function may be declared `const`, `volatile`, or
 `const` `volatile`. These *cv-qualifier*s affect the type of the `this`
-pointer ([[class.this]]). They also affect the function type (
-[[dcl.fct]]) of the member function; a member function declared `const`
-is a *const* member function, a member function declared `volatile` is a
-*volatile* member function and a member function declared `const`
-`volatile` is a *const volatile* member function.
 [*Example 2*:
 ``` cpp
 struct X {
   void g() const;
   void h() const volatile;
 };
 ```
-`X::g` is a `const` member function and `X::h` is a `const` `volatile`
-member function.
 — *end example*]
-A non-static member function may be declared with a *ref-qualifier* (
-[[dcl.fct]]); see  [[over.match.funcs]].
-A non-static member function may be declared *virtual* (
-[[class.virtual]]) or *pure virtual* ([[class.abstract]]).
 #### The `this` pointer <a id="class.this">[[class.this]]</a>
-In the body of a non-static ([[class.mfct]]) member function, the
-keyword `this` is a prvalue expression whose value is the address of the
-object for which the function is called. The type of `this` in a member
-function of a class `X` is `X*`. If the member function is declared
-`const`, the type of `this` is `const` `X*`, if the member function is
-declared `volatile`, the type of `this` is `volatile` `X*`, and if the
-member function is declared `const` `volatile`, the type of `this` is
-`const` `volatile` `X*`.
-[*Note 1*: Thus in a `const` member function, the object for which the
-function is called is accessed through a `const` access
 path. — *end note*]
 [*Example 1*:
 ``` cpp
@@ -125,22 +117,23 @@ struct s {
 int s::f() const { return a; }
 ```
 The `a++` in the body of `s::h` is ill-formed because it tries to modify
 (a part of) the object for which `s::h()` is called. This is not allowed
-in a `const` member function because `this` is a pointer to `const`;
-that is, `*this` has `const` type.
 — *end example*]
-Similarly, `volatile` semantics ([[dcl.type.cv]]) apply in `volatile`
-member functions when accessing the object and its non-static data
-members.
-A cv-qualified member function can be called on an object-expression (
-[[expr.ref]]) only if the object-expression is as cv-qualified or
-less-cv-qualified than the member function.
 [*Example 2*:
 ``` cpp
 void k(s& x, const s& y) {
@@ -150,17 +143,15 @@ void k(s& x, const s& y) {
   y.g();                        // error
 }
 ```
 The call `y.g()` is ill-formed because `y` is `const` and `s::g()` is a
-non-`const` member function, that is, `s::g()` is less-qualified than
-the object-expression `y`.
 — *end example*]
-Constructors ([[class.ctor]]) and destructors ([[class.dtor]]) shall
-not be declared `const`, `volatile` or `const` `volatile`.
-[*Note 2*: However, these functions can be invoked to create and
-destroy objects with cv-qualified types, see  [[class.ctor]] and
-[[class.dtor]]. — *end note*]

 ### Non-static member functions <a id="class.mfct.non-static">[[class.mfct.non-static]]</a>
 A non-static member function may be called for an object of its class
+type, or for an object of a class derived [[class.derived]] from its
+class type, using the class member access syntax ([[expr.ref]],
+[[over.match.call]]). A non-static member function may also be called
+directly using the function call syntax ([[expr.call]],
+[[over.match.call]]) from within its class or a class derived from its
+class, or a member thereof, as described below.
 If a non-static member function of a class `X` is called for an object
 that is not of type `X`, or of a type derived from `X`, the behavior is
 undefined.
+When an *id-expression* [[expr.prim.id]] that is not part of a class
+member access syntax [[expr.ref]] and not used to form a pointer to
+member [[expr.unary.op]] is used in a member of class `X` in a context
+where `this` can be used [[expr.prim.this]], if name lookup
+[[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 [[expr.ref]] using `(*this)` [[class.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
+[[temp.dep.type]].
 [*Example 1*:
 ``` cpp
 struct tnode {
 In the body of the member function `tnode::set`, the member names
 `tword`, `count`, `left`, and `right` refer to members of the object for
 which the function is called. Thus, in the call `n1.set("abc",&n2,0)`,
 `tword` refers to `n1.tword`, and in the call `n2.set("def",0,0)`, it
 refers to `n2.tword`. The functions `strlen`, `perror`, and `strcpy` are
+not members of the class `tnode` and should be declared elsewhere.[^2]
 — *end example*]
 A non-static member function may be declared `const`, `volatile`, or
 `const` `volatile`. These *cv-qualifier*s affect the type of the `this`
+pointer [[class.this]]. They also affect the function type [[dcl.fct]]
+of the member function; a member function declared `const` is a *const
+member function*, a member function declared `volatile` is a *volatile
+member function* and a member function declared `const` `volatile` is a
+*const volatile member function*.
 [*Example 2*:
 ``` cpp
 struct X {
   void g() const;
   void h() const volatile;
 };
 ```
+`X::g` is a const member function and `X::h` is a const volatile member
+function.
 — *end example*]
+A non-static member function may be declared with a *ref-qualifier*
+[[dcl.fct]]; see  [[over.match.funcs]].
+A non-static member function may be declared virtual [[class.virtual]]
+or pure virtual [[class.abstract]].
 #### The `this` pointer <a id="class.this">[[class.this]]</a>
+In the body of a non-static [[class.mfct]] member function, the keyword
+`this` is a prvalue whose value is a pointer to the object for which the
+function is called. The type of `this` in a member function whose type
+has a *cv-qualifier-seq* cv and whose class is `X` is “pointer to cv
+`X`”.
+[*Note 1*: Thus in a const member function, the object for which the
+function is called is accessed through a const access
 path. — *end note*]
 [*Example 1*:
 ``` cpp
 int s::f() const { return a; }
 ```
 The `a++` in the body of `s::h` is ill-formed because it tries to modify
 (a part of) the object for which `s::h()` is called. This is not allowed
+in a const member function because `this` is a pointer to `const`; that
+is, `*this` has `const` type.
 — *end example*]
+[*Note 2*: Similarly, `volatile` semantics [[dcl.type.cv]] apply in
+volatile member functions when accessing the object and its non-static
+data members. — *end note*]
+A member function whose type has a *cv-qualifier-seq* *cv1* can be
+called on an object expression [[expr.ref]] of type *cv2* `T` only if
+*cv1* is the same as or more cv-qualified than *cv2*
+[[basic.type.qualifier]].
 [*Example 2*:
 ``` cpp
 void k(s& x, const s& y) {
   y.g();                        // error
 }
 ```
 The call `y.g()` is ill-formed because `y` is `const` and `s::g()` is a
+non-const member function, that is, `s::g()` is less-qualified than the
+object expression `y`.
 — *end example*]
+[*Note 3*: Constructors and destructors cannot be declared `const`,
+`volatile`, or `const` `volatile`. However, these functions can be
+invoked to create and destroy objects with cv-qualified types; see
+[[class.ctor]] and  [[class.dtor]]. — *end note*]

Diff to HTML by rtfpessoa