Pointer to non-static member functions

[Tim Frink]

Hi,

I'm experimenting with function pointers and found
two questions. Let's assume this code:

1 #include <iostream>
2 class A;
3
4 ////////////////////////////////////////////
5 class B
6 {
7 public:
8 void printB( void (A::*)(void) );
9 };
10
11 void B::printB( void (A::*func)(void) )
12 {
13 *func(); // not working
14 }
15
16 ////////////////////////////////////////////
17 class A
18 {
19 public:
20 void printA(void);
21 void invokeB(void);
22
23 private:
24 B myB;
25 };
26
27 void A::printA(void)
28 {
29 std::cout << "A::print" << std::endl;
30 return;
31 }
32
33 void A::invokeB(void)
34 {
35 myB.printB( &A::printA );
36 return;
37 }
38
39 ////////////////////////////////////////////
40 int main(void)
41 {
42 A myA;
43 a.invokeB();
44
45 return 0;
46 }

What I want to achieve is a communication between two object
with a callback function. Object A invokes a function in
object B passing a callback function. The invoked function in
object B calls the passed callback function to communicate
with the caller A.

So, I'm passing a pointer to A::printA in line 35 to
B::printB. The called member function printB of object
myB than should deference the passed function pointer
(line 13, not working yet) to invoke again a function
(A::printfA) of the original caller. Thus, myA invokes
myB which in turn invokes myA again.

My first question concerns line 35. What exactly is the
address of &A::printA? When I forward this value to "cout",
(cout << &A::printA) I get the output "1" and not an
address. Since A::printA is a non-static member function,
it cannot be considered independent of a concrete object.
Thus, I would assume that &AA::printA is an offset which
must be added to the memory address where a concrete
object of class A is allocated. Adding the start address
and the offset would result in the address where the
function printA of an individual object of class A is
located.

And this brings me to my second question concerning line
13. When I try to compiler this code, I get the compiler error:
error: must use .* or ->* to call pointer-to-member function in `func (...)'
I assume the problem is that the function pointer "func" has
no reference to a concrete object of class A (myA in this case).
So, the function cannot be invoked. How can I solve this?
Do I have to pass the address of myA to B::printB?
Something like "myB.printB( &A::printA, this );" in line 35
and than use the pointer in "this" to invoke func?

Thank you.

Regards,
Tim

[peter koch]

On 8 Maj, 11:26, Tim Frink <[e-mail]:

Hi,

I'm experimenting with function pointers and found
two questions. Let's assume this code:

* 1 #include <iostream>
* 2 class A;
* 3
* 4 ////////////////////////////////////////////
* 5 class B
* 6 {
* 7 * public:
* 8 * * void printB( void (A::*)(void) );
* 9 };
*10
*11 void B::printB( void (A::*func)(void) )
*12 {
*13 * *func(); // not working
*14 }
*15
*16 ////////////////////////////////////////////
*17 class A
*18 {
*19 * public:
*20 * * void printA(void);
*21 * * void invokeB(void);
*22
*23 * private:
*24 * * B myB;
*25 };
*26
*27 void A::printA(void)
*28 {
*29 * std::cout << "A::print" << std::endl;
*30 * return;
*31 }
*32
*33 void A::invokeB(void)
*34 {
*35 * myB.printB( &A::printA );
*36 * return;
*37 }
*38
*39 ////////////////////////////////////////////
*40 int main(void)
*41 {
*42 * A myA;
*43 * a.invokeB();
*44
*45 * return 0;
*46 }

What I want to achieve is a communication between two object
with a callback function. Object A invokes a function in
object B passing a callback function. The invoked function in
object B calls the passed callback function to communicate
with the caller A.

So, I'm passing a pointer to A::printA in line 35 to
B::printB. The called member function printB of object
myB than should deference the passed function pointer
(line 13, not working yet) to invoke again a function
(A::printfA) of the original caller. Thus, myA invokes
myB which in turn invokes myA again.

My first question concerns line 35. What exactly is the
address of &A::printA? When I forward this value to "cout",
(cout << &A::printA) I get the output "1" and not an
address.

Probably you did print "true" because the memberfunction is not null.
Apart from that, I do not see what interest you could have in getting
its adress. If it is out of curiosity, I would recommend you to
examine the value in a debugger instead.

Since A::printA is a non-static member function,
it cannot be considered independent of a concrete object.

Yes it can. A memberfunction is not connected to any concrete object.
I will come back to that later.

Thus, I would assume that &AA::printA is an offset which
must be added to the memory address where a concrete
object of class A is allocated. Adding the start address
and the offset would result in the address where the
function printA of an individual object of class A is
located.

I am not sure I can decipher the above, but if your understanding is
that a memberfunction somehow is placed inside an object, your
understanding is wrong. A memberfunction is does not take up any space
in an object.

>
And this brings me to my second question concerning line
13. When I try to compiler this code, I get the compiler error:
error: must use .* or ->* to call pointer-to-member function in `func (...)'

