Show page
Recent changes

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

poo-is-ab:laboratoare:01 [2025/01/11 11:54]
razvan.cristea0106 [Diferențe C/C++] 		poo-is-ab:laboratoare:01 [2025/11/20 14:06] (current)
razvan.cristea0106
Line 1: Line 1:
-===== Laborator 01 - Recapitulare ​=====+===== Laborator 01 - Asemănări C/C++ =====
  
 **Autor: Răzvan Cristea** **Autor: Răzvan Cristea**
Line 7: Line 7:
 Studentul va fi capabil la finalul acestui laborator să: Studentul va fi capabil la finalul acestui laborator să:
  
-  * recunoască ​diferențele ​dintre limbajele C și C+++  * recunoască ​asemănările ​dintre limbajele C și C++
   * scrie un program simplu în limbajul C++   * scrie un program simplu în limbajul C++
 +  * utilizeze comenzi elementare de git în terminal
 +  * creeze un repository pe contul personal de GitHub
  
 ==== Introducere ==== ==== Introducere ====
  
-În acest laborator vom face o scurtă recapitulare a noțiunilor de bază învățate în anul întâi la disciplina **Programarea Calculatoarelor și Limbaje de Programare (PCLP)** și vom vedea care sunt diferențele ​în linii mari dintre limbajele C și C++. Noi vom scrie programe în C++ pe întreg parcursul acestui semestru, deoarece vom învăța o nouă paradigmă de programare și anume cea **Orientată Obiect (OO)**.+În acest laborator vom face o scurtă recapitulare a noțiunilor de bază învățate în anul întâi la disciplina **Programarea Calculatoarelor și Limbaje de Programare (PCLP)** și vom vedea care sunt asemănările ​în linii mari dintre limbajele C și C++. Noi vom scrie programe în C++ pe întreg parcursul acestui semestru, deoarece vom învăța o nouă paradigmă de programare și anume cea **Orientată Obiect (OO)**.
  
 ==== Scurt Istoric ==== ==== Scurt Istoric ====
Line 22: Line 24:
 ==== Asemănări C/C++ ==== ==== Asemănări C/C++ ====
  
-În continuare, vom explora ​asemănările dintre cele două limbaje de programare, ilustrând ​aceste ​similarități prin exemple de cod concrete.+În continuare, vom descoperi ​asemănările dintre cele două limbaje de programare, ilustrând similaritățile dintre acestea ​prin exemple de cod concrete.
  
 === Declararea și initializarea variabilelor === === Declararea și initializarea variabilelor ===
