Function Pointers and Inheritance

When dealing with inheritance and function pointers, there are a few things to consider. In general, you can assign a derived class member function to a base class function pointer, as long as the function signatures match. However, there are some caveats. Let's look at an example:

1#include <iostream>
2
3class Base {
4 public:
5  void foo() {
6    std::cout << "Base::foo()\n"; }
7};
8
9class Derived : public Base {
10 public:
11  void foo() {
12    std::cout << "Derived::foo()\n"; }
13};
14
15int main() {
16  void (Base::*fooPtr)(){&Base::foo};
17
18  Base* basePtr = new Derived;
19  (basePtr->*fooPtr)();  
20
21  Derived* derivedPtr = new Derived;
22  (derivedPtr->*fooPtr)();  
23
24  delete basePtr;
25  delete derivedPtr;
26}

1Base::foo()
2Base::foo()

In this example, fooPtr is a pointer to a member function of the Base class. We can assign the address of Base::foo() to it.

When we call the function pointer on a Base* that points to a Derived object, it invokes the Base::foo() implementation, not the Derived::foo() override. This is because the function pointer type is based on the Base class.

Similarly, even when we call the function pointer on a Derived*, it still invokes the Base::foo() implementation.

To achieve polymorphic behavior with function pointers, you need to use virtual functions. In the example above, if Base::foo() is declared as virtual and Derived::foo() overrides it, the behavior changes:

1#include <iostream>
2
3class Base {
4 public:
5  virtual void foo() {
6    std::cout << "Base::foo()\n"; }
7};
8
9class Derived : public Base {
10 public:
11  void foo() override {
12    std::cout << "Derived::foo()\n"; }
13};
14
main function (unchanged)|Show
15int main() {/*...*/}

1Derived::foo()
2Derived::foo()

Now, the function pointer invokes the derived class's implementation when called on a derived class object, exhibiting polymorphic behavior.

It's important to note that if the function signatures don't match between the base and derived classes, you won't be able to assign the derived class function to a base class function pointer.

Also, be cautious when using raw pointers and make sure to properly deallocate the memory to avoid leaks. In modern C++, it's recommended to use smart pointers or other resource management techniques to handle object lifetimes more safely.