Differences
This shows you the differences between two versions of the page.
|
sd-ca:laboratoare:lab-01 [2020/02/19 20:20] andrei_adrian.dinu [Bibliografie recomandată] |
sd-ca:laboratoare:lab-01 [2023/03/01 22:04] (current) iulia.corici [Exerciții] |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== Laborator 1 - Recapitulare PC. Vectori si matrice. Alocare dinamica ====== | + | ====== Laborator 1 - Recapitulare PC. Vectori și matrice. Alocare dinamică ====== |
| Responsabili | Responsabili | ||
| - | * [[mailto:dinuaadrian@gmail.com|Andrei Dinu]] | + | * [[mailto:coriciiulia76@gmail.com |Iulia Corici]] |
| - | * [[mailto:rares96cheseli@gmail.com|Rares Cheseli]] | + | * [[mailto:banu.maximilian401@gmail.com|Banu Maximilian]] |
| - | * [[mailto:andrei.vasiliu2211@gmail.com|Andrei Vasiliu]] | + | |
| - | În cadrul acestui laborator ne propunem să recapitulam cateva dintre conceptele de C invatate la cursul de Programarea Calculatoarelor. | + | În cadrul acestui laborator ne propunem să recapitulăm cateva dintre conceptele de C invatate la cursul de Programarea Calculatoarelor. |
| ===== Obiective ===== | ===== Obiective ===== | ||
| Ne dorim să: | Ne dorim să: | ||
| - | *Recapitulam alocarea dinamica a memoriei si pointerii | + | *Recapitulăm alocarea dinamică a memoriei și pointerii |
| - | *Recapitulam lucrul cu structuri | + | *Recapitulăm lucrul cu structuri |
| - | *Recapitulam directivele de preprocesare | + | *Recapitulăm directivele de preprocesare |
| - | *Invatam sa ne asiguram ca nu avem memory leaks in programul nostru | + | *Recapitulăm cum ne asigurăm ca nu avem memory leaks în programul nostru |
| ===== Pass by value vs Pass by address ===== | ===== Pass by value vs Pass by address ===== | ||
| - | C este un limbaj pass-by-value. Asta inseamna ca functiile isi vor creea copii ale parametrilor si vor lucra cu ele. | + | C este un limbaj pass-by-value. Asta înseamnă ca funcțiile își vor crea copii ale parametrilor și vor lucra cu ele. |
| - | Daca vrem sa lucram direct pe variabilele trimise ca parametru, va trebui sa trimitem adresa lor catre functie. | + | Dacă vrem să lucram direct pe variabilele trimise ca parametru, va trebui să trimitem adresa lor către funcție. |
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | // Se va face cate o copie a variabilelor a si b. Aceste copii se vor distruge | + | // Se va face câte o copie a variabilelor a și b. Aceste copii se vor distruge |
| - | // dupa ce functia isi va incheia executia | + | // după ce funcția își va încheia execuția |
| void swap(int a, int b) { | void swap(int a, int b) { | ||
| int temp = a; | int temp = a; | ||
| Line 30: | Line 29: | ||
| } | } | ||
| - | // Se va face cate o copie a pointerilor dar vor pointa tot catre variabilele | + | // Se va face câte o copie a pointerilor dar vor pointa tot către variabilele |
| - | // a si b | + | // a și b |
| void swap2(int* a, int* b) { | void swap2(int* a, int* b) { | ||
| int temp = *a; | int temp = *a; | ||
| Line 56: | Line 55: | ||
| ===== Void pointer (void*) ===== | ===== Void pointer (void*) ===== | ||
| - | Un pointer de tipul void* este un pointer care nu este asociat cu niciun tip de date, ceea ce ii permite sa pointeze la adrese de memorie de orice tip. De asemenea, el poate fi castat la orice tip de date. | + | Un pointer de tipul ''void*'' este un pointer care nu este asociat cu niciun tip de date, ceea ce îi permite să pointeze la adrese de memorie de orice tip. De asemenea, el poate fi specializat (cast) la orice tip de date. |
| - | ==== Exemplu de folosire in contextul genericitatii ==== | + | ==== Exemplu de folosire în contextul genericității ==== |
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| Line 93: | Line 92: | ||
| </code> | </code> | ||
| - | ===== Alocarea dinamica ===== | + | ===== Alocarea dinamică ===== |
| ==== Vectori ==== | ==== Vectori ==== | ||
| - | Printr-un vector se înţelege o colecţie liniară şi omogenă de date. Un vector este liniar pentru că datele(elementele) pot fi accesate în mod unic printr-un index. Un vector este, de asemenea, omogen, pentru că toate elementele sunt de acelaşi tip. În limbajul C, indexul este un număr întreg pozitiv şi indexarea se face începând cu 0. | + | Printr-un vector se înţelege o colecţie liniară şi omogenă de date. Un vector este liniar pentru că datele (elementele) pot fi accesate în mod unic printr-un index. Un vector este, de asemenea, omogen, pentru că toate elementele sunt de acelaşi tip. În limbajul C, indexul este un număr întreg pozitiv şi indexarea se face începând cu 0. |
| Declarare vector static: | Declarare vector static: | ||
| <code c> | <code c> | ||
| - | int a[100]; // structură statică: dimensiunea acestuia trebuie să fie o constantă la compilare şi nu poate fi modificată în cursul | + | int a[100]; // declarare statică: dimensiunea acestui vector trebuie să fie o constantă |
| - | // execuţiei programului. | + | // la compilare şi nu poate fi modificată în cursul execuţiei programului. |
| </code> | </code> | ||
| Line 106: | Line 105: | ||
| Declarare vector alocat dinamic: | Declarare vector alocat dinamic: | ||
| <code c> | <code c> | ||
| - | int *a = malloc(n * sizeof(int)); | + | int *a = malloc(n * sizeof(*a)); |
| … | … | ||
| free(a); | free(a); | ||
| </code> | </code> | ||
| - | În limbajul C nu există practic nici o diferenţă între utilizarea unui vector cu dimensiune fixă şi utilizarea unui vector alocat dinamic. | + | În limbajul C nu există la nivel de sintaxă nicio diferenţă între utilizarea unui vector cu dimensiune fixă şi utilizarea unui vector alocat dinamic. |
| + | |||
| + | <note important> | ||
| + | Este posibil ca funcțiile ce alocă memorie să nu reușească să facă acest lucru, drept care întorc ''NULL''. Din acest motiv, este obligatoriu să verificăm de fiecare dată pointerul întors de funcțiile ''malloc'', ''calloc'' și ''realloc''. Un mod universal acceptat de a face acest lucru este prin macro-ul ''DIE''. Acesta primește ca "parametri" o condiție de verificat și o descriere a eventualei erori. | ||
| + | |||
| + | Observați în codul de mai jos macro-urile ''%%__FILE__%%'' și ''%%__LINE__%%''. Acestea se expandează în cadrul preprocesării la numele fișierului și, respectiv, linia curentă din acesta, pentru a ajuta la identificarea erorii. Funcția ''perror'' afișeaza la consolă mesajul primit ca parametru, împreună cu o descriere a ultimei erori produse în sistem. Aceasta este indicată de variabila ''errno'', care este un număr întreg, declarat în headerul ''errno.h'', și care indică ultima eroare aparută în sistem. Funcția ''perror'' se folosește, deci, de ''errno''. | ||
| + | |||
| + | <code c> | ||
| + | #include <errno.h> | ||
| + | #define DIE(assertion, call_description) \ | ||
| + | do { \ | ||
| + | if (assertion) { \ | ||
| + | fprintf(stderr, "(%s, %d): ", \ | ||
| + | __FILE__, __LINE__); \ | ||
| + | perror(call_description); \ | ||
| + | exit(errno); \ | ||
| + | } \ | ||
| + | } while (0) | ||
| + | </code> | ||
| + | |||
| + | Pentru mai multe detalii despre ''DIE'', puteți consulta și descrierea acestuia de pe [[https://ocw.cs.pub.ro/courses/so/laboratoare/resurse/die|pagina cursului de Sisteme de Operare]], din anul 3. | ||
| + | </note> | ||
| ==== Matrice ==== | ==== Matrice ==== | ||
| - | Matricea este o colecţie omogenă şi bidimensională de elemente. Acestea pot fi accesate prin intermediul a doi indici, numerotaţi, ca şi în cazul vectorilor, începand de la 0. | + | Matricea este o colecţie omogenă şi bidimensională de elemente. Acestea pot fi accesate prin intermediul a doi indici, numerotaţi, ca şi în cazul vectorilor, începând de la 0. |
| - | Declarare matrice statica: | + | Declarare matrice statica: |
| <code c> | <code c> | ||
| int mat[5][10]; | int mat[5][10]; | ||
| </code> | </code> | ||
| - | Declarare matrice dinamica: | + | Declarare matrice dinamică: |
| <code c> | <code c> | ||
| int **a; | int **a; | ||
| Line 136: | Line 156: | ||
| </code> | </code> | ||
| - | Daca se cunoaste la compilare prima dimensiune a matricei (numarul de linii), un alt mod de a declara o matrice dinamic este urmatorul: | + | Dacă se cunoaște la compilare prima dimensiune a matricei (numărul de linii), un alt mod de a declara o matrice dinamic este următorul: |
| <code c> | <code c> | ||
| - | int (*mat)[10] = (int (*)[10])malloc(sizeof(*mat) * 5); | + | int (*mat)[10] = malloc(sizeof(*mat) * 5); |
| ... | ... | ||
| free(mat); | free(mat); | ||
| </code> | </code> | ||
| - | In acest caz, toata matricea va fi alocata intr-o zona continua de memorie. | + | <note important> |
| + | În acest caz, toată matricea va fi alocată într-o zonă continuă de memorie. Pentru a explicita codul de mai sus, trebuie să ințelegem de ce ''sizeof(*mat) == 40''. Acest lucru este datorat faptului că ''mat'' desemnează un array de vectori de câte 10 ''int''-uri, adică 40 de octeți. Va sa zica, pentru oricare ''i'', ''mat[i]'' este un vector de 10 ''int''-uri. | ||
| + | </note> | ||
| <note> | <note> | ||
| - | Pentru a aloca dinamic un vector putem folosi si functia calloc. Exista doua mari diferente intre calloc si malloc: | + | Pentru a aloca dinamic un vector putem folosi și funcția ''calloc''. Există două mari diferențe între ''calloc'' si ''malloc'': |
| - | *Semnatura functiei: calloc() primeşte două argumente, o lungime de vector şi o dimensiune a fiecărui element. | + | *Semnătura funcției: ''calloc'' primeşte două argumente, mai exact o lungime de vector şi o dimensiune a fiecărui element. |
| - | *calloc initializeaza elementele cu 0, malloc nu face niciun fel de initializare. | + | *''calloc'' initializeaza elementele cu 0, pe când ''malloc'' nu face niciun fel de inițializare. |
| - | </note> | + | </note> |
| ==== Realocarea ==== | ==== Realocarea ==== | ||
| - | Redimensionarea unui vector care creste (sau scade) fata de dimensiunea alocata initial se poate face cu funcţia //realloc//, care primeşte adresa veche şi noua dimensiune şi întoarce noua adresă. In cazul in care realocarea a esuat, la fel ca celelalte functii de alocare, realloc va intoarce NULL. | + | Redimensionarea unui vector care crește (sau scade) față de dimensiunea alocată inițial se poate face cu funcţia //realloc//, care primeşte adresa veche şi noua dimensiune şi întoarce noua adresă. |
| + | <note important> | ||
| + | În cazul în care realocarea a eșuat, la fel ca celelalte funcții de alocare, ''realloc'' va întoarce ''NULL''. Orice funcție din “familia” ''*alloc'' manifestă acest comportament atunci când alocarea de memorie eșuează. Din acest motiv, trebuie sa verificați **intotdeauna** că pointerii întoarși de acestea nu sunt ''NULL''. | ||
| + | </note> | ||
| ===== Static ===== | ===== Static ===== | ||
| ==== Variabile statice ==== | ==== Variabile statice ==== | ||
| - | Variabilele statice reprezinta un tip special de variabile care isi pastreaza valoarea in program pana la terminarea executiei lui. Ele sunt stocate intr-o parte separata a memoriei, astfel incat dupa iesirea din scope sau stack frame ele nu se distrug. | + | Variabilele statice reprezintă un tip special de variabile care sunt stocate într-o parte separată a memoriei, astfel încât să fie vizibile oriunde în program. Acestea au avantajul că dacă sunt declarate într-o funcție și apoi modificate, acele modificări vor fi vizibile și la următorul apel al funcției, spre deosebire de variabilele locale obișnuite. |
| <code c> | <code c> | ||
| Line 175: | Line 200: | ||
| </code> | </code> | ||
| - | ==== Functii statice ==== | + | ==== Funcții statice ==== |
| - | Declarerea unei functii statice ii va restrictiona acesteia accesul la fisierul in care este declarata. Astfel, daca fisierul sursa al acesteia este inclus in altul si iar functia este apelata din el, vom primi o eroare de compilare, functia statica nefiind inclusa. | + | Declararea unei funcții ca fiind statică îi va restricționa acesteia accesul la fișierul în care este declarată. Astfel, dacă fișierul sursă al acesteia este inclus în altul iar funcția respectivă este apelată din el, vom primi o eroare de compilare, funcția statică nefiind inclusă. |
| + | <note important> | ||
| + | Este recomandat, deci, ca atunci când vă definiți o funcție auxiliară sau care pur și simplu nu are sens să fie vizibilă din alte fișiere ce ar fi linkate cu fișierul in care e definită funcția, aceasta să fie declarată folosind keywordul ''static''. | ||
| + | |||
| + | O explicație mai detaliată și mai tehnică găsiți [[https://ocw.cs.pub.ro/courses/so/laboratoare/resurse/c_tips#folosirea_specificatorului_static_pentru_variabile_globale_si_functii|aici]]. | ||
| + | </note> | ||
| <code c f1.c> | <code c f1.c> | ||
| Line 189: | Line 219: | ||
| int main() { | int main() { | ||
| - | f(); // Se va genera o eroare de tip “undefinied reference to f” deoarece functia statica nu a fost importata. | + | f(); // Se va genera o eroare de tip “undefinied reference to f” deoarece funcția statică nu a fost importata. |
| return 0; | return 0; | ||
| } | } | ||
| Line 195: | Line 225: | ||
| ===== Const ===== | ===== Const ===== | ||
| - | Keyword-ul //const// desemneaza o variabila constanta, read-only, a carei valoare nu se va mai schimba dupa initializare. Daca se incearca schimbarea valorii se va genera o eroare de compilare. In cazul pointerilor fiti atenti daca adresa de memorie este constanta sau valorea spre care pointeaza! | + | Keyword-ul //const// desemnează o variabilă constantă, read-only, a cărei valoare nu se va mai schimba după actualizare. Cand se incearca schimbarea valorii, se va genera o eroare de compilare. În cazul pointerilor fiți atenți dacă adresa de memorie este cea constantă sau valoarea spre care pointeaza! |
| - | Deducerea acestor declaratii se poate face prin [[http://c-faq.com/decl/spiral.anderson.html|clockwise/spiral rule]]. | + | Deducerea acestor declarări se poate face prin [[http://c-faq.com/decl/spiral.anderson.html|clockwise/spiral rule]]. |
| Exemple: | Exemple: | ||
| Line 208: | Line 238: | ||
| <note> | <note> | ||
| - | Pentru syntactic sugar putem muta primul const la inceputul declaratiei: | + | Pentru syntactic sugar putem muta primul const la începutul declarației: |
| <code> | <code> | ||
| - | const int* a == int* const a (veti vedea de multe ori acest tip de declaratie) | + | const int* a == int const* a (veți vedea de multe ori acest tip de declarare) |
| </code> | </code> | ||
| </note> | </note> | ||
| Line 220: | Line 250: | ||
| </code> | </code> | ||
| - | Putem defini constante ce vor fi inlocuite peste tot in program in etapa de procesare. Este recomandat sa folosim aceasta optiune in defavoarea scrierii efective a constantei deoarece suntem mai predispusi la bug-uri putand uita sa modificam constanta in unele parti ale programului. | + | Putem defini constante ce vor fi înlocuite peste tot în program în etapa de preprocesare. Este recomandat să folosim aceasta optiune în defavoarea scrierii efective a constantei deoarece suntem mai predispuși la buguri putând uita sa modificăm constanta în unele părți ale programului. |
| ==== Garzi === | ==== Garzi === | ||
| - | Folosim garzi de preprocesare pentru a evita incluziunea multipla si redefinirea de variabile. Astfel, chiar daca includem de mai multe ori acelasi header, textual, vom avea o singura inlocuire a variabilelor/functiilor. | + | Folosim gărzi de preprocesare pentru a evita incluziunea multiplă și redefinirea de variabile. Astfel, chiar dacă includem de mai multe ori același header, textual, vom avea o singura înlocuire a variabilelor/funcțiilor. |
| Line 233: | Line 263: | ||
| <code c car.h> | <code c car.h> | ||
| car.h | car.h | ||
| - | #include “engine.h” // se va inlocui cu struct A la preprocesare | + | #include “engine.h” // se va înlocui cu struct A la preprocesare |
| </code> | </code> | ||
| - | <code c main.c> | + | <code c main.c> |
| #include “engine.h” | #include “engine.h” | ||
| #include “car.h” | #include “car.h” | ||
| - | ...// Vom avea inclusa de doua ori struct A, ceea ce va duce la o eroare de compilare | + | ...// Vom avea inclusă de două ori struct A, ceea ce va duce la o eroare de compilare |
| - | // deoarece se incearca redefinirea lui A. | + | // deoarece se încearcă redefinirea lui A. |
| </code> | </code> | ||
| - | **Solutie**: Adaugam garzi in fiecare fisier | + | **Solutie**: Adăugăm gărzi în fiecare fișier |
| <code c engine.h> | <code c engine.h> | ||
| Line 273: | Line 303: | ||
| </code> | </code> | ||
| - | Dupa expandare vom avea: | + | După expandare vom avea: |
| <code c main.c> | <code c main.c> | ||
| - | #ifndef __ENGINE_H__ // Adaugam o intrare pentru "engine" in tabela de simboluri | + | #ifndef __ENGINE_H__ // Adăugăm o intrare pentru "engine" în tabela de simboluri |
| #define __ENGINE_H__ | #define __ENGINE_H__ | ||
| Line 282: | Line 312: | ||
| #endif | #endif | ||
| - | #ifndef __CAR_H__ // Adaugam o intrare pentru "car" in tabela de simboluri | + | #ifndef __CAR_H__ // Adăugăm o intrare pentru "car" in tabela de simboluri |
| #define __CAR_H__ | #define __CAR_H__ | ||
| - | #ifndef __ENGINE_H__ // "engine" este definit deci sarim peste acest branch si nu includem struct A din nou | + | #ifndef __ENGINE_H__ // "engine" este definit deci sărim peste acest branch și nu includem struct A din nou |
| #define __ENGINE_H__ | #define __ENGINE_H__ | ||
| Line 301: | Line 331: | ||
| ===== Exerciții ===== | ===== Exerciții ===== | ||
| + | {{:sd-ca:laboratoare:lab01_recap_pc_skel.zip|Scheletul de laborator}} | ||
| - | <note> | + | 1) Se citesc de la tastatura N cercuri definite prin coordonatele centrului si raza (toate, numere întregi). |
| - | Fiecare laborator va avea unul sau doua exerciții publice si un pool de subiecte ascunse, din care asistentul poate alege cum se formeaza celelalte puncte ale laboratorului. | + | Sa se numere cate perechi de cercuri se intersectează. Se consideră că două cercuri se intersectează și dacă acestea sunt doar tangente. |
| - | </note> | + | |
| + | Ex:\\ | ||
| + | 6\\ | ||
| + | 25 25 15\\ | ||
| + | 10 10 12\\ | ||
| + | 25 20 7\\ | ||
| + | 40 40 5\\ | ||
| + | 48 40 5\\ | ||
| + | 0 30 5\\ | ||
| - | <hidden> | + | Output: 4 (se intersectează perechile de cercuri: (1, 2), (1, 3), (2, 3), (4, 5)) |
| - | 311CAa | + | 2) Se citește o matrice de dimensiune n x m. Fiecare linie va forma un număr. Exemplu: linia [3, 0, 2] va forma numărul 302. Afișați suma liniilor. |
| - | 2) [**6p**] Un robot pleacă de la coordonatele (0, 0) ale unei matrice de dimensiune n x m. El primește dimensiunile matricei si o serie de comenzi codificate astfel ‘U’ -> up (merge o casuță în sus), ‘D’ -> down (merge o casuță în jos), ‘R’ -> right (merge o casuță la dreapta), ‘L’ -> left (merge o casuță la stânga). Robotul primește comenzile ca un șir de caractere (ex: “DDURLLR”). Întoarceți true dacă robotul ajunge înapoi în bază după aceste comenzi (coordonatele (0, 0)) sau false în caz contrar. Afisati matricea dupa fiecare miscare, marcand pozitia robotului cu un caracter distinct. | + | * Alocați dinamic matricea. |
| - | * [**2p**] Alocați dinamic matricea | + | * Implementați logica problemei. |
| - | * [**2p**] Implementați logica problemei | + | * Verificați cu Valgrind că nu aveți memory leaks. |
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | + | |
| - | 311CAb | ||
| - | 2) [**6p**] Se citește o matrice de dimensiune n x m. Se primesc alte două dimensiuni n’ si m’. Se va face conversia de la matricea de n x m la matricea n’ x m’ și se va întoarce noua matrice (dacă este posibil). În caz contrar se va afișa vechea matrice. | ||
| - | * [**2p**] Alocați dinamic matricea | ||
| - | * [**2p**] Implementați logica problemei | ||
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | ||
| - | |||
| - | Ex: | ||
| - | n = 2 | ||
| - | m = 2 | ||
| - | [[1, 2], [3, 4]] | ||
| - | | ||
| - | n’ = 1 | ||
| - | m’ = 4 | ||
| - | [1, 2, 3, 4] | ||
| - | |||
| - | |||
| - | 312CAa | ||
| - | 2) [**6p**] Se citește o matrice de dimensiune n x m cu proprietatea că fiecare linie și coloană este sortată crescător. Să se caute elementul cerut în matrice. Se va întoarce true dacă a fost găsit și false dacă nu a fost găsit. | ||
| - | * [**2p**] Alocați dinamic matricea | ||
| - | * [**2p**] Implementați logica problemei | ||
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | ||
| - | |||
| - | |||
| - | 312CAb | ||
| - | 2) [**6p**] Se citește o matrice de dimensiune n x m. Să se rețină în memorie și să se afișeze transpusa ei. | ||
| - | * [**2p**] Alocați dinamic matricea | ||
| - | * [**2p**] Implementați logica problemei | ||
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | ||
| - | |||
| - | |||
| - | 313CAa | ||
| - | 2) [**6p**] Se citește o matrice de dimensiune n x m cu toate elementele 0 și un șir de operații formate din perechi de câte două numere a și b. La fiecare operatie, se incrementeaza toate elementele matricei aflate in dreptunghiul cu coltul stanga-sus in [0,0] si dreapta-jos in [a,b]. | ||
| - | * [**2p**] Alocați dinamic matricea | ||
| - | * [**2p**] Implementați logica problemei | ||
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | ||
| - | |||
| - | Exemplu: | ||
| - | |||
| - | m = 3 | ||
| - | n = 3 | ||
| - | |||
| - | Operații: [2, 2], [3, 3] | ||
| - | |||
| - | Inițial, M va fi | ||
| - | |||
| - | 0 0 0 | ||
| - | |||
| - | 0 0 0 | ||
| - | |||
| - | 0 0 0 | ||
| - | |||
| - | După [2, 2], M va fi | ||
| - | |||
| - | 1 1 0 | ||
| - | |||
| - | 1 1 0 | ||
| - | |||
| - | 0 0 0 | ||
| - | |||
| - | După [3, 3], M va fi | ||
| - | |||
| - | 2 2 1 | ||
| - | |||
| - | 2 2 1 | ||
| - | |||
| - | 1 1 1 | ||
| - | |||
| - | Afișați matricea finală. | ||
| - | |||
| - | |||
| - | 313CAb | ||
| - | 2) [**6p**] Se citește o matrice de dimensiune n x m. Se poate efectua operația XOR de-a lungul unei linii sau a unei coloane. Să se afișeze rezultatul maxim. | ||
| - | * [**2p**] Alocați dinamic matricea | ||
| - | * [**2p**] Implementați logica problemei | ||
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | ||
| - | |||
| - | 314CAa | ||
| - | 2) [**6p**] Se citește o matrice de dimensiune n x m. Fiecare linie va forma un număr. Exemplu: linia [3, 0, 2] va forma numărul 302. Afișați suma liniilor. | ||
| - | * [**2p**] Alocați dinamic matricea | ||
| - | * [**2p**] Implementați logica problemei | ||
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | ||
| - | |||
| - | 314CAb | ||
| - | 2) [**6p**] Se citește o matrice de dimensiune n x m. Se va popula cu caracterele ‘B’ -> bomb, ‘E’ -> enemy si ‘X’ -> zona neutră. | ||
| - | Fiecare bombă va exploda și va afecta întrega linie și întreaga coloană din care face parte, transforând-o în zonă neutră. Întoarceți true dacă mai există inamici pe hartă și false în caz contrar. | ||
| - | * [**2p**] Alocați dinamic matricea | ||
| - | * [**2p**] Implementați logica problemei | ||
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | ||
| - | |||
| - | Exemplu: | ||
| - | Matrice inițială: | ||
| - | [ [X, X, E, X], | ||
| - | [X, B, X, X], | ||
| - | [X, E, X, X], | ||
| - | [X, X, B, X]] | ||
| - | |||
| - | După explozia bombelor: | ||
| - | [ [X, X, X, X], | ||
| - | [X, X, X, X], | ||
| - | [X, X, X, X], | ||
| - | [X, X, X, X]] -> false | ||
| - | |||
| - | 315CAa | ||
| - | 2) [**6p**] Se citește o matrice de dimensiune n x m. Elementul ei minim va fi 1. Verificați că matricea conține doar numere consecutive (suma tuturor elementelor == n * (n + 1) / 2) | ||
| - | * [**2p**] Alocați dinamic matricea | ||
| - | * [**2p**] Implementați logica problemei | ||
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | ||
| - | |||
| - | |||
| - | 315CAb | ||
| - | 2) [**6**] Se citește o matrice de dimensiune n x m sortată crescător pe linii. Elementele ei vor fi doar 0 și 1. Să se afișeze index-ul liniei cu cei mai multi de 1. | ||
| - | * [**2p**] Alocați dinamic matricea | ||
| - | * [**2p**] Implementați logica problemei | ||
| - | * [**2p**] Verificați cu Valgrind că nu aveți memory leaks | ||
| - | |||
| - | </hidden> | ||
| ===== Interviu ===== | ===== Interviu ===== | ||
| Line 436: | Line 357: | ||
| Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le puteți întâlni la un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul laboratorului. | Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le puteți întâlni la un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul laboratorului. | ||
| - | * Care este diferența între struct și class în C++? | + | * Care este diferența dintre pass by value si pass by address? |
| - | * Ce face keyword-ul static în fața metodei unei clase în C++? | + | * Ce întoarce funcția ''malloc''? De ce? |
| - | * Ce este diferit între o metodă statică și o metodă normală a unei clase? (Hint: explicați cum e cu pointer-ul //this//) | + | * Care sunt diferențele dintre alocarea dinamică și alocarea statică? |
| + | * Ce se întâmplă dacă un header este inclus de două ori? | ||
| Și multe altele... | Și multe altele... | ||
| Line 444: | Line 366: | ||
| ===== Bibliografie obligatorie===== | ===== Bibliografie obligatorie===== | ||
| - | <hidden> | ||
| - [[https://www.csd.uoc.gr/~zakkak/hy255/reading/c_coding_style.pdf| Cum scriem cod C corect?]] | - [[https://www.csd.uoc.gr/~zakkak/hy255/reading/c_coding_style.pdf| Cum scriem cod C corect?]] | ||
| - | </hidden> | + | - [[http://valgrind.org/docs/manual/quick-start.html | Valgrind quick start]] |
| ===== Bibliografie recomandată===== | ===== Bibliografie recomandată===== | ||
| - | - [[https://www.learn-c.org/ | Tutorial C pentru incepatori]] | + | - [[https://www.learn-c.org/ | Tutorial C pentru începători]] |
| - [[http://www2.cs.uregina.ca/~hilder/cs833/Other%20Reference%20Materials/The%20C%20Programming%20Language.pdf | The C Programming Language by K&R]] | - [[http://www2.cs.uregina.ca/~hilder/cs833/Other%20Reference%20Materials/The%20C%20Programming%20Language.pdf | The C Programming Language by K&R]] | ||
| + | |||