Line 31: Line 33:
 int main() int main()
 { {
- int x = 3; // variabila de tip intreg +    ​int x = 3; // variabila de tip intreg 
- float nr = 3.5f; // variabila de tip float +    float nr = 3.5f; // variabila de tip float 
- double y = 10.6; // variabila de tip double +    double y = 10.6; // variabila de tip double 
- char c = '​q';​ // variabila de tip caracter +    char c = '​q';​ // variabila de tip caracter 
- long w = 1000000000; // variabila de tip long+    long w = 1000000000; // variabila de tip long
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 43: Line 45:
 === Operații cu variabile === === Operații cu variabile ===
  
-La fel ca în C, în C++ putem face aceleași operații cu tipurile de date existente precum adunări, scăderi, înmulțiri,​ împărțiri etc. Operatorii existenți în C++ sunt **identici** cu cei din C.+La fel ca în C, în C++ putem face aceleași operații cu tipurile de date existente precum: **adunări**, **scăderi**, **înmulțiri**, **împărțiri** etc. Operatorii existenți în C++ sunt **identici** cu cei din C.
  
 <code cpp> <code cpp>
 int main() int main()
 { {
- int a = 8; +    ​int a = 8; 
- int b = 5;+    int b = 5;
  
- int suma = a + b; +    ​int suma = a + b; 
- int produs = a * b; +    int produs = a * b; 
- int diferenta = a - b;+    int diferenta = a - b;
  
- float impartire = (float) a / b; // va avea valoarea 1.6 +    ​float impartire = (float)a / b; // va avea valoarea 1.6 
- int rest = a % b; // calculam restul impartirii lui a la b+    int rest = a % b; // calculam restul impartirii lui a la b
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 66: Line 68:
 === Instrucțiunile decizionale și cele repetitive === === Instrucțiunile decizionale și cele repetitive ===
  
-În C++ regăsim toate instrucțiunile de bază ale limbajului C. Ca **instrucțiuni decizionale** amintim **if else** și **switch**, iar ca **instrucțiuni repetitive** menționăm buclele **for**, **while** și **do while**+În C++ regăsim toate instrucțiunile de bază ale limbajului C. Ca **instrucțiuni decizionale** amintim **if-else** și **switch**, iar ca **instrucțiuni repetitive** menționăm buclele **for**, **while** și **do while**
  
 == Instrucțiuni decizionale == == Instrucțiuni decizionale ==
Line 73: Line 75:
  
 <code cpp> <code cpp>
-if (conditie1) ​+if (conditie1)
 { {
- // bloc de cod+    ​// bloc de cod
 } }
 else if (conditie2) else if (conditie2)
 { {
-        ​// bloc de cod+    ​// bloc de cod
 } }
 else if (conditie3) else if (conditie3)
 { {
-        ​// bloc de cod+    ​// bloc de cod
 } }
 ... ...
 else else
 { {
-        ​// bloc de cod+    ​// bloc de cod
 } }
 </​code>​ </​code>​
  
-Să luăm ca exemplu verificarea parității unui număr. ​Sțim că un număr este par dacă restul împărțirii lui la 2 este egal cu 0.+Să luăm ca exemplu verificarea parității unui număr. ​Știm că un număr este par dacă restul împărțirii lui la 2 este egal cu 0.
  
 <code cpp> <code cpp>
 int main() int main()
 { {
- int x = 13; +    ​int x = 13; 
- int estePar = -1; // variabila care are valoarea 0 daca numarul este impar si 1 daca este par+    int estePar = -1; // variabila care are valoarea 0 daca numarul este impar si 1 daca este par
  
- if (x % 2 == 0) +    ​if (x % 2 == 0) 
- { +    { 
- estePar = 1; +        estePar = 1; 
- } +    } 
- else  +    else 
- { +    { 
- estePar = 0; +        estePar = 0; 
- }+    }
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 137: Line 139:
 int main() int main()
 { {
- int n = 4;+    ​int n = 4;
  
- switch (n) +    ​switch (n) 
- { +    { 
- case 0: +    case 0: 
- n++; +        n++; 
- break;+        break;
  
- case 1: +    ​case 1: 
- n = n * 5 + 1; +        n = n * 5 + 1; 
- break;+        break;
  
- case 2: +    ​case 2: 
- n--; +        n--; 
- break;+        break;
  
- case 3: +    ​case 3: 
- n *= 5; +        n *= 5; 
- break;+        break;
  
- case 4: +    ​case 4: 
- n = n - 2 + n++ + n * 2; +        n = n - 2 + n++ + n * 2; 
- break;+        break;
  
- default: +    ​default: 
- n = 0; +        n = 0; 
- break; +        break; 
- }+    }
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 179: Line 181:
 for (start; conditie de continuare; pas) for (start; conditie de continuare; pas)
 { {
- // bloc de cod care se execută+    ​// bloc de cod care se execută
 } }
 </​code>​ </​code>​
Line 188: Line 190:
 int main() int main()
 { {
- int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; +    ​int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; 
- int nrElemente = 8;+    int nrElemente = 8;
  
- for (int index = 0; index < nrElemente; index++) +    ​for (int index = 0; index < nrElemente; index++) 
- { +    { 
- vector[index] += 5; // echivalent cu a scrie vector[index] = vector[index] + 5; +        vector[index] += 5; // echivalent cu a scrie vector[index] = vector[index] + 5; 
- }+    }
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 202: Line 204:
 Se poate observa că a fost declarat un vector care are capacitatea de 10 elemente din care am ocupat doar primele 8 poziții. Vom reaminti mai târziu de ce această variantă nu este chiar cea mai potrivită atunci când vom menționa despre alocarea dinamică a memoriei. Se poate observa că a fost declarat un vector care are capacitatea de 10 elemente din care am ocupat doar primele 8 poziții. Vom reaminti mai târziu de ce această variantă nu este chiar cea mai potrivită atunci când vom menționa despre alocarea dinamică a memoriei.
  
-Instrucțiunea **while** oferă funcționalități similare cu cele ale instrucțiunii for, însă diferă prin faptul că utilizează un singur parametru, care reprezintă o **expresie logică** evaluată la fiecare iterație a buclei. Această expresie servește drept condiție de continuare a buclei, similar cu condiția de continuare din bucla for. Bucla **while** va continua să se execute atât timp cât această condiție este **adevărată**.+Instrucțiunea **while** oferă funcționalități similare cu cele ale instrucțiunii ​**for**, însă diferă prin faptul că utilizează un singur parametru, care reprezintă o **expresie logică** evaluată la fiecare iterație a buclei. Această expresie servește drept condiție de continuare a buclei, similar cu condiția de continuare din bucla for. Bucla **while** va continua să se execute atât timp cât această condiție este **adevărată**.
  
 Forma generală a buclei while Forma generală a buclei while
Line 209: Line 211:
 while (expresie) while (expresie)
 { {
- // bloc de cod care se execută+    ​// bloc de cod care se execută
 } }
 </​code>​ </​code>​
Line 218: Line 220:
 int main() int main()
 { {
- int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; +    ​int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; 
- int nrElemente = 8;+    int nrElemente = 8;
  
- int index = 0;+    ​int index = 0;
  
- while (index != nrElemente) +    ​while (index != nrElemente) 
- { +    { 
- vector[index] += 5; +        vector[index] += 5; 
- index++; +        index++; 
- }+    }
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
  
-Instrucțiunea **do-while** este o variantă a buclei **while**, cu o diferență esențială:​ în bucla **do-while**,​ condiția de verificare este evaluată **după** ce codul din interiorul buclei a fost executat, **nu** înainte. Aceasta înseamnă că blocul de cod din bucla **do-while** va fi executat cel puțin **o dată**, indiferent ​dacă condiția este adevărată sau falsă.+Instrucțiunea **do-while** este o variantă a buclei **while**, cu o diferență esențială:​ în bucla **do-while**,​ condiția de verificare este evaluată **după** ce codul din interiorul buclei a fost executat, **nu** înainte. Aceasta înseamnă că blocul de cod din bucla **do-while** va fi executat cel puțin **o dată**, indiferent ​de valoare de adevăr a expresiei din clauza while.
  
 Forma generală a instrucțiunii do-while Forma generală a instrucțiunii do-while
Line 249: Line 251:
 int main() int main()
 { {
- int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; +    ​int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; 
- int nrElemente = 8;+    int nrElemente = 8;
  
- int index = 0;+    ​int index = 0;
  
- do +    ​do 
- { +    { 
- vector[index] += 5; +        vector[index] += 5; 
- index++; +        index++; 
- } while (index != nrElemente);​+    } while (index != nrElemente);​
  
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 275: Line 277:
 int main() int main()
 { {
- int x = 8;+    ​int x = 8;
  
- for ( ; ; ) +    ​for ( ; ; ) 
- { +    { 
- x = x * 10; +        x = x * 10; 
- }+    }
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 297: Line 299:
 int main() int main()
 { {
- int x = 10; +    ​int x = 10; 
- int* ptr = &x;+    int* ptr = &x;
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 315: Line 317:
 int main() int main()
 { {
- int x = 10; +    ​int x = 10; 
- int y = 2;+    int y = 2;
  
- int* ptr = &x, & y; // eroare de compilare un pointer nu poate arata catre 2 adrese simultan+    ​int* ptr = &x, & y; // eroare de compilare un pointer nu poate arata catre 2 adrese simultan
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 328: Line 330:
 {{ :​poo-is-ab:​laboratoare:​incorrect_pointer_logic.jpg |}} {{ :​poo-is-ab:​laboratoare:​incorrect_pointer_logic.jpg |}}
  
-Trebuie însă înțeles faptul că această situație **nu** este permisă și **nu** are sens. E ca și cum ați vrea să arătați **simultan** cu **același deget** spre două persoane **diferite** ceea ce este fizic **imposibil**.+Trebuie însă înțeles faptul că această situație **nu** este permisă și **nu** are sens. E ca și cum vă doriți să arătați **simultan** cu **același deget** spre două persoane **diferite** ceea ce este fizic **imposibil**.
  
 În schimb situația următoare este permisă și complet validă. În schimb situația următoare este permisă și complet validă.
Line 345: Line 347:
 </​code>​ </​code>​
  
-Dacă un pointer arată către adresa de memorie a unei variabile, cum putem accesa totuși valoarea de la acea adresă spre care pointează pointerul nostru? Răspunsul este unul foarte simplu și anume printr-o operație specifică pointerilor cunoscută sub numele de __**dereferențiere**__.+Dacă un pointer arată către adresa de memorie a unei variabile, cum putem accesa totuși valoarea de la acea adresă spre care pointează pointerul nostru? Răspunsul este unul foarte simplu și anume printr-o operație specifică pointerilor cunoscută sub numele de **dereferențiere**.
  
 <code cpp> <code cpp>
 int main() int main()
 { {
- int x = 10; +    ​int x = 10; 
- int* ptr = &x; // declararea unei variabile de tip pointer la int si initializarea acesteia cu adresa lui x+    int* ptr = &x; // declararea unei variabile de tip pointer la int si initializarea acesteia cu adresa lui x 
 +    int y = *ptr; // dereferentierea pointerului ptr si stocarea valorii in variabila y (echivalent cu a scrie direct int y = x;)
  
- int y = *ptr; // dereferentierea pointerului ptr si stocarea valorii in variabila y (echivalent cu a scrie direct int y = x;) +    ​return 0;
- +
- return 0;+
 } }
 </​code>​ </​code>​
Line 366: Line 367:
 int main() int main()
 { {
- int x = 10; +    ​int x = 10; 
- int* ptr = &x;+    int* ptr = &x;
  
- *ptr = 4; +    ​*ptr = 4; 
- x -= 2; +    x -= 2; 
- *ptr *= 2; +    *ptr *= 2; 
- *ptr += 10;+    *ptr += 10;
  
-        ​// care este valoarea lui x dupa ce s-au executat toate liniile de mai sus+    ​// care este valoarea lui x dupa ce s-au executat toate liniile de mai sus
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 385: Line 386:
 int main() int main()
 { {
- int* ptr = NULL; +    ​int* ptr = NULL; 
- +    return 0;
- return 0;+
 } }
 </​code>​ </​code>​
Line 406: Line 406:
   - **lista de parametri**   - **lista de parametri**
  
-<​note>​A doua componentă împreună cu cea de a treia sunt cunoscute și sub denumirea de __**semnătură a funcției**__.</​note>​+<​note>​A ​**doua** componentă împreună cu cea de a **treia** sunt cunoscute și sub denumirea de **semnătură a funcției**.</​note>​
  
-Dacă îmbinăm cele 3 componente ​o funcție în pseudocod poate arăta ​așa -> return_type name(parameters)+Dacă îmbinăm cele 3 componente ​putem constata ca forma generală a unei funcții în C/C++ va arăta ​în felul următor ​-> **return_type name(parameters)**.
  
 În continuare vom vedea câteva exemple de declarări pentru funcții definite de către programator. În continuare vom vedea câteva exemple de declarări pentru funcții definite de către programator.
Line 467: Line 467:
  
     int dif = diferenta(x,​ y);     int dif = diferenta(x,​ y);
- 
     return 0;     return 0;
 } }
Line 490: Line 489:
  
     interschimbare(x,​ y); // interschimbarea se realizeaza doar la nivelul functiei (x = 5, y = 21)     interschimbare(x,​ y); // interschimbarea se realizeaza doar la nivelul functiei (x = 5, y = 21)
- 
     return 0;     return 0;
 } }
Line 524: Line 522:
  
     interschimbare(&​x,​ &y); // modificarile se vor rasfrange asupra lui x si y (x = 21, y = 5)     interschimbare(&​x,​ &y); // modificarile se vor rasfrange asupra lui x si y (x = 21, y = 5)
- 
     return 0;     return 0;
 } }
Line 538: Line 535:
 void afisareVector(int* v, int* n) void afisareVector(int* v, int* n)
 { {
- for (int index = 0; index < *n; index++) +    ​for (int index = 0; index < *n; index++) 
- { +    { 
- std::cout << v[index] << " "; +        std::cout << v[index] << " "; 
- }+    }
 } }
  
 int main() int main()
 { {
- int nrElemente = 10; +    ​int nrElemente = 10; 
- int vec[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };+    int vec[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  
- afisareVector(vec,​ &​nrElemente);​ // sau un apel echivalent afisareVector(&​vec[0],​ &​nrElemente);​ +    ​afisareVector(vec,​ &​nrElemente);​ // sau un apel echivalent afisareVector(&​vec[0],​ &​nrElemente);​ 
- +    return 0;
- return 0;+
 } }
 </​code>​ </​code>​
Line 568: Line 564:
 void func() void func()
 { {
- // bloc de cod+    ​// bloc de cod
 } }
  
 int main() int main()
 { {
- std::cout << func << '​\n';​ +    ​std::cout << func << '​\n';​ 
- +    return 0;
- return 0;+
 } }
 </​code>​ </​code>​
Line 581: Line 576:
 Practic, numele funcției reprezintă adresa din memorie unde este stocată acea funcție. Cu alte cuvinte, atunci când folosim numele funcției, accesăm automat locația sa din memorie, ceea ce permite atribuirea adresei acesteia unui **pointer la funcție**. Practic, numele funcției reprezintă adresa din memorie unde este stocată acea funcție. Cu alte cuvinte, atunci când folosim numele funcției, accesăm automat locația sa din memorie, ceea ce permite atribuirea adresei acesteia unui **pointer la funcție**.
  
-Rețeta cea mai simplă pentru declararea unui **function pointer** este următoarea -> **return_type (*name)(parameters)**+Rețeta cea mai simplă pentru declararea ​corectă a unui **function pointer** ​în C/C++ este următoarea -> **return_type (*name)(parameters)**.
  
-Să construim ​un **function pointer** pentru funcția de la exemplul anterior.+În continuare vom construi ​un **function pointer** pentru funcția de la exemplul anterior.
  
 <code cpp> <code cpp>
Line 590: Line 585:
 void func() void func()
 { {
- // bloc de cod+    ​// bloc de cod
 } }
  
 int main() int main()
 { {
- void (*functionPtr)() = func; // declararea si initializarea unui function pointer cu adresa functiei func+    ​void (*functionPtr)() = func; // declararea si initializarea unui function pointer cu adresa functiei func
  
- std::cout << func << '​\n';​ +    ​std::cout << func << '​\n';​ 
- std::cout << functionPtr << '​\n';​ // afiseaza aceeasi adresa cu cea de la linia anterioara+    std::cout << functionPtr << '​\n';​ // afiseaza aceeasi adresa cu cea de la linia anterioara
  
- return 0;+    ​return 0;
 } }
 </​code>​ </​code>​
Line 615: Line 610:
 void interschimbare(int* a, int* b) void interschimbare(int* a, int* b)
 { {
- if (a == NULL || b == NULL) +    ​if (a == NULL || b == NULL) 
- { +    { 
- return; +        return; 
- }+    }
  
- int auxiliar = *a; +    ​int auxiliar = *a; 
- *a = *b; +    *a = *b; 
- *b = auxiliar;+    *b = auxiliar;
 } }
  
 void sortareVectorCrescator(int* vector, int* nrElemente) void sortareVectorCrescator(int* vector, int* nrElemente)
 { {
- for (int i = 0; i < *nrElemente - 1; i++) +    ​for (int i = 0; i < *nrElemente - 1; i++) 
- { +    { 
- for (int j = i + 1; j < *nrElemente;​ j++) +        for (int j = i + 1; j < *nrElemente;​ j++) 
- { +        { 
- if (vector[i] > vector[j]) +            if (vector[i] > vector[j]) 
- { +            { 
- interschimbare(&​vector[i],​ &​vector[j]);​ +                interschimbare(&​vector[i],​ &​vector[j]);​ 
- } +            } 
- } +        } 
- }+    }
 } }
  
 void sortareVectorDescrescator(int* vector, int* nrElemente) void sortareVectorDescrescator(int* vector, int* nrElemente)
 { {
- for (int i = 0; i < *nrElemente - 1; i++) +    ​for (int i = 0; i < *nrElemente - 1; i++) 
- { +    { 
- for (int j = i + 1; j < *nrElemente;​ j++) +        for (int j = i + 1; j < *nrElemente;​ j++) 
- { +        { 
- if (vector[i] < vector[j]) +            if (vector[i] < vector[j]) 
- { +            { 
- interschimbare(&​vector[i],​ &​vector[j]);​ +                interschimbare(&​vector[i],​ &​vector[j]);​ 
- } +            } 
- } +        } 
- }+    }
 } }
  
 void afisareVector(int* vector, int* nrElemente) void afisareVector(int* vector, int* nrElemente)
 { {
- for (int index = 0; index < *nrElemente;​ index++) +    ​for (int index = 0; index < *nrElemente;​ index++) 
- { +    { 
- std::cout << vector[index] << ' '; +        std::cout << vector[index] << ' '; 
- }+    }
  
- std::cout << '​\n';​+    ​std::cout << '​\n';​
 } }
  
 int main() int main()
 { {
- int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 }; +    ​int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 }; 
- int nrElemente = 10;+    int nrElemente = 10;
  
- std::cout << "​Vectorul sortat crescator este: ";+    ​std::cout << "​Vectorul sortat crescator este: ";
  
- sortareVectorCrescator(vector,​ &​nrElemente);​ +    ​sortareVectorCrescator(vector,​ &​nrElemente);​ 
- afisareVector(vector,​ &​nrElemente);​+    afisareVector(vector,​ &​nrElemente);​
  
- std::cout << "​\nVectorul sortat descrescator este: ";+    ​std::cout << "​\nVectorul sortat descrescator este: ";
  
- sortareVectorDescrescator(vector,​ &​nrElemente);​ +    ​sortareVectorDescrescator(vector,​ &​nrElemente);​ 
- afisareVector(vector,​ &​nrElemente);​+    afisareVector(vector,​ &​nrElemente);​
  
- +    ​return 0;
- return 0;+
 } }
 </​code>​ </​code>​
Line 690: Line 684:
 void interschimbare(int* a, int* b) void interschimbare(int* a, int* b)
 { {
- if (a == NULL || b == NULL) +    ​if (a == NULL || b == NULL) 
- { +    { 
- return; +        return; 
- }+    }
  
- int auxiliar = *a; +    ​int auxiliar = *a; 
- *a = *b; +    *a = *b; 
- *b = auxiliar;+    *b = auxiliar;
 } }
  
 bool ordonareCrescatoare(int a, int b) bool ordonareCrescatoare(int a, int b)
 { {
- return a < b;+    ​return a < b;
 } }
  
 bool ordonareDescrescatoare(int a, int b) bool ordonareDescrescatoare(int a, int b)
 { {
- return a > b;+    ​return a > b;
 } }
  
 void sortareVector(int* vector, int* nrElemente, bool (*comparator)(int,​ int)) void sortareVector(int* vector, int* nrElemente, bool (*comparator)(int,​ int))
 { {
- for (int i = 0; i < *nrElemente - 1; i++) +    ​for (int i = 0; i < *nrElemente - 1; i++) 
- { +    { 
- for (int j = i + 1; j < *nrElemente;​ j++) +        for (int j = i + 1; j < *nrElemente;​ j++) 
- { +        { 
- if (comparator(vector[i],​ vector[j]) == false) +            if (comparator(vector[i],​ vector[j]) == false) 
- { +            { 
- interschimbare(&​vector[i],​ &​vector[j]);​ +                interschimbare(&​vector[i],​ &​vector[j]);​ 
- } +            } 
- } +        } 
- }+    }
 } }
  
 void afisareVector(int* vector, int* nrElemente) void afisareVector(int* vector, int* nrElemente)
 { {
- for (int index = 0; index < *nrElemente;​ index++) +    ​for (int index = 0; index < *nrElemente;​ index++) 
- { +    { 
- std::cout << vector[index] << ' '; +        std::cout << vector[index] << ' '; 
- }+    }
  
- std::cout << '​\n';​+    ​std::cout << '​\n';​
 } }
  
 int main() int main()
 { {
- int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 }; +    ​int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 }; 
- int nrElemente = 10;+    int nrElemente = 10;
  
- std::cout << "​Vectorul sortat crescator este: ";+    ​std::cout << "​Vectorul sortat crescator este: ";
  
- sortareVector(vector,​ &​nrElemente,​ ordonareCrescatoare);​ +    ​sortareVector(vector,​ &​nrElemente,​ ordonareCrescatoare);​ 
- afisareVector(vector,​ &​nrElemente);​+    afisareVector(vector,​ &​nrElemente);​
  
- std::cout << "​\nVectorul sortat descrescator este: ";+    ​std::cout << "​\nVectorul sortat descrescator este: ";
  
- sortareVector(vector,​ &​nrElemente,​ ordonareDescrescatoare);​ +    ​sortareVector(vector,​ &​nrElemente,​ ordonareDescrescatoare);​ 
- afisareVector(vector,​ &​nrElemente);​+    afisareVector(vector,​ &​nrElemente);​
  
- +    ​return 0;
- return 0;+
 } }
 </​code>​ </​code>​
Line 760: Line 753:
 === Variabile constante === === Variabile constante ===
  
-La fel ca în C, în C++ putem declara variabile constante folosind cuvântul cheie **const**. Așa cum le spune și numele variabilele constante sunt cele care odată inițializate cu o valoare **nu** mai pot fi modificate.+La fel ca în C, în C++ putem declara variabile constante folosind cuvântul cheie **const**. Așa cum le spune și numele variabilele constante sunt acea categorie de variabile ​care odată ​ce au fost inițializate cu o valoare **nu** mai pot fi modificate ​ulterior.
  
-<note warning>​O variabilă constantă se ințializează pe linia unde a fost **declarată** altfel va genera o eroare de compilare</​note>​+<note warning>​O ​**variabilă constantă** se ințializează pe linia unde a fost **declarată** altfel va genera o eroare de compilare.</​note>​
  
 == Utilizarea keyword-ului const pe variabile obișnuite == == Utilizarea keyword-ului const pe variabile obișnuite ==
Line 771: Line 764:
 int main() int main()
 { {
- const float pi = 3.14f; // variabila constanta corect declarata +    ​const float pi = 3.14f; // variabila constanta corect declarata 
- const double k; // eroare de compilare variabila constanta este neinitializata+    /* float const pi = 3.14f // era de asemenea corect, fiind doar o alta forma de scriere */ 
 +    ​const double k; // eroare de compilare variabila constanta este declarata dar neinitializata
  
- int a = 2; +    ​int a = 2; 
- int b = 3;+    int b = 3;
  
- const int suma = a + b; // corect+    ​const int suma = a + b; // corect 
 +    suma = 20; // incorect, o variabila constanta nu mai poate fi modificata dupa ce a fost declarata si initializata
  
- suma = 20; // incorect, o variabila constanta nu mai poate fi modificata dupa declarare si initializare +    ​return 0;
- +
- return 0;+
 } }
 </​code>​ </​code>​
Line 794: Line 787:
     int a = 2;     int a = 2;
     int b = 3;     int b = 3;
 +
 +    // Situatia 1
  
     // Pointer la un int, dar pointerul nu poate modifica valoarea la care pointeaza     // Pointer la un int, dar pointerul nu poate modifica valoarea la care pointeaza
Line 802: Line 797:
     // P2 este un pointer la un int constant (valoarea la care pointeaza nu poate fi modificata prin intermediul lui p2)     // P2 este un pointer la un int constant (valoarea la care pointeaza nu poate fi modificata prin intermediul lui p2)
     int const* p2 = &b;     int const* p2 = &b;
 +
 +    // Situatia 2
 +
 +    // Pointer constant la un int
 +    // P3 este un pointer constant la un int (pointerul in sine nu poate fi schimbat, dar valoarea la care pointeaza poate fi modificata)
 +    int* const p3 = &a;
 +
 +    // Situatia 3
  
     // Pointer constant la un int constant     // Pointer constant la un int constant
-    // P3 este un pointer constant la un int constant si pointerul ​în sine nu poate fi schimbat (nu poate pointa catre alta adresa) +    // P3 este un pointer constant la un int constant si pointerul ​in sine nu poate fi schimbat (nu poate pointa catre alta adresa) 
-    const int* const p3 = &a;+    const int* const p4 = &a;
  
-    // Efectiv aceeași declaratie ca p3, dar cu sintaxa diferita +    // Efectiv aceeași declaratie ca p4, dar cu sintaxa diferita 
-    // P3 este un pointer constant la un int constant si pointerul ​în sine nu poate fi schimbat +    // P4 este un pointer constant la un int constant si pointerul ​in sine nu poate fi schimbat 
-    int const* const p4 = &a;+    int const* const p5 = &a;
  
     *p1 = 5; // eroare de compilare     *p1 = 5; // eroare de compilare
-    p1 = &b; // corect+    p1 = &b; // valid
  
     *p2 = *p1; // eroare de compilare     *p2 = *p1; // eroare de compilare
     p2 = p1; // valid     p2 = p1; // valid
  
-    *p3 = 50; // eroare de compilare +    *p3 = *p2; // valid 
-    p3 = p2; // eroare de compilare+    p3 = &b; // eroare de compilare
  
-    p4 = p1; // eroare de compilare +    ​*p4 = 50; // eroare de compilare 
-    *p4 = 10; // eroare de compilare+    p4 = p2; // eroare de compilare 
 + 
 +    p5 = p1; // eroare de compilare 
 +    *p5 = 10; // eroare de compilare
  
     return 0;     return 0;
Line 831: Line 837:
 Este similar cu ceea ce ați văzut în cele 2 situații pentru variabile și pentru pointeri. Reluați exemplele de cod de mai sus care conțin funcții și încercați să vă dați seama unde ar fi necesar ca subprogramele să aibă parametrii constanți. Este similar cu ceea ce ați văzut în cele 2 situații pentru variabile și pentru pointeri. Reluați exemplele de cod de mai sus care conțin funcții și încercați să vă dați seama unde ar fi necesar ca subprogramele să aibă parametrii constanți.
  
-==== Diferențe C/C++ ====+==== GIT și GitHub ​====
  
-=== Citirea ​și afișarea variabilelor ===+**GIT** este un sistem de control al versiunilor distribuit, dezvoltat de **Linus Torvalds** în 2005 pentru a gestiona kernel-ul Linux. În prezent, este cel mai folosit sistem de versionare, iar împreună cu platforma **GitHub** oferă un cadru complet pentru dezvoltare colaborativă,​ versionare ​și backup al proiectelor software.
  
-În C erați obișnuiți ​să citiți ​și să afișați variabilele utilizând funcțiile **scanf** și **printf**. În C++ vom folosi operatorul **>>​** pentru citire și operatorul **<<​** pentru afișare.+=== De ce să folosim Git și GitHub? ===
  
-== Citirea ​și afișarea în C ==+  * **Lucru colaborativ** – mai mulți programatori pot contribui la același proiect. 
 +  * **Backup pentru cod** – fiecare clonă locală conține întregul istoric. 
 +  * **Istoricul modificărilor** – putem reveni oricând la o versiune anterioară. 
 +  * **Gestionarea branch-urilor** – dezvoltare paralelă ​și integrare prin **merge**. 
 +  * **Integrare cu unelte moderne** – paltforma GitHub permite **code review**, **issue tracking** și **CI/CD**.
  
-<code c> +=== Termeni specifici ===
-#include <​stdio.h>​+
  
-int main() +  * **Repository** – componenta ce conține ierarhia de fișiere și istoricul versiunilor. 
-{ +  * **Checkout** – descărcarea unei versiuni în mediul local. 
- int x;+  * **Working copy** – copia locală a proiectului în care lucrăm. 
 +  * **Commit** – publicarea în repository-ul local a modificărilor din working copy. 
 +  * **Push** – trimiterea modificărilor locale către repository-ul central ​(GitHub). 
 +  * **Pull** – actualizarea versiunii locale cu modificările de pe server și integrarea lor în branch-ul curent. 
 +  * **Fetch** – aducerea ultimelor modificări de pe server (remote) dar **fără a le integra automat** în branch-ul local. 
 +  * **Branch** – linie paralelă de dezvoltare. 
 +  * **Merge** – unirea a două sau mai multe ramuri de dezvoltare. 
 +  * **Conflict** – apare când mai mulți utilizatori modifică același fișier și Git nu poate decide singur ce variantă să păstreze. 
 +  * **Stash** – arhivează temporar modificările locale care nu sunt încă pregătite pentru commit, permițând schimbarea branch-ului sau actualizarea codului fără a pierde progresul. 
 +  * **Cherry-pick** – preluarea unui anumit commit dintr-un alt branch și aplicarea lui în branch-ul curent, fără a face un merge complet; util pentru a integra doar modificări specifice.
  
- printf("​Introduceti un numar: "); +=== Comenzi uzuale ===
- scanf("​%d",​ &x);+
  
- printf("​Numarul introdus de utilizator este: %d\n", x);+== Inițializarea unui repository ==
  
-        return 0; +<code bash> git init </​code>​
-} +
-</​code>​+
  
-== Citirea și afișarea în C++ ==+== Verificarea statusului ​==
  
-<​code ​cpp> +<​code ​bash> git status ​</code>
-#​include ​<iostream>+
  
-int main() +== Vizualizarea istoricului commit-urilor ==
-{ +
- int x;+
  
- std::​cout ​<< ​"​Introduceti un numar: "; ​// cout vine de la console output +<code bash> git log </code>
- std::​cin ​>> x; // cin vine de la console input+
  
- std::cout << "​Numarul introdus de utilizator este: " << x << '​\n';​+== Adăugarea și commit-ul modificărilor ==
  
- return 0; +<code bash> 
-}+git add . # adaugă toate fișierele modificate 
 +git add nume_fisier ​ # adaugă un singur fișier 
 +git commit -m "Mesaj pentru modificare"​
 </​code>​ </​code>​
  
-<​note>​Puteți folosi în C++ și funcțiile **scanf** și **printf** desigur, dar ca și recomandare ar fi mai indicat să utilizați operatorii limbajului C++, deoarece sunt mai specializați pentru ceea ce vom învăța ​pe parcursul semestrului.</​note>​+== Trimiterea modificărilor pe server (GitHub) ==
  
-=== Alocarea dinamică a memoriei === +<​code ​bash> 
- +git push # trimite modificările locale către branch-ul curent de pe remote 
-Ei bine aici clar există diferențe majore și le vom prezenta pe rând. +git push origin ​main # trimite explicit către branch-ul ​'main' ​de pe remote
- +
-== Alocare dinamică în C == +
- +
-Pentru a aloca dinamic în C ați folosit fie funcția **malloc** fie funcția **calloc**, singura diferență între ele fiind faptul că **calloc** initializează cu 0 valorile. Pentru eliberarea memoriei se folosește funcția **free**. +
- +
-<​code ​cpp> +
-#include <​iostream>​ +
- +
-int main() +
-{ +
- int* ptr1 = (int*)malloc(sizeof(int));​ +
- *ptr1 = 5; +
- +
- // sau folosind calloc +
- +
- int* ptr2 = (int*)calloc(1,​ sizeof(int));​ +
- +
- std::cout << *ptr2 << ​'\n'; +
- +
- *ptr2 = *ptr1; +
- +
- std::cout << *ptr1 << '​\n';​ +
- std::cout << *ptr2 << '​\n';​ +
- +
- free(ptr1);​ +
- free(ptr2);​ +
- +
- return 0; +
-}+
 </​code>​ </​code>​
  
-Dacă dorim să alocăm dinamic a un vector putem proceda în felul următor.+== Actualizarea repository-ului local ==
  
-<​code ​cpp> +<​code ​bash> 
-int main() +git fetch # aduce modificările de pe server, fără a le integra automat 
-{ +git pull # aduce și integrează modificările din branch-ul curent de pe server 
- int nrElemente = 5; +git pull origin main # aduce și integrează modificările din branch-ul main
- int* vector = (int*)malloc(nrElemente * sizeof(int));​ +
- +
- vector[0] = 3; +
- vector[1] = 2; +
- vector[2] = -2; +
- vector[3] = 10; +
- vector[4] = 8; +
- +
- std::cout << "​Vectorul alocat dinamic este: "; +
- +
- for (int i = 0; i < nrElemente; i++) +
- { +
- std::cout << vector[i] << ' '; +
- } +
- +
- free(vector);​ +
- +
- return 0; +
-}+
 </​code>​ </​code>​
  
-Iar dacă vrem să realocăm spațiul din vector folosim funcția **realloc**.+== Lucrul cu branch-uri ==
  
-<​code ​cpp> +<​code ​bash> 
-int main() +git branch # afișează branch-urile locale 
-{ +git branch -a # afișează toate branch-urile (locale și remote) 
- int nrElemente = 5; +git checkout nume_branch # schimbă branch-ul curent 
- int* vector = (int*)malloc(nrElemente * sizeof(int));​ +git branch -b nou_branch # creează un branch nou și trece pe el 
- +git merge branch_modificari # unirea unui branch în branch-ul curent
- vector[0] = 3; +
- vector[1] = 2; +
- vector[2] = -2; +
- vector[3] = 10; +
- vector[4] = 8; +
- +
- std::cout << "​Vectorul alocat dinamic este: "; +
- +
- for (int i = 0; i < nrElemente; i++) +
- { +
- std::cout << vector[i] << ' '; +
- } +
- +
- nrElemente = 8; +
- +
- vector = (int*)realloc(vector,​ nrElemente * sizeof(int));​ +
- +
- vector[5] = 15; +
- vector[6] = 20; +
- vector[7] = 25; +
- +
- std::cout << "​\nVectorul realocat dinamic este: "; +
- +
- for (int i = 0; i < nrElemente; i++) +
- { +
- std::cout << vector[i] << ' '; +
- } +
- +
- free(vector);​ +
- +
- return 0; +
-}+
 </​code>​ </​code>​
  
-== Alocare dinamică în C++ ==+== Cherry-pick ​==
  
-În C++ alocarea și dezalocarea memoriei sunt mai simple, deoarece aici **nu** mai avem **funcții** ci **operatori specifici**. Pentru a aloca memoria ​în C++ se folosește **operatorul new**, iar pentru a elibera memoria folosim **operatorul delete**.+<code bash> git cherry-pick <​commit_id>​ # aplică un commit specific din alt branch ​în branch-ul curent </​code>​
  
-**Alocarea dinamică pentru o singură adresă de memorie**+== Stash ==
  
-În exemplul de mai jos puteți vedea diferite variante de alocare și dezalocare pentru un singur spațiu de memorie. +<​code ​bash>  
- +git stash # salvează temporar modificările locale 
-<​code ​cpp> +git stash apply # reaplică ultimele modificări stashed 
-#include <​iostream>​ +git stash list # afișează lista modificărilor stashed 
- +git stash drop # șterge un stash specific ​
-int main() +
-{ +
- int* ptr1 = new int; // alocare dinamica fara initializare,​ compilatorul va atribui o valoare in mod aleator +
- int* ptr2 = new int(10); // alocare dinamica cu initializare +
- +
- std::cout << *ptr1 << '​\n';​ +
- std::cout << *ptr2 << '​\n';​ +
- +
- /*delete ptr1, ptr2; // desi nu da eroare de compilare va elibera doar spatiul pentru ptr1, nu se recomanda aceasta scriere pentru ca va genera memory leak-uri usor*/ +
- +
- delete ptr1; +
- delete ptr2; +
- +
-        return 0; +
-}+
 </​code>​ </​code>​
  
-<note warning>**Numărul** de delete-uri trebuie ​**să fie egal** cu **numărul** de new-uri.</note>+=== Pașii pe care îi urmăm pentru un proiect colaborativ ca și developeri === 
 +  
 +  ​* **Inițializăm** repository-ul local cu **git init** sau clonăm unul existent cu **git clone link_repo**. 
 +  * **Lucrăm** în working copy pentru a efectua modificări locale. 
 +  * **Adăugăm** modificările pregătite pentru commit ​cu **git add**. 
 +  * **Facem commit** cu modificările adăugate: ​**git commit -m "​Mesaj"​**. 
 +  * **Dacă avem modificări locale** care **nu** sunt gata pentru commit, le putem salva temporar cu **git stash**. 
 +  * **Transmitem** modificările pe server cu **git push**. 
 +  * **Actualizăm** repository-ul local cu ultimele schimbări: **git fetch**, **git pull**. 
 +  * **Lucrăm** pe branch-uri pentru dezvoltare paralelă și izolare modificări. 
 +  * **Pentru a integra** modificări specifice din alt branch, putem folosi **git cherry-pick ​<commit_id>**. 
 +  * **Rezolvăm** eventualele conflicte apărute la **merge** sau **pull**. 
 +  * **La final**, facem **merge** pentru a integra branch-urile de dezvoltare în branch-ul principal. 
 +  * **Verificăm** istoricul și starea proiectului cu **git log** și **git status** pentru claritate și control.
  
-**Alocarea dinamică pentru un bloc de memorie**+=== Ce ar trebui să facem? ===
  
-Dacă intenționăm să alocăm dinamic un vector în C++ vom folosi tot operatorul new, dar puțin diferit.+  - Să instalăm **Git** pe mașinile noastre 
 +  - Să avem sau să ne facem un cont pe platforma **GitHub** 
 +  - La **prima** utilizare după ce am instalat Git-ul trebuie să rulăm comenzile **git config %%--%%global user.name** și **git config %%--%%global user.email** 
 +  - Să ne setăm o cheie **ssh** conform instrucțiunilor de [[https://​www.youtube.com/​watch?​v=2kuG9ElVMhM|aici]].
  
-<code cpp> +==== ====
-#include <​iostream>​ +
- +
-int main() +
-{ +
- int nrElemente ​= 5; +
- int* vector ​= new int[nrElemente];​ // se folosesc [] pentru a anunta compilatorul ca vrem sa alocam spatiu pentru un bloc de memorie continuu +
- +
- for (int i = 0; i < nrElemente; i++) +
- { +
- std::cout << "​vector["​ << i << "​] ​= "; +
- std::cin >> vector[i];​ +
- } +
- +
- std::cout << "​\nElementele vectorului alocat sunt: "; +
- +
- for (int i = 0; i < nrElemente; i++) +
- { +
- std::cout << vector[i] << ' '; +
- } +
- +
- delete[] vector; // se folosesc [] pentru a anunta compilatorul ca ne dorim sa eliberam memoria unui bloc contiguu +
- +
-        return 0; +
-} +
-</​code>​ +
- +
-<note warning>​În C++ **nu** există operator pentru **realocarea memoriei**. **Nu** este recomandată utilizarea **funcției realloc** pe un vector care a fost alocat cu **operatorul new**, deoarece va duce la un comportament nedefinit. Dacă vrem să realocăm vectorul va trebui mai întâi să îl ștergem și apoi să îl realocăm cu noua dimensiune.</​note>​ +
- +
-<code cpp> +
-#include <​iostream>​ +
- +
-int main() +
-{ +
- int nrElemente ​= 6; +
- int* vector ​= new int[nrElemente];​ +
- +
- for (int i = 0; i < nrElemente; i++) +
- { +
- std::cout << "​vector["​ << i << "] = "; +
- std::cin >> vector[i];​ +
- } +
- +
- std::cout << "​\nElementele vectorului alocat sunt: "; +
- +
- for (int i = 0; i < nrElemente; i++) +
- { +
- std::cout << vector[i] << ' '; +
- } +
- +
- delete[] vector; +
- +
- nrElemente = 3; +
- +
- vector = new int[nrElemente];​ +
- +
- std::cout << "​\n\n===================================================\n\n";​ +
- +
- for (int i = 0; i < nrElemente; i++) +
- { +
- std::cout << "​vector["​ << i << "] = "; +
- std::cin >> vector[i];​ +
- } +
- +
- std::cout << "​\nElementele vectorului realocat sunt: "; +
- +
- for (int i = 0; i < nrElemente; i++) +
- { +
- std::cout << vector[i] << ' '; +
- } +
- +
- std::cout << '​\n';​ +
- +
- delete[] vector; +
- +
-        return 0; +
-} +
-</​code>​ +
- +
-=== Tipul referință === +
- +
-În C++, referințele reprezintă o extensie importantă a modului în care putem gestiona variabilele. O referință este, în esență, un **alias** pentru o variabilă existentă. Spre deosebire de un pointer, care stochează adresa unei variabile, o referință acționează direct asupra variabilei pe care o referențiază,​ fără a necesita acces explicit la adresa acesteia. +
- +
-Când atribuim o referință unei variabile, orice operație efectuată asupra referinței este de fapt aplicată direct asupra variabilei originale. Se comportă similar cu pointerii doar că există niște diferențe. +
- +
-  - Referința când este declarată trebuie **instant inițializată** +
-  - După inițializare referința **nu** mai poate fi schimbată +
-  - Referințele **nu** pot fi nule +
-  - Referințele **nu** trebuie dereferențiate +
- +
-<code cpp> +
-#include <​iostream>​ +
- +
-int main() +
-{ +
- int x = 10; +
- int& ref = x; +
- +
- ref = 16;  +
- +
- std::cout << x << '​\n';​ // x devine 16 deoarece ref este un alias pentru el +
- +
- x = 20; +
- +
- std::cout << ref << '​\n';​ // ref este 20 datorita faptului ca se refera la x +
- +
- int y = 0; +
- ref = y; // poate parea schimbarea referintei dar in realitate este doar atribuirea valorii 0 lui ref +
- +
- std::cout << x << '​\n';​ // x este 0 din motive evidente +
- +
-        return 0; +
-} +
-</​code>​ +
- +
-Pentru a înțelge mai bine, în desenul de mai jos se poate observa de fapt cine este **ref** și că nu face altceva decât să partajeze aceeași zonă de memorie ca și **x**. +
- +
-{{ :​poo-is-ab:​laboratoare:​reference_logic.jpg |}} +
- +
-Cu ajutorul acestui tip de date putem să ne facem viața mult mai ușoară, deoarece putem trimite parametrii unei funcții prin referință. +
- +
-<code cpp> +
-#include <​iostream>​ +
- +
-void alocareVector(int*&​ v, const int& dim) +
-{ +
- v = new int[dim]; +
-} +
- +
-void citireVector(int*&​ v, const int& dim) +
-{ +
- for (int i = 0; i < dim; i++) +
- { +
- std::cout << "​vector["​ << i << "] = "; +
- std::cin >> v[i]; +
- } +
-} +
- +
-void afisareVector(const int* const& v, const int& dim) +
-{ +
- std::cout << "​Elementele vectorului alocat sunt: "; +
- +
- for (int i = 0; i < dim; i++) +
- { +
- std::cout << v[i] << ' '; +
- } +
- +
- std::cout << '​\n';​ +
-} +
- +
-void dezalocareVector(int*&​ v) +
-{ +
- if (v != nullptr) +
- { +
- delete[] v; +
- } +
-} +
- +
-int main() +
-{ +
- int nrElemente = 5; +
- int* vector = nullptr; +
- +
- alocareVector(vector,​ nrElemente);​ +
- citireVector(vector,​ nrElemente);​ +
- afisareVector(vector,​ nrElemente);​ +
- dezalocareVector(vector);​ +
- +
-        return 0; +
-} +
-</​code>​ +
- +
-Funcțiile folosesc referințe la pointeri (de exemplu, int*& v) pentru a permite modificarea efectivă a pointerilor în funcția apelantă. Astfel, funcțiile pot aloca memorie sau modifica adresele pointerilor direct în cadrul funcției care le-a apelat, fără a returna un nou pointer. +
- +
-Parametrii transmiși ca referințe constante (de exemplu, const int& dim) sunt utilizați pentru a asigura că valoarea acestora nu este modificată în interiorul funcției, protejând astfel valorile originale. Acest lucru ajută la prevenirea modificărilor accidentale și la creșterea clarității. +
- +
-Funcția afisareVector folosește referințe constante la pointeri (const int* const& v), pentru a garanta că atât adresa vectorului, cât și conținutul acestuia nu vor fi modificate în timpul afișării, menținând integritatea datelor. +
- +
-<note important>​C++ introduce posibilitatea de a inițializa pointerii cu **nullptr**,​ care este specific doar pentru acest tip de date. Acesta funcționează similar cu **NULL**, dar cu un avantaj important: **nullptr** este un tip de date dedicat **pointerilor**,​ ceea ce previne atribuirea sa accidentală altor tipuri de variabile, cum se putea întâmpla cu **NULL** în C++. În C++, **NULL** este definit doar ca un **macro** care reprezintă valoarea 0 și poate fi atribuit chiar și variabilelor care nu sunt pointeri, lucru care poate duce la confuzii nedorite.</​note>​ +
- +
-<code cpp> +
-#include <​iostream>​ +
- +
-int main() +
-{ +
- int x = NULL; // valid +
- int* ptr = NULL; // valid +
- +
- ptr = nullptr; // valid +
- x = nullptr; // eroare de compilare x nu este un pointer +
- +
-        return 0; +
-} +
-</​code>​+
  
 +<note tip>
 +  * Pentru a descărca git-ul accesați site-ul următor: [[https://​git-scm.com/​downloads|Download Git]]
 +  * Pentru instalare git urmăriți acest tutorial: [[https://​www.youtube.com/​watch?​v=iYkLrXobBbA|Tutorial instalare Git]]
 +  * Pentru a vă crea un cont pe GitHub puteți urmări indicațiile de [[https://​youtu.be/​Gn3w1UvTx0A|aici]]
 +</​note>​
 ==== Concluzii ==== ==== Concluzii ====
  
-Am putut observa în cadrul acestui laborator ​care sunt **asemănările**, dar și **diferențele** în linii mari dintre C și C++. De acum înainte suntem pregătiți să explorăm **Paradigma Orientată Obiect** pe care o vom începe din laboratorul ​următor.+În cadrul acestui laborator ​am explorat ​asemănările ​dintre **C** și **C++** și am observat că ambele limbaje folosesc **aceeași sintaxă** de bază pentru **variabile**,​ **funcții** și **instrucțiuni**. De asemenea, am înțeles în mare ce sunt **Git** și **GitHub** și am învățat să **inițializăm** și să **clonăm** repository-uri,​ să lucrăm cu **branch-uri**,​ să facem **commit-uri** și să folosim comenzi precum **push** sau **pull**. În esență ​laboratorul ​și-a propus trecerea lină de la **C** la **C++** cât și pregătirea mediului de lucru pe partea de **Git** și **Github**.

Info Curs

Programare Orientată pe Obiecte

Cursuri

Laboratoare

Teme

Resurse

poo-is-ab/laboratoare/01.1736589247.txt.gz · Last modified: 2025/01/11 11:54 by razvan.cristea0106
Show pageOld revisions
Media ManagerBack to top
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0