HOWTO · C++
Overload delle funzioni VS Override in C++
Questo articolo spiega la differenza tra sovraccarico di funzioni e ridefinizione di funzioni in C++.
In questa pagina
Il sovraccarico di funzioni e la ridefinizione di funzioni risolvono problemi diversi in C++. Il sovraccarico di funzioni assegna lo stesso nome a funzioni nello stesso ambito, ma con liste di parametri diverse; il compilatore sceglie quella corrispondente agli argomenti della chiamata. La ridefinizione di funzioni consente a una classe derivata di fornire una nuova implementazione di una funzione virtual ereditata; se la chiamata avviene tramite un riferimento o un puntatore alla classe base, a runtime viene selezionata l’implementazione dell’oggetto derivato.
Cosa significano sovraccarico e ridefinizione in C++
Il sovraccarico consiste nello scegliere tra funzioni che differiscono per i parametri. La ridefinizione consiste nel sostituire un comportamento all’interno di una gerarchia di ereditarietà. Il solo tipo restituito non distingue un sovraccarico, mentre per ridefinire una funzione è necessario che la classe base ne dichiari una virtual. Lo specificatore override chiede al compilatore di verificare che la dichiarazione della classe derivata corrisponda davvero a una funzione virtuale della classe base.
Come funziona il sovraccarico di funzioni
Dichiara nello stesso ambito funzioni con il medesimo nome e liste di parametri diverse. Le liste possono differire per numero o tipo dei parametri. Quando viene effettuata una chiamata, la risoluzione del sovraccarico usa gli argomenti e i tipi dei parametri delle funzioni candidate. Il tipo restituito non viene usato per scegliere una funzione: due dichiarazioni che differiscono soltanto per il tipo restituito non formano quindi un insieme valido di sovraccarichi.
Esegui questo esempio:
Il codice e le etichette o gli output visibili in questa sezione restano in inglese.
#include <iostream>
class Formatter {
public:
void show(int value) const {
std::cout << "integer: " << value << '\n';
}
void show(double value) const {
std::cout << "decimal: " << value << '\n';
}
};
int main() {
Formatter formatter;
formatter.show(7);
formatter.show(2.5);
}
integer: 7
decimal: 2.5
Le evidenze di esecuzione fornite confermano che questo esempio è stato eseguito correttamente e ha prodotto quell’output. Gli argomenti interi e decimali selezionano due diversi sovraccarichi di show. Quando aggiungi un sovraccarico, assicurati che la lista dei parametri differisca in modo significativo e che le chiamate restino prive di ambiguità.
Come funziona la ridefinizione di funzioni
La classe base dichiara una funzione virtual; una classe derivata fornisce una funzione con lo stesso nome e la stessa lista di parametri, oltre a qualificatori e tipo restituito compatibili. Contrassegna la dichiarazione derivata con override, così un’incompatibilità genera un errore di compilazione. Quando la funzione viene chiamata tramite un riferimento o un puntatore alla classe base, il dispatch virtuale seleziona la ridefinizione finale per l’oggetto.
Esegui questo esempio:
Il codice e le etichette o gli output visibili in questa sezione restano in inglese.
#include <iostream>
class Message {
public:
virtual void print() const {
std::cout << "message\n";
}
};
class Alert : public Message {
public:
void print() const override {
std::cout << "alert\n";
}
};
int main() {
Alert alert;
const Message& message = alert;
message.print();
}
alert
Le evidenze di esecuzione fornite confermano che questo esempio è stato eseguito correttamente e ha prodotto quell’output. Anche se message ha il tipo della classe base, fa riferimento a un oggetto Alert; perciò la chiamata virtuale usa Alert::print. Una classe base può anche dichiarare una funzione virtuale pura con = 0; in tal caso la classe è astratta e non può essere istanziata finché le classi derivate concrete non implementano le sue funzioni virtuali pure.
Sovraccarico e ridefinizione: differenze principali
| Aspetto | Sovraccarico di funzioni | Ridefinizione di funzioni |
|---|---|---|
| Scopo | Fornire operazioni con lo stesso nome per argomenti diversi | Specializzare il comportamento ereditato per un tipo derivato |
| Requisito | Liste di parametri diverse nello stesso ambito | Ereditarietà e una funzione virtual corrispondente nella classe base |
| Selezione | Risoluzione del sovraccarico a compile time in base agli argomenti della chiamata | Dispatch virtuale a runtime tramite un riferimento o un puntatore alla classe base |
| Verifica utile | Assicurarsi che le chiamate identifichino il sovraccarico desiderato | Aggiungere override per verificare la corrispondenza della dichiarazione |
I sovraccarichi possono esistere senza ereditarietà o funzioni virtuali. Le ridefinizioni dipendono dall’ereditarietà e dal dispatch virtuale: non vengono selezionate passando una lista di argomenti diversa.
Errori comuni e come riconoscerli
Una funzione derivata con lo stesso nome non ridefinisce automaticamente una funzione della classe base. Se la funzione base non è virtual, la dichiarazione derivata nasconde il nome della funzione base invece di abilitare il dispatch virtuale. Se non corrisponde un parametro, il qualificatore const o un’altra parte del tipo della funzione, la ridefinizione prevista potrebbe non riuscire; scrivere override rende evidente l’incompatibilità in fase di compilazione.
Non cercare di creare un sovraccarico cambiando soltanto il tipo restituito. Inoltre, se ti aspetti un comportamento polimorfico, evita di passare oggetti derivati per valore: copiarne uno in un oggetto della classe base elimina la parte derivata. Usa un riferimento o un puntatore alla classe base per preservare il dispatch dinamico. Per la gestione ordinaria della proprietà, preferisci oggetti automatici o puntatori intelligenti; se elimini un oggetto derivato tramite un puntatore alla classe base, quest’ultima dovrebbe avere un distruttore virtuale.