C++: Casting Member Function Pointer

You are running into undefined behavior.

TypeFoo and bar are different types of function pointers (int (*)(int) and int (NB::B::*)(int) respectively). While it is possible to cast one to the other, using the result to call the function will result in undefined behavior.

8.2.10 Reinterpret cast [expr.reinterpret.cast]
...
6. A function pointer can be explicitly converted to a function pointer of a different type. [ Note: The effect of calling a function through a pointer to a function type (11.3.5) that is not the same as the type used in the definition of the function is undefined. —end note ] Except that converting a prvalue of type “pointer to T1” to the type “pointer to T2” (where T1 and T2 are function types) and back to its original type yields the original pointer value, the result of such a pointer conversion is unspecified. [ Note: See also 7.11 for more details of pointer conversions. —end note ]

Short answer: you don't.

Non-static member function pointers are weird. Calling one involves a secret this parameter, and they may or may not be virtual. This makes them impossible to mix with ordinary function pointers.

You should consider using std::function<int(int)> instead of int (*)(int). This would allow you to store something like the following lambda:

B(){
    std::function<int(int)> myfn = [this](int x){
        return bar(x);
    };
}

This lambda captures the current object by reference, and this reference is stored inside the std::function object itself. But you can just as well assign any other function to a std::function, directly or through a lambda or bind expression.

On the other hand, if your bar method doesn't really doesn't depend on an instance, just make it static. This will allow it to mix with regular function pointers, since it no longer needs a secret this and cannot be virtual.

static int bar(int i) {
    std::cout << i << std::endl;
    return i*2;
}

Written like this, &B::bar can be assigned to a regular int (*)(int) function pointer.

Your TypeFoo defines a pointer to a regular function while bar is a method. Each non-static method has an implicit first parameter this.

So you should decide what do you need: a regular function (in this case make the bar static) or a method, in this case you should typedef like that:

typedef int (B::*TypeFoo)(int);

The reinterpret_cast is an error prone practice. If you cannot cast without it - there is high probability that your code is not correct.

Invoking a member function pointer is a real pain. I suggest you go about this the following way, simplifying much of the context handling:

#include <iostream>
namespace NA {
    class A {
    public:
        int (A::*foo)(int);
    };
}

namespace NB {
    class B : public NA::A {
    public:
        int bar(int i) {
            std::cout << i << std::endl;
            return i*2;
        }
        int callFoo(int x) {
            return (this->*foo)(x);
        }
        B() {
            this->foo = (int(A::*)(int)) (&B::bar);
        }
    };
}


int main() {
    NA::A *a = new NB::B(); 
    std::cout << ((NB::B*)a)->callFoo(2) << std::endl;
}