Downcasting Function Pointers in C++

In C++, function pointer types are not part of any inheritance hierarchy, so the notion of downcasting doesn't directly apply. However, you can cast between function pointer types as long as the signatures are compatible.

Here's an example:

1#include <iostream>
2
3class Base {
4 public:
5  virtual void f() { std::cout << "Base\n"; }
6};
7
8class Derived : public Base {
9 public:
10  void f() override { std::cout << "Derived\n"; }
11};
12
13int main() {
14  void (Base::*bp)() = &Base::f;
15  void (Derived::*dp)() =
16    static_cast<void (Derived::*)()>(bp);  
17
18  Derived d;
19  (d.*dp)();  
20}

1Derived

Here, bp is a pointer to the Base version of f, and we cast it to a pointer to the Derived version, storing the result in dp. This is allowed because the function signatures are the same.

However, this is generally unsafe and can lead to undefined behavior if the function pointed to by bp is not actually a Derived function. The cast bypasses the type system and there's no runtime check.

It's much safer to use virtual functions and let the language handle the dispatch:

1Base* p = new Derived;
2p->f();

1Derived

In this case, the correct version of f will be called polymorphically through the base pointer.

So while you can cast function pointers, it's often a sign of bad design and should be avoided in favor of virtual functions or other safe polymorphism techniques.