9 Classes [class]

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. [ Note: 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. [ Example:

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.110  — end example ]

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. [ Example:

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]).