Show page

Differences

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

--- poo-is-ab:laboratoare:01 [2024/09/13 17:44]
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**
@@ Line 7: / Line 7: @@
 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++
+  * utilizeze comenzi elementare de git în terminal
+  * creeze un repository pe contul personal de GitHub
 ==== Introducere ====
-În acest laborator vom face o scurtă recapitulare a noțiunilor de bază învățate în limbajul C ș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 ====
@@ Line 22: / Line 24: @@
 ==== 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 ===
@@ Line 31: / Line 33: @@
 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>
@@ Line 43: / Line 45: @@
 === 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 existeț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>
 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>
-<note important>Se observă că pe linia unde **a** se împarte la **b** este folosit un operator special numit operatorul de **cast explicit** care are menirea să convertească rezultatul împărtirii într-unul de tip float. Dacă variabila **a** era declarată ca //float// atunci nu mai era necesară folosirea operatorului de cast, rezultatul fiind calculat corect cu virgulă.</note>
+<note important>Se observă că pe linia unde valoarea variabilei **a** se împarte la cea a variabilei **b** este folosit un operator special numit operatorul de **cast explicit** care are menirea să convertească rezultatul împărțirii într-unul de tip **float**. Dacă variabila **a** era declarată ca **float** atunci **nu** mai era necesară folosirea **operatorului de cast**, rezultatul fiind calculat corect cu virgulă.</note>
 === 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ționam **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 ==
-Forma generală a instrucțiunii if-else
+Forma generală a instrucțiunii **if-else**
 <code cpp>
 if (conditie1)
 {
-	// bloc de cod
+    // bloc de cod
 }
 else if (conditie2)
 {
-        // bloc de cod
+    // bloc de cod
 }
 else if (conditie3)
 {
-        // bloc de cod
+    // bloc de cod
 }
 ...
 else
 {
-        // bloc de cod
+    // bloc de cod
 }
 </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>
 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>
-Instrucțiunea switch poate fi o alternativă mult mai elegantă atunci când vrem să înlocuim o secvență de instrucțiuni de forma if -> else if -> ... -> else. Deși pare o instrucțiune "demodată" aceasta este extrem de eficientă și de utilă atunci când ne dorim un cod rapid și ușor de citit.
+Instrucțiunea **switch** poate fi o alternativă mult mai elegantă atunci când vrem să înlocuim o secvență de instrucțiuni de forma **if -> else if -> ... -> else**. Deși pare o instrucțiune "demodată" aceasta este extrem de eficientă și de utilă atunci când ne dorim un cod rapid și ușor de citit.
 Forma generală a instrucțiunii swicth
@@ Line 137: / Line 139: @@
 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>
@@ Line 172: / Line 174: @@
 == Instrucțiuni repetitive ==
-Instrucțiunea for este prima instrucțiune repetitivă pe care o amintim. Ați folosit-o destul de mult la parcurgerea șirurilor de caractere, a vectorilor cât și a altor structuri de date învățate pe parcursul semestrului trecut la disciplina Proiectarea Algoritmilor.
+Instrucțiunea **for** este prima instrucțiune repetitivă pe care o amintim. Ați folosit-o destul de mult la parcurgerea șirurilor de caractere, a vectorilor cât și a altor structuri de date învățate pe parcursul semestrului trecut la disciplina **Proiectarea Algoritmilor**.
 Forma generală a instrucțiunii for
@@ Line 179: / Line 181: @@
 for (start; conditie de continuare; pas)
 {
-	// bloc de cod care se execută
+    // bloc de cod care se execută
 }
 </code>
-Pasul indică la ce iterație ne aflăm în bucla for și dacă este satisfăcută condiția de continuare. Putem lua ca exemplu de cod incrementarea cu 5 a valorilor unui vector de numere întregi.
+Pasul indică la ce iterație ne aflăm în bucla **for** și dacă este satisfăcută condiția de continuare. Putem lua ca exemplu de cod incrementarea cu 5 a valorilor unui vector de numere întregi.
 <code cpp>
 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>
@@ 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.
-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
@@ Line 209: / Line 211: @@
 while (expresie)
 {
-	// bloc de cod care se execută
+    // bloc de cod care se execută
 }
 </code>
-Vom lua drept exemplu de utilizare pe cel de la bucla for pentru a vedea cum putem scrie același program dar cu bucla while.
+Vom lua drept exemplu de utilizare pe cel de la bucla for pentru a vedea cum putem scrie același program, dar cu bucla while.
 <code cpp>
 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>
