Differences
This shows you the differences between two versions of the page.
|
poo-is-ab:laboratoare:01 [2025/09/30 11:08] razvan.cristea0106 [Asemănări C/C++] |
poo-is-ab:laboratoare:01 [2026/09/29 10:44] (current) razvan.cristea0106 [Asemănări C/C++] |
||
|---|---|---|---|
| Line 26: | Line 26: | ||
| În continuare, vom descoperi asemănările dintre cele două limbaje de programare, ilustrând similaritățile dintre acestea 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 inițializarea variabilelor === |
| Modul de declarare și de inițializare a variabilelor în cele 2 limbaje este același, avem aceleași tipuri de date precum: **int**, **float**, **char**, **double**, **unsigned int**, **long**, **unsigned long** etc. | Modul de declarare și de inițializare a variabilelor în cele 2 limbaje este același, avem aceleași tipuri de date precum: **int**, **float**, **char**, **double**, **unsigned int**, **long**, **unsigned long** etc. | ||
| Line 94: | Line 94: | ||
| </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> | ||
| Line 117: | Line 117: | ||
| 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 | + | Forma generală a instrucțiunii switch |
| <code cpp> | <code cpp> | ||
| Line 190: | Line 190: | ||
| int main() | int main() | ||
| { | { | ||
| - | int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; | ||
| int nrElemente = 8; | int nrElemente = 8; | ||
| + | int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; | ||
| for (int index = 0; index < nrElemente; index++) | for (int index = 0; index < nrElemente; index++) | ||
| Line 220: | Line 220: | ||
| int main() | int main() | ||
| { | { | ||
| - | int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; | ||
| int nrElemente = 8; | int nrElemente = 8; | ||
| + | int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; | ||
| int index = 0; | int index = 0; | ||
| Line 235: | Line 235: | ||
| </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 de valoare de adevăr a expresiei din clauza while. | + | 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 valoarea de adevăr a expresiei din clauza while. |
| Forma generală a instrucțiunii do-while | Forma generală a instrucțiunii do-while | ||
| Line 251: | Line 251: | ||
| int main() | int main() | ||
| { | { | ||
| - | int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; | ||
| int nrElemente = 8; | int nrElemente = 8; | ||
| + | int vector[10] = { 2, 4, 1, -4, 8, 10, 3, -5 }; | ||
| int index = 0; | int index = 0; | ||
| Line 268: | Line 268: | ||
| <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>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> | ||
| 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. | ||
| Line 279: | Line 276: | ||
| int x = 8; | int x = 8; | ||
| - | for (; ; ) | + | for ( ; ; ) |
| { | { | ||
| x = x * 10; | x = x * 10; | ||
| Line 289: | Line 286: | ||
| 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. | ||
| + | |||
| + | <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> | ||
| === Utilizarea pointerilor === | === Utilizarea pointerilor === | ||
| Line 294: | Line 294: | ||
| 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ă luăm spre exemplu următoarea secvență de cod. |
| <code cpp> | <code cpp> | ||
| Line 306: | Line 306: | ||
| </code> | </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 variabilă 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 linia a doua de cod. |
| {{ :poo-is-ab:laboratoare:pointer_logic.jpg |}} | {{ :poo-is-ab:laboratoare:pointer_logic.jpg |}} | ||
| Line 330: | 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 347: | 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> | ||
| Line 391: | Line 391: | ||
| </code> | </code> | ||
| - | <note tip>Vom folosi foarte mult pointerii în acest semestru, iar pentru cei mai puțini familiarizați puteți urmări tutorialul urmator: [[https://youtu.be/zuegQmMdy8M?si=kxUOPspywfF5gR00|C++ Pointers]] | + | <note tip>Vom folosi foarte mult pointerii în acest semestru, iar pentru cei mai puțini familiarizați puteți urmări tutorialul următor: [[https://youtu.be/zuegQmMdy8M?si=kxUOPspywfF5gR00|C++ Pointers]] |
| </note> | </note> | ||
| Line 408: | Line 408: | ||
| <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 putem constata ca forma generală a unei funcții în C/C++ va arăta în felul următor -> **return_type name(parameters)**. | + | Dacă îmbinăm cele 3 componente putem constata că 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 471: | Line 471: | ||
| </code> | </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 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. | Pentru a vedea efectiv dezavantajul transmiterii parametrilor prin valoare vom implementa o funcție care realizează interschimbarea valorilor a două variabile întregi. | ||
| Line 495: | Line 495: | ||
| 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. | + | Vom soluționa problema de mai sus utilizând un alt mod de transmitere a parametrilor și anume cel prin intermediul pointerilor. |
| __**Transmiterea parametrilor prin pointer**__ | __**Transmiterea parametrilor prin pointer**__ | ||
| Line 526: | Line 526: | ||
| </code> | </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 subprogramul 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 să 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 afișarea valorilor unui vector de numere întregi.</note> |
| <code cpp> | <code cpp> | ||
| Line 660: | Line 660: | ||
| int main() | int main() | ||
| { | { | ||
| - | int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 }; | ||
| int nrElemente = 10; | int nrElemente = 10; | ||
| + | int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 }; | ||
| std::cout << "Vectorul sortat crescator este: "; | std::cout << "Vectorul sortat crescator este: "; | ||
| Line 730: | Line 730: | ||
| int main() | int main() | ||
| { | { | ||
| - | int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 }; | ||
| int nrElemente = 10; | int nrElemente = 10; | ||
| + | int vector[10] = { 2, 1, 4, -3, 0, 5, -1, 8, 10, 9 }; | ||
| std::cout << "Vectorul sortat crescator este: "; | std::cout << "Vectorul sortat crescator este: "; | ||
| Line 747: | Line 747: | ||
| </code> | </code> | ||
| - | 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]]. | + | 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 folosiț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> | ||
| Line 753: | 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 iniț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 765: | Line 765: | ||
| { | { | ||
| const float pi = 3.14f; // variabila constanta corect declarata | const float pi = 3.14f; // variabila constanta corect declarata | ||
| + | /* 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 | const double k; // eroare de compilare variabila constanta este declarata dar neinitializata | ||
| Line 806: | Line 807: | ||
| // Pointer constant la un int constant | // Pointer constant la un int constant | ||
| - | // P3 este un pointer constant la un int constant si pointerul in sine nu poate fi schimbat (nu poate pointa catre alta adresa) | + | // P4 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 p4 = &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 |
| - | // P4 este un pointer constant la un int constant si pointerul in sine nu poate fi schimbat | + | // P5 este un pointer constant la un int constant si pointerul in sine nu poate fi schimbat |
| int const* const p5 = &a; | int const* const p5 = &a; | ||
| Line 846: | Line 847: | ||
| * **Istoricul modificărilor** – putem reveni oricând la o versiune anterioară. | * **Istoricul modificărilor** – putem reveni oricând la o versiune anterioară. | ||
| * **Gestionarea branch-urilor** – dezvoltare paralelă și integrare prin **merge**. | * **Gestionarea branch-urilor** – dezvoltare paralelă și integrare prin **merge**. | ||
| - | * **Integrare cu unelte moderne** – paltforma GitHub permite **code review**, **issue tracking** și **CI/CD**. | + | * **Integrare cu unelte moderne** – platforma GitHub permite **code review**, **issue tracking** și **CI/CD**. |
| === Termeni specifici === | === Termeni specifici === | ||
| Line 906: | Line 907: | ||
| git branch -a # afișează toate branch-urile (locale și remote) | git branch -a # afișează toate branch-urile (locale și remote) | ||
| git checkout nume_branch # schimbă branch-ul curent | git checkout nume_branch # schimbă branch-ul curent | ||
| - | git branch -b nou_branch # creează un branch nou și trece pe el | + | git branch -b nou_branch # creează un branch nou și se mută pe el |
| git merge branch_modificari # unirea unui branch în branch-ul curent | git merge branch_modificari # unirea unui branch în branch-ul curent | ||
| </code> | </code> | ||
| Line 940: | Line 941: | ||
| === Ce ar trebui să facem? === | === Ce ar trebui să facem? === | ||
| - | - Să instalăm Git pe mașinile noastre | + | - Să instalăm **Git** pe mașinile noastre |
| - Să avem sau să ne facem un cont pe platforma **GitHub** | - 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** | + | - 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]]. | - Să ne setăm o cheie **ssh** conform instrucțiunilor de [[https://www.youtube.com/watch?v=2kuG9ElVMhM|aici]]. | ||
| + | - Să ne facem cont pe [[https://rezultate.eu/|rezultate.eu]] pentru a putea accesa exercițiile de laborator. | ||
| ==== ==== | ==== ==== | ||
| <note tip> | <note tip> | ||
| - | * Pentru descărcare git accesați site-ul următor: [[https://git-scm.com/downloads|Download git]] | + | * 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 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]] | * Pentru a vă crea un cont pe GitHub puteți urmări indicațiile de [[https://youtu.be/Gn3w1UvTx0A|aici]] | ||
| </note> | </note> | ||
| + | |||
| ==== Concluzii ==== | ==== Concluzii ==== | ||
| - | Î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**. | + | Î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**. |
