Apprendimento C/C++ Passo-Passo - Pagina 15

15. Passo-Passo C/C++ — Programmazione C++ - Sovraccarico degli Operatori

Sovraccarico degli Operatori

| | 1. Introduzione

2. Operatore
   • Regole del Sovraccarico degli Operatori
   • Restrizioni sul Sovraccarico degli Operatori
3. Sovraccarico degli Operatori Unari
4. Sovraccarico degli Operatori Binari
5. Sovraccarico degli Operatori con Stringhe |

1. Introduzione

| | // Assegna una variabile a un’altra
#include
using namespace std;
int main()
{
int a = 10, b;
b = a; // valido
cout << b;
return 0;
} | // Assegna un oggetto a un altro
#include
using namespace std;
class emp
{
public:
int eno;
float sal;
};
int main()
{
emp e1= { 1001, 2300.45 },e2 ;
cout << endl << e1.eno << e1.sal;
e2 = e1; // valido
cout << endl << e2.eno << e2.sal;
return 0;
} |

Le espressioni sono comuni in ogni linguaggio; un’espressione è una raccolta di operandi e operatori. Mentre un’operazione è una raccolta di espressioni.
I due programmi sopra dimostrano come le variabili/gli oggetti siano stati assegnati insieme.

Entrambi i programmi sono validi, dimostrano l’uso dell’operatore di uguaglianza ( = ).

| | | |

Il sovraccarico degli operatori è una delle caratteristiche più entusiasmanti della programmazione orientata agli oggetti. Viene utilizzato per superare situazioni come l’operazione di struttura illegale sopra. Può trasformare elenchi di programmi complessi e oscuri in elenchi intuitivamente ovvi.

Attraverso il sovraccarico degli operatori possiamo vedere come gli operatori C++ normali possano ricevere nuovi significati quando applicati a tipi di dati definiti dall’utente. La parola chiave operator viene utilizzata per sovraccaricare un operatore, e l’operatore risultante adotterà il significato fornito dal programmatore.

Ad esempio, utilizzando un oggetto possiamo eseguire un’operazione di assegnazione di stringhe diretta.

| | // Programma per assegnare una stringa a un’altra
#include
#include
#include
using namespace std;
class string
{
char str;
public:
string() { }
string(char s) { str = s; }
void putstring()
{
cout << str;
}
};
int main()
{
string s1(“Computer”);
string s2;
s2 = s1;
s2.putstring();
return 0;
} |

2. Operatore

type operator simbolo-operatore ( lista-parametri )

La parola chiave operator dichiara una funzione specificando cosa significa simbolo-operatore quando applicato alle istanze di una classe. Questo conferisce all’operatore più di un significato, o lo “sovraccarica”. Il compilatore distingue tra i diversi significati di un operatore esaminando i tipi dei suoi operandi.

Regole del Sovraccarico degli Operatori

• Puoi sovraccaricare i seguenti operatori:

| | ^= | &= | |= | << | >> | <<= | | | <= | >= | && | || | ++ | –– | | | ( ) | [ ] | new | delete | & | | | | | ~ | = | /= | %= | >>= | == | | | != | , | –> | –> | | |

• Se un operatore può essere utilizzato sia come operatore unario che come operatore binario, puoi sovraccaricare ciascun uso separatamente.

• Puoi sovraccaricare un operatore utilizzando sia una funzione membro non statica che una funzione globale che è un’amica di una classe. Una funzione globale deve avere almeno un parametro che è di tipo classe o un riferimento a tipo classe.

• Se un operatore unario è sovraccaricato utilizzando una funzione membro, non prende argomenti. Se è sovraccaricato utilizzando una funzione globale, prende un argomento.

Se un operatore binario è sovraccaricato utilizzando una funzione membro, prende un argomento. Se è sovraccaricato utilizzando una funzione globale, prende due argomenti.

Restrizioni sul Sovraccarico degli Operatori

• Non puoi definire nuovi operatori, come **.

• Non puoi cambiare la precedenza o il raggruppamento di un operatore, né puoi cambiare il numero di operandi che accetta.

• Non puoi ridefinire il significato di un operatore quando applicato a tipi di dati incorporati.

• Gli operatori sovraccaricati non possono prendere argomenti predefiniti.

• Non puoi sovraccaricare alcun simbolo del preprocessore, né puoi sovraccaricare i seguenti operatori:

| | . | .* | :: | ?: |

L’operatore di assegnazione ha alcune restrizioni aggiuntive. Può essere sovraccaricato solo come funzione membro non statica, non come funzione amica. È l’unico operatore che non può essere ereditato; una classe derivata non può utilizzare l’operatore di assegnazione di una classe base.

3. Sovraccarico degli Operatori Unari

Iniziamo sovraccaricando un operatore unario. Gli operatori unari agiscono su un solo operando. (Un operando è semplicemente una variabile su cui agisce un operatore). Esempi di operatori unari sono gli operatori di incremento e decremento ++ e –, e il meno unario.

Esempio:
Il seguente esempio dimostra l’uso dell’operatore di incremento ++.

| | #include
using namespace std;
class counter
{
private:
unsigned int count;
public:
counter(){ count = 0; }
int get_count()  { return count; }
counter operator ++()
{
count++;
counter temp;
temp.count = count;
return temp;
}
};
int main()
{
counter c1, c2;                            // c1 = 0,  c2 = 0
cout << “\nC1 = “ << c1.get_count();       // visualizza
cout << “\nC2 = “ << c2.get_count();

++c1; // c1 = 1
c2 = ++c1 ; // c1 = 2, c2 = 2

cout << “\nC1 = “ << c1.get_count();       // visualizza di nuovo
cout << “\nC2 = “ << c2++.get_count();     // c2 = 3
return 0;
} |

Un altro esempio per sovraccaricare il meno unario.

| | #include
using namespace std;
class subtract
{
int a;
int b;
public:
void getdata(int x, int y)
{
a = x; b = y;
}
void putdata()
{
cout<< endl << “A = “ << a <<”B = “ << b;
}
void operator -()
{
a = -a; b = -b;
}
};

int main()
{
subtract s;
s.getdata(34, -6);
cout << endl << “S : “;
s.putdata();
-s;
cout << endl << “S : “;
s.putdata();
return 0;
}
|

4. Sovraccarico degli Operatori Binari

Ma gli operatori possono essere sovraccaricati altrettanto facilmente degli operatori unari.  Vedremo esempi che sovraccaricano operatori aritmetici, operatori di confronto e operatori di assegnazione aritmetica.

Abbiamo appena visto come sovraccaricare un operatore unario. Lo stesso meccanismo può essere utilizzato per sovraccaricare un operatore binario.

| | // Sovraccarico dell’operatore +
#include
using namespace std;
class time
{
int hh; int mm; int ss;
public:
time( ) { }
time(int h, int m, int s)
{
hh =h; mm = m; ss = s;
}
void disp_time()
{
cout << endl << hh<< “ : “
<< mm << “ : “ << ss;
}
time operator+(time);
};

time time::operator+(time t)
{
time temp;
temp.hh = hh + t.hh;
temp.mm = mm + t.mm;
temp.ss = ss + t.ss;
return temp;
}

int main()
{
time t1(12,1,24) , t2(5, 23, 45), t3;
t3 = t1 + t2;
t3.disp_time();
return 0;
} |

5. Sovraccarico degli Operatori con Stringhe

C/C++ gestisce le stringhe in modo piuttosto diverso; non copiamo, concatenamo o confrontiamo le stringhe utilizzando operatori come in altri linguaggi. C/C++ ha funzioni incorporate per eseguire le operazioni sopra. Ma C++ fornisce la possibilità di fare tutto sulle stringhe utilizzando operatori. Ciò significa che dobbiamo fornire responsabilità extra agli operatori per eseguire tali operazioni.

Il seguente esempio dimostra il confronto tra due stringhe utilizzando l’operatore di confronto ==.

| | // Programma per confrontare due stringhe utilizzando il sovraccarico degli operatori
#include
#include
#include
using namespace std;

enum boolean{ false, true };

class string
{
char str;
public:
string() { str = NULL; }
string(char *s) { str = s; }
int operator ==(string ts)
{
if (strcmp(str, ts.str) >= 0)
return true;
else
return false;
}
};

int main()
{
string s1(“Computer”);
string s2(“Computers”);

if(s1 == s2)
cout << “Uguale”;
else
cout << “Non Uguale”;

return 0;
} |

| | // concatenazione di due stringhe
#include
#include
#include
using namespace std;

class string
{
char str;
public:
string()
{
str = new char[30] ; str = NULL;
}
string(char *s) { str = s; }
string operator +(string ts)
{
string t;
strcat(t.str, str);
strcat(t.str, ts.str);
return t;
}
void putstring()
{
cout << endl << str;
}
};

int main()
{
string s1(“Computer”); string s2(“Istituto”);
s1.putstring(); s2.putstring();
string s3;

s3 = s1 + s2;

s3.putstring();
return 0;
} |

Rif: Programmazione orientata agli oggetti in Turbo C++: Robert Lafore