(repeating offensive code)

11 void B::printB( void (A::*func)(void) )
12 {
13 *func(); // not working
14 }
15

This is because your perception of a member-function pointer is wrong.
A member-function pointer is a pointer that can be used to call a
memberfunction oon all objects of the given type. But you have to
provide an object. So your code should have been somewhat like:

11 void B::printB( A *a, void (A::*func)(void) )
12 {
13 (a->*func)();
14 }
15

I assume the problem is that the function pointer "func" has
no reference to a concrete object of class A (myA in this case).
So, the function cannot be invoked. How can I solve this?
Do I have to pass the address of myA to B::printB?
Something like "myB.printB( &A::printA, this );" in line 35
and than use the pointer in "this" to invoke func?

Exactly.
/Peter

[Krice]

Tim Frink kirjoitti:

How can I solve this?

Use C-style functions. Another option is that you start programming
in C++ and stop using function pointers.

[Szabolcs Ferenczi]

On May 8, 11:26*am, Tim Frink <[e-mail]:

What I want to achieve is a communication between two object
with a callback function. Object A invokes a function in
object B passing a callback function. The invoked function in
object B calls the passed callback function to communicate
with the caller A.

You might want to check out the visitor design pattern to achieve the
same effect.

Best Regards,
Szabolcs

[James Kanze]

I'm experimenting with function pointers and found

two questions. Let's assume this code:

1 #include <iostream>
2 class A;

4 ////////////////////////////////////////////
5 class B
6 {
7 public:
8 void printB( void (A::*)(void) );
9 };
10
11 void B::printB( void (A::*func)(void) )
12 {
13 *func(); // not working

That's because you need an object on which to call the function.

14 }
15
16 ////////////////////////////////////////////
17 class A
18 {
19 public:
20 void printA(void);
21 void invokeB(void);

23 private:
24 B myB;
25 };

27 void A::printA(void)
28 {
29 std::cout << "A::print" << std::endl;
30 return;
31 }

33 void A::invokeB(void)
34 {
35 myB.printB( &A::printA );
36 return;
37 }

39 ////////////////////////////////////////////
40 int main(void)
41 {
42 A myA;
43 a.invokeB();

45 return 0;
46 }

What I want to achieve is a communication between two object
with a callback function. Object A invokes a function in
object B passing a callback function. The invoked function in
object B calls the passed callback function to communicate
with the caller A.

Are the types known to both objects? The "usual" solution here
involves an abstract base class, something like:

class AbstractCallback
{
public:
virtual ~AbstractCallback() {}
virtual void notify() = 0 ; // or some other name.
} ;

The class requesting the callback can then derive from this;
often, you migth also provide a templated concrete derivation:

template< typename T, void (T::*fnc)() >
class Callback : public AbstractCallback
{
public:
Callback( T* obj ) : myObj( obj ) {}
virtual void notify()
{
(myObj->*fnc)() ;
}

private:
T* myObj ;
} ;

In the absense of garbage collection, this solution requires
some complex memory management, however.

