Sovraccarico degli operatori e delle funzioni in C++

Sovraccarico delle funzioni in C++

All'interno dello stesso ambito, è possibile dichiarare più funzioni con lo stesso nome simile, ma i parametri delle funzioni (cioè il numero, il tipo o l'ordine dei parametri) devono essere diversi. Non è possibile sovraccaricare le funzioni solo differendo nel tipo di ritorno.

Nello esempio seguente, le funzioni con lo stesso nome print() usata per output di diversi tipi di dati:

#include <iostream>
using namespace std;
　
class printData
{
　　　public:
　　　　　　void print(int i) {
　　　　　　　　cout << "L'intero è: " << i << endl;
　　　　　　}
　
　　　　　　void print(double f) {
　　　　　　　　cout << "Il numero a virgola mobile è: " << f << endl;
　　　　　　}
　
　　　　　　void print(char c[]) {
　　　　　　　　cout << "La stringa è: " << c << endl;
　　　　　　}
};
　
int main(void)
{
　　　printData pd;
　
　　　// Output dell'intero
　　　pd.print(5);
　　　// Output del numero a virgola mobile
　　　pd.print(500.263);
　　　// Output della stringa
　　　char c[] = "Hello C++";
　　　pd.print(c);
　
　　　return 0;
}

Quando il codice sopra viene compilato ed eseguito, produce i seguenti risultati:

L'intero è: 5
Il numero a virgola mobile è: 500.263
La stringa è: Hello C++

Sovraccarico degli operatori in C++

Puoi ridefinire o sovraccaricare la maggior parte degli operatori nativi di C++. In questo modo, puoi utilizzare gli operatori su tipi personalizzati.

Gli operatori sovraccaricati sono funzioni con nomi speciali, il nome della funzione è composto dalla parola chiave operator e dal simbolo dell'operatore da sovraccaricare che segue. Come altre funzioni, il sovraccarico degli operatori ha un tipo di ritorno e un elenco di parametri.

Box operator+(const Box&);

L'operatore somma viene dichiarato per sommare due oggetti Box e restituire l'oggetto Box finale. La maggior parte degli operatori sovraccaricati possono essere definiti come funzioni non membri o come funzioni membri. Se definiamo la funzione sopra come una funzione non membro, dobbiamo passare due parametri per ogni operazione, come segue:

Box operator+(const Box&, const Box&);

L'esempio seguente utilizza le funzioni membro per illustrare il concetto di sovraccarico degli operatori. In questo caso, gli oggetti vengono passati come parametri e le proprietà degli oggetti vengono this L'operatore viene utilizzato per l'accesso, come segue:

#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;
　　　　　　}
　　　　　　//　重载 + 运算符，用于把两个 Box 对象相加
　　　　　　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;　　//　长度
　　　　　　double breadth;　　//　宽度
　　　　　　double height;　　//　高度
};
//　程序的主函数
int main(　)
{
　　　Box Box1;　　//　声明 Box1，类型为 Box
　　　Box Box2;　　//　声明 Box2，类型为 Box
　　　Box Box3;　　//　声明 Box3，类型为 Box
　　　double volume = 0.0; // Stoccare il volume in questa variabile
　
　　　// Dettagli di Box1
　　　Box1.setLength(6.0);　
　　　Box1.setBreadth(7.0);　
　　　Box1.setHeight(5.0);
　
　　　// Dettagli di Box2
　　　Box2.setLength(12.0);　
　　　Box2.setBreadth(13.0);　
　　　Box2.setHeight(10.0);
　
　　　// Volume di Box1
　　　volume = Box1.getVolume();
　　　cout << "Il volume di Box1: " << volume << endl;
　
　　　// Volume di Box2
　　　volume = Box2.getVolume();
　　　cout << "Il volume di Box2: " << volume << endl;
　
　　　// Somma due oggetti, ottenendo Box3
　　　Box3 = Box1 + Box2;
　
　　　// Volume di Box3
　　　volume = Box3.getVolume();
　　　cout << "Il volume di Box3: " << volume << endl;
　
　　　return 0;
}

Quando il codice sopra viene compilato ed eseguito, produce i seguenti risultati:

Il volume di Box1: 210
Il volume di Box2: 1560
Il volume di Box3: 5400

Operatori ricaricabili/Operatori non ricaricabili

Ecco l'elenco degli operatori ricaricabili:

Ecco l'elenco degli operatori non ricaricabili:

• .: Operatore di accesso ai membri

• .*, ->*: Operatore di accesso ai puntatori ai membri

• ::: Operatore di dominio

• sizeof: Operatore di lunghezza

• ?:: Operatore condizionale

• #: Simbolo di preprocessore

Esempio di sovraccarico dell'operatore

Di seguito sono forniti esempi di sovraccarico degli operatori per aiutarvi a comprendere meglio il concetto di sovraccarico.