[class.mfct] - C++14 → C++17

Files changed (1) hide show

tmp/tmp3kj17fg_/{from.md → to.md} +40 -176

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

@@ -1,44 +1,43 @@
-## Member functions <a id="class.mfct">[[class.mfct]]</a>
-Functions declared in the definition of a class, excluding those
-declared with a `friend` specifier ([[class.friend]]), are called
-member functions of that class. A member function may be declared
-`static` in which case it is a *static* member function of its class (
-[[class.static]]); otherwise it is a *non-static* member function of its
-class ([[class.mfct.non-static]],  [[class.this]]).
 A member function may be defined ([[dcl.fct.def]]) in its class
 definition, in which case it is an *inline* member function (
-[[dcl.fct.spec]]), or it may be defined outside of its class definition
-if it has already been declared but not defined in its class definition.
-A member function definition that appears outside of the class
-definition shall appear in a namespace scope enclosing the class
-definition. Except for member function definitions that appear outside
-of a class definition, and except for explicit specializations of member
-functions of class templates and member function templates (
-[[temp.spec]]) appearing outside of the class definition, a member
-function shall not be redeclared.
-An `inline` member function (whether static or non-static) may also be
 defined outside of its class definition provided either its declaration
 in the class definition or its definition outside of the class
-definition declares the function as `inline`. Member functions of a
-class in namespace scope have external linkage. Member functions of a
-local class ([[class.local]]) have no linkage. See  [[basic.link]].
-There shall be at most one definition of a non-inline member function in
-a program; no diagnostic is required. There may be more than one
-`inline` member function definition in a program. See  [[basic.def.odr]]
-and  [[dcl.fct.spec]].
 If the definition of a member function is lexically outside its class
 definition, the member function name shall be qualified by its class
-name using the `::` operator. A name used in a member function
-definition (that is, in the *parameter-declaration-clause* including the
-default arguments ([[dcl.fct.default]]) or in the member function body)
-is looked up as described in  [[basic.lookup]].
 ``` cpp
 struct X {
   typedef int T;
   static T count;
@@ -52,176 +51,41 @@ notation `X::f` specifies that the function `f` is a member of class `X`
 and in the scope of class `X`. In the function definition, the parameter
 type `T` refers to the typedef member `T` declared in class `X` and the
 default argument `count` refers to the static data member `count`
 declared in class `X`.
-A `static` local variable in a member function always refers to the same
-object, whether or not the member function is `inline`.
 Previously declared member functions may be mentioned in `friend`
 declarations.
 Member functions of a local class shall be defined inline in their class
 definition, if they are defined at all.
 A member function can be declared (but not defined) using a typedef for
 a function type. The resulting member function has exactly the same type
 as it would have if the function declarator were provided explicitly,
 see  [[dcl.fct]]. For example,
 ``` cpp
-typedef void fv(void);
-typedef void fvc(void) const;
 struct S {
-  fv memfunc1;      // equivalent to: void memfunc1(void);
   void memfunc2();
-  fvc memfunc3;     // equivalent to: void memfunc3(void) const;
 };
 fv  S::* pmfv1 = &S::memfunc1;
 fv  S::* pmfv2 = &S::memfunc2;
 fvc S::* pmfv3 = &S::memfunc3;
 ```
 Also see  [[temp.arg]].
-### Nonstatic 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.general]]), 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. If `C` is not `X`
-or a base class of `X`, the class member access expression is
-ill-formed. 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.
-``` cpp
-struct tnode {
-  char tword[20];
-  int count;
-  tnode* left;
-  tnode* right;
-  void set(const char*, tnode* l, tnode* r);
-};
-void tnode::set(const char* w, tnode* l, tnode* r) {
-  count = strlen(w)+1;
-  if (sizeof(tword)<=count)
-      perror("tnode string too long");
-  strcpy(tword,w);
-  left = l;
-  right = r;
-}
-void f(tnode n1, tnode n2) {
-  n1.set("abc",&n2,0);
-  n2.set("def",0,0);
-}
-```
-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]
-A non-static member function may be declared `const`, `volatile`, or
-`const` `volatile`. These *cv-qualifiers* 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.
-``` 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.
-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*`. thus in a `const` member function, the object
-for which the function is called is accessed through a `const` access
-path.
-``` cpp
-struct s {
-  int a;
-  int f() const;
-  int g() { return a++; }
-  int h() const { return a++; } // error
-};
-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.
-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.
-``` cpp
-void k(s& x, const s& y) {
-  x.f();
-  x.g();
-  y.f();
-  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`.
-Constructors ([[class.ctor]]) and destructors ([[class.dtor]]) shall
-not 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]]).

+### Member functions <a id="class.mfct">[[class.mfct]]</a>
 A member function may be defined ([[dcl.fct.def]]) in its class
 definition, in which case it is an *inline* member function (
+[[dcl.inline]]), or it may be defined outside of its class definition if
+it has already been declared but not defined in its class definition. A
+member function definition that appears outside of the class definition
+shall appear in a namespace scope enclosing the class definition. Except
+for member function definitions that appear outside of a class
+definition, and except for explicit specializations of member functions
+of class templates and member function templates ([[temp.spec]])
+appearing outside of the class definition, a member function shall not
+be redeclared.
+An inline member function (whether static or non-static) may also be
 defined outside of its class definition provided either its declaration
 in the class definition or its definition outside of the class
+definition declares the function as `inline` or `constexpr`.
+[*Note 1*: Member functions of a class in namespace scope have the
+linkage of that class. Member functions of a local class (
+[[class.local]]) have no linkage. See  [[basic.link]]. — *end note*]
+[*Note 2*: There can be at most one definition of a non-inline member
+function in a program. There may be more than one `inline` member
+function definition in a program. See  [[basic.def.odr]] and
+[[dcl.inline]]. — *end note*]
 If the definition of a member function is lexically outside its class
 definition, the member function name shall be qualified by its class
+name using the `::` operator.
+[*Note 3*: A name used in a member function definition (that is, in the
+*parameter-declaration-clause* including the default arguments (
+[[dcl.fct.default]]) or in the member function body) is looked up as
+described in  [[basic.lookup]]. — *end note*]
+[*Example 1*:
 ``` cpp
 struct X {
   typedef int T;
   static T count;
 and in the scope of class `X`. In the function definition, the parameter
 type `T` refers to the typedef member `T` declared in class `X` and the
 default argument `count` refers to the static data member `count`
 declared in class `X`.
+— *end example*]
+[*Note 4*: A `static` local variable or local type in a member function
+always refers to the same entity, whether or not the member function is
+`inline`. — *end note*]
 Previously declared member functions may be mentioned in `friend`
 declarations.
 Member functions of a local class shall be defined inline in their class
 definition, if they are defined at all.
+[*Note 5*:
 A member function can be declared (but not defined) using a typedef for
 a function type. The resulting member function has exactly the same type
 as it would have if the function declarator were provided explicitly,
 see  [[dcl.fct]]. For example,
 ``` cpp
+typedef void fv();
+typedef void fvc() const;
 struct S {
+  fv memfunc1;      // equivalent to: void memfunc1();
   void memfunc2();
+  fvc memfunc3;     // equivalent to: void memfunc3() const;
 };
 fv  S::* pmfv1 = &S::memfunc1;
 fv  S::* pmfv2 = &S::memfunc2;
 fvc S::* pmfv3 = &S::memfunc3;
 ```
 Also see  [[temp.arg]].
+— *end note*]

Diff to HTML by rtfpessoa