Implementacja funkcji członka podstawowego za pomocą wskaźnika funkcji członka do funkcji wirtualnej

Question

Mam sytuację, w której chcę wskaźnik funkcji członka do funkcji wirtualnej, która unika dynamicznego wysyłania. Patrz poniżej:

struct Base 
{ 
    virtual int Foo() { return -1; } 
}; 

struct Derived : public Base 
{ 
    virtual int Foo() { return -2; } 
}; 

int main() 
{ 
    Base *x = new Derived; 

    // Dynamic dispatch goes to most derived class' implementation  
    std::cout << x->Foo() << std::endl;  // Outputs -2 

    // Or I can force calling of the base-class implementation: 
    std::cout << x->Base::Foo() << std::endl; // Outputs -1 

    // Through a Base function pointer, I also get dynamic dispatch 
    // (which ordinarily I would want) 
    int (Base::*fooPtr)() = &Base::Foo; 
    std::cout << (x->*fooPtr)() << std::endl; // Outputs -2 

    // Can I force the calling of the base-class implementation 
    // through a member function pointer? 
    // ...magic foo here...? 

    return 0; 
} 

dla ciekawskich, powodem chcę to dlatego, że pochodzi implementacja klasy stosuje klasę użytkową do memoize (dodać około cache) realizację bazowej klasy. Klasa narzędzi przyjmuje wskaźnik funkcji, ale oczywiście wskaźnik funkcji dynamicznie odsyła do najbardziej wyprowadzonej klasy i otrzymuję nieskończoną rekursję.

Czy istnieje składnia, która pozwala mi odtworzyć zachowanie statyczne wysyłki, które można uzyskać za pomocą x->Base::foo(), ale za pomocą wskaźnika funkcji?

Answer 1

Można wymusić krojenie na Base* tak:

std::cout << (static_cast<Base>(*x).*fooPtr)() << std::endl; // Outputs -1 

Answer 2

Nie ma wolnostojący „wskaźnik funkcji członek” z właściwością chcesz. Najbliższa rzecz do oprawionego funkcji członka jest zamknięcie:

Base * x = new Derived; 
auto f = [x]() { x->Base::Foo(); } 
f(); 

Jeśli klasa Base jest specjalną, jednorazową przypadków użycia i jest pod kontrolą, należy prawdopodobnie dodać jakiś rodzaj „przyjąć gościa” funkcja do niej, dzięki czemu można przejść w dzwoniących członkowskich dynamicznie, jak x->accept(foo_caller); itp Przykładem w C++ 14:

struct X 
{ 
    template <typename F> 
    auto accept(F && f) 
    { 
     return [this, &f](auto &&... args) { 
      return f(this, std::forward<decltype(args)>(args)...); }; 
    } 

    virtual void foo() const { std::cout << "base\n"; } 
}; 

Zastosowanie:

void call_static_foo(X * p) 
{ 
    p->accept([](X * that){that->X::foo();}); 
}