Interrupts using member function
Calling the static member of the base class should work.
You just have to make sure the Instance pointer is correct.
This can be done with the singleton pattern.
Be aware of potential reentrancy risk with this approach though.

Example (disclaimer: I have not dealt with this exact problem before):
https://godbolt.org/z/a6qj3c
class Base {
protected:
    static Base *instance;
    Base(){}
    virtual ~Base(){}
public:
    static Base* getInstance(){
        return instance;
    }
    static void setInstance(Base* p){
        instance = p;
    }
    virtual void run();
};

Base* Base::instance;

class Child : public Base {
public:
    Child(){
        Base::setInstance(this);
    }
    ~Child() override {
        Base::setInstance(nullptr);
    }
    void run() override;
};

void Base::run(){
    cout &lt;&lt; &quot;the base thing&quot; &lt;&lt; endl;
}

void Child::run() {
    cout &lt;&lt; &quot;the child thing&quot; &lt;&lt; endl;
}

extern &quot;C&quot; void isr(){
    if(Base::getInstance() != nullptr)
        Base::getInstance()-&gt;run();
}

int main()
{
    Child b;
    isr();
    return 0;
}

Returns:
the child thing

Now, big red flag, you can call Child::run() from two contexts. Your main thread and your interrupt routine. This means that Child::run() can be called while executing Child::run(), this a reentrancy problem.