Member Function Pointers and Multiple Inheritance

Working with member function pointers in the context of multiple inheritance can be a bit tricky, but it's definitely possible. Let's break this down step by step:

Basic Syntax

First, let's recall the basic syntax for a member function pointer:

1return_type (ClassName::*pointerName)(parameter_types);

Multiple Inheritance Scenario

Now, let's consider a multiple inheritance scenario:

1#include <iostream>
2
3class Base1 {
4public:
5  virtual void foo() {
6    std::cout << "Base1::foo\n";
7  }
8};
9
10class Base2 {
11public:
12  virtual void bar() {
13    std::cout << "Base2::bar\n";
14  }
15};
16
17class Derived : public Base1, public Base2 {
18public:
19  void foo() override {
20    std::cout << "Derived::foo\n";
21  }
22
23  void bar() override {
24    std::cout << "Derived::bar\n";
25  }
26};

Pointer to Member Function

To create a pointer to a member function in this context, you need to specify which base class the function belongs to:

1#include <iostream>
2
Base1 Class|Show
3class Base1 {/*...*/};
10
Base2 Class|Show
11class Base2 {/*...*/};
18
Derived Class|Show
19class Derived : Base1, Base2 {/*...*/};
30
31int main() {
32  void (Base1::*pBase1Foo)() = &Base1::foo;
33  void (Base2::*pBase2Bar)() = &Base2::bar;
34  void (Derived::*pDerivedFoo)() = &Derived::foo;
35  void (Derived::*pDerivedBar)() = &Derived::bar;
36}

Using the Pointers

To use these pointers, you need an object of the appropriate type:

1#include <iostream>
2
Base1 Class|Show
3class Base1 {/*...*/};
10
Base2 Class|Show
11class Base2 {/*...*/};
18
Derived Class|Show
19class Derived : Base1, Base2 {/*...*/};
30
31int main() {
32  void (Base1::*pBase1Foo)() = &Base1::foo;
33  void (Base2::*pBase2Bar)() = &Base2::bar;
34  void (Derived::*pDerivedFoo)() = &Derived::foo;
35  void (Derived::*pDerivedBar)() = &Derived::bar;
36
37  Derived d;
38  Base1* pb1 = &d;
39  Base2* pb2 = &d;
40
41  (d.*pDerivedFoo)(); // Calls Derived::foo
42  (d.*pDerivedBar)(); // Calls Derived::bar
43
44  // Calls Derived::foo (virtual dispatch)
45  (pb1->*pBase1Foo)();
46  // Calls Derived::bar (virtual dispatch)
47  (pb2->*pBase2Bar)();
48}

1Derived::foo
2Derived::bar
3Derived::foo
4Derived::bar

Potential Pitfalls

Be aware of potential pitfalls. Firstly, if both base classes have a function with the same name, you need to explicitly specify which one you're referring to to avoid ambiguity:

1void (Derived::*pFoo)() =
2  static_cast<void (Derived::*)()>(&Base1::foo);

Remember that virtual functions will still use dynamic dispatch when called through pointers to member functions.

Additionally, multiple inheritance can lead to the dreaded "diamond problem" if not handled carefully. Always use virtual inheritance when appropriate to avoid this issue.

Using std::function

For more flexibility, you can use std::function along with std::bind:

1#include <functional>
2#include <iostream>
3
Base1 Class|Show
4class Base1 {/*...*/};
11
Base2 Class|Show
12class Base2 {/*...*/};
19
Derived Class|Show
20class Derived : Base1, Base2 {/*...*/};
31
32int main() {
33  Derived d;
34  std::function<void()> f =
35    std::bind(&Base1::foo, &d);
36
37  f();
38}

1Derived::foo

This approach can make working with member function pointers in multiple inheritance scenarios more manageable.

Remember, while multiple inheritance can be powerful, it also increases complexity. Always consider whether simpler design patterns might achieve your goals more cleanly.