Übergeben abgeleitete virtuelle Überschreibung, um reines virtuelles Mitglied zu basieren

Question

Ich verstehe, warum Sie nicht einfach einen abgeleiteten Klassenmitgliedsfunktionszeiger auf Basisfunktionszeiger des Basismitglieds wie erläutert here umwandeln können.

Aber angesichts dieser Ausschnitt:

struct base 
{ 
    virtual void foo() = 0; 
}; 

struct derived : base 
{ 
    void foo() override {}; 
}; 

struct invoker 
{ 
    typedef void(base::*target)(); 

    invoker(base* b, target t) 
    { 
     (b->*t)(); 
    } 
}; 

template<typename B, typename D> 
void (B::*cast(void (D::*method)()))() 
{ 
    return static_cast<void(B::*)()>(method); 
} 

derived d; 
invoker bad(&d, &derived::foo); //C2664 
invoker good(&d, cast<base>(&derived::foo)); 

ich fragen wollte, ist es möglich, die Basisfunktion Unterschrift zu dekorieren, so dass Compiler es versteht, ist eine rein virtuelle Methode und, und es wird irgendwo in der Hierarchie implementiert werden (sonst könnte ich kein Objekt vom Typ B konstruieren)? Ich verstehe, warum ich das mit normalen Funktionen nicht tun kann, aber IMHO im Falle einer reinen virtuellen Funktion hat der Compiler eine Garantie, dass es implementiert wird (falls es nicht gemacht wurde, würde ich einen Fehler über die Klasse B nicht über die Besetzung).

Answer 1

Es ist nicht notwendig, den Typ &derived::foo zu manipulieren. Man kann stattdessen einfach &base::foo verwenden.

Zeiger auf Mitgliedsfunktionen respektieren die Virtualität. Dieser Aufruf

base* pBase = new derived; 
auto pFoo = &base::foo; 
(pBase->*pFoo)(); 

wird derived::foo eigentlich nennen, genau wie ein einfacher Anruf pBase->foo() würde.

Answer 2

Auch wenn es eine Garantie für die Implementierung gibt, werden möglicherweise zusätzliche Datenelemente verwendet, die nur in derived deklariert sind. Eine mögliche Lösung besteht darin, Funktionszeiger zu verwenden und this als ersten Parameter zu übergeben (dies zeigt Ihnen auch, warum Sie dies nicht über virtual tun können).

Answer 3

Betrachten Sie die folgende Diamant-Hierarchie:

struct base { 
virtual void foo() = 0; 
}; 

struct D1 : public virtual base { 
virtual void foo() override; 
}; 

struct D2 : public virtual base { 
virtual void foo() override; 
}; 

struct Derived : public virtual D1, D2 { 
virtual void foo() final; 
}; 

Jetzt ein Szenario, in dem ein upcast von Abgeleitet ist erlaubt :: * zu stützen :: *. Welche Funktion sollte aufgerufen werden? Der Compiler verliert Informationen darüber, welche von D1 :: foo, D2 :: foo oder Derived :: foo Sie aufrufen möchten, da diese Information weggeworfen wurde. Um diese Art von Mehrdeutigkeit zu vermeiden, ist ein solcher Upcast nicht zulässig.