Programare orientată pe · Curs 4 Programare orientată pe obiecte C++/Java 24.10.2013 3 1....

LECTOR DR. ADRIAN RUNCEANU

Programare orientată pe

obiecte

Universitatea “Constantin Brâncuşi” din Târgu-Jiu

Facultatea de Inginerie

Departamentul de Automatică, Energie şi Mediu

24.10.2013 Programare orientată pe obiecte C++/Java

2

Curs 4 Supraîncărcarea operatorilor

(partea I)

Curs 4


3

1. Supraîncărcarea operatorilor 2. Modalităţi de supraîncărcare a

operatorilor 2.1. Supraîncărcarea operatorilor

folosind funcţii membre 2.2. Supraîncărcarea operatorilor

folosind funcţii prietene (friends)

1. Supraîncărcarea operatorilor


4

Operatorii sunt notaţii concise, infixate, pentru operaţii matematice uzuale.

Limbajul C++, ca orice limbaj de programare

asigură un set de operatori pentru tipurile primitive.

În plus, faţă de limbajul C, C++ oferă

posibilitatea asocierii operatorilor existenţi cu tipurile definite de utilizator.



5

Astfel, prezintă interes extinderea operatorilor:

în aritmetică complexă în algebra matricială în lucrul cu şiruri de caractere, etc Un operator poate fi privit ca o funcţie, în care

termenii sunt argumentele funcţiei: în lipsa operatorului + expresia a+b s-ar calcula apelând funcţia aduna(a,b)



6

Limbajul C++ introduce următorii operatori noi:

1. new şi 2. delete - pentru gestiunea memoriei

dinamice 3. operatorul de rezoluţie (::) şi 4. operatorii de acces la membri: .* şi ->*.



7

Limbajul C++ permite programatorului să definească diverse operații cu obiecte ale claselor, folosind simbolurile operatorilor standard.

Un tip clasă se poate defini împreună cu un set de operatori asociați, obtinuți prin supraîncărcarea (overloading) operatorilor existenți.

În acest fel, se efectuează operații specifice cu noul tip la fel de simplu ca în cazul tipurilor standard.



8

Procedeul constă în definirea unei funcții cu numele:

operator simbol unde: operator este cuvântul cheie dedicat simbol este simbolul oricărui operator

C++, mai puțin următoriii: “.”, “*”, “::”, “?:”, “sizeof”.



9

Vom evita folosirea termenului redefinire, căruia îi vom da o semnificaţie diferită, în contextul moştenirii.

Anumiţi operatori pot fi utilizaţi cu orice tip de termeni (sunt deja supraîncărcaţi global de către compilator).



10

Aceştia sunt: new delete sizeof :: = & ->* .* . ->



11

Pot fi supraîncărcaţi următorii operatori:

+ *= ->

- %= >

/ |= []

% >>= ()

^ *

-= ,



12

Nu pot fi supraîncărcaţi operatorii: :: . .* ?: sizeof



13

Reguli pentru supraîncărcare: Setul de operatori ai limbajul C++ nu poate fi

extins prin asocierea de semnificaţii noi unor caractere, care nu sunt operatori (de exemplu nu putem defini operatorul „**”).

Prin supraîncărcarea unui operator nu i se poate modifica aritatea (astfel operatorul “!” este unar şi poate fi supraincarcat numai ca operator unar). De asemeni asociativitatea şi precedenţa operatorului se menţin.



14

La supraîncărcarea unui operator nu se pot specifica argumente cu valori implicite.

Operatorii supraîncărcaţi într-o clasă sunt moşteniţi în clasele derivate (excepţie face operatorul de atribuire „=”).

Curs 4


15





2. Modalităţi de supraîncărcare a operatorilor


16

Exemple:

Pentru exemplificare, folosim tot tipul abstract complex definit în cursul anterior și supraîncărcăm:

operatorul “+” pentru a putea aduna două numere complexe

operatorul “-” pentru a putea scădea două numere complexe

2. Modalităţi de supraîncărcare a operatorilor