-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
@@ Line 244: / Line 246: @@
 </code>
-Iar ca și exemplu de cod vom rescrie exemplul de la bucla while astfel:
+Iar ca și exemplu de cod îl vom rescrie pe cel de la bucla while.
 <code cpp>
 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>
@@ Line 267: / Line 269: @@
 <note>Puteți folosi oricare din cele 3 instrucțiuni repetitive, important este ca efectul codului scris de voi să fie cel dorit și să fiți atenți la cum puneți condițiile.</note>
-<note warning>Trebuie menționat faptul că șansele de a intra într-o buclă infinită sunt mai mari atunci când folosim instrucțiunea while, deoarece putem omite să modificăm pasul la fiecare iterație. Instrucțiunea for este mai sigură din acest punct de vedere, dar trebuie menționat că putem avea un infinite loop chiar și dacă folosim cum nu trebuie for-ul.
+<note warning>Trebuie menționat faptul că șansele de a intra într-o **buclă infinită** sunt mai mari atunci când folosim instrucțiunea **while**, deoarece putem omite să modificăm **pasul** la fiecare iterație. Instrucțiunea **for** este mai sigură din acest punct de vedere, dar trebuie menționat că putem avea un **infinite loop** chiar și dacă folosim cum nu trebuie for-ul.
 </note>
-Pentru a avea un program care rulează la infinit utilizând bucla for putem să nu specificăm nimic între parantezele rotunde ale instrucțiunii.
+Pentru a avea un program care rulează la infinit utilizând bucla **for** putem să nu specificăm nimic între parantezele rotunde ale instrucțiunii.
 <code cpp>
 int main()
 {
-	int x = 8;
+    int x = 8;
-	for ( ; ; )
+    for ( ; ; )
-	{
+    {
-		x = x * 10;
+        x = x * 10;
-	}
+    }
-	return 0;
+    return 0;
 }
 </code>
-Astfel programul nu va mai ieși din bucla for și va multiplica valoarea lui x de 10 ori la infinit.
+Astfel programul nu va mai ieși din bucla **for** și va multiplica valoarea lui x de 10 ori la infinit.
 === Utilizarea pointerilor ===
-C++, la fel ca C-ul, are tipuri de date speciale denumite pointeri, care sunt utile atunci când vrem să modificăm o valoare de la o anumită adresă din memorie.
+C++, la fel ca C-ul, are tipuri de date speciale denumite **pointeri**, care sunt utile atunci când vrem să modificăm o valoare de la o anumită adresă din memorie.
-Un pointer este un tip de date care stochează o adresă din memorie la un anumit moment de timp în program. Să luam spre exemplu următoarea secvență de cod.
+**Un pointer** este un tip de date care stochează **o adresă** din memorie la un anumit moment de timp în program. Să luam spre exemplu următoarea secvență de cod.
 <code cpp>
 int main()
 {
-	int x = 10;
+    int x = 10;
-	int* ptr = &x;
+    int* ptr = &x;
-	return 0;
+    return 0;
 }
 </code>
-Se poate observa că avem o varibilă de tip int care a fost inițializată cu valoarea 10 și un pointer la int care a fost inițializat cu adresa lui x. Într-o ilustrare simplificată putem înțelege efectiv ce s-a întâmplat pe lina a doua de cod.
+Se poate observa că avem o varibilă de **tip int** care a fost inițializată cu valoarea 10 și un **pointer la int** care a fost inițializat cu adresa lui x. Într-o ilustrare simplificată putem înțelege efectiv ce s-a întâmplat pe lina a doua de cod.
 {{ :poo-is-ab:laboratoare:pointer_logic.jpg |}}
-Pe linia ''int* ptr = &x;'', ceea ce se întâmplă este faptul că pointerul ptr este asociat cu adresa variabilei x (apariția săgeții de la ptr la adresa lui x din desen). Practic, ptr devine un „arătător” către locația din memorie unde este stocată variabila x. Este important să înțelegeți că un pointer nu este altceva decât o variabilă specială care conține adresa de memorie a unei alte variabile. Astfel, ptr indică către adresa lui x și poate fi folosit pentru a accesa sau modifica valoarea lui x prin intermediul acestei adrese.
+Pe linia ''int* ptr = &x;'', ceea ce se întâmplă este faptul că pointerul **ptr** este asociat cu adresa variabilei **x** (apariția săgeții de la **ptr** la **adresa** lui **x** din desen). Practic, **ptr** devine un **"arătător"** către locația din memorie unde este stocată variabila **x**. Este important să înțelegeți că un pointer nu este altceva decât o variabilă specială care conține adresa de memorie a unei alte variabile. Astfel, **ptr** indică către adresa lui **x** și poate fi folosit pentru a accesa sau modifica valoarea lui **x** prin intermediul acestei adrese.
-<note warning>Un pointer poate pointa doar către **o singură** adresă, situația de mai jos fiind taxată cu o eroare de compilare.</note>
+<note warning>**Un pointer** poate pointa doar către **o singură** adresă, situația de mai jos fiind taxată cu o eroare de compilare.</note>
 <code cpp>
 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>
@@ Line 328: / Line 330: @@
 {{ :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 este complet validă.
+În schimb situația următoare este permisă și complet validă.
 <code cpp>
@@ Line 345: / Line 347: @@
 </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>
 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>
-<note important>Dereferențierea unui pointer în limbaj natural poate fi privită ca obținerea/vizualizarea valorii existente la o anumită adresă. Aceasta se realizează cu ajutorul operatorului de dereferențiere "*" plasat înaintea variabilei de tip pointer. A nu se confunda cu steluța de la declararea unui pointer și cu operatorul aritmetic de înmulțire a două numere.</note>
+<note important>**Dereferențierea** unui pointer în limbaj natural poate fi privită ca **obținerea/vizualizarea** valorii existente la o anumită adresă din memorie. Aceasta se realizează cu ajutorul operatorului de **dereferențiere** **"*"** plasat înaintea variabilei de tip pointer. A **nu** se confunda cu steluța de la declararea unui pointer sau cu operatorul aritmetic de înmulțire a două numere.</note>
-Orice modificare pe care o suferă valoarea lui x va fi vizibilă și prin intermediul dereferențierii pointerului ptr și invers. Adică orice modificare a valorii de la adresa de pointare a lui ptr se va răsfrânge asupra lui x. Ca și mic exercițiu aflați valoarea lui x de la finalul programului următor.
+Orice modificare pe care o suferă valoarea lui **x** va fi vizibilă și prin intermediul dereferențierii pointerului **ptr** și invers. Adică orice modificare a valorii de la adresa de pointare a lui **ptr** se va răsfrânge asupra lui **x**. Ca și mic exercițiu aflați valoarea lui **x** de la finalul programului următor.
 <code cpp>
 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>
-<note warning>Pointerii au ca și valoare default o adresă alocată random de compilator. NULL este un pointer special care conține o adresă vidă formată doar din zerouri. Practic NULL e echivalentul lui nimic (o adresă care este mereu goală) și de obicei când declarăm un pointer pe care nu îl utilizăm imediat este bine să îl inițializăm cu NULL.</note>
+<note warning>Pointerii au ca și valoare **default** o adresă alocată **random** de compilator. **NULL** este un pointer special care conține o **adresă vidă** formată doar din zerouri. Practic **NULL** e echivalentul lui nimic (o adresă care este mereu goală) și de obicei când declarăm un pointer pe care nu îl utilizăm imediat este bine să îl inițializăm cu **NULL**.</note>
 <code cpp>
 int main()
 {
-	int* ptr = NULL;
+    int* ptr = NULL;
+    return 0;
-	return 0;
 }
 </code>
@@ Line 396: / Line 396: @@
 === Definirea funcțiilor de către programator ===
-C++, la fel ca C-ul, suportă paradigma procedurală care presupune organizarea codului sursă în suprograme denumite funcții. Funcția după cum îi spune numele trebuie să se ocupe de un anumit lucru în program.
+C++, la fel ca C-ul, suportă paradigma procedurală care presupune organizarea codului sursă în **subprograme** denumite și **funcții**. **Funcția** după cum îi spune și numele trebuie să se ocupe de un anumit lucru în program.
-<note important>Ca și regulă de bună practică o funcție **nu trebuie** să facă mai mult de un singur lucru pe care este menită să îl facă.</note>
+<note important>Ca și regulă de bună practică o funcție **nu trebuie** să facă mai mult de **un singur lucru** pe care este menită să îl facă.</note>
 Rețeta cea mai simplă pentru declararea unei funcții este:
-  - tipul de date returnat
+  - **tipul de date returnat**
-  - numele funcției
+  - **numele funcției**
-  - 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.
@@ Line 420: / Line 420: @@
 </code>
-Implementarea funcțiilor se face în corpul acestora care este reprezentat de parantezele acolade. Funcțiile pot fi folosite prin apelare fie în funcția main fie în alte funcții după nevoie. Să urmărim exemplul de cod următor.
+Implementarea funcțiilor se face în corpul acestora care este reprezentat de parantezele acolade. Funcțiile pot fi folosite prin apelare fie în funcția **main** fie în alte funcții după nevoie. Să urmărim exemplul de cod următor.
 <code cpp>
@@ Line 451: / Line 451: @@
 __**Transmiterea parametrilor prin valoare**__
-Acest mod de transmitere a parametrilor implică crearea unor copii ale valorilor originale ale parametrilor. Aceste copii sunt utilizate în interiorul funcției, iar orice modificare adusă acestora nu va afecta variabilele originale. După încheierea execuției funcției, aceste copii sunt eliminate din memorie, iar valorile inițiale rămân neschimbate.
+Acest mod de transmitere a parametrilor implică crearea unor copii ale valorilor originale ale parametrilor. Aceste copii sunt utilizate în interiorul funcției, iar orice modificare adusă acestora **nu** va afecta variabilele originale. După încheierea execuției funcției, aceste copii sunt eliminate din memorie, iar valorile inițiale rămân **neschimbate**.
 Să analizăm exemplul de mai jos.
@@ Line 467: / Line 467: @@
     int dif = diferenta(x, y);
     return 0;
 }
 </code>
-Variabilelor x și y li se face la fiecare câte o copie atunci când se apelează funcția **diferenta**. Nu doar că aceste copii sunt pierdute la încheierea execuției acestei funcții ba chiar și rezultatul întors de această funcție este transmis prin valoare. Deci în total avem 3 copii care s-au făcut în momentul în care linia de cod ''int dif = diferenta(x, y);'' a fost executată.
+Variabilelor **x** și **y** li se face la fiecare câte o copie atunci când se apelează funcția **diferenta**. Nu doar că aceste copii sunt pierdute la încheierea execuției acestei funcții ba chiar și rezultatul întors de această funcție este transmis prin valoare. Deci în total avem 3 copii care s-au făcut în momentul în care linia de cod ''int dif = diferenta(x, y);'' a fost executată.
 Pentru a vedea efectiv dezavantajul transmiterii parametrilor prin valoare vom implementa o funcție care realizează interschimbarea valorilor a două variabile întregi.
@@ Line 490: / Line 489: @@
     interschimbare(x, y); // interschimbarea se realizeaza doar la nivelul functiei (x = 5, y = 21)
     return 0;
 }
 </code>
-Deși parametrii **a** și **b** ai funcției **interschimbare** sunt copii ale variabilelor **x** și **y** din programul principal, aceștia sunt doar variabile locale care există doar în interiorul funcției. Astfel, valoarea lui **a** va deveni 21 și cea a lui b va fi 5, însă aceste modificări se aplică doar la nivel local. După terminarea execuției funcției, variabilele originale x și y nu vor fi afectate și vor păstra valorile inițiale, deoarece modificările din interiorul funcției nu se propagă în afara ei.
+Deși parametrii **a** și **b** ai funcției **interschimbare** sunt copii ale variabilelor **x** și **y** din programul principal, aceștia sunt doar variabile locale care există doar în interiorul funcției. Astfel, valoarea lui **a** va deveni 21 și cea a lui **b** va fi 5, însă aceste modificări se aplică doar la nivel local. După terminarea execuției funcției, variabilele originale **x** și **y** nu vor fi afectate și vor păstra valorile inițiale, deoarece modificările din interiorul funcției nu se propagă în afara ei.
 Vom soluționa problema de mai sus utilizând un alt mod de transmitere a parametrilor și anume cea prin intermediul pointerilor.
@@ Line 501: / Line 499: @@
 __**Transmiterea parametrilor prin pointer**__
-Acest tip de transmitere a parametrilor unei funcții este utilizat atunci când intenționăm ca modificările pe care le facem în interiorul funcției să persiste în afara ei.
+Acest tip de transmitere a parametrilor unei funcții este utilizat atunci când intenționăm ca modificările pe care le facem în interiorul funcției să **persiste** în afara ei.
 Să reluăm exemplul prezentat pentru interschimbarea valorilor a două numere întregi.
@@ Line 524: / Line 522: @@
     interschimbare(&x, &y); // modificarile se vor rasfrange asupra lui x si y (x = 21, y = 5)
     return 0;
 }
 </code>
-Deși parametrii **a** și **b** sunt tot variabile locale în funcția **interschimbare**, faptul că aceștia sunt pointeri schimbă modul în care subrogramul funcționează. În loc să fie doar copii ale valorilor lui **x** și **y**, acești pointeri conțin adresele de memorie ale variabilelor originale. Astfel, orice modificare efectuată asupra variabilelor accesate prin intermediul pointerilor va afecta direct valorile lui **x** și **y**. Acest mecanism permite funcției să modifice variabilele din programul principal, deoarece nu lucrează cu copii ale acestora, ci direct cu locațiile lor din memorie.
+Deși parametrii **a** și **b** sunt tot variabile locale în funcția **interschimbare**, faptul că aceștia sunt pointeri schimbă modul în care subrogramul funcționează. În loc să fie doar copii ale valorilor lui **x** și **y**, acești pointeri conțin adresele de memorie ale variabilelor originale. Astfel, orice modificare efectuată asupra variabilelor accesate prin intermediul pointerilor va afecta **direct** valorile lui **x** și **y**. Acest mecanism permite funcției să modifice variabilele din programul principal, deoarece nu lucrează cu copii ale acestora, ci direct cu locațiile lor din memorie.
-<note>Putem folosi transmiterea prin pointer atunci când vrem sa facem anumite modificări asupra variabilelor, dar se poate utiliza și atunci când ne dorim doar să evităm copierea inutilă a valorilor, spre exemplu afisarea valorilor unui vector de numere întregi.</note>
+<note>Putem folosi transmiterea prin pointer atunci când vrem sa facem anumite modificări asupra variabilelor, dar se poate utiliza și atunci când ne dorim doar să **evităm** copierea inutilă a valorilor, spre exemplu afisarea valorilor unui vector de numere întregi.</note>
 <code cpp>
@@ Line 538: / Line 535: @@
 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 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>
-Deși în acest caz nu modificăm numărul de elemente sau valorile din vector, am reușit să evităm două copieri inutile care ar fi avut loc dacă am fi transmis vectorul și numărul de elemente prin valoare. Atunci când un vector este transmis ca parametru, numele său este echivalent cu adresa primului element din memorie, ceea ce permite funcției să lucreze direct cu datele din vectorul original. Din acest motiv, nu este necesar să folosim operatorul **"&"** pentru a obține adresa vectorului, deoarece aceasta este implicit furnizată atunci când transmitem variabila **vec**.
+Deși în acest caz **nu** modificăm numărul de elemente sau valorile din vector, am reușit să evităm două copieri inutile care ar fi avut loc dacă am fi transmis vectorul și numărul de elemente prin valoare. Atunci când un vector este transmis ca parametru, numele său este echivalent cu adresa primului element din memorie, ceea ce permite funcției să lucreze direct cu datele din vectorul original. Din acest motiv, nu este necesar să folosim operatorul **"&"** pentru a obține adresa vectorului, deoarece aceasta este implicit furnizată atunci când transmitem variabila **vec**.
 === Pointeri la funcții ===
-Pointerii la funcții (Function Pointers) sunt o caracteristică avansată a limbajelor de programare C și C++, care permit stocarea adreselor funcțiilor în variabile. Un pointer la funcție nu stochează o valoare, ci adresa din memorie unde este definită o funcție, oferind posibilitatea de a apela acea funcție indirect, prin intermediul pointerului.
+Pointerii la funcții (**Function Pointers**) sunt o caracteristică avansată a limbajelor de programare C și C++, care permit stocarea adreselor funcțiilor în variabile. Un pointer la funcție nu stochează o valoare, ci adresa din memorie unde este definită o funcție, oferind posibilitatea de a apela acea funcție indirect, prin intermediul pointerului.
-Cum ne putem da seama dacă o funcție are asociată o adresă din memorie? Răspunsul este unul simplu și o apelăm fără parametri.
+Cum ne putem da seama dacă o funcție are asociată o adresă din memorie? Răspunsul este unul simplu și anume o apelăm fără parametri.
 <code cpp>
@@ Line 568: / Line 564: @@
 void func()
 {
-	// bloc de cod
+    // bloc de cod
 }
 int main()
 {
-	std::cout << func << '\n';
+    std::cout << func << '\n';
+    return 0;
-	return 0;
 }
 </code>
-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>
@@ Line 590: / Line 585: @@
 void func()
 {
-	// bloc de cod
+    // bloc de cod
 }
 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>
-<note warning>Atât tipul returnat de function pointer cât și lista parametrilor acestuia trebuie să fie identice cu cele ale funcției spre care pointează pentru a nu avea eroare de compilare.</note>
+<note warning>Atât **tipul returnat** de function pointer cât și **lista parametrilor** acestuia trebuie să fie **identice** cu cele ale funcției spre care pointează pentru a nu avea eroare de compilare.</note>
 Utilitatea pointerilor la funcții devine evidentă atunci când dorim să evităm duplicarea codului și să facem programul mai flexibil și mai modular. În loc să scriem cod redundant pentru a apela funcții similare în contexte diferite, putem utiliza pointeri la funcții pentru a selecta dinamic funcția corespunzătoare în timpul execuției.
-Să luăm ca exemplu sortarea unui vector de numere întregi mai întâi crescător și apoi descrescător. Vom utiliza Bubble sort pentru a nu complica foarte mult logica programului.
+Să luăm ca exemplu sortarea unui vector de numere întregi mai întâi crescător și apoi descrescător. Vom utiliza Bubble Sort pentru a păstra simplitatea programului.
 <code cpp>
@@ Line 615: / Line 610: @@
 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)
 {
-	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)
 {
-	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)
 {
-	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 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>
-Se poate observa că singura diferență, între cele două funcții de sortare, apare la condiția din if pentru a stabili ordinea în care va fi afișat vectorul. Pentru a putea simplifica masiv codul am putea utiliza pointeri la funcții.
+Se poate observa că singura diferență, între cele două funcții de sortare, apare la condiția din **if** pentru a stabili ordinea în care vor fi ordonate elementele vectorului. Pentru a putea simplifica masiv codul am putea utiliza **pointeri la funcții**.
 <code cpp>
@@ Line 690: / Line 684: @@
 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)
 {
-	return a < b;
+    return a < b;
 }
 bool ordonareDescrescatoare(int a, int b)
 {
-	return a > b;
+    return a > b;
 }
 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)
 {
-	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 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>
@@ Line 756: / Line 749: @@
 Se poate observa cât de elegant am evitat acum codul duplicat prin construirea a doi comparatori (cele două funcții care întorc o valoare booleană) pentru a decide ordinea de sortare și trimiterea adreselor acestora ca al treilea parametru de la funcția de sortare. Așadar prin utilizarea function pointer-ului ca parametru beneficiem de flexibilitate și eleganță în cod chiar dacă sintaxa nu este cea mai prietenoasă. Acesta este doar un simplu exemplu demonstrativ de utilizare a pointerilor la funcții. Pentru mai multe exemple de cum pot fi folosți pointerii la funcții puteți citi de [[https://www.geeksforgeeks.org/function-pointer-in-c/|aici]].
-<note important>Tipul de date **bool** în C++ este un **tip de bază**, care simplifică exprimarea condițiilor în programare. O variabilă booleană poate avea doar două valori: **true** sau **false**, făcând astfel codul mai clar și mai ușor de înțeles. Se recomandă utilizarea tipului bool în locul tipului int atunci când rezultatul unei comparații este strict adevărat sau fals. În C, pentru a folosi acest tip de date, este necesară includerea antetului stdbool.h prin directiva ''#include <stdbool.h>'' la începutul programului.</note>
+<note important>Tipul de date **bool** în C++ este un **tip de bază**, care simplifică exprimarea condițiilor în programare. O variabilă booleană poate avea doar două valori: **true** sau **false**, făcând astfel codul mai clar și mai ușor de înțeles. Se recomandă utilizarea tipului **bool** în locul tipului **int** atunci când rezultatul unei comparații este strict **adevărat** sau **fals**. În C, pentru a folosi acest tip de date, este necesară includerea antetului **stdbool.h** prin directiva ''#include <stdbool.h>'' la începutul programului.</note>
 === 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 ==
@@ Line 771: / Line 764: @@
 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 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>
@@ Line 794: / Line 787: @@
     int a = 2;
     int b = 3;
+    // Situatia 1
     // 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)
     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
-    // 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 = &b; // corect
+    p1 = &b; // valid
     *p2 = *p1; // eroare de compilare
     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;
@@ Line 829: / Line 835: @@
 == Utilizarea keyword-ului const pe parametrii funcțiilor ==
-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 necesari parametri 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 afisarea î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 afisarea î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>
-<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>
-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>
-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>
-== 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 random
-	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 poate genera memory leak-uri usor*/
-	delete ptr1;
-	delete ptr2;
-        return 0;
-}
 </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 vechiul 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 erori neintenționate.</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 ====
-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.1726238668.txt.gz · Last modified: 2024/09/13 17:44 by razvan.cristea0106

Show page Old revisions

Media Manager Back to top