Differences
This shows you the differences between two versions of the page.
|
poo-is-ab:laboratoare:05 [2025/09/24 11:48] razvan.cristea0106 [Funcții friend] |
poo-is-ab:laboratoare:05 [2025/11/01 11:58] (current) razvan.cristea0106 [Supraîncărcarea operatorilor] |
||
|---|---|---|---|
| Line 50: | Line 50: | ||
| | **Virgulă** | , | stânga - dreapta | | | **Virgulă** | , | stânga - dreapta | | ||
| - | <note important>Pentru operatorii din tabelul de mai sus am ales această ordine pentru a putea stabili cu ușurință **prioritățile** fiecăruia dintre ei. Astfel cea mai **mică** prioritate o are operatorul **virgulă**, în timp ce cea mai **mare** prioritate o au **operatorii primari**.</note> | + | <note important>Pentru operatorii din tabelul de mai sus am ales această ordine pentru a putea stabili cu ușurință **prioritățile** fiecăruia dintre ei. Astfel cea mai **mică** prioritate o are **operatorul virgulă**, în timp ce cea mai **mare** prioritate o au **operatorii primari**.</note> |
| ==== Funcții friend ==== | ==== Funcții friend ==== | ||
| Line 56: | Line 56: | ||
| În C++ funcțiile **friend** sunt acele funcții care au aces la zona **privată** a clasei, dar și la cea **protected**. Deși o funcție friend strică **principiul încapsulării datelor**, trebuie menționat că acest lucru este controlat. | În C++ funcțiile **friend** sunt acele funcții care au aces la zona **privată** a clasei, dar și la cea **protected**. Deși o funcție friend strică **principiul încapsulării datelor**, trebuie menționat că acest lucru este controlat. | ||
| - | <note tip>Pentru a înțelege mai bine rolul funcțiilor **friend**, imaginați-vă următoarea analogie: fiecare dintre voi are un set de gânduri și sentimente care sunt **private**, **inaccesibile** celorlalți. Totuși, ca ființe sociale, avem prieteni cărora alegem să le împărtășim aceste gânduri. Deși prietenii noștri **au acces** la informații personale, acest lucru **nu** înseamnă că oricine poate avea acces la ele. Voi sunteți cei care **dețineți controlul total** asupra a ceea ce **dezvăluiți** și **cui**.</note> | + | <note tip>Pentru a înțelege mai bine rolul **funcțiilor friend**, putem privi lucrurile astfel: fiecare dintre noi are un set de gânduri și sentimente care sunt **private**, **inaccesibile** celorlalți. Totuși, ca ființe sociale, avem prieteni cărora alegem să le împărtășim o parte din aceste gânduri. Deși prietenii noștri **au acces** la informații personale, acest lucru **nu** înseamnă că oricine le poate vedea. **Noi** suntem cei care **deținem controlul total** asupra a ceea ce **dezvăluim** și mai ales **cui**.</note> |
| Pentru a declara o funcție de tip **friend**, folosim cuvântul cheie **friend**. Aceste funcții sunt declarate în interiorul clasei și au cuvântul cheie **friend** plasat **înaintea tipului de return** al funcției. | Pentru a declara o funcție de tip **friend**, folosim cuvântul cheie **friend**. Aceste funcții sunt declarate în interiorul clasei și au cuvântul cheie **friend** plasat **înaintea tipului de return** al funcției. | ||
| Line 63: | Line 63: | ||
| <code cpp> | <code cpp> | ||
| - | #include <iostream> | ||
| #include <cstring> | #include <cstring> | ||
| + | #include <iostream> | ||
| class Persoana | class Persoana | ||
| { | { | ||
| - | int varsta; | + | int varsta; |
| - | char* nume; | + | char* nume; |
| public: | public: | ||
| - | Persoana(const int& varsta, const char* nume); | + | Persoana(const int& varsta, const char* nume); |
| - | ~Persoana(); | + | ~Persoana(); |
| - | friend void afisarePersoana(const Persoana& persoana); // functie friend pentru afisarea datelor unei persoane | + | friend void afisarePersoana(const Persoana& persoana); // functie friend pentru afisarea datelor unei persoane |
| }; | }; | ||
| Persoana::Persoana(const int& varsta, const char* nume) | Persoana::Persoana(const int& varsta, const char* nume) | ||
| { | { | ||
| - | this->varsta = varsta; | + | this->varsta = varsta; |
| - | if (nume != nullptr) | + | if (nume != nullptr) |
| - | { | + | { |
| - | this->nume = new char[strlen(nume) + 1]; | + | this->nume = new char[strlen(nume) + 1]; |
| - | strcpy(this->nume, nume); | + | strcpy(this->nume, nume); |
| - | } | + | } |
| - | else | + | else |
| - | { | + | { |
| - | this->nume = nullptr; | + | this->nume = nullptr; |
| - | } | + | } |
| } | } | ||
| Persoana::~Persoana() | Persoana::~Persoana() | ||
| { | { | ||
| - | if (nume != nullptr) | + | if (nume != nullptr) |
| - | { | + | { |
| - | delete[] nume; | + | delete[] nume; |
| - | } | + | } |
| } | } | ||
| void afisarePersoana(const Persoana& persoana) | void afisarePersoana(const Persoana& persoana) | ||
| { | { | ||
| - | std::cout << "Numele persoanei este: " << persoana.nume << '\n'; | + | std::cout << "Numele persoanei este: " << persoana.nume << '\n'; |
| - | std::cout << "Varsta persoanei este: " << persoana.varsta << "\n\n"; | + | std::cout << "Varsta persoanei este: " << persoana.varsta << "\n\n"; |
| } | } | ||
| int main() | int main() | ||
| { | { | ||
| - | Persoana persoana(22, "Andrei"); | + | Persoana persoana(22, "Andrei"); |
| - | afisarePersoana(persoana); // apelarea functiei friend este identica cu a unei functii clasice din C/C++ | + | afisarePersoana(persoana); // apelarea functiei friend este identica cu a unei functii clasice din C/C++ |
| - | return 0; | + | return 0; |
| } | } | ||
| </code> | </code> | ||
| Line 135: | Line 135: | ||
| class NrComplex | class NrComplex | ||
| { | { | ||
| - | double real; | + | double real; |
| - | double imaginar; | + | double imaginar; |
| public: | public: | ||
| - | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); // constructor cu parametri cu valori implicite | + | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); // constructor cu parametri cu valori implicite |
| - | double getReal() const; | + | double getReal() const; |
| - | double getImaginar() const; | + | double getImaginar() const; |
| - | void setReal(const double& real); | + | void setReal(const double& real); |
| - | void setImaginar(const double& imaginar); | + | void setImaginar(const double& imaginar); |
| }; | }; | ||
| </code> | </code> | ||
| Line 157: | Line 157: | ||
| NrComplex::NrComplex(const double& real, const double& imaginar) | NrComplex::NrComplex(const double& real, const double& imaginar) | ||
| { | { | ||
| - | this->real = real; | + | this->real = real; |
| - | this->imaginar = imaginar; | + | this->imaginar = imaginar; |
| } | } | ||
| double NrComplex::getReal() const | double NrComplex::getReal() const | ||
| { | { | ||
| - | return real; | + | return real; |
| } | } | ||
| double NrComplex::getImaginar() const | double NrComplex::getImaginar() const | ||
| { | { | ||
| - | return imaginar; | + | return imaginar; |
| } | } | ||
| void NrComplex::setReal(const double& real) | void NrComplex::setReal(const double& real) | ||
| { | { | ||
| - | this->real = real; | + | this->real = real; |
| } | } | ||
| void NrComplex::setImaginar(const double& imaginar) | void NrComplex::setImaginar(const double& imaginar) | ||
| { | { | ||
| - | this->imaginar = imaginar; | + | this->imaginar = imaginar; |
| } | } | ||
| </code> | </code> | ||
| Line 203: | Line 203: | ||
| class NrComplex | class NrComplex | ||
| { | { | ||
| - | double real; | + | double real; |
| - | double imaginar; | + | double imaginar; |
| public: | public: | ||
| - | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); | + | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); |
| - | double getReal() const; | + | double getReal() const; |
| - | double getImaginar() const; | + | double getImaginar() const; |
| - | void setReal(const double& real); | + | void setReal(const double& real); |
| - | void setImaginar(const double& imaginar); | + | void setImaginar(const double& imaginar); |
| - | // supraincarcarea operatorilor ca functii membre | + | // supraincarcarea operatorilor ca functii membre |
| - | NrComplex& operator++(); // forma prefixata | + | NrComplex& operator++(); // forma prefixata |
| - | NrComplex operator++(int); // forma postfixata | + | NrComplex operator++(int); // forma postfixata |
| }; | }; | ||
| </code> | </code> | ||
| Line 228: | Line 228: | ||
| NrComplex& NrComplex::operator++() | NrComplex& NrComplex::operator++() | ||
| { | { | ||
| - | this->real++; | + | this->real++; |
| - | this->imaginar++; | + | this->imaginar++; |
| - | return *this; | + | return *this; |
| } | } | ||
| NrComplex NrComplex::operator++(int) | NrComplex NrComplex::operator++(int) | ||
| { | { | ||
| - | NrComplex copie = *this; | + | NrComplex copie = *this; |
| - | this->real++; | + | this->real++; |
| - | this->imaginar++; | + | this->imaginar++; |
| - | return copie; | + | return copie; |
| } | } | ||
| </code> | </code> | ||
| - | <note important>Se poate observa ca la **forma postfixată** avem un parametru de care **nu** ne folosim. Acel parametru este **doar** pentru a asigura **polimorfismul**, compilatorul făcând distincția între cele două variante de operator de incrementare.</note> | + | <note important>Se poate observa că la **forma postfixată** avem un parametru de care **nu** ne folosim. Acel parametru este **doar** pentru a asigura **polimorfismul**, compilatorul făcând distincția între cele două variante de operator de incrementare.</note> |
| Pentru **operatorul de decrementare** se aplică aceleași **exact** aceeași pași, încercați să îl implementați voi pentru a putea înțelege mai bine cum funcționează conceptul de **overloading**. | Pentru **operatorul de decrementare** se aplică aceleași **exact** aceeași pași, încercați să îl implementați voi pentru a putea înțelege mai bine cum funcționează conceptul de **overloading**. | ||
| Line 260: | Line 260: | ||
| class NrComplex | class NrComplex | ||
| { | { | ||
| - | double real; | + | double real; |
| - | double imaginar; | + | double imaginar; |
| public: | public: | ||
| - | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); | + | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); |
| - | double getReal() const; | + | double getReal() const; |
| - | double getImaginar() const; | + | double getImaginar() const; |
| - | void setReal(const double& real); | + | void setReal(const double& real); |
| - | void setImaginar(const double& imaginar); | + | void setImaginar(const double& imaginar); |
| - | // supraincarcarea operatorilor ca functii membre | + | // supraincarcarea operatorilor ca functii membre |
| - | NrComplex operator!() const; // operatorul de negare logica (in cazul acestei clase va conjuga un numar complex) | + | NrComplex operator!() const; // operatorul de negare logica (in cazul acestei clase va conjuga un numar complex) |
| - | NrComplex& operator++(); | + | NrComplex& operator++(); |
| - | NrComplex operator++(int); | + | NrComplex operator++(int); |
| }; | }; | ||
| </code> | </code> | ||
| Line 287: | Line 287: | ||
| NrComplex NrComplex::operator!() const | NrComplex NrComplex::operator!() const | ||
| { | { | ||
| - | NrComplex conjugat = *this; | + | NrComplex conjugat = *this; |
| - | conjugat.imaginar = -conjugat.imaginar; | + | conjugat.imaginar = -conjugat.imaginar; |
| - | return conjugat; | + | return conjugat; |
| } | } | ||
| </code> | </code> | ||
| Line 299: | Line 299: | ||
| == Supraîncărcarea operatorilor == și != == | == Supraîncărcarea operatorilor == și != == | ||
| - | **Operatorul %%==%%** este folosit pentru a testa egaliatetea dintre doi operanzi, deci prin urmare trebuie să returneze o valoare de adevăr (**true** sau **false**). Îl supraîncârcăm ca funcție membră, deoarece avem deja un parametru existent, și anume **pointerul this**, la care mai adăugăm un alt parametru care reprezintă **obiectul cu care facem comparația**. | + | **Operatorul %%==%%** este folosit pentru a testa egalitatea dintre doi operanzi, deci prin urmare trebuie să returneze o valoare de adevăr (**true** sau **false**). Îl supraîncârcăm ca funcție membră, deoarece avem deja un parametru existent, și anume **pointerul this**, la care mai adăugăm un alt parametru care reprezintă **obiectul cu care facem comparația**. |
| Același lucru putem spune și despre **operatorul %%!=%%**, numai că el face exact **opusul** a ceea ce face operatorul de testare a egalității între doi operanzi, adică verifică dacă valorile celor doi termeni sunt **diferite**. | Același lucru putem spune și despre **operatorul %%!=%%**, numai că el face exact **opusul** a ceea ce face operatorul de testare a egalității între doi operanzi, adică verifică dacă valorile celor doi termeni sunt **diferite**. | ||
| Line 310: | Line 310: | ||
| class NrComplex | class NrComplex | ||
| { | { | ||
| - | double real; | + | double real; |
| - | double imaginar; | + | double imaginar; |
| public: | public: | ||
| - | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); | + | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); |
| - | double getReal() const; | + | double getReal() const; |
| - | double getImaginar() const; | + | double getImaginar() const; |
| - | void setReal(const double& real); | + | void setReal(const double& real); |
| - | void setImaginar(const double& imaginar); | + | void setImaginar(const double& imaginar); |
| - | // supraincarcarea operatorilor functii membre | + | // supraincarcarea operatorilor functii membre |
| - | NrComplex operator!() const; | + | NrComplex operator!() const; |
| - | NrComplex& operator++(); | + | NrComplex& operator++(); |
| - | NrComplex operator++(int); | + | NrComplex operator++(int); |
| - | bool operator==(const NrComplex& z) const; // operatorul de testare a egalitatii intre doua numere complexe | + | bool operator==(const NrComplex& z) const; // operatorul de testare a egalitatii intre doua numere complexe |
| - | bool operator!=(const NrComplex& z) const; // operatorul de testare a diferentei intre doua numere complexe | + | bool operator!=(const NrComplex& z) const; // operatorul de testare a diferentei intre doua numere complexe |
| }; | }; | ||
| </code> | </code> | ||
| Line 340: | Line 340: | ||
| bool NrComplex::operator==(const NrComplex& z) const | bool NrComplex::operator==(const NrComplex& z) const | ||
| { | { | ||
| - | return this->real == z.real && this->imaginar == z.imaginar; | + | return this->real == z.real && this->imaginar == z.imaginar; |
| } | } | ||
| bool NrComplex::operator!=(const NrComplex& z) const | bool NrComplex::operator!=(const NrComplex& z) const | ||
| { | { | ||
| - | return this->real != z.real || this->imaginar != z.imaginar; | + | return this->real != z.real || this->imaginar != z.imaginar; |
| + | /*return !(*this == z) // o varianta mai eleganta de a nega rezultatul intors de operatorul == pentru a nu duplica codul*/ | ||
| } | } | ||
| </code> | </code> | ||
| Line 358: | Line 359: | ||
| class NrComplex | class NrComplex | ||
| { | { | ||
| - | double real; | + | double real; |
| - | double imaginar; | + | double imaginar; |
| public: | public: | ||
| - | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); | + | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); |
| - | double getReal() const; | + | double getReal() const; |
| - | double getImaginar() const; | + | double getImaginar() const; |
| - | void setReal(const double& real); | + | void setReal(const double& real); |
| - | void setImaginar(const double& imaginar); | + | void setImaginar(const double& imaginar); |
| - | // supraincarcarea operatorilor ca functii membre | + | // supraincarcarea operatorilor ca functii membre |
| - | NrComplex operator!() const; | + | NrComplex operator!() const; |
| - | NrComplex& operator+=(const NrComplex& z); // operatorul compus pentru adunarea a doua numere complexe | + | NrComplex& operator+=(const NrComplex& z); // operatorul compus pentru adunarea a doua numere complexe |
| - | NrComplex& operator++(); | + | NrComplex& operator++(); |
| - | NrComplex operator++(int); | + | NrComplex operator++(int); |
| - | bool operator==(const NrComplex& z) const; | + | bool operator==(const NrComplex& z) const; |
| - | bool operator!=(const NrComplex& z) const; | + | bool operator!=(const NrComplex& z) const; |
| }; | }; | ||
| </code> | </code> | ||
| Line 390: | Line 391: | ||
| NrComplex& NrComplex::operator+=(const NrComplex& z) | NrComplex& NrComplex::operator+=(const NrComplex& z) | ||
| { | { | ||
| - | this->real += z.real; | + | this->real += z.real; |
| - | this->imaginar += z.imaginar; | + | this->imaginar += z.imaginar; |
| - | return *this; | + | return *this; |
| } | } | ||
| </code> | </code> | ||
| Line 401: | Line 402: | ||
| ==== ==== | ==== ==== | ||
| - | <note important>Nu doar **operatorii unari** sunt supraîncărcați ca funcții membre, mai putem supraîncărca și operatori precum cel de **indexare ("[]")**, operatorul de **apel de funcție ("()")**, operatorul **săgeată ("%%->%%")** și operatorul de **asignare ("=")**. Cei din urmă trebuie implementați **exclusiv** ca funcții membre în clasă. De asemenea, și operatorii de comparație pot fi supraîncărcați ca **metode** ale clasei, dar în contextul numerelor complexe aceștia **nu au sens**, deoarece în matematică **nu** există **relație de ordine** în mulțimea numerelor complexe.</note> | + | <note important>Nu doar **operatorii unari** sunt supraîncărcați ca funcții membre, mai putem supraîncărca și operatori precum cel de **indexare ("[ ]")**, operatorul de **apel de funcție ("( )")**, operatorul **săgeată ("%%->%%")** și operatorul de **asignare ("=")**. Cei din urmă trebuie implementați **exclusiv** ca funcții membre în clasă. De asemenea, și operatorii de comparație pot fi supraîncărcați ca **metode** ale clasei, dar în contextul numerelor complexe aceștia **nu au sens**, deoarece în matematică **nu** există **relație de ordine** în mulțimea numerelor complexe.</note> |
| === Operatori supraîncărcați ca funcții friend === | === Operatori supraîncărcați ca funcții friend === | ||
| Line 418: | Line 419: | ||
| class NrComplex | class NrComplex | ||
| { | { | ||
| - | double real; | + | double real; |
| - | double imaginar; | + | double imaginar; |
| public: | public: | ||
| - | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); | + | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); |
| - | double getReal() const; | + | double getReal() const; |
| - | double getImaginar() const; | + | double getImaginar() const; |
| - | void setReal(const double& real); | + | void setReal(const double& real); |
| - | void setImaginar(const double& imaginar); | + | void setImaginar(const double& imaginar); |
| - | // supraincarcarea operatorilor ca functii membre | + | // supraincarcarea operatorilor ca functii membre |
| - | NrComplex operator!() const; | + | NrComplex operator!() const; |
| - | NrComplex& operator+=(const NrComplex& z); | + | NrComplex& operator+=(const NrComplex& z); |
| - | NrComplex& operator++(); | + | NrComplex& operator++(); |
| - | NrComplex operator++(int); | + | NrComplex operator++(int); |
| - | bool operator==(const NrComplex& z) const; | + | bool operator==(const NrComplex& z) const; |
| - | bool operator!=(const NrComplex& z) const; | + | bool operator!=(const NrComplex& z) const; |
| - | // operatori supraincarcati ca functii friend | + | // operatori supraincarcati ca functii friend |
| - | friend NrComplex operator+(const NrComplex& z1, const NrComplex& z2); // operator pentru adunarea a doua numere complexe | + | friend NrComplex operator+(const NrComplex& z1, const NrComplex& z2); // operator pentru adunarea a doua numere complexe |
| - | friend NrComplex operator+(const NrComplex& z1, const double& numar); // operator pentru adunarea unui numar complex cu un numar real | + | friend NrComplex operator+(const NrComplex& z1, const double& numar); // operator pentru adunarea unui numar complex cu un numar real |
| - | friend NrComplex operator+(const double& numar, const NrComplex& z1); // operator pentru adunarea unui numar real cu un numar complex | + | friend NrComplex operator+(const double& numar, const NrComplex& z1); // operator pentru adunarea unui numar real cu un numar complex |
| }; | }; | ||
| </code> | </code> | ||
| Line 456: | Line 457: | ||
| NrComplex operator+(const NrComplex& z1, const NrComplex& z2) | NrComplex operator+(const NrComplex& z1, const NrComplex& z2) | ||
| { | { | ||
| - | NrComplex z; | + | NrComplex z; |
| - | z.real = z1.real + z2.real; | + | z.real = z1.real + z2.real; |
| - | z.imaginar = z1.imaginar + z2.imaginar; | + | z.imaginar = z1.imaginar + z2.imaginar; |
| - | return z; | + | return z; |
| } | } | ||
| NrComplex operator+(const NrComplex& z1, const double& numar) | NrComplex operator+(const NrComplex& z1, const double& numar) | ||
| { | { | ||
| - | NrComplex z; | + | NrComplex z; |
| - | z.real = z1.real + numar; | + | z.real = z1.real + numar; |
| - | z.imaginar = z1.imaginar; | + | z.imaginar = z1.imaginar; |
| - | return z; | + | return z; |
| } | } | ||
| NrComplex operator+(const double& numar, const NrComplex& z1) | NrComplex operator+(const double& numar, const NrComplex& z1) | ||
| { | { | ||
| - | NrComplex z; | + | NrComplex z; |
| - | z.real = numar + z1.real; | + | z.real = numar + z1.real; |
| - | z.imaginar = z1.imaginar; | + | z.imaginar = z1.imaginar; |
| - | return z; | + | return z; |
| } | } | ||
| </code> | </code> | ||
| Line 495: | Line 496: | ||
| <code cpp> | <code cpp> | ||
| #include <iostream> | #include <iostream> | ||
| - | using namespace std; | ||
| class NrComplex | class NrComplex | ||
| { | { | ||
| - | double real; | + | double real; |
| - | double imaginar; | + | double imaginar; |
| public: | public: | ||
| - | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); | + | NrComplex(const double& real = 0.0, const double& imaginar = 0.0); |
| - | double getReal() const; | + | double getReal() const; |
| - | double getImaginar() const; | + | double getImaginar() const; |
| - | void setReal(const double& real); | + | void setReal(const double& real); |
| - | void setImaginar(const double& imaginar); | + | void setImaginar(const double& imaginar); |
| - | // supraincarcarea operatorilor ca functii membre | + | // supraincarcarea operatorilor ca functii membre |
| - | NrComplex operator!() const; | + | NrComplex operator!() const; |
| - | NrComplex& operator+=(const NrComplex& z); | + | NrComplex& operator+=(const NrComplex& z); |
| - | NrComplex& operator++(); | + | NrComplex& operator++(); |
| - | NrComplex operator++(int); | + | NrComplex operator++(int); |
| - | bool operator==(const NrComplex& z) const; | + | bool operator==(const NrComplex& z) const; |
| - | bool operator!=(const NrComplex& z) const; | + | bool operator!=(const NrComplex& z) const; |
| - | // operatori supraincarcati ca functii friend | + | // operatori supraincarcati ca functii friend |
| - | friend NrComplex operator+(const NrComplex& z1, const NrComplex& z2); | + | friend NrComplex operator+(const NrComplex& z1, const NrComplex& z2); |
| - | friend NrComplex operator+(const NrComplex& z1, const double& numar); | + | friend NrComplex operator+(const NrComplex& z1, const double& numar); |
| - | friend NrComplex operator+(const double& numar, const NrComplex& z1); | + | friend NrComplex operator+(const double& numar, const NrComplex& z1); |
| - | friend istream& operator>>(istream& in, NrComplex& z); // operator pentru citirea unui numar complex | + | friend std::istream& operator>>(std::istream& in, NrComplex& z); // operator pentru citirea unui numar complex |
| - | friend ostream& operator<<(ostream& out, const NrComplex& z); // operator pentru afisarea unui numar complex | + | friend std::ostream& operator<<(std::ostream& out, const NrComplex& z); // operator pentru afisarea unui numar complex |
| }; | }; | ||
| </code> | </code> | ||
| Line 541: | Line 541: | ||
| <code cpp> | <code cpp> | ||
| - | istream& operator>>(istream& in, NrComplex& z) | + | std::istream& operator>>(std::istream& in, NrComplex& z) |
| { | { | ||
| - | cout << "Introduceti partea reala a numarului complex: "; | + | std::cout << "Introduceti partea reala a numarului complex: "; |
| - | in >> z.real; | + | in >> z.real; |
| - | cout << "Introduceti partea imaginara a numarului complex: "; | + | std::cout << "Introduceti partea imaginara a numarului complex: "; |
| - | in >> z.imaginar; | + | in >> z.imaginar; |
| - | return in; | + | return in; |
| } | } | ||
| - | ostream& operator<<(ostream& out, const NrComplex& z) | + | std::ostream& operator<<(std::ostream& out, const NrComplex& z) |
| { | { | ||
| - | out << "Partea reala a numarului complex este: " << z.real << '\n'; | + | out << "Partea reala a numarului complex este: " << z.real << '\n'; |
| - | out << "Partea imaginara a numarului complex este: " << z.imaginar << "\n\n"; | + | out << "Partea imaginara a numarului complex este: " << z.imaginar << "\n\n"; |
| - | return out; | + | return out; |
| } | } | ||
| </code> | </code> | ||
