Ignora in modo sicuro le funzioni virtuali C ++

Ho una classe base con una funzione virtuale e voglio sovrascrivere quella funzione in una classe derivata. C'è un modo per fare in modo che il compilatore controlli se la funzione che ho dichiarato nella classe derivata sostituisce effettivamente una funzione nella classe base? Vorrei aggiungere qualche macro o qualcosa che assicuri di non dichiarare accidentalmente una nuova funzione, invece di sovrascrivere quella vecchia.

Prendi questo esempio:

class parent {
public:
  virtual void handle_event(int something) const {
    // boring default code
  }
};

class child : public parent {
public:
  virtual void handle_event(int something) {
    // new exciting code
  }
};

int main() {
  parent *p = new child();
  p->handle_event(1);
}

Qui parent::handle_event()viene chiamato invece di child::handle_event(), perché il metodo del bambino manca la constdichiarazione e quindi dichiara un nuovo metodo. Potrebbe anche essere un errore di battitura nel nome della funzione o qualche piccola differenza nei tipi di parametri. Può anche accadere facilmente se l'interfaccia della classe base cambia e da qualche parte qualche classe derivata non è stata aggiornata per riflettere la modifica.

C'è un modo per evitare questo problema, posso in qualche modo dire al compilatore oa qualche altro strumento di controllarlo per me? Eventuali flag utili per il compilatore (preferibilmente per g ++)? Come eviti questi problemi?

A partire da g ++ 4.7, comprende la nuova overrideparola chiave C ++ 11 :

class child : public parent {
    public:
      // force handle_event to override a existing function in parent
      // error out if the function with the correct signature does not exist
      void handle_event(int something) override;
};

Qualcosa come la overrideparola chiave di C # non fa parte di C ++.

In gcc, -Woverloaded-virtualavverte di non nascondere una funzione virtuale della classe base con una funzione con lo stesso nome ma una firma sufficientemente diversa da non sovrascriverla. Tuttavia, non ti proteggerà dal non riuscire a sovrascrivere una funzione a causa dell'ortografia errata del nome della funzione stessa.

Per quanto ne so, non puoi semplicemente renderlo astratto?

class parent {
public:
  virtual void handle_event(int something) const = 0 {
    // boring default code
  }
};

Pensavo di aver letto su www.parashift.com che puoi effettivamente implementare un metodo astratto. Il che ha senso per me personalmente, l'unica cosa che fa è costringere le sottoclassi a implementarlo, nessuno ha detto nulla sul fatto che non gli sia permesso di avere un'implementazione stessa.

In MSVC, puoi usare la overrideparola chiave CLR anche se non stai compilando per CLR.

In g ++, non esiste un modo diretto per imporlo in tutti i casi; altre persone hanno dato buone risposte su come rilevare le differenze di firma utilizzando -Woverloaded-virtual. In una versione futura, qualcuno potrebbe aggiungere una sintassi simile __attribute__ ((override))o equivalente utilizzando la sintassi C ++ 0x.

In MSVC ++ puoi usare la parola chiaveoverride

class child : public parent {
public:
  virtual void handle_event(int something) <b>override</b> {
    // new exciting code
  }
};

override funziona sia per codice nativo che CLR in MSVC ++.

Rendi astratta la funzione, in modo che le classi derivate non abbiano altra scelta che sovrascriverla.

@Ray Il tuo codice non è valido.

class parent {
public:
  virtual void handle_event(int something) const = 0 {
    // boring default code
  }
};

Le funzioni astratte non possono avere corpi definiti in linea. Deve essere modificato per diventare

class parent {
public:
  virtual void handle_event(int something) const = 0;
};

void parent::handle_event( int something ) { /* do w/e you want here. */ }

Suggerirei un leggero cambiamento nella tua logica. Potrebbe funzionare o meno, a seconda di ciò che devi realizzare.

handle_event () può ancora fare il "noioso codice predefinito" ma invece di essere virtuale, nel punto in cui vuoi che esegua il "nuovo codice eccitante" fai chiamare la classe base un metodo astratto (cioè deve essere sovrascritto) che verrà fornito dalla tua classe discendente.

EDIT: E se in seguito decidi che alcune delle tue classi discendenti non hanno bisogno di fornire un "nuovo codice entusiasmante", puoi cambiare l'abstract in virtuale e fornire un'implementazione della classe base vuota di quella funzionalità "inserita".

Il tuo compilatore potrebbe avere un avviso che può generare se una funzione della classe base viene nascosta. Se lo fa, abilitalo. Ciò catturerà i conflitti di const e le differenze negli elenchi di parametri. Purtroppo questo non rivelerà un errore di ortografia.

Ad esempio, questo è un avviso C4263 in Microsoft Visual C ++.

La overrideparola chiave C ++ 11 quando viene utilizzata con la dichiarazione di funzione all'interno della classe derivata, forza il compilatore a verificare che la funzione dichiarata stia effettivamente sovrascrivendo alcune funzioni della classe base. In caso contrario, il compilatore genererà un errore.

Quindi è possibile utilizzare lo overridespecificatore per garantire il polimorfismo dinamico (sostituzione della funzione).

class derived: public base{
public:
  virtual void func_name(int var_name) override {
    // statement
  }
};