C++ : Pointers to member functions


Q112: What is the type of `ptr-to-member-fn'?  Is it diffn't from `ptr-to-fn'?
A: A member fn of class X has type:  Returntype (X::*)(Argtypes)
   while a plain function has type:  Returntype (*)   (Argtypes)

Q113: How can I ensure `X's objects are only created with new, not on the stack?
A: Make constructors protected and define `friend' or `static' fns that return
a ptr to objects created via `new' (the ctors must be protected rather than
private, otherwise you couldn't derive from the class).  Ex:

	class X {	//only want to allow dynamicly allocated X's
	           X(int i);
	           X(const X& x);
	  virtual ~X();
	  static X* create()           { return new X();  }
	  static X* create(int i)      { return new X(i); }
	  static X* create(const X& x) { return new X(x); }

	X* Xptr = X::create(5);

Q114: How do I pass a ptr to member fn to a signal handler,X event callback,etc?
A: Because a member function is meaningless without an object to invoke it on,
you can't do this directly (if `X' were rewritten in C++, it would probably
pass references to *objects* around, not just pointers to fns; naturally the
objects would embody the required function and probably a whole lot more).

As a patch for existing software, use a free function as a wrapper which takes
an object obtained through some other technique (held in a global, perhaps) and
calls the desired member function.  There is one exception: static member
functions do not require an actual object to be invoked, and ptrs-to-static-
member-fns are type compatible with regular ptrs-to-fns (see ARM p.25, 158).

Ex: suppose you want to call X::memfn() on interrupt:

    class X {
             void memfn();
      static void staticmemfn();	//a static member fn can handle it

    //wrapper fn remembers the object on which to invoke memfn in a static var:
    static X* object_which_will_handle_signal;
    void X_memfn_wrapper() { object_which_will_handle_signal.memfn(); }

      /* signal(SIGINT, X::memfn); */   //Can NOT do this
      signal(SIGINT, X_memfn_wrapper);  //Ok
      signal(SIGINT, X::staticmemfn);   //Also Ok

Q115: Why am I having trouble taking the address of a C++ function?
Short ans: Please read previous question first; this is a corollary.

Long ans: In C++, member fns have an implicit parameter which points to the
object (the `this' ptr inside the member fn).  Normal C fns can be thought of
as having a different calling convention from member fns, so the types of their
ptrs (ptr-to-member-fn vs ptr-to-fn) are different and incompatible.  C++
introduces a new type of ptr, called a ptr-to-member, which can only be invoked
by providing an object (see ARM 5.5).  Do NOT attempt to `cast' a ptr-to-mem-fn
into a ptr-to-fn; the result is undefined and probably disastrous; a ptr-to-
member-fn is NOT required to contain the machine addr of the appropriate fn
(see ARM, 8.1.2c, p.158).  As was said in the last example, if you want a
regular C fn ptr, use either a top-level (non-class) fn, or a `static' (class)
member fn.

Q116: How do I declare an array of pointers to member functions?
A: Use the following declaration:

	class Frob {
	  Rettype f(T1 x, T2 y);
	  Rettype g(T1 x, T2 y);
	  Rettype h(T1 x, T2 y);
	  Rettype i(T1 x, T2 y);

	Rettype (Frob::*fn_ptr[3])(T1,T2) = { &Frob::f, &Frob::g, &Frob::h };

You can make the array declaration somewhat clearer with a typedef:
	typedef  Rettype (Frob::*Frob_member_ptr)(T1,T2);
	Frob_member_ptr fn_ptr[3] = { &Frob::f, &Frob::g, &Frob::h };

To call one of the functions on an object `frob', use:
	Frob frob;
	(frob.*fn_ptr[i])(x, y);

You can make the call somewhat clearer using a #define:
	#define  apply_member_fn(object,fn)   ((object).*(fn))
	apply_member_fn(frob,fn_ptr[i])(x, y)