So, I'm passing a pointer to A::printA in line 35 to
B::printB. The called member function printB of object myB
than should deference the passed function pointer (line 13,
not working yet) to invoke again a function (A::printfA) of
the original caller. Thus, myA invokes myB which in turn
invokes myA again.

My first question concerns line 35. What exactly is the
address of &A::printA?

A pointer to member function. Which is more of a selector than
a pointer in the real sense. At any rate, it definitely must
contain more than just an address, since it must work with
virtual functions (where the actual function called depends on
the dynamic type it is being called on). If you check the
sizeof a pointer to member function, it will typically (but not
necessarily) be larger than a normal pointer to function.

When I forward this value to "cout", (cout << &A::printA) I
get the output "1" and not an address.

There is no << operator defined for pointer to members. There
is an implicit conversion of pointers to members to a bool,
which results in true if the pointer to member is not null, and
there is a << operator for bool.

Since A::printA is a non-static member function, it cannot be
considered independent of a concrete object. Thus, I would
assume that &AA::printA is an offset which must be added to
the memory address where a concrete object of class A is
allocated.

It's more complicated than that. The class instance doesn't
actually contain a copy of the code of its member functions; in
many ways, the only difference between a member function and a
non member function is that the member function has an
additional hidden argument. The way member functions are
called, however, is different, both in regards to syntax, and
(at least when virtual functions are considered) the mechanics.

Adding the start address and the offset would result in the
address where the function printA of an individual object of
class A is located.

No.

And this brings me to my second question concerning line 13.
When I try to compiler this code, I get the compiler error:
error: must use .* or ->* to call pointer-to-member function
in `func (...)' I assume the problem is that the function
pointer "func" has no reference to a concrete object of class
A (myA in this case). So, the function cannot be invoked. How
can I solve this? Do I have to pass the address of myA to
B::printB? Something like "myB.printB( &A::printA, this );"
in line 35 and than use the pointer in "this" to invoke func?

Exactly. Or you wrap some, using an intermediate "agent" class.
(This is generally considered the prefered solution, since it
means that the class invoking the callback doesn't need to know
of the class which is called back.)

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Tim Frink]

>

Probably you did print "true" because the memberfunction is not null.

But why did I not get the address? I though that &A::printA is a pointer.
So, I can't understand why I get "true".

Apart from that, I do not see what interest you could have in getting
its adress. If it is out of curiosity, I would recommend you to
examine the value in a debugger instead.

This was just for curiosity. When this value is passed as an
argument, it would make sense to check if it's not 0. So I think
that the check of the address makes sense in some situations.

I am not sure I can decipher the above, but if your understanding is
that a memberfunction somehow is placed inside an object, your
understanding is wrong. A memberfunction is does not take up any space
in an object.

I'm not aware of the code generation for C++ programs. But from your
post I assume that for each C++ class exactly one code (fragment) is
allocated in the object's text section independently if and how many
times objects of this class are instantiated. So what happens when
an object of a particular class is instantiated? Will additional code
be allocated in the .text section? Or will this new object be considered
as data allocated on the stack/heap with some references to the class
code located somewhere in the .text section?

>And this brings me to my second question concerning line
13. When I try to compiler this code, I get the compiler error:
error: must use .* or ->* to call pointer-to-member function in `func (...)'

(repeating offensive code)

> 11 void B::printB( void (A::*func)(void) )
12 {
13 *func(); // not working
14 }
15

This is because your perception of a member-function pointer is wrong.
A member-function pointer is a pointer that can be used to call a
memberfunction oon all objects of the given type. But you have to
provide an object. So your code should have been somewhat like:

So, why do I need the object and can't access the function (in my
case func) without the object? If it's already in the memory
(.text section) and func has the address to it, so why is the
object still needed for the access?

My assumption would be that an instantiated object has some references
which point to addresses (or functions/attributes behind theses addresses)
that is is allowed to access. So, the object code contains a sort
of permissions about what code can be accessed and which not. Are these
thoughts going into the right direction?

Tim