Differences
This shows you the differences between two versions of the page.
| — |
programare:backup:2025:lab01 [2025/10/10 18:50] (current) darius.neatu created |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| + | ===== Unelte de programare ===== | ||
| + | **Responsabili:** | ||
| + | * [[darius.neatu@upb.ro|Darius Neațu (2024)]] | ||
| + | * [[laura.vasilescu@cti.pub.ro|Laura Vasilescu (2015)]] | ||
| + | |||
| + | |||
| + | ==== Obiective ==== | ||
| + | |||
| + | În urma parcurgerii acestui laborator studentul va fi capabil să: | ||
| + | * înțeleagă ce înseamnă noțiunile de program, limbaj de programare, compilare/interpretare | ||
| + | * scrie și compileze programe simple în limbajul C | ||
| + | * utilizeze utilitarul Make pentru a compila automat programele scrise | ||
| + | * utilizeze funcțiile din limbaj de citire și scriere a datelor | ||
| + | |||
| + | ==== Introducere ==== | ||
| + | **Calculatorul** este un instrument care stochează, procesează și redă date sub forma unei secvențe de zero și unu ([[https://ro.wikipedia.org/wiki/Sistem_binar | un sistem binar]], despre care veți învăța mai multe semstrul acesta la Proiectare Logică și Introducere în Informatică), fiind utilizat pentru rezolvarea unor probleme folosind acele date. Un **program** este o înșiruire de instrucțiuni pe care calculatorul le va urma //întocmai// în vederea îndeplinirii unei sarcini. Când calculatorul urmează instrucțiunile dintr-un program, spunem că //execută// programul. | ||
| + | |||
| + | Deoarece noi nu putem folosi direct sistemul binar pentru a spune unui calculator ce să facă, utilizăm un **limbaj de programare**, similar limbii vorbite (are o sintaxă, punctuație bine definite și cuvinte-cheie preluate în general din limba engleză) și deci ușor de asimilat. Acesta poate fi “tradus” prin compilare sau interpretare în //cod-mașină//, limbajul înțeles de calculator și exprimat, în general, în binar. | ||
| + | |||
| + | Compilarea (specifică limbajelor precum Java, Pascal, C - pe care îl veți folosi anul acesta la Programarea Calculatoarelor și Structuri de Date) constă în traducerea propriu-zisă de către un compilator din limbajul de programare ales în cod-mașină, care va fi executat direct de calculator. Interpretarea (Python, Ruby, JavaScript) implică faptul că programul nu va fi rulat direct de calculator, ci de un alt program, //interpretor//, care este deja compilat în cod-mașină. | ||
| + | |||
| + | //**Pentru acasă**// | ||
| + | * //Puteți gândi programul ca pe o rețetă care îți spune cum să faci un sendviș cu unt de arahide. În acest model, voi sunteți calculatorul, programul este rețeta, iar limbajul de programare este, desigur, limba în care este scrisă rețeta.// | ||
| + | * //Încercați să formulați o secvență de instrucțiuni pentru a spune cuiva cum să facă un sendviș cu unt de arahide, fără să omiteți vreun pas sau să îi puneți în ordinea greșită.// | ||
| + | * //A fost ușor? V-ați amintit toți pașii? Poate ați uitat să menționați că trebuie folosit un cuțit și [[https://www.youtube.com/watch?v=cDA3_5982h8| cine urmează instrucțiunile are mâinile pline de unt de arahide]]! Sigur vă veți gândi că un om nu este atât de inapt. Dar un calculator chiar este! El va face numai și numai ce îi spui să facă. Acest lucru poate fi frustrant la început, dar într-un fel este o ușurare: dacă faci totul corect, știi exact ce va face calculatorul, pentru că i-ai spus tu. ([[https://en.wikiversity.org/wiki/Introduction_to_Programming/About_Programming|sursa]])// | ||
| + | |||
| + | |||
| + | C este un limbaj de programare structurată menit să simplifice scrierea programelor apropiate de masină. A fost creat de către Dennis Ritchie (care este și unul dintre creatorii sistemului Unix) în perioada 1968-1973 și a fost dezvoltat în strânsă legatură cu sistemul de operare Unix (cu care vă veți familiariza semestrul acesta prin materia Utilizarea Sistemelor de Operare), care a fost rescris în întregime în C. Utilizarea limbajului s-a extins cu trecerea timpului de la sisteme de operare și aplicaţii de sistem la aplicaţii generale. | ||
| + | |||
| + | Deşi în prezent, pentru dezvoltarea aplicaţiilor complexe au fost create limbaje de nivel mai înalt (''Java, C#, Python''), C este în continuare foarte folosit la scrierea sistemelor de operare şi a aplicațiilor de performanţă mare sau dimensiune mică (în lumea dispozitivelor embedded). Nucleele sistemelor Windows şi Linux sunt scrise în C. | ||
| + | |||
| + | Să începem prin a analiza un program simplu scris în limbajul C, al cărui scop este să afișeze în linia de comandă mesajul “Hello, World!”: | ||
| + | <code c> | ||
| + | #include <stdio.h> | ||
| + | |||
| + | int main() | ||
| + | { | ||
| + | //Hello from my first program! | ||
| + | printf("Hello, World!\n"); | ||
| + | return 0; | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | <note tip>Puteți testa codul [[http://tpcg.io/2yCLtg|aici]]! </note> | ||
| + | |||
| + | |||
| + | Prima linie reprezintă o instrucțiune de preprocesare care spune programului să includă header-ul standard input output (stdio.h) din biblioteca C, permițând utilizarea funcțiilor de bază precum //printf, scanf, getc, puts// etc. | ||
| + | |||
| + | Declarația int main() indică începutul funcției principale, de la care începe execuția în orice program C. Conținutul acestei funcții este încadrat de acolade {}. Conform [[https://www.kernel.org/doc/html/v4.10/process/coding-style.html|convenției]], main fiind o funcție, cele două acolade se află singure pe câte o linie. Pentru alte comenzi (if, while, do, for etc), prima acoladă se va pune pe linia comenzii. | ||
| + | |||
| + | După fiecare comandă este obligatoriu caracterul punct și virgulă //;// pentru a indica sfârșitul comenzii. Din această cauză orice comandă în C se poate scrie pe oricâte rânduri, dar acest lucru nu este recomandat decât dacă linia respectivă ar fi extrem de lungă (peste 80 de caractere). | ||
| + | |||
| + | Așa cum este important să scrii frumos de mână pentru ca ceilalți care citesc să înțeleagă, este important să scrii și cod frumos ca să fie ușor de înțeles. Există niște reguli de bază numite **coding style** pe care le găsiți pe scurt [[https://ocw.cs.pub.ro/courses/programare/coding-style|aici]]. | ||
| + | |||
| + | Textul care urmează după cele două slash-uri reprezintă un comentariu dedicat exclusiv omului, pe care compilatorul nu îl citește. Comentariile sunt în general folosite pentru a explica/clarifica ce fac anumite părți din cod persoanei care citește codul (inclusiv celui care l-a scris!). Există două moduri de a scrie comentarii: | ||
| + | |||
| + | <code c> | ||
| + | //Everything on this line is a comment. | ||
| + | This text is not a comment. It would cause errors when the compiler tries to translate it. | ||
| + | /* Comments like this can be written | ||
| + | on multiple lines */ | ||
| + | </code> | ||
| + | |||
| + | {{ :programare:laboratoare:god_only_knows.jpg?400 |}} | ||
| + | |||
| + | Ultima linie din funcția main, //return 0//; indică sfârșitul cu succes a programului în C și este obligatorie. Orice program are un exit code la sfârșitul rulării, care indică dacă programul a fost executat cu succes (acest cod este, în general, zero) sau nu (caz în care va fi returnată o altă valoare care semnifică un anumit cod de eroare). În cazul nostru, 0 este //exit// code.{{ :programare:laboratoare:error.png?400 |}} | ||
| + | |||
| + | |||
| + | |||
| + | ==== Unelte folosite ==== | ||
| + | |||
| + | === Compilatorul GCC === | ||
| + | |||
| + | În cadrul laboratorului și pentru testarea temelor de casă se va folosi compilatorul GCC. GCC este unul dintre primele pachete software dezvoltate în cadrul Proiectului GNU (''GNU's Not Unix'') de către Free Software Foundation. Deși GCC se traducea iniţial prin ''GNU C Compiler'', acesta a devenit între timp un compilator multifrontend, multi-backend, având suport pentru o serie largă de limbaje, ca C, C++, Objective-C, Ada, Java, etc, astfel că denumirea curentă a devenit ''GNU Compiler Collection''. În cadrul cursului de [[http://ocw.cs.pub.ro/programare|Programare]] ne vom referi totuşi numai la partea de C din suita de compilatoare. | ||
| + | |||
| + | Compilatorul GCC rulează pe o gamă largă de echipamente hardware (procesoare din familia: ''i386, alpha, vax, m68k, sparc, HPPA, arm, MIPS, PowerPC,'' etc.) și de sisteme de operare (''GNU/Linux, DOS, Windows 9x/NT/2000, Solaris, Tru64, VMS, Ultrix, Aix ''), fiind la ora actuală cel mai folosit compilator. | ||
| + | |||
| + | Compilatorul GCC se apelează din linia de comandă, folosind diferite opțiuni, în funcție de rezultatul care se dorește (specificarea de căi suplimentare de căutare a bibliotecilor/fișierelor antet, link-area unor biblioteci specifice, opțiuni de optimizare, controlul stagiilor de compilare, al avertisementelor, etc.). | ||
| + | |||
| + | === Utilizare GCC === | ||
| + | |||
| + | <note> | ||
| + | Instrucțiuni de instalare gcc - [[https://ocw.cs.pub.ro/courses/programare/vmchecker_conf#instalare_gccmake| Instalare gcc/make ]] | ||
| + | </note> | ||
| + | |||
| + | Vom folosi pentru exemplificare un program simplu care tipărește la ieșirea standard un șir de caractere. | ||
| + | |||
| + | <code c hello.c> | ||
| + | #include <stdio.h> | ||
| + | |||
| + | int main() { | ||
| + | printf("Hello from your first program!\n"); | ||
| + | return 0; | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | Pentru compilarea programului se va lansa comanda (în linia de comandă): | ||
| + | <code bash> gcc hello.c</code> | ||
| + | presupunând că fișierul sursă se numește ''hello.c''. | ||
| + | |||
| + | Pe un sistem de operare ''Linux'', compilarea default va genera un executabil cu numele ''a.out''. Pentru rularea acestuia, trebuie executată comanda: | ||
| + | <code bash> ./a.out</code> | ||
| + | |||
| + | Pentru un control mai fin al comportării compilatorului, sunt prezentate în tabelul următor cele mai folosite opţiuni (pentru lista completă studiaţi pagina de manual pentru GCC - ''man gcc''): | ||
| + | |||
| + | ^ Opțiune ^ Efect ^ | ||
| + | |**-o** nume_fișier|Numele fișierului de ieşire va fi nume_fişier. În cazul în care această opțiune nu este setată, se va folosi numele implicit (pentru fișiere executabile: a.out - pentru Linux).| | ||
| + | |**-I** cale_către_fișiere_antet|Caută fișiere antet și în calea specificată.| | ||
| + | |**-L** cale_către_biblioteci|Caută fișiere bibliotecă și în calea specificată.| | ||
| + | |**-l** nume_bibliotecă|Link-editează biblioteca ''nume_bibliotecă''. **Atenție!!!** ''nume_bibliotecă'' nu este întotdeauna același cu numele fișierului antet prin care se include această bibliotecă. Spre exemplu, pentru includerea bibliotecii de funcții matematice, fișierul antet este math.h, iar biblioteca este ''m''.| | ||
| + | |**-W** tip_warning|Afișează tipurile de avertismente specificate (Pentru mai multe detalii ''man gcc'' sau ''gcc --help''). Cel mai folosit tip este ''all''. Este indicat ca la compilarea cu ''-Wall'' să nu apară nici un fel de avertismente.| | ||
| + | |**-c**|Compilează și asamblează, dar nu link-editează. Generează fișiere obiect, cu extensia ''.o''.| | ||
| + | |**-S**|Se oprește după faza de compilare, fară să asambleze. Rezultă cod assembler în fișiere cu extensia ''.s''.| | ||
| + | |||
| + | Despre etapele compilării puteți să citiți mai multe [[http://elf.cs.pub.ro/so/wiki/laboratoare/laborator-01#fazele-compilarii|aici]]. | ||
| + | |||
| + | == Exemplu == | ||
| + | <code bash>gcc -o tema1 tema1.c -lm -Wall</code> | ||
| + | |||
| + | Comanda de mai sus are ca efect compilarea și link-editarea fişierului ''tema1.c'', cu includerea bibliotecii matematice, afişând toate avertismentele. Fişierul de ieşire se va numi ''tema1''. | ||
| + | |||
| + | **Atenție!!!** Dacă folosiți opțiunea **-o**, nu adăugați imediat după fișierele sursă. Acest lucru ar avea ca efect suprascrierea acestora și pierderea întregului conținut. | ||
| + | |||
| + | === Utilitarul Make === | ||
| + | |||
| + | <note> | ||
| + | Instrucțiuni de instalare gcc - [[https://ocw.cs.pub.ro/courses/programare/vmchecker_conf#instalare_gccmake| Instalare gcc/make ]] | ||
| + | </note> | ||
| + | |||
| + | Utilitarul ''make'' determină automat care sunt părțile unui proiect care trebuie recompilate ca urmare a operării unor modificări și declanşează comenzile necesare pentru recompilarea lor. Pentru a putea utiliza ''make'', este necesar un fișier de tip ''makefile'' (numit de obicei ''Makefile'' sau ''makefile'') care descrie relațiile de dependenţă între diferitele fișiere din care se compune programul şi care specifică regulile de actualizare pentru fiecare fişier în parte. | ||
| + | |||
| + | În mod normal, într-un program, fişierul executabil este actualizat (recompilat) pe baza fișierelor-obiect, care la rândul lor sunt obținute prin compilarea fișierelor sursă. Totuși, acest utilitar poate fi folosit pentru orice proiect care conţine dependenţe şi cu orice compilator/utilitar care poate rula în linia de comandă. Odată creat fișierul ''makefile'', de fiecare dată când apare vreo modificare în fișierele sursă, este suficient să rulăm utilitarul ''make'' pentru ca toate recompilările necesare să fie efectuate. Programul ''make'' utilizează fișierul Makefile ca bază de date şi pe baza timpilor ultimei modificări a fișierelor din Makefile decide care sunt fișierele care trebuie actualizate. Pentru fiecare din aceste fișiere, sunt executate comenzile precizate in Makefile. În continuare prezentăm un exemplu simplu. | ||
| + | |||
| + | <code bash> | ||
| + | # Declaratiile de variabile | ||
| + | CC = gcc | ||
| + | CFLAGS = -Wall -lm | ||
| + | SRC = radical.c | ||
| + | EXE = radical | ||
| + | |||
| + | # Regula de compilare | ||
| + | all: | ||
| + | $(CC) -o $(EXE) $(SRC) $(CFLAGS) | ||
| + | |||
| + | # Regulile de "curatenie" (se folosesc pentru stergerea fisierelor intermediare si/sau rezultate) | ||
| + | .PHONY : clean | ||
| + | clean : | ||
| + | rm -f $(EXE) *~ | ||
| + | </code> | ||
| + | |||
| + | **Atenție!!!** Este obligatorie folosirea tab-urilor (nu spații!). | ||
| + | Mai multe informații puteți găsiti pe [[http://www.gnu.org/software/make|pagina proiectului]]. | ||
| + | |||
| + | === Editoare === | ||
| + | |||
| + | Pentru editarea surselor se poate folosi orice editor de text. | ||
| + | |||
| + | **Exemple:** | ||
| + | |||
| + | * interfața în mod text | ||
| + | * [[http://www.vim.org|Vim]] | ||
| + | * [[http://www.gnu.org/software/emacs|Emacs]] | ||
| + | * [[http://www.nano-editor.org|nano]] | ||
| + | * interfață grafică | ||
| + | * [[https://code.visualstudio.com/docs/setup/linux | Visual Studio Code]] | ||
| + | * [[https://www.sublimetext.com/ | Sublime Text]] | ||
| + | * [[http://projects.gnome.org/gedit|gedit]] | ||
| + | * [[http://kate-editor.org|Kate]] | ||
| + | * [[https://www.jetbrains.com/clion|CLion]] (gratuit pentru studenți) | ||
| + | * [[https://www.codeblocks.org|Code::Blocks]] | ||
| + | |||
| + | |||
| + | ==== Interacțiunea program-utilizator ==== | ||
| + | |||
| + | Majoritatea algoritmilor presupun introducerea unor date de intrare și calcularea unor rezultate. În cazul programelor de consolă (cele scrise la laborator), datele sunt introduse de la tastatură și afișate pe ecran (alte variante sunt folosirea fișierelor sau preluarea datelor de la un hardware periferic). | ||
| + | |||
| + | Programul dat ca exemplu mai sus folosește funcția de afișare ''printf''. Această funcție realizează transferul și conversia de reprezentare a valorii întregi / reale in șir de caractere sub controlul unui format (specificat ca un șir de caractere): | ||
| + | <code c> | ||
| + | printf("format", expr_1, expr_2, ..., expr_n); | ||
| + | </code> | ||
| + | unde ''expr_i'' este o expresie care se evaluează la unul din tipurile fundamentale ale limbajului. Este necesar ca pentru fiecare expresie să existe un specificator de format, şi viceversa. | ||
| + | |||
| + | În caz contrar, compilatorul va returna o eroare (în afara cazului în care formatul este obtinut la rulare). | ||
| + | Sintaxa unui descriptor de format este: | ||
| + | <code> | ||
| + | % [ - ] [ Lung ] [ .frac ] [ h|l|L ] descriptor | ||
| + | </code> | ||
| + | |||
| + | Semnificația câmpurilor din descriptor este descrisă în tabelul următor: | ||
| + | |||
| + | ^ Câmp ^ Descriere ^ | ||
| + | |**-**|Indică o aliniere la stânga în câmpul de lungime ''Lung'' (implicit alinierea se face la dreapta).| | ||
| + | |**Lung**|Dacă expresia conține mai puțin de ''Lung'' caractere, ea este precedată de spații sau zerouri, dacă ''Lung'' începe printr-un zero. Dacă expresia conține mai mult de ''Lung'' caractere, câmpul de afișare este extins. În absența lui ''Lung'', expresia va fi afișată cu atâtea caractere câte conține.| | ||
| + | |**frac**|Indică numărul de cifre după virgulă (precizia) cu care se face afișarea.| | ||
| + | |**l**|Marchează un ''long int'', în timp ce pentru reali ''l'' determină afișarea unei valori double.| | ||
| + | |**h**|Marchează un ''short int''.| | ||
| + | |**L**|Precede unul din descriptorii ''f'', ''e'', ''E'', ''g'', ''G'' pentru afișarea unei valori de tip ''long double''.| | ||
| + | |||
| + | Tabelul următor prezintă descriptorii și conversiile care au loc: | ||
| + | |||
| + | ^ Descriptor ^ Descriere ^ | ||
| + | |**d**|Întreg cu semn în baza 10.| | ||
| + | |**u**|Întreg fără semn în baza 10.| | ||
| + | |**o**|Întreg fără semn în baza 8.| | ||
| + | |**x** sau **X**|Întreg fără semn în baza 16. Se folosesc literele a, b, c, d, e, f mici, respectiv mari.| | ||
| + | |**c**|Caracter.| | ||
| + | |**s**|Șir de caractere.| | ||
| + | |**f**|Real zecimal de forma [-]xxx.yyyyyy (implicit 6 cifre după virgulă)| | ||
| + | |**e** sau **E**|Real zecimal în notație exponențială. Se folosește e mic, respectiv E mare.| | ||
| + | |**g**|La fel ca și e, E și f dar afișarea se face cu număr minim de cifre zecimale.| | ||
| + | |||
| + | |||
| + | Citirea cu format se realizează cu ajutorul funcției ''scanf()'' astfel: | ||
| + | <code c> | ||
| + | scanf("format", &var_1, &var_2, ..., &var_n); | ||
| + | </code> | ||
| + | care citește valorile de la intrarea standard în formatul precizat și le depune în variabilele ''var_i'', returnând numarul de valori citite. | ||
| + | |||
| + | **Atenție!!!** Funcția ''scanf'' primește adresele variabilelor în care are loc citirea. Pentru tipuri fundamentale și/sau structuri, aceasta se obține folosind operatorul de adresă - ''&''. | ||
| + | |||
| + | Sintaxa descriptorului de format în acest caz este: | ||
| + | <code> | ||
| + | % [*] [ Lung ] [ l ] descriptor | ||
| + | </code> | ||
| + | Semnificația campurilor din descriptor este descrisă în tabelul următor: | ||
| + | |||
| + | ^ Câmp ^ Descriere ^ | ||
| + | |** * **|Indică faptul că valoarea citită nu se atribuie unei variabile. (valoarea citită poate fi folosită pentru specificarea lungimii câmpului)| | ||
| + | |**Lung**|Indică lungimea câmpului din care se face citirea. În cazul în care e nespecificat, citirea are loc până la primul caracter care nu face parte din număr, sau până la '\n' (linie nouă/enter).| | ||
| + | |**d**|Întreg în baza 10.| | ||
| + | |**o**|Întreg în baza 8.| | ||
| + | |**x**|Întreg în baza 16.| | ||
| + | |**f**|Real.| | ||
| + | |**c**|Caracter.| | ||
| + | |**s**|Șir de caractere.| | ||
| + | |**L**|Indică un întreg long sau un real double.| | ||
| + | |**h**|Indică un întreg short.| | ||
| + | |||
| + | Pentru scrierea și citirea unui singur caracter, biblioteca ''stdio.h'' mai definește și funcțiile ''getchar()'' și ''putchar()'': | ||
| + | * ''getchar()'' are ca efect citirea cu ecou a unui caracter de la terminalul standard. Caracterele introduse de la tastatură sunt puse într-o zonă tampon, până la acționarea tastei ''ENTER'', moment în care în zona tampon se introduce caracterul rând nou. Fiecare apel ''getchar()'' preia următorul caracter din zona tampon. | ||
| + | * ''putchar()'' afișează caracterul având codul ASCII egal cu valoarea expresiei parametru. | ||
| + | |||
| + | **Nota:** ''getchar()'' și ''putchar()'' nu sunt de fapt funcții, ci niște macroinstrucțiuni definite în ''stdio.h'' | ||
| + | |||
| + | Pentru citirea și scrierea unei linii biblioteca ''stdio.h'' definește funcțiile ''gets()'' și ''puts()'': | ||
| + | * ''gets(zona)'' - introduce de la terminalul standard un șir de caractere terminat prin acționarea tastei ''ENTER''. Funcția are ca parametru adresa zonei de memorie în care se introduc caracterele citite. Funcția returnează adresa de început a zonei de memorie; la întalnirea sfarșitului de fișier (CTRL+Z) funcția returnează ''NULL''. | ||
| + | * ''puts(zona)'' - afișează la terminalul standard șirul de caractere din zona dată ca parametru, până la caracterul ''null'' (''\0''), care va fi înlocuit prin caracterul linie nouă. Funcția returnează codul ultimului caracter din șirul de caractere afișate sau ''-1'' în caz de eroare. | ||
| + | |||
| + | ===== Exerciții laborator CB/CD ===== | ||
| + | |||
| + | Urmați indicațiile împreună cu asistenul de la laborator. | ||
| + | |||
| + | <hidden> | ||
| + | ** Desfăsurător laborator introducere:** | ||
| + | * asistentul se prezintă, spune cum îl cheamă, cum preferă să fie contactat și câteva lucruri despre experiența lui în domeniu | ||
| + | * studenții sunt puși pe rând să se prezinte, să spună de la ce liceu/oraș vin, ce experiență anterioară au cu programarea, dacă au făcut C/C++ în liceu (pentru a îi remarca pe cei care nu au făcut asta și pentru a îi ajuta mai mult la început), și, mai ales, ce așteptări au și ce i-a motivat să vină aici | ||
| + | * experiența spune că majoritatea studenților au făcut C/C++ în liceu | ||
| + | * asistentul poate continua discuția pentru încă câteva minute, pe baza a ceea ce observă din discuțiile anterioare | ||
| + | * asistentul prezintă regulamentul, punctajul și îi pune să semneze declarația anti-copiat | ||
| + | |||
| + | ** Hands-on: ** | ||
| + | * asistentul va scrie împreună cu studenții un program Hello World pe tablă; întreabă, studenții răspuns... construiește împreună și _explică_ după ce notează pe tablă pentru a putea înțelege de ce sunt lucrurile astfel și cei care nu știu | ||
| + | * orice program are în mod obligatoriu funcția **main** | ||
| + | * cum definim funcția main? | ||
| + | * pentru a afișa un mesaj folosim printf. | ||
| + | * se vor explica **printf** și **scanf** | ||
| + | * trebuie să punem return 0; de ce? ce înseamnă 1? ce se întâmpla dacă puneam void la main? de ce punem int? | ||
| + | * #include<stdio.h>, stdlib.h... ce sunt bibliotecile? de ce? | ||
| + | * după ce toate lucrurile sunt lămurite, asistentul îi pune pe studenți să încerce să scrie și ei în mod practic; | ||
| + | * pentru că e prima dată când lucrează sub Linux (pentru majoritatea), vor fi ghidați pas cu pas | ||
| + | * pentru început vor fi puși să deschidă un terminal | ||
| + | * vor tasta comanda **ls** | ||
| + | * vor tasta comanda **pwd** | ||
| + | * vor tasta comanda **cd Desktop** | ||
| + | * vor tasta din nou ls și pwd | ||
| + | * vor tasta comanda **cd ..** | ||
| + | * li se va explica pe scurt structura de fișiere/directoare | ||
| + | * pentru început vor deschide un editor: | ||
| + | * tastați comanda: **gedit** | ||
| + | * ce observați că se întâmplă în terminal? rulați comanda ls | ||
| + | * vor închide editorul | ||
| + | * vor tasta comanda: **gedit &** | ||
| + | * ce observați că se întâmplă în terminal? rulați comanda ls | ||
| + | * vor fi încurajați să folosească varianta asta | ||
| + | * li se va spune că vor înțelge mai pe larg simbolul **&** la USO | ||
| + | * în editorul deschis, vor fi puși să salveze fișierul nou creat în home-ul utilizatorului student cu numele **hello.c** | ||
| + | * vor fi puși să scrie un program care citește un număr natural și îl afișează | ||
| + | * asistentul va trece pe la fiecare și se va asigura că cel puțin pare că toată lumea a procedat corect | ||
| + | * dacă sunt observații, le va face punctual, fiecăruia | ||
| + | * dacă o observație se repetă, o va face în mod generic | ||
| + | * vor fi puși să salveze din nou | ||
| + | * li se va explica comanda **gcc**, cu prezentarea param **-o** și **-Wall** | ||
| + | * vor rula | ||
| + | * asistentul se va asigura că toată lumea a procedat corect | ||
| + | |||
| + | Dacă mai e timp, se poate da o problemă, fie de mai jos, fie alta, fie se poate discuta mai mult despre așteptările lor și despre cum ar fi bine să fie proactivi și să se implice în diverse cursuri/activități extracurriculare. | ||
| + | </hidden> | ||
| + | |||
| + | ===== Probleme ===== | ||
| + | |||
| + | - Compilați programul din laborator ([[http://ocw.cs.pub.ro/courses/_export/code/programare/laboratoare/lab01?codeblock=0|hello.c]]) utilizând ''gcc''. | ||
| + | * folosiți un fișier de tip ''makefile'' | ||
| + | * executabilul se va numi ''hello'' | ||
| + | - Într-un director care conține fișierul ''hello.c'' și **nu** conține niciun fișier de tip ''makefile'' rulați comanda: <code>make hello</code> Ce observați? | ||
| + | - Se citește de la tastatură un număr natural în baza 10. Să se afișeze în bazele 8, 10 și 16. | ||
| + | - Se citesc de la tastatură două numere reale. Să se afișeze suma, diferenta și media lor cu precizie de 5 zecimale exacte. | ||
| + | - Să se calculeze (folosind formule matematice; nu instrucțiuni repetitive) și să se afișeze sumele (''n'' se va citi de la tastatura): | ||
| + | * \begin{eqnarray*}& & S_1 = \sum_{k=0}^n {k}\end{eqnarray*} | ||
| + | * \begin{eqnarray*}& & S_2 = \sum_{k=0}^n {k^2}\end{eqnarray*} | ||
| + | - Să se determine minimul și maximul a două numere folosind funcția matematiă ''fabs''. | ||
| + | * afișați rezultatul cu două zecimale | ||
| + | * **Atenție!** Trebuie să includeți antetul ''math.h'' și să compilați cu opțiunea ''-lm'' | ||
| + | - Se citesc de la tastatură două numere reale. Să se afișeze ''EQ'' dacă cele două numere sunt egale cu precizie de 4 zecimale; în caz contrar se va afișa mesajul ''NOT EQ''. | ||
| + | |||
| + | ==== Extra ==== | ||
| + | * [[https://github.com/cs-pub-ro/ComputerProgramming/blob/master/Laboratories/Lab1/cheatsheet.pdf|Cheatsheet]] | ||
| + | |||
| + | <hidden> | ||
| + | ==== Soluții ==== | ||
| + | |||
| + | {{:programare:laboratoare:1-solutions.zip|}} | ||
| + | </hidden> | ||