17

Funcțiile operator+() si operator-() trebuie să primească câte doi parametri de tip complex și să returneze un rezultat de tip complex și trebuie să aibă acces la datele clasei complex.

Acest lucru se poate realiza în două moduri:

1. ca funcții membre ale clasei complex 2. ca funcții prietene ale clasei complex

Curs 4


18





2.1 Supraîncărcarea operatorilor folosind funcţii membre


19

O funcție membră primește în mod implicit adresa obiectului pentru care este apelată.

Funcția operator+() va avea prototipul: complex operator+(complex);

Expresia x + y, unde x și y sunt de tipul complex, va fi interpretată de compilator ca un apel:

x.complex+(y)



20

Funcția operator-() va avea prototipul:

complex operator-(complex); Expresia x - y, unde x și y sunt de tipul

complex, va fi interpretată de compilator ca un apel:

x.complex-(y)



21

Programul următor prezintă o variantă mai simplă a clasei complex, cu operatorii “+” și “-” supraîncărcați:

#include class complex { // date membru protejate(private) double real; double imag;



22

// funcții membru neprotejate public: // constructor folosit la inițializare complex(double x=0, double y=0); void afiscomplex(); complex operator+(complex); complex operator-(complex); };



23

complex::complex(double x, double y) { real=x; imag=y; } void complex::afiscomplex() { cout



24

complex complex::operator+(complex x) { complex z; z.real = real + x.real; z.imag = imag + x.imag; return z; }



25

complex complex::operator-(complex x) { complex z; z.real = real - x.real; z.imag = imag - x.imag; return z; }



26

int main(void) { double x, y; cout



27

cout



28

complex t1, t2; t1 = z1 + z2; cout

Curs 4


29





2.2. Supraîncărcarea operatorilor folosind funcţii prietene (friends)


30

Funcții prietene (friend) Există posibilitatea ca anumite funcții,

care nu aparțin unei clase să poată accesa datele private ale acesteia, caz în care funcțiile respective se numesc “funcții prietene”.



31

Pentru a atașa unei clase o funcție prieten introducem în interiorul definiției sale prototipul funcției prieten, precedat de cuvântul cheie friend.

O funcție prieten nu poate accesa datele direct, așa cum poate o metodă a clasei respective, ci prin intermediul parametrului de tip obiect transmis.



32

În C++ operatorii pot fi supraîncărcaţi prin funcţii prieten.

Revenind la exemplul cu clasa complex, putem adauga funcția prietenă operator*() care are următorul prototip: complex operator*(complex, complex)

Expresia x * y va fi interpretată de către compilator ca un apel al funcției

operator*(x, y) care este perfect echivalentă.



33

Exemplul următor prezintă acest tip de supraîncărcare a operatorilor “*” și “/”:

#include class complex { // date membru protejate(private) double real; double imag;



34

// funcții membru neprotejate public: // constructor folosit la inițializare complex(double x=0,double y=0); void afiscomplex(); // prototipul funcțiilor prietene friend complex operator*(complex, complex); friend complex operator/(complex, complex); };



35

complex::complex(double x, double y) { real=x; imag=y; } void complex::afiscomplex() { cout



36

complex operator*(complex x, complex y)

{ complex z; z.real = x.real * y.real – x.imag * y.imag; z.imag = x.real * y.imag + x.imag *

y.real; return z; }



37

complex operator/(complex x, complex y) { complex z; z.real = (y.real * x.real + y.imag * x.imag)

/ (x.real * x.real + x.imag * x.imag); z.imag=(y.imag * x.real – y.real * x.imag)

/ (x.real * x.real + x.imag * x.imag); return z; }



38

int main(void) { double x, y; cout



39

cout



40

complex t1, t2; t1 = z1 * z2; cout


41

Întrebări?

Date post:	31-Jan-2021
Category:	Documents
Upload:	others
View:	9 times
Download:	0 times

Programare orientată pe · Curs 4 Programare orientată pe obiecte C++/Java 24.10.2013 3 1....

Documents