Che cosa significa la parola chiave virtuale quando si sostituisce un metodo?

Question

Cosa fa la parola chiave virtuale quando si sostituisce un metodo? Non sto usando e tutto funziona bene.

Ogni compilatore si comporta allo stesso modo a questo proposito?

Devo usarlo o no?

Answer 1

Non è possibile sostituire una funzione membro senza di essa.

È possibile solo nascondere uno.

struct Base { 
    void foo() {} 
}; 

struct Derived : Base { 
    void foo() {} 
}; 

Derived::foo fa non di override Base::foo; semplicemente nasconde perché ha lo stesso nome, in modo tale che la seguente:

Derived d; 
d.foo(); 

invoca Derived::foo.

virtual consente il polimorfismo tale che si realtà funzioni di override:

struct Base { 
    virtual void foo() {} 
}; 

struct Derived : Base { 
    virtual void foo() {} // * second `virtual` is optional, but clearest 
}; 

Derived d; 
Base& b = d; 
b.foo(); 

Questo richiama Derived::foo, perché questo ora overrideBase::foo — l'oggetto è polimorfico.

(È inoltre necessario da usare riferimenti o puntatori per questo, a causa di the slicing problem.)

---

• Derived::foo non ha bisogno di ripetere la parola virtual perché Base::foo ha già usato. Questo è garantito dallo standard e puoi fare affidamento su di esso. Tuttavia, alcuni pensano che sia meglio tenerlo per chiarezza.

Answer 2

Un metodo virtual nella classe base si sovrapporrà nella gerarchia, rendendo anche ogni metodo di sottoclasse con la stessa firma virtual.

class Base{ 
public: 
    virtual void foo(){} 
}; 

class Derived1 : public Base{ 
public: 
    virtual void foo(){} // fine, but 'virtual' is no needed 
}; 

class Derived2 : public Base{ 
public: 
    void foo(){} // also fine, implicitly 'virtual' 
}; 

io consiglierei di scrivere il virtual però, se a scopo di documentazione solo.

Answer 3

Quando una funzione è virtuale, rimane virtuale in tutta la gerarchia, indipendentemente dal fatto che specifichi esplicitamente ogni volta che è virtuale. Quando si esegue l'override un metodo, utilizzare virtuale al fine di essere più espliciti - nessun altra differenza :)

class A 
{ 
    virtual void f() 
    { 
     /*...*/ 
    }; 
}; 

class B:public A; 
{ 
    virtual void f() //same as just void f() 
    { 
     /*...*/ 
    }; 
};