Puntatori alle funzioni dei membri virtuali. Come funziona?

Question

Si consideri il seguente codice C++:

class A 
{ 
public: 
     virtual void f()=0; 
}; 


int main() 
{ 
    void (A::*f)()=&A::f; 
} 

Se avessi a indovinare, direi che & A :: F in questo contesto significherebbe "l'indirizzo della realizzazione di una di f()", poiché non esiste una separazione esplicita tra i puntatori alle funzioni membro regolari e le funzioni membro virtuali. E dal momento che A non implementa f(), sarebbe un errore di compilazione. Tuttavia, non lo è.

E non solo. Il seguente codice:

void (A::*f)()=&A::f; 
A *a=new B;   // B is a subclass of A, which implements f() 
(a->*f)(); 

chiamerà effettivamente B :: f.

Come mai?

Answer 1

Ecco troppe informazioni sui puntatori funzione membro. C'è un po 'di cose sulle funzioni virtuali sotto "I compilatori ben fatti", anche se IIRC quando ho letto l'articolo che stavo sfiorando quella parte, dato che l'articolo riguarda l'implementazione dei delegati in C++.

http://www.codeproject.com/KB/cpp/FastDelegate.aspx

La risposta è che dipende dal compilatore, ma una possibilità è che il puntatore a funzione membro è implementato come una struttura che contiene un puntatore a una funzione "thunk" che rende la chiamata virtuale.

Answer 2

Funziona perché lo standard dice che è come dovrebbe accadere. Ho fatto alcuni test con GCC, e si è scoperto per le funzioni virtuali, GCC memorizza l'offset della tabella virtuale della funzione in questione, in byte.

struct A { virtual void f() { } virtual void g() { } }; 
int main() { 
    union insp { 
    void (A::*pf)(); 
    ptrdiff_t pd[2]; 
    }; 
    insp p[] = { { &A::f }, { &A::g } }; 
    std::cout << p[0].pd[0] << " " 
      << p[1].pd[0] << std::endl; 
} 

Tale uscite del programma 1 5 - gli offset byte degli voci della tabella virtuali di queste due funzioni. Segue lo Itanium C++ ABI, which specifies that.

Answer 3

Non sono del tutto sicuro, ma penso che sia solo un comportamento polimorfico regolare. Penso che &A::f in realtà significhi l'indirizzo del puntatore alla funzione nel vtable della classe, ed è per questo che non si ottiene un errore del compilatore. Lo spazio nel vtable è ancora allocato, e questa è la posizione in cui si sta effettivamente tornando.

Questo ha senso perché le classi derivate essenzialmente sovrascrivono questi valori con i puntatori alle loro funzioni. Questo è il motivo per cui (a->*f)() funziona nel secondo esempio: f fa riferimento al vtable implementato nella classe derivata.