Ci sono sottigliezze nell'uso di entrambe le parole chiave virtuali e di override in C++ 11?

Question

È pericoloso utilizzare sia virtual e override su una funzione in C++? Ti apre per ambiguità con sovraccarico?

Ovviamente virtual deve essere utilizzato nella classe base e sarebbe stupido non utilizzare override nella classe derivata, ma è in realtà problematico utilizzare virtualconoverride nella classe derivata?

Cercando di determinare se questo è un problema di stile o correttezza.

Esempio:

class Widget { 
    virtual void transmogrify() = 0; 
} 

class Gadget : public Widget { 
    virtual void transmogrify() override {} 
} 

Answer 1

Il virtual parola chiave non ha alcun effetto quando si è prevalente. Una funzione derivata che corrisponde a una firma per una funzione virtuale definita in una classe base sovrascriverà la definizione di base e l'override verrà immessa nel vtable, indipendentemente dal fatto che la parola chiave virtual sia utilizzata nella classe derivata o meno.

Poiché la parola chiave override causerà un errore di compilazione in caso di ignoranza, la parola chiave virtual non è utile in combinazione.

Qui, hanno un bigino:

| Keyword used | Matching virtual function in base class | Result     | 
|--------------|-----------------------------------------|--------------------------| 
| Neither  | No          | New non-virtual function | 
| Neither  | Yes          | Override     | 
| virtual  | No          | New virtual function  | 
| virtual  | Yes          | Override     | 
| override  | No          | Compile error   | 
| override  | Yes          | Override     | 
| Both   | No          | Compile error   | 
| Both   | Yes          | Override     | 

Answer 2

Nel tuo esempio si sta dicendo due cose diverse, ma importanti sul metodo Gadget s' transmogrify

virtual - se una classe deriva dalla Gadget poi il transmogrify la funzione sarà considerata virtuale dalla classe derivata

override - la classe Gadget è sovrascrivere esplicitamente la versione della classe base Widget di transmogrify.

I due lavori chiave sono ortogonali e non si influenzano a vicenda. La cosa bella della parola chiave override è che sta dichiarando al compilatore che stai tentando di sovrascrivere una funzione virtuale ereditata. Se hai fatto un errore in corrispondenza della firma funzione della funzione sulla classe di base non si compila come deve ignorare una funzione ereditata, se dichiarata come override