Diferență între revizuiri ale paginii „C++ POO Lab Lucrarea 3”

De la WikiLabs
Jump to navigationJump to search
Linia 5: Linia 5:
 
* Referința
 
* Referința
 
* Supraîncărcarea operatorilor
 
* Supraîncărcarea operatorilor
 
  
 
= Destructorul =
 
= Destructorul =
 +
=== Introducere ===
  
 
Așa cum s-a prezentat în laboratorul anterior, crearea unui obiect se face folosind o metodă specială, numită '''constructor'''. Printre altele, cu ajutorul constructorului putem:  
 
Așa cum s-a prezentat în laboratorul anterior, crearea unui obiect se face folosind o metodă specială, numită '''constructor'''. Printre altele, cu ajutorul constructorului putem:  
Linia 16: Linia 16:
 
Pe de altă parte, odată ce nu mai avem nevoie de un obiect, acesta trebuie eliminat într-un mod controlat, astfel încât memoria ocupată să poată fi refolosită. Acest lucru este realizat cu ajutorul unei alte metode speciale, numită '''destructor''', ce este apelată automat atunci când contextul în care a fost declarat obiectul se încheie (out of scope). Pentru mai multe informații legate de context (scope) în C++, accesați [https://en.cppreference.com/w/cpp/language/scope acest link].
 
Pe de altă parte, odată ce nu mai avem nevoie de un obiect, acesta trebuie eliminat într-un mod controlat, astfel încât memoria ocupată să poată fi refolosită. Acest lucru este realizat cu ajutorul unei alte metode speciale, numită '''destructor''', ce este apelată automat atunci când contextul în care a fost declarat obiectul se încheie (out of scope). Pentru mai multe informații legate de context (scope) în C++, accesați [https://en.cppreference.com/w/cpp/language/scope acest link].
  
 +
=== Exemplu ===
  
 
În exemplul de mai jos sunt evidențiate mecanismele de ’construire’ si ’distrugere’ a obiectelor:
 
În exemplul de mai jos sunt evidențiate mecanismele de ’construire’ si ’distrugere’ a obiectelor:
Linia 57: Linia 58:
  
 
= Referința =  
 
= Referința =  
 +
=== Introducere ===
 +
 +
O referință reprezintă un nume alternativ cu care poate fi accesat un obiect/o variabilă. Așa cum vom prezenta în continuare, mecanismul de referințe simplifică accesul la date intre diferite entități (de exemplu între funcții). <br>
 +
 +
Sintaxa pentru declararea unei referințe este următoarea: <code> <tip_de_date>'''&''' nume_referinta = variabila </code> <br>
 +
Odată declarată, cu ajutorul referinței vom accesa aceeași informație pe care o accesăm cu variabila cu care aceasta a fost legată (cele două făcând referire la aceeași zonă de memorie).
 +
 +
Exemplu:
 +
<syntaxhighlight lang="C++">
 +
#include <iostream>
 +
 +
int main() {
 +
    int numar = 25;
 +
 +
    // rNumar va fi o referinta (alt nume) a variabilei numar
 +
    int& rNumar = numar;
 +
 +
    // observam ca au aceeasi valoare
 +
    std::cout << "Numar  initial: " << numar  << std::endl;
 +
    std::cout << "rNumar initial: " << rNumar << std::endl << std::endl;
 +
 +
    rNumar++;
 +
    numar++;
 +
 +
    std::cout << "Numar  final: " << numar  << std::endl;
 +
    std::cout << "rNumar final: " << rNumar << std::endl;
 +
 +
    return 0;
 +
}
 +
</syntaxhighlight>
 +
 +
Output:
 +
<syntaxhighlight>
 +
Numar  initial: 25
 +
rNumar initial: 25
 +
 +
Numar  final: 27
 +
rNumar final: 27
 +
</syntaxhighlight>
 +
 +
În exemplul anterior se observă că deși folosim două variabile diferite, valorile celor doua sunt întotdeauna identice, iar o modificare asupra uneia se reflectă și asupra celeilalte.
 +
 +
=== Asocierea referințelor ===
  
 
= Supraîncărcarea operatorilor =
 
= Supraîncărcarea operatorilor =

Versiunea de la data 29 martie 2022 18:20

Introducere

Această lucrare are ca scop familiarizarea cu următoarele noțiuni:

  • Destructorul
  • Referința
  • Supraîncărcarea operatorilor

Destructorul

Introducere

Așa cum s-a prezentat în laboratorul anterior, crearea unui obiect se face folosind o metodă specială, numită constructor. Printre altele, cu ajutorul constructorului putem:

  • Inițializa câmpurile obiectului pe care îl construim
  • Condiționa valorile cu care inițializăm câmpurile (de exemplu vârsta unei persoane nu poate avea valoare negativa)
  • Aloca memorie în mod dinamic

Pe de altă parte, odată ce nu mai avem nevoie de un obiect, acesta trebuie eliminat într-un mod controlat, astfel încât memoria ocupată să poată fi refolosită. Acest lucru este realizat cu ajutorul unei alte metode speciale, numită destructor, ce este apelată automat atunci când contextul în care a fost declarat obiectul se încheie (out of scope). Pentru mai multe informații legate de context (scope) în C++, accesați acest link.

Exemplu

În exemplul de mai jos sunt evidențiate mecanismele de ’construire’ si ’distrugere’ a obiectelor:

#include <iostream>

// clasa Array modeleaza un array alocat dinamic
class Array{
public:
    int *arr;

    // constructorul aloca memorie si stocheaza adresa primului element in *arr
    Array(int dimensiune){
        arr = (int*) malloc(dimensiune * sizeof(int));
        std::cout << "Acest mesaj provine din constructor" << std::endl;
    }

    // destructorul se asigura ca memoria alocata este eliberata atunci cand obiectul este distrus
    ~Array(){
        free(arr);
        std::cout << "Acest mesaj provine din destructor" << std::endl;
    }
};

int main() {
    Array array(4);
    std::cout << "Obiectul a fost construit!" << std::endl;

    return 0;
}

Output:

Acest mesaj provine din constructor
Obiectul a fost construit!
Acest mesaj provine din destructor

Observăm că, odată ce contextul în care a fost declarat obiectul (contextul este, aici, funcția main), destructorul acestui obiect a fost apelat automat si a fost generat mesajul corespunzător.

Referința

Introducere

O referință reprezintă un nume alternativ cu care poate fi accesat un obiect/o variabilă. Așa cum vom prezenta în continuare, mecanismul de referințe simplifică accesul la date intre diferite entități (de exemplu între funcții).

Sintaxa pentru declararea unei referințe este următoarea: <tip_de_date>& nume_referinta = variabila
Odată declarată, cu ajutorul referinței vom accesa aceeași informație pe care o accesăm cu variabila cu care aceasta a fost legată (cele două făcând referire la aceeași zonă de memorie).

Exemplu:

#include <iostream>

int main() {
    int numar = 25;

    // rNumar va fi o referinta (alt nume) a variabilei numar
    int& rNumar = numar;

    // observam ca au aceeasi valoare
    std::cout << "Numar  initial: " << numar  << std::endl;
    std::cout << "rNumar initial: " << rNumar << std::endl << std::endl;

    rNumar++;
    numar++;

    std::cout << "Numar  final: " << numar  << std::endl;
    std::cout << "rNumar final: " << rNumar << std::endl;

    return 0;
}

Output:

Numar  initial: 25
rNumar initial: 25

Numar  final: 27
rNumar final: 27

În exemplul anterior se observă că deși folosim două variabile diferite, valorile celor doua sunt întotdeauna identice, iar o modificare asupra uneia se reflectă și asupra celeilalte.

Asocierea referințelor

Supraîncărcarea operatorilor