Differences
This shows you the differences between two versions of the page.
|
poo-is-ab:laboratoare:05 [2024/10/13 18:24] razvan.cristea0106 [Moștenirea între două clase] |
poo-is-ab:laboratoare:05 [2025/01/19 22:29] (current) razvan.cristea0106 |
||
|---|---|---|---|
| Line 17: | Line 17: | ||
| Acest tip de relație ne permite să definim **ierarhii de clase**, să **reutilizăm codul** și să **extindem** funcționalitățile claselor, oferind un model de organizare flexibil și scalabil. **Moștenirea** funcționează similar cu cea din viața reală: **clasa derivată** preia proprietățile și comportamentele **clasei de bază**, dar poate adăuga și **comportamente noi** sau **modifica** pe cele existente. Astfel, **moștenirea** facilitează **extensibilitatea** și **întreținerea** codului, reducând duplicarea și oferind un mod eficient de a gestiona complexitatea în proiecte de mari dimensiuni. | Acest tip de relație ne permite să definim **ierarhii de clase**, să **reutilizăm codul** și să **extindem** funcționalitățile claselor, oferind un model de organizare flexibil și scalabil. **Moștenirea** funcționează similar cu cea din viața reală: **clasa derivată** preia proprietățile și comportamentele **clasei de bază**, dar poate adăuga și **comportamente noi** sau **modifica** pe cele existente. Astfel, **moștenirea** facilitează **extensibilitatea** și **întreținerea** codului, reducând duplicarea și oferind un mod eficient de a gestiona complexitatea în proiecte de mari dimensiuni. | ||
| - | |||
| - | |||
| - | |||
| ==== Moștenirea între două clase ==== | ==== Moștenirea între două clase ==== | ||
| Line 52: | Line 49: | ||
| friend std::ostream& operator<<(std::ostream& out, const Locuinta& locuinta); | friend std::ostream& operator<<(std::ostream& out, const Locuinta& locuinta); | ||
| }; | }; | ||
| - | </code> | ||
| - | |||
| - | Iar implementările pentru funcțiile membre și cea friend le putem observa în codul de mai jos. | ||
| - | |||
| - | <code cpp> | ||
| - | #include "Locuinta.h" | ||
| - | |||
| - | Locuinta::Locuinta() | ||
| - | { | ||
| - | pret = 0.0f; | ||
| - | adresa = nullptr; | ||
| - | } | ||
| - | |||
| - | Locuinta::Locuinta(const float& pret, const char* adresa) | ||
| - | { | ||
| - | this->pret = pret; | ||
| - | |||
| - | if (adresa != nullptr) | ||
| - | { | ||
| - | this->adresa = new char[strlen(adresa) + 1]; | ||
| - | strcpy(this->adresa, adresa); | ||
| - | } | ||
| - | else | ||
| - | { | ||
| - | this->adresa = nullptr; | ||
| - | } | ||
| - | } | ||
| - | |||
| - | Locuinta::Locuinta(const Locuinta& locuinta) | ||
| - | { | ||
| - | pret = locuinta.pret; | ||
| - | |||
| - | if (locuinta.adresa != nullptr) | ||
| - | { | ||
| - | adresa = new char[strlen(locuinta.adresa) + 1]; | ||
| - | strcpy(adresa, locuinta.adresa); | ||
| - | } | ||
| - | else | ||
| - | { | ||
| - | adresa = nullptr; | ||
| - | } | ||
| - | } | ||
| - | |||
| - | Locuinta& Locuinta::operator=(const Locuinta& locuinta) | ||
| - | { | ||
| - | if (this == &locuinta) | ||
| - | { | ||
| - | return *this; | ||
| - | } | ||
| - | |||
| - | if (adresa != nullptr) | ||
| - | { | ||
| - | delete[] adresa; | ||
| - | } | ||
| - | |||
| - | pret = locuinta.pret; | ||
| - | |||
| - | if (locuinta.adresa != nullptr) | ||
| - | { | ||
| - | adresa = new char[strlen(locuinta.adresa) + 1]; | ||
| - | strcpy(adresa, locuinta.adresa); | ||
| - | } | ||
| - | else | ||
| - | { | ||
| - | adresa = nullptr; | ||
| - | } | ||
| - | |||
| - | return *this; | ||
| - | } | ||
| - | |||
| - | Locuinta::~Locuinta() | ||
| - | { | ||
| - | if (adresa != nullptr) | ||
| - | { | ||
| - | delete[] adresa; | ||
| - | } | ||
| - | } | ||
| - | |||
| - | float Locuinta::getPret() const | ||
| - | { | ||
| - | return pret; | ||
| - | } | ||
| - | |||
| - | char* Locuinta::getAdresa() const | ||
| - | { | ||
| - | return adresa; | ||
| - | } | ||
| - | |||
| - | void Locuinta::setPret(const float& pret) | ||
| - | { | ||
| - | if (pret <= 0.0f) | ||
| - | { | ||
| - | return; | ||
| - | } | ||
| - | |||
| - | this->pret = pret; | ||
| - | } | ||
| - | |||
| - | void Locuinta::setAdresa(const char* adresa) | ||
| - | { | ||
| - | if (adresa == nullptr) | ||
| - | { | ||
| - | return; | ||
| - | } | ||
| - | |||
| - | if (this->adresa != nullptr) | ||
| - | { | ||
| - | delete[] this->adresa; | ||
| - | } | ||
| - | |||
| - | this->adresa = new char[strlen(adresa) + 1]; | ||
| - | strcpy(this->adresa, adresa); | ||
| - | } | ||
| - | |||
| - | std::ostream& operator<<(std::ostream& out, const Locuinta& locuinta) | ||
| - | { | ||
| - | out << "Pretul locuintei este: " << locuinta.pret << " ron\n"; | ||
| - | |||
| - | if (locuinta.adresa != nullptr) | ||
| - | { | ||
| - | out << "Adresa locuintei este: " << locuinta.adresa << "\n"; | ||
| - | } | ||
| - | else | ||
| - | { | ||
| - | out << "Adresa locuintei este: inexistenta\n"; | ||
| - | } | ||
| - | |||
| - | return out; | ||
| - | } | ||
| </code> | </code> | ||
| Line 219: | Line 87: | ||
| </code> | </code> | ||
| - | === Relația de "is-a" între două clase === | + | === Relația de tip "is-a" între două clase === |
| Acest tip de relație ne permite să implementăm **moștenirea** între clase. În acest context, când discutăm despre moștenire, întâlnim următorii termeni esențiali: **clasă părinte (denumită și clasă de bază sau superclasă)** și **clasă derivată (denumită și clasă copil sau subclasă)**. **Clasa părinte** reprezintă clasa de la care dorim să **preluăm** atribute și metode, având posibilitatea să **reutilizăm** codul existent, în timp ce **clasa derivată** **extinde** această funcționalitate, **adăugând** noi comportamente și caracteristici. | Acest tip de relație ne permite să implementăm **moștenirea** între clase. În acest context, când discutăm despre moștenire, întâlnim următorii termeni esențiali: **clasă părinte (denumită și clasă de bază sau superclasă)** și **clasă derivată (denumită și clasă copil sau subclasă)**. **Clasa părinte** reprezintă clasa de la care dorim să **preluăm** atribute și metode, având posibilitatea să **reutilizăm** codul existent, în timp ce **clasa derivată** **extinde** această funcționalitate, **adăugând** noi comportamente și caracteristici. | ||
| Line 300: | Line 168: | ||
| === Implementarea metodelor și a funcțiilor friend în clasa derivată === | === Implementarea metodelor și a funcțiilor friend în clasa derivată === | ||
| - | În continuare vom prezenta modul în care trebuiesc implementate toate funcționalitățile clasei **Apartament** astfel încât realția de **"is-a"** să fie satisfăcută și să reutilizăm codul din clasa **Locuinta**. | + | În continuare vom prezenta modul în care trebuiesc implementate toate funcționalitățile clasei **Apartament** astfel încât relația de **"is-a"** să fie satisfăcută și să reutilizăm codul din clasa **Locuinta**. |
| == Implementarea constructorilor clasei derivate == | == Implementarea constructorilor clasei derivate == | ||
| Line 339: | Line 207: | ||
| Se poate observa din implementarea anterioară că am deschis lista de inițializare pentru acest constructor unde am chemat constructorul cu parametri al clasei părinte (clasa **Locuinta**). | Se poate observa din implementarea anterioară că am deschis lista de inițializare pentru acest constructor unde am chemat constructorul cu parametri al clasei părinte (clasa **Locuinta**). | ||
| - | <note warning>Constructorul cu parametri al **clasei derivate** include în lista sa de argumente și parametrii necesari pentru a apela **constructorul corespunzător din clasa părinte**. Acești parametri sunt transmiși în lista de inițializare a constructorului **clasei copil** atunci când este apelat constructorul din **superclasă**, facilitând astfel **inițializarea corectă** a **membrilor moșteniți** din **clasa părinte**. Acest mecanism permite transmiterea valorilor necesare direct către **clasa părinte**, asigurând o **organizare clară** și o **reutilizare eficientă** a codului.</note> | + | <note warning>Constructorul cu parametri din **clasa derivată** include în lista sa de argumente și parametrii necesari pentru a apela **constructorul corespunzător din clasa părinte**. Acești parametri sunt transmiși în lista de inițializare a constructorului **clasei copil** atunci când este apelat constructorul din **superclasă**, facilitând astfel **inițializarea corectă** a **membrilor moșteniți** din **clasa părinte**. Acest mecanism permite transmiterea valorilor necesare direct către **clasa părinte**, asigurând o **organizare clară** și o **reutilizare eficientă** a codului.</note> |
| - | În manieră simlară se implementează și constructorul de copiere al clasei derivate. | + | În manieră similară se implementează și constructorul de copiere al clasei derivate. |
| <code cpp> | <code cpp> | ||
| Line 422: | Line 290: | ||
| if (apartament.numeProprietar != nullptr) | if (apartament.numeProprietar != nullptr) | ||
| { | { | ||
| - | out << "Adresa locuintei este: " << apartament.numeProprietar << "\n"; | + | out << "Numele proprietarului este: " << apartament.numeProprietar << "\n"; |
| } | } | ||
| else | else | ||
| Line 433: | Line 301: | ||
| </code> | </code> | ||
| - | <note warning>Funcțiile **friend** dintr-o clasă **nu** se moștenesc automat de către **clasa derivată**, motiv pentru care trebuie să apelăm explicit **operatorul %%<<%%** definit în **clasa de bază**. Pentru a înțelege mai bine acest comportament, putem face următoarea analogie: prietenii părinților voștri **nu sunt neapărat** și prietenii voștri. Relația de prietenie este specifică **doar** între părinții voștri și acele persoane, iar aceasta **nu se extinde automat** asupra voastră. La fel, funcțiile **friend** sunt prietene ale **clasei părinte**, dar **nu** devin prietene implicit și pentru **clasa derivată**.</note> | + | <note warning>**Funcțiile friend** dintr-o clasă **nu** se moștenesc automat de către **clasa derivată**, motiv pentru care trebuie să apelăm explicit **operatorul %%<<%%** definit în **clasa de bază**. Pentru a înțelege mai bine acest comportament, putem face următoarea analogie: prietenii părinților voștri **nu sunt neapărat** și prietenii voștri. Relația de prietenie este specifică **doar** între părinții voștri și acele persoane, iar aceasta **nu se extinde automat** asupra voastră. La fel, funcțiile **friend** sunt prietene ale **clasei părinte**, dar **nu** devin prietene implicit și pentru **clasa derivată**.</note> |
| ==== ==== | ==== ==== | ||
| - | Acum că am înțeles conceptul de **moștenire** între două clase, vom putea avansa către implementarea unor ierarhii mai complexe începând cu următorul laborator. Moștenirea ne permite să construim structuri **ierarhice**, în care clasele pot extinde și reutiliza funcționalități din **clasele părinte**. Astfel, vom fi capabili să dezvoltăm sisteme mai robuste, eficiente și ușor de întreținut, în care fiecare clasă va adăuga comportamente și atribute specifice, păstrând în același timp funcționalitatea de bază moștenită. Aceste ierarhii de clase vor facilita gestionarea mai bună a codului și îmbunătățirea scalabilității aplicațiilor noastre. | + | Acum că am înțeles conceptul de **moștenire** între două clase, vom putea avansa către implementarea unor **ierarhii** mai complexe începând cu următorul laborator. **Moștenirea** ne permite să construim structuri **ierarhice**, în care clasele pot extinde și reutiliza funcționalități din **clasele părinte**. Astfel, vom fi capabili să dezvoltăm sisteme mai robuste, eficiente și ușor de întreținut, în care fiecare clasă va adăuga comportamente și atribute specifice, păstrând în același timp funcționalitatea de bază moștenită. Aceste ierarhii de clase vor facilita gestionarea mai bună a codului și îmbunătățirea scalabilității aplicațiilor noastre. |
| ==== Concluzii ==== | ==== Concluzii ==== | ||
| Line 449: | Line 317: | ||
| Un alt concept esențial a fost utilizarea **listei de inițializare a constructorului** în clasele derivate. În momentul în care instanțiem un obiect din clasa derivată, trebuie să avem grijă să inițializăm corect și **membrii clasei părinte**. Aceasta se realizează prin apelarea **explicită** a **constructorului părinte** în **lista de inițializare a constructorului clasei derivate**. Am subliniat importanța acestui mecanism, deoarece **doar** constructorii pot fi apelați în această manieră. | Un alt concept esențial a fost utilizarea **listei de inițializare a constructorului** în clasele derivate. În momentul în care instanțiem un obiect din clasa derivată, trebuie să avem grijă să inițializăm corect și **membrii clasei părinte**. Aceasta se realizează prin apelarea **explicită** a **constructorului părinte** în **lista de inițializare a constructorului clasei derivate**. Am subliniat importanța acestui mecanism, deoarece **doar** constructorii pot fi apelați în această manieră. | ||
| - | În plus, pentru a accesa metode sau funcții din **clasa părinte** care nu sunt constructori, trebuie să apelăm **explicit** funcția dorită folosind sintaxa: **''nume_clasa_parinte::nume_metodă()''**. Acest apel este necesar pentru a ne asigura că executăm **corect** comportamentul definit în **clasa părinte** asupra obiectelor din **clasa fiu**. | + | În plus, pentru a accesa metode sau funcții din **clasa părinte** care nu sunt constructori, trebuie să apelăm **explicit** funcția dorită folosind sintaxa: **''numeClasăPărinte::numeMetodă()''**. Acest apel este necesar pentru a ne asigura că executăm **corect** comportamentul definit în **clasa părinte** asupra obiectelor din **clasa fiu**. |
| Prin toate aceste concepte și tehnici, am făcut un pas important în **utilizarea eficientă** a **moștenirii** în limbajul C++, și suntem pregătiți să explorăm ierarhii mai complexe de clase în laboratoarele viitoare. | Prin toate aceste concepte și tehnici, am făcut un pas important în **utilizarea eficientă** a **moștenirii** în limbajul C++, și suntem pregătiți să explorăm ierarhii mai complexe de clase în laboratoarele viitoare. | ||
