Sovraccarico C ++ (operatore e funzione)
C ++ ti consente di specificare più di una definizione per un file function nome o un operator nello stesso ambito, che viene chiamato function overloading e operator overloading rispettivamente.
Una dichiarazione sovraccarica è una dichiarazione dichiarata con lo stesso nome di una dichiarazione dichiarata in precedenza nello stesso ambito, tranne per il fatto che entrambe le dichiarazioni hanno argomenti diversi e ovviamente una definizione (implementazione) diversa.
Quando chiami un file overload function o operator, il compilatore determina la definizione più appropriata da utilizzare, confrontando i tipi di argomenti utilizzati per chiamare la funzione o l'operatore con i tipi di parametro specificati nelle definizioni. Viene chiamato il processo di selezione della funzione o dell'operatore sovraccaricato più appropriatooverload resolution.
Sovraccarico di funzioni in C ++
È possibile avere più definizioni per lo stesso nome di funzione nello stesso ambito. La definizione della funzione deve differire l'una dall'altra per i tipi e / o il numero di argomenti nell'elenco degli argomenti. Non è possibile eseguire l'overload di dichiarazioni di funzione che differiscono solo per il tipo restituito.
Di seguito è riportato l'esempio in cui la stessa funzione print() viene utilizzato per stampare diversi tipi di dati -
#include <iostream>
using namespace std;
class printData {
public:
void print(int i) {
cout << "Printing int: " << i << endl;
}
void print(double f) {
cout << "Printing float: " << f << endl;
}
void print(char* c) {
cout << "Printing character: " << c << endl;
}
};
int main(void) {
printData pd;
// Call print to print integer
pd.print(5);
// Call print to print float
pd.print(500.263);
// Call print to print character
pd.print("Hello C++");
return 0;
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Printing int: 5
Printing float: 500.263
Printing character: Hello C++Sovraccarico degli operatori in C ++
È possibile ridefinire o sovraccaricare la maggior parte degli operatori incorporati disponibili in C ++. Pertanto, un programmatore può utilizzare anche operatori con tipi definiti dall'utente.
Gli operatori sovraccarichi sono funzioni con nomi speciali: la parola chiave "operatore" seguita dal simbolo dell'operatore da definire. Come qualsiasi altra funzione, un operatore sovraccarico ha un tipo restituito e un elenco di parametri.
Box operator+(const Box&);dichiara l'operatore di addizione che può essere utilizzato adddue oggetti Box e restituisce l'oggetto Box finale. La maggior parte degli operatori sovraccaricati può essere definita come funzioni ordinarie non membro o come funzioni membro di classe. Nel caso in cui definiamo la funzione sopra come funzione non membro di una classe, dovremmo passare due argomenti per ogni operando come segue:
Box operator+(const Box&, const Box&);Di seguito è riportato l'esempio per mostrare il concetto di operatore sovraccarico utilizzando una funzione membro. Qui un oggetto viene passato come argomento le cui proprietà saranno accessibili usando questo oggetto, l'oggetto che chiamerà questo operatore può essere raggiunto usandothis operatore come spiegato di seguito -
#include <iostream>
using namespace std;
class Box {
public:
double getVolume(void) {
return length * breadth * height;
}
void setLength( double len ) {
length = len;
}
void setBreadth( double bre ) {
breadth = bre;
}
void setHeight( double hei ) {
height = hei;
}
// Overload + operator to add two Box objects.
Box operator+(const Box& b) {
Box box;
box.length = this->length + b.length;
box.breadth = this->breadth + b.breadth;
box.height = this->height + b.height;
return box;
}
private:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};
// Main function for the program
int main() {
Box Box1; // Declare Box1 of type Box
Box Box2; // Declare Box2 of type Box
Box Box3; // Declare Box3 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// volume of box 1
volume = Box1.getVolume();
cout << "Volume of Box1 : " << volume <<endl;
// volume of box 2
volume = Box2.getVolume();
cout << "Volume of Box2 : " << volume <<endl;
// Add two object as follows:
Box3 = Box1 + Box2;
// volume of box 3
volume = Box3.getVolume();
cout << "Volume of Box3 : " << volume <<endl;
return 0;
}Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:
Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400Operatori sovraccaricabili / non sovraccaricabili
Di seguito è riportato l'elenco degli operatori che possono essere sovraccaricati:
| + | - | * | / | % | ^ |
| & | | | ~ | ! | , | = |
| < | > | <= | > = | ++ | - |
| << | >> | == | ! = | && | || |
| + = | - = | / = | % = | ^ = | & = |
| | = | * = | << = | >> = | [] | () |
| -> | -> * | nuovo | nuovo [] | Elimina | Elimina [] |
Di seguito è riportato l'elenco degli operatori, che non possono essere sovraccaricati:
| :: | . * | . | ?: |
Esempi di sovraccarico dell'operatore
Di seguito sono riportati vari esempi di sovraccarico dell'operatore per aiutarti a comprendere il concetto.