Anumite operatii se pot exprima mult mai bine prin operatori. Nu se pot defini operatori noi, dar se pot supraincarca cei existenti ( +, <, ++, +=, >, [ ], ( ), new, delete, ., mai putin operatorii ), fara a modifica insa aritatea, prioritatea sau asociativitatea.
Supraincarcarea se poate face cu:
a) functii membru - numarul parametrilor fiind egal cu aritatea operatorului minus unu, deoarece un operand este chiar obiectul curent 131f56b pentru care se apeleaza metoda (acesta putand fi referit prin pointerul this),
b) functii prietene - numarul parametrilor fiind egal cu aritatea operatorului.
Redefinirea unui operator se realizeaza printr-o functie (prietena sau membru) al carei nume este compus din cuvantul operator urmat de operatorul propriuzis (+, <, .) .
Exemplu
Operatori de concatenare + &
# include <Conio.h>
# include <String.h> # include <Iostream.h>
class String ;
String::String ()
String::String (const String& S)
String::String (const char* S)
String& String::operator=(const String& S)
return *this; }
String String::operator+(String& S) // functie membru a)
String::~String ()
int String::Length ()
String operator&(String& s,String& S) // functie prietena b)
void String::Print ()
void main ()
Operatorul de atribuire ( ) se poate utiliza si pentru obiecte, acesta fiind supraincarcat implicit si realizeaza copierea datelor membru. Daca insa datele membru sunt referinte (pointeri) la niste variabile dinamice, atunci prin copiere se vor obtine doua obiecte care refera acceasi zona de memorie, iar la dealocare se va elibera aceeasi zona de doua ori, iar alta niciodata, ceea ce ne obliga, in aceasta situatie, la redefinirea (supraincarcarea) acestui operator. Prin aceasta, continutul variabilelor dinamice sunt identice, dar la adrese diferite, astfel incat daca un obiect isi modifica valorile, celalalt obiect ramane neschimbat.
Pentru o declaratie de tipul Clasa Obiect; se va apela constructorul implicit, sau cel cu toti parametrii impliciti, iar pentru o declaratie de forma Clasa Obiect=Ob; se va apela constructorul de copiere (si nu operatorul de atribuire) ca si la o declaratie de forma Clasa Obiect(Ob);. Constructorul de copiere se mai poate apela daca parametrul unei functii este un obiect sau daca functia returneaza un obiect.
Exemplu
Clasa Numar Natural Op.
# include <Conio.h>
# include <String.h>
# include <Iostream.h>
class Natural ;
Natural::Natural ( )
Natural::Natural (const Natural& S)
Natural::Natural (unsigned long S)
Natural& Natural::operator = (const Natural& S)
return *this; }
char* Suma (const char*, const char*);
Natural Natural::operator (const Natural& S)
char* Dif(const char*, const char*);
Natural Natural::operator (const Natural& S)
int Natural::operator< (const Natural& S)
int Natural::operator<=(const Natural& S)
int Natural::operator> (const Natural& S)
int Natural::operator>=(const Natural& S)
int Natural::operator==(const Natural& S)
int Natural::operator!=(const Natural& S)
int Natural:: Length ()
void Natural:: Print ()
void Natural:: Input ()
Natural::~Natural()
int Natural::Lung(unsigned long n)
char* Suma (const char* a, const char *b)
else t=0; j--; }
if (!t) return c;
char* d=new char[m+2]; for (i=0,d[0]='1'; i<=m; i++) d[i+1]=c[i];
delete []c; return d;
char* Dif (const char* a, const char *b)
else t=0; j--; }
char *d=c; while((*d=='0') && *(d+1)) d++;
strcpy(c,d); return c;
void main ()
Acesti operatori ( nu sunt supraincarcati automat, deci daca dorim sa-i utilizam va trebui sa ii redefinim (asa cum se poate vedea in exemplul urmator supraincarcarea operatorilor
Exemplu
Clasa Numar Natural Op.
# include <Conio.h>
# include <String.h> # include <Iostream.h>
class Natural ;
Natural::Natural ( )
Natural::Natural (const Natural& S)
Natural::Natural (unsigned long S)
Natural& Natural::operator= (const Natural& S)
char* Suma (const char* a, const char *b)
char* Dif (const char* a, const char *b)
Natural Natural::operator+ (const Natural& S)
Natural Natural::operator- (const Natural& S)
Natural& Natural::operator +=(Natural& S)
Natural& Natural::operator -=(Natural& S)
int Natural::operator< (const Natural& S)
int Natural::operator<=(const Natural& S)
int Natural::operator> (const Natural& S)
int Natural::operator>=(const Natural& S)
int Natural::operator==(const Natural& S)
int Natural::operator!=(const Natural& S)
int Natural:: Length ()
void Natural:: Print ()
Natural::~Natural()
int Natural::Lung(unsigned long n)
void main ()
getche();
Santana feat. Everlast - Put your lights on
Continuand cu exemplul anterior, dorim sa suparaincarcam operatorii de incrementare si decrementare, mai intai cei prefixati (++x, x), unde nu sunt probleme deosebite, apoi ce postfixati (x++, x Pentru a supraincarca si operatorii de incrementare postfixati vom adauga cate o functie membru avand un parametru de tip int (care nu se va folosi, si care automat la un apel va lua valoarea zero).
Exemplu
Clasa Numar Natural (Op. ++x,--x,x++,x--)
# include <Conio.h>
# include <String.h> # include <Iostream.h>
class Natural ;
Natural::Natural ( )
Natural::Natural (const Natural& S)
Natural::Natural (unsigned long S)
Natural& Natural::operator= (const Natural& S)
Natural Natural::operator+(const Natural& S)
Natural Natural::operator-(const Natural& S)
int Natural::operator< (const Natural& S)
Natural::~Natural()
Natural& Natural::operator++() // ++x
Natural& Natural::operator--() // --x
Natural Natural::operator++(int) // x++
Natural Natural::operator--(int) // x--
ostream& Natural::Tip (ostream& S) // cout
istream& Natural::Cit (istream& S) // cin
ostream& operator << ( ostream& S, Natural s ) // <<
istream& operator >> ( istream& S, Natural& s ) // >>
void main ()
|
