En C++ si une fonction membre est virtuelle quand la liaison statique peut-elle être utilisée?

Question

En C++, quand une fonction virtuelle peut-elle utiliser une liaison statique? Si on y accède par un pointeur, on y accède directement ou jamais?

Answer 1

La liaison statique ne peut être effectuée que lorsque le type de l'objet est totalement non ambigu à la compilation. Je ne peux penser qu'à quatre endroits où le type d'un objet abstrait est sans ambiguïté: dans le constructeur, dans le destructeur, lorsqu'il est déclaré localement et dans la même portée qu'une allocation dynamique. Je ne connais pas très bien le standard, donc je ne peux pas dire ce qu'il dit à propos de ces quatre possibilités (je dirais que les deux premiers sont liés statiquement, le troisième possible statiquement et le dernier non, bien qu'il soit probablement indéfini ou dépendante de l'implémentation). En dehors de ces points, l'objet auquel on accède via un pointeur de classe de base peut pointer vers une classe dérivée et l'unité de traduction actuelle n'a aucun moyen de le savoir. La liaison statique n'est donc pas possible. La fonction peut être appelée avec un pointeur vers la classe de base dans une instance et un pointeur vers une classe dérivée dans une autre!

Answer 2

Si vous voulez appeler la version de classe de base d'une fonction, vous pouvez le faire en nommant explicitement la classe de base:

class Base 
{ 
public: 
    virtual ~Base() {} 
    virtual void DoIt() { printf("In Base::DoIt()\n"); } 
}; 

class Derived : public Base 
{ 
public: 
    virtual void DoIt() { printf("In Derived::DoIt()\n"); } 
}; 

Base *basePtr = new Derived; 
basePtr->DoIt(); // Calls Derived::DoIt() through virtual function call 
basePtr->Base::DoIt(); // Explicitly calls Base::DoIt() using normal function call 
delete basePtr;

Answer 3

Lorsqu'une méthode virtuelle est appelée par un pointeur ou une référence, la liaison dynamique est utilisé. A tout autre moment, la liaison à la compilation est utilisée. Ex:

class C; 

void Foo(C* a, C& b, C c) { 
    a->foo(); // dynamic 
    b.foo(); // dynamic 
    c.foo(); // static (compile-time) 
}