WikiLabs - Contribuții utilizator [ro]

Programare Orientată pe Obiecte (C++)

2026-03-24T13:28:11Z

Costin.vasile1003:

== Scopul laboratorului ==

Scopul laboratorului de Programare Orientată Obiect este de a introduce studentului conceptele paradigmei de programare orientată pe obiecte, aprofundarea limbajului C++, precum și familiarizarea cu tehnicile de programare specifice.

<div class="regula"><font color="#ff0000">Atenție:</font> Toate lucrările acestui laborator pleacă de la premiza că sunteți deja familiarizați cu sintaxa limbajului C.</div>

<div class="regula"><font color="#ff0000">Atenție:</font> Toate fișierele/ programele scrise la fiecare laborator se pot salva, pe e-mail, pe un stick USB, pe un repository personal de Git sau pe Moodle.</div>

== Platforme de laborator ==

# [[C++ POO Lab Lucrarea 1]] - recapitulare: pointeri și structuri
# [[C++ POO Lab Lucrarea 2]] - paradigme de programare; clasa, obiectul, câmpul și metoda; supraîncărcarea; constructorul; încapsularea și modificatorii de acces
# [[C++ POO Lab Lucrarea 3]] - destructorul; referința; metode ''const-qualified''; supraîncărcarea operatorilor; constructorul de copiere și operatorul de copiere prin atribuire
# [[C++ POO Lab Lucrarea 4]] - moștenirea; polimorfismul - metode virtuale și pur virtuale; clase abstracte
# [[C++ POO Lab Lucrarea 5]] - tratarea excepțiilor


== Tutorial Instalare g++ (Compilatorul C++ de la GNU) ==

=== Instalare Windows ===

Pentru Windows, compilatorul g++ poate fi instalat prin [http://www.mingw.org MinGW]. Urmăriți instrucțiunile de instalare și nu uitați să bifați compilatorul de C++ și utilitarul <code>make</code>.

=== Instalare Linux ===

Pentru Ubuntu, deschideți un terminal și tastați următoarea comandă:
<syntaxhighlight lang="bash">
sudo apt-get install build-essential
</syntaxhighlight>

== Tutorial Instalare CLion IDE ==

Pentru toate sistemele de operare, urmăriți instrucțiunile prezentate pe [https://www.jetbrains.com/help/clion/installation-guide.html site-ul oficial].

== Tutorial Utilizare CLion IDE si Debugger ==

[[C++ POO Lab Utile]] - utilizarea IDE-ului CLion și a debugger-ului

C++ POO Lab Lucrarea 3

2026-03-24T13:23:40Z

Costin.vasile1003:

= Introducere =

Această lucrare are ca scop familiarizarea cu următoarele noțiuni:
* Destructorul
* Referința
* Metode ''const-qualified''
* Supraîncărcarea operatorilor
* Constructorul de copiere
* Operatorul de copiere prin atribuire

= 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 [https://en.cppreference.com/w/cpp/language/scope acest link].

Destructorul (pentru că nu poate exista decât unul singur în fiecare clasă), poate fi recunoscut după următoarele proprietăți:
# are numele format din caracterul <code>~</code> urmat de numele clasei;
# nu are argumente;
# nu are tip returnat (nici măcar '''void''').

== Exemplu ==

În exemplul de mai jos sunt evidențiate mecanismele de ’construire’ si ’distrugere’ a obiectelor:
<syntaxhighlight lang="C++">
#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;
}
</syntaxhighlight>

Output:
<syntaxhighlight lang="text">
Acest mesaj provine din constructor
Obiectul a fost construit!
Acest mesaj provine din destructor
</syntaxhighlight>

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). <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).

<div class="regula"><font color="#ff0000">Atenție:</font> O referință trebuie obligatoriu inițializată.</div>

== 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 lang="text">
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 ==

Asocierea între o referință și o variabilă este permanentă și nu putem asocia referința cu altă variabilă! Putem, în schimb, să asociem mai multe referințe cu aceeași variabilă.
Observați datele de ieșire ale următorului exemplu:

<syntaxhighlight lang="C++">
#include <iostream>

int main() {
#include <iostream>

int main() {
int numar_1 = 25;
int numar_2 = 30;

int& r1Numar = numar_1;
int& r2Numar = numar_1;

r1Numar = numar_2;
r1Numar++;

std::cout << "Valoarea lui r1Numar: " << r1Numar << std::endl;
std::cout << "Valoarea lui r2Numar: " << r2Numar << std::endl;
std::cout << "Valoarea lui numar_1: " << numar_1 << std::endl;
std::cout << "Valoarea lui numar_2: " << numar_2 << std::endl;

return 0;
}
</syntaxhighlight>

Ieșire:
<syntaxhighlight lang="text">
Valoarea lui r1Numar: 31
Valoarea lui r2Numar: 31
Valoarea lui numar_1: 31
Valoarea lui numar_2: 30
</syntaxhighlight>

Observăm că expresia <code>r1Numar = numar_2;</code> nu a asociat referința <code>r1Numar</code> cu variabila <code>numar_2</code>, ci a determinat copierea valorii <code>numar_2</code> în variabila cu care <code>rNumar</code> este asociată.
De asemenea, observăm că variabila <code>numar_1</code> este asociată cu două referințe.

O referință nu poate fi asociată cu o valoare. Următorul program va genera erori de compilare:
<syntaxhighlight lang="C++">
int main() {
int& rNumar = 20; // aceasta expresie nu este permisa
return 0;
}
</syntaxhighlight>

== Transmiterea argumentelor prin referință ==

Utilitatea referințelor este evidențiată atunci când avem nevoie sa accesăm o variabilă din contexte diferite (precum două metode diferite). Folosind referințe putem economisi memorie, folosind același spațiu de memorie accesat cu două nume de variabile diferite. <br>

Următorul exemplu '''nu folosește referințe''' pentru pasarea argumentelor ('''pass-by-value''').

În acest caz, de fiecare dată când funcția <code>concat</code> este apelată, în memorie este alocat spațiu pentru două variabile noi ce iau valorile argumentelor. Acest lucru nu este eficient atunci când avem nevoie să transmitem informații de dimensiuni mari.

<syntaxhighlight lang="C++">
#include <iostream>
#include <string>
/*
*
* Exemplu pass-by-value
*
**/

std::string concat(std::string a, std::string b){
return a + b;
}

int main() {
std::string a = "Ana are ";
std::string b = "mere.";
std::string result = concat(a, b);

std::cout << "Rezultat: " << result << std::endl;

return 0;
}
</syntaxhighlight>

Următorul exemplu '''folosește referințe''' pentru transmiterea argumentelor ('''pass-by-reference''').

În acest caz, de fiecare dată când funcția sum este apelată, argumentele funcției nu sunt copii ale variabilelor, ci referințe către variabilele transmise funcției.

<syntaxhighlight lang="C++">
#include <iostream>
#include <string>
/*
*
* Exemplu pass-by-reference
*
**/

std::string concat(std::string & a, std::string & b){
return a + b;
}

int main() {
std::string a = "Ana are ";
std::string b = "mere.";
std::string result = concat(a, b);

std::cout << "Rezultat: " << result << std::endl;

return 0;
}
</syntaxhighlight>

<div class="regula"><font color="#ff0000">Atenție:</font> Deși transmiterea argumentelor prin referință eficientizează dimensiunea memoriei ocupate la ''runtime'', argumentele funcțiilor vor trebui manipulate cu grijă; o modificare a acestora în corpul funcției se va reflecta și asupra variabilei transmise ca argument!</div>

<div class="sfat"><font color="darkgreen">Sfat:</font> Deoarece mecanismul folosit pentru referințe este de fapt tot bazat pe adrese de memorie (pointeri), evitarea copierii valorii are sens doar pentru valori mai mari decât dimensiunea unui pointer. Astfel, pentru valori primitive (int, float, long, double, uint64_t, char, etc.) nu este necesară transmiterea lor ca referință pentru evitarea copierii, ci doar dacă doriți modificarea variabilelor în funcție.</div>

== Referințe constante (const) ==

Pentru a evita problema menționată mai sus (modificarea accidentală a unei variabile transmise unei funcții ca referință), se introduce conceptul de referință constantă. Acest tip de referință poate fi folosită doar pentru citirea informațiilor dintr-un obiect sau accesarea valorii unei variabile, nu și pentru modificarea acestora. Declararea unei referințe constante se face folosind cuvântul cheie <code>const</code>.

Iată un exemplu:
<syntaxhighlight lang="C++">
#include <iostream>
#include <string>
/*
*
* Exemplu pass-by-reference
*
**/

std::string concat(const std::string & s1, const std::string & s2){
return s1 + s2;
}

int main() {
std::string a = "Ana are ";
std::string b = "mere.";
std::string result = concat(a, b);

std::cout << "Rezultat: " << result << std::endl;

return 0;
}
</syntaxhighlight>

Folosind referințele '''s1''' și '''s2''' se pot citi datele din variabilele '''a''' și '''b''' din <code>main</code>, dar fără a risca modificarea lor. Dacă se încearcă modificarea uneia din ele (de exemplu <code>s2 = "pere";</code>), se va genera o eroare de compilare.

<div class="regula"><font color="#ff0000">Atenție: </font>Spre deosebire de o referință non-const, o referință constantă se poate asocia și cu o valoare constantă: </div>
<syntaxhighlight lang="C++">
#include <iostream>
#include <string>
/*
*
* Exemplu pass-by-const-reference
*
**/

std::string concat(const std::string & s1, const std::string & s2){
return s1 + s2;
}

int main() {
std::string result = concat("Ana are ", "mere.");

std::cout << "Rezultat: " << result << std::endl;

return 0;
}
</syntaxhighlight>

= Metode ''const-qualified'' =

În cazul în care un obiect este declarat <code>const</code>, sau se accesează printr-o referință constantă, acest obiect nu poate fi modificat. Modificarea unui obiect înseamnă modificarea valorilor câmpurilor sale. Astfel, pe lângă faptul că nu putem atribui valori noi câmpurilor în cazul în care avem acces la ele, nu putem nici apela metode care au ca efect modificarea obiectului. Iată un exemplu mai jos:

<syntaxhighlight lang="C++">
class Animal {
public:
std::string mName;
std::string mColor;
int mAge;
bool mHasFeathers;

public:
void makeSound() {
printf("Animal %s makes a sound!\n", mName.c_str());
}

// this is a getter method
std::string getName() {
return mName;
}

// this is a setter method
void setAge(int age) {
if(age > 0) {
mAge = age;
}
}
};

int main() {
const Animal animal;
animal.mName = "Cat"; // eroare de compilare - nu se poate modifica acest camp
animal.makeSound(); // eroare de compilare - nu se poate apela aceasta metoda
return 0;
}
</syntaxhighlight>

În exemplul de mai sus, este evident că nu putem modifica membrul <code>mName</code> al obiectului <code>animal</code> pentru că acesta este declarat <code>const</code>. Cu toate acestea, metoda <code>makeSound</code> nu modifică obiectul (nu modifică niciunul din câmpurile sale la apelare), dar nici aceasta nu poate fi apelată. Motivul este dat de faptul că programatorul trebuie să specifice explicit către compilator care sunt metodele care nu modifică obiectul, compilatorul nu face aceste verificări automat. O metodă care nu modifică obiectul pentru care se apelează se declară <code>const</code> și se numește ''const-qualified'':

<syntaxhighlight lang="C++">
class Animal {
public:
std::string mName;
std::string mColor;
int mAge;
bool mHasFeathers;

public:
void makeSound() const {
printf("Animal %s makes a sound!\n", mName.c_str());
}

// this is a getter method
std::string getName() const {
return mName;
}

// this is a setter method
void setAge(int age) {
if(age > 0) {
mAge = age;
}
}
};

int main() {
const Animal animal;
animal.mName = "Cat"; // eroare de compilare - nu se poate modifica acest camp
animal.makeSound(); // aici nu se mai produce nicio eroare de compilare, metoda makeSound este const-qualified
return 0;
}
</syntaxhighlight>

Deci, pentru obiecte constante sau folosind referințe constante, se pot apela doar metode const-qualified.

= Supraîncărcarea operatorilor =

Dacă dorim să tratăm instanțele claselor (i.e. obiectele) așa cum tratăm tipurile de date fundamentale, trebuie să putem folosi aceiași operatori pe care îi folosim si cu tipurile fundamentale.

Cunoaștem, de exemplu, faptul că putem aduna două valori de tip întreg folosind operatorul '+'. În mod similar, am dori să putem calcula și suma a două numere complexe definite de clasa <code>Complex</code> din următorul exemplu:
<syntaxhighlight lang="C++">
class Complex{
double mReal; // partea reala
double mImaginar; // partea imaginara

public:

/*
* Constructorul ce initializeaza campurile obiectului
*
* */
Complex(double real, double imaginar){
mReal = real;
mImaginar = imaginar;
}

/*
* Constructorul fara argumente
*
* */
Complex() = default;

/*
* Metoda: get_suma
*
* Intoarce suma (sub forma de obiect de tip Complex) dintre obiectul curent si obiectul primit ca argument
*
* */
Complex get_sum(Complex alt_numar){
double real_rezultat = mReal + alt_numar.mReal;
double imaginar_rezultat = mImaginar + alt_numar.mImaginar;

Complex rezultat(real_rezultat, imaginar_rezultat);

return rezultat;
}

/*
* Metoda: afisare
*
* Afiseaza numarul complex in formatul a+bi
*
* */
void afisare(){
std::cout << mReal << '+' << mImaginar << 'i' << std::endl;
}
};
</syntaxhighlight>

Folosind cunoștințele acumulate până acum, putem realiza suma a doua obiecte de tip <code>Complex</code> implementând metoda <code>get_suma</code> din exemplul de mai sus. Totuși, aceasta nu ne permite să adunăm două obiecte de tip <code>Complex</code> folosind operatorul '+', așa cum dorim.

Fie clasa <code>Complex</code> definită anterior. Acesta este un exemplu de utilizare a funcției <code>get_sum</code>:
<syntaxhighlight lang="C++">
int main() {
Complex complex_1 (5, 10);
Complex complex_2 (-1, 3);

Complex suma = complex_1.get_sum(complex_2);

suma.afisare();

return 0;
}
</syntaxhighlight>

Ieșire:
<syntaxhighlight lang="text">
4+13i
</syntaxhighlight>

Supraîncărcarea operatorilor presupune implementarea uneia sau mai multor funcții speciale (numite funcții operator) ce descriu comportamentul operatorilor doriți.

Numele unei astfel de funcții începe cu cuvântul cheie <code>operator</code> și este urmat de simbolul operatorului supraîncărcat. De asemenea, la fel ca funcțiile obișnuite, operatorii vor avea tip de date returnat și (opțional) argumente.

Sintaxa pentru declararea unei funcții operator:

<code>
''tip_returnat'' '''operator''' ''simbol'' (<''lista argumentelor''>)
</code>

=== Reguli generale ===
Supraîncărcarea operatorilor trebuie să respecte următoarele reguli:
# Prioritatea operatorilor nu poate fi schimbată (ex. '*' are prioritate față de '+')
# Asociativitatea și comutativitatea operatorilor nu pot fi schimbate
# Numărul de operanzi ai unui operator nu poate fi schimbat (ex. operatorul '+' este binar, în timp ce '!' este unar)
# Nu pot fi supraîncărcați operatori noi, doar cei definiți în standardul C++. Consultați [https://en.cppreference.com/w/cpp/language/operators acest link] pentru lista operatorilor.

=== Exemplu ===
Metoda <code>get_sum</code> din exemplul anterior este înlocuită în exemplul următor de operatorul '+'.

<syntaxhighlight lang="C++">
#include <iostream>

class Complex{
double mReal; // partea reala
double mImaginar; // partea imaginara

public:
/*
* Constructorul ce initializeaza campurile obiectului
*
* */
Complex(double real, double imaginar){
mReal = real;
mImaginar = imaginar;
}

/*
* Constructorul fara argumente
*
* */
Complex() = default;

/*
* Metoda: operator +
*
* Intoarce suma (sub forma de obiect de tip Complex) dintre obiectul curent si obiectul primit ca argument
*
* */
Complex operator +(Complex alt_numar){
double real_rezultat = mReal + alt_numar.mReal;
double imaginar_rezultat = mImaginar + alt_numar.mImaginar;

Complex rezultat(real_rezultat, imaginar_rezultat);

return rezultat;
}

/*
* Metoda: afisare
*
* Afiseaza numarul complex in formatul a+bi
*
* */
void afisare(){
std::cout << mReal << '+' << mImaginar << 'i' << std::endl;
}
};

int main() {
Complex complex_1 (5, 10);
Complex complex_2 (-1, 3);

Complex suma = complex_1 + complex_2;

suma.afisare();

return 0;
}
</syntaxhighlight>

= Constructorul de copiere =

== Introducere ==
Obiectele se copiază în două situații:
# Atunci când se inițializează un obiect (i se atribuie o valoare la declarație);
# Atunci când se transmite un obiect către o funcție cu argumente de tip ''pass-by-value'', deci nu ca referință.
# Atunci când se atribuie un obiect unui alt obiect (evident de același fel), în altă parte decât la inițializare.

În primele două situații, această copiere se realizează de un constructor special, numit '''constructor de copiere'''. Acest constructor există implicit în toate clasele fiind adăugat de compilator. Copierea implicită pe care o face acesta este prin a duplica tot conținutul obiectului sursă, așa cum este acesta salvat în memorie. În multe situații, acest comportament este cel corect. Totuși, există și situații când acest comportament implicit trebuie modificat. Prin urmare trebuie definit explicit acest constructor de copiere în cadrul clasei.

Forma unui constructor de copiere pentru o clasă oarecare <code>T</code> este:
<syntaxhighlight lang="C++">
T(const T & source);
</syntaxhighlight>

Prin urmare, constructorul de copiere ca lua ca argument o referință constantă la un alt obiect de același fel, care reprezintă sursa copierii de date.

<div class="regula"><font color="#ff0000">Atenție:</font> Argumentul constructorului de copiere trebuie obligatoriu să fie de tip referință, pentru că în caz contrar, acesta trebuie copiat la apelul constructorului, copiere care se realizează folosind chiar constructorul de copiere, și deci rezultă un apel recursiv infinit. În acest caz veți primi o eroare de compilare.</div>

== Exemplu ==

Reluând exemplul de la capitolul [[#Destructorul]], vom adăuga acum constructorul de copiere, pentru a evita crearea mai multor obiecte care să aibă pointer intern la aceeași zonă de memorie:
<syntaxhighlight lang="C++">
#include <cstdint>
#include <cstring>
#include <iostream>

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

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

Array(const Array & source) {
arr = (int*) malloc(source.dim * sizeof(int));
dim = source.dim;
memcpy(arr, source.arr, dim * sizeof(int));
std::cout << "Acest mesaj provine din constructorul de copiere" << 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;
}
};

void test(Array array) {
std::cout << "Mesaj din functie!" << std::endl;
}

int main() {
Array array(4);
std::cout << "Obiectul a fost construit!" << std::endl;
Array copy = array;
std::cout << "Obiectul a fost copiat!" << std::endl;
test(array);
std::cout << "Functia a fost apelata." << std::endl;
return 0;
}
</syntaxhighlight>

Ieșire:
<syntaxhighlight lang="text">
Acest mesaj provine din constructor
Obiectul a fost construit!
Acest mesaj provine din constructorul de copiere
Obiectul a fost copiat!
Acest mesaj provine din constructorul de copiere
Mesaj din functie!
Acest mesaj provine din destructor
Functia a fost apelata.
Acest mesaj provine din destructor
Acest mesaj provine din destructor
</syntaxhighlight>

= Operatorul de copiere prin atribuire =
== Introducere ==
În situația numărul 3 de mai sus (atunci când se atribuie un obiect unui alt obiect, în altă parte decât la inițializare), această copiere se realizează de un operator special, numit operatorul de copiere prin atribuie (copy-assignment operator). Acesta, similar cu constructorul de copiere, există în mod implicit, și copiază conținutul obiectului la nivel de byte. Și exact în același fel, câteodată este necesar să putem modifica acest comportament.

Forma unui operator de copiere prin atribuire pentru o clasă oarecare <code>T</code> este:
<syntaxhighlight lang="C++">
T& operator=(const T & source) {
//aici se realizeaza copierea
return *this;
}
</syntaxhighlight>

Prin urmare, operatorul de copiere prin atribuire va lua ca argument o referință constantă la un alt obiect de același fel, care reprezintă sursa copierii de date. Acesta poate fi de tip <code>void</code>, dar ca să se respecte specificația care spune că rezultatul operatorului de atribuire este valoarea atribuită, este recomandat ca întotdeauna această să întoarcă o referință la obiectul curent. Astfel, se pot realiza lanțuri de atribuiri.

== Exemplu ==

Continuând exemplul de mai sus, vom adăuga acum operatorul de copiere prin atribuire:
<syntaxhighlight lang="C++">
#include <cstdint>
#include <cstring>
#include <iostream>

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

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

Array(const Array & source) {
arr = (int*) malloc(source.dim * sizeof(int));
dim = source.dim;
memcpy(arr, source.arr, dim * sizeof(int));
std::cout << "Acest mesaj provine din constructorul de copiere" << std::endl;
}

Array & operator=(const Array & source) {
free(arr); // obiectul curent aici exista deja, deci trebuie sa stergem memoria alocata in constructor inainte de a aloca altceva
arr = (int*) malloc(source.dim * sizeof(int));
dim = source.dim;
memcpy(arr, source.arr, dim * sizeof(int));
std::cout << "Acest mesaj provine din operatorul de copiere prin atribuire" << std::endl;
return *this;
}

// 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);
Array other(5);
other = array;
return 0;
}
</syntaxhighlight>

Ieșire:
<syntaxhighlight lang="text">
Acest mesaj provine din constructor
Acest mesaj provine din constructor
Acest mesaj provine din operatorul de copiere prin atribuire
Acest mesaj provine din destructor
Acest mesaj provine din destructor
</syntaxhighlight>

<div class="regula"><font color="#ff0000">The Rule of Three:</font> O regulă cunoscută în limbajul C++ este următoarea: dacă aveți de nevoie să implementați explicit constructorul de copiere SAU operatorul de copiere prin atribuire SAU destructorul, atunci trebuie să le implementați pe toate trei!.</div>

= Operatorii <code>new</code> și <code>delete</code>=
În programele scrise până acum, majoritatea variabilelor și obiectelor au fost declarate în mod direct, de exemplu:

<syntaxhighlight lang="c++">
int x;
Persoana p;
</syntaxhighlight>

În aceste cazuri, memoria necesară este rezervată automat la intrarea în blocul în care au fost declarate, iar eliberarea ei are loc tot automat la ieșirea din acel bloc. Acest mod de lucru este simplu și sigur, dar nu este întotdeauna suficient.

Există numeroase situații în care un program nu poate ști dinainte de câtă memorie are nevoie. De exemplu:
* numărul de elemente dintr-un vector este citit de la tastatură;
* un obiect trebuie să existe și după terminarea funcției în care a fost creat;
* o clasă trebuie să gestioneze intern resurse a căror dimensiune este variabilă;
* programul trebuie să creeze obiecte dinamic, doar atunci când este nevoie de ele

În astfel de situații apare nevoia de alocare dinamică a memoriei, adică rezervarea memoriei în timpul execuției programului. În C++, acest lucru se realizează cu ajutorul operatorilor <code>new</code> și <code>delete</code>.

== Operatorul <code>new</code> ==
Operatorul <code>new</code> este folosit pentru a rezerva memorie dinamică și, în cazul obiectelor, pentru a construi obiectul în acea zonă de memorie (prin apelarea constructorului).

Forma generală pentru <code>new</code> este următoarea:
<syntaxhighlight lang="c++">
<tip_de_date> <nume_pointer> = new <tip_de_date>;
</syntaxhighlight>
Această linie:
* rezervă memorie pentru o variabilă de tipul specificat;
* returnează adresa acelei zone de memorie;
* memorează adresa într-un pointer de tip corespunzător

Dacă se dorește și inițializare:
<syntaxhighlight lang="c++">
<tip_de_date> <nume_pointer> = new <tip_de_date>(<valoare_initiala>);
</syntaxhighlight>
În plus față de varianta anterioară, această linie inițializează cu <valoare_initiala> valoarea stocată în memoria alocată.

== Operatorul <code>delete</code> ==
Operatorul <code>delete</code> este folosit pentru a distruge obiectul creat dinamic (prin apelarea destructorului) și pentru a elibera memoria ocupată de acesta.

Forma generală pentru <code>delete</code> este următoarea:
<syntaxhighlight lang="c++">
delete <nume_pointer>;
<nume_pointer> = nullptr;
</syntaxhighlight>

= Alocarea dinamică pentru tipuri simple =
În această secțiune vor fi prezentate câteva exemple comune de utilizare a operatorilor <code>new</code> și <code>delete</code> cu tipuri de date simple.

== Exemplul 1: alocare dinamică pentru un element de tip <code>int</code> ==
<syntaxhighlight lang="c++">
// declară un pointer p către int si alocă dinamic memorie pentru un număr întreg
int* p = new int;
// stocheaza valoarea 10 la adresa stocata in pointerul p
*p = 10;

// afișează valoarea stocată la adresa din pointerul p
cout << *p << endl;

// memoria alocată anterior este eliberată
delete p;
</syntaxhighlight>

== Exemplul 2: alocare cu inițializare ==
<syntaxhighlight lang="c++">
// declară un pointer p către int si alocă dinamic memorie pentru un număr întreg
// și inițializează valoarea de la acea adresă cu 25
int* p = new int(25);

cout << *p << endl;

delete p;
</syntaxhighlight>

== Exemplul 3: alocare cu alte tipuri simple ==
<syntaxhighlight lang="c++">
double* x = new double(3.14);
char* c = new char('A');

cout << *x << endl;
cout << *c << endl;

delete x;
delete c;
</syntaxhighlight>

= Alocarea dinamică a vectorilor de date simple =
Sintaxa generală este următoarea:
<syntaxhighlight lang="c++">
// new
<tip_de_date>* <nume_pointer> = new <tip_de_date>[<numar_elemente>];

// delete
delete[] <nume_pointer>;
</syntaxhighlight>

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> pentru memoria alocată dinamic sub forma unui vector, folosind <code>new[]</code>, eliberarea trebuie făcută întotdeauna cu <code>delete[]</code> și nu cu <code>delete</code>. Folosirea lui <code>delete</code> simplu în acest caz este greșită și conduce la comportament nedefinit, deoarece programul nu mai tratează corect memoria rezervată pentru toate elementele vectorului.</div>

== Exemplul 1: alocarea dinamică a unui vector ==
<syntaxhighlight lang="c++">
int n = 5;
int* v = new int[n]; // aloca memorie pentru un vector de int cu 5 elemente
</syntaxhighlight>

== Exemplul 2: suma numerelor dintr-un vector ==
<syntaxhighlight lang="c++">
// se declara n si se citeste de la tastatura dimensiunea vectorului
int n;
cin >> n;

// se aloca dinamic vectorul de n elemente
int* v = new int[n];

// se citesc de la tastatura elementele vectorului
for (int i = 0; i < n; i++)
cin >> v[i];

// se calculeaza suma tuturor elementelor din vector
int suma = 0;
for (int i = 0; i < n; i++)
suma += v[i];

// afisarea sumei
cout << "Suma = " << suma << endl;

// se elibereaza memoria alocata anterior
delete[] v;
v = nullptr;
</syntaxhighlight>

= Alocarea dinamică a obiectelor =
La fel ca la tipurile de date simple, sintaxa generală este următoarea:
<syntaxhighlight lang="c++">
<numa_clasa>* <nume_pointer> = new <nume_clasa>;
</syntaxhighlight>
Această linie va aloca memorie pentru noul obiect și va apela constructorul fără argumente.

Dacă dorim să apelăm constructorul cu parametri, vom folosi următoarea sintaxa:
<syntaxhighlight lang="c++">
<numa_clasa>* <nume_pointer> = new <nume_clasa>(<argumente_constructor>);
</syntaxhighlight>

Pentru distrugerea obiectului se foloseste in continuare:
<syntaxhighlight lang="c++">
delete <nume_pointer>;
</syntaxhighlight>

== Exemplul 1: obiect creat dinamic folosind constructorul implicit ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct() {
x = 0;
y = 0;
cout << "Constructor implicit\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// alocă memorie pentru un obiect de tip Punct și apelează constructorul implicit al clasei
Punct* p = new Punct;
// deoarece avem un pointer la obiect, metodele si campurile sale sunt accesate cu ->
p->afiseaza();
// apelează destructorul obiectului și apoi eliberează memoria ocupată de el
delete p;

return 0;
}
</syntaxhighlight>

== Exemplul 2: obiect creat dinamic folosind un constructor cu parametri ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct(int a, int b) {
x = a;
y = b;
cout << "Constructor cu parametri\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// aloca memorie si apeleaza constructorul cu parametri
Punct* p = new Punct(3, 4);
// deoarece avem un pointer la obiect, metodele si campurile sale sunt accesate cu ->
p->afiseaza();
// apelează destructorul obiectului și apoi eliberează memoria ocupată de el
delete p;
return 0;
}
</syntaxhighlight>

== Exemplul 3: alocarea dinamică și constructorul de copiere ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct(int a, int b) {
x = a;
y = b;
cout << "Constructor cu parametri\n";
}

Punct(const Punct& other) {
x = other.x;
y = other.y;
cout << "Constructor de copiere\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// obiectul p1 este creat obisnuit, apeland constructorul cu argumentr
Punct p1(1, 2);
// creează dinamic un nou obiect folosind constructorul de copiere
Punct* p2 = new Punct(p1);

p2->afiseaza();

delete p2;
return 0;
}
</syntaxhighlight>

== Diferența dintre <code>new</code> și <code>malloc</code> ==
În limbajul C, alocarea dinamică a memoriei se face în mod obișnuit cu funcția malloc. În C++, aceasta există în continuare pentru compatibilitate, dar pentru obiecte și clase nu este soluția potrivită.

Dacă alocăm un obiect cu <code>new</code>:
<syntaxhighlight lang="c++">
Test* p = new Test;
</syntaxhighlight>
se întâmplă două lucruri:
* se rezervă memorie pentru obiect;
* se apelează constructorul obiectului

Dacă încercăm să alocăm memorie pentru același tip folosind malloc:
<syntaxhighlight lang="c++">
Test* p = (Test*)malloc(sizeof(Test));
</syntaxhighlight>
se rezervă doar memorie brută. Constructorul nu este apelat. Cu alte cuvinte, <code>malloc</code> știe doar să rezerve un număr de octeți, dar nu știe nimic despre noțiunea de obiect, constructor sau clasă.

Aceasta este diferența fundamentală:
* <code>malloc</code> alocă memorie;
* <code>new</code> alocă memorie și construiește obiectul.

= Alocarea dinamică a vectorilor de obiecte =
În cazul unui vector de obiecte, operatorul new[] rezervă memorie pentru toate elementele vectorului și apelează constructorul corespunzător pentru fiecare obiect, iar operatorul delete[] apelează destructorul fiecărui obiect și apoi eliberează memoria ocupată de întregul vector.

La fel ca la vectorii de date simple, sintaxa generală este următoarea:
<syntaxhighlight lang="c++">
<nume_clasa>* <nume_vector> = new <nume_clasa>[<dimensiune>];
</syntaxhighlight>

== Exemplul 1: vector dinamic de obiecte folosind constructorul implicit ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct() {
x = 0;
y = 0;
cout << "Constructor implicit\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// creează un vector dinamic cu 3 obiecte de tip Punct
// Pentru fiecare element din vector este apelat constructorul implicit
Punct* v = new Punct[3];

for (int i = 0; i < 3; i++)
v[i].afiseaza(); // Accesul la elementele vectorului se face ca la un vector obișnuit:

// apelează destructorul pentru fiecare dintre cele 3 obiecte și apoi eliberează memoria vectorului
delete[] v;
return 0;
}
</syntaxhighlight>

== Exemplul 2: modificarea elementelor din vector ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct() {
x = 0;
y = 0;
}

~Punct() {
cout << "Destructor pentru punctul (" << x << ", " << y << ")\n";
}

void set(int a, int b) {
x = a;
y = b;
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
int n = 4;
Punct* v = new Punct[n];

for (int i = 0; i < n; i++)
v[i].set(i, i * 10);

for (int i = 0; i < n; i++)
v[i].afiseaza();

delete[] v;
return 0;
}
</syntaxhighlight>

= Obiecte care conțin memorie alocată dinamic =
Un astfel de obiect nu mai conține doar date simple, ci și un pointer către o zonă de memorie alocată dinamic. În acest caz, clasa trebuie să gestioneze corect această resursă: să o aloce atunci când obiectul este creat, să o elibereze atunci când obiectul este distrus și să o copieze corect atunci când obiectul este copiat sau atribuit altuia.

== Exemplul 1: un obiect care deține memorie dinamică ==
<syntaxhighlight lang="c++">
#include <iostream>
#include <cstring>
using namespace std;

class Text {
// clasa Text conține un pointer la char
char* s;
public:
Text(const char* p) {
// constructorul aloca memorie suficienta pentru pointerul s
s = new char[strlen(p) + 1];
// apoi se face copierea element cu element (in cazul acesta folosind strcpy)
// atribuirea directa s = p ar fi fost gresita; in acest caz s-ar copia pointerul, nu valorile catre care trimite acesta
strcpy(s, p);
}

~Text() {
// la distrugerea obiectului, memoria alocata in constructor trebuie eliberată
delete[] s;
}

void afiseaza() {
cout << s << endl;
}
};

int main() {
Text t("Laborator C++");
t.afiseaza();
return 0;
}
</syntaxhighlight>

== Exemplul 2: La distrugerea obiectului, memoria trebuie eliberată ==
<syntaxhighlight lang="c++">
#include <iostream>
#include <cstring>
using namespace std;

class Text {
char* s;
public:
Text(const char* p) {
s = new char[strlen(p) + 1];
strcpy(s, p);
}

~Text() {
delete[] s;
}

void afiseaza() {
cout << s << endl;
}
};

int main() {
Text t1("C++");
// copiere superficiala (shallow copy)
Text t2 = t1;

t1.afiseaza();
t2.afiseaza();

return 0;
}
</syntaxhighlight>
La prima vedere, codul pare corect. Totuși, el ascunde o problemă gravă.
Pentru că noi nu am definit un constructor de copiere, compilatorul generează automat unul implicit. Acesta copiază fiecare membru „ca atare”. În consecință, pointerul s din t2 va primi exact aceeași adresă ca pointerul s din t1.

Cu alte cuvinte, după copiere:
* t1.s și t2.s indică spre aceeași zonă de memorie;
* nu există două copii ale textului, ci doar două pointere către același text.

Aceasta se numește copiere superficială (shallow copy).

Dacă două obiecte indică spre aceeași zonă de memorie, atunci la distrugerea lor fiecare destructor va încerca să elibereze aceeași zonă:
* destructorul lui t2 face delete[] s;
* destructorul lui t1 face din nou delete[] s.

Rezultatul este o dublă eliberare a memoriei, ceea ce produce comportament nedefinit.

Prin urmare, pentru clasele care conțin pointeri spre memorie alocată dinamic, copierea superficială este greșită.

== Exemplul 3: copiere profundă ==
Pentru a evita problema copierii superficiale, fiecare obiect trebuie să aibă propria sa copie a datelor. Cu alte cuvinte, la copiere nu trebuie copiată doar adresa, ci trebuie alocată o nouă zonă de memorie și copiat conținutul în ea.

Aceasta se numește copiere profundă (deep copy).

<syntaxhighlight lang="c++">
#include <iostream>
#include <cstring>
using namespace std;

class Text {
char* s;
public:
Text(const char* p) {
s = new char[strlen(p) + 1];
strcpy(s, p);
}

// constructor de copiere
Text(const Text& other) {
s = new char[strlen(other.s) + 1];
strcpy(s, other.s);
}

// operatorul de atribuire
Text& operator=(const Text& other) {
// verifica daca nu se incearca autoatribuire
if (this != &other) {
// elibereaza memoria veche
delete[] s;
// aloca memorie noua si copiaza datele
s = new char[strlen(other.s) + 1];
strcpy(s, other.s);
}
return *this;
}

~Text() {
delete[] s;
}

void afiseaza() {
cout << s << endl;
}
};

int main() {
Text t1("Laborator");
Text t2("Initial");

t2 = t1;

t1.afiseaza();
t2.afiseaza();

return 0;
}
</syntaxhighlight>

C++ POO Operatorii new si delete

2026-03-24T13:18:27Z

Costin.vasile1003:

[WIP Costin] Pagina este in lucru!

= Introducere =
În programele scrise până acum, majoritatea variabilelor și obiectelor au fost declarate în mod direct, de exemplu:

<syntaxhighlight lang="c++">
int x;
Persoana p;
</syntaxhighlight>

În aceste cazuri, memoria necesară este rezervată automat la intrarea în blocul în care au fost declarate, iar eliberarea ei are loc tot automat la ieșirea din acel bloc. Acest mod de lucru este simplu și sigur, dar nu este întotdeauna suficient.

Există numeroase situații în care un program nu poate ști dinainte de câtă memorie are nevoie. De exemplu:
* numărul de elemente dintr-un vector este citit de la tastatură;
* un obiect trebuie să existe și după terminarea funcției în care a fost creat;
* o clasă trebuie să gestioneze intern resurse a căror dimensiune este variabilă;
* programul trebuie să creeze obiecte dinamic, doar atunci când este nevoie de ele

În astfel de situații apare nevoia de alocare dinamică a memoriei, adică rezervarea memoriei în timpul execuției programului. În C++, acest lucru se realizează cu ajutorul operatorilor <code>new</code> și <code>delete</code>.

== Operatorul <code>new</code> ==
Operatorul <code>new</code> este folosit pentru a rezerva memorie dinamică și, în cazul obiectelor, pentru a construi obiectul în acea zonă de memorie (prin apelarea constructorului).

Forma generală pentru <code>new</code> este următoarea:
<syntaxhighlight lang="c++">
<tip_de_date> <nume_pointer> = new <tip_de_date>;
</syntaxhighlight>
Această linie:
* rezervă memorie pentru o variabilă de tipul specificat;
* returnează adresa acelei zone de memorie;
* memorează adresa într-un pointer de tip corespunzător

Dacă se dorește și inițializare:
<syntaxhighlight lang="c++">
<tip_de_date> <nume_pointer> = new <tip_de_date>(<valoare_initiala>);
</syntaxhighlight>
În plus față de varianta anterioară, această linie inițializează cu <valoare_initiala> valoarea stocată în memoria alocată.

== Operatorul <code>delete</code> ==
Operatorul <code>delete</code> este folosit pentru a distruge obiectul creat dinamic (prin apelarea destructorului) și pentru a elibera memoria ocupată de acesta.

Forma generală pentru <code>delete</code> este următoarea:
<syntaxhighlight lang="c++">
delete <nume_pointer>;
<nume_pointer> = nullptr;
</syntaxhighlight>

= Alocarea dinamică pentru tipuri simple =
În această secțiune vor fi prezentate câteva exemple comune de utilizare a operatorilor <code>new</code> și <code>delete</code> cu tipuri de date simple.

== Exemplul 1: alocare dinamică pentru un element de tip <code>int</code> ==
<syntaxhighlight lang="c++">
// declară un pointer p către int si alocă dinamic memorie pentru un număr întreg
int* p = new int;
// stocheaza valoarea 10 la adresa stocata in pointerul p
*p = 10;

// afișează valoarea stocată la adresa din pointerul p
cout << *p << endl;

// memoria alocată anterior este eliberată
delete p;
</syntaxhighlight>

== Exemplul 2: alocare cu inițializare ==
<syntaxhighlight lang="c++">
// declară un pointer p către int si alocă dinamic memorie pentru un număr întreg
// și inițializează valoarea de la acea adresă cu 25
int* p = new int(25);

cout << *p << endl;

delete p;
</syntaxhighlight>

== Exemplul 3: alocare cu alte tipuri simple ==
<syntaxhighlight lang="c++">
double* x = new double(3.14);
char* c = new char('A');

cout << *x << endl;
cout << *c << endl;

delete x;
delete c;
</syntaxhighlight>

= Alocarea dinamică a vectorilor de date simple =
Sintaxa generală este următoarea:
<syntaxhighlight lang="c++">
// new
<tip_de_date>* <nume_pointer> = new <tip_de_date>[<numar_elemente>];

// delete
delete[] <nume_pointer>;
</syntaxhighlight>

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> pentru memoria alocată dinamic sub forma unui vector, folosind <code>new[]</code>, eliberarea trebuie făcută întotdeauna cu <code>delete[]</code> și nu cu <code>delete</code>. Folosirea lui <code>delete</code> simplu în acest caz este greșită și conduce la comportament nedefinit, deoarece programul nu mai tratează corect memoria rezervată pentru toate elementele vectorului.</div>

== Exemplul 1: alocarea dinamică a unui vector ==
<syntaxhighlight lang="c++">
int n = 5;
int* v = new int[n]; // aloca memorie pentru un vector de int cu 5 elemente
</syntaxhighlight>

== Exemplul 2: suma numerelor dintr-un vector ==
<syntaxhighlight lang="c++">
// se declara n si se citeste de la tastatura dimensiunea vectorului
int n;
cin >> n;

// se aloca dinamic vectorul de n elemente
int* v = new int[n];

// se citesc de la tastatura elementele vectorului
for (int i = 0; i < n; i++)
cin >> v[i];

// se calculeaza suma tuturor elementelor din vector
int suma = 0;
for (int i = 0; i < n; i++)
suma += v[i];

// afisarea sumei
cout << "Suma = " << suma << endl;

// se elibereaza memoria alocata anterior
delete[] v;
v = nullptr;
</syntaxhighlight>

= Alocarea dinamică a obiectelor =
La fel ca la tipurile de date simple, sintaxa generală este următoarea:
<syntaxhighlight lang="c++">
<numa_clasa>* <nume_pointer> = new <nume_clasa>;
</syntaxhighlight>
Această linie va aloca memorie pentru noul obiect și va apela constructorul fără argumente.

Dacă dorim să apelăm constructorul cu parametri, vom folosi următoarea sintaxa:
<syntaxhighlight lang="c++">
<numa_clasa>* <nume_pointer> = new <nume_clasa>(<argumente_constructor>);
</syntaxhighlight>

Pentru distrugerea obiectului se foloseste in continuare:
<syntaxhighlight lang="c++">
delete <nume_pointer>;
</syntaxhighlight>

== Exemplul 1: obiect creat dinamic folosind constructorul implicit ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct() {
x = 0;
y = 0;
cout << "Constructor implicit\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// alocă memorie pentru un obiect de tip Punct și apelează constructorul implicit al clasei
Punct* p = new Punct;
// deoarece avem un pointer la obiect, metodele si campurile sale sunt accesate cu ->
p->afiseaza();
// apelează destructorul obiectului și apoi eliberează memoria ocupată de el
delete p;

return 0;
}
</syntaxhighlight>

== Exemplul 2: obiect creat dinamic folosind un constructor cu parametri ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct(int a, int b) {
x = a;
y = b;
cout << "Constructor cu parametri\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// aloca memorie si apeleaza constructorul cu parametri
Punct* p = new Punct(3, 4);
// deoarece avem un pointer la obiect, metodele si campurile sale sunt accesate cu ->
p->afiseaza();
// apelează destructorul obiectului și apoi eliberează memoria ocupată de el
delete p;
return 0;
}
</syntaxhighlight>

== Exemplul 3: alocarea dinamică și constructorul de copiere ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct(int a, int b) {
x = a;
y = b;
cout << "Constructor cu parametri\n";
}

Punct(const Punct& other) {
x = other.x;
y = other.y;
cout << "Constructor de copiere\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// obiectul p1 este creat obisnuit, apeland constructorul cu argumentr
Punct p1(1, 2);
// creează dinamic un nou obiect folosind constructorul de copiere
Punct* p2 = new Punct(p1);

p2->afiseaza();

delete p2;
return 0;
}
</syntaxhighlight>

== Diferența dintre <code>new</code> și <code>malloc</code> ==
În limbajul C, alocarea dinamică a memoriei se face în mod obișnuit cu funcția malloc. În C++, aceasta există în continuare pentru compatibilitate, dar pentru obiecte și clase nu este soluția potrivită.

Dacă alocăm un obiect cu <code>new</code>:
<syntaxhighlight lang="c++">
Test* p = new Test;
</syntaxhighlight>
se întâmplă două lucruri:
* se rezervă memorie pentru obiect;
* se apelează constructorul obiectului

Dacă încercăm să alocăm memorie pentru același tip folosind malloc:
<syntaxhighlight lang="c++">
Test* p = (Test*)malloc(sizeof(Test));
</syntaxhighlight>
se rezervă doar memorie brută. Constructorul nu este apelat. Cu alte cuvinte, <code>malloc</code> știe doar să rezerve un număr de octeți, dar nu știe nimic despre noțiunea de obiect, constructor sau clasă.

Aceasta este diferența fundamentală:
* <code>malloc</code> alocă memorie;
* <code>new</code> alocă memorie și construiește obiectul.

= Alocarea dinamică a vectorilor de obiecte =
În cazul unui vector de obiecte, operatorul new[] rezervă memorie pentru toate elementele vectorului și apelează constructorul corespunzător pentru fiecare obiect, iar operatorul delete[] apelează destructorul fiecărui obiect și apoi eliberează memoria ocupată de întregul vector.

La fel ca la vectorii de date simple, sintaxa generală este următoarea:
<syntaxhighlight lang="c++">
<nume_clasa>* <nume_vector> = new <nume_clasa>[<dimensiune>];
</syntaxhighlight>

== Exemplul 1: vector dinamic de obiecte folosind constructorul implicit ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct() {
x = 0;
y = 0;
cout << "Constructor implicit\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// creează un vector dinamic cu 3 obiecte de tip Punct
// Pentru fiecare element din vector este apelat constructorul implicit
Punct* v = new Punct[3];

for (int i = 0; i < 3; i++)
v[i].afiseaza(); // Accesul la elementele vectorului se face ca la un vector obișnuit:

// apelează destructorul pentru fiecare dintre cele 3 obiecte și apoi eliberează memoria vectorului
delete[] v;
return 0;
}
</syntaxhighlight>

== Exemplul 2: modificarea elementelor din vector ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct() {
x = 0;
y = 0;
}

~Punct() {
cout << "Destructor pentru punctul (" << x << ", " << y << ")\n";
}

void set(int a, int b) {
x = a;
y = b;
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
int n = 4;
Punct* v = new Punct[n];

for (int i = 0; i < n; i++)
v[i].set(i, i * 10);

for (int i = 0; i < n; i++)
v[i].afiseaza();

delete[] v;
return 0;
}
</syntaxhighlight>

= Obiecte care conțin memorie alocată dinamic =
Un astfel de obiect nu mai conține doar date simple, ci și un pointer către o zonă de memorie alocată dinamic. În acest caz, clasa trebuie să gestioneze corect această resursă: să o aloce atunci când obiectul este creat, să o elibereze atunci când obiectul este distrus și să o copieze corect atunci când obiectul este copiat sau atribuit altuia.

== Exemplul 1: un obiect care deține memorie dinamică ==
<syntaxhighlight lang="c++">
#include <iostream>
#include <cstring>
using namespace std;

class Text {
// clasa Text conține un pointer la char
char* s;
public:
Text(const char* p) {
// constructorul aloca memorie suficienta pentru pointerul s
s = new char[strlen(p) + 1];
// apoi se face copierea element cu element (in cazul acesta folosind strcpy)
// atribuirea directa s = p ar fi fost gresita; in acest caz s-ar copia pointerul, nu valorile catre care trimite acesta
strcpy(s, p);
}

~Text() {
// la distrugerea obiectului, memoria alocata in constructor trebuie eliberată
delete[] s;
}

void afiseaza() {
cout << s << endl;
}
};

int main() {
Text t("Laborator C++");
t.afiseaza();
return 0;
}
</syntaxhighlight>

== Exemplul 2: La distrugerea obiectului, memoria trebuie eliberată ==
<syntaxhighlight lang="c++">
#include <iostream>
#include <cstring>
using namespace std;

class Text {
char* s;
public:
Text(const char* p) {
s = new char[strlen(p) + 1];
strcpy(s, p);
}

~Text() {
delete[] s;
}

void afiseaza() {
cout << s << endl;
}
};

int main() {
Text t1("C++");
// copiere superficiala (shallow copy)
Text t2 = t1;

t1.afiseaza();
t2.afiseaza();

return 0;
}
</syntaxhighlight>
La prima vedere, codul pare corect. Totuși, el ascunde o problemă gravă.
Pentru că noi nu am definit un constructor de copiere, compilatorul generează automat unul implicit. Acesta copiază fiecare membru „ca atare”. În consecință, pointerul s din t2 va primi exact aceeași adresă ca pointerul s din t1.

Cu alte cuvinte, după copiere:
* t1.s și t2.s indică spre aceeași zonă de memorie;
* nu există două copii ale textului, ci doar două pointere către același text.

Aceasta se numește copiere superficială (shallow copy).

Dacă două obiecte indică spre aceeași zonă de memorie, atunci la distrugerea lor fiecare destructor va încerca să elibereze aceeași zonă:
* destructorul lui t2 face delete[] s;
* destructorul lui t1 face din nou delete[] s.

Rezultatul este o dublă eliberare a memoriei, ceea ce produce comportament nedefinit.

Prin urmare, pentru clasele care conțin pointeri spre memorie alocată dinamic, copierea superficială este greșită.

== Exemplul 3: copiere profundă ==
Pentru a evita problema copierii superficiale, fiecare obiect trebuie să aibă propria sa copie a datelor. Cu alte cuvinte, la copiere nu trebuie copiată doar adresa, ci trebuie alocată o nouă zonă de memorie și copiat conținutul în ea.

Aceasta se numește copiere profundă (deep copy).

<syntaxhighlight lang="c++">
#include <iostream>
#include <cstring>
using namespace std;

class Text {
char* s;
public:
Text(const char* p) {
s = new char[strlen(p) + 1];
strcpy(s, p);
}

// constructor de copiere
Text(const Text& other) {
s = new char[strlen(other.s) + 1];
strcpy(s, other.s);
}

// operatorul de atribuire
Text& operator=(const Text& other) {
// verifica daca nu se incearca autoatribuire
if (this != &other) {
// elibereaza memoria veche
delete[] s;
// aloca memorie noua si copiaza datele
s = new char[strlen(other.s) + 1];
strcpy(s, other.s);
}
return *this;
}

~Text() {
delete[] s;
}

void afiseaza() {
cout << s << endl;
}
};

int main() {
Text t1("Laborator");
Text t2("Initial");

t2 = t1;

t1.afiseaza();
t2.afiseaza();

return 0;
}
</syntaxhighlight>

C++ POO Operatorii new si delete

2026-03-24T13:15:10Z

Costin.vasile1003:

[WIP Costin] Pagina este in lucru!

= Introducere =
În programele scrise până acum, majoritatea variabilelor și obiectelor au fost declarate în mod direct, de exemplu:

<syntaxhighlight lang="c++">
int x;
Persoana p;
</syntaxhighlight>

În aceste cazuri, memoria necesară este rezervată automat la intrarea în blocul în care au fost declarate, iar eliberarea ei are loc tot automat la ieșirea din acel bloc. Acest mod de lucru este simplu și sigur, dar nu este întotdeauna suficient.

Există numeroase situații în care un program nu poate ști dinainte de câtă memorie are nevoie. De exemplu:
* numărul de elemente dintr-un vector este citit de la tastatură;
* un obiect trebuie să existe și după terminarea funcției în care a fost creat;
* o clasă trebuie să gestioneze intern resurse a căror dimensiune este variabilă;
* programul trebuie să creeze obiecte dinamic, doar atunci când este nevoie de ele

În astfel de situații apare nevoia de alocare dinamică a memoriei, adică rezervarea memoriei în timpul execuției programului. În C++, acest lucru se realizează cu ajutorul operatorilor <code>new</code> și <code>delete</code>.

== Operatorul <code>new</code> ==
Operatorul <code>new</code> este folosit pentru a rezerva memorie dinamică și, în cazul obiectelor, pentru a construi obiectul în acea zonă de memorie (prin apelarea constructorului).

Forma generală pentru <code>new</code> este următoarea:
<syntaxhighlight lang="c++">
<tip_de_date> <nume_pointer> = new <tip_de_date>;
</syntaxhighlight>
Această linie:
* rezervă memorie pentru o variabilă de tipul specificat;
* returnează adresa acelei zone de memorie;
* memorează adresa într-un pointer de tip corespunzător

Dacă se dorește și inițializare:
<syntaxhighlight lang="c++">
<tip_de_date> <nume_pointer> = new <tip_de_date>(<valoare_initiala>);
</syntaxhighlight>
În plus față de varianta anterioară, această linie inițializează cu <valoare_initiala> valoarea stocată în memoria alocată.

== Operatorul <code>delete</code> ==
Operatorul <code>delete</code> este folosit pentru a distruge obiectul creat dinamic (prin apelarea destructorului) și pentru a elibera memoria ocupată de acesta.

Forma generală pentru <code>delete</code> este următoarea:
<syntaxhighlight lang="c++">
delete <nume_pointer>;
<nume_pointer> = nullptr;
</syntaxhighlight>

= Alocarea dinamică pentru tipuri simple =
În această secțiune vor fi prezentate câteva exemple comune de utilizare a operatorilor <code>new</code> și <code>delete</code> cu tipuri de date simple.

== Exemplul 1: alocare dinamică pentru un element de tip <code>int</code> ==
<syntaxhighlight lang="c++">
// declară un pointer p către int si alocă dinamic memorie pentru un număr întreg
int* p = new int;
// stocheaza valoarea 10 la adresa stocata in pointerul p
*p = 10;

// afișează valoarea stocată la adresa din pointerul p
cout << *p << endl;

// memoria alocată anterior este eliberată
delete p;
</syntaxhighlight>

== Exemplul 2: alocare cu inițializare ==
<syntaxhighlight lang="c++">
// declară un pointer p către int si alocă dinamic memorie pentru un număr întreg
// și inițializează valoarea de la acea adresă cu 25
int* p = new int(25);

cout << *p << endl;

delete p;
</syntaxhighlight>

== Exemplul 3: alocare cu alte tipuri simple ==
<syntaxhighlight lang="c++">
double* x = new double(3.14);
char* c = new char('A');

cout << *x << endl;
cout << *c << endl;

delete x;
delete c;
</syntaxhighlight>

= Alocarea dinamică a vectorilor de date simple =
Sintaxa generală este următoarea:
<syntaxhighlight lang="c++">
// new
<tip_de_date>* <nume_pointer> = new <tip_de_date>[<numar_elemente>];

// delete
delete[] <nume_pointer>;
</syntaxhighlight>

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> pentru memoria alocată dinamic sub forma unui vector, folosind <code>new[]</code>, eliberarea trebuie făcută întotdeauna cu <code>delete[]</code> și nu cu <code>delete</code>. Folosirea lui <code>delete</code> simplu în acest caz este greșită și conduce la comportament nedefinit, deoarece programul nu mai tratează corect memoria rezervată pentru toate elementele vectorului.</div>

== Exemplul 1: alocarea dinamică a unui vector ==
<syntaxhighlight lang="c++">
int n = 5;
int* v = new int[n]; // aloca memorie pentru un vector de int cu 5 elemente
</syntaxhighlight>

== Exemplul 2: suma numerelor dintr-un vector ==
<syntaxhighlight lang="c++">
// se declara n si se citeste de la tastatura dimensiunea vectorului
int n;
cin >> n;

// se aloca dinamic vectorul de n elemente
int* v = new int[n];

// se citesc de la tastatura elementele vectorului
for (int i = 0; i < n; i++)
cin >> v[i];

// se calculeaza suma tuturor elementelor din vector
int suma = 0;
for (int i = 0; i < n; i++)
suma += v[i];

// afisarea sumei
cout << "Suma = " << suma << endl;

// se elibereaza memoria alocata anterior
delete[] v;
v = nullptr;
</syntaxhighlight>

= Alocarea dinamică a obiectelor =
La fel ca la tipurile de date simple, sintaxa generală este următoarea:
<syntaxhighlight lang="c++">
<numa_clasa>* <nume_pointer> = new <nume_clasa>;
</syntaxhighlight>
Această linie va aloca memorie pentru noul obiect și va apela constructorul fără argumente.

Dacă dorim să apelăm constructorul cu parametri, vom folosi următoarea sintaxa:
<syntaxhighlight lang="c++">
<numa_clasa>* <nume_pointer> = new <nume_clasa>(<argumente_constructor>);
</syntaxhighlight>

Pentru distrugerea obiectului se foloseste in continuare:
<syntaxhighlight lang="c++">
delete <nume_pointer>;
</syntaxhighlight>

== Exemplul 1: obiect creat dinamic folosind constructorul implicit ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct() {
x = 0;
y = 0;
cout << "Constructor implicit\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// alocă memorie pentru un obiect de tip Punct și apelează constructorul implicit al clasei
Punct* p = new Punct;
// deoarece avem un pointer la obiect, metodele si campurile sale sunt accesate cu ->
p->afiseaza();
// apelează destructorul obiectului și apoi eliberează memoria ocupată de el
delete p;

return 0;
}
</syntaxhighlight>

== Exemplul 2: obiect creat dinamic folosind un constructor cu parametri ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct(int a, int b) {
x = a;
y = b;
cout << "Constructor cu parametri\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// aloca memorie si apeleaza constructorul cu parametri
Punct* p = new Punct(3, 4);
// deoarece avem un pointer la obiect, metodele si campurile sale sunt accesate cu ->
p->afiseaza();
// apelează destructorul obiectului și apoi eliberează memoria ocupată de el
delete p;
return 0;
}
</syntaxhighlight>

== Exemplul 3: alocarea dinamică și constructorul de copiere ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct(int a, int b) {
x = a;
y = b;
cout << "Constructor cu parametri\n";
}

Punct(const Punct& other) {
x = other.x;
y = other.y;
cout << "Constructor de copiere\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// obiectul p1 este creat obisnuit, apeland constructorul cu argumentr
Punct p1(1, 2);
// creează dinamic un nou obiect folosind constructorul de copiere
Punct* p2 = new Punct(p1);

p2->afiseaza();

delete p2;
return 0;
}
</syntaxhighlight>

== Diferența dintre <code>new</code> și <code>malloc</code> ==
În limbajul C, alocarea dinamică a memoriei se face în mod obișnuit cu funcția malloc. În C++, aceasta există în continuare pentru compatibilitate, dar pentru obiecte și clase nu este soluția potrivită.

Dacă alocăm un obiect cu <code>new</code>:
<syntaxhighlight lang="c++">
Test* p = new Test;
</syntaxhighlight>
se întâmplă două lucruri:
* se rezervă memorie pentru obiect;
* se apelează constructorul obiectului

Dacă încercăm să alocăm memorie pentru același tip folosind malloc:
<syntaxhighlight lang="c++">
Test* p = (Test*)malloc(sizeof(Test));
</syntaxhighlight>
se rezervă doar memorie brută. Constructorul nu este apelat. Cu alte cuvinte, <code>malloc</code> știe doar să rezerve un număr de octeți, dar nu știe nimic despre noțiunea de obiect, constructor sau clasă.

Aceasta este diferența fundamentală:
* <code>malloc</code> alocă memorie;
* <code>new</code> alocă memorie și construiește obiectul.

= Alocarea dinamică a vectorilor de obiecte =
În cazul unui vector de obiecte, operatorul new[] rezervă memorie pentru toate elementele vectorului și apelează constructorul corespunzător pentru fiecare obiect, iar operatorul delete[] apelează destructorul fiecărui obiect și apoi eliberează memoria ocupată de întregul vector.

La fel ca la vectorii de date simple, sintaxa generală este următoarea:
<syntaxhighlight lang="c++">
<nume_clasa>* <nume_vector> = new <nume_clasa>[<dimensiune>];
</syntaxhighlight>

== Exemplul 1: vector dinamic de obiecte folosind constructorul implicit ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct() {
x = 0;
y = 0;
cout << "Constructor implicit\n";
}

~Punct() {
cout << "Destructor\n";
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
// creează un vector dinamic cu 3 obiecte de tip Punct
// Pentru fiecare element din vector este apelat constructorul implicit
Punct* v = new Punct[3];

for (int i = 0; i < 3; i++)
v[i].afiseaza(); // Accesul la elementele vectorului se face ca la un vector obișnuit:

// apelează destructorul pentru fiecare dintre cele 3 obiecte și apoi eliberează memoria vectorului
delete[] v;
return 0;
}
</syntaxhighlight>

== Exemplul 2: modificarea elementelor din vector ==
<syntaxhighlight lang="c++">
#include <iostream>
using namespace std;

class Punct {
int x, y;
public:
Punct() {
x = 0;
y = 0;
}

~Punct() {
cout << "Destructor pentru punctul (" << x << ", " << y << ")\n";
}

void set(int a, int b) {
x = a;
y = b;
}

void afiseaza() {
cout << "(" << x << ", " << y << ")\n";
}
};

int main() {
int n = 4;
Punct* v = new Punct[n];

for (int i = 0; i < n; i++)
v[i].set(i, i * 10);

for (int i = 0; i < n; i++)
v[i].afiseaza();

delete[] v;
return 0;
}
</syntaxhighlight>

= Obiecte care conțin memorie alocată dinamic =
Un astfel de obiect nu mai conține doar date simple, ci și un pointer către o zonă de memorie alocată dinamic. În acest caz, clasa trebuie să gestioneze corect această resursă: să o aloce atunci când obiectul este creat, să o elibereze atunci când obiectul este distrus și să o copieze corect atunci când obiectul este copiat sau atribuit altuia.

== Exemplul 1: un obiect care deține memorie dinamică ==
<syntaxhighlight lang="c++">
#include <iostream>
#include <cstring>
using namespace std;

class Text {
// clasa Text conține un pointer la char
char* s;
public:
Text(const char* p) {
// constructorul aloca memorie suficienta pentru pointerul s
s = new char[strlen(p) + 1];
// apoi se face copierea element cu element (in cazul acesta folosind strcpy)
// atribuirea directa s = p ar fi fost gresita; in acest caz s-ar copia pointerul, nu valorile catre care trimite acesta
strcpy(s, p);
}

~Text() {
// la distrugerea obiectului, memoria alocata in constructor trebuie eliberată
delete[] s;
}

void afiseaza() {
cout << s << endl;
}
};

int main() {
Text t("Laborator C++");
t.afiseaza();
return 0;
}
</syntaxhighlight>

== Exemplul 2: La distrugerea obiectului, memoria trebuie eliberată ==
<syntaxhighlight lang="c++">
#include <iostream>
#include <cstring>
using namespace std;

class Text {
char* s;
public:
Text(const char* p) {
s = new char[strlen(p) + 1];
strcpy(s, p);
}

~Text() {
delete[] s;
}

void afiseaza() {
cout << s << endl;
}
};

int main() {
Text t1("C++");
// copiere superficiala (shallow copy)
Text t2 = t1;

t1.afiseaza();
t2.afiseaza();

return 0;
}
</syntaxhighlight>
La prima vedere, codul pare corect. Totuși, el ascunde o problemă gravă.
Pentru că noi nu am definit un constructor de copiere, compilatorul generează automat unul implicit. Acesta copiază fiecare membru „ca atare”. În consecință, pointerul s din t2 va primi exact aceeași adresă ca pointerul s din t1.

Cu alte cuvinte, după copiere:
* t1.s și t2.s indică spre aceeași zonă de memorie;
* nu există două copii ale textului, ci doar două pointere către același text.

Aceasta se numește copiere superficială (shallow copy).

Dacă două obiecte indică spre aceeași zonă de memorie, atunci la distrugerea lor fiecare destructor va încerca să elibereze aceeași zonă:
* destructorul lui t2 face delete[] s;
* destructorul lui t1 face din nou delete[] s.

Rezultatul este o dublă eliberare a memoriei, ceea ce produce comportament nedefinit.

Prin urmare, pentru clasele care conțin pointeri spre memorie alocată dinamic, copierea superficială este greșită.

== Exemplul 3: copiere profundă ==
Pentru a evita problema copierii superficiale, fiecare obiect trebuie să aibă propria sa copie a datelor. Cu alte cuvinte, la copiere nu trebuie copiată doar adresa, ci trebuie alocată o nouă zonă de memorie și copiat conținutul în ea.

Aceasta se numește copiere profundă (deep copy).

<syntaxhighlight lang="c++">
#include <iostream>
#include <cstring>
using namespace std;

class Text {
char* s;
public:
Text(const char* p) {
s = new char[strlen(p) + 1];
strcpy(s, p);
}

Text(const Text& other) {
s = new char[strlen(other.s) + 1];
strcpy(s, other.s);
}

~Text() {
delete[] s;
}

void afiseaza() {
cout << s << endl;
}
};

int main() {
Text t1("C++");
Text t2 = t1;

t1.afiseaza();
t2.afiseaza();

return 0;
}
</syntaxhighlight>

C++ POO Operatorii new si delete

2026-03-24T13:09:23Z

Costin.vasile1003:

C++ POO Operatorii new si delete

2026-03-24T10:22:30Z

Costin.vasile1003:

C++ POO Operatorii new si delete

2026-03-24T09:46:08Z

Costin.vasile1003:

C++ POO Operatorii new si delete

2026-03-24T09:40:15Z

Costin.vasile1003:

C++ POO Operatorii new si delete

2026-03-24T08:27:57Z

Costin.vasile1003:

C++ POO Operatorii new si delete

2026-03-24T08:17:37Z

Costin.vasile1003:

C++ POO Operatorii new si delete

2026-03-24T07:52:02Z

Costin.vasile1003:

[WIP Costin] Pagina este in lucru!

= Introducere =
În programele scrise până acum, majoritatea variabilelor și obiectelor au fost declarate în mod direct, de exemplu:

<syntaxhighlight lang="c++">
int x;
Persoana p;
</syntaxhighlight>

= Alocarea dinamică pentru tipuri simple =
Lorem ipsum dolor sit amet.

= Alocarea dinamică a obiectelor =
Lorem ipsum dolor sit amet.

= Alocarea dinamică a vectorilor de obiecte =
Lorem ipsum dolor sit amet.

= Obiecte care conțin memorie alocată dinamic =
Lorem ipsum dolor sit amet.

= Greșeli frecvente și comportamente periculoase =
Lorem ipsum dolor sit amet.

Programare Orientată pe Obiecte (C++)

2026-03-24T07:39:59Z

Costin.vasile1003:

C++ POO Operatorii new si delete

2026-03-24T07:38:06Z

Costin.vasile1003:

[WIP Costin] Pagina este in lucru!

= Introducere =
Lorem ipsum dolor sit amet.

= Alocarea dinamică pentru tipuri simple =
Lorem ipsum dolor sit amet.

= Alocarea dinamică a obiectelor =
Lorem ipsum dolor sit amet.

= Alocarea dinamică a vectorilor de obiecte =
Lorem ipsum dolor sit amet.

= Obiecte care conțin memorie alocată dinamic =
Lorem ipsum dolor sit amet.

= Greșeli frecvente și comportamente periculoase =
Lorem ipsum dolor sit amet.

C++ POO Operatorii new si delete

2026-03-24T07:27:27Z

Costin.vasile1003: Pagină nouă: WIP Costin

WIP Costin

C++ POO Lab Lucrarea 3

2022-03-29T20:24:00Z

Costin.vasile1003:

= 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 [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:
<syntaxhighlight lang="C++">
#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;
}
</syntaxhighlight>

Output:
<syntaxhighlight lang="C++">
Acest mesaj provine din constructor
Obiectul a fost construit!
Acest mesaj provine din destructor
</syntaxhighlight>

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). <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 ===

Asocierea între o referință și o variabilă este permanentă și nu putem asocia referința cu altă variabilă! Putem, în schimb, să asociem mai multe referințe cu aceeași variabilă. <br>
Observați datele de ieșire ale următorului exemplu:

<syntaxhighlight lang="C++">
#include <iostream>

int main() {
#include <iostream>

int main() {
int numar_1 = 25;
int numar_2 = 30;

int& r1Numar = numar_1;
int& r2Numar = numar_1;

r1Numar = numar_2;
r1Numar++;

std::cout << "Valoarea lui r1Numar: " << r1Numar << std::endl;
std::cout << "Valoarea lui r2Numar: " << r2Numar << std::endl;
std::cout << "Valoarea lui numar_1: " << numar_1 << std::endl;
std::cout << "Valoarea lui numar_2: " << numar_2 << std::endl;

return 0;
}
</syntaxhighlight>

Output:
<syntaxhighlight>
Valoarea lui r1Numar: 31
Valoarea lui r2Numar: 31
Valoarea lui numar_1: 31
Valoarea lui numar_2: 30
</syntaxhighlight>

Observăm că expresia <code>r1Numar= numar_2;</code> nu a asociat referința r1Numarcu variabila numar_2, ci a determinat copierea valorii numar_2 în variabila cu care rNumar este asociată. <br>
De asemenea, observăm că variabila numar_1 este asociată cu două referințe.

O referință nu poate fi asociată cu o valoare. Următorul program va genera erori de compilare:
<syntaxhighlight lang="C++">
int main() {
int& rNumar = 20; // aceasta expresie nu este permisa

return 0;
}
</syntaxhighlight>

=== Pasarea argumentelor prin referință ===

Utilitatea referințelor este evidențiată atunci când avem nevoie sa accesăm o variabilă din contexte diferite (precum două metode diferite). Folosind referințe putem economisi memorie, folosind același spațiu de memorie accesat cu două nume de variabile diferite. <br>

Următorul exemplu '''nu folosește referințe''' pentru pasarea argumentelor ('''pass-by-value'''). <br>
În acest caz, de fiecare dată când funcția sum este apelată, în memorie este alocat spațiu pentru două variabile noi ce iau valorile argumentelor. Acest lucru nu este eficient atunci când avem nevoie sa pasăm informații de dimensiuni mari.
<syntaxhighlight lang="C++">
#include <iostream>

/*
*
* Exemplu pass-by-value
*
**/

int sum(int a, int b){
return a + b;
}

int main() {
int a = 5;
int b = 6;
int suma = sum(a, b);

std::cout << "Suma: " << suma << std::endl;

return 0;
}
</syntaxhighlight>

Următorul exemplu '''folosește referințe''' pentru pasarea argumentelor ('''pass-by-reference'''). <br>
În acest caz, de fiecare dată când funcția sum este apelată, argumentele funcției nu sunt copii ale variabilelor, ci referințe către variabilele pasate funcției.

<syntaxhighlight lang="C++">
#include <iostream>

/*
*
* Exemplu pass-by-reference
*
**/

int sum(int& a, int& b){
return a + b;
}

int main() {
int a = 5;
int b = 6;
int suma = sum(a, b);

std::cout << "Suma: " << suma << std::endl;

return 0;
}
</syntaxhighlight>

'''Atenție!''' Deși pasarea argumentelor prin referință eficientizează dimensiunea memoriei ocupate la run-time, argumentele funcțiilor vor trebui manipulate cu grijă; o modificare a acestora în corpul funcției se va reflecta și asupra variabilei pasate ca argument!

= Supraîncărcarea operatorilor =

Dacă dorim să tratăm instanțele claselor (i.e. obiectele) așa cum tratăm tipurile de date fundamentale, trebuie să putem folosi aceiași operatori pe care îi folosim si cu tipurile fundamentale. <br>
Cunoaștem, de exemplu, faptul că putem aduna două valori de tip întreg folosind operatorul '+'. În mod similar, am dori să putem calcula și suma a două numere complexe definite de clasa Complex din următorul exemplu:
<syntaxhighlight lang="C++">
class Complex{
double mReal; // partea reala
double mImaginar; // partea imaginara

public:

/*
* Constructorul ce initializeaza campurile obiectului
*
* */
Complex(double real, double imaginar){
mReal = real;
mImaginar = imaginar;
}

/*
* Constructorul fara argumente
*
* */
Complex() = default;

/*
* Metoda: get_suma
*
* Intoarce suma (sub forma de obiect de tip Complex) dintre obiectul curent si obiectul primit ca argument
*
* */
Complex get_sum(Complex alt_numar){
double real_rezultat = mReal + alt_numar.mReal;
double imaginar_rezultat = mImaginar + alt_numar.mImaginar;

Complex rezultat(real_rezultat, imaginar_rezultat);

return rezultat;
}

/*
* Metoda: afisare
*
* Afiseaza numarul complex in formatul a+bi
*
* */
void afisare(){
std::cout << mReal << '+' << mImaginar << 'i' << std::endl;
}
};
</syntaxhighlight>

Folosind cunoștințele acumulate până acum, putem realiza suma a doua obiecte de tip Complex implementând funcția get_suma din exemplul de mai sus. <br>
Totuși, aceasta nu ne permite să adunăm două obiecte de tip complex folosind operatorul '+', așa cum dorim.

Fie clasa Complex definită anterior. Acesta este un exemplu de utilizare a funcției get_sum:
<syntaxhighlight lang="C++">
int main() {
Complex complex_1 (5, 10);
Complex complex_2 (-1, 3);

Complex suma = complex_1.get_sum(complex_2);

suma.afisare();

return 0;
}
</syntaxhighlight>

Output:
<syntaxhighlight>
4+13i
</syntaxhighlight>

Supraîncărcarea operatorilor presupune implementarea uneia sau mai multor funcții speciale (numite funcții operator) ce descriu comportamentul operatorilor doriți. <br>
Numele unei astfel de funcții începe cu cuvântul cheie operator și este urmat de simbolul operatorului supraîncărcat. De asemenea, la fel ca funcțiile obișnuite, operatorii vor avea tip de date returnat și (opțional) argumente.

Sintaxa pentru declararea unei funcții operator: <br>
<code>
''tip_returnat'' '''operator''' ''simbol'' (<''lista argumentelor''>)
</code>

=== Reguli generale ===
Supraîncărcarea operatorilor trebuie să respecte următoarele reguli:
# Prioritatea operatorilor nu poate fi schimbată (ex. '*' are prioritate față de '+')
# Asociativitatea și comutativitatea operatorilor nu pot fi schimbate
# Numărul de operanzi ai unui operator nu poate fi schimbat (ex. operatorul '+' este binar, în timp ce '!' este unar)
# Nu pot fi supraîncărcați operatori noi, doar cei definiți în standardul C++. Consultați [https://en.cppreference.com/w/cpp/language/operators acest link] pentru lista operatorilor.

=== Exemplu ===
Metoda get_sum din exemplul anterior este înlocuită în exemplul următor de operatorul '+'.

<syntaxhighlight lang="C++">
#include <iostream>

class Complex{
double mReal; // partea reala
double mImaginar; // partea imaginara

public:
/*
* Constructorul ce initializeaza campurile obiectului
*
* */
Complex(double real, double imaginar){
mReal = real;
mImaginar = imaginar;
}

/*
* Constructorul fara argumente
*
* */
Complex() = default;

/*
* Metoda: operator +
*
* Intoarce suma (sub forma de obiect de tip Complex) dintre obiectul curent si obiectul primit ca argument
*
* */
Complex operator +(Complex alt_numar){
double real_rezultat = mReal + alt_numar.mReal;
double imaginar_rezultat = mImaginar + alt_numar.mImaginar;

Complex rezultat(real_rezultat, imaginar_rezultat);

return rezultat;
}

/*
* Metoda: afisare
*
* Afiseaza numarul complex in formatul a+bi
*
* */
void afisare(){
std::cout << mReal << '+' << mImaginar << 'i' << std::endl;
}
};

int main() {
Complex complex_1 (5, 10);
Complex complex_2 (-1, 3);

Complex suma = complex_1 + complex_2;

suma.afisare();

return 0;
}
</syntaxhighlight>

C++ POO Lab Lucrarea 3

2022-03-29T20:01:57Z

Costin.vasile1003:

C++ POO Lab Lucrarea 3

2022-03-29T19:03:41Z

Costin.vasile1003:

C++ POO Lab Lucrarea 3

2022-03-29T19:00:21Z

Costin.vasile1003:

C++ POO Lab Lucrarea 3

2022-03-29T18:53:25Z

Costin.vasile1003:

C++ POO Lab Lucrarea 3

2022-03-29T18:38:04Z

Costin.vasile1003:

C++ POO Lab Lucrarea 3

2022-03-29T18:20:39Z

Costin.vasile1003:

C++ POO Lab Lucrarea 3

2022-03-28T20:15:39Z

Costin.vasile1003:

= Introducere =

Această lucrare are ca scop familiarizarea cu următoarele noțiuni:
* Destructorul
* Referința
* Supraîncărcarea operatorilor

= Destructorul =

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 [https://en.cppreference.com/w/cpp/language/scope acest link].

În exemplul de mai jos sunt evidențiate mecanismele de ’construire’ si ’distrugere’ a obiectelor:
<syntaxhighlight lang="C++">
#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;
}
</syntaxhighlight>

Output:
<syntaxhighlight lang="C++">
Acest mesaj provine din constructor
Obiectul a fost construit!
Acest mesaj provine din destructor
</syntaxhighlight>

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 =

= Supraîncărcarea operatorilor =

C++ POO Lab Lucrarea 3

2022-03-28T20:14:51Z

Costin.vasile1003:

Această lucrare are ca scop familiarizarea cu următoarele noțiuni:
* Destructorul
* Referința
* Supraîncărcarea operatorilor

= Destructorul =

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 [https://en.cppreference.com/w/cpp/language/scope acest link].

În exemplul de mai jos sunt evidențiate mecanismele de ’construire’ si ’distrugere’ a obiectelor:
<syntaxhighlight lang="C++">
#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;
}
</syntaxhighlight>

Output:
<syntaxhighlight lang="C++">
Acest mesaj provine din constructor
Obiectul a fost construit!
Acest mesaj provine din destructor
</syntaxhighlight>

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 =

= Supraîncărcarea operatorilor =

C++ POO Lab Lucrarea 3

2022-03-28T20:09:19Z

Costin.vasile1003: Pagină nouă: Această lucrare are ca scop familiarizarea cu următoarele noțiuni: * Destructorul * Referința * Supraîncărcarea operatorilor = Destructorul = Așa cum s-a prezentat în la...

Această lucrare are ca scop familiarizarea cu următoarele noțiuni:
* Destructorul
* Referința
* Supraîncărcarea operatorilor

= Destructorul =

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 [https://en.cppreference.com/w/cpp/language/scope acest link].

În exemplul de mai jos sunt evidențiate mecanismele de ’construire’ si ’distrugere’ a obiectelor:
<syntaxhighlight lang="C++">
#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;
}
</syntaxhighlight>

Dacă executăm acest program obținem următorul output:
<syntaxhighlight lang="C++">
Acest mesaj provine din constructor
Obiectul a fost construit!
Acest mesaj provine din destructor
</syntaxhighlight>

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 =

= Supraîncărcarea operatorilor =

C++ POO Lab Lucrarea 1

2020-09-20T09:09:10Z

Costin.vasile1003:

În acest laborator ne vom reaminti sintaxa limbajului C, vom exersa utilizarea mediului de dezvoltare CLion și a ''debugger''-ului.

== Tool-ul de depanare GDB ==
Depanatorul GNU, cunoscut drept GDB (GNU debugger), este depanatorul standard pentru sistemul de software GNU.<br>
Scopul unui depanator precum GDB este de a permite utilizatorului să vadă ce se întâmplă în interiorul unui alt program în timp ce acesta se execută (pentru a determina motivul rezultatelor necorespunzătoare) sau ce s-a întâmplat cu programul în momentul în care a fost întreruptă execuţia în mod neaşteptat.<br><br>

GDB este capabil de a îndeplini 4 categorii de operații (și alte operaţii intermediare lor):
* să pornească programul, specificând orice ar putea interveni în buna funcționare a acestuia;
* să determine o pauză in execuţia programului în anumite condiții specificate de utilizator;
* să examineze ce s-a întâmplat în momentul opririi programului;
* să modifice anumite valori în program pentru a putea corecta efectele unui bug și a investiga urmările altuia.<br>
Odată pornit, GDB citește comenzi din terminal până la întâlnirea comenzii de ieșire "quit".<br>
<div class="regula">'''<font color="red"> Atenție:</font>''' Pentru a putea folosi debugger-ul, la generarea fișierului executabil trebuie folosită opțiunea '''-g''', care adaugă simboluri de debug în executabil, fără de care depanarea nu este posibilă. (vezi [http://wiki.dcae.pub.ro/index.php/PC_Laborator_1 Laboratorul 1])</div>
Exemplul unei comenzi de compilare în vederea depanării:<br>

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gcc -g hello.c -o hello'''

=== Comenzi specifice GDB ===
Cea mai folosită modalitate de a porni tool-ul de depanare este de a scrie '''gdb''' în terminal, urmat de numele executabilului ce se dorește a fi depanat.

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gdb hello'''

O parte din comenzile cele mai utilizate ale GDB sunt următoarele (pentru lista completă studiați pagina de manual GDB - man gdb):
{| class="wikitable"
! Opțiune !! Efect
|-
| <code style="color: green">break</code> [nume_fișier:] nume_funcție <br> <code style="color: green">break</code> [nume_fișier:] număr_linie || Setează un breakpoint (punct de întrerupere) la începutul funcției ''nume_funcție'' sau la linia specificată prin ''număr_linie'' din fișierul specificat prin ''nume_fișier''.
|-
| <code style="color: green">run</code> [listă_argumente] || Pornește programul în execuție (cu lista de argumente, dacă au fost specificate).
|-
| <code style="color: green">bt</code> || Backtrace: afișează stiva de program.
|-
| <code style="color: green">print</code> expresie || Afișează valoarea unei expresii (valoarea stocată într-o variabilă, valoarea returnată de o funcție etc.).
|-
| <code style="color: green">c</code> || Continuă execuția programului (după ce a fost oprit, spre exemplu după un breakpoint).
|-
| <code style="color: green">next</code> || Execută următoarea linie de program (după oprire), sărind peste orice apel de funcție care se găsește în această linie.
|-
| <code style="color: green">list</code> [nume_fișier:] nume_funcție || Afișează liniile de cod ale programului din vecinătatea locului unde este oprit acum.
|-
| <code style="color: green">step</code> || Execută următoarea linie de program (după oprire), intrând în orice funcție apelată de acea linie.
|-
| <code style="color: green">help</code> [nume] || Afișează informații despre comanda GDB ''nume'' sau informații generale despre utilizarea GDB.
|-
| <code style="color: green">quit</code> || Iese din GDB.
|}

<div class="regula"> ''' Observație: ''' Cele mai multe dintre aceste comenzi pot fi apelate doar prin prima literă a numelui lor. </div>
Spre exemplu, următoarea comandă:
'''(gdb) next'''
este identică cu:
'''(gdb) n'''
<div class="regula"> ''' Observație: ''' Dacă se apasă pe enter fără a scrie o comandă, se repetă ultima comandă specificată.</div>

=== Exemplu de depanare ===
Se dă fișierul sursă ''suma_fact.c'', care conține următoarele instrucțiuni:
<syntaxhighlight lang="C">
#include<stdio.h>

unsigned int factorial(int n) {
if (n == 0) {
return 1;
}
int i;
unsigned int fact = 0;
for (i = 1; i <= n; i++){
fact *= i;
}
return fact;
}

int main() {
int n, i;
do {
printf("Introduceti un numar natural mai mic sau egal cu 8: ");
scanf("%d", &n);
} while (n < 0 || n > 8);
unsigned int suma = 0;
for (i = 0; i <= n; i++) {
suma += factorial(i);
}
printf("%u\n", suma);
return 0;
}
</syntaxhighlight>
Programul își propune să calculeze suma factorialelor de la 0 la n, unde n este introdus de la tastatură. Dacă rulăm programul vom obține ca rezultat numărul '''1''', indiferent de ce a fost introdus de la tastatură. Ne propunem să descoperim bug-ul folosind GDB.<br>
Compilăm sursa, adăugând simboluri de debug în executabil, după care lansăm în execuție debugger-ul:

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gcc -g suma_fact.c -o suma_fact'''
'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gdb suma_fact'''

<div class="regula">'''<font color="red"> Atenție:</font>''' Comanda de mai sus lansează în execuție numai debugger-ul, nu și programul ''suma_fact''.</div>
<div class="regula"> ''' Observație: ''' Putem observa că am pornit debugger-ul prin faptul că fiecare rând nou din linia de comandă începe acum astfel:</div>
'''(gdb)'''
Punem un ''breakpoint'' la linia 20, unde se citește valoarea lui n:
'''(gdb) b 20'''
'''Breakpoint 1 at 0x80484c2: file suma_fact.c, line 20.'''
'''(gdb) '''

Pornim programul în interiorul debugger-ului:
'''(gdb) run'''
'''Starting program: /home/student/Desktop/suma_fact'''
''' '''
'''Breakpoint 1, main () at suma_fact.c:20'''
'''20 scanf("%d", &n);'''
'''(gdb) '''
Trecem mai departe și introducem o valoare pentru n:
'''(gdb) next'''
'''Introduceti un numar natural mai mic sau egal cu 8: 6 '''
'''21 }while(n<0 || n>8);'''
'''(gdb) '''
Vom parcurge programul pas cu pas până la apelarea funcției ''factorial'':
'''(gdb) n'''
'''22 unsigned int suma = 0;'''
'''(gdb) n'''
'''23 for(i=0; i<=n; i++){'''
'''(gdb) n'''
'''24 suma += factorial(i);'''
'''(gdb) s'''
'''factorial (n=0) at suma_fact.c:4'''
'''4 if(n==0){'''
'''(gdb) s'''
'''5 return 1;'''
'''(gdb) s'''
'''13 }'''
'''(gdb) s'''
'''main () at suma_fact.c:23'''
'''23 for(i=0; i<=n; i++){'''
'''(gdb) s'''
'''24 suma += factorial(i);'''
'''(gdb) s'''
'''factorial (n=1) at suma_fact.c:4'''
'''4 if(n==0){'''
'''(gdb) s'''
'''8 unsigned int fact=0;'''
'''(gdb) s'''
'''9 for(i=1; i<=n; i++){'''
'''(gdb) s'''
'''10 fact *= i;'''
'''(gdb) s'''
'''9 for(i=1; i<=n; i++){'''
'''(gdb) s'''
'''12 return fact;'''
'''(gdb) print fact'''
'''$1 = 0'''
'''(gdb) '''
Observăm că valoarea returnată de funcția ''factorial'' pentru orice număr nenul este '''0'''. Acest lucru se datorează inițializării variabilei ''fact'' cu valoarea '''0''' la începutul funcției ''factorial''. Putem ieși din debugger pentru a modifica linia 8 din fișierul sursă suma_fact.c:
'''(gdb) q'''
'''A debugging session is active.'''
''' '''
''' Inferior 1 [process 4279] will be killed.'''
''' '''
'''Quit anyway? (y or n) y '''
'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span>'''
<div class="regula"> ''' Observație: ''' Pentru a putea intra în interiorul funcției ''factorial'' este absolut necesar să se folosească comanda '''step''' și nu comanda '''next''' care ar trece peste acea linie 24 fără a intra în corpul funcției ''factorial''.</div>

După acest laborator veți putea folosi IDE-ul CLion pentru a scrie și depana programe în C. Totodată veți relua și recapitula noțiunile legate de pointeri în C.

= Utilizarea IDE-ului CLion =

[https://www.jetbrains.com/clion CLion] este un mediu integrat de dezvoltare (IDE) care permite dezvoltarea de programe în limbajele C și C++. CLion nu instalează și compilator pentru C/C++, acesta trebuie instalat manual, în prealabil.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Imaginea de Linux folosită la Programarea Calculatoarelor are deja instalat compilatorul de C.</div>

== Instalarea GCC ==

=== Instalarea GCC în Linux ===

Pentru instalarea compilatorului de C (GCC) în distribuțiile de Linux provenite din Ubuntu (Ubuntu, Kubuntu, Xubuntu, Mint, LMDE, etc.) se poate folosi comanda:

apt-get install -y build-essential

=== Instalarea GCC în Windows ===

Pentru compilarea de programe cu GCC în Windows, aveți nevoie de instalarea acestui compilator care poate fi făcută prin instalarea unuia din următoarele două suite de programe:
* [https://cygwin.com Cygwin] - Tutorial de instalare [https://cygwin.com/install.html aici].
* [http://www.mingw.org/ MinGW] - Tutorial de instalare [http://www.mingw.org/wiki/InstallationHOWTOforMinGW aici].

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Nu uitați ca la instalare să bifați în lista de pachete și compilatorul de C (<code>gcc</code>), <code>make</code> și <code>git</code>.</div>

== Instalarea CLion ==

De la adresa https://www.jetbrains.com/clion/download/#section=linux puteți descărca kitul de instalare pentru sistemul vostru de operare.
După instalare, urmaţi următorii paşi de configurare, în funcţie de suita de programe aleasă:
* [https://www.jetbrains.com/help/clion/quick-tutorial-on-configuring-clion-on-windows.html#Cygwin Configurare CLion cu Cygwin]
* [https://www.jetbrains.com/help/clion/quick-tutorial-on-configuring-clion-on-windows.html#MinGW Configurare CLion cu MinGW]

== Realizarea unui proiect ==

Odată pornit, CLion oferă posibilitatea de a deschide un proiect existent, sau de a crea unul nou. Vrem să realizăm un proiect nou, aşadar se va alege '''New Project'''.

<div class="regula"> ''' Observație: ''' Se poate realiza un nou proiect atunci când altul este deja deschis folosind meniul <code>File - New Project </code> .</div>

[[Fișier:Welcome_to_clion.png | 600px | Imaginea 1]]

<br> Mai departe se va selecta categoria '''C++ Executable''' şi se va introduce locaţia proiectului.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> În imagine se observă că locaţia introdusă este '''/home/student/projects/NewProject'''. Se recomandă ca directorul în care se realizează proiectul să aibă numele proiectului, sau un nume sugestiv (în imagine '''NewProject''')</div>

[[Fișier:New_project_location_clion.png | 600px | Imaginea 2]]

== Componentele IDE-ului CLion ==

[[Fișier:CLion_env.png | 1000px | Imaginea 3]]

La crearea unui nou proiect, IDE-ul CLion generează automat fişierul '''main.cpp'''. Acesta conţine un exemplu program ce va fi rescris de către utilizator. <br>

Secţiunile marcate în imagine reprezintă:
# Zona <span style="color: green">verde</span> - '''Project view''' indică toate fişierele şi directoarele ce alcătuiesc proiectul.
# Zona <span style="color: blue">albastră</span> - '''Editor''' este fereastra de vizualizare şi editare a textului
# Zona <span style="color: red">roşie</span> - '''Toolbar''' oferă acces rapid pentru operaţiile uzuale. Dintre acestea, cel mai des vom folosi:
#*'''Build''' [[Fișier:CLion_build_button.png | 16px]]
#*'''Run''' [[Fișier:CLion_run_button.png | 16px]]
#*'''Debug''' [[Fișier:CLion_debug_button.png | 16px]]
# Zona <span style="color: gold">galbenă</span> - '''Run''' este zona în care se introduc datele de intrare şi se în care vor fi afişate datele de ieşire.

== Exemplu de program în modul ''debug'' ==

Copiați codul de mai jos înlocuind programul deja existent în fișierul ''main.c'':
<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(){
printf("Debugging program...\n");
int value = 0;
value = value + 1;
value++;
value = value * 2;
value -= 1;
printf("Value is now %d!\n", value);
return 0;
}
</syntaxhighlight>

Pentru a executa programul în modul debug trebuie sa introducem cel puţin un '''breakpoint'''. Astfel indicăm programului unde se va opri pentru a ne acorda control asupra execuţiei, având posibilitatea de a continua execuţia pas cu pas. <br>

Introducem un nou breakpoint dând click în dreptul liniei de la care vrem să obţinem controlul. În cazul nostru, vom alege să indroducem un breakpoint chiar la definirea variabilei <code>value</code>.

[[Fișier:CLion_breakpoint.png | 1000px | Imaginea 4]]

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Când alegem locaţia unui breakpoint trebuie să ţinem cont de următorul aspect: în modul '''debug''' programul se va opri '''înainte''' de a executa linia în dreptul căreia a fost introdus breakpoint-ul!</div>

În continuare, trebuie se pornim execuţia programului in modul debug [[Fișier:CLion_debug_button.png | 16px]]. Observăm apariţia ferestrei Debug (chenarul albastru, Imaginea 5) ce conţine următoarele:
#Zona <span style="color: gold">galbenă</span> - fereastra cu toate variabilele declarate, împreună cu valorile lor. Momentan nu există nicio variabilă declarată (deoarece linia asupra la care ne-am oprit nu a fost încă executată!)
#Zona <span style="color: red">roşie</span> - Permite trecerea între fereastra pentru procesul de depanare ('''Debugger''') şi fereastra în care se afişează/introduc datele ('''Console''')
#Zona <span style="color: green">verde</span> - Conţine comenzile pentru controlul execuţiei în modul debug (comenzi numite '''stepping actions'''):
#*'''Step over''' [[Fișier:CLion_step_over.png | 16px]] - Execută comenzile de pe linia curentă şi trece la următoarea linie
#*'''Step into''' [[Fișier:CLion_step_into.png | 16px]] - Programul va executa linia curentă iar dacă pe linia curentă există un apel de funcție, se va opri pe prima linie din funcția respectivă. Această comandă este utilă atunci cand pe linia curentă se află un apel de funcţie şi vrem sa studiem comportamentul codului din interiorul funcţiei.
#*'''Step out''' [[Fișier:CLion_step_out.png | 16px]] - Termină de executat funcţia în care se află linia curentă
#*'''Run to cursor''' [[Fișier:CLion_run_to_cursor.png | 16px]] - Execută toate instructiunile până se intâlneste cursorul.

<div class="regula"> ''' Observație: ''' În modul debug, linia curentă este marcată de către mediul de dezvoltare prin colorarea acesteia cu albastru.</div>

Alte comenzi utile:
*'''Resume program''' [[Fișier:CLion_resume_project.png | 16px]] - Continuă execuţia pâmă la următorul breakpoint (dacă nu există, se va executa până la final)
*'''Stop''' [[Fișier:CLion_stop.png | 16px]] - Se opreşte definitv execuţia programului, împreună cu modul debug

[[Fișier:CLion_debug_process.png | 1000px | Imaginea 5]]<br>

Pentru a exersa utilizarea sistemului de debug, realizați următoarele operații:
# Parcurgeti tot programul folosind '''Step Over''' și vizualizând valoarea variabilei <code>value</code> la fiecare pas, până la ultima linie din program, unde utilizați '''Resume program'''.
# Reporniți aplicația în modul de debug și puneți un al doilea ''breakpoint'' pe linia cu apelul funcției <code>printf</code>.
# Folosiți '''Resume program''' pentru a ajunge la al doilea ''breakpoint''.
# Odată ajunși acolo, folosiți '''Step In''' pentru a intra în funcția <code>printf</code> (neavând codul sursă, veți vedea codul de asamblare obținut din dezasamblarea fișierului obiect de către GDB).
# Folosiți '''Step Out''' pentru a reveni în funcția <code>main</code> și apoi '''Resume program''' pentru a termina execuția.

== Tips & Tricks ==

=== Formatare automată a codului ===

CLion oferă opțiunea de a formata automat codul prin selectarea '''Code -> Reformat Code'''.

Ce probleme rezolvă această formatare automată:
* alinierea liniilor în funcție de blocurile de instrucțiuni și tipurile de ''statements'' de pe fiecare linie;
* plasarea sau eliminarea de spații acolo unde este necasar.
Ce probleme NU rezolvă această formatare automată;
* lipsa acoladelor de la blocurile '''if''' și '''for''';
* numele insuficient de sugestive pentru numele de funcții, structuri sau variabile.

Stilul conform căruia este modificat codul poate fi configurat folosind meniul <code>File|Settings|Editor|CodeStyle</code>

=== Generare automată a codului ===

CLion oferă posibilitatea de a genera fragmente de cod des înâlnite, precum constructori şi operatori în interiorul claselor. Această acţiune poate fi realizată folosind meniul <code> Code|Generate</code>.

=== Altele ===
* [https://www.jetbrains.com/help/clion/using-todo.html TODO Comments]

<br> Nu uitați de regulile următoare: [[Convenții de cod - C]]

C++ POO Lab Lucrarea 1

2020-09-19T14:30:31Z

Costin.vasile1003: CLion debugger

În acest laborator ne vom reaminti sintaxa limbajului C, vom exersa utilizarea mediului de dezvoltare CLion și a ''debugger''-ului.

== Tool-ul de depanare GDB ==
Depanatorul GNU, cunoscut drept GDB (GNU debugger), este depanatorul standard pentru sistemul de software GNU.<br>
Scopul unui depanator precum GDB este de a permite utilizatorului să vadă ce se întâmplă în interiorul unui alt program în timp ce acesta se execută (pentru a determina motivul rezultatelor necorespunzătoare) sau ce s-a întâmplat cu programul în momentul în care a fost întreruptă execuţia în mod neaşteptat.<br><br>

GDB este capabil de a îndeplini 4 categorii de operații (și alte operaţii intermediare lor):
* să pornească programul, specificând orice ar putea interveni în buna funcționare a acestuia;
* să determine o pauză in execuţia programului în anumite condiții specificate de utilizator;
* să examineze ce s-a întâmplat în momentul opririi programului;
* să modifice anumite valori în program pentru a putea corecta efectele unui bug și a investiga urmările altuia.<br>
Odată pornit, GDB citește comenzi din terminal până la întâlnirea comenzii de ieșire "quit".<br>
<div class="regula">'''<font color="red"> Atenție:</font>''' Pentru a putea folosi debugger-ul, la generarea fișierului executabil trebuie folosită opțiunea '''-g''', care adaugă simboluri de debug în executabil, fără de care depanarea nu este posibilă. (vezi [http://wiki.dcae.pub.ro/index.php/PC_Laborator_1 Laboratorul 1])</div>
Exemplul unei comenzi de compilare în vederea depanării:<br>

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gcc -g hello.c -o hello'''

=== Comenzi specifice GDB ===
Cea mai folosită modalitate de a porni tool-ul de depanare este de a scrie '''gdb''' în terminal, urmat de numele executabilului ce se dorește a fi depanat.

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gdb hello'''

O parte din comenzile cele mai utilizate ale GDB sunt următoarele (pentru lista completă studiați pagina de manual GDB - man gdb):
{| class="wikitable"
! Opțiune !! Efect
|-
| <code style="color: green">break</code> [nume_fișier:] nume_funcție <br> <code style="color: green">break</code> [nume_fișier:] număr_linie || Setează un breakpoint (punct de întrerupere) la începutul funcției ''nume_funcție'' sau la linia specificată prin ''număr_linie'' din fișierul specificat prin ''nume_fișier''.
|-
| <code style="color: green">run</code> [listă_argumente] || Pornește programul în execuție (cu lista de argumente, dacă au fost specificate).
|-
| <code style="color: green">bt</code> || Backtrace: afișează stiva de program.
|-
| <code style="color: green">print</code> expresie || Afișează valoarea unei expresii (valoarea stocată într-o variabilă, valoarea returnată de o funcție etc.).
|-
| <code style="color: green">c</code> || Continuă execuția programului (după ce a fost oprit, spre exemplu după un breakpoint).
|-
| <code style="color: green">next</code> || Execută următoarea linie de program (după oprire), sărind peste orice apel de funcție care se găsește în această linie.
|-
| <code style="color: green">list</code> [nume_fișier:] nume_funcție || Afișează liniile de cod ale programului din vecinătatea locului unde este oprit acum.
|-
| <code style="color: green">step</code> || Execută următoarea linie de program (după oprire), intrând în orice funcție apelată de acea linie.
|-
| <code style="color: green">help</code> [nume] || Afișează informații despre comanda GDB ''nume'' sau informații generale despre utilizarea GDB.
|-
| <code style="color: green">quit</code> || Iese din GDB.
|}

<div class="regula"> ''' Observație: ''' Cele mai multe dintre aceste comenzi pot fi apelate doar prin prima literă a numelui lor. </div>
Spre exemplu, următoarea comandă:
'''(gdb) next'''
este identică cu:
'''(gdb) n'''
<div class="regula"> ''' Observație: ''' Dacă se apasă pe enter fără a scrie o comandă, se repetă ultima comandă specificată.</div>

=== Exemplu de depanare ===
Se dă fișierul sursă ''suma_fact.c'', care conține următoarele instrucțiuni:
<syntaxhighlight lang="C">
#include<stdio.h>

unsigned int factorial(int n) {
if (n == 0) {
return 1;
}
int i;
unsigned int fact = 0;
for (i = 1; i <= n; i++){
fact *= i;
}
return fact;
}

int main() {
int n, i;
do {
printf("Introduceti un numar natural mai mic sau egal cu 8: ");
scanf("%d", &n);
} while (n < 0 || n > 8);
unsigned int suma = 0;
for (i = 0; i <= n; i++) {
suma += factorial(i);
}
printf("%u\n", suma);
return 0;
}
</syntaxhighlight>
Programul își propune să calculeze suma factorialelor de la 0 la n, unde n este introdus de la tastatură. Dacă rulăm programul vom obține ca rezultat numărul '''1''', indiferent de ce a fost introdus de la tastatură. Ne propunem să descoperim bug-ul folosind GDB.<br>
Compilăm sursa, adăugând simboluri de debug în executabil, după care lansăm în execuție debugger-ul:

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gcc -g suma_fact.c -o suma_fact'''
'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gdb suma_fact'''

<div class="regula">'''<font color="red"> Atenție:</font>''' Comanda de mai sus lansează în execuție numai debugger-ul, nu și programul ''suma_fact''.</div>
<div class="regula"> ''' Observație: ''' Putem observa că am pornit debugger-ul prin faptul că fiecare rând nou din linia de comandă începe acum astfel:</div>
'''(gdb)'''
Punem un ''breakpoint'' la linia 20, unde se citește valoarea lui n:
'''(gdb) b 20'''
'''Breakpoint 1 at 0x80484c2: file suma_fact.c, line 20.'''
'''(gdb) '''

Pornim programul în interiorul debugger-ului:
'''(gdb) run'''
'''Starting program: /home/student/Desktop/suma_fact'''
''' '''
'''Breakpoint 1, main () at suma_fact.c:20'''
'''20 scanf("%d", &n);'''
'''(gdb) '''
Trecem mai departe și introducem o valoare pentru n:
'''(gdb) next'''
'''Introduceti un numar natural mai mic sau egal cu 8: 6 '''
'''21 }while(n<0 || n>8);'''
'''(gdb) '''
Vom parcurge programul pas cu pas până la apelarea funcției ''factorial'':
'''(gdb) n'''
'''22 unsigned int suma = 0;'''
'''(gdb) n'''
'''23 for(i=0; i<=n; i++){'''
'''(gdb) n'''
'''24 suma += factorial(i);'''
'''(gdb) s'''
'''factorial (n=0) at suma_fact.c:4'''
'''4 if(n==0){'''
'''(gdb) s'''
'''5 return 1;'''
'''(gdb) s'''
'''13 }'''
'''(gdb) s'''
'''main () at suma_fact.c:23'''
'''23 for(i=0; i<=n; i++){'''
'''(gdb) s'''
'''24 suma += factorial(i);'''
'''(gdb) s'''
'''factorial (n=1) at suma_fact.c:4'''
'''4 if(n==0){'''
'''(gdb) s'''
'''8 unsigned int fact=0;'''
'''(gdb) s'''
'''9 for(i=1; i<=n; i++){'''
'''(gdb) s'''
'''10 fact *= i;'''
'''(gdb) s'''
'''9 for(i=1; i<=n; i++){'''
'''(gdb) s'''
'''12 return fact;'''
'''(gdb) print fact'''
'''$1 = 0'''
'''(gdb) '''
Observăm că valoarea returnată de funcția ''factorial'' pentru orice număr nenul este '''0'''. Acest lucru se datorează inițializării variabilei ''fact'' cu valoarea '''0''' la începutul funcției ''factorial''. Putem ieși din debugger pentru a modifica linia 8 din fișierul sursă suma_fact.c:
'''(gdb) q'''
'''A debugging session is active.'''
''' '''
''' Inferior 1 [process 4279] will be killed.'''
''' '''
'''Quit anyway? (y or n) y '''
'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span>'''
<div class="regula"> ''' Observație: ''' Pentru a putea intra în interiorul funcției ''factorial'' este absolut necesar să se folosească comanda '''step''' și nu comanda '''next''' care ar trece peste acea linie 24 fără a intra în corpul funcției ''factorial''.</div>

După acest laborator veți putea folosi IDE-ul CLion pentru a scrie și depana programe în C. Totodată veți relua și recapitula noțiunile legate de pointeri în C.

= Utilizarea IDE-ului CLion =

[https://www.jetbrains.com/clion CLion] este un mediu integrat de dezvoltare (IDE) care permite dezvoltarea de programe în limbajele C și C++. CLion nu instalează și compilator pentru C/C++, acesta trebuie instalat manual, în prealabil.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Imaginea de Linux folosită la Programarea Calculatoarelor are deja instalat compilatorul de C.</div>

== Instalarea GCC ==

=== Instalarea GCC în Linux ===

Pentru instalarea compilatorului de C (GCC) în distribuțiile de Linux provenite din Ubuntu (Ubuntu, Kubuntu, Xubuntu, Mint, LMDE, etc.) se poate folosi comanda:

apt-get install -y build-essential

=== Instalarea GCC în Windows ===

Pentru compilarea de programe cu GCC în Windows, aveți nevoie de instalarea acestui compilator care poate fi făcută prin instalarea unuia din următoarele două suite de programe:
* [https://cygwin.com Cygwin] - Tutorial de instalare [https://cygwin.com/install.html aici].
* [http://www.mingw.org/ MinGW] - Tutorial de instalare [http://www.mingw.org/wiki/InstallationHOWTOforMinGW aici].

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Nu uitați ca la instalare să bifați în lista de pachete și compilatorul de C (<code>gcc</code>), <code>make</code> și <code>git</code>.</div>

== Instalarea CLion ==

De la adresa https://www.jetbrains.com/clion/download/#section=linux puteți descărca kitul de instalare pentru sistemul vostru de operare (imaginea de Virtualbox cu Linux folosită la Programarea Calculatoarelor ruelază un Linux pe 32 de biți).

Aveți [https://blog.jetbrains.com/clion/2015/05/debug-clion/ aici] un tutorial pentru modalitatea de utilizarea a IDE-ului pentru depanarea codului.

Nu uitați de regulile următoare: [[Convenții de cod - C]]

== Realizarea unui proiect ==

Odată pornit, CLion oferă posibilitatea de a deschide un proiect existent, sau de a crea unul nou. Vrem să realizăm un proiect nou, aşadar se va alege '''New Project'''.

<div class="regula"> ''' Observație: ''' Se poate realiza un nou proiect atunci când altul este deja deschis folosind meniul <code>File - New Project </code> .</div>

[[Fișier:Welcome_to_clion.png | 600px | Imaginea 1]]

<br> Mai departe se va selecta categoria '''C++ Executable''' şi se va introduce locaţia proiectului.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> În imagine se observă că locaţia introdusă este '''/home/student/projects/NewProject'''. Se recomandă ca directorul în care se realizează proiectul să aibă numele proiectului, sau un nume sugestiv (în imagine '''NewProject''')</div>

[[Fișier:New_project_location_clion.png | 600px | Imaginea 2]]

== Componentele IDE-ului CLion ==

[[Fișier:CLion_env.png | 1000px | Imaginea 3]]

La crearea unui nou proiect, IDE-ul CLion generează automat fişierul '''main.cpp'''. Acesta conţine un exemplu program ce va fi rescris de către utilizator. <br>

Secţiunile marcate în imagine reprezintă:
# Zona <span style="color: green">verde</span> - '''Project view''' indică toate fişierele şi directoarele ce alcătuiesc proiectul.
# Zona <span style="color: blue">albastră</span> - '''Editor''' este fereastra de vizualizare şi editare a textului
# Zona <span style="color: red">roşie</span> - '''Toolbar''' oferă acces rapid pentru operaţiile uzuale. Dintre acestea, cel mai des vom folosi:
#*'''Build''' [[Fișier:CLion_build_button.png | 16px]]
#*'''Run''' [[Fișier:CLion_run_button.png | 16px]]
#*'''Debug''' [[Fișier:CLion_debug_button.png | 16px]]
# Zona <span style="color: gold">galbenă</span> - '''Run''' este zona în care se introduc datele de intrare şi se în care vor fi afişate datele de ieşire.

== Exemplu de program în modul ''debug'' ==

Copiați codul de mai jos înlocuind programul deja existent în fișierul ''main.c'':
<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(){
printf("Debugging program...\n");
int value = 0;
value = value + 1;
value++;
value = value * 2;
value -= 1;
printf("Value is now %d!\n", value);
return 0;
}
</syntaxhighlight>

Pentru a executa programul în modul debug trebuie sa introducem cel puţin un '''breakpoint'''. Astfel indicăm programului unde se va opri pentru a ne acorda control asupra execuţiei, având posibilitatea de a continua execuţia pas cu pas. <br>

Introducem un nou breakpoint dând click în dreptul liniei de la care vrem să obţinem controlul. În cazul nostru, vom alege să indroducem un breakpoint chiar la definirea variabilei <code>value</code>.

[[Fișier:CLion_breakpoint.png | 1000px | Imaginea 4]]

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Când alegem locaţia unui breakpoint trebuie să ţinem cont de următorul aspect: în modul '''debug''' programul se va opri '''înainte''' de a executa linia în dreptul căreia a fost introdus breakpoint-ul!</div>

În continuare, trebuie se pornim execuţia programului in modul debug [[Fișier:CLion_debug_button.png | 16px]]. Observăm apariţia ferestrei Debug (chenarul albastru, Imaginea 5) ce conţine următoarele:
#Zona <span style="color: gold">galbenă</span> - fereastra cu toate variabilele declarate, împreună cu valorile lor. Momentan nu există nicio variabilă declarată (deoarece linia asupra la care ne-am oprit nu a fost încă executată!)
#Zona <span style="color: red">roşie</span> - Permite trecerea între fereastra pentru procesul de depanare ('''Debugger''') şi fereastra în care se afişează/introduc datele ('''Console''')
#Zona <span style="color: green">verde</span> - Conţine comenzile pentru controlul execuţiei în modul debug (comenzi numite '''stepping actions'''):
#*'''Step over''' [[Fișier:CLion_step_over.png | 16px]] - Execută comenzile de pe linia curentă şi trece la următoarea linie
#*'''Step into''' [[Fișier:CLion_step_into.png | 16px]] - Programul va executa linia curentă iar dacă pe linia curentă există un apel de funcție, se va opri pe prima linie din funcția respectivă. Această comandă este utilă atunci cand pe linia curentă se află un apel de funcţie şi vrem sa studiem comportamentul codului din interiorul funcţiei.
#*'''Step out''' [[Fișier:CLion_step_out.png | 16px]] - Termină de executat funcţia în care se află linia curentă
#*'''Run to cursor''' [[Fișier:CLion_run_to_cursor.png | 16px]] - Execută toate instructiunile până se intâlneste cursorul.

<div class="regula"> ''' Observație: ''' În modul debug, linia curentă este marcată de către mediul de dezvoltare prin colorarea acesteia cu albastru.</div>

Alte comenzi utile:
*'''Resume program''' [[Fișier:CLion_resume_project.png | 16px]] - Continuă execuţia pâmă la următorul breakpoint (dacă nu există, se va executa până la final)
*'''Stop''' [[Fișier:CLion_stop.png | 16px]] - Se opreşte definitv execuţia programului, împreună cu modul debug

[[Fișier:CLion_debug_process.png | 1000px | Imaginea 5]]

Fișier:CLion stop.png

2020-09-19T14:16:42Z

Costin.vasile1003:

Fișier:CLion resume project.png

2020-09-19T14:16:29Z

Costin.vasile1003:

Fișier:CLion debug process.png

2020-09-19T13:42:31Z

Costin.vasile1003:

Fișier:CLion step over.png

2020-09-19T13:38:45Z

Costin.vasile1003:

Fișier:CLion step out.png

2020-09-19T13:38:38Z

Costin.vasile1003:

Fișier:CLion step into.png

2020-09-19T13:38:29Z

Costin.vasile1003:

Fișier:CLion run to cursor.png

2020-09-19T13:38:17Z

Costin.vasile1003:

Fișier:CLion breakpoint.png

2020-09-19T08:14:45Z

Costin.vasile1003:

Fișier:CLion breakpoint.gif

2020-09-19T08:06:41Z

Costin.vasile1003:

C++ POO Lab Lucrarea 1

2020-09-18T20:30:12Z

Costin.vasile1003: Intro CLion

Fișier:CLion debug button.png

2020-09-18T19:57:59Z

Costin.vasile1003:

Fișier:CLion build button.png

2020-09-18T19:56:22Z

Costin.vasile1003:

Fișier:CLion run button.png

2020-09-18T19:54:43Z

Costin.vasile1003:

Fișier:CLion env.png

2020-09-18T19:36:29Z

Costin.vasile1003:

Fișier:New project location clion.png

2020-09-18T18:57:46Z

Costin.vasile1003:

Fișier:Welcome to clion.png

2020-09-18T18:56:51Z

Costin.vasile1003: