Cbira: Pagină nouă: În acest laborator ne vom reaminti sintaxa limbajului C, vom exersa utilizarea mediului de dezvoltare CLion și a ''debugger''-ului. == Tool-ul de depanare GDB == Depanatorul GNU...

2026-02-20T07:34:16Z

Pagină nouă: În acest laborator ne vom reaminti sintaxa limbajului C, vom exersa utilizarea mediului de dezvoltare CLion și a ''debugger''-ului. == Tool-ul de depanare GDB == Depanatorul GNU...

Pagină nouă

În acest laborator ne vom reaminti sintaxa limbajului C, vom exersa utilizarea mediului de dezvoltare CLion și a ''debugger''-ului.

== Tool-ul de depanare GDB ==
Depanatorul GNU, cunoscut drept GDB (GNU debugger), este depanatorul standard pentru sistemul de software GNU.<br>
Scopul unui depanator precum GDB este de a permite utilizatorului să vadă ce se întâmplă în interiorul unui alt program în timp ce acesta se execută (pentru a determina motivul rezultatelor necorespunzătoare) sau ce s-a întâmplat cu programul în momentul în care a fost întreruptă execuţia în mod neaşteptat.<br><br>

GDB este capabil de a îndeplini 4 categorii de operații (și alte operaţii intermediare lor):
* să pornească programul, specificând orice ar putea interveni în buna funcționare a acestuia;
* să determine o pauză in execuţia programului în anumite condiții specificate de utilizator;
* să examineze ce s-a întâmplat în momentul opririi programului;
* să modifice anumite valori în program pentru a putea corecta efectele unui bug și a investiga urmările altuia.<br>
Odată pornit, GDB citește comenzi din terminal până la întâlnirea comenzii de ieșire "quit".<br>
<div class="regula">'''<font color="red"> Atenție:</font>''' Pentru a putea folosi debugger-ul, la generarea fișierului executabil trebuie folosită opțiunea '''-g''', care adaugă simboluri de debug în executabil, fără de care depanarea nu este posibilă. (vezi [http://wiki.dcae.pub.ro/index.php/PC_Laborator_1 Laboratorul 1])</div>
Exemplul unei comenzi de compilare în vederea depanării:<br>

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gcc -g hello.c -o hello'''

=== Comenzi specifice GDB ===
Cea mai folosită modalitate de a porni tool-ul de depanare este de a scrie '''gdb''' în terminal, urmat de numele executabilului ce se dorește a fi depanat.

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gdb hello'''

O parte din comenzile cele mai utilizate ale GDB sunt următoarele (pentru lista completă studiați pagina de manual GDB - man gdb):
{| class="wikitable"
! Opțiune !! Efect
|-
| <code style="color: green">break</code> [nume_fișier:] nume_funcție <br> <code style="color: green">break</code> [nume_fișier:] număr_linie || Setează un breakpoint (punct de întrerupere) la începutul funcției ''nume_funcție'' sau la linia specificată prin ''număr_linie'' din fișierul specificat prin ''nume_fișier''.
|-
| <code style="color: green">run</code> [listă_argumente] || Pornește programul în execuție (cu lista de argumente, dacă au fost specificate).
|-
| <code style="color: green">bt</code> || Backtrace: afișează stiva de program.
|-
| <code style="color: green">print</code> expresie || Afișează valoarea unei expresii (valoarea stocată într-o variabilă, valoarea returnată de o funcție etc.).
|-
| <code style="color: green">c</code> || Continuă execuția programului (după ce a fost oprit, spre exemplu după un breakpoint).
|-
| <code style="color: green">next</code> || Execută următoarea linie de program (după oprire), sărind peste orice apel de funcție care se găsește în această linie.
|-
| <code style="color: green">list</code> [nume_fișier:] nume_funcție || Afișează liniile de cod ale programului din vecinătatea locului unde este oprit acum.
|-
| <code style="color: green">step</code> || Execută următoarea linie de program (după oprire), intrând în orice funcție apelată de acea linie.
|-
| <code style="color: green">help</code> [nume] || Afișează informații despre comanda GDB ''nume'' sau informații generale despre utilizarea GDB.
|-
| <code style="color: green">quit</code> || Iese din GDB.
|}

<div class="regula"> ''' Observație: ''' Cele mai multe dintre aceste comenzi pot fi apelate doar prin prima literă a numelui lor. </div>
Spre exemplu, următoarea comandă:
'''(gdb) next'''
este identică cu:
'''(gdb) n'''
<div class="regula"> ''' Observație: ''' Dacă se apasă pe enter fără a scrie o comandă, se repetă ultima comandă specificată.</div>

=== Exemplu de depanare ===
Se dă fișierul sursă ''suma_fact.c'', care conține următoarele instrucțiuni:
<syntaxhighlight lang="C">
#include<stdio.h>

unsigned int factorial(int n) {
if (n == 0) {
return 1;
}
int i;
unsigned int fact = 0;
for (i = 1; i <= n; i++){
fact *= i;
}
return fact;
}

int main() {
int n, i;
do {
printf("Introduceti un numar natural mai mic sau egal cu 8: ");
scanf("%d", &n);
} while (n < 0 || n > 8);
unsigned int suma = 0;
for (i = 0; i <= n; i++) {
suma += factorial(i);
}
printf("%u\n", suma);
return 0;
}
</syntaxhighlight>
Programul își propune să calculeze suma factorialelor de la 0 la n, unde n este introdus de la tastatură. Dacă rulăm programul vom obține ca rezultat numărul '''1''', indiferent de ce a fost introdus de la tastatură. Ne propunem să descoperim bug-ul folosind GDB.<br>
Compilăm sursa, adăugând simboluri de debug în executabil, după care lansăm în execuție debugger-ul:

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gcc -g suma_fact.c -o suma_fact'''
'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gdb suma_fact'''

<div class="regula">'''<font color="red"> Atenție:</font>''' Comanda de mai sus lansează în execuție numai debugger-ul, nu și programul ''suma_fact''.</div>
<div class="regula"> ''' Observație: ''' Putem observa că am pornit debugger-ul prin faptul că fiecare rând nou din linia de comandă începe acum astfel:</div>
'''(gdb)'''
Punem un ''breakpoint'' la linia 20, unde se citește valoarea lui n:
'''(gdb) b 20'''
'''Breakpoint 1 at 0x80484c2: file suma_fact.c, line 20.'''
'''(gdb) '''

Pornim programul în interiorul debugger-ului:
'''(gdb) run'''
'''Starting program: /home/student/Desktop/suma_fact'''
''' '''
'''Breakpoint 1, main () at suma_fact.c:20'''
'''20 scanf("%d", &n);'''
'''(gdb) '''
Trecem mai departe și introducem o valoare pentru n:
'''(gdb) next'''
'''Introduceti un numar natural mai mic sau egal cu 8: 6 '''
'''21 }while(n<0 || n>8);'''
'''(gdb) '''
Vom parcurge programul pas cu pas până la apelarea funcției ''factorial'':
'''(gdb) n'''
'''22 unsigned int suma = 0;'''
'''(gdb) n'''
'''23 for(i=0; i<=n; i++){'''
'''(gdb) n'''
'''24 suma += factorial(i);'''
'''(gdb) s'''
'''factorial (n=0) at suma_fact.c:4'''
'''4 if(n==0){'''
'''(gdb) s'''
'''5 return 1;'''
'''(gdb) s'''
'''13 }'''
'''(gdb) s'''
'''main () at suma_fact.c:23'''
'''23 for(i=0; i<=n; i++){'''
'''(gdb) s'''
'''24 suma += factorial(i);'''
'''(gdb) s'''
'''factorial (n=1) at suma_fact.c:4'''
'''4 if(n==0){'''
'''(gdb) s'''
'''8 unsigned int fact=0;'''
'''(gdb) s'''
'''9 for(i=1; i<=n; i++){'''
'''(gdb) s'''
'''10 fact *= i;'''
'''(gdb) s'''
'''9 for(i=1; i<=n; i++){'''
'''(gdb) s'''
'''12 return fact;'''
'''(gdb) print fact'''
'''$1 = 0'''
'''(gdb) '''
Observăm că valoarea returnată de funcția ''factorial'' pentru orice număr nenul este '''0'''. Acest lucru se datorează inițializării variabilei ''fact'' cu valoarea '''0''' la începutul funcției ''factorial''. Putem ieși din debugger pentru a modifica linia 8 din fișierul sursă suma_fact.c:
'''(gdb) q'''
'''A debugging session is active.'''
''' '''
''' Inferior 1 [process 4279] will be killed.'''
''' '''
'''Quit anyway? (y or n) y '''
'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span>'''
<div class="regula"> ''' Observație: ''' Pentru a putea intra în interiorul funcției ''factorial'' este absolut necesar să se folosească comanda '''step''' și nu comanda '''next''' care ar trece peste acea linie 24 fără a intra în corpul funcției ''factorial''.</div>

După acest laborator veți putea folosi IDE-ul CLion pentru a scrie și depana programe în C. Totodată veți relua și recapitula noțiunile legate de pointeri în C.

= Utilizarea IDE-ului CLion =

[https://www.jetbrains.com/clion CLion] este un mediu integrat de dezvoltare (IDE) care permite dezvoltarea de programe în limbajele C și C++. CLion nu instalează și compilator pentru C/C++, acesta trebuie instalat manual, în prealabil.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Imaginea de Linux folosită la Programarea Calculatoarelor are deja instalat compilatorul de C.</div>

== Instalarea GCC ==

=== Instalarea GCC în Linux ===

Pentru instalarea compilatorului de C (GCC) în distribuțiile de Linux provenite din Ubuntu (Ubuntu, Kubuntu, Xubuntu, Mint, LMDE, etc.) se poate folosi comanda:

apt-get install -y build-essential

=== Instalarea GCC în Windows ===

Pentru compilarea de programe cu GCC în Windows, aveți nevoie de instalarea acestui compilator care poate fi făcută prin instalarea unuia din următoarele două suite de programe:
* [https://cygwin.com Cygwin] - Tutorial de instalare [https://cygwin.com/install.html aici].
* [http://www.mingw.org/ MinGW] - Tutorial de instalare [http://www.mingw.org/wiki/InstallationHOWTOforMinGW aici].

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Nu uitați ca la instalare să bifați în lista de pachete și compilatorul de C (<code>gcc</code>), <code>make</code> și <code>git</code>.</div>

== Instalarea CLion ==

De la adresa https://www.jetbrains.com/clion/download/#section=linux puteți descărca kitul de instalare pentru sistemul vostru de operare.
După instalare, urmaţi următorii paşi de configurare, în funcţie de suita de programe aleasă:
* [https://www.jetbrains.com/help/clion/quick-tutorial-on-configuring-clion-on-windows.html#Cygwin Configurare CLion cu Cygwin]
* [https://www.jetbrains.com/help/clion/quick-tutorial-on-configuring-clion-on-windows.html#MinGW Configurare CLion cu MinGW]

== Realizarea unui proiect ==

Odată pornit, CLion oferă posibilitatea de a deschide un proiect existent, sau de a crea unul nou. Vrem să realizăm un proiect nou, aşadar se va alege '''New Project'''.

<div class="regula"> ''' Observație: ''' Se poate realiza un nou proiect atunci când altul este deja deschis folosind meniul <code>File - New Project </code> .</div>

[[Fișier:Welcome_to_clion.png | 600px | Imaginea 1]]

<br> Mai departe se va selecta categoria '''C++ Executable''' şi se va introduce locaţia proiectului.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> În imagine se observă că locaţia introdusă este '''/home/student/projects/NewProject'''. Se recomandă ca directorul în care se realizează proiectul să aibă numele proiectului, sau un nume sugestiv (în imagine '''NewProject''')</div>

[[Fișier:New_project_location_clion.png | 600px | Imaginea 2]]

== Componentele IDE-ului CLion ==

[[Fișier:CLion_env.png | 1000px | Imaginea 3]]

La crearea unui nou proiect, IDE-ul CLion generează automat fişierul '''main.cpp'''. Acesta conţine un exemplu program ce va fi rescris de către utilizator. <br>

Secţiunile marcate în imagine reprezintă:
# Zona <span style="color: green">verde</span> - '''Project view''' indică toate fişierele şi directoarele ce alcătuiesc proiectul.
# Zona <span style="color: blue">albastră</span> - '''Editor''' este fereastra de vizualizare şi editare a textului
# Zona <span style="color: red">roşie</span> - '''Toolbar''' oferă acces rapid pentru operaţiile uzuale. Dintre acestea, cel mai des vom folosi:
#*'''Build''' [[Fișier:CLion_build_button.png | 16px]]
#*'''Run''' [[Fișier:CLion_run_button.png | 16px]]
#*'''Debug''' [[Fișier:CLion_debug_button.png | 16px]]
# Zona <span style="color: gold">galbenă</span> - '''Run''' este zona în care se introduc datele de intrare şi se în care vor fi afişate datele de ieşire.

== Exemplu de program în modul ''debug'' ==

Copiați codul de mai jos înlocuind programul deja existent în fișierul ''main.c'':
<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(){
printf("Debugging program...\n");
int value = 0;
value = value + 1;
value++;
value = value * 2;
value -= 1;
printf("Value is now %d!\n", value);
return 0;
}
</syntaxhighlight>

Pentru a executa programul în modul debug trebuie sa introducem cel puţin un '''breakpoint'''. Astfel indicăm programului unde se va opri pentru a ne acorda control asupra execuţiei, având posibilitatea de a continua execuţia pas cu pas. <br>

Introducem un nou breakpoint dând click în dreptul liniei de la care vrem să obţinem controlul. În cazul nostru, vom alege să indroducem un breakpoint chiar la definirea variabilei <code>value</code>.

[[Fișier:CLion_breakpoint.png | 1000px | Imaginea 4]]

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Când alegem locaţia unui breakpoint trebuie să ţinem cont de următorul aspect: în modul '''debug''' programul se va opri '''înainte''' de a executa linia în dreptul căreia a fost introdus breakpoint-ul!</div>

În continuare, trebuie se pornim execuţia programului in modul debug [[Fișier:CLion_debug_button.png | 16px]]. Observăm apariţia ferestrei Debug (chenarul albastru, Imaginea 5) ce conţine următoarele:
#Zona <span style="color: gold">galbenă</span> - fereastra cu toate variabilele declarate, împreună cu valorile lor. Momentan nu există nicio variabilă declarată (deoarece linia asupra la care ne-am oprit nu a fost încă executată!)
#Zona <span style="color: red">roşie</span> - Permite trecerea între fereastra pentru procesul de depanare ('''Debugger''') şi fereastra în care se afişează/introduc datele ('''Console''')
#Zona <span style="color: green">verde</span> - Conţine comenzile pentru controlul execuţiei în modul debug (comenzi numite '''stepping actions'''):
#*'''Step over''' [[Fișier:CLion_step_over.png | 16px]] - Execută comenzile de pe linia curentă şi trece la următoarea linie
#*'''Step into''' [[Fișier:CLion_step_into.png | 16px]] - Programul va executa linia curentă iar dacă pe linia curentă există un apel de funcție, se va opri pe prima linie din funcția respectivă. Această comandă este utilă atunci cand pe linia curentă se află un apel de funcţie şi vrem sa studiem comportamentul codului din interiorul funcţiei.
#*'''Step out''' [[Fișier:CLion_step_out.png | 16px]] - Termină de executat funcţia în care se află linia curentă
#*'''Run to cursor''' [[Fișier:CLion_run_to_cursor.png | 16px]] - Execută toate instructiunile până se intâlneste cursorul.

<div class="regula"> ''' Observație: ''' În modul debug, linia curentă este marcată de către mediul de dezvoltare prin colorarea acesteia cu albastru.</div>

Alte comenzi utile:
*'''Resume program''' [[Fișier:CLion_resume_project.png | 16px]] - Continuă execuţia pâmă la următorul breakpoint (dacă nu există, se va executa până la final)
*'''Stop''' [[Fișier:CLion_stop.png | 16px]] - Se opreşte definitv execuţia programului, împreună cu modul debug

[[Fișier:CLion_debug_process.png | 1000px | Imaginea 5]]<br>

Pentru a exersa utilizarea sistemului de debug, realizați următoarele operații:
# Parcurgeti tot programul folosind '''Step Over''' și vizualizând valoarea variabilei <code>value</code> la fiecare pas, până la ultima linie din program, unde utilizați '''Resume program'''.
# Reporniți aplicația în modul de debug și puneți un al doilea ''breakpoint'' pe linia cu apelul funcției <code>printf</code>.
# Folosiți '''Resume program''' pentru a ajunge la al doilea ''breakpoint''.
# Odată ajunși acolo, folosiți '''Step In''' pentru a intra în funcția <code>printf</code> (neavând codul sursă, veți vedea codul de asamblare obținut din dezasamblarea fișierului obiect de către GDB).
# Folosiți '''Step Out''' pentru a reveni în funcția <code>main</code> și apoi '''Resume program''' pentru a termina execuția.

== Tips & Tricks ==

=== Formatare automată a codului ===

CLion oferă opțiunea de a formata automat codul prin selectarea '''Code -> Reformat Code'''.

Ce probleme rezolvă această formatare automată:
* alinierea liniilor în funcție de blocurile de instrucțiuni și tipurile de ''statements'' de pe fiecare linie;
* plasarea sau eliminarea de spații acolo unde este necasar.
Ce probleme NU rezolvă această formatare automată;
* lipsa acoladelor de la blocurile '''if''' și '''for''';
* numele insuficient de sugestive pentru numele de funcții, structuri sau variabile.

Stilul conform căruia este modificat codul poate fi configurat folosind meniul <code>File|Settings|Editor|CodeStyle</code>

=== Generare automată a codului ===

CLion oferă posibilitatea de a genera fragmente de cod des înâlnite, precum constructori şi operatori în interiorul claselor. Această acţiune poate fi realizată folosind meniul <code> Code|Generate</code>.

=== Altele ===
* [https://www.jetbrains.com/help/clion/using-todo.html TODO Comments]

<br> Nu uitați de regulile următoare: [[Convenții de cod - C]]

C++ POO Lab Utile - Revizia istoricului

Cbira: Pagină nouă: În acest laborator ne vom reaminti sintaxa limbajului C, vom exersa utilizarea mediului de dezvoltare CLion și a ''debugger''-ului. == Tool-ul de depanare GDB == Depanatorul GNU...