WikiLabs - Contribuții utilizator [ro]

PC Laborator 13

2017-01-11T20:44:17Z

Lflueratoru: /* Exerciții */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil să:
* să lucreze cu fișiere text: deschidere, citire, scriere, închidere
* să înțeleagă modul de funcționare al fișierelor binare

== Informații generale ==
Datele pot fi stocate temporar în memoria internă, dar la închiderea programului acestea se vor pierde. Pentru suportul acestui dezavantaj se poate folosi noțiunea de fișier, desigur stocat in memoria externă. Memoria externă furnizează o capacitate de stocare mult mai mare decât memoria internă, nu este volatilă, deci nu-şi pierde conţinutul la o eventuală întrerupere, dar are ca principal dezavantaj viteza de transfer a datelor redusă.

Prelucrarea unui fişier presupune asocierea acestuia cu un canal de I/E (numit flux sau '''stream''').(vezi [[PC Laborator 3#Stream-urile standard ale unui proces|PC Laborator 3]]).

Limbajul C permite operarea cu fişiere:

*text - fişier ce conţine o succesiune de linii
*binare - fişier conţine o succesiune de octeti, fără o structură.

*"b" - specifică fişier de tip binar
*"t" - specifică fişier de tip text (implicit)

== Operații cu fișiere ==

Pentru a avea acces la informaţiile dintr-un fişier, se realizează următoarele operaţii:
* deschiderea fişierului
* citirea/scrierea conţinutului fişierului
* închiderea fisierului

<div class="regula">'''<font color="red"> '''Observatie:'''</font> '''Operaţiile cu fişierele se realizează prin intermediul unui set de funcţii din
biblioteca standard de intrare/ieşire (I/O), deci este necasară includerea fişierului header '''stdio.h'''.</div>

Atunci când intenționăm să lucrăm cu fişiere este necesar să ne definim un pointer către o structură de tipul FILE.
O structură de tipul FILE este o structură de control a streamurilor.
Această structură păstrează informaţii cum ar fi adresa de început, poziţia indicatorului de fişier, poziţia indicatorului de sfârşit a fişierului și altele.
Pentru a se putea utiliza un fişier, este necesară folosirea unui pointer. Acesta este un pointer către anumite informaţii
despre fişierul respectiv – nume, starea şi poziţia în care se află poinetrul de fişier.
<syntaxhighlight lang="C">
FILE * fisier;
</syntaxhighlight>

=== Deschiderea fișierelor ===

Fişierele necesită a fi inițializate, le trebuie asociat un fişier fizic de pe dispozitivul de stocare.

<syntaxhighlight lang="C">
FILE *fopen(const char *nume_fișier, const char *mod);
</syntaxhighlight>

:FILE -returnează un pointer la fișier
:nume_fișiere -se specifică numele sau calea acestuia
:mod -se specifică modul de deschidere al fișierului

'''Moduri de deschidere al fișierelor:'''

* "r" - (read only), permite deschiderea doar pentru citirea conținutului
* "w" - (write), crează un nou fişier în care se pot scrie date. Dacă exista deja un fișier cu acest nume, conținutul va fi sters
* "a" - (append), deschide pentru scriere într-un fişier existent (scrierea se va face în continuare) -adăugare-
* "r+" - deschide un fişier pentru actualizarea datelor, permite atât scriere cât şi citire
* "w+" - crează un fişier nou în care se vor putea scrie cât şi citi date.
* "a+" - deschide un fişier pentru adăugare de date cât şipentru citire. Operațiile de scriere vor fi efectuate în continuarea datelor existente

<div class="regula">'''<font color="red"> Observatie:</font> '''Dacă operaţia de deschidere eşuează, funcţia returnează valoarea NULL. Dacă deschiderea
reuşeşte, funcţia returnează o valoare de tip FILE *.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen("exemplu.txt", "w");

if (fisier == NULL) {
printf("Fisierul nu poate fi creat.");
} else {
printf("Fisierul a fost creat");
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În acest mod se confirmă și crearea corectă a fișierului, fiind o practică recomandată.'''</div>

=== Închiderea fișierelor ===

După ce sunt folosite, fişierele trebuie închise. Atunci când execuţia programului se încheie cu succes
(fie prin încheierea execuţiei funcţiei main (), fie prin apelarea funcţiei exit() ), toate fişierele
deschise în momenul respectiv sunt automat închise.
Închiderea unui fişier se face cu funcţia fclose ().
<syntaxhighlight lang="C">
int fclose(FILE *fisier)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''Funcţia fclose() returnează 0 dacă operaţia de închidere a fişierului s-a realizat cu succes şi EOF dacă a intervenit o eroare.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen("/work/pc/F/group1/ion/lab13/test.txt", "w");

if (fisier == NULL) {
printf("Fisierul nu a putut fi creat");
} else {
//...
fclose(fisier);
}
</syntaxhighlight>

=== Parcurgerea fișierelor ===

Orice fişier, odată deschis, are asociat un cursor care indică poziţia curentă în fişierul respectiv (inițial această poziție este la începutul fişierului). Funcţiile de scriere şi citire din fişiere operează începand de la poziţia curentă a cursorului.
Totodată, orice operaţie de scriere sau citire avansează automat acest cursor cu numărul de octeţi citiţi/scrişi.

Poziția curent este dată de funcția ftell():
<syntaxhighlight lang="C">
int ftell(FILE *fisier)
</syntaxhighlight>

Poziţionarea cursorului pe o anumita poziţie se poate face folosind funcţia fseek():
<syntaxhighlight lang="C">
int fseek(FILE *fisier, long pozitie, int referinta)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În termeni uzuali se folosește long offset, int whence. Offset fiind numărul de octeți peste care se deplasează, iar whence poziția cursorului'''</div>

Whence poate avea una din cele trei valori posibile:
*SEEK_SET = 0 - Căutarea se face de la începutul fişierului
*SEEK_CUR = 1 - Căutare din poziţia curentă
*SEEK_END = 2 - Căutare de la sfârşitul fişierului

=== Citirea şi scrierea în/din fişiere ===
<div class="sfat">'''
În cazul în care se lucrează cu fişiere text se folosesc în mod uzual următoarele funcţii:
*scriere: <code style="color: green">fputs()</code> şi <code style="color: green">fprintf()</code>
*citire: <code style="color: green">fgets()</code> şi <code style="color: green">fscanf()</code>

''' Funcţiile <code style="color: green">fscanf()</code> şi <code style="color: green">fprintf()</code> funcţionează identic cu funcţiile <code style="color: green">scanf()</code> şi <code style="color: green">printf()</code>, cu deosebirea că citirea respectiv scrierea operează asupra unui fişier specificat ca prim parametru:

<syntaxhighlight lang="C">
int fprintf(FILE *f, const char *format, ...);
int fscanf(FILE *f, const char *format, ...);
</syntaxhighlight>

Funcţiile recomandate pentru lucrul cu fişiere binare sunt urmatoarele:
*scriere: <code style="color: green">fwrite()</code>
*citire: <code style="color: green">fread()</code>

<syntaxhighlight lang="C">
size_t fread(void *ptr, size_t noct, size_t nr, FILE *f);
size_t fwrite(void *ptr, size_t noct, size_t nr, FILE *f);
</syntaxhighlight>
</div>

=== Exerciții ===

#Să se scrie un program care citește de la tastatură un text de mai multe linii și îl scrie într-un fișier text.
#Să se scrie un program care citește un fișier text și îl afișeză linie cu linie.

PC Laborator 13

2017-01-11T20:42:32Z

Lflueratoru: /* Citirea şi scrierea în/din fişiere */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil să:
* să lucreze cu fișiere text: deschidere, citire, scriere, închidere
* să înțeleagă modul de funcționare al fișierelor binare

== Informații generale ==
Datele pot fi stocate temporar în memoria internă, dar la închiderea programului acestea se vor pierde. Pentru suportul acestui dezavantaj se poate folosi noțiunea de fișier, desigur stocat in memoria externă. Memoria externă furnizează o capacitate de stocare mult mai mare decât memoria internă, nu este volatilă, deci nu-şi pierde conţinutul la o eventuală întrerupere, dar are ca principal dezavantaj viteza de transfer a datelor redusă.

Prelucrarea unui fişier presupune asocierea acestuia cu un canal de I/E (numit flux sau '''stream''').(vezi [[PC Laborator 3#Stream-urile standard ale unui proces|PC Laborator 3]]).

Limbajul C permite operarea cu fişiere:

*text - fişier ce conţine o succesiune de linii
*binare - fişier conţine o succesiune de octeti, fără o structură.

*"b" - specifică fişier de tip binar
*"t" - specifică fişier de tip text (implicit)

== Operații cu fișiere ==

Pentru a avea acces la informaţiile dintr-un fişier, se realizează următoarele operaţii:
* deschiderea fişierului
* citirea/scrierea conţinutului fişierului
* închiderea fisierului

<div class="regula">'''<font color="red"> '''Observatie:'''</font> '''Operaţiile cu fişierele se realizează prin intermediul unui set de funcţii din
biblioteca standard de intrare/ieşire (I/O), deci este necasară includerea fişierului header '''stdio.h'''.</div>

Atunci când intenționăm să lucrăm cu fişiere este necesar să ne definim un pointer către o structură de tipul FILE.
O structură de tipul FILE este o structură de control a streamurilor.
Această structură păstrează informaţii cum ar fi adresa de început, poziţia indicatorului de fişier, poziţia indicatorului de sfârşit a fişierului și altele.
Pentru a se putea utiliza un fişier, este necesară folosirea unui pointer. Acesta este un pointer către anumite informaţii
despre fişierul respectiv – nume, starea şi poziţia în care se află poinetrul de fişier.
<syntaxhighlight lang="C">
FILE * fisier;
</syntaxhighlight>

=== Deschiderea fișierelor ===

Fişierele necesită a fi inițializate, le trebuie asociat un fişier fizic de pe dispozitivul de stocare.

<syntaxhighlight lang="C">
FILE *fopen(const char *nume_fișier, const char *mod);
</syntaxhighlight>

:FILE -returnează un pointer la fișier
:nume_fișiere -se specifică numele sau calea acestuia
:mod -se specifică modul de deschidere al fișierului

'''Moduri de deschidere al fișierelor:'''

* "r" - (read only), permite deschiderea doar pentru citirea conținutului
* "w" - (write), crează un nou fişier în care se pot scrie date. Dacă exista deja un fișier cu acest nume, conținutul va fi sters
* "a" - (append), deschide pentru scriere într-un fişier existent (scrierea se va face în continuare) -adăugare-
* "r+" - deschide un fişier pentru actualizarea datelor, permite atât scriere cât şi citire
* "w+" - crează un fişier nou în care se vor putea scrie cât şi citi date.
* "a+" - deschide un fişier pentru adăugare de date cât şipentru citire. Operațiile de scriere vor fi efectuate în continuarea datelor existente

<div class="regula">'''<font color="red"> Observatie:</font> '''Dacă operaţia de deschidere eşuează, funcţia returnează valoarea NULL. Dacă deschiderea
reuşeşte, funcţia returnează o valoare de tip FILE *.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen("exemplu.txt", "w");

if (fisier == NULL) {
printf("Fisierul nu poate fi creat.");
} else {
printf("Fisierul a fost creat");
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În acest mod se confirmă și crearea corectă a fișierului, fiind o practică recomandată.'''</div>

=== Închiderea fișierelor ===

După ce sunt folosite, fişierele trebuie închise. Atunci când execuţia programului se încheie cu succes
(fie prin încheierea execuţiei funcţiei main (), fie prin apelarea funcţiei exit() ), toate fişierele
deschise în momenul respectiv sunt automat închise.
Închiderea unui fişier se face cu funcţia fclose ().
<syntaxhighlight lang="C">
int fclose(FILE *fisier)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''Funcţia fclose() returnează 0 dacă operaţia de închidere a fişierului s-a realizat cu succes şi EOF dacă a intervenit o eroare.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen("/work/pc/F/group1/ion/lab13/test.txt", "w");

if (fisier == NULL) {
printf("Fisierul nu a putut fi creat");
} else {
//...
fclose(fisier);
}
</syntaxhighlight>

=== Parcurgerea fișierelor ===

Orice fişier, odată deschis, are asociat un cursor care indică poziţia curentă în fişierul respectiv (inițial această poziție este la începutul fişierului). Funcţiile de scriere şi citire din fişiere operează începand de la poziţia curentă a cursorului.
Totodată, orice operaţie de scriere sau citire avansează automat acest cursor cu numărul de octeţi citiţi/scrişi.

Poziția curent este dată de funcția ftell():
<syntaxhighlight lang="C">
int ftell(FILE *fisier)
</syntaxhighlight>

Poziţionarea cursorului pe o anumita poziţie se poate face folosind funcţia fseek():
<syntaxhighlight lang="C">
int fseek(FILE *fisier, long pozitie, int referinta)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În termeni uzuali se folosește long offset, int whence. Offset fiind numărul de octeți peste care se deplasează, iar whence poziția cursorului'''</div>

Whence poate avea una din cele trei valori posibile:
*SEEK_SET = 0 - Căutarea se face de la începutul fişierului
*SEEK_CUR = 1 - Căutare din poziţia curentă
*SEEK_END = 2 - Căutare de la sfârşitul fişierului

=== Citirea şi scrierea în/din fişiere ===
<div class="sfat">'''
În cazul în care se lucrează cu fişiere text se folosesc în mod uzual următoarele funcţii:
*scriere: <code style="color: green">fputs()</code> şi <code style="color: green">fprintf()</code>
*citire: <code style="color: green">fgets()</code> şi <code style="color: green">fscanf()</code>

''' Funcţiile <code style="color: green">fscanf()</code> şi <code style="color: green">fprintf()</code> funcţionează identic cu funcţiile <code style="color: green">scanf()</code> şi <code style="color: green">printf()</code>, cu deosebirea că citirea respectiv scrierea operează asupra unui fişier specificat ca prim parametru:

<syntaxhighlight lang="C">
int fprintf(FILE *f, const char *format, ...);
int fscanf(FILE *f, const char *format, ...);
</syntaxhighlight>

Funcţiile recomandate pentru lucrul cu fişiere binare sunt urmatoarele:
*scriere: <code style="color: green">fwrite()</code>
*citire: <code style="color: green">fread()</code>

<syntaxhighlight lang="C">
size_t fread(void *ptr, size_t noct, size_t nr, FILE *f);
size_t fwrite(void *ptr, size_t noct, size_t nr, FILE *f);
</syntaxhighlight>
</div>

=== Exerciții ===

#Să se scrie programul care citește de la tastatură un text de mai multe linii și îl scrie într-un fișier text.
#Să se scrie programul care citește un fișier text și îl afișeză linie cu linie.

PC Laborator 13

2017-01-11T20:42:13Z

Lflueratoru: /* Citirea şi scrierea în/din fişiere */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil să:
* să lucreze cu fișiere text: deschidere, citire, scriere, închidere
* să înțeleagă modul de funcționare al fișierelor binare

== Informații generale ==
Datele pot fi stocate temporar în memoria internă, dar la închiderea programului acestea se vor pierde. Pentru suportul acestui dezavantaj se poate folosi noțiunea de fișier, desigur stocat in memoria externă. Memoria externă furnizează o capacitate de stocare mult mai mare decât memoria internă, nu este volatilă, deci nu-şi pierde conţinutul la o eventuală întrerupere, dar are ca principal dezavantaj viteza de transfer a datelor redusă.

Prelucrarea unui fişier presupune asocierea acestuia cu un canal de I/E (numit flux sau '''stream''').(vezi [[PC Laborator 3#Stream-urile standard ale unui proces|PC Laborator 3]]).

Limbajul C permite operarea cu fişiere:

*text - fişier ce conţine o succesiune de linii
*binare - fişier conţine o succesiune de octeti, fără o structură.

*"b" - specifică fişier de tip binar
*"t" - specifică fişier de tip text (implicit)

== Operații cu fișiere ==

Pentru a avea acces la informaţiile dintr-un fişier, se realizează următoarele operaţii:
* deschiderea fişierului
* citirea/scrierea conţinutului fişierului
* închiderea fisierului

<div class="regula">'''<font color="red"> '''Observatie:'''</font> '''Operaţiile cu fişierele se realizează prin intermediul unui set de funcţii din
biblioteca standard de intrare/ieşire (I/O), deci este necasară includerea fişierului header '''stdio.h'''.</div>

Atunci când intenționăm să lucrăm cu fişiere este necesar să ne definim un pointer către o structură de tipul FILE.
O structură de tipul FILE este o structură de control a streamurilor.
Această structură păstrează informaţii cum ar fi adresa de început, poziţia indicatorului de fişier, poziţia indicatorului de sfârşit a fişierului și altele.
Pentru a se putea utiliza un fişier, este necesară folosirea unui pointer. Acesta este un pointer către anumite informaţii
despre fişierul respectiv – nume, starea şi poziţia în care se află poinetrul de fişier.
<syntaxhighlight lang="C">
FILE * fisier;
</syntaxhighlight>

=== Deschiderea fișierelor ===

Fişierele necesită a fi inițializate, le trebuie asociat un fişier fizic de pe dispozitivul de stocare.

<syntaxhighlight lang="C">
FILE *fopen(const char *nume_fișier, const char *mod);
</syntaxhighlight>

:FILE -returnează un pointer la fișier
:nume_fișiere -se specifică numele sau calea acestuia
:mod -se specifică modul de deschidere al fișierului

'''Moduri de deschidere al fișierelor:'''

* "r" - (read only), permite deschiderea doar pentru citirea conținutului
* "w" - (write), crează un nou fişier în care se pot scrie date. Dacă exista deja un fișier cu acest nume, conținutul va fi sters
* "a" - (append), deschide pentru scriere într-un fişier existent (scrierea se va face în continuare) -adăugare-
* "r+" - deschide un fişier pentru actualizarea datelor, permite atât scriere cât şi citire
* "w+" - crează un fişier nou în care se vor putea scrie cât şi citi date.
* "a+" - deschide un fişier pentru adăugare de date cât şipentru citire. Operațiile de scriere vor fi efectuate în continuarea datelor existente

<div class="regula">'''<font color="red"> Observatie:</font> '''Dacă operaţia de deschidere eşuează, funcţia returnează valoarea NULL. Dacă deschiderea
reuşeşte, funcţia returnează o valoare de tip FILE *.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen("exemplu.txt", "w");

if (fisier == NULL) {
printf("Fisierul nu poate fi creat.");
} else {
printf("Fisierul a fost creat");
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În acest mod se confirmă și crearea corectă a fișierului, fiind o practică recomandată.'''</div>

=== Închiderea fișierelor ===

După ce sunt folosite, fişierele trebuie închise. Atunci când execuţia programului se încheie cu succes
(fie prin încheierea execuţiei funcţiei main (), fie prin apelarea funcţiei exit() ), toate fişierele
deschise în momenul respectiv sunt automat închise.
Închiderea unui fişier se face cu funcţia fclose ().
<syntaxhighlight lang="C">
int fclose(FILE *fisier)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''Funcţia fclose() returnează 0 dacă operaţia de închidere a fişierului s-a realizat cu succes şi EOF dacă a intervenit o eroare.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen("/work/pc/F/group1/ion/lab13/test.txt", "w");

if (fisier == NULL) {
printf("Fisierul nu a putut fi creat");
} else {
//...
fclose(fisier);
}
</syntaxhighlight>

=== Parcurgerea fișierelor ===

Orice fişier, odată deschis, are asociat un cursor care indică poziţia curentă în fişierul respectiv (inițial această poziție este la începutul fişierului). Funcţiile de scriere şi citire din fişiere operează începand de la poziţia curentă a cursorului.
Totodată, orice operaţie de scriere sau citire avansează automat acest cursor cu numărul de octeţi citiţi/scrişi.

Poziția curent este dată de funcția ftell():
<syntaxhighlight lang="C">
int ftell(FILE *fisier)
</syntaxhighlight>

Poziţionarea cursorului pe o anumita poziţie se poate face folosind funcţia fseek():
<syntaxhighlight lang="C">
int fseek(FILE *fisier, long pozitie, int referinta)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În termeni uzuali se folosește long offset, int whence. Offset fiind numărul de octeți peste care se deplasează, iar whence poziția cursorului'''</div>

Whence poate avea una din cele trei valori posibile:
*SEEK_SET = 0 - Căutarea se face de la începutul fişierului
*SEEK_CUR = 1 - Căutare din poziţia curentă
*SEEK_END = 2 - Căutare de la sfârşitul fişierului

=== Citirea şi scrierea în/din fişiere ===
<div class="sfat">'''
În cazul în care se lucrează cu fişiere text se folosesc în mod uzual următoarele funcţii:
*scriere: <code style="color: green">fputs()</code> şi <code style="color: green">fprintf()</code>
*citire: <code style="color: green">fgets()</code> şi <code style="color: green">fscanf()</code>

''' Funcţiile <code style="color: green">fscanf()</code> şi <code style="color: green">fprintf()</code> funcţionează identic cu funcţiile <code style="color: green">scanf()</code> şi <code style="color: green">printf()</code>, cu deosebirea că citirea respectiv scrierea operează asupra unui fişier specificat ca prim parametru:

<syntaxhighlight lang="C">
int fprintf(FILE *f, const char *format, ...);
int fscanf(FILE *f, const char *format, ...);
</syntaxhighlight>

Funcţiile recomandate pentru lucrul cu fişiere binare sunt urmatoarele:
*scriere: <code style="color: green">fwrite()</code>
*citire: <code style="color: green">fread()</code>

<syntaxhighlight lang="C">
size_t fread (void *ptr, size_t noct, size_t nr, FILE *f);
size_t fwrite (void *ptr, size_t noct, size_t nr, FILE *f);
</syntaxhighlight>
</div>

=== Exerciții ===

#Să se scrie programul care citește de la tastatură un text de mai multe linii și îl scrie într-un fișier text.
#Să se scrie programul care citește un fișier text și îl afișeză linie cu linie.

PC Laborator 13

2017-01-11T20:35:42Z

Lflueratoru: /* Operații cu fișiere */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil să:
* să lucreze cu fișiere text: deschidere, citire, scriere, închidere
* să înțeleagă modul de funcționare al fișierelor binare

== Informații generale ==
Datele pot fi stocate temporar în memoria internă, dar la închiderea programului acestea se vor pierde. Pentru suportul acestui dezavantaj se poate folosi noțiunea de fișier, desigur stocat in memoria externă. Memoria externă furnizează o capacitate de stocare mult mai mare decât memoria internă, nu este volatilă, deci nu-şi pierde conţinutul la o eventuală întrerupere, dar are ca principal dezavantaj viteza de transfer a datelor redusă.

Prelucrarea unui fişier presupune asocierea acestuia cu un canal de I/E (numit flux sau '''stream''').(vezi [[PC Laborator 3#Stream-urile standard ale unui proces|PC Laborator 3]]).

Limbajul C permite operarea cu fişiere:

*text - fişier ce conţine o succesiune de linii
*binare - fişier conţine o succesiune de octeti, fără o structură.

*"b" - specifică fişier de tip binar
*"t" - specifică fişier de tip text (implicit)

== Operații cu fișiere ==

Pentru a avea acces la informaţiile dintr-un fişier, se realizează următoarele operaţii:
* deschiderea fişierului
* citirea/scrierea conţinutului fişierului
* închiderea fisierului

<div class="regula">'''<font color="red"> '''Observatie:'''</font> '''Operaţiile cu fişierele se realizează prin intermediul unui set de funcţii din
biblioteca standard de intrare/ieşire (I/O), deci este necasară includerea fişierului header '''stdio.h'''.</div>

Atunci când intenționăm să lucrăm cu fişiere este necesar să ne definim un pointer către o structură de tipul FILE.
O structură de tipul FILE este o structură de control a streamurilor.
Această structură păstrează informaţii cum ar fi adresa de început, poziţia indicatorului de fişier, poziţia indicatorului de sfârşit a fişierului și altele.
Pentru a se putea utiliza un fişier, este necesară folosirea unui pointer. Acesta este un pointer către anumite informaţii
despre fişierul respectiv – nume, starea şi poziţia în care se află poinetrul de fişier.
<syntaxhighlight lang="C">
FILE * fisier;
</syntaxhighlight>

=== Deschiderea fișierelor ===

Fişierele necesită a fi inițializate, le trebuie asociat un fişier fizic de pe dispozitivul de stocare.

<syntaxhighlight lang="C">
FILE *fopen(const char *nume_fișier, const char *mod);
</syntaxhighlight>

:FILE -returnează un pointer la fișier
:nume_fișiere -se specifică numele sau calea acestuia
:mod -se specifică modul de deschidere al fișierului

'''Moduri de deschidere al fișierelor:'''

* "r" - (read only), permite deschiderea doar pentru citirea conținutului
* "w" - (write), crează un nou fişier în care se pot scrie date. Dacă exista deja un fișier cu acest nume, conținutul va fi sters
* "a" - (append), deschide pentru scriere într-un fişier existent (scrierea se va face în continuare) -adăugare-
* "r+" - deschide un fişier pentru actualizarea datelor, permite atât scriere cât şi citire
* "w+" - crează un fişier nou în care se vor putea scrie cât şi citi date.
* "a+" - deschide un fişier pentru adăugare de date cât şipentru citire. Operațiile de scriere vor fi efectuate în continuarea datelor existente

<div class="regula">'''<font color="red"> Observatie:</font> '''Dacă operaţia de deschidere eşuează, funcţia returnează valoarea NULL. Dacă deschiderea
reuşeşte, funcţia returnează o valoare de tip FILE *.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen("exemplu.txt", "w");

if (fisier == NULL) {
printf("Fisierul nu poate fi creat.");
} else {
printf("Fisierul a fost creat");
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În acest mod se confirmă și crearea corectă a fișierului, fiind o practică recomandată.'''</div>

=== Închiderea fișierelor ===

După ce sunt folosite, fişierele trebuie închise. Atunci când execuţia programului se încheie cu succes
(fie prin încheierea execuţiei funcţiei main (), fie prin apelarea funcţiei exit() ), toate fişierele
deschise în momenul respectiv sunt automat închise.
Închiderea unui fişier se face cu funcţia fclose ().
<syntaxhighlight lang="C">
int fclose(FILE *fisier)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''Funcţia fclose() returnează 0 dacă operaţia de închidere a fişierului s-a realizat cu succes şi EOF dacă a intervenit o eroare.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen("/work/pc/F/group1/ion/lab13/test.txt", "w");

if (fisier == NULL) {
printf("Fisierul nu a putut fi creat");
} else {
//...
fclose(fisier);
}
</syntaxhighlight>

=== Parcurgerea fișierelor ===

Orice fişier, odată deschis, are asociat un cursor care indică poziţia curentă în fişierul respectiv (inițial această poziție este la începutul fişierului). Funcţiile de scriere şi citire din fişiere operează începand de la poziţia curentă a cursorului.
Totodată, orice operaţie de scriere sau citire avansează automat acest cursor cu numărul de octeţi citiţi/scrişi.

Poziția curent este dată de funcția ftell():
<syntaxhighlight lang="C">
int ftell(FILE *fisier)
</syntaxhighlight>

Poziţionarea cursorului pe o anumita poziţie se poate face folosind funcţia fseek():
<syntaxhighlight lang="C">
int fseek(FILE *fisier, long pozitie, int referinta)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În termeni uzuali se folosește long offset, int whence. Offset fiind numărul de octeți peste care se deplasează, iar whence poziția cursorului'''</div>

Whence poate avea una din cele trei valori posibile:
*SEEK_SET = 0 - Căutarea se face de la începutul fişierului
*SEEK_CUR = 1 - Căutare din poziţia curentă
*SEEK_END = 2 - Căutare de la sfârşitul fişierului

=== Citirea şi scrierea în/din fişiere ===
<div class="sfat">'''
În cazul în care se lucrează cu fişiere text se folosesc în mod uzual următoarele funcţii:
*scriere: <code style="color: green">fputs()</code> şi <code style="color: green">fprintf()</code>
*citire: <code style="color: green">fgets()</code> şi <code style="color: green">fscanf()</code>

''' Funcţiile <code style="color: green">fscanf()</code> şi <code style="color: green">fprintf()</code> funcţionează identic cu funcţiile <code style="color: green">scanf()</code> şi <code style="color: green">printf()</code>, cu deosebirea că citirea respectiv scrierea se face operează asupra unui fişier specificat ca prim parametru:

<syntaxhighlight lang="C">
int fprintf(FILE *f, const char *format, ...);
int fscanf(FILE *f, const char *format, ...);
</syntaxhighlight>

Funcţiile recomandate pentru lucrul cu fişiere binare sunt urmatoarele:
*scriere: <code style="color: green">fwrite()</code>
*citire: <code style="color: green">fread()</code>

<syntaxhighlight lang="C">
size_t fread (void *ptr,size_t noct,size_t nr,FILE *f);
size_t fwrite (void *ptr,size_t noct,size_t nr,FILE *f);
</syntaxhighlight>
</div>

=== Exerciții ===

#Să se scrie programul care citește de la tastatură un text de mai multe linii și îl scrie într-un fișier text.
#Să se scrie programul care citește un fișier text și îl afișeză linie cu linie.

PC Laborator 13

2017-01-11T20:29:38Z

Lflueratoru: /* Informații generale */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil să:
* să lucreze cu fișiere text: deschidere, citire, scriere, închidere
* să înțeleagă modul de funcționare al fișierelor binare

== Informații generale ==
Datele pot fi stocate temporar în memoria internă, dar la închiderea programului acestea se vor pierde. Pentru suportul acestui dezavantaj se poate folosi noțiunea de fișier, desigur stocat in memoria externă. Memoria externă furnizează o capacitate de stocare mult mai mare decât memoria internă, nu este volatilă, deci nu-şi pierde conţinutul la o eventuală întrerupere, dar are ca principal dezavantaj viteza de transfer a datelor redusă.

Prelucrarea unui fişier presupune asocierea acestuia cu un canal de I/E (numit flux sau '''stream''').(vezi [[PC Laborator 3#Stream-urile standard ale unui proces|PC Laborator 3]]).

Limbajul C permite operarea cu fişiere:

*text - fişier ce conţine o succesiune de linii
*binare - fişier conţine o succesiune de octeti, fără o structură.

*"b" - specifică fişier de tip binar
*"t" - specifică fişier de tip text (implicit)

== Operații cu fișiere ==

Pentru a avea acces la informaţiile dintr-un fişier, se realizează următoarele operaţii:
* deschiderea fişierului
* citirea/scrierea conţinutului fişierului
* închiderea fisierului

<div class="regula">'''<font color="red"> '''Observatie:'''</font> '''Operaţiile cu fişierele se realizează prin intermediul unui set de funcţii din
biblioteca standard de intrare/ieşire (I/O), deci este necasară includerea fişierului header '''stdio.h'''.</div>

Atunci când intenționăm să lucrăm cu fişiere este necesar să ne definim un pointer către o structură de tipul FILE.
O structură de tipul FILE este o structură de control a streamurilor.
Această structură păstrează informaţii cum ar fi adresa de început, poziţia indicatorului de fişier, poziţia indicatorului de sfârşit a fişierului și altele.
Pentru a se putea utiliza un fişier, este necesară folosirea unui pointer. Acesta este un pointer către anumite informaţii
despre fişierul respectiv – nume, starea şi poziţia în care se află poinetrul de fişier.
<syntaxhighlight lang="C">
FILE * fisier;
</syntaxhighlight>

=== Deschiderea fișierelor ===

Fişierele necesită a fi inițializate, le trebuie asociat un fişier fizic de pe dispozitivul de stocare.

<syntaxhighlight lang="C">
FILE *fopen(const char *nume_fișier, const char *mod);
</syntaxhighlight>

:FILE -returnează un pointer la fișier
:nume_fișiere -se specifică numele sau calea acestuia
:mod -se specifică modul de deschidere al fișierului

'''Moduri de deschidere al fișierelor:'''

* "r" - (read only), permite deschiderea doar pentru citirea conținutului
* "w" - (write), crează un nou fişier în care se pot scrie date. Dacă exista deja un fișier cu acest nume,conținutul va fi sters
* "a" - (append), deschide pentru scriere într-un fişier existent (scrierea se va face în continuare)-adăugare-
* "r+" - deschide un fişier pentru actualizarea datelor,permite atât scriere cât şi citire
* "w+" - crează un fişier nou în care se vor putea scrie cât şi citi date.
* "a+" - deschide un fişier pentru adăugare de date cât şipentru citire. Operațiile de scriere vor fi efectuate în continuarea datelor existente

<div class="regula">'''<font color="red"> Observatie:</font> '''Dacă operaţia de deschidere eşuează, funcţia returnează valoarea NULL. Dacă deschiderea
reuşeşte, funcţia returnează o valoare de tip FILE *.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen ("exemplu.txt", "w");

if (fisier == NULL){
printf ("Fisierul nu poate fi creat.");
}else{
printf ("Fisierul a fost creat");
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În acest mod se confirmă și crearea corectă a fișierului, fiind o practică recomandată'''</div>

=== Închiderea fișierelor ===

După ce sunt folosite, fişierele trebuie închise. Atunci când execuţia programului se încheie cu succes
(fie prin încheierea execuţiei funcţiei main (), fie prin apelarea funcţiei exit() ), toate fişierele
deschise în momenul respectiv sunt automat închise.
Închiderea unui fişier se face cu funcţia fclose ().
<syntaxhighlight lang="C">
int fclose (FILE *fisier)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''Funcţia fclose () returnează 0 dacă operaţia de închidere a fişierului s-a realizat cu succes şi EOF dacă a intervenit o eroare.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier=fopen("/work/pc/F/group1/ion/lab13/test.txt", "w");

if (fisier==NULL){
printf("Fisierul nu a putut fi creat");
}else{
//...
fclose(fisier);
}
</syntaxhighlight>

=== Parcurgerea fișierelor ===

Orice fişier, odată deschis, are asociat un cursor care indică poziţia curentă în fişierul respectiv (inițial această poziție este la începutul fişierului). Funcţiile de scriere şi citire din fişiere operează începand de la poziţia curentă a cursorului.
Totodată, orice operaţie de scriere sau citire avansează automat acest cursor cu numărul de octeţi citiţi/scrişi.

Poziția curent este dată de funcția ftell():
<syntaxhighlight lang="C">
int ftell (FILE *fisier)
</syntaxhighlight>

Poziţionarea cursorului pe o anumita poziţie se poate face folosind funcţia fseek():
<syntaxhighlight lang="C">
int fseek (FILE *fisier, long pozitie, int referinta)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În termeni uzuali se folosește long offset, int whence.Offset fiind numărul de octeți peste care se deplasează,iar whence poziția cursorului'''</div>

Whence poate avea una din cele trei valori posibile:
*SEEK_SET = 0 - Căutarea se face de la începutul fişierului
*SEEK_CUR = 1 - Căutare din poziţia curentă
*SEEK_END = 2 - Căutare de la sfârşitul fişierului

=== Citirea şi scrierea în/din fişiere ===
<div class="sfat">'''
În cazul în care se lucrează cu fişiere text se folosesc în mod uzual următoarele funcţii:
*scriere: <code style="color: green">fputs()</code> () şi <code style="color: green">fprintf()</code>
*citire: <code style="color: green">fgets()</code> şi <code style="color: green">fscanf()</code>

''' Funcţiile <code style="color: green">fscanf()</code> şi <code style="color: green">fprintf()</code> funcţionează identic cu funcţiile <code style="color: green">scanf()</code> şi <code style="color: green">printf()</code>, cu deosebirea că citirea respectiv scrierea se face operează asupra unui fişier specificat ca prim parametru:

<syntaxhighlight lang="C">
int fprintf(FILE *f, const char *format, ...);
int fscanf(FILE *f, const char *format, ...);
</syntaxhighlight>

Funcţiile recomandate pentru lucrul cu fişiere binare sunt urmatoarele:
*scriere: <code style="color: green">fwrite()</code>
*citire: <code style="color: green">fread()</code>

<syntaxhighlight lang="C">
size_t fread (void *ptr,size_t noct,size_t nr,FILE *f);
size_t fwrite (void *ptr,size_t noct,size_t nr,FILE *f);
</syntaxhighlight>
</div>

=== Exerciții ===

#Să se scrie programul care citește de la tastatură un text de mai multe linii și îl scrie într-un fișier text.
#Să se scrie programul care citește un fișier text și îl afișeză linie cu linie.

PC Laborator 13

2017-01-11T20:28:51Z

Lflueratoru: /* Obiective */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil să:
* să lucreze cu fișiere text: deschidere, citire, scriere, închidere
* să înțeleagă modul de funcționare al fișierelor binare

== Informații generale ==
Datele pot fi stocate temporar în memoria internă,dar la închiderea programului acestea se vor pierde. Pentru suportul acestui dezavantaj se poate folosii noțiunea de fișier,desigur stocat in memoria externă. Memoria externă furnizează o capacitate de stocare mult mai mare decât memoria internă, nu este volatilă deci nu-şi pierde conţinutul la o eventuală întrerupere, dar are ca principal dezavantaj viteza de transfer a datelor redusă.

Prelucrarea unui fişier presupune asocierea acestuia cu un canal de I/E (numit flux sau '''stream''').(vezi [[PC Laborator 3#Stream-urile standard ale unui proces|PC Laborator 3]]).

Limbajul C permite operarea cu fişiere:

*text - fişier ce conţine o succesiune de linii
*binare - fişier conţine o succesiune de octeti, fără o structură.

*"b" - specifică fişier de tip binar
*"t" - specifică fişier de tip text (implicit)

== Operații cu fișiere ==

Pentru a avea acces la informaţiile dintr-un fişier, se realizează următoarele operaţii:
* deschiderea fişierului
* citirea/scrierea conţinutului fişierului
* închiderea fisierului

<div class="regula">'''<font color="red"> '''Observatie:'''</font> '''Operaţiile cu fişierele se realizează prin intermediul unui set de funcţii din
biblioteca standard de intrare/ieşire (I/O), deci este necasară includerea fişierului header '''stdio.h'''.</div>

Atunci când intenționăm să lucrăm cu fişiere este necesar să ne definim un pointer către o structură de tipul FILE.
O structură de tipul FILE este o structură de control a streamurilor.
Această structură păstrează informaţii cum ar fi adresa de început, poziţia indicatorului de fişier, poziţia indicatorului de sfârşit a fişierului și altele.
Pentru a se putea utiliza un fişier, este necesară folosirea unui pointer. Acesta este un pointer către anumite informaţii
despre fişierul respectiv – nume, starea şi poziţia în care se află poinetrul de fişier.
<syntaxhighlight lang="C">
FILE * fisier;
</syntaxhighlight>

=== Deschiderea fișierelor ===

Fişierele necesită a fi inițializate, le trebuie asociat un fişier fizic de pe dispozitivul de stocare.

<syntaxhighlight lang="C">
FILE *fopen(const char *nume_fișier, const char *mod);
</syntaxhighlight>

:FILE -returnează un pointer la fișier
:nume_fișiere -se specifică numele sau calea acestuia
:mod -se specifică modul de deschidere al fișierului

'''Moduri de deschidere al fișierelor:'''

* "r" - (read only), permite deschiderea doar pentru citirea conținutului
* "w" - (write), crează un nou fişier în care se pot scrie date. Dacă exista deja un fișier cu acest nume,conținutul va fi sters
* "a" - (append), deschide pentru scriere într-un fişier existent (scrierea se va face în continuare)-adăugare-
* "r+" - deschide un fişier pentru actualizarea datelor,permite atât scriere cât şi citire
* "w+" - crează un fişier nou în care se vor putea scrie cât şi citi date.
* "a+" - deschide un fişier pentru adăugare de date cât şipentru citire. Operațiile de scriere vor fi efectuate în continuarea datelor existente

<div class="regula">'''<font color="red"> Observatie:</font> '''Dacă operaţia de deschidere eşuează, funcţia returnează valoarea NULL. Dacă deschiderea
reuşeşte, funcţia returnează o valoare de tip FILE *.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier = fopen ("exemplu.txt", "w");

if (fisier == NULL){
printf ("Fisierul nu poate fi creat.");
}else{
printf ("Fisierul a fost creat");
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În acest mod se confirmă și crearea corectă a fișierului, fiind o practică recomandată'''</div>

=== Închiderea fișierelor ===

După ce sunt folosite, fişierele trebuie închise. Atunci când execuţia programului se încheie cu succes
(fie prin încheierea execuţiei funcţiei main (), fie prin apelarea funcţiei exit() ), toate fişierele
deschise în momenul respectiv sunt automat închise.
Închiderea unui fişier se face cu funcţia fclose ().
<syntaxhighlight lang="C">
int fclose (FILE *fisier)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''Funcţia fclose () returnează 0 dacă operaţia de închidere a fişierului s-a realizat cu succes şi EOF dacă a intervenit o eroare.'''</div>

==== Exemplu ====

<syntaxhighlight lang="C">
FILE *fisier;
fisier=fopen("/work/pc/F/group1/ion/lab13/test.txt", "w");

if (fisier==NULL){
printf("Fisierul nu a putut fi creat");
}else{
//...
fclose(fisier);
}
</syntaxhighlight>

=== Parcurgerea fișierelor ===

Orice fişier, odată deschis, are asociat un cursor care indică poziţia curentă în fişierul respectiv (inițial această poziție este la începutul fişierului). Funcţiile de scriere şi citire din fişiere operează începand de la poziţia curentă a cursorului.
Totodată, orice operaţie de scriere sau citire avansează automat acest cursor cu numărul de octeţi citiţi/scrişi.

Poziția curent este dată de funcția ftell():
<syntaxhighlight lang="C">
int ftell (FILE *fisier)
</syntaxhighlight>

Poziţionarea cursorului pe o anumita poziţie se poate face folosind funcţia fseek():
<syntaxhighlight lang="C">
int fseek (FILE *fisier, long pozitie, int referinta)
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''În termeni uzuali se folosește long offset, int whence.Offset fiind numărul de octeți peste care se deplasează,iar whence poziția cursorului'''</div>

Whence poate avea una din cele trei valori posibile:
*SEEK_SET = 0 - Căutarea se face de la începutul fişierului
*SEEK_CUR = 1 - Căutare din poziţia curentă
*SEEK_END = 2 - Căutare de la sfârşitul fişierului

=== Citirea şi scrierea în/din fişiere ===
<div class="sfat">'''
În cazul în care se lucrează cu fişiere text se folosesc în mod uzual următoarele funcţii:
*scriere: <code style="color: green">fputs()</code> () şi <code style="color: green">fprintf()</code>
*citire: <code style="color: green">fgets()</code> şi <code style="color: green">fscanf()</code>

''' Funcţiile <code style="color: green">fscanf()</code> şi <code style="color: green">fprintf()</code> funcţionează identic cu funcţiile <code style="color: green">scanf()</code> şi <code style="color: green">printf()</code>, cu deosebirea că citirea respectiv scrierea se face operează asupra unui fişier specificat ca prim parametru:

<syntaxhighlight lang="C">
int fprintf(FILE *f, const char *format, ...);
int fscanf(FILE *f, const char *format, ...);
</syntaxhighlight>

Funcţiile recomandate pentru lucrul cu fişiere binare sunt urmatoarele:
*scriere: <code style="color: green">fwrite()</code>
*citire: <code style="color: green">fread()</code>

<syntaxhighlight lang="C">
size_t fread (void *ptr,size_t noct,size_t nr,FILE *f);
size_t fwrite (void *ptr,size_t noct,size_t nr,FILE *f);
</syntaxhighlight>
</div>

=== Exerciții ===

#Să se scrie programul care citește de la tastatură un text de mai multe linii și îl scrie într-un fișier text.
#Să se scrie programul care citește un fișier text și îl afișeză linie cu linie.

PC Laborator 12

2016-12-21T18:31:49Z

Lflueratoru: /* Evitarea pierderilor de memorie - valgrind */

= Obiective =

La sfârșitul acestui laborator studenții vor fi capabili:
* să definească și să utilizeze tipuri de date pointer;
* să folosească pointeri pentru a putea modifica variabilele trimise ca argumente unor funcții;
* să aloce, să folosească și să elibereze memorie HEAP, în mod dinamic;
* să utilizeze aritmetica pointerilor pentru a itera peste elemente de la adrese consecutive de memorie;
* să utilizeze <code>valgrind</code> pentru a diagnostica pierderile de memorie.

= Tipuri de date pointer =

Un '''pointer''' reprezintă o variabilă care stochează o adresă în memoria dedicată aplicației. Tipul variabilei de tip pointer specifică tipul datei care poate fi citit de la adresa respectivă.

O variabilă de tip pointer se definește în felul următor:

<tip_data> * <nume_variabila>;

Spre exemplu:

<syntaxhighlight lang="c">
int * pa;
</syntaxhighlight>

Variabila de tip pointer <code>pa</code> nu memorează un întreg, ci o adresă în memorie, iar de la adresa respectivă se poate citi un întreg. Acest lucru se numește indirectare simplă. În plus, deoarece tipul pointer este în sine un tip de dată, și în definiția unui pointer <tip_data> poate fi un pointer, aceasta permite următoarele construcții:
* <code>int * pa;</code> - variabilă ce stochează o adresă de unde se poate citi un întreg (indirectare simplă);
* <code>int ** pa;</code> - variabilă ce stochează o adresă de unde se poate citi o adresă de unde se poate citi un întreg (dublă indirectare);
* <code>int *** pa;</code> - variabilă ce stochează o adresă de unde se poate citi o adresă de unde se poate citi o adresă de unde se poate citi un întreg (triplă indirectare);
* etc.

<div class="regula"><span style="color: red; font-weight: bold">Regulă:</span> Orice variabilă este stocată în memorie și deci are o adresă în memorie.</div>

În C există un tip de dată pointer care poate memora o adresă fără a ști ce date se află la adresa respectivă. Acest tip de pointer este <code>void*</code>.

== Dimensiunea tipului de date pointer ==

Conform regulii de mai sus, și variabilele de tip pointer ocupă loc în memorie, deci au dimensiune, în octeți. Un pointer nu oferă informații legate de dimensiunea ocupată de datele de la adresa respectivă, ci doar adresa de unde începe zona ocupată. Din moment ce un pointer memorează doar o adresă, dimensiunea variabilelor de tip pointer nu depinde decât de dimensiunea spațiului de memorie. Astfel, pentru procesoare și sisteme de operare pe 32 de biți, o variabilă de tip pointer va avea 32 de biți, iar pe procesoare și sisteme de operare pe 64 de biți, o variabilă de tip pointer va avea 64 de biți.

== Adresa unei variabile ==

Operatorul care permite aflarea adresei unde este stocată o variabilă este ampersand (&). Acesta este un operator unar ce se plasează înaintea unei variabile iar rezultatul evaluării sale este adresa unde este stocată variabila respectivă. Această adresă poate fi stocată într-o altă variabilă de tipul corespunzător. Altfel spus, pentru o variabilă de tip ''tip_data'', adresa acesteia se poate stoca într-o variabilă de tip ''tip_data *'':
<syntaxhighlight lang="c">
float floatValue;
float * floatAddress = &floatValue;

int intValue;
int * intAddress = &intValue;
int ** intPointerAddress = &intAddress;
</syntaxhighlight>

== Adresa NULL ==

Pentru orice aplicație, adresa 0 din spațiul ei de memorie este rezervată. Aceasta nu poate fi nici scrisă și nici citită. Această adresa poartă numele de '''NULL'''. Orice variabilă de tip pointer poate lua valoarea '''NULL''', lucru care de obicei specifică faptul că de fapt variabila pointer nu stochează o adresă validă.

Constanta '''NULL''' este definită în fișierul header <code style="color: green">stdlib.h</code> (Standard Library).

<syntaxhighlight lang="C">
#include <stdlib.h>

int main() {
char * charPointer = NULL;
return 0;
}
</syntaxhighlight>

== Valoarea de la o adresă ==

Având o variabilă de tip pointer, valoarea stocată în memorie la adresa respectivă se poate afla folosind caracterul steluță (*), numit și operator de indirectare. Acesta este un operator unar ce se plasează înaintea unei variabile de tip pointer iar rezultatul evaluării sale este valoarea din memorie de la adresa stocată în variabila respectivă. Această valoare poate fi stocată într-o altă variabilă de tipul corespunzător. Altfel spus, pentru o variabilă pointer de tip ''tip_data *'', valoarea de la adresa stocată de pointerul respectiv se poate memora într-o altă variabilă de tip ''tip_data'':

<syntaxhighlight lang="c">
float floatValue;
float * floatAddress = &floatValue;
float anotherFloatValue = *floatAddress;

int intValue;
int * intAddress = &intValue;
int ** intPointerAddress = &intAddress;
int * anotherintAddress = *intPointerAddress;
</syntaxhighlight>

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Accesarea valorii de la o adresă se numește dereferențiere. Dereferențierea unei adrese care nu face parte din spațiul de memorie al aplicației sau dereferențierea lui '''NULL''' va avea ca efect oprirea imediată a programului printr-un ''Segmentation fault.''</div>

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Nu confundați steluța utilizată la definirea unui pointer cu operatorul de indirectare/ dereferențiere. Aceștia sunt la fel de diferiți cum este și operatorul de inmulțire față de cel de indirectare.</div>

= Utilitatea variabilelor de tip pointer =

Pointerii în C au două roluri foarte importante:
# Alocarea dinamică de memorie în HEAP
# Modificarea variabilelor parametri ale unor funcții astfel încât modificarea să se păstreze în afara funcției

== Alocarea dinamică de memorie ==

Memoria alocată unei aplicații de către sistemul de operare este împărțită în mai multe secțiuni, dintre care importante pentru stocarea de date sunt:

* Segmentele BSS și Data - reprezintă memoria alocată pentru variabilele statice (globale), care există de la începutul până la încheierea programului, fără posibilitate de eliberare;
* Stiva (Stack) - zona de memorie în care se alocă contextele funcțiilor apelate în timpul execuției programului și în care se alocă argumentele și variabilele locale are funcțiilor; această zonă este alocată la intrarea în funcție și este eliberată la ieșirea din funcție;
* HEAP - zonă de memorie în care se pot aloca dinamic, de către programator, blocuri de memorie ce pot fi folosite în program până la eliberarea acestora de către programator.

Alocarea și dezalocarea memoriei în heap se fac folosind următoarele funcții:
* <code>void * malloc(unsigned size)</code> - alocă ''size'' octeți într-o zonă continuă din HEAP și întoarce adresa de memorie unde începe zona respectivă; dacă alocarea eșuează (nu exită suficientă memorie într-o zonă continuă în HEAP), funcția va întoarce '''NULL'''; alocarea nu șterge conținutul memoriei respective;
* <code>void * calloc(unsigned elements, unsigned elementSize)</code> - alocă ''elements'' elemente de ''elementSize'' octeți fiecare într-o zonă continuă din HEAP și întoarce adresa de memorie unde începe zona respectivă; dacă alocarea eșuează (nu exită suficientă memorie într-o zonă continuă în HEAP), funcția va întoarce '''NULL'''; alocarea șterge tot conținutul memoriei respective, scriind 0 la fiecare locație;
* <code>void free (void *)</code> - dezalocă o zonă de memorie alocată în prealabil cu <code>malloc</code> sau <code>calloc</code>; apelul succesiv de două sau mai multe ori a funcției <code>free</code> pentru aceeași zonă de memorie sau apelul ei pentru o adresă care nu a fost alocată în prealabil va avea ca efect oprirea imediată a programului cu eroare (''double free or corruption'').

Toate aceste funcții sunt definite în fișierul header <code style="color: green">stdlib.h</code>.

<syntaxhighlight lang="c">
#include <stdlib.h>
#include <stdio.h>

int main(){
int * intPointer;
short * shortPointer;

intPointer = (int*) malloc(sizeof(int));
shortPointer = (short*) calloc(1, sizeof(short));

printf("Valoarea din zona alocata pentru int este: %d\n", *intPointer);
printf("Valoarea din zona alocata pentru short este: %hd\n", *shortPointer);

free(intPointer);
free(shortPointer);

return 0;
}
</syntaxhighlight>

<div class="sfat"><span style="color: red; font-weight: bold">Atenție:</span> Deoarece funcțiile <code>malloc</code> și <code>calloc</code> au doar rolul de a aloca memorie, fără să știe care este scopul utilizării acestei memorii, ele întorc un pointer de tip <code>void *</code>. Astfel, pentru a putea stoca adresa într-un alt tip de pointer (de exemplu <code>int *</code>), ea trebuie convertită la tipul de date corect. Aceasta este explicația prezenței operatorului de cast din fața apelului funcțiilor <code>malloc</code> și <code>calloc</code> din codul de mai sus.</div>

== Aritmetica pointerilor ==

Când se alocă memorie in HEAP, rareori se alocă pentru un singur element, de cele mai multe ori se alocă pentru un număr mare de elemente de același fel. Ca exemplu, dacă vrem să stocăm o imagine High Definition, ne trebuie o zonă de memorie care să poată memora informație de culoare pentru 1920 * 1080 de pixeli, fiecare pixel având informație de culoare pentru roșu, verde și albastru (RGB). Fiecare din aceste componente de culoare se stochează pe un octet ca valoare întreagă fără semn (unsigned char). Prin urmare, pentru un frame se vor aloca 1920 * 1080 * 3 octeți = 6220800, aproape 6 MB. Această memorie se alocă întotdeauna într-o zonă continuă de către funcțiile <code>malloc</code> și <code>calloc</code>:

<syntaxhighlight lang="c">
#include <stdlib.h>
int main(){
unsigned char * frame;
frame = (unsigned char*) malloc(1920 * 1080 * 3 * sizeof(unsigned char));
//... use frame

free (frame);
return 0;
}
</syntaxhighlight>

Deoarece pointer-ul nu memorează decât adresa de început a zonei de memorie, există posibilitatea de a modifica adresa pentru a accesa elementele ulterioare. În acest scop, variabilele de tip pointer suportă doar operații aritmetice de adunare sau scădere, nu și de înmulțire sau împărțire.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Incrementarea unui pointer nu crește adresa cu 1, ci cu dimensiunea tipului de dată al pointer-ului. Deci pentru un <code>int * p;</code>, linia <code>p++;</code> va incrementa adresa cu 4 (sizeof(int)):</div>

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(){
int * pointer;
pointer = (int*) malloc(10 * sizeof(int));
printf("The pointer address is: %p\n", pointer);
printf("The pointer address + 1 is: %p\n", pointer + 1);
free (pointer);
return 0;
}
</syntaxhighlight>

<div class="regula"><span style="color: red; font-weight: bold">Atenție </span> ca prin operații pe pointeri să nu depășiți zona de memorie alocată.</div>

== Pointerii și vectorii ==

Memoria alocată pentru mai multe elemente de același fel reprezintă de fapt un vector de elemente de acel tip. Astfel aflăm că de fapt vectorii și pointerii, în multe situații se pot folosi interschimbabil.

Când se definește un vector, numele vectorului reprezintă un pointer la adresa de unde începe zona lui de memorie, adică adresa unde este memorat elementul de la indexul 0:

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(){
int array[10];
array[0] = 13;
printf("The array pointer address is: %p\n", array);
printf("The value at address %p is %d\n", array, *array);
return 0;
}
</syntaxhighlight>

Dereferențierea unui pointer indexat cu o valoare este echivalentă cu folosirea operatorului de acces la vector: <code>*(v + k)</code> == <code>v[k]</code>, unde '''v''' este un pointer (sau vector) iar '''k''' este un întreg.

<syntaxhighlight lang="c" highlight="14,18">
#include <stdlib.h>
#include <stdio.h>
int main(){
int arraySize;
printf("size = ");
scanf("%d", &arraySize);

int * heapArray;
heapArray = (int*) malloc(arraySize * sizeof(int));

int i;
for(i = 0; i < arraySize; i++) {
printf("heapArray[%d] = ", i);
scanf("%d", &heapArray[i]);
}

for(i = 0; i < arraySize; i++) {
printf("heapArray[%d] = %d\n", i, *(heapArray + i));
}

free (heapArray);
return 0;
}
</syntaxhighlight>

== Pointerii și structurile ==

Ca orice tip de dată, și variabilele de tip structură ocupă loc în memorie și deci pot exista pointeri de tip structură:

<syntaxhighlight lang="c">
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test testStructVar;
struct Test * structPointer = &testStructVar;
return 0;
}
</syntaxhighlight>

Având un pointer la o structură, accesul la câmpuri se poate face în două moduri:
<ol>
<li>Dereferențierea pointerului pentru a obține "valoarea" structurii și apoi utilizarea operatorului "." pentru accesul la membri:
<syntaxhighlight lang="c" highlight="12">
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test testStructVar;
struct Test * structPointer = &testStructVar;

*structPointer.intField = 10;
return 0;
}
</syntaxhighlight>
</li>
<li>Accesul la membrii unei structuri accesate printr-un pointer este atât de popular și des întâlnit în C încât există un operator special care permite accesul la câmpuri fără dereferențiere. Acest operator este săgeata "->":
<syntaxhighlight lang="c" highlight="13,14">
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test testStructVar;
struct Test * structPointer = &testStructVar;

*structPointer.intField = 10;
structPointer->floatField = 4.3;
structPointer->charField = 'B';
return 0;
}
</syntaxhighlight>
</li>
</ol>

Alocarea memoriei în HEAP pentru structuri se face identic cu alocarea pentru tipurile primitive de date:
<syntaxhighlight lang="c" highlight="10, 14">
#include <stdlib.h>
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test * structPointer = (struct Test*) malloc(sizeof(struct Test));

// use structPointer

free(structPointer);
return 0;
}
</syntaxhighlight>

== Adrese ca argumente de funcție ==

Știm deja că în C argumentele funcțiilor sunt pass-by-value, asta înseamnă că funcției i se transmite valoarea dintr-o variabilă, nu variabila în sine. Astfel, dacă o variabilă este folosită ca argument la apelul unei funcții, modificarea argumentului în funcție nu se propagă și spre variabila sursă:

<syntaxhighlight lang="c">
#include <stdio.h>

void divideByTwo(int arg) {
printf("Argument before division = %d\n", arg);
arg /= 2;
printf("Argument after division = %d\n", arg);
}

int main() {
int var = 10;
divideByTwo(var);
printf("Variabile after function call = %d\n", var);
return 0;
}
</syntaxhighlight>

Există o soluție pentru a permite propagarea modificării spre variabila sursă, și anume în loc de a trimite ca argument funcției variabila, se transmite adresa variabilei. Asta permite funcției să scrie direct în memoria alocată pentru variabilă și deci să-i modifice valoarea:
<syntaxhighlight lang="c">
#include <stdio.h>

void divideByTwo(int *arg) {
printf("Argument before division = %d\n", *arg);
*arg /= 2;
printf("Argument after division = %d\n", *arg);
}

int main() {
int var = 10;
divideByTwo(&var);
printf("Variabile after function call = %d\n", var);
return 0;
}
</syntaxhighlight>

= Evitarea pierderilor de memorie - <code>valgrind</code> =

Pierderile de memorie (memory leaks) apar atunci când programatorul alocă memorie, dar uită să o elibereze. Aceasta este o problemă foarte delicată pentru că aplicația va continua să aloce până când va depăși limitele permise și sistemul de operare va opri procesul forțat. Chiar și dacă nu se ajunge acolo, ocuparea de cantități mari de memorie va face ca tot sistemul să se miște din ce în ce mai greu (vezi versiunile vechi de Firefox):

<syntaxhighlight lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main() {
char * buffer = (char*) malloc(100 * sizeof(char));
buffer = NULL;
printf("Done!\n");
return 0;
}
</syntaxhighlight>

În exemplul de mai sus este alocat un buffer de 100 de bytes, iar adresa către zona respectivă se pierde când pointerului buffer i se atribuie valoarea '''NULL'''. Astfel, acea memorie nu mai poate fi nici accesată și nici eliberată. Cu toate acestea, programul compilează și rulează fără probleme. Pentru a verifica că nu există pierderi de memorie, se poate folosi programul <code>valgrind</code>:

<span style="font-weight: bold"><span style="color: green">rhobincu@IronMan</span> <span style="color: blue">~/work/pc/test $</span></span> valgrind --leak-check=full ./test
==6076== Memcheck, a memory error detector
==6076== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==6076== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==6076== Command: ./test
==6076==
Done!
==6076==
==6076== HEAP SUMMARY:
==6076== in use at exit: 100 bytes in 1 blocks
==6076== total heap usage: 1 allocs, 0 frees, 100 bytes allocated
==6076==
==6076== 100 bytes in 1 blocks are definitely lost in loss record 1 of 1
==6076== at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6076== by 0x40058E: main (test.c:5)
==6076==
==6076== LEAK SUMMARY:
==6076== definitely lost: 100 bytes in 1 blocks
==6076== indirectly lost: 0 bytes in 0 blocks
==6076== possibly lost: 0 bytes in 0 blocks
==6076== still reachable: 0 bytes in 0 blocks
==6076== suppressed: 0 bytes in 0 blocks
==6076==
==6076== For counts of detected and suppressed errors, rerun with: -v
==6076== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

<div class="regula"><span style="color: red; font-weight: bold">Observație: </span> Ca valgrind să poată afișa numărul liniei și fișierul sursă unde apare eroarea, codul trebuie compilat cu simboluri de debug (-g).</div>

Pentru un cod corect, ieșirea lui '''valgrind''' este:
<syntaxhighlight lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main() {
char * buffer = (char*) malloc(100 * sizeof(char));
free(buffer);
buffer = NULL;
printf("Done!\n");
return 0;
}
</syntaxhighlight>

<span style="font-weight: bold"><span style="color: green">rhobincu@IronMan</span> <span style="color: blue">~/work/pc/test $</span></span> valgrind --leak-check=full ./test
==6244== Memcheck, a memory error detector
==6244== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==6244== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==6244== Command: ./test
==6244==
Done!
==6244==
==6244== HEAP SUMMARY:
==6244== in use at exit: 0 bytes in 0 blocks
==6244== total heap usage: 1 allocs, 1 frees, 100 bytes allocated
==6244==
==6244== All heap blocks were freed -- no leaks are possible
==6244==
==6244== For counts of detected and suppressed errors, rerun with: -v
==6244== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

= Exerciții =

<ol>
<li> Realizați o funcție <code>char * allocateString(unsigned size)</code> care să aloce în HEAP o zonă de memorie care să poată stoca un sir de caractere de dimensiunea <code>size</code> și să întoarcă adresa de unde începe zona respectivă. HINT: nu uitați de caracterul pentru final de șir.</li>
<li> Citiți de la tastatură o lungime de șir <code>length</code> apoi folosind funcția de mai sus, alocați memorie pentru stocarea unui șir de acea dimensiune. Citiți apoi de la tastatură și memorați un șir de caractere pe care să-l afișați ulterior în consolă folosind funcția <code>puts</code>.</li>
<li> Pentru programul de mai sus, realizați o funcție <code>void printString(char * string)</code> care să afișeze pe ecran șirul de caractere, folosind exclusiv funcția <code>putchar</code> și fără a folosi operatorul de indexare a vectorilor ([]). Verificați că această funcție afișează același lucru ca funcția <code>puts</code>. HINT: Utilizați operatorul de dereferențiere și aritmetica pointerilor.</li>
<li>Realizați o funcție <code>compute</code> de tip <code>void</code> care să calculeze suma și produsul a două valori de tip <code>float</code> astfel încât funcția apelantă să le poată utiliza. Testați funcția într-un program.</li>
<li>Găsiți și eliminați pierderile de memorie din codul de mai jos:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BUFFER_SIZE 100

struct Buffer {
unsigned size;
char * string;
};

struct Buffer * createBuffer(unsigned size) {
struct Buffer * newBuffer = (struct Buffer*) malloc (sizeof(struct Buffer));
newBuffer->size = size;
newBuffer->string = (char*) malloc(size * sizeof(char));
return newBuffer;
}

struct Buffer * reverseWord(struct Buffer * buffer) {
struct Buffer * newBuffer = createBuffer(buffer->size);
int i;
for(i = 0; i < strlen(buffer->string); i++) {
*(newBuffer->string + i) = buffer->string[strlen(buffer->string) - 1 - i];
}
newBuffer->string[strlen(buffer->string)] = '\0';
return newBuffer;
}

int main() {
unsigned wordCount;
printf("How many words? ");
scanf("%u", &wordCount);

unsigned i;
for(i = 0; i < wordCount; i++) {
struct Buffer * buffer = createBuffer(BUFFER_SIZE);
scanf("%s", buffer->string);
buffer = reverseWord(buffer);
printf("Reversed is: %s\n", buffer->string);
free(buffer);
}
return 0;
}

</syntaxhighlight>
</li>
</ol>

PC Laborator 12

2016-12-21T18:29:13Z

Lflueratoru: /* Utilitatea variabilelor de tip pointer */

= Obiective =

La sfârșitul acestui laborator studenții vor fi capabili:
* să definească și să utilizeze tipuri de date pointer;
* să folosească pointeri pentru a putea modifica variabilele trimise ca argumente unor funcții;
* să aloce, să folosească și să elibereze memorie HEAP, în mod dinamic;
* să utilizeze aritmetica pointerilor pentru a itera peste elemente de la adrese consecutive de memorie;
* să utilizeze <code>valgrind</code> pentru a diagnostica pierderile de memorie.

= Tipuri de date pointer =

Un '''pointer''' reprezintă o variabilă care stochează o adresă în memoria dedicată aplicației. Tipul variabilei de tip pointer specifică tipul datei care poate fi citit de la adresa respectivă.

O variabilă de tip pointer se definește în felul următor:

<tip_data> * <nume_variabila>;

Spre exemplu:

<syntaxhighlight lang="c">
int * pa;
</syntaxhighlight>

Variabila de tip pointer <code>pa</code> nu memorează un întreg, ci o adresă în memorie, iar de la adresa respectivă se poate citi un întreg. Acest lucru se numește indirectare simplă. În plus, deoarece tipul pointer este în sine un tip de dată, și în definiția unui pointer <tip_data> poate fi un pointer, aceasta permite următoarele construcții:
* <code>int * pa;</code> - variabilă ce stochează o adresă de unde se poate citi un întreg (indirectare simplă);
* <code>int ** pa;</code> - variabilă ce stochează o adresă de unde se poate citi o adresă de unde se poate citi un întreg (dublă indirectare);
* <code>int *** pa;</code> - variabilă ce stochează o adresă de unde se poate citi o adresă de unde se poate citi o adresă de unde se poate citi un întreg (triplă indirectare);
* etc.

<div class="regula"><span style="color: red; font-weight: bold">Regulă:</span> Orice variabilă este stocată în memorie și deci are o adresă în memorie.</div>

În C există un tip de dată pointer care poate memora o adresă fără a ști ce date se află la adresa respectivă. Acest tip de pointer este <code>void*</code>.

== Dimensiunea tipului de date pointer ==

Conform regulii de mai sus, și variabilele de tip pointer ocupă loc în memorie, deci au dimensiune, în octeți. Un pointer nu oferă informații legate de dimensiunea ocupată de datele de la adresa respectivă, ci doar adresa de unde începe zona ocupată. Din moment ce un pointer memorează doar o adresă, dimensiunea variabilelor de tip pointer nu depinde decât de dimensiunea spațiului de memorie. Astfel, pentru procesoare și sisteme de operare pe 32 de biți, o variabilă de tip pointer va avea 32 de biți, iar pe procesoare și sisteme de operare pe 64 de biți, o variabilă de tip pointer va avea 64 de biți.

== Adresa unei variabile ==

Operatorul care permite aflarea adresei unde este stocată o variabilă este ampersand (&). Acesta este un operator unar ce se plasează înaintea unei variabile iar rezultatul evaluării sale este adresa unde este stocată variabila respectivă. Această adresă poate fi stocată într-o altă variabilă de tipul corespunzător. Altfel spus, pentru o variabilă de tip ''tip_data'', adresa acesteia se poate stoca într-o variabilă de tip ''tip_data *'':
<syntaxhighlight lang="c">
float floatValue;
float * floatAddress = &floatValue;

int intValue;
int * intAddress = &intValue;
int ** intPointerAddress = &intAddress;
</syntaxhighlight>

== Adresa NULL ==

Pentru orice aplicație, adresa 0 din spațiul ei de memorie este rezervată. Aceasta nu poate fi nici scrisă și nici citită. Această adresa poartă numele de '''NULL'''. Orice variabilă de tip pointer poate lua valoarea '''NULL''', lucru care de obicei specifică faptul că de fapt variabila pointer nu stochează o adresă validă.

Constanta '''NULL''' este definită în fișierul header <code style="color: green">stdlib.h</code> (Standard Library).

<syntaxhighlight lang="C">
#include <stdlib.h>

int main() {
char * charPointer = NULL;
return 0;
}
</syntaxhighlight>

== Valoarea de la o adresă ==

Având o variabilă de tip pointer, valoarea stocată în memorie la adresa respectivă se poate afla folosind caracterul steluță (*), numit și operator de indirectare. Acesta este un operator unar ce se plasează înaintea unei variabile de tip pointer iar rezultatul evaluării sale este valoarea din memorie de la adresa stocată în variabila respectivă. Această valoare poate fi stocată într-o altă variabilă de tipul corespunzător. Altfel spus, pentru o variabilă pointer de tip ''tip_data *'', valoarea de la adresa stocată de pointerul respectiv se poate memora într-o altă variabilă de tip ''tip_data'':

<syntaxhighlight lang="c">
float floatValue;
float * floatAddress = &floatValue;
float anotherFloatValue = *floatAddress;

int intValue;
int * intAddress = &intValue;
int ** intPointerAddress = &intAddress;
int * anotherintAddress = *intPointerAddress;
</syntaxhighlight>

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Accesarea valorii de la o adresă se numește dereferențiere. Dereferențierea unei adrese care nu face parte din spațiul de memorie al aplicației sau dereferențierea lui '''NULL''' va avea ca efect oprirea imediată a programului printr-un ''Segmentation fault.''</div>

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Nu confundați steluța utilizată la definirea unui pointer cu operatorul de indirectare/ dereferențiere. Aceștia sunt la fel de diferiți cum este și operatorul de inmulțire față de cel de indirectare.</div>

= Utilitatea variabilelor de tip pointer =

Pointerii în C au două roluri foarte importante:
# Alocarea dinamică de memorie în HEAP
# Modificarea variabilelor parametri ale unor funcții astfel încât modificarea să se păstreze în afara funcției

== Alocarea dinamică de memorie ==

Memoria alocată unei aplicații de către sistemul de operare este împărțită în mai multe secțiuni, dintre care importante pentru stocarea de date sunt:

* Segmentele BSS și Data - reprezintă memoria alocată pentru variabilele statice (globale), care există de la începutul până la încheierea programului, fără posibilitate de eliberare;
* Stiva (Stack) - zona de memorie în care se alocă contextele funcțiilor apelate în timpul execuției programului și în care se alocă argumentele și variabilele locale are funcțiilor; această zonă este alocată la intrarea în funcție și este eliberată la ieșirea din funcție;
* HEAP - zonă de memorie în care se pot aloca dinamic, de către programator, blocuri de memorie ce pot fi folosite în program până la eliberarea acestora de către programator.

Alocarea și dezalocarea memoriei în heap se fac folosind următoarele funcții:
* <code>void * malloc(unsigned size)</code> - alocă ''size'' octeți într-o zonă continuă din HEAP și întoarce adresa de memorie unde începe zona respectivă; dacă alocarea eșuează (nu exită suficientă memorie într-o zonă continuă în HEAP), funcția va întoarce '''NULL'''; alocarea nu șterge conținutul memoriei respective;
* <code>void * calloc(unsigned elements, unsigned elementSize)</code> - alocă ''elements'' elemente de ''elementSize'' octeți fiecare într-o zonă continuă din HEAP și întoarce adresa de memorie unde începe zona respectivă; dacă alocarea eșuează (nu exită suficientă memorie într-o zonă continuă în HEAP), funcția va întoarce '''NULL'''; alocarea șterge tot conținutul memoriei respective, scriind 0 la fiecare locație;
* <code>void free (void *)</code> - dezalocă o zonă de memorie alocată în prealabil cu <code>malloc</code> sau <code>calloc</code>; apelul succesiv de două sau mai multe ori a funcției <code>free</code> pentru aceeași zonă de memorie sau apelul ei pentru o adresă care nu a fost alocată în prealabil va avea ca efect oprirea imediată a programului cu eroare (''double free or corruption'').

Toate aceste funcții sunt definite în fișierul header <code style="color: green">stdlib.h</code>.

<syntaxhighlight lang="c">
#include <stdlib.h>
#include <stdio.h>

int main(){
int * intPointer;
short * shortPointer;

intPointer = (int*) malloc(sizeof(int));
shortPointer = (short*) calloc(1, sizeof(short));

printf("Valoarea din zona alocata pentru int este: %d\n", *intPointer);
printf("Valoarea din zona alocata pentru short este: %hd\n", *shortPointer);

free(intPointer);
free(shortPointer);

return 0;
}
</syntaxhighlight>

<div class="sfat"><span style="color: red; font-weight: bold">Atenție:</span> Deoarece funcțiile <code>malloc</code> și <code>calloc</code> au doar rolul de a aloca memorie, fără să știe care este scopul utilizării acestei memorii, ele întorc un pointer de tip <code>void *</code>. Astfel, pentru a putea stoca adresa într-un alt tip de pointer (de exemplu <code>int *</code>), ea trebuie convertită la tipul de date corect. Aceasta este explicația prezenței operatorului de cast din fața apelului funcțiilor <code>malloc</code> și <code>calloc</code> din codul de mai sus.</div>

== Aritmetica pointerilor ==

Când se alocă memorie in HEAP, rareori se alocă pentru un singur element, de cele mai multe ori se alocă pentru un număr mare de elemente de același fel. Ca exemplu, dacă vrem să stocăm o imagine High Definition, ne trebuie o zonă de memorie care să poată memora informație de culoare pentru 1920 * 1080 de pixeli, fiecare pixel având informație de culoare pentru roșu, verde și albastru (RGB). Fiecare din aceste componente de culoare se stochează pe un octet ca valoare întreagă fără semn (unsigned char). Prin urmare, pentru un frame se vor aloca 1920 * 1080 * 3 octeți = 6220800, aproape 6 MB. Această memorie se alocă întotdeauna într-o zonă continuă de către funcțiile <code>malloc</code> și <code>calloc</code>:

<syntaxhighlight lang="c">
#include <stdlib.h>
int main(){
unsigned char * frame;
frame = (unsigned char*) malloc(1920 * 1080 * 3 * sizeof(unsigned char));
//... use frame

free (frame);
return 0;
}
</syntaxhighlight>

Deoarece pointer-ul nu memorează decât adresa de început a zonei de memorie, există posibilitatea de a modifica adresa pentru a accesa elementele ulterioare. În acest scop, variabilele de tip pointer suportă doar operații aritmetice de adunare sau scădere, nu și de înmulțire sau împărțire.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Incrementarea unui pointer nu crește adresa cu 1, ci cu dimensiunea tipului de dată al pointer-ului. Deci pentru un <code>int * p;</code>, linia <code>p++;</code> va incrementa adresa cu 4 (sizeof(int)):</div>

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(){
int * pointer;
pointer = (int*) malloc(10 * sizeof(int));
printf("The pointer address is: %p\n", pointer);
printf("The pointer address + 1 is: %p\n", pointer + 1);
free (pointer);
return 0;
}
</syntaxhighlight>

<div class="regula"><span style="color: red; font-weight: bold">Atenție </span> ca prin operații pe pointeri să nu depășiți zona de memorie alocată.</div>

== Pointerii și vectorii ==

Memoria alocată pentru mai multe elemente de același fel reprezintă de fapt un vector de elemente de acel tip. Astfel aflăm că de fapt vectorii și pointerii, în multe situații se pot folosi interschimbabil.

Când se definește un vector, numele vectorului reprezintă un pointer la adresa de unde începe zona lui de memorie, adică adresa unde este memorat elementul de la indexul 0:

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(){
int array[10];
array[0] = 13;
printf("The array pointer address is: %p\n", array);
printf("The value at address %p is %d\n", array, *array);
return 0;
}
</syntaxhighlight>

Dereferențierea unui pointer indexat cu o valoare este echivalentă cu folosirea operatorului de acces la vector: <code>*(v + k)</code> == <code>v[k]</code>, unde '''v''' este un pointer (sau vector) iar '''k''' este un întreg.

<syntaxhighlight lang="c" highlight="14,18">
#include <stdlib.h>
#include <stdio.h>
int main(){
int arraySize;
printf("size = ");
scanf("%d", &arraySize);

int * heapArray;
heapArray = (int*) malloc(arraySize * sizeof(int));

int i;
for(i = 0; i < arraySize; i++) {
printf("heapArray[%d] = ", i);
scanf("%d", &heapArray[i]);
}

for(i = 0; i < arraySize; i++) {
printf("heapArray[%d] = %d\n", i, *(heapArray + i));
}

free (heapArray);
return 0;
}
</syntaxhighlight>

== Pointerii și structurile ==

Ca orice tip de dată, și variabilele de tip structură ocupă loc în memorie și deci pot exista pointeri de tip structură:

<syntaxhighlight lang="c">
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test testStructVar;
struct Test * structPointer = &testStructVar;
return 0;
}
</syntaxhighlight>

Având un pointer la o structură, accesul la câmpuri se poate face în două moduri:
<ol>
<li>Dereferențierea pointerului pentru a obține "valoarea" structurii și apoi utilizarea operatorului "." pentru accesul la membri:
<syntaxhighlight lang="c" highlight="12">
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test testStructVar;
struct Test * structPointer = &testStructVar;

*structPointer.intField = 10;
return 0;
}
</syntaxhighlight>
</li>
<li>Accesul la membrii unei structuri accesate printr-un pointer este atât de popular și des întâlnit în C încât există un operator special care permite accesul la câmpuri fără dereferențiere. Acest operator este săgeata "->":
<syntaxhighlight lang="c" highlight="13,14">
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test testStructVar;
struct Test * structPointer = &testStructVar;

*structPointer.intField = 10;
structPointer->floatField = 4.3;
structPointer->charField = 'B';
return 0;
}
</syntaxhighlight>
</li>
</ol>

Alocarea memoriei în HEAP pentru structuri se face identic cu alocarea pentru tipurile primitive de date:
<syntaxhighlight lang="c" highlight="10, 14">
#include <stdlib.h>
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test * structPointer = (struct Test*) malloc(sizeof(struct Test));

// use structPointer

free(structPointer);
return 0;
}
</syntaxhighlight>

== Adrese ca argumente de funcție ==

Știm deja că în C argumentele funcțiilor sunt pass-by-value, asta înseamnă că funcției i se transmite valoarea dintr-o variabilă, nu variabila în sine. Astfel, dacă o variabilă este folosită ca argument la apelul unei funcții, modificarea argumentului în funcție nu se propagă și spre variabila sursă:

<syntaxhighlight lang="c">
#include <stdio.h>

void divideByTwo(int arg) {
printf("Argument before division = %d\n", arg);
arg /= 2;
printf("Argument after division = %d\n", arg);
}

int main() {
int var = 10;
divideByTwo(var);
printf("Variabile after function call = %d\n", var);
return 0;
}
</syntaxhighlight>

Există o soluție pentru a permite propagarea modificării spre variabila sursă, și anume în loc de a trimite ca argument funcției variabila, se transmite adresa variabilei. Asta permite funcției să scrie direct în memoria alocată pentru variabilă și deci să-i modifice valoarea:
<syntaxhighlight lang="c">
#include <stdio.h>

void divideByTwo(int *arg) {
printf("Argument before division = %d\n", *arg);
*arg /= 2;
printf("Argument after division = %d\n", *arg);
}

int main() {
int var = 10;
divideByTwo(&var);
printf("Variabile after function call = %d\n", var);
return 0;
}
</syntaxhighlight>

= Evitarea pierderilor de memorie - <code>valgrind</code> =

Pierderile de memorie (memory leaks) apar atunci când programatorul alocă memorie dar uită să o elibereze. Aceasta este o problemă foarte delicată pentru că aplicația va continua să aloce până când va depăși limitele permise și sistemul de operare va opri procesul forțat. Chiar și dacă nu se ajunge acolo, ocuparea de cantități mari de memorie va face ca tot sistemul să se miște din ce în ce mai greu (vezi versiunile vechi de Firefox):

<syntaxhighlight lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main() {
char * buffer = (char*) malloc(100 * sizeof(char));
buffer = NULL;
printf("Done!\n");
return 0;
}
</syntaxhighlight>

În exemplul de mai sus este alocat un buffer de 100 de bytes iar adresa către zona respectivă se pierde când pointerului buffer i se atribuie valoarea '''NULL'''. Astfel, acea memorie nu mai poate fi nici accesată și nici eliberată. Cu toate acestea, programul compilează și rulează fără probleme. Pentru a verifica că nu există pierderi de memorie, se poate folosi programul <code>valgind</code>:

<span style="font-weight: bold"><span style="color: green">rhobincu@IronMan</span> <span style="color: blue">~/work/pc/test $</span></span> valgrind --leak-check=full ./test
==6076== Memcheck, a memory error detector
==6076== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==6076== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==6076== Command: ./test
==6076==
Done!
==6076==
==6076== HEAP SUMMARY:
==6076== in use at exit: 100 bytes in 1 blocks
==6076== total heap usage: 1 allocs, 0 frees, 100 bytes allocated
==6076==
==6076== 100 bytes in 1 blocks are definitely lost in loss record 1 of 1
==6076== at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6076== by 0x40058E: main (test.c:5)
==6076==
==6076== LEAK SUMMARY:
==6076== definitely lost: 100 bytes in 1 blocks
==6076== indirectly lost: 0 bytes in 0 blocks
==6076== possibly lost: 0 bytes in 0 blocks
==6076== still reachable: 0 bytes in 0 blocks
==6076== suppressed: 0 bytes in 0 blocks
==6076==
==6076== For counts of detected and suppressed errors, rerun with: -v
==6076== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

<div class="regula"><span style="color: red; font-weight: bold">Observație: </span> Ca valgrind să poată afișa numărul liniei și fișierul sursă unde apare eroarea, codul trebuie compilat cu simboluri de debug (-g).</div>

Pentru un cod corect, ieșirea lui '''valgrind''' este:
<syntaxhighlight lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main() {
char * buffer = (char*) malloc(100 * sizeof(char));
free(buffer);
buffer = NULL;
printf("Done!\n");
return 0;
}
</syntaxhighlight>

<span style="font-weight: bold"><span style="color: green">rhobincu@IronMan</span> <span style="color: blue">~/work/pc/test $</span></span> valgrind --leak-check=full ./test
==6244== Memcheck, a memory error detector
==6244== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==6244== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==6244== Command: ./test
==6244==
Done!
==6244==
==6244== HEAP SUMMARY:
==6244== in use at exit: 0 bytes in 0 blocks
==6244== total heap usage: 1 allocs, 1 frees, 100 bytes allocated
==6244==
==6244== All heap blocks were freed -- no leaks are possible
==6244==
==6244== For counts of detected and suppressed errors, rerun with: -v
==6244== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

= Exerciții =

<ol>
<li> Realizați o funcție <code>char * allocateString(unsigned size)</code> care să aloce în HEAP o zonă de memorie care să poată stoca un sir de caractere de dimensiunea <code>size</code> și să întoarcă adresa de unde începe zona respectivă. HINT: nu uitați de caracterul pentru final de șir.</li>
<li> Citiți de la tastatură o lungime de șir <code>length</code> apoi folosind funcția de mai sus, alocați memorie pentru stocarea unui șir de acea dimensiune. Citiți apoi de la tastatură și memorați un șir de caractere pe care să-l afișați ulterior în consolă folosind funcția <code>puts</code>.</li>
<li> Pentru programul de mai sus, realizați o funcție <code>void printString(char * string)</code> care să afișeze pe ecran șirul de caractere, folosind exclusiv funcția <code>putchar</code> și fără a folosi operatorul de indexare a vectorilor ([]). Verificați că această funcție afișează același lucru ca funcția <code>puts</code>. HINT: Utilizați operatorul de dereferențiere și aritmetica pointerilor.</li>
<li>Realizați o funcție <code>compute</code> de tip <code>void</code> care să calculeze suma și produsul a două valori de tip <code>float</code> astfel încât funcția apelantă să le poată utiliza. Testați funcția într-un program.</li>
<li>Găsiți și eliminați pierderile de memorie din codul de mai jos:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BUFFER_SIZE 100

struct Buffer {
unsigned size;
char * string;
};

struct Buffer * createBuffer(unsigned size) {
struct Buffer * newBuffer = (struct Buffer*) malloc (sizeof(struct Buffer));
newBuffer->size = size;
newBuffer->string = (char*) malloc(size * sizeof(char));
return newBuffer;
}

struct Buffer * reverseWord(struct Buffer * buffer) {
struct Buffer * newBuffer = createBuffer(buffer->size);
int i;
for(i = 0; i < strlen(buffer->string); i++) {
*(newBuffer->string + i) = buffer->string[strlen(buffer->string) - 1 - i];
}
newBuffer->string[strlen(buffer->string)] = '\0';
return newBuffer;
}

int main() {
unsigned wordCount;
printf("How many words? ");
scanf("%u", &wordCount);

unsigned i;
for(i = 0; i < wordCount; i++) {
struct Buffer * buffer = createBuffer(BUFFER_SIZE);
scanf("%s", buffer->string);
buffer = reverseWord(buffer);
printf("Reversed is: %s\n", buffer->string);
free(buffer);
}
return 0;
}

</syntaxhighlight>
</li>
</ol>

PC Laborator 12

2016-12-21T18:22:33Z

Lflueratoru: /* Tipuri de date pointer */

= Obiective =

La sfârșitul acestui laborator studenții vor fi capabili:
* să definească și să utilizeze tipuri de date pointer;
* să folosească pointeri pentru a putea modifica variabilele trimise ca argumente unor funcții;
* să aloce, să folosească și să elibereze memorie HEAP, în mod dinamic;
* să utilizeze aritmetica pointerilor pentru a itera peste elemente de la adrese consecutive de memorie;
* să utilizeze <code>valgrind</code> pentru a diagnostica pierderile de memorie.

= Tipuri de date pointer =

Un '''pointer''' reprezintă o variabilă care stochează o adresă în memoria dedicată aplicației. Tipul variabilei de tip pointer specifică tipul datei care poate fi citit de la adresa respectivă.

O variabilă de tip pointer se definește în felul următor:

<tip_data> * <nume_variabila>;

Spre exemplu:

<syntaxhighlight lang="c">
int * pa;
</syntaxhighlight>

Variabila de tip pointer <code>pa</code> nu memorează un întreg, ci o adresă în memorie, iar de la adresa respectivă se poate citi un întreg. Acest lucru se numește indirectare simplă. În plus, deoarece tipul pointer este în sine un tip de dată, și în definiția unui pointer <tip_data> poate fi un pointer, aceasta permite următoarele construcții:
* <code>int * pa;</code> - variabilă ce stochează o adresă de unde se poate citi un întreg (indirectare simplă);
* <code>int ** pa;</code> - variabilă ce stochează o adresă de unde se poate citi o adresă de unde se poate citi un întreg (dublă indirectare);
* <code>int *** pa;</code> - variabilă ce stochează o adresă de unde se poate citi o adresă de unde se poate citi o adresă de unde se poate citi un întreg (triplă indirectare);
* etc.

<div class="regula"><span style="color: red; font-weight: bold">Regulă:</span> Orice variabilă este stocată în memorie și deci are o adresă în memorie.</div>

În C există un tip de dată pointer care poate memora o adresă fără a ști ce date se află la adresa respectivă. Acest tip de pointer este <code>void*</code>.

== Dimensiunea tipului de date pointer ==

Conform regulii de mai sus, și variabilele de tip pointer ocupă loc în memorie, deci au dimensiune, în octeți. Un pointer nu oferă informații legate de dimensiunea ocupată de datele de la adresa respectivă, ci doar adresa de unde începe zona ocupată. Din moment ce un pointer memorează doar o adresă, dimensiunea variabilelor de tip pointer nu depinde decât de dimensiunea spațiului de memorie. Astfel, pentru procesoare și sisteme de operare pe 32 de biți, o variabilă de tip pointer va avea 32 de biți, iar pe procesoare și sisteme de operare pe 64 de biți, o variabilă de tip pointer va avea 64 de biți.

== Adresa unei variabile ==

Operatorul care permite aflarea adresei unde este stocată o variabilă este ampersand (&). Acesta este un operator unar ce se plasează înaintea unei variabile iar rezultatul evaluării sale este adresa unde este stocată variabila respectivă. Această adresă poate fi stocată într-o altă variabilă de tipul corespunzător. Altfel spus, pentru o variabilă de tip ''tip_data'', adresa acesteia se poate stoca într-o variabilă de tip ''tip_data *'':
<syntaxhighlight lang="c">
float floatValue;
float * floatAddress = &floatValue;

int intValue;
int * intAddress = &intValue;
int ** intPointerAddress = &intAddress;
</syntaxhighlight>

== Adresa NULL ==

Pentru orice aplicație, adresa 0 din spațiul ei de memorie este rezervată. Aceasta nu poate fi nici scrisă și nici citită. Această adresa poartă numele de '''NULL'''. Orice variabilă de tip pointer poate lua valoarea '''NULL''', lucru care de obicei specifică faptul că de fapt variabila pointer nu stochează o adresă validă.

Constanta '''NULL''' este definită în fișierul header <code style="color: green">stdlib.h</code> (Standard Library).

<syntaxhighlight lang="C">
#include <stdlib.h>

int main() {
char * charPointer = NULL;
return 0;
}
</syntaxhighlight>

== Valoarea de la o adresă ==

Având o variabilă de tip pointer, valoarea stocată în memorie la adresa respectivă se poate afla folosind caracterul steluță (*), numit și operator de indirectare. Acesta este un operator unar ce se plasează înaintea unei variabile de tip pointer iar rezultatul evaluării sale este valoarea din memorie de la adresa stocată în variabila respectivă. Această valoare poate fi stocată într-o altă variabilă de tipul corespunzător. Altfel spus, pentru o variabilă pointer de tip ''tip_data *'', valoarea de la adresa stocată de pointerul respectiv se poate memora într-o altă variabilă de tip ''tip_data'':

<syntaxhighlight lang="c">
float floatValue;
float * floatAddress = &floatValue;
float anotherFloatValue = *floatAddress;

int intValue;
int * intAddress = &intValue;
int ** intPointerAddress = &intAddress;
int * anotherintAddress = *intPointerAddress;
</syntaxhighlight>

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Accesarea valorii de la o adresă se numește dereferențiere. Dereferențierea unei adrese care nu face parte din spațiul de memorie al aplicației sau dereferențierea lui '''NULL''' va avea ca efect oprirea imediată a programului printr-un ''Segmentation fault.''</div>

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Nu confundați steluța utilizată la definirea unui pointer cu operatorul de indirectare/ dereferențiere. Aceștia sunt la fel de diferiți cum este și operatorul de inmulțire față de cel de indirectare.</div>

= Utilitatea variabilelor de tip pointer =

Pointerii în C au două roluri foarte importante:
# Alocarea dinamică de memorie în HEAP
# Modificarea variabilelor parametri ale unor funcții astfel încât modificarea să se păstreze în afara funcției

== Alocarea dinamică de memorie ==

Memoria alocată unei aplicații de către sistemul de operare este împărțită în mai multe secțiuni, din care importante pentru stocarea de date sunt:

* Segmentele BSS și Data - reprezintă memoria alocată pentru variabilele statice (globale), care există de la începutul până la încheierea programului, fără posibilitate de eliberare;
* Stiva (Stack) - zona de memorie în care se alocă contextele funcțiilor apelate în timpul execuției programului și în care se alocă argumentele și variabilele locale are funcțiilor; această zonă este alocată la intrarea în funcție și este eliberată la ieșirea din funcție;
* HEAP - zonă de memorie în care se pot aloca dinamic, de către programator, blocuri de memorie ce pot fi folosite în program până la eliberarea acestora de către programator.

Alocarea și dezalocarea memoriei în heap se face folosind următoarele funcții:
* <code>void * malloc(unsigned size)</code> - alocă ''size'' octeți într-o zonă continuă din HEAP și întoarce adresa de memorie unde începe zona respectivă; dacă alocarea eșuează (nu exită suficientă memorie într-o zonă continuă în HEAP), funcția va întoarce '''NULL'''; alocarea nu șterge conținutul memoriei respective;
* <code>void * calloc(unsigned elements, unsigned elementSize)</code> - alocă ''elements'' elemente de ''elementSize'' octeți fiecare într-o zonă continuă din HEAP și întoarce adresa de memorie unde începe zona respectivă; dacă alocarea eșuează (nu exită suficientă memorie într-o zonă continuă în HEAP), funcția va întoarce '''NULL'''; alocarea șterge tot conținutul memoriei respective, scriind 0 la fiecare locație;
* <code>void free (void *)</code> - dezalocă o zonă de memorie alocată în prealabil cu <code>malloc</code> sau <code>calloc</code>; apelul succesiv de două sau mai multe ori a funcției <code>free</code> pentru aceeași zonă de memorie sau apelul ei pentru o adresă care nu a fost alocată în prealabil va avea ca efect oprirea imediată a programului cu eroare (''double free or corruption'').

Toate aceste funcții sunt definite în fișierul header <code style="color: green">stdlib.h</code>.

<syntaxhighlight lang="c">
#include <stdlib.h>
#include <stdio.h>

int main(){
int * intPointer;
short * shortPointer;

intPointer = (int*) malloc(sizeof(int));
shortPointer = (short*) calloc(1, sizeof(short));

printf("Valoarea din zona alocata pentru int este: %d\n", *intPointer);
printf("Valoarea din zona alocata pentru short este: %hd\n", *shortPointer);

free(intPointer);
free(shortPointer);

return 0;
}
</syntaxhighlight>

<div class="sfat"><span style="color: red; font-weight: bold">Atenție:</span> Deoarece funcțiile <code>malloc</code> și <code>calloc</code> au doar rolul de a aloca memorie, fără să știe care este scopul utilizării acestei memorii, ele întorc un pointer de tip <code>void *</code>. Astfel, pentru a putea stoca adresa într-un alt tip de pointer (de exemplu <code>int *</code>), ea trebuie convertită la tipul de date corect. Aceasta este explicația prezenței operatorului de cast din fața apelului funcțiilor <code>malloc</code> și <code>calloc</code> din codul de mai sus.</div>

== Aritmetica pointerilor ==

Când se alocă memorie in HEAP, rareori se alocă pentru un singur element, de cele mai multe ori se alocă pentru un număr mare de elemente de același fel. Ca exemplu, dacă vrem să stocăm o imagine High Definition, ne trebuie o zonă de memorie care să poată memora informație de culoare pentru 1920 * 1080 de pixeli, fiecare pixel având informație de culoare pentru roșu, verde și albastru (RGB). Fiecare din aceste componente de culoare se stochează pe un octet ca valoare întreagă fără semn (unsigned char). Prin urmare pentru un frame se vor aloca 1920 * 1080 * 3 octeți = 6220800, aproape 6 MB. Această memorie se alocă întotdeauna într-o zonă continuă de către funcțiile <code>malloc</code> și <code>calloc</code>:

<syntaxhighlight lang="c">
#include <stdlib.h>
int main(){
unsigned char * frame;
frame = (unsigned char*) malloc(1920 * 1080 * 3 * sizeof(unsigned char));
//... use frame

free (frame);
return 0;
}
</syntaxhighlight>

Deoarece pointer-ul nu memorează decât adresa de început a zonei de memorie, există posibilitatea de a modifica adresa pentru a accesa elementele ulterioare. În acest scop, variabilele de tip pointer suportă doar operații aritmetice de adunare sau scădere, nu și de înmulțire sau împărțire.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Incrementarea unui pointer nu crește adresa cu 1, ci cu dimensiunea tipului de dată al pointer-ului. Deci pentru un <code>int * p;</code>, linia <code>p++;</code> va incrementa adresa cu 4 (sizeof(int)):</div>

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(){
int * pointer;
pointer = (int*) malloc(10 * sizeof(int));
printf("The pointer address is: %p\n", pointer);
printf("The pointer address + 1 is: %p\n", pointer + 1);
free (pointer);
return 0;
}
</syntaxhighlight>

<div class="regula"><span style="color: red; font-weight: bold">Atenție </span> ca prin operații pe pointeri să nu depășiți zona de memorie alocată.</div>

== Pointerii și vectorii ==

Memoria alocată pentru mai multe elemente de același fel reprezintă de fapt un vector de elemente de acel tip. Astfel aflăm că de fapt vectorii și pointerii, în multe situații se pot folosi interschimbabil.

Când se definește un vector, numele vectorului reprezintă un pointer la adresa de unde începe zona lui de memorie, adică adresa unde este memorat elementul de la indexul 0:

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(){
int array[10];
array[0] = 13;
printf("The array pointer address is: %p\n", array);
printf("The value at address %p is %d\n", array, *array);
return 0;
}
</syntaxhighlight>

Dereferențierea unui pointer indexat cu o valoare este echivalentă cu folosirea operatorului de acces la vector: <code>*(v + k)</code> == <code>v[k]</code>, unde '''v''' este un pointer (sau vector) iar '''k''' este un întreg.

<syntaxhighlight lang="c" highlight="14,18">
#include <stdlib.h>
#include <stdio.h>
int main(){
int arraySize;
printf("size = ");
scanf("%d", &arraySize);

int * heapArray;
heapArray = (int*) malloc(arraySize * sizeof(int));

int i;
for(i = 0; i < arraySize; i++) {
printf("heapArray[%d] = ", i);
scanf("%d", &heapArray[i]);
}

for(i = 0; i < arraySize; i++) {
printf("heapArray[%d] = %d\n", i, *(heapArray + i));
}

free (heapArray);
return 0;
}
</syntaxhighlight>

== Pointerii și structurile ==

Ca orice tip de dată, și variabilele de tip structură ocupă loc în memorie și deci pot exista pointeri de tip structură:

<syntaxhighlight lang="c">
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test testStructVar;
struct Test * structPointer = &testStructVar;
return 0;
}
</syntaxhighlight>

Având un pointer la o structură, accesul la câmpuri se poate face în două moduri:
<ol>
<li>Dereferențierea pointerului pentru a obține "valoarea" structurii și apoi utilizarea operatorului "." pentru accesul la membrii:
<syntaxhighlight lang="c" highlight="12">
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test testStructVar;
struct Test * structPointer = &testStructVar;

*structPointer.intField = 10;
return 0;
}
</syntaxhighlight>
</li>
<li>Accesul la membrii unei structuri accesate printr-un pointer este atât de popular și des întâlnit în C încât există un operator special care permite accesul la câmpuri fără dereferențiere. Acest operator este săgeata "->":
<syntaxhighlight lang="c" highlight="13,14">
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test testStructVar;
struct Test * structPointer = &testStructVar;

*structPointer.intField = 10;
structPointer->floatField = 4.3;
structPointer->charField = 'B';
return 0;
}
</syntaxhighlight>
</li>
</ol>

Alocarea memoriei în HEAP pentru structuri se face identic cu alocarea pentru tipurile primitive de date:
<syntaxhighlight lang="c" highlight="10, 14">
#include <stdlib.h>
struct Test {
int intField;
float floatField;
char charField;
char charArrayField[100];
};

int main() {
struct Test * structPointer = (struct Test*) malloc(sizeof(struct Test));

// use structPointer

free(structPointer);
return 0;
}
</syntaxhighlight>

== Adrese ca argumente de funcție ==

Știm deja că în C, argumentele funcțiilor sunt pass-by-value, asta înseamnă că funcției i se transmite valoarea dintr-o variabilă, nu variabila în sine. Astfel, dacă o variabilă este folosită ca argument la apelul unei funcții, modificarea argumentului în funcție nu se propagă și spre variabila sursă:

<syntaxhighlight lang="c">
#include <stdio.h>

void divideByTwo(int arg) {
printf("Argument before division = %d\n", arg);
arg /= 2;
printf("Argument after division = %d\n", arg);
}

int main() {
int var = 10;
divideByTwo(var);
printf("Variabile after function call = %d\n", var);
return 0;
}
</syntaxhighlight>

Există o soluție pentru a permite propagarea modificării spre variabila sursă, și anume în loc de a trimite ca argument funcției variabila, se transmite adresa variabilei. Asta permite funcției să scrie direct în memoria alocată pentru variabilă și deci să-i modifice valoarea:
<syntaxhighlight lang="c">
#include <stdio.h>

void divideByTwo(int *arg) {
printf("Argument before division = %d\n", *arg);
*arg /= 2;
printf("Argument after division = %d\n", *arg);
}

int main() {
int var = 10;
divideByTwo(&var);
printf("Variabile after function call = %d\n", var);
return 0;
}
</syntaxhighlight>

= Evitarea pierderilor de memorie - <code>valgrind</code> =

Pierderile de memorie (memory leaks) apar atunci când programatorul alocă memorie dar uită să o elibereze. Aceasta este o problemă foarte delicată pentru că aplicația va continua să aloce până când va depăși limitele permise și sistemul de operare va opri procesul forțat. Chiar și dacă nu se ajunge acolo, ocuparea de cantități mari de memorie va face ca tot sistemul să se miște din ce în ce mai greu (vezi versiunile vechi de Firefox):

<syntaxhighlight lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main() {
char * buffer = (char*) malloc(100 * sizeof(char));
buffer = NULL;
printf("Done!\n");
return 0;
}
</syntaxhighlight>

În exemplul de mai sus este alocat un buffer de 100 de bytes iar adresa către zona respectivă se pierde când pointerului buffer i se atribuie valoarea '''NULL'''. Astfel, acea memorie nu mai poate fi nici accesată și nici eliberată. Cu toate acestea, programul compilează și rulează fără probleme. Pentru a verifica că nu există pierderi de memorie, se poate folosi programul <code>valgind</code>:

<span style="font-weight: bold"><span style="color: green">rhobincu@IronMan</span> <span style="color: blue">~/work/pc/test $</span></span> valgrind --leak-check=full ./test
==6076== Memcheck, a memory error detector
==6076== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==6076== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==6076== Command: ./test
==6076==
Done!
==6076==
==6076== HEAP SUMMARY:
==6076== in use at exit: 100 bytes in 1 blocks
==6076== total heap usage: 1 allocs, 0 frees, 100 bytes allocated
==6076==
==6076== 100 bytes in 1 blocks are definitely lost in loss record 1 of 1
==6076== at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6076== by 0x40058E: main (test.c:5)
==6076==
==6076== LEAK SUMMARY:
==6076== definitely lost: 100 bytes in 1 blocks
==6076== indirectly lost: 0 bytes in 0 blocks
==6076== possibly lost: 0 bytes in 0 blocks
==6076== still reachable: 0 bytes in 0 blocks
==6076== suppressed: 0 bytes in 0 blocks
==6076==
==6076== For counts of detected and suppressed errors, rerun with: -v
==6076== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

<div class="regula"><span style="color: red; font-weight: bold">Observație: </span> Ca valgrind să poată afișa numărul liniei și fișierul sursă unde apare eroarea, codul trebuie compilat cu simboluri de debug (-g).</div>

Pentru un cod corect, ieșirea lui '''valgrind''' este:
<syntaxhighlight lang="c" line>
#include <stdio.h>
#include <stdlib.h>

int main() {
char * buffer = (char*) malloc(100 * sizeof(char));
free(buffer);
buffer = NULL;
printf("Done!\n");
return 0;
}
</syntaxhighlight>

<span style="font-weight: bold"><span style="color: green">rhobincu@IronMan</span> <span style="color: blue">~/work/pc/test $</span></span> valgrind --leak-check=full ./test
==6244== Memcheck, a memory error detector
==6244== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==6244== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==6244== Command: ./test
==6244==
Done!
==6244==
==6244== HEAP SUMMARY:
==6244== in use at exit: 0 bytes in 0 blocks
==6244== total heap usage: 1 allocs, 1 frees, 100 bytes allocated
==6244==
==6244== All heap blocks were freed -- no leaks are possible
==6244==
==6244== For counts of detected and suppressed errors, rerun with: -v
==6244== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

= Exerciții =

<ol>
<li> Realizați o funcție <code>char * allocateString(unsigned size)</code> care să aloce în HEAP o zonă de memorie care să poată stoca un sir de caractere de dimensiunea <code>size</code> și să întoarcă adresa de unde începe zona respectivă. HINT: nu uitați de caracterul pentru final de șir.</li>
<li> Citiți de la tastatură o lungime de șir <code>length</code> apoi folosind funcția de mai sus, alocați memorie pentru stocarea unui șir de acea dimensiune. Citiți apoi de la tastatură și memorați un șir de caractere pe care să-l afișați ulterior în consolă folosind funcția <code>puts</code>.</li>
<li> Pentru programul de mai sus, realizați o funcție <code>void printString(char * string)</code> care să afișeze pe ecran șirul de caractere, folosind exclusiv funcția <code>putchar</code> și fără a folosi operatorul de indexare a vectorilor ([]). Verificați că această funcție afișează același lucru ca funcția <code>puts</code>. HINT: Utilizați operatorul de dereferențiere și aritmetica pointerilor.</li>
<li>Realizați o funcție <code>compute</code> de tip <code>void</code> care să calculeze suma și produsul a două valori de tip <code>float</code> astfel încât funcția apelantă să le poată utiliza. Testați funcția într-un program.</li>
<li>Găsiți și eliminați pierderile de memorie din codul de mai jos:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BUFFER_SIZE 100

struct Buffer {
unsigned size;
char * string;
};

struct Buffer * createBuffer(unsigned size) {
struct Buffer * newBuffer = (struct Buffer*) malloc (sizeof(struct Buffer));
newBuffer->size = size;
newBuffer->string = (char*) malloc(size * sizeof(char));
return newBuffer;
}

struct Buffer * reverseWord(struct Buffer * buffer) {
struct Buffer * newBuffer = createBuffer(buffer->size);
int i;
for(i = 0; i < strlen(buffer->string); i++) {
*(newBuffer->string + i) = buffer->string[strlen(buffer->string) - 1 - i];
}
newBuffer->string[strlen(buffer->string)] = '\0';
return newBuffer;
}

int main() {
unsigned wordCount;
printf("How many words? ");
scanf("%u", &wordCount);

unsigned i;
for(i = 0; i < wordCount; i++) {
struct Buffer * buffer = createBuffer(BUFFER_SIZE);
scanf("%s", buffer->string);
buffer = reverseWord(buffer);
printf("Reversed is: %s\n", buffer->string);
free(buffer);
}
return 0;
}

</syntaxhighlight>
</li>
</ol>

PC Laborator 10

2016-12-14T16:35:03Z

Lflueratoru: /* Exemplu de depanare */

__TOC__
== Obiective ==
La sfârșitul acestui laborator studenții vor fi capabili:
* să înțeleagă funcționarea funcțiilor recursive;
* să implementeze și să apeleze funcții recursive;
* să folosească tool-ul de depanare GDB.

== Funcții recursive ==
Un obiect se definește în mod recursiv dacă în cadrul definiției sale există o referire la el însuși.<br>
Recursivitatea este un procedeu de programare în care o funcție se apelează pe ea însăși; o funcție care se auto-apelează poartă numele de funcție recursivă. O metodă de a înțelege mai ușor funcțiile recursive este imaginarea unui proces în execuție în care una dintre instrucțiuni este repetarea procesul în sine. O metodă și mai ușoară de a înțelege acest concept este compararea funcțiilor recursive cu [https://ro.wikipedia.org/wiki/Matrio%C8%99ka papușile Matrioska], unde o păpușă conține în interiorul său una sau mai multe păpuși de același fel, excepție făcând ultima păpușă, cea mai mică dintre ele, care este goală.<br>
Recursivitatea se folosește și în matematică - un exemplu ar fi șirul lui Fibonacci, care se folosește de ultimii doi termeni din șir pentru a afla termenul curent. Utilitatea recursivității, atât în matematică, cât și în cadrul programării, provine din posibilitatea de a defini un set infinit de termeni sau obiecte folosind o singură relație.<br>
Recursivitatea diferă de structurile iterative, deși ambele concepte presupun execuția repetată a unei porțiuni de cod. În cadrul execuției unei funcții recursive se verifică o condiție a cărei nerealizare duce la o altă execuție a funcției, fără a termina execuția curentă care va fi suspendată. În momentul satisfacerii condiției se revine la execuția curentă, fiecare apel suspendat fiind reluat și încheiat, în ordine invers cronologică.
<div class="regula">'''<font color="red"> Atenție:</font>''' Orice apel recursiv al unei funcții trebuie condiționat de o decizie care să împiedice apelarea funcției în buclă infinită.</div>
Recursivitatea poate fi de două feluri:
* recursivitate directă (în care o funcție conține o referință către ea însăși);
* recursivitate indirectă (în care o funcție X conține o referință către o funcție Y, funcția Y conținând la rândul ei o referință către funcția X).<br>
=== Exemplu de recursivitate directă ===
<syntaxhighlight lang="C">
int factorial(int n) {
if (n < 0) {
return 0;
} else if (n == 0) {
return 1;
}
int rez;
rez = n * factorial(n - 1);
return rez;
}
</syntaxhighlight>
=== Exemplu de recursivitate indirectă ===
<syntaxhighlight lang="C">
int factorial(int n) {
if (n < 0) {
return 0;
} else if (n == 0) {
return 1;
}
int rez;
rez = inmul_fact(n, n - 1);
return rez;
}

int inmul_fact(int a, int b) {
int prod;
prod = a * factorial(b);
return prod;
}
</syntaxhighlight>

== 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ă sau ce s-a întâmplat cu programul în momentul în care acesta a dat crash.<br>
GDB este capabil de a face 4 mari categorii de operații (și alte tipuri de operații ce duc la îndeplinirea celor 4):
* să pornească programul, specificând orice ar putea interveni în buna funcționare a acestuia;
* să facă programul să se oprească din execuție în anumite condiții specificate de utilizator;
* să examineze ce s-a întâmplat în momentul opririi programului;
* să schimbe anumite lucruri î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>

== Exerciții ==
<ol><li>Să se citească de la tastatură un număr întreg fără semn n. Să se implementeze o funcție recursivă care returnează suma primelor n numere naturale și să se afișeze rezultatul apelării acestei funcții.</li>
<li>Scrieți o funcție recursivă care șterge dintr-un vector elementul de pe o anumită poziție; funcția primește ca parametri vectorul, numărul de elemente din vector și poziția elementului ce urmează a fi șters.</li>
<li>Să se citească de la tastatură un număr întreg fără semn n. Să se implementeze o funcție recursivă care calculează termenul de pe o poziție dată din șirul lui Fibonacci și să se afișeze primii n termeni, știind că șirul lui Fibonacci este definit astfel:
* F(0) = 0;
* F(1) = 1;
* F(i) = F(i-1) + F(i-2), pentru i>=2.</li>
<li>Scrieți o funcție recursivă care calculează 2 la puterea n, unde n este un număr întreg fără semn introdus de la tastatură.</li>
<li>Scrieți o funcție recursivă care descompune un număr întreg fără semn n într-o sumă de puteri ale lui 2. Afișați această descompunere.</li>
<li>Scrieți o funcție recursivă care descompune un număr întreg fără semn n într-o sumă de termeni din șirul lui Fibonacci. Afișați termenii din care este compus numărul.</li>

</ol>

PC Laborator 10

2016-12-14T16:32:49Z

Lflueratoru: /* Funcții recursive */

__TOC__
== Obiective ==
La sfârșitul acestui laborator studenții vor fi capabili:
* să înțeleagă funcționarea funcțiilor recursive;
* să implementeze și să apeleze funcții recursive;
* să folosească tool-ul de depanare GDB.

== Funcții recursive ==
Un obiect se definește în mod recursiv dacă în cadrul definiției sale există o referire la el însuși.<br>
Recursivitatea este un procedeu de programare în care o funcție se apelează pe ea însăși; o funcție care se auto-apelează poartă numele de funcție recursivă. O metodă de a înțelege mai ușor funcțiile recursive este imaginarea unui proces în execuție în care una dintre instrucțiuni este repetarea procesul în sine. O metodă și mai ușoară de a înțelege acest concept este compararea funcțiilor recursive cu [https://ro.wikipedia.org/wiki/Matrio%C8%99ka papușile Matrioska], unde o păpușă conține în interiorul său una sau mai multe păpuși de același fel, excepție făcând ultima păpușă, cea mai mică dintre ele, care este goală.<br>
Recursivitatea se folosește și în matematică - un exemplu ar fi șirul lui Fibonacci, care se folosește de ultimii doi termeni din șir pentru a afla termenul curent. Utilitatea recursivității, atât în matematică, cât și în cadrul programării, provine din posibilitatea de a defini un set infinit de termeni sau obiecte folosind o singură relație.<br>
Recursivitatea diferă de structurile iterative, deși ambele concepte presupun execuția repetată a unei porțiuni de cod. În cadrul execuției unei funcții recursive se verifică o condiție a cărei nerealizare duce la o altă execuție a funcției, fără a termina execuția curentă care va fi suspendată. În momentul satisfacerii condiției se revine la execuția curentă, fiecare apel suspendat fiind reluat și încheiat, în ordine invers cronologică.
<div class="regula">'''<font color="red"> Atenție:</font>''' Orice apel recursiv al unei funcții trebuie condiționat de o decizie care să împiedice apelarea funcției în buclă infinită.</div>
Recursivitatea poate fi de două feluri:
* recursivitate directă (în care o funcție conține o referință către ea însăși);
* recursivitate indirectă (în care o funcție X conține o referință către o funcție Y, funcția Y conținând la rândul ei o referință către funcția X).<br>
=== Exemplu de recursivitate directă ===
<syntaxhighlight lang="C">
int factorial(int n) {
if (n < 0) {
return 0;
} else if (n == 0) {
return 1;
}
int rez;
rez = n * factorial(n - 1);
return rez;
}
</syntaxhighlight>
=== Exemplu de recursivitate indirectă ===
<syntaxhighlight lang="C">
int factorial(int n) {
if (n < 0) {
return 0;
} else if (n == 0) {
return 1;
}
int rez;
rez = inmul_fact(n, n - 1);
return rez;
}

int inmul_fact(int a, int b) {
int prod;
prod = a * factorial(b);
return prod;
}
</syntaxhighlight>

== 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ă sau ce s-a întâmplat cu programul în momentul în care acesta a dat crash.<br>
GDB este capabil de a face 4 mari categorii de operații (și alte tipuri de operații ce duc la îndeplinirea celor 4):
* să pornească programul, specificând orice ar putea interveni în buna funcționare a acestuia;
* să facă programul să se oprească din execuție în anumite condiții specificate de utilizator;
* să examineze ce s-a întâmplat în momentul opririi programului;
* să schimbe anumite lucruri î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>

== Exerciții ==
<ol><li>Să se citească de la tastatură un număr întreg fără semn n. Să se implementeze o funcție recursivă care returnează suma primelor n numere naturale și să se afișeze rezultatul apelării acestei funcții.</li>
<li>Scrieți o funcție recursivă care șterge dintr-un vector elementul de pe o anumită poziție; funcția primește ca parametri vectorul, numărul de elemente din vector și poziția elementului ce urmează a fi șters.</li>
<li>Să se citească de la tastatură un număr întreg fără semn n. Să se implementeze o funcție recursivă care calculează termenul de pe o poziție dată din șirul lui Fibonacci și să se afișeze primii n termeni, știind că șirul lui Fibonacci este definit astfel:
* F(0) = 0;
* F(1) = 1;
* F(i) = F(i-1) + F(i-2), pentru i>=2.</li>
<li>Scrieți o funcție recursivă care calculează 2 la puterea n, unde n este un număr întreg fără semn introdus de la tastatură.</li>
<li>Scrieți o funcție recursivă care descompune un număr întreg fără semn n într-o sumă de puteri ale lui 2. Afișați această descompunere.</li>
<li>Scrieți o funcție recursivă care descompune un număr întreg fără semn n într-o sumă de termeni din șirul lui Fibonacci. Afișați termenii din care este compus numărul.</li>

</ol>

PC Laborator 9

2016-12-06T21:45:20Z

Lflueratoru: /* Exerciții */

= Obiective =

În urma acestui laborator, studentul va fi capabil:
* să înțeleagă conceptul de funcție;
* să definească funcții, sub formă de prototip și implementare;
* să apeleze funcții;
* să utilizeze corect cuvintele cheie <code>void</code> și <code>return</code>.

= Funcții =

Funcțiile sunt secțiuni ale unui program care se pot apela de mai multe ori, care pot modifica starea programului (prin modificarea variabilelor sau operații de IO - citire și scriere de date) și care pot întoarce un rezultat.

== Definirea/ Declararea unei funcții ==

O funcție în C este <span style="color: black; font-weight: bold">declarată</span> în următorul fel:

tip_returnat nume_functie(lista_tip_argumente);

unde:
* <code>tip_returnat</code> definește tipul de date din care face parte valoarea returnată de funcție; dacă funcția nu întoarce nici o valoare (este folosit exclusiv pentru modificarea stării programului sau pentru IO), atunci se mai numește și procedură, iar tipul returnat este <code>void</code>;
* <code>nume_functie</code> reprezintă numele funcției care este folosit ulterior pentru apelul ei, și care respectă aceleași reguli ca orice identificator generic din C: poate conține exclusiv cifre, litere mici și mari, caracterul underscore (_), și nu poate începe cu cifră;
* <code>lista_tip_argumente</code> reprezintă o listă de tipuri de date, separate prin virgulă, din care fac parte argumentele funcției; această listă poate fi goală (dacă funcția nu are argumente).

O declarație de funcție se numește și <span style="color: blue; font-weight: bold">prototip</span>.

=== Exemple de declarații de funcții ===

<syntaxhighlight lang="c">
float max(float, float);
int inc(int);
void print(char[]);
int getAge();
</syntaxhighlight>

== Implementarea unei funcții ==

Implementarea (definirea) unei funcții în C se face în felul următor:

tip_returnat nume_functie(lista_argumente) {
statement_1
statement_2
...
statement_n
}

unde:
* <code>tip_returnat</code> reprezintă tipul returnat al funcției (vezi definiția unei funcții);
* <code>nume_funcție</code> reprezintă numele funcției (vezi definiția unei funcții);
* <code>lista_argumente</code> reprezintă o listă de definiții de variabile (de forma "tip_data nume_variabilă") care sunt argumentele funcției; această listă poate fi goală;
* <code>statement_...</code> reprezintă una sau mai multe instructiuni (''statement'') C care implementează comportamentul funcției și care se execută de fiecare dată când se apelează funcția; corpul unei funcții poate fi gol (poate să nu conțină nici un statement), dar atunci apelul ei nu are nici un efect; dacă funcția nu este de tip <code>void</code>, atunci obligatoriu ultima instrucțiune executată din funcție trebuie să fie <code>return</code>, care setează valoarea întoarsă de funcție.

=== Exemple de implementări (definiri) de funcții ===

<syntaxhighlight lang="c">
float max(float a, float b) {
if (a >= b) return a;
return b;
}

int inc(int value) {
return value + 1;
}

void print(char string[]) {
printf("%s", string);
}

int getAge() {
return 20;
}
</syntaxhighlight>

== Observații ==
<ol>
<li> O funcție nu este accesibilă/ apelabilă până nu este declarată în program.</li>
<li> Nu pot exista mai multe funcții cu același prototip.</li>
<li> O funcție poate avea o singură definiție/implementare și oricâte declarații.</li>
<li> O funcție declarată și ne-implementată (ne-definită) poate fi apelată, și fișierul va compila cu succes, dar linker-ul nu va reuși să creeze fișierul executabil. Ca exemplu, încercați scrierea, compilarea și execuția acestui program:
<syntaxhighlight lang="c">
#include <stdio.h>

int inc(int);

int main() {
int n;
printf("n = ");
scanf("%d", &n);
printf("n + 1 = %d\n", inc(n));
return 0;
}
</syntaxhighlight></li>
<li> Implementarea unei funcții ține loc implicit și de declarație, dacă aceasta nu există deja.</li>
<li> Cuvântul cheie <code>return</code> oprește execuția funcției, indiferent dacă mai există sau nu instrucțiuni după <code>return</code>.</li>
<li> Cuvântul cheie <code>return</code> poate fi folosit și în funcții <code>void</code>, dar urmat doar de punct și virgulă (;) și are ca efect ieșirea imediată din funcție. Ca exemplu, încercați scrierea, compilarea și execuția acestui program:
<syntaxhighlight lang="c">
#include <stdio.h>

void printIfNotZero(int value) {
if (value == 0) return;

printf("S-a apelat functia printIfNotZero cu valoarea %d.\n", value);
}

int main() {
printIfNotZero(1);
printIfNotZero(0);
printIfNotZero(2);
printIfNotZero(3);
printIfNotZero(0);
return 0;
}
</syntaxhighlight>
</li>
<li>În C, argumentele unei funcții sunt "pass-by-value", în sensul că ele conțin valorile variabilelor cu care se apelează funcția, nu se identifică cu aceste variabile. Altfel spus, modificarea unui argument al funcției nu se propagă în afara funcției. Ca exemplu, încercați scrierea, compilarea și execuția acestui program:
<syntaxhighlight lang="c">
#include <stdio.h>

void inc(int value) {
printf("In 'inc', la intrare, value este %d\n", value);
value = value + 1;
printf("In 'inc', la iesire, value este %d\n", value);
}

int main() {
int n = 3;
printf("Inainte de 'inc', n este egal cu %d\n", n);
inc(n);
printf("După 'inc', n este egal cu %d\n", n);
return 0;
}
</syntaxhighlight>
</li>
</ol>

= Programe din mai multe fișiere =

Programele complexe pot fi sparte în mai multe fișiere. În general, prin convenție, într-un fișier se scriu funcții care au legătură între ele, în sensul că sunt folosite pentru aceeași funcționalitate (de exemplu, funcții pentru criptare, sau funcții pentru IO, sau funcții pentru operații matematice, etc.). Pentru că aceste funcții pot teoretic fi folosite în multiple alte funcții din alte fișiere, sistemul cel mai des întâlnit pentru separarea acestor funcții este următorul:
* prototipurile funcțiilor se scriu într-un fișier cu extensia .h (header), iar acest fișier header este inclus acolo unde aceste funcții sunt apelate; aceste fișiere header trebuie obligatoriu să aibă gardă de dublă incluziune.
* implementările funcțiilor se scriu într-un fișier sursă .c, care include header-ul de mai sus, și care este compilat separat într-un object file.
* toate fișierele obiect se link-editează apoi într-un fișier executabil.

== Exemplu ==

<ul>

<li> <code style="color: green">custom_math.h</code>
<syntaxhighlight lang="c">
#ifndef CUSTOM_MATH_H
#define CUSTOM_MATH_H

long long factorial (int);

#endif
</syntaxhighlight>
</li>

<li> <code style="color: green">custom_math.c</code>
<syntaxhighlight lang="c">
#include <custom_math.h>
long long factorial (int n) {
long long result = 1;
int i;
if (n < 0) return 0;
for (i = 2; i < n; i++) {
result *= i;
}
return result;
}
</syntaxhighlight>
</li>

<li> <code style="color: green">main.c</code>
<syntaxhighlight lang="c">
#include <stdio.h>
#include <custom_math.h>
int main() {
int n;
printf("n = ");
scanf("%d", &n);
printf("%d! = %d\n", n, factorial(n));
return 0;
}
</syntaxhighlight>
</li>
</ul>

== Compilarea unui executabil din mai multe fișiere ==

Pentru a obține executabilul pentru exemplul de mai sus, se compilează fiecare fișier sursă într-un object file:
gcc -c custom_math.c -o custom_math.o
gcc -c main.c -o main.o

Apoi, se link-editează cele două surse împreună într-un executabil:
gcc custom_math.o main.o -o main

== Makefile pentru compilarea unui executabil din mai multe fișiere ==

<syntaxhighlight lang="make">
C_FILES=custom_math.c main.c
OBJ_FILES=$(C_FILES:.c=.o)

main: $(OBJ_FILES)
gcc $^ -o $@

%.o: %.c
gcc -c $^ -o $@

.PHONY: clear
clear:
rm -rf main $(OBJ_FILES)
</syntaxhighlight>

'''Observații:'''
# <code>C_FILES</code> definește o variabilă care conține o listă cu fișierele sursă ce se doresc compilate.
# <code>OBJ_FILES</code> reprezintă tot lista cu fișierele sursă, dar în care extensia .c se transformă în .o (astfel, se obține lista cu fișierele obiect necesare pentru compilare).
# Executabilul <code>main</code> depinde de toate fișierele obiect și se generează prin apelul lui <code>gcc</code>.
# Regula <code>%.o: %.c</code> este o regulă template care spune că dacă este necesară generarea unui fișier obiect, acesta depinde de un fișier cu același nume dar cu extensia .c, și se generează folosind tot un apel la <code>gcc</code>.
# Pentru a compila și alte surse în acest Makefile, tot ce este necesar este să le adăugați la lista <code>C_FILES</code>.

= Exerciții =

# Scrieți un program care să implementeze trei funcții:
#* <code>readTempCelsius</code> care să citească și să întoarcă un număr în virgulă reprezentând o temperatură în grade Celsius;
#* <code>celsius2fahrenheit</code> care să convertească un argument din grade Celsius în grade Fahrenheit;
#* <code>main</code> care să folosească celelalte două funcții pentru a converti o temperatură citită, din grade Celsius în Fahrenheit.
# Scrieți o funcție care să calculeze determinantul unei matrici de 3x3 sau mai simplu de 2x2. Testați funcția integrând-o într-un program.
# Scrieți o funcție care să primească ca argumente o matrice de numere întregi, dimensiunile ei și un număr întreg reprezentând o coloană, și să întoarcă suma numerelor de pe coloana respectivă. Funcția va afișa un mesaj și va întoarce 0 daca coloana nu există în matrice. Testați funcția integrând-o într-un program.
# Scrieți o funcție care să determine dacă un cuvânt este palindrom. Scrieți apoi un program care să citească cuvinte de la tastatură până când cuvântul introdus are lungimea 0. Pentru fiecare cuvânt introdus se va specifica dacă este sau nu palindrom.
#Scrieți o funcție care să compare doi vectori de caractere. Funcția primește doi vectori de caractere și are un rezultat întreg. <font color="green">HINT: asemenea funcției strcmp</font>. Funcția ce trebuie realizată întoarce:
#*număr pozitiv dacă primul șir e mai mare
#*număr negativ dacă primul sir e mai mic
#*zero dacă sunt egale
#Scrieți o funcție <code>sortare</code> care primește ca și argumente un întreg sort si un vector v. Funcția modifică elementele vectorului în funcție de întregul sort, astfel numere mai mari ca sort vor fi plasate la începutul vectorului.

PC Laborator 9

2016-12-06T20:56:49Z

Lflueratoru: /* Funcții */

= Obiective =

În urma acestui laborator, studentul va fi capabil:
* să înțeleagă conceptul de funcție;
* să definească funcții, sub formă de prototip și implementare;
* să apeleze funcții;
* să utilizeze corect cuvintele cheie <code>void</code> și <code>return</code>.

= Funcții =

Funcțiile sunt secțiuni ale unui program care se pot apela de mai multe ori, care pot modifica starea programului (prin modificarea variabilelor sau operații de IO - citire și scriere de date) și care pot întoarce un rezultat.

== Definirea/ Declararea unei funcții ==

O funcție în C este <span style="color: black; font-weight: bold">declarată</span> în următorul fel:

tip_returnat nume_functie(lista_tip_argumente);

unde:
* <code>tip_returnat</code> definește tipul de date din care face parte valoarea returnată de funcție; dacă funcția nu întoarce nici o valoare (este folosit exclusiv pentru modificarea stării programului sau pentru IO), atunci se mai numește și procedură, iar tipul returnat este <code>void</code>;
* <code>nume_functie</code> reprezintă numele funcției care este folosit ulterior pentru apelul ei, și care respectă aceleași reguli ca orice identificator generic din C: poate conține exclusiv cifre, litere mici și mari, caracterul underscore (_), și nu poate începe cu cifră;
* <code>lista_tip_argumente</code> reprezintă o listă de tipuri de date, separate prin virgulă, din care fac parte argumentele funcției; această listă poate fi goală (dacă funcția nu are argumente).

O declarație de funcție se numește și <span style="color: blue; font-weight: bold">prototip</span>.

=== Exemple de declarații de funcții ===

<syntaxhighlight lang="c">
float max(float, float);
int inc(int);
void print(char[]);
int getAge();
</syntaxhighlight>

== Implementarea unei funcții ==

Implementarea (definirea) unei funcții în C se face în felul următor:

tip_returnat nume_functie(lista_argumente) {
statement_1
statement_2
...
statement_n
}

unde:
* <code>tip_returnat</code> reprezintă tipul returnat al funcției (vezi definiția unei funcții);
* <code>nume_funcție</code> reprezintă numele funcției (vezi definiția unei funcții);
* <code>lista_argumente</code> reprezintă o listă de definiții de variabile (de forma "tip_data nume_variabilă") care sunt argumentele funcției; această listă poate fi goală;
* <code>statement_...</code> reprezintă una sau mai multe instructiuni (''statement'') C care implementează comportamentul funcției și care se execută de fiecare dată când se apelează funcția; corpul unei funcții poate fi gol (poate să nu conțină nici un statement), dar atunci apelul ei nu are nici un efect; dacă funcția nu este de tip <code>void</code>, atunci obligatoriu ultima instrucțiune executată din funcție trebuie să fie <code>return</code>, care setează valoarea întoarsă de funcție.

=== Exemple de implementări (definiri) de funcții ===

<syntaxhighlight lang="c">
float max(float a, float b) {
if (a >= b) return a;
return b;
}

int inc(int value) {
return value + 1;
}

void print(char string[]) {
printf("%s", string);
}

int getAge() {
return 20;
}
</syntaxhighlight>

== Observații ==
<ol>
<li> O funcție nu este accesibilă/ apelabilă până nu este declarată în program.</li>
<li> Nu pot exista mai multe funcții cu același prototip.</li>
<li> O funcție poate avea o singură definiție/implementare și oricâte declarații.</li>
<li> O funcție declarată și ne-implementată (ne-definită) poate fi apelată, și fișierul va compila cu succes, dar linker-ul nu va reuși să creeze fișierul executabil. Ca exemplu, încercați scrierea, compilarea și execuția acestui program:
<syntaxhighlight lang="c">
#include <stdio.h>

int inc(int);

int main() {
int n;
printf("n = ");
scanf("%d", &n);
printf("n + 1 = %d\n", inc(n));
return 0;
}
</syntaxhighlight></li>
<li> Implementarea unei funcții ține loc implicit și de declarație, dacă aceasta nu există deja.</li>
<li> Cuvântul cheie <code>return</code> oprește execuția funcției, indiferent dacă mai există sau nu instrucțiuni după <code>return</code>.</li>
<li> Cuvântul cheie <code>return</code> poate fi folosit și în funcții <code>void</code>, dar urmat doar de punct și virgulă (;) și are ca efect ieșirea imediată din funcție. Ca exemplu, încercați scrierea, compilarea și execuția acestui program:
<syntaxhighlight lang="c">
#include <stdio.h>

void printIfNotZero(int value) {
if (value == 0) return;

printf("S-a apelat functia printIfNotZero cu valoarea %d.\n", value);
}

int main() {
printIfNotZero(1);
printIfNotZero(0);
printIfNotZero(2);
printIfNotZero(3);
printIfNotZero(0);
return 0;
}
</syntaxhighlight>
</li>
<li>În C, argumentele unei funcții sunt "pass-by-value", în sensul că ele conțin valorile variabilelor cu care se apelează funcția, nu se identifică cu aceste variabile. Altfel spus, modificarea unui argument al funcției nu se propagă în afara funcției. Ca exemplu, încercați scrierea, compilarea și execuția acestui program:
<syntaxhighlight lang="c">
#include <stdio.h>

void inc(int value) {
printf("In 'inc', la intrare, value este %d\n", value);
value = value + 1;
printf("In 'inc', la iesire, value este %d\n", value);
}

int main() {
int n = 3;
printf("Inainte de 'inc', n este egal cu %d\n", n);
inc(n);
printf("După 'inc', n este egal cu %d\n", n);
return 0;
}
</syntaxhighlight>
</li>
</ol>

= Programe din mai multe fișiere =

Programele complexe pot fi sparte în mai multe fișiere. În general, prin convenție, într-un fișier se scriu funcții care au legătură între ele, în sensul că sunt folosite pentru aceeași funcționalitate (de exemplu, funcții pentru criptare, sau funcții pentru IO, sau funcții pentru operații matematice, etc.). Pentru că aceste funcții pot teoretic fi folosite în multiple alte funcții din alte fișiere, sistemul cel mai des întâlnit pentru separarea acestor funcții este următorul:
* prototipurile funcțiilor se scriu într-un fișier cu extensia .h (header), iar acest fișier header este inclus acolo unde aceste funcții sunt apelate; aceste fișiere header trebuie obligatoriu să aibă gardă de dublă incluziune.
* implementările funcțiilor se scriu într-un fișier sursă .c, care include header-ul de mai sus, și care este compilat separat într-un object file.
* toate fișierele obiect se link-editează apoi într-un fișier executabil.

== Exemplu ==

<ul>

<li> <code style="color: green">custom_math.h</code>
<syntaxhighlight lang="c">
#ifndef CUSTOM_MATH_H
#define CUSTOM_MATH_H

long long factorial (int);

#endif
</syntaxhighlight>
</li>

<li> <code style="color: green">custom_math.c</code>
<syntaxhighlight lang="c">
#include <custom_math.h>
long long factorial (int n) {
long long result = 1;
int i;
if (n < 0) return 0;
for (i = 2; i < n; i++) {
result *= i;
}
return result;
}
</syntaxhighlight>
</li>

<li> <code style="color: green">main.c</code>
<syntaxhighlight lang="c">
#include <stdio.h>
#include <custom_math.h>
int main() {
int n;
printf("n = ");
scanf("%d", &n);
printf("%d! = %d\n", n, factorial(n));
return 0;
}
</syntaxhighlight>
</li>
</ul>

== Compilarea unui executabil din mai multe fișiere ==

Pentru a obține executabilul pentru exemplul de mai sus, se compilează fiecare fișier sursă într-un object file:
gcc -c custom_math.c -o custom_math.o
gcc -c main.c -o main.o

Apoi, se link-editează cele două surse împreună într-un executabil:
gcc custom_math.o main.o -o main

== Makefile pentru compilarea unui executabil din mai multe fișiere ==

<syntaxhighlight lang="make">
C_FILES=custom_math.c main.c
OBJ_FILES=$(C_FILES:.c=.o)

main: $(OBJ_FILES)
gcc $^ -o $@

%.o: %.c
gcc -c $^ -o $@

.PHONY: clear
clear:
rm -rf main $(OBJ_FILES)
</syntaxhighlight>

'''Observații:'''
# <code>C_FILES</code> definește o variabilă care conține o listă cu fișierele sursă ce se doresc compilate.
# <code>OBJ_FILES</code> reprezintă tot lista cu fișierele sursă, dar în care extensia .c se transformă în .o (astfel, se obține lista cu fișierele obiect necesare pentru compilare).
# Executabilul <code>main</code> depinde de toate fișierele obiect și se generează prin apelul lui <code>gcc</code>.
# Regula <code>%.o: %.c</code> este o regulă template care spune că dacă este necesară generarea unui fișier obiect, acesta depinde de un fișier cu același nume dar cu extensia .c, și se generează folosind tot un apel la <code>gcc</code>.
# Pentru a compila și alte surse în acest Makefile, tot ce este necesar este să le adăugați la lista <code>C_FILES</code>.

= Exerciții =

# Scrieți un program care să implementeze trei funcții:
#* <code>readTempCelsius</code> care să citească și să întoarcă un număr în virgulă reprezentând o temperatură în grade Celsius;
#* <code>celsius2fahrenheit</code> care să convertească un argument din grade Celsius în grade Fahrenheit;
#* <code>main</code> care să folosească celelalte două funcții pentru a converti o temperatură citită, din grade Celsius în Fahrenheit.
# Scrieți o funcție care să calculeze determinantul unei matrici de 3x3 sau mai simplu de 2x2. Testați funcția integrând-o într-un program.
# Scrieți o funcție care să primească ca argumente o matrice de numere întregi, dimensiunile ei și un număr întreg reprezentând o coloană, și să întoarcă suma numerelor de pe coloana respectivă. Funcția va afișa un mesaj și va întoarce 0 daca coloana nu există în matrice. Testați funcția integrând-o într-un program.
# Scrieți o funcție care să determine dacă un cuvânt este palindrom. Scrieți apoi un program care să citească cuvinte de la tastatură până când cuvântul introdus are lungimea 0. Pentru fiecare cuvânt introdus se va specifica dacă este sau nu palindrom.
#Scrieți o funcție care să compare doi vectori de caractere.Funcția primește doi vectori de caractere și are un rezultat întreg.<font color="green">HINT: asemenea funcției strcmp </font>.Funcția ce trebuie realizată întoarce:
#*număr pozitiv dacă primul șir e mai mare
#*număr negativ dacă primul sir e mai mic
#*zero dacă sunt egale
#Scrieți o funcție <code>sortare</code> care primește ca și argumente un întreg sort si un vector v. Funcția modifică elementele vectorului în funcție de întregul sort,astfel numere mai mari ca sort vor fi plasate la începutul vectorului.

PC Laborator 8

2016-11-23T20:59:35Z

Lflueratoru: /* Compararea a doua șiruri de caractere */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
*înțeleagă cum funcționează șirurile de caractere
*facă operații cu șiruri de caractere

== Șiruri de caractere ==

[[Fișier:ascii_table.jpg|thumb]]

În C, tipul de dată șir nu există în mod implicit. Singurul mod prin care putem opera cu șiruri este folosind tablourile unidimensionale, vectorii. Ne amintim că un vector este definit complet prin intermediul a trei caracteristici: tipul de date conținute, numele vectorului și numărul său de elemente. Așadar, putem declara un vector al cărui tip de data să fie char, caz în care acel vector va fi denumit șir (de caractere).
Declararea unui șir de caractere se face astfel:
<syntaxhighlight lang="C">
char numele_sirului [numarul_de_caractere];
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Spre deosebire de vectorii studiați în laboratorul anterior, ale căror elemente sunt precizate explicit, șirurile au un caracter special, implicit, numit end of string și reprezentat astfel: \0.
</div>

== Operații cu șiruri ==

Toate proprietățile vectorilor, studiate în laboratorul anterior, sunt valabile și în cazul șirurilor. De asemenea, toate operațiile pe care le putem face cu vectori sunt posibile și în cazul șirurilor.

<div class="regula"> ''' Observație: ''' Există anumite operații asociate exclusiv șirurilor, precum căutarea unor caractere sau a unui șir într-un alt șir, concatenarea, etc. Toate aceste operații au funcții predefinite, care pot fi găsite într-un header specific, string.h. </div>

=== Aflarea lungimii unui șir de caractere ===
Pe lângă metoda clasică, discutată în capitolul anterior, ce presupune parcurgerea șirului și numărarea elementelor acestuia, avem și o metodă proprie șirurilor. Ea presupune apelarea funcției strlen(), predefinita în biblioteca string.h, care va întoarce numărul de elemente al șirului.
<div class="regula"> ''' Observație: ''' Caracterul '\0' marchează sfârșitul șirului, iar acolo se oprește numărarea.
</div>
Sintaxa generala:
<syntaxhighlight lang="C">
lungime_sir = strlen (sir_de_caractere);
</syntaxhighlight>

=== Citirea unui șir de caractere ===
Există mai multe variante pentru a citi un șir de caractere, unele asemănătoare vectorilor, altele specifice șirurilor de caractere.

1. Citirea șirului caracter cu caracter, până la întâlnirea caracterului cu codul ASCII 10 (newline - \n), moment în care se scrie caracterul de sfârșit de șir (null terminator - \0):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
int i;
for (i = 0; i < MAX_SIZE; i++) {
scanf ("%c", &sir_de_caractere[i]);
/* 10 este codul ascii pentru \n, adica enter */
if (sir_de_caractere[i] == 10) {
sir_de_caractere[i] = '\0';
break;
}
}
</syntaxhighlight>

2. Se folosește <code>scanf</code> cu template-ul <code>%s</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul caracter alb - spațiu, tab sau newline):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%s", sir_de_caractere);
</syntaxhighlight>

3. Se folosește <code>scanf</code> cu template-ul <code>%[^\n]</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul newline pe care nu îl va consuma din stream - acesta va trebui eliminat manual cu apel de <code>getchar()</code>):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%[^\n]", sir_de_caractere);
getchar();
</syntaxhighlight>

4. Se folosește <code>fgets</code> (atenție, acestă funcție va citi maxim MAX_SIZE - 1 caractere de la tastatură, sau până la întâlnirea lui \n, în care situație caracterul \n va fi adăugat în șir):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
fgets(sir_de_caractere, MAX_SIZE, stdin);
</syntaxhighlight>

=== Afișarea unui șir de caractere ===
Analog citirii unui șir de caractere, afișarea se poate face și ea în mai multe moduri, după cum urmează:

1. Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf("%s",sir_de_caractere); // citire sir de caractere

int i;
for (i = 0; i < MAX_SIZE && sir_de_caractere [i] != '\0'; i++) {
printf ("%c", sir_de_caractere [i]);
}
</syntaxhighlight>

2. Sintaxa generala
<syntaxhighlight lang="C">
printf ("%s", sir_de_caractere);
</syntaxhighlight>
3. Sintaxa generala:
<syntaxhighlight lang="C">
puts(sir_de_caractere);
</syntaxhighlight>

'''Exemplu''': Fie șirul de caractere sir[10]. Citiți următoarea frază folosind toate cele 3 metode, apoi afișați conținutul șirului folosind puts();. Ce observați? Explicați.

=== Căutarea unui caracter într-un șir de caractere ===
Funcția folosită: strchr();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE], char caracterul_cautat;
int pozitie;
pozitie = strchr(sir_de_caractere, caracterul_cautat) - sir_de_caractere;
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Funcția strchr NU oferă toate pozițiile pe care se află caracterul_căutat, ci doar prima poziție.
*Pentru a afla ultima poziție pe care se află un caracter căutat, se va folosi funcția strrchr(), sintaxa fiind identică.
*Pentru a caută un șir de caractere într-un alt șir de caractere, se va folosi funcția strstr(), sintaxa fiind aceeași.
</div>

=== Copierea unui șir de caractere în altul ===
Funcția folosită: strcpy ();
Sintaxa:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcpy(destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' șirul sursă se copiază în șirul destinație. Dacă lungimea șirului destinație este mai mică decât a șirului sursă, atunci copierea se face cu erori. Trebuie deci să punem următoarea condiție:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen(sursa);
</syntaxhighlight>
</div>

=== Concatenarea unor șiruri de caractere ===
Funcția folosită: srtcat();
Sintaxa generala:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcat(destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Concatenarea se face adăugând șirul sursă la șirul destinație. Este deci necesar ca șirul sursă să "încăpă" în șirul destinație. Matematic, asta se traduce astfel:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen(sursa) + strlen(destinatie);
</syntaxhighlight>
</div>

=== Compararea a doua șiruri de caractere ===
Funcția folosită: strcmp();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir1 [MAX_SIZE1], sir2 [MAX_SIZE2];
int rezultat;
rezultat = strcmp(sir1, sir2);
</syntaxhighlight>
Funcția strcmp(); întoarce următoarele valori:
* un număr negativ - dacă sir1 este înainte din punct de vedere alfabetic;
* 0 - dacă cele două șiruri sunt identice;
* un număr pozitiv - dacă sir2 este înainte din punct de vedere alfabetic.

=== Inserția unui șir de caractere într-un alt șir ===
Pentru această operație nu există o funcție specializată în biblioteca string.h. Ceea ce vom face va fi să folosim procedee învățate la vectori, cât și funcții menționate anterior. Etapele sunt următoarele:
* declarăm cele două șiruri;
* verificăm dacă șirul ce urmează să fie introdus încape în șirul inițial;
* găsim poziția unde dorim să adăugăm șirul ce urmează să fie introdus;
* începând cu acea poziție, mutăm toate caracterele la dreaptă cu un număr de poziții egal cu lungimea șirului ce urmează să fie introdus;
* pe pozițiile rămase "goale" introducem șirul nou.
'''Exemplu:'''
Transformați fraza "Studentul a picat examenul final." în "Studentul nu a picat examenul final."
Date necesare: sir_inițial[50] = "Sudentul a picat examenul final.", sir_nou[3] = "nu ".

== Observații și exemple==

=== strlen vs sizeof ===

<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "StringLab";
int len,size;

len = strlen(str1);
size = sizeof(str1);
printf("Lungimea str1: %d\n", len);
printf("Lungimea total alocata str1: %d\n", size);

return 0;
}

</syntaxhighlight>

=== strchr vs strrchr ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[40] = "Cautare de caracter printre caractere";
printf ("Caz1: %s\n", strchr(str1, 'a'));
printf ("Caz2: %s\n", strrchr(str1, 'a'));
printf ("Caz3: %s\n", strstr(str1, "de"));

return 0;
}
</syntaxhighlight>

=== Exemple operații cu șiruri===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>

int main () {

char str1[10] = "Hello";
char str2[10] = "String Lab";
char str3[10];
int len ;

/* copiaza str1 in str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );

/* concateneaza str1 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );

/* lungimea str1 dupa concatenare */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );

return 0;
}

</syntaxhighlight>

=== Model de concatenare fără a utiliza strcat ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(){

char str1[10], str2[10], str3[20];
int i, poz;
printf("Introduceti sir1: ");
scanf("%s",str1);
printf("Introduceti sir2: ");
scanf("%s",str2);

for (i = 0; i < strlen(str1); i++)
str3[i] = str1[i];
poz=i;
for (i = 0; i < strlen(str2); i++)
str3[poz+i] = str2[i];
str3[poz+i] ='\0';

printf("Sir concatenat: %s\n",str3);

return 0;
}
</syntaxhighlight>

=== Exemple fgets & puts ===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>
int main(){
char nume[30];
printf("Numele este: ");
/* Citește string de la utilizator */
fgets(nume, 30, stdin);
printf("Nume: ");
/* Afișează string */
puts(nume);
return 0;
}
</syntaxhighlight>

== Exerciții ==

#Să se scrie un program care citește de la tastatură un cuvânt.Să se afișeze cuvintele ce se obțin prin eliminarea succesiva a primei si ultimei litere din cuvântul citit.
#Să se scrie un program care șterge toate caracterele dintr-o linie citită de la tastatură cu excepția literelor.
#Să se scrie un program care afișează pe ecran frecvența de apariție a unui caracter citit de la tastatură.
#Se citeşte de la tastatură o propoziţie (şir de caractere) terminată cu punct.Să se afişeze fiecare cuvânt din propoziţie pe câte o linie separată.

PC Laborator 8

2016-11-23T20:35:05Z

Lflueratoru: /* Compararea a doua șiruri de caractere */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
*înțeleagă cum funcționează șirurile de caractere
*facă operații cu șiruri de caractere

== Șiruri de caractere ==

[[Fișier:ascii_table.jpg|thumb]]

În C, tipul de dată șir nu există în mod implicit. Singurul mod prin care putem opera cu șiruri este folosind tablourile unidimensionale, vectorii. Ne amintim că un vector este definit complet prin intermediul a trei caracteristici: tipul de date conținute, numele vectorului și numărul său de elemente. Așadar, putem declara un vector al cărui tip de data să fie char, caz în care acel vector va fi denumit șir (de caractere).
Declararea unui șir de caractere se face astfel:
<syntaxhighlight lang="C">
char numele_sirului [numarul_de_caractere];
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Spre deosebire de vectorii studiați în laboratorul anterior, ale căror elemente sunt precizate explicit, șirurile au un caracter special, implicit, numit end of string și reprezentat astfel: \0.
</div>

== Operații cu șiruri ==

Toate proprietățile vectorilor, studiate în laboratorul anterior, sunt valabile și în cazul șirurilor. De asemenea, toate operațiile pe care le putem face cu vectori sunt posibile și în cazul șirurilor.

<div class="regula"> ''' Observație: ''' Există anumite operații asociate exclusiv șirurilor, precum căutarea unor caractere sau a unui șir într-un alt șir, concatenarea, etc. Toate aceste operații au funcții predefinite, care pot fi găsite într-un header specific, string.h. </div>

=== Aflarea lungimii unui șir de caractere ===
Pe lângă metoda clasică, discutată în capitolul anterior, ce presupune parcurgerea șirului și numărarea elementelor acestuia, avem și o metodă proprie șirurilor. Ea presupune apelarea funcției strlen(), predefinita în biblioteca string.h, care va întoarce numărul de elemente al șirului.
<div class="regula"> ''' Observație: ''' Caracterul '\0' marchează sfârșitul șirului, iar acolo se oprește numărarea.
</div>
Sintaxa generala:
<syntaxhighlight lang="C">
lungime_sir = strlen (sir_de_caractere);
</syntaxhighlight>

=== Citirea unui șir de caractere ===
Există mai multe variante pentru a citi un șir de caractere, unele asemănătoare vectorilor, altele specifice șirurilor de caractere.

1. Citirea șirului caracter cu caracter, până la întâlnirea caracterului cu codul ASCII 10 (newline - \n), moment în care se scrie caracterul de sfârșit de șir (null terminator - \0):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
int i;
for (i = 0; i < MAX_SIZE; i++) {
scanf ("%c", &sir_de_caractere[i]);
/* 10 este codul ascii pentru \n, adica enter */
if (sir_de_caractere[i] == 10) {
sir_de_caractere[i] = '\0';
break;
}
}
</syntaxhighlight>

2. Se folosește <code>scanf</code> cu template-ul <code>%s</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul caracter alb - spațiu, tab sau newline):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%s", sir_de_caractere);
</syntaxhighlight>

3. Se folosește <code>scanf</code> cu template-ul <code>%[^\n]</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul newline pe care nu îl va consuma din stream - acesta va trebui eliminat manual cu apel de <code>getchar()</code>):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%[^\n]", sir_de_caractere);
getchar();
</syntaxhighlight>

4. Se folosește <code>fgets</code> (atenție, acestă funcție va citi maxim MAX_SIZE - 1 caractere de la tastatură, sau până la întâlnirea lui \n, în care situație caracterul \n va fi adăugat în șir):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
fgets(sir_de_caractere, MAX_SIZE, stdin);
</syntaxhighlight>

=== Afișarea unui șir de caractere ===
Analog citirii unui șir de caractere, afișarea se poate face și ea în mai multe moduri, după cum urmează:

1. Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf("%s",sir_de_caractere); // citire sir de caractere

int i;
for (i = 0; i < MAX_SIZE && sir_de_caractere [i] != '\0'; i++) {
printf ("%c", sir_de_caractere [i]);
}
</syntaxhighlight>

2. Sintaxa generala
<syntaxhighlight lang="C">
printf ("%s", sir_de_caractere);
</syntaxhighlight>
3. Sintaxa generala:
<syntaxhighlight lang="C">
puts(sir_de_caractere);
</syntaxhighlight>

'''Exemplu''': Fie șirul de caractere sir[10]. Citiți următoarea frază folosind toate cele 3 metode, apoi afișați conținutul șirului folosind puts();. Ce observați? Explicați.

=== Căutarea unui caracter într-un șir de caractere ===
Funcția folosită: strchr();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE], char caracterul_cautat;
int pozitie;
pozitie = strchr(sir_de_caractere, caracterul_cautat) - sir_de_caractere;
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Funcția strchr NU oferă toate pozițiile pe care se află caracterul_căutat, ci doar prima poziție.
*Pentru a afla ultima poziție pe care se află un caracter căutat, se va folosi funcția strrchr(), sintaxa fiind identică.
*Pentru a caută un șir de caractere într-un alt șir de caractere, se va folosi funcția strstr(), sintaxa fiind aceeași.
</div>

=== Copierea unui șir de caractere în altul ===
Funcția folosită: strcpy ();
Sintaxa:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcpy(destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' șirul sursă se copiază în șirul destinație. Dacă lungimea șirului destinație este mai mică decât a șirului sursă, atunci copierea se face cu erori. Trebuie deci să punem următoarea condiție:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen(sursa);
</syntaxhighlight>
</div>

=== Concatenarea unor șiruri de caractere ===
Funcția folosită: srtcat();
Sintaxa generala:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcat(destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Concatenarea se face adăugând șirul sursă la șirul destinație. Este deci necesar ca șirul sursă să "încăpă" în șirul destinație. Matematic, asta se traduce astfel:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen(sursa) + strlen(destinatie);
</syntaxhighlight>
</div>

=== Compararea a doua șiruri de caractere ===
Funcția folosită: strcmp();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir1 [MAX_SIZE1], sir2 [MAX_SIZE2];
int rezultat;
rezultat = strcmp(sir1, sir2);
</syntaxhighlight>
Funcția strcmp(); întoarce următoarele valori:
* -1 dacă sir1 este înainte din punct de vedere alfabetic;
* 0 dacă cele două șiruri sunt identice;
* +1 dacă sir2 este înainte din punct de vedere alfabetic.

=== Inserția unui șir de caractere într-un alt șir ===
Pentru această operație nu există o funcție specializată în biblioteca string.h. Ceea ce vom face va fi să folosim procedee învățate la vectori, cât și funcții menționate anterior. Etapele sunt următoarele:
* declarăm cele două șiruri;
* verificăm dacă șirul ce urmează să fie introdus încape în șirul inițial;
* găsim poziția unde dorim să adăugăm șirul ce urmează să fie introdus;
* începând cu acea poziție, mutăm toate caracterele la dreaptă cu un număr de poziții egal cu lungimea șirului ce urmează să fie introdus;
* pe pozițiile rămase "goale" introducem șirul nou.
'''Exemplu:'''
Transformați fraza "Studentul a picat examenul final." în "Studentul nu a picat examenul final."
Date necesare: sir_inițial[50] = "Sudentul a picat examenul final.", sir_nou[3] = "nu ".

== Observații și exemple==

=== strlen vs sizeof ===

<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "StringLab";
int len,size;

len = strlen(str1);
size = sizeof(str1);
printf("Lungimea str1: %d\n", len);
printf("Lungimea total alocata str1: %d\n", size);

return 0;
}

</syntaxhighlight>

=== strchr vs strrchr ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[40] = "Cautare de caracter printre caractere";
printf ("Caz1: %s\n", strchr(str1, 'a'));
printf ("Caz2: %s\n", strrchr(str1, 'a'));
printf ("Caz3: %s\n", strstr(str1, "de"));

return 0;
}
</syntaxhighlight>

=== Exemple operații cu șiruri===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>

int main () {

char str1[10] = "Hello";
char str2[10] = "String Lab";
char str3[10];
int len ;

/* copiaza str1 in str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );

/* concateneaza str1 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );

/* lungimea str1 dupa concatenare */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );

return 0;
}

</syntaxhighlight>

=== Model de concatenare fără a utiliza strcat ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(){

char str1[10], str2[10], str3[20];
int i, poz;
printf("Introduceti sir1: ");
scanf("%s",str1);
printf("Introduceti sir2: ");
scanf("%s",str2);

for (i = 0; i < strlen(str1); i++)
str3[i] = str1[i];
poz=i;
for (i = 0; i < strlen(str2); i++)
str3[poz+i] = str2[i];
str3[poz+i] ='\0';

printf("Sir concatenat: %s\n",str3);

return 0;
}
</syntaxhighlight>

=== Exemple fgets & puts ===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>
int main(){
char nume[30];
printf("Numele este: ");
/* Citește string de la utilizator */
fgets(nume, 30, stdin);
printf("Nume: ");
/* Afișează string */
puts(nume);
return 0;
}
</syntaxhighlight>

== Exerciții ==

#Să se scrie un program care citește de la tastatură un cuvânt.Să se afișeze cuvintele ce se obțin prin eliminarea succesiva a primei si ultimei litere din cuvântul citit.
#Să se scrie un program care șterge toate caracterele dintr-o linie citită de la tastatură cu excepția literelor.
#Să se scrie un program care afișează pe ecran frecvența de apariție a unui caracter citit de la tastatură.
#Se citeşte de la tastatură o propoziţie (şir de caractere) terminată cu punct.Să se afişeze fiecare cuvânt din propoziţie pe câte o linie separată.

PC Laborator 8

2016-11-23T20:34:51Z

Lflueratoru: /* Concatenarea unor șiruri de caractere */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
*înțeleagă cum funcționează șirurile de caractere
*facă operații cu șiruri de caractere

== Șiruri de caractere ==

[[Fișier:ascii_table.jpg|thumb]]

În C, tipul de dată șir nu există în mod implicit. Singurul mod prin care putem opera cu șiruri este folosind tablourile unidimensionale, vectorii. Ne amintim că un vector este definit complet prin intermediul a trei caracteristici: tipul de date conținute, numele vectorului și numărul său de elemente. Așadar, putem declara un vector al cărui tip de data să fie char, caz în care acel vector va fi denumit șir (de caractere).
Declararea unui șir de caractere se face astfel:
<syntaxhighlight lang="C">
char numele_sirului [numarul_de_caractere];
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Spre deosebire de vectorii studiați în laboratorul anterior, ale căror elemente sunt precizate explicit, șirurile au un caracter special, implicit, numit end of string și reprezentat astfel: \0.
</div>

== Operații cu șiruri ==

Toate proprietățile vectorilor, studiate în laboratorul anterior, sunt valabile și în cazul șirurilor. De asemenea, toate operațiile pe care le putem face cu vectori sunt posibile și în cazul șirurilor.

<div class="regula"> ''' Observație: ''' Există anumite operații asociate exclusiv șirurilor, precum căutarea unor caractere sau a unui șir într-un alt șir, concatenarea, etc. Toate aceste operații au funcții predefinite, care pot fi găsite într-un header specific, string.h. </div>

=== Aflarea lungimii unui șir de caractere ===
Pe lângă metoda clasică, discutată în capitolul anterior, ce presupune parcurgerea șirului și numărarea elementelor acestuia, avem și o metodă proprie șirurilor. Ea presupune apelarea funcției strlen(), predefinita în biblioteca string.h, care va întoarce numărul de elemente al șirului.
<div class="regula"> ''' Observație: ''' Caracterul '\0' marchează sfârșitul șirului, iar acolo se oprește numărarea.
</div>
Sintaxa generala:
<syntaxhighlight lang="C">
lungime_sir = strlen (sir_de_caractere);
</syntaxhighlight>

=== Citirea unui șir de caractere ===
Există mai multe variante pentru a citi un șir de caractere, unele asemănătoare vectorilor, altele specifice șirurilor de caractere.

1. Citirea șirului caracter cu caracter, până la întâlnirea caracterului cu codul ASCII 10 (newline - \n), moment în care se scrie caracterul de sfârșit de șir (null terminator - \0):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
int i;
for (i = 0; i < MAX_SIZE; i++) {
scanf ("%c", &sir_de_caractere[i]);
/* 10 este codul ascii pentru \n, adica enter */
if (sir_de_caractere[i] == 10) {
sir_de_caractere[i] = '\0';
break;
}
}
</syntaxhighlight>

2. Se folosește <code>scanf</code> cu template-ul <code>%s</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul caracter alb - spațiu, tab sau newline):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%s", sir_de_caractere);
</syntaxhighlight>

3. Se folosește <code>scanf</code> cu template-ul <code>%[^\n]</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul newline pe care nu îl va consuma din stream - acesta va trebui eliminat manual cu apel de <code>getchar()</code>):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%[^\n]", sir_de_caractere);
getchar();
</syntaxhighlight>

4. Se folosește <code>fgets</code> (atenție, acestă funcție va citi maxim MAX_SIZE - 1 caractere de la tastatură, sau până la întâlnirea lui \n, în care situație caracterul \n va fi adăugat în șir):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
fgets(sir_de_caractere, MAX_SIZE, stdin);
</syntaxhighlight>

=== Afișarea unui șir de caractere ===
Analog citirii unui șir de caractere, afișarea se poate face și ea în mai multe moduri, după cum urmează:

1. Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf("%s",sir_de_caractere); // citire sir de caractere

int i;
for (i = 0; i < MAX_SIZE && sir_de_caractere [i] != '\0'; i++) {
printf ("%c", sir_de_caractere [i]);
}
</syntaxhighlight>

2. Sintaxa generala
<syntaxhighlight lang="C">
printf ("%s", sir_de_caractere);
</syntaxhighlight>
3. Sintaxa generala:
<syntaxhighlight lang="C">
puts(sir_de_caractere);
</syntaxhighlight>

'''Exemplu''': Fie șirul de caractere sir[10]. Citiți următoarea frază folosind toate cele 3 metode, apoi afișați conținutul șirului folosind puts();. Ce observați? Explicați.

=== Căutarea unui caracter într-un șir de caractere ===
Funcția folosită: strchr();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE], char caracterul_cautat;
int pozitie;
pozitie = strchr(sir_de_caractere, caracterul_cautat) - sir_de_caractere;
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Funcția strchr NU oferă toate pozițiile pe care se află caracterul_căutat, ci doar prima poziție.
*Pentru a afla ultima poziție pe care se află un caracter căutat, se va folosi funcția strrchr(), sintaxa fiind identică.
*Pentru a caută un șir de caractere într-un alt șir de caractere, se va folosi funcția strstr(), sintaxa fiind aceeași.
</div>

=== Copierea unui șir de caractere în altul ===
Funcția folosită: strcpy ();
Sintaxa:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcpy(destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' șirul sursă se copiază în șirul destinație. Dacă lungimea șirului destinație este mai mică decât a șirului sursă, atunci copierea se face cu erori. Trebuie deci să punem următoarea condiție:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen(sursa);
</syntaxhighlight>
</div>

=== Concatenarea unor șiruri de caractere ===
Funcția folosită: srtcat();
Sintaxa generala:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcat(destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Concatenarea se face adăugând șirul sursă la șirul destinație. Este deci necesar ca șirul sursă să "încăpă" în șirul destinație. Matematic, asta se traduce astfel:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen(sursa) + strlen(destinatie);
</syntaxhighlight>
</div>

=== Compararea a doua șiruri de caractere ===
Funcția folosită: strcmp();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir1 [MAX_SIZE1], sir2 [MAX_SIZE2];
int rezultat;
rezultat = strcmp (sir1, sir2);
</syntaxhighlight>
Funcția strcmp(); întoarce următoarele valori:
* -1 dacă sir1 este înainte din punct de vedere alfabetic;
* 0 dacă cele două șiruri sunt identice;
* +1 dacă sir2 este înainte din punct de vedere alfabetic.

=== Inserția unui șir de caractere într-un alt șir ===
Pentru această operație nu există o funcție specializată în biblioteca string.h. Ceea ce vom face va fi să folosim procedee învățate la vectori, cât și funcții menționate anterior. Etapele sunt următoarele:
* declarăm cele două șiruri;
* verificăm dacă șirul ce urmează să fie introdus încape în șirul inițial;
* găsim poziția unde dorim să adăugăm șirul ce urmează să fie introdus;
* începând cu acea poziție, mutăm toate caracterele la dreaptă cu un număr de poziții egal cu lungimea șirului ce urmează să fie introdus;
* pe pozițiile rămase "goale" introducem șirul nou.
'''Exemplu:'''
Transformați fraza "Studentul a picat examenul final." în "Studentul nu a picat examenul final."
Date necesare: sir_inițial[50] = "Sudentul a picat examenul final.", sir_nou[3] = "nu ".

== Observații și exemple==

=== strlen vs sizeof ===

<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "StringLab";
int len,size;

len = strlen(str1);
size = sizeof(str1);
printf("Lungimea str1: %d\n", len);
printf("Lungimea total alocata str1: %d\n", size);

return 0;
}

</syntaxhighlight>

=== strchr vs strrchr ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[40] = "Cautare de caracter printre caractere";
printf ("Caz1: %s\n", strchr(str1, 'a'));
printf ("Caz2: %s\n", strrchr(str1, 'a'));
printf ("Caz3: %s\n", strstr(str1, "de"));

return 0;
}
</syntaxhighlight>

=== Exemple operații cu șiruri===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>

int main () {

char str1[10] = "Hello";
char str2[10] = "String Lab";
char str3[10];
int len ;

/* copiaza str1 in str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );

/* concateneaza str1 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );

/* lungimea str1 dupa concatenare */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );

return 0;
}

</syntaxhighlight>

=== Model de concatenare fără a utiliza strcat ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(){

char str1[10], str2[10], str3[20];
int i, poz;
printf("Introduceti sir1: ");
scanf("%s",str1);
printf("Introduceti sir2: ");
scanf("%s",str2);

for (i = 0; i < strlen(str1); i++)
str3[i] = str1[i];
poz=i;
for (i = 0; i < strlen(str2); i++)
str3[poz+i] = str2[i];
str3[poz+i] ='\0';

printf("Sir concatenat: %s\n",str3);

return 0;
}
</syntaxhighlight>

=== Exemple fgets & puts ===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>
int main(){
char nume[30];
printf("Numele este: ");
/* Citește string de la utilizator */
fgets(nume, 30, stdin);
printf("Nume: ");
/* Afișează string */
puts(nume);
return 0;
}
</syntaxhighlight>

== Exerciții ==

#Să se scrie un program care citește de la tastatură un cuvânt.Să se afișeze cuvintele ce se obțin prin eliminarea succesiva a primei si ultimei litere din cuvântul citit.
#Să se scrie un program care șterge toate caracterele dintr-o linie citită de la tastatură cu excepția literelor.
#Să se scrie un program care afișează pe ecran frecvența de apariție a unui caracter citit de la tastatură.
#Se citeşte de la tastatură o propoziţie (şir de caractere) terminată cu punct.Să se afişeze fiecare cuvânt din propoziţie pe câte o linie separată.

PC Laborator 8

2016-11-23T20:34:32Z

Lflueratoru: /* Copierea unui șir de caractere în altul */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
*înțeleagă cum funcționează șirurile de caractere
*facă operații cu șiruri de caractere

== Șiruri de caractere ==

[[Fișier:ascii_table.jpg|thumb]]

În C, tipul de dată șir nu există în mod implicit. Singurul mod prin care putem opera cu șiruri este folosind tablourile unidimensionale, vectorii. Ne amintim că un vector este definit complet prin intermediul a trei caracteristici: tipul de date conținute, numele vectorului și numărul său de elemente. Așadar, putem declara un vector al cărui tip de data să fie char, caz în care acel vector va fi denumit șir (de caractere).
Declararea unui șir de caractere se face astfel:
<syntaxhighlight lang="C">
char numele_sirului [numarul_de_caractere];
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Spre deosebire de vectorii studiați în laboratorul anterior, ale căror elemente sunt precizate explicit, șirurile au un caracter special, implicit, numit end of string și reprezentat astfel: \0.
</div>

== Operații cu șiruri ==

Toate proprietățile vectorilor, studiate în laboratorul anterior, sunt valabile și în cazul șirurilor. De asemenea, toate operațiile pe care le putem face cu vectori sunt posibile și în cazul șirurilor.

<div class="regula"> ''' Observație: ''' Există anumite operații asociate exclusiv șirurilor, precum căutarea unor caractere sau a unui șir într-un alt șir, concatenarea, etc. Toate aceste operații au funcții predefinite, care pot fi găsite într-un header specific, string.h. </div>

=== Aflarea lungimii unui șir de caractere ===
Pe lângă metoda clasică, discutată în capitolul anterior, ce presupune parcurgerea șirului și numărarea elementelor acestuia, avem și o metodă proprie șirurilor. Ea presupune apelarea funcției strlen(), predefinita în biblioteca string.h, care va întoarce numărul de elemente al șirului.
<div class="regula"> ''' Observație: ''' Caracterul '\0' marchează sfârșitul șirului, iar acolo se oprește numărarea.
</div>
Sintaxa generala:
<syntaxhighlight lang="C">
lungime_sir = strlen (sir_de_caractere);
</syntaxhighlight>

=== Citirea unui șir de caractere ===
Există mai multe variante pentru a citi un șir de caractere, unele asemănătoare vectorilor, altele specifice șirurilor de caractere.

1. Citirea șirului caracter cu caracter, până la întâlnirea caracterului cu codul ASCII 10 (newline - \n), moment în care se scrie caracterul de sfârșit de șir (null terminator - \0):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
int i;
for (i = 0; i < MAX_SIZE; i++) {
scanf ("%c", &sir_de_caractere[i]);
/* 10 este codul ascii pentru \n, adica enter */
if (sir_de_caractere[i] == 10) {
sir_de_caractere[i] = '\0';
break;
}
}
</syntaxhighlight>

2. Se folosește <code>scanf</code> cu template-ul <code>%s</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul caracter alb - spațiu, tab sau newline):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%s", sir_de_caractere);
</syntaxhighlight>

3. Se folosește <code>scanf</code> cu template-ul <code>%[^\n]</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul newline pe care nu îl va consuma din stream - acesta va trebui eliminat manual cu apel de <code>getchar()</code>):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%[^\n]", sir_de_caractere);
getchar();
</syntaxhighlight>

4. Se folosește <code>fgets</code> (atenție, acestă funcție va citi maxim MAX_SIZE - 1 caractere de la tastatură, sau până la întâlnirea lui \n, în care situație caracterul \n va fi adăugat în șir):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
fgets(sir_de_caractere, MAX_SIZE, stdin);
</syntaxhighlight>

=== Afișarea unui șir de caractere ===
Analog citirii unui șir de caractere, afișarea se poate face și ea în mai multe moduri, după cum urmează:

1. Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf("%s",sir_de_caractere); // citire sir de caractere

int i;
for (i = 0; i < MAX_SIZE && sir_de_caractere [i] != '\0'; i++) {
printf ("%c", sir_de_caractere [i]);
}
</syntaxhighlight>

2. Sintaxa generala
<syntaxhighlight lang="C">
printf ("%s", sir_de_caractere);
</syntaxhighlight>
3. Sintaxa generala:
<syntaxhighlight lang="C">
puts(sir_de_caractere);
</syntaxhighlight>

'''Exemplu''': Fie șirul de caractere sir[10]. Citiți următoarea frază folosind toate cele 3 metode, apoi afișați conținutul șirului folosind puts();. Ce observați? Explicați.

=== Căutarea unui caracter într-un șir de caractere ===
Funcția folosită: strchr();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE], char caracterul_cautat;
int pozitie;
pozitie = strchr(sir_de_caractere, caracterul_cautat) - sir_de_caractere;
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Funcția strchr NU oferă toate pozițiile pe care se află caracterul_căutat, ci doar prima poziție.
*Pentru a afla ultima poziție pe care se află un caracter căutat, se va folosi funcția strrchr(), sintaxa fiind identică.
*Pentru a caută un șir de caractere într-un alt șir de caractere, se va folosi funcția strstr(), sintaxa fiind aceeași.
</div>

=== Copierea unui șir de caractere în altul ===
Funcția folosită: strcpy ();
Sintaxa:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcpy(destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' șirul sursă se copiază în șirul destinație. Dacă lungimea șirului destinație este mai mică decât a șirului sursă, atunci copierea se face cu erori. Trebuie deci să punem următoarea condiție:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen(sursa);
</syntaxhighlight>
</div>

=== Concatenarea unor șiruri de caractere ===
Funcția folosită: srtcat();
Sintaxa generala:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcat (destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Concatenarea se face adăugând șirul sursă la șirul destinație. Este deci necesar ca șirul sursă să "încăpă" în șirul destinație. Matematic, asta se traduce astfel:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen (sursa) + strlen (destinatie);
</syntaxhighlight>
</div>

=== Compararea a doua șiruri de caractere ===
Funcția folosită: strcmp();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir1 [MAX_SIZE1], sir2 [MAX_SIZE2];
int rezultat;
rezultat = strcmp (sir1, sir2);
</syntaxhighlight>
Funcția strcmp(); întoarce următoarele valori:
* -1 dacă sir1 este înainte din punct de vedere alfabetic;
* 0 dacă cele două șiruri sunt identice;
* +1 dacă sir2 este înainte din punct de vedere alfabetic.

=== Inserția unui șir de caractere într-un alt șir ===
Pentru această operație nu există o funcție specializată în biblioteca string.h. Ceea ce vom face va fi să folosim procedee învățate la vectori, cât și funcții menționate anterior. Etapele sunt următoarele:
* declarăm cele două șiruri;
* verificăm dacă șirul ce urmează să fie introdus încape în șirul inițial;
* găsim poziția unde dorim să adăugăm șirul ce urmează să fie introdus;
* începând cu acea poziție, mutăm toate caracterele la dreaptă cu un număr de poziții egal cu lungimea șirului ce urmează să fie introdus;
* pe pozițiile rămase "goale" introducem șirul nou.
'''Exemplu:'''
Transformați fraza "Studentul a picat examenul final." în "Studentul nu a picat examenul final."
Date necesare: sir_inițial[50] = "Sudentul a picat examenul final.", sir_nou[3] = "nu ".

== Observații și exemple==

=== strlen vs sizeof ===

<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "StringLab";
int len,size;

len = strlen(str1);
size = sizeof(str1);
printf("Lungimea str1: %d\n", len);
printf("Lungimea total alocata str1: %d\n", size);

return 0;
}

</syntaxhighlight>

=== strchr vs strrchr ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[40] = "Cautare de caracter printre caractere";
printf ("Caz1: %s\n", strchr(str1, 'a'));
printf ("Caz2: %s\n", strrchr(str1, 'a'));
printf ("Caz3: %s\n", strstr(str1, "de"));

return 0;
}
</syntaxhighlight>

=== Exemple operații cu șiruri===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>

int main () {

char str1[10] = "Hello";
char str2[10] = "String Lab";
char str3[10];
int len ;

/* copiaza str1 in str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );

/* concateneaza str1 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );

/* lungimea str1 dupa concatenare */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );

return 0;
}

</syntaxhighlight>

=== Model de concatenare fără a utiliza strcat ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(){

char str1[10], str2[10], str3[20];
int i, poz;
printf("Introduceti sir1: ");
scanf("%s",str1);
printf("Introduceti sir2: ");
scanf("%s",str2);

for (i = 0; i < strlen(str1); i++)
str3[i] = str1[i];
poz=i;
for (i = 0; i < strlen(str2); i++)
str3[poz+i] = str2[i];
str3[poz+i] ='\0';

printf("Sir concatenat: %s\n",str3);

return 0;
}
</syntaxhighlight>

=== Exemple fgets & puts ===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>
int main(){
char nume[30];
printf("Numele este: ");
/* Citește string de la utilizator */
fgets(nume, 30, stdin);
printf("Nume: ");
/* Afișează string */
puts(nume);
return 0;
}
</syntaxhighlight>

== Exerciții ==

#Să se scrie un program care citește de la tastatură un cuvânt.Să se afișeze cuvintele ce se obțin prin eliminarea succesiva a primei si ultimei litere din cuvântul citit.
#Să se scrie un program care șterge toate caracterele dintr-o linie citită de la tastatură cu excepția literelor.
#Să se scrie un program care afișează pe ecran frecvența de apariție a unui caracter citit de la tastatură.
#Se citeşte de la tastatură o propoziţie (şir de caractere) terminată cu punct.Să se afişeze fiecare cuvânt din propoziţie pe câte o linie separată.

PC Laborator 8

2016-11-23T20:34:16Z

Lflueratoru: /* Copierea unui șir de caractere în altul */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
*înțeleagă cum funcționează șirurile de caractere
*facă operații cu șiruri de caractere

== Șiruri de caractere ==

[[Fișier:ascii_table.jpg|thumb]]

În C, tipul de dată șir nu există în mod implicit. Singurul mod prin care putem opera cu șiruri este folosind tablourile unidimensionale, vectorii. Ne amintim că un vector este definit complet prin intermediul a trei caracteristici: tipul de date conținute, numele vectorului și numărul său de elemente. Așadar, putem declara un vector al cărui tip de data să fie char, caz în care acel vector va fi denumit șir (de caractere).
Declararea unui șir de caractere se face astfel:
<syntaxhighlight lang="C">
char numele_sirului [numarul_de_caractere];
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Spre deosebire de vectorii studiați în laboratorul anterior, ale căror elemente sunt precizate explicit, șirurile au un caracter special, implicit, numit end of string și reprezentat astfel: \0.
</div>

== Operații cu șiruri ==

Toate proprietățile vectorilor, studiate în laboratorul anterior, sunt valabile și în cazul șirurilor. De asemenea, toate operațiile pe care le putem face cu vectori sunt posibile și în cazul șirurilor.

<div class="regula"> ''' Observație: ''' Există anumite operații asociate exclusiv șirurilor, precum căutarea unor caractere sau a unui șir într-un alt șir, concatenarea, etc. Toate aceste operații au funcții predefinite, care pot fi găsite într-un header specific, string.h. </div>

=== Aflarea lungimii unui șir de caractere ===
Pe lângă metoda clasică, discutată în capitolul anterior, ce presupune parcurgerea șirului și numărarea elementelor acestuia, avem și o metodă proprie șirurilor. Ea presupune apelarea funcției strlen(), predefinita în biblioteca string.h, care va întoarce numărul de elemente al șirului.
<div class="regula"> ''' Observație: ''' Caracterul '\0' marchează sfârșitul șirului, iar acolo se oprește numărarea.
</div>
Sintaxa generala:
<syntaxhighlight lang="C">
lungime_sir = strlen (sir_de_caractere);
</syntaxhighlight>

=== Citirea unui șir de caractere ===
Există mai multe variante pentru a citi un șir de caractere, unele asemănătoare vectorilor, altele specifice șirurilor de caractere.

1. Citirea șirului caracter cu caracter, până la întâlnirea caracterului cu codul ASCII 10 (newline - \n), moment în care se scrie caracterul de sfârșit de șir (null terminator - \0):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
int i;
for (i = 0; i < MAX_SIZE; i++) {
scanf ("%c", &sir_de_caractere[i]);
/* 10 este codul ascii pentru \n, adica enter */
if (sir_de_caractere[i] == 10) {
sir_de_caractere[i] = '\0';
break;
}
}
</syntaxhighlight>

2. Se folosește <code>scanf</code> cu template-ul <code>%s</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul caracter alb - spațiu, tab sau newline):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%s", sir_de_caractere);
</syntaxhighlight>

3. Se folosește <code>scanf</code> cu template-ul <code>%[^\n]</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul newline pe care nu îl va consuma din stream - acesta va trebui eliminat manual cu apel de <code>getchar()</code>):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%[^\n]", sir_de_caractere);
getchar();
</syntaxhighlight>

4. Se folosește <code>fgets</code> (atenție, acestă funcție va citi maxim MAX_SIZE - 1 caractere de la tastatură, sau până la întâlnirea lui \n, în care situație caracterul \n va fi adăugat în șir):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
fgets(sir_de_caractere, MAX_SIZE, stdin);
</syntaxhighlight>

=== Afișarea unui șir de caractere ===
Analog citirii unui șir de caractere, afișarea se poate face și ea în mai multe moduri, după cum urmează:

1. Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf("%s",sir_de_caractere); // citire sir de caractere

int i;
for (i = 0; i < MAX_SIZE && sir_de_caractere [i] != '\0'; i++) {
printf ("%c", sir_de_caractere [i]);
}
</syntaxhighlight>

2. Sintaxa generala
<syntaxhighlight lang="C">
printf ("%s", sir_de_caractere);
</syntaxhighlight>
3. Sintaxa generala:
<syntaxhighlight lang="C">
puts(sir_de_caractere);
</syntaxhighlight>

'''Exemplu''': Fie șirul de caractere sir[10]. Citiți următoarea frază folosind toate cele 3 metode, apoi afișați conținutul șirului folosind puts();. Ce observați? Explicați.

=== Căutarea unui caracter într-un șir de caractere ===
Funcția folosită: strchr();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE], char caracterul_cautat;
int pozitie;
pozitie = strchr(sir_de_caractere, caracterul_cautat) - sir_de_caractere;
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Funcția strchr NU oferă toate pozițiile pe care se află caracterul_căutat, ci doar prima poziție.
*Pentru a afla ultima poziție pe care se află un caracter căutat, se va folosi funcția strrchr(), sintaxa fiind identică.
*Pentru a caută un șir de caractere într-un alt șir de caractere, se va folosi funcția strstr(), sintaxa fiind aceeași.
</div>

=== Copierea unui șir de caractere în altul ===
Funcția folosită: strcpy ();
Sintaxa:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcpy(destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' șirul sursă se copiază în șirul destinație. Dacă lungimea șirului destinație este mai mică decât a șirului sursă, atunci copierea se face cu erori. Trebuie deci să punem următoarea condiție:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen (sursa);
</syntaxhighlight>
</div>

=== Concatenarea unor șiruri de caractere ===
Funcția folosită: srtcat();
Sintaxa generala:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcat (destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Concatenarea se face adăugând șirul sursă la șirul destinație. Este deci necesar ca șirul sursă să "încăpă" în șirul destinație. Matematic, asta se traduce astfel:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen (sursa) + strlen (destinatie);
</syntaxhighlight>
</div>

=== Compararea a doua șiruri de caractere ===
Funcția folosită: strcmp();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir1 [MAX_SIZE1], sir2 [MAX_SIZE2];
int rezultat;
rezultat = strcmp (sir1, sir2);
</syntaxhighlight>
Funcția strcmp(); întoarce următoarele valori:
* -1 dacă sir1 este înainte din punct de vedere alfabetic;
* 0 dacă cele două șiruri sunt identice;
* +1 dacă sir2 este înainte din punct de vedere alfabetic.

=== Inserția unui șir de caractere într-un alt șir ===
Pentru această operație nu există o funcție specializată în biblioteca string.h. Ceea ce vom face va fi să folosim procedee învățate la vectori, cât și funcții menționate anterior. Etapele sunt următoarele:
* declarăm cele două șiruri;
* verificăm dacă șirul ce urmează să fie introdus încape în șirul inițial;
* găsim poziția unde dorim să adăugăm șirul ce urmează să fie introdus;
* începând cu acea poziție, mutăm toate caracterele la dreaptă cu un număr de poziții egal cu lungimea șirului ce urmează să fie introdus;
* pe pozițiile rămase "goale" introducem șirul nou.
'''Exemplu:'''
Transformați fraza "Studentul a picat examenul final." în "Studentul nu a picat examenul final."
Date necesare: sir_inițial[50] = "Sudentul a picat examenul final.", sir_nou[3] = "nu ".

== Observații și exemple==

=== strlen vs sizeof ===

<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "StringLab";
int len,size;

len = strlen(str1);
size = sizeof(str1);
printf("Lungimea str1: %d\n", len);
printf("Lungimea total alocata str1: %d\n", size);

return 0;
}

</syntaxhighlight>

=== strchr vs strrchr ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[40] = "Cautare de caracter printre caractere";
printf ("Caz1: %s\n", strchr(str1, 'a'));
printf ("Caz2: %s\n", strrchr(str1, 'a'));
printf ("Caz3: %s\n", strstr(str1, "de"));

return 0;
}
</syntaxhighlight>

=== Exemple operații cu șiruri===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>

int main () {

char str1[10] = "Hello";
char str2[10] = "String Lab";
char str3[10];
int len ;

/* copiaza str1 in str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );

/* concateneaza str1 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );

/* lungimea str1 dupa concatenare */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );

return 0;
}

</syntaxhighlight>

=== Model de concatenare fără a utiliza strcat ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(){

char str1[10], str2[10], str3[20];
int i, poz;
printf("Introduceti sir1: ");
scanf("%s",str1);
printf("Introduceti sir2: ");
scanf("%s",str2);

for (i = 0; i < strlen(str1); i++)
str3[i] = str1[i];
poz=i;
for (i = 0; i < strlen(str2); i++)
str3[poz+i] = str2[i];
str3[poz+i] ='\0';

printf("Sir concatenat: %s\n",str3);

return 0;
}
</syntaxhighlight>

=== Exemple fgets & puts ===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>
int main(){
char nume[30];
printf("Numele este: ");
/* Citește string de la utilizator */
fgets(nume, 30, stdin);
printf("Nume: ");
/* Afișează string */
puts(nume);
return 0;
}
</syntaxhighlight>

== Exerciții ==

#Să se scrie un program care citește de la tastatură un cuvânt.Să se afișeze cuvintele ce se obțin prin eliminarea succesiva a primei si ultimei litere din cuvântul citit.
#Să se scrie un program care șterge toate caracterele dintr-o linie citită de la tastatură cu excepția literelor.
#Să se scrie un program care afișează pe ecran frecvența de apariție a unui caracter citit de la tastatură.
#Se citeşte de la tastatură o propoziţie (şir de caractere) terminată cu punct.Să se afişeze fiecare cuvânt din propoziţie pe câte o linie separată.

PC Laborator 8

2016-11-23T20:34:00Z

Lflueratoru: /* Căutarea unui caracter într-un șir de caractere */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
*înțeleagă cum funcționează șirurile de caractere
*facă operații cu șiruri de caractere

== Șiruri de caractere ==

[[Fișier:ascii_table.jpg|thumb]]

În C, tipul de dată șir nu există în mod implicit. Singurul mod prin care putem opera cu șiruri este folosind tablourile unidimensionale, vectorii. Ne amintim că un vector este definit complet prin intermediul a trei caracteristici: tipul de date conținute, numele vectorului și numărul său de elemente. Așadar, putem declara un vector al cărui tip de data să fie char, caz în care acel vector va fi denumit șir (de caractere).
Declararea unui șir de caractere se face astfel:
<syntaxhighlight lang="C">
char numele_sirului [numarul_de_caractere];
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Spre deosebire de vectorii studiați în laboratorul anterior, ale căror elemente sunt precizate explicit, șirurile au un caracter special, implicit, numit end of string și reprezentat astfel: \0.
</div>

== Operații cu șiruri ==

Toate proprietățile vectorilor, studiate în laboratorul anterior, sunt valabile și în cazul șirurilor. De asemenea, toate operațiile pe care le putem face cu vectori sunt posibile și în cazul șirurilor.

<div class="regula"> ''' Observație: ''' Există anumite operații asociate exclusiv șirurilor, precum căutarea unor caractere sau a unui șir într-un alt șir, concatenarea, etc. Toate aceste operații au funcții predefinite, care pot fi găsite într-un header specific, string.h. </div>

=== Aflarea lungimii unui șir de caractere ===
Pe lângă metoda clasică, discutată în capitolul anterior, ce presupune parcurgerea șirului și numărarea elementelor acestuia, avem și o metodă proprie șirurilor. Ea presupune apelarea funcției strlen(), predefinita în biblioteca string.h, care va întoarce numărul de elemente al șirului.
<div class="regula"> ''' Observație: ''' Caracterul '\0' marchează sfârșitul șirului, iar acolo se oprește numărarea.
</div>
Sintaxa generala:
<syntaxhighlight lang="C">
lungime_sir = strlen (sir_de_caractere);
</syntaxhighlight>

=== Citirea unui șir de caractere ===
Există mai multe variante pentru a citi un șir de caractere, unele asemănătoare vectorilor, altele specifice șirurilor de caractere.

1. Citirea șirului caracter cu caracter, până la întâlnirea caracterului cu codul ASCII 10 (newline - \n), moment în care se scrie caracterul de sfârșit de șir (null terminator - \0):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
int i;
for (i = 0; i < MAX_SIZE; i++) {
scanf ("%c", &sir_de_caractere[i]);
/* 10 este codul ascii pentru \n, adica enter */
if (sir_de_caractere[i] == 10) {
sir_de_caractere[i] = '\0';
break;
}
}
</syntaxhighlight>

2. Se folosește <code>scanf</code> cu template-ul <code>%s</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul caracter alb - spațiu, tab sau newline):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%s", sir_de_caractere);
</syntaxhighlight>

3. Se folosește <code>scanf</code> cu template-ul <code>%[^\n]</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul newline pe care nu îl va consuma din stream - acesta va trebui eliminat manual cu apel de <code>getchar()</code>):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%[^\n]", sir_de_caractere);
getchar();
</syntaxhighlight>

4. Se folosește <code>fgets</code> (atenție, acestă funcție va citi maxim MAX_SIZE - 1 caractere de la tastatură, sau până la întâlnirea lui \n, în care situație caracterul \n va fi adăugat în șir):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
fgets(sir_de_caractere, MAX_SIZE, stdin);
</syntaxhighlight>

=== Afișarea unui șir de caractere ===
Analog citirii unui șir de caractere, afișarea se poate face și ea în mai multe moduri, după cum urmează:

1. Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf("%s",sir_de_caractere); // citire sir de caractere

int i;
for (i = 0; i < MAX_SIZE && sir_de_caractere [i] != '\0'; i++) {
printf ("%c", sir_de_caractere [i]);
}
</syntaxhighlight>

2. Sintaxa generala
<syntaxhighlight lang="C">
printf ("%s", sir_de_caractere);
</syntaxhighlight>
3. Sintaxa generala:
<syntaxhighlight lang="C">
puts(sir_de_caractere);
</syntaxhighlight>

'''Exemplu''': Fie șirul de caractere sir[10]. Citiți următoarea frază folosind toate cele 3 metode, apoi afișați conținutul șirului folosind puts();. Ce observați? Explicați.

=== Căutarea unui caracter într-un șir de caractere ===
Funcția folosită: strchr();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE], char caracterul_cautat;
int pozitie;
pozitie = strchr(sir_de_caractere, caracterul_cautat) - sir_de_caractere;
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Funcția strchr NU oferă toate pozițiile pe care se află caracterul_căutat, ci doar prima poziție.
*Pentru a afla ultima poziție pe care se află un caracter căutat, se va folosi funcția strrchr(), sintaxa fiind identică.
*Pentru a caută un șir de caractere într-un alt șir de caractere, se va folosi funcția strstr(), sintaxa fiind aceeași.
</div>

=== Copierea unui șir de caractere în altul ===
Funcția folosită: strcpy ();
Sintaxa:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcpy (destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' șirul sursă se copiază în șirul destinație. Dacă lungimea șirului destinație este mai mică decât a șirului sursă, atunci copierea se face cu erori. Trebuie deci să punem următoarea condiție:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen (sursa);
</syntaxhighlight>
</div>

=== Concatenarea unor șiruri de caractere ===
Funcția folosită: srtcat();
Sintaxa generala:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcat (destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Concatenarea se face adăugând șirul sursă la șirul destinație. Este deci necesar ca șirul sursă să "încăpă" în șirul destinație. Matematic, asta se traduce astfel:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen (sursa) + strlen (destinatie);
</syntaxhighlight>
</div>

=== Compararea a doua șiruri de caractere ===
Funcția folosită: strcmp();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir1 [MAX_SIZE1], sir2 [MAX_SIZE2];
int rezultat;
rezultat = strcmp (sir1, sir2);
</syntaxhighlight>
Funcția strcmp(); întoarce următoarele valori:
* -1 dacă sir1 este înainte din punct de vedere alfabetic;
* 0 dacă cele două șiruri sunt identice;
* +1 dacă sir2 este înainte din punct de vedere alfabetic.

=== Inserția unui șir de caractere într-un alt șir ===
Pentru această operație nu există o funcție specializată în biblioteca string.h. Ceea ce vom face va fi să folosim procedee învățate la vectori, cât și funcții menționate anterior. Etapele sunt următoarele:
* declarăm cele două șiruri;
* verificăm dacă șirul ce urmează să fie introdus încape în șirul inițial;
* găsim poziția unde dorim să adăugăm șirul ce urmează să fie introdus;
* începând cu acea poziție, mutăm toate caracterele la dreaptă cu un număr de poziții egal cu lungimea șirului ce urmează să fie introdus;
* pe pozițiile rămase "goale" introducem șirul nou.
'''Exemplu:'''
Transformați fraza "Studentul a picat examenul final." în "Studentul nu a picat examenul final."
Date necesare: sir_inițial[50] = "Sudentul a picat examenul final.", sir_nou[3] = "nu ".

== Observații și exemple==

=== strlen vs sizeof ===

<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "StringLab";
int len,size;

len = strlen(str1);
size = sizeof(str1);
printf("Lungimea str1: %d\n", len);
printf("Lungimea total alocata str1: %d\n", size);

return 0;
}

</syntaxhighlight>

=== strchr vs strrchr ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[40] = "Cautare de caracter printre caractere";
printf ("Caz1: %s\n", strchr(str1, 'a'));
printf ("Caz2: %s\n", strrchr(str1, 'a'));
printf ("Caz3: %s\n", strstr(str1, "de"));

return 0;
}
</syntaxhighlight>

=== Exemple operații cu șiruri===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>

int main () {

char str1[10] = "Hello";
char str2[10] = "String Lab";
char str3[10];
int len ;

/* copiaza str1 in str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );

/* concateneaza str1 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );

/* lungimea str1 dupa concatenare */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );

return 0;
}

</syntaxhighlight>

=== Model de concatenare fără a utiliza strcat ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(){

char str1[10], str2[10], str3[20];
int i, poz;
printf("Introduceti sir1: ");
scanf("%s",str1);
printf("Introduceti sir2: ");
scanf("%s",str2);

for (i = 0; i < strlen(str1); i++)
str3[i] = str1[i];
poz=i;
for (i = 0; i < strlen(str2); i++)
str3[poz+i] = str2[i];
str3[poz+i] ='\0';

printf("Sir concatenat: %s\n",str3);

return 0;
}
</syntaxhighlight>

=== Exemple fgets & puts ===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>
int main(){
char nume[30];
printf("Numele este: ");
/* Citește string de la utilizator */
fgets(nume, 30, stdin);
printf("Nume: ");
/* Afișează string */
puts(nume);
return 0;
}
</syntaxhighlight>

== Exerciții ==

#Să se scrie un program care citește de la tastatură un cuvânt.Să se afișeze cuvintele ce se obțin prin eliminarea succesiva a primei si ultimei litere din cuvântul citit.
#Să se scrie un program care șterge toate caracterele dintr-o linie citită de la tastatură cu excepția literelor.
#Să se scrie un program care afișează pe ecran frecvența de apariție a unui caracter citit de la tastatură.
#Se citeşte de la tastatură o propoziţie (şir de caractere) terminată cu punct.Să se afişeze fiecare cuvânt din propoziţie pe câte o linie separată.

PC Laborator 8

2016-11-23T20:33:22Z

Lflueratoru: /* Concatenarea unor șiruri de caractere */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
*înțeleagă cum funcționează șirurile de caractere
*facă operații cu șiruri de caractere

== Șiruri de caractere ==

[[Fișier:ascii_table.jpg|thumb]]

În C, tipul de dată șir nu există în mod implicit. Singurul mod prin care putem opera cu șiruri este folosind tablourile unidimensionale, vectorii. Ne amintim că un vector este definit complet prin intermediul a trei caracteristici: tipul de date conținute, numele vectorului și numărul său de elemente. Așadar, putem declara un vector al cărui tip de data să fie char, caz în care acel vector va fi denumit șir (de caractere).
Declararea unui șir de caractere se face astfel:
<syntaxhighlight lang="C">
char numele_sirului [numarul_de_caractere];
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Spre deosebire de vectorii studiați în laboratorul anterior, ale căror elemente sunt precizate explicit, șirurile au un caracter special, implicit, numit end of string și reprezentat astfel: \0.
</div>

== Operații cu șiruri ==

Toate proprietățile vectorilor, studiate în laboratorul anterior, sunt valabile și în cazul șirurilor. De asemenea, toate operațiile pe care le putem face cu vectori sunt posibile și în cazul șirurilor.

<div class="regula"> ''' Observație: ''' Există anumite operații asociate exclusiv șirurilor, precum căutarea unor caractere sau a unui șir într-un alt șir, concatenarea, etc. Toate aceste operații au funcții predefinite, care pot fi găsite într-un header specific, string.h. </div>

=== Aflarea lungimii unui șir de caractere ===
Pe lângă metoda clasică, discutată în capitolul anterior, ce presupune parcurgerea șirului și numărarea elementelor acestuia, avem și o metodă proprie șirurilor. Ea presupune apelarea funcției strlen(), predefinita în biblioteca string.h, care va întoarce numărul de elemente al șirului.
<div class="regula"> ''' Observație: ''' Caracterul '\0' marchează sfârșitul șirului, iar acolo se oprește numărarea.
</div>
Sintaxa generala:
<syntaxhighlight lang="C">
lungime_sir = strlen (sir_de_caractere);
</syntaxhighlight>

=== Citirea unui șir de caractere ===
Există mai multe variante pentru a citi un șir de caractere, unele asemănătoare vectorilor, altele specifice șirurilor de caractere.

1. Citirea șirului caracter cu caracter, până la întâlnirea caracterului cu codul ASCII 10 (newline - \n), moment în care se scrie caracterul de sfârșit de șir (null terminator - \0):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
int i;
for (i = 0; i < MAX_SIZE; i++) {
scanf ("%c", &sir_de_caractere[i]);
/* 10 este codul ascii pentru \n, adica enter */
if (sir_de_caractere[i] == 10) {
sir_de_caractere[i] = '\0';
break;
}
}
</syntaxhighlight>

2. Se folosește <code>scanf</code> cu template-ul <code>%s</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul caracter alb - spațiu, tab sau newline):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%s", sir_de_caractere);
</syntaxhighlight>

3. Se folosește <code>scanf</code> cu template-ul <code>%[^\n]</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul newline pe care nu îl va consuma din stream - acesta va trebui eliminat manual cu apel de <code>getchar()</code>):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%[^\n]", sir_de_caractere);
getchar();
</syntaxhighlight>

4. Se folosește <code>fgets</code> (atenție, acestă funcție va citi maxim MAX_SIZE - 1 caractere de la tastatură, sau până la întâlnirea lui \n, în care situație caracterul \n va fi adăugat în șir):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
fgets(sir_de_caractere, MAX_SIZE, stdin);
</syntaxhighlight>

=== Afișarea unui șir de caractere ===
Analog citirii unui șir de caractere, afișarea se poate face și ea în mai multe moduri, după cum urmează:

1. Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf("%s",sir_de_caractere); // citire sir de caractere

int i;
for (i = 0; i < MAX_SIZE && sir_de_caractere [i] != '\0'; i++) {
printf ("%c", sir_de_caractere [i]);
}
</syntaxhighlight>

2. Sintaxa generala
<syntaxhighlight lang="C">
printf ("%s", sir_de_caractere);
</syntaxhighlight>
3. Sintaxa generala:
<syntaxhighlight lang="C">
puts(sir_de_caractere);
</syntaxhighlight>

'''Exemplu''': Fie șirul de caractere sir[10]. Citiți următoarea frază folosind toate cele 3 metode, apoi afișați conținutul șirului folosind puts();. Ce observați? Explicați.

=== Căutarea unui caracter într-un șir de caractere ===
Funcția folosită: strchr();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE], char caracterul_cautat;
int pozitie;
pozitie = strchr (sir_de_caractere, caracterul_cautat) - sir_de_caractere;
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Funcția strchr NU oferă toate pozițiile pe care se află caracterul_căutat, ci doar prima poziție.
*Pentru a afla ultima poziție pe care se află un caracter căutat, se va folosi funcția strrchr(), sintaxa fiind identică.
*Pentru a caută un șir de caractere într-un alt șir de caractere, se va folosi funcția strstr(), sintaxa fiind aceeași.
</div>

=== Copierea unui șir de caractere în altul ===
Funcția folosită: strcpy ();
Sintaxa:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcpy (destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' șirul sursă se copiază în șirul destinație. Dacă lungimea șirului destinație este mai mică decât a șirului sursă, atunci copierea se face cu erori. Trebuie deci să punem următoarea condiție:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen (sursa);
</syntaxhighlight>
</div>

=== Concatenarea unor șiruri de caractere ===
Funcția folosită: srtcat();
Sintaxa generala:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcat (destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Concatenarea se face adăugând șirul sursă la șirul destinație. Este deci necesar ca șirul sursă să "încăpă" în șirul destinație. Matematic, asta se traduce astfel:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen (sursa) + strlen (destinatie);
</syntaxhighlight>
</div>

=== Compararea a doua șiruri de caractere ===
Funcția folosită: strcmp();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir1 [MAX_SIZE1], sir2 [MAX_SIZE2];
int rezultat;
rezultat = strcmp (sir1, sir2);
</syntaxhighlight>
Funcția strcmp(); întoarce următoarele valori:
* -1 dacă sir1 este înainte din punct de vedere alfabetic;
* 0 dacă cele două șiruri sunt identice;
* +1 dacă sir2 este înainte din punct de vedere alfabetic.

=== Inserția unui șir de caractere într-un alt șir ===
Pentru această operație nu există o funcție specializată în biblioteca string.h. Ceea ce vom face va fi să folosim procedee învățate la vectori, cât și funcții menționate anterior. Etapele sunt următoarele:
* declarăm cele două șiruri;
* verificăm dacă șirul ce urmează să fie introdus încape în șirul inițial;
* găsim poziția unde dorim să adăugăm șirul ce urmează să fie introdus;
* începând cu acea poziție, mutăm toate caracterele la dreaptă cu un număr de poziții egal cu lungimea șirului ce urmează să fie introdus;
* pe pozițiile rămase "goale" introducem șirul nou.
'''Exemplu:'''
Transformați fraza "Studentul a picat examenul final." în "Studentul nu a picat examenul final."
Date necesare: sir_inițial[50] = "Sudentul a picat examenul final.", sir_nou[3] = "nu ".

== Observații și exemple==

=== strlen vs sizeof ===

<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "StringLab";
int len,size;

len = strlen(str1);
size = sizeof(str1);
printf("Lungimea str1: %d\n", len);
printf("Lungimea total alocata str1: %d\n", size);

return 0;
}

</syntaxhighlight>

=== strchr vs strrchr ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[40] = "Cautare de caracter printre caractere";
printf ("Caz1: %s\n", strchr(str1, 'a'));
printf ("Caz2: %s\n", strrchr(str1, 'a'));
printf ("Caz3: %s\n", strstr(str1, "de"));

return 0;
}
</syntaxhighlight>

=== Exemple operații cu șiruri===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>

int main () {

char str1[10] = "Hello";
char str2[10] = "String Lab";
char str3[10];
int len ;

/* copiaza str1 in str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );

/* concateneaza str1 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );

/* lungimea str1 dupa concatenare */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );

return 0;
}

</syntaxhighlight>

=== Model de concatenare fără a utiliza strcat ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(){

char str1[10], str2[10], str3[20];
int i, poz;
printf("Introduceti sir1: ");
scanf("%s",str1);
printf("Introduceti sir2: ");
scanf("%s",str2);

for (i = 0; i < strlen(str1); i++)
str3[i] = str1[i];
poz=i;
for (i = 0; i < strlen(str2); i++)
str3[poz+i] = str2[i];
str3[poz+i] ='\0';

printf("Sir concatenat: %s\n",str3);

return 0;
}
</syntaxhighlight>

=== Exemple fgets & puts ===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>
int main(){
char nume[30];
printf("Numele este: ");
/* Citește string de la utilizator */
fgets(nume, 30, stdin);
printf("Nume: ");
/* Afișează string */
puts(nume);
return 0;
}
</syntaxhighlight>

== Exerciții ==

#Să se scrie un program care citește de la tastatură un cuvânt.Să se afișeze cuvintele ce se obțin prin eliminarea succesiva a primei si ultimei litere din cuvântul citit.
#Să se scrie un program care șterge toate caracterele dintr-o linie citită de la tastatură cu excepția literelor.
#Să se scrie un program care afișează pe ecran frecvența de apariție a unui caracter citit de la tastatură.
#Se citeşte de la tastatură o propoziţie (şir de caractere) terminată cu punct.Să se afişeze fiecare cuvânt din propoziţie pe câte o linie separată.

PC Laborator 8

2016-11-23T18:08:49Z

Lflueratoru: /* Citirea unui șir de caractere */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
*înțeleagă cum funcționează șirurile de caractere
*facă operații cu șiruri de caractere

== Șiruri de caractere ==

[[Fișier:ascii_table.jpg|thumb]]

În C, tipul de dată șir nu există în mod implicit. Singurul mod prin care putem opera cu șiruri este folosind tablourile unidimensionale, vectorii. Ne amintim că un vector este definit complet prin intermediul a trei caracteristici: tipul de date conținute, numele vectorului și numărul său de elemente. Așadar, putem declara un vector al cărui tip de data să fie char, caz în care acel vector va fi denumit șir (de caractere).
Declararea unui șir de caractere se face astfel:
<syntaxhighlight lang="C">
char numele_sirului [numarul_de_caractere];
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Spre deosebire de vectorii studiați în laboratorul anterior, ale căror elemente sunt precizate explicit, șirurile au un caracter special, implicit, numit end of string și reprezentat astfel: \0.
</div>

== Operații cu șiruri ==

Toate proprietățile vectorilor, studiate în laboratorul anterior, sunt valabile și în cazul șirurilor. De asemenea, toate operațiile pe care le putem face cu vectori sunt posibile și în cazul șirurilor.

<div class="regula"> ''' Observație: ''' Există anumite operații asociate exclusiv șirurilor, precum căutarea unor caractere sau a unui șir într-un alt șir, concatenarea, etc. Toate aceste operații au funcții predefinite, care pot fi găsite într-un header specific, string.h. </div>

=== Aflarea lungimii unui șir de caractere ===
Pe lângă metoda clasică, discutată în capitolul anterior, ce presupune parcurgerea șirului și numărarea elementelor acestuia, avem și o metodă proprie șirurilor. Ea presupune apelarea funcției strlen(), predefinita în biblioteca string.h, care va întoarce numărul de elemente al șirului.
<div class="regula"> ''' Observație: ''' Caracterul '\0' marchează sfârșitul șirului, iar acolo se oprește numărarea.
</div>
Sintaxa generala:
<syntaxhighlight lang="C">
lungime_sir = strlen (sir_de_caractere);
</syntaxhighlight>

=== Citirea unui șir de caractere ===
Există mai multe variante pentru a citi un șir de caractere, unele asemănătoare vectorilor, altele specifice șirurilor de caractere.

1. Citirea șirului caracter cu caracter, până la întâlnirea caracterului cu codul ASCII 10 (newline - \n), moment în care se scrie caracterul de sfârșit de șir (null terminator - \0):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
int i;
for (i = 0; i < MAX_SIZE; i++) {
scanf ("%c", &sir_de_caractere[i]);
/* 10 este codul ascii pentru \n, adica enter */
if (sir_de_caractere[i] == 10) {
sir_de_caractere[i] = '\0';
break;
}
}
</syntaxhighlight>

2. Se folosește <code>scanf</code> cu template-ul <code>%s</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul caracter alb - spațiu, tab sau newline):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%s", sir_de_caractere);
</syntaxhighlight>

3. Se folosește <code>scanf</code> cu template-ul <code>%[^\n]</code> (atenție, acest <code>scanf</code> va citi exclusiv până la primul newline pe care nu îl va consuma din stream - acesta va trebui eliminat manual cu apel de <code>getchar()</code>):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf ("%[^\n]", sir_de_caractere);
getchar();
</syntaxhighlight>

4. Se folosește <code>fgets</code> (atenție, acestă funcție va citi maxim MAX_SIZE - 1 caractere de la tastatură, sau până la întâlnirea lui \n, în care situație caracterul \n va fi adăugat în șir):
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
fgets(sir_de_caractere, MAX_SIZE, stdin);
</syntaxhighlight>

=== Afișarea unui șir de caractere ===
Analog citirii unui șir de caractere, afișarea se poate face și ea în mai multe moduri, după cum urmează:

1. Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE];
scanf("%s",sir_de_caractere); // citire sir de caractere

int i;
for (i = 0; i < MAX_SIZE && sir_de_caractere [i] != '\0'; i++) {
printf ("%c", sir_de_caractere [i]);
}
</syntaxhighlight>

2. Sintaxa generala
<syntaxhighlight lang="C">
printf ("%s", sir_de_caractere);
</syntaxhighlight>
3. Sintaxa generala:
<syntaxhighlight lang="C">
puts(sir_de_caractere);
</syntaxhighlight>

'''Exemplu''': Fie șirul de caractere sir[10]. Citiți următoarea frază folosind toate cele 3 metode, apoi afișați conținutul șirului folosind puts();. Ce observați? Explicați.

=== Căutarea unui caracter într-un șir de caractere ===
Funcția folosită: strchr();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir_de_caractere[MAX_SIZE], char caracterul_cautat;
int pozitie;
pozitie = strchr (sir_de_caractere, caracterul_cautat) - sir_de_caractere;
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' Funcția strchr NU oferă toate pozițiile pe care se află caracterul_căutat, ci doar prima poziție.
*Pentru a afla ultima poziție pe care se află un caracter căutat, se va folosi funcția strrchr(), sintaxa fiind identică.
*Pentru a caută un șir de caractere într-un alt șir de caractere, se va folosi funcția strstr(), sintaxa fiind aceeași.
</div>

=== Copierea unui șir de caractere în altul ===
Funcția folosită: strcpy ();
Sintaxa:
<syntaxhighlight lang="C">
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcpy (destinatie, sursa);
</syntaxhighlight>
<div class="regula"> ''' Observație: ''' șirul sursă se copiază în șirul destinație. Dacă lungimea șirului destinație este mai mică decât a șirului sursă, atunci copierea se face cu erori. Trebuie deci să punem următoarea condiție:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen (sursa);
</syntaxhighlight>
</div>

=== Concatenarea unor șiruri de caractere ===
Funcția folosită: srtcat();
Sintaxa generala:
char destinatie[MAX_SIZE1], sursa[MAX_SIZE2];
strcat (destinatie, sursa);
<div class="regula"> ''' Observație: ''' Concatenarea se face adăugând șirul sursă la șirul destinație. Este deci necesar ca șirul sursă să "încăpă" în șirul destinație. Matematic, asta se traduce astfel:
<syntaxhighlight lang="C">
MAX_SIZE1 >= strlen (sursa) + strlen (destinatie);
</syntaxhighlight>
</div>

=== Compararea a doua șiruri de caractere ===
Funcția folosită: strcmp();
Sintaxa generala:
<syntaxhighlight lang="C">
char sir1 [MAX_SIZE1], sir2 [MAX_SIZE2];
int rezultat;
rezultat = strcmp (sir1, sir2);
</syntaxhighlight>
Funcția strcmp(); întoarce următoarele valori:
* -1 dacă sir1 este înainte din punct de vedere alfabetic;
* 0 dacă cele două șiruri sunt identice;
* +1 dacă sir2 este înainte din punct de vedere alfabetic.

=== Inserția unui șir de caractere într-un alt șir ===
Pentru această operație nu există o funcție specializată în biblioteca string.h. Ceea ce vom face va fi să folosim procedee învățate la vectori, cât și funcții menționate anterior. Etapele sunt următoarele:
* declarăm cele două șiruri;
* verificăm dacă șirul ce urmează să fie introdus încape în șirul inițial;
* găsim poziția unde dorim să adăugăm șirul ce urmează să fie introdus;
* începând cu acea poziție, mutăm toate caracterele la dreaptă cu un număr de poziții egal cu lungimea șirului ce urmează să fie introdus;
* pe pozițiile rămase "goale" introducem șirul nou.
'''Exemplu:'''
Transformați fraza "Studentul a picat examenul final." în "Studentul nu a picat examenul final."
Date necesare: sir_inițial[50] = "Sudentul a picat examenul final.", sir_nou[3] = "nu ".

== Observații și exemple==

=== strlen vs sizeof ===

<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "StringLab";
int len,size;

len = strlen(str1);
size = sizeof(str1);
printf("Lungimea str1: %d\n", len);
printf("Lungimea total alocata str1: %d\n", size);

return 0;
}

</syntaxhighlight>

=== strchr vs strrchr ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>
int main()
{
char str1[40] = "Cautare de caracter printre caractere";
printf ("Caz1: %s\n", strchr(str1, 'a'));
printf ("Caz2: %s\n", strrchr(str1, 'a'));
printf ("Caz3: %s\n", strstr(str1, "de"));

return 0;
}
</syntaxhighlight>

=== Exemple operații cu șiruri===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>

int main () {

char str1[10] = "Hello";
char str2[10] = "String Lab";
char str3[10];
int len ;

/* copiaza str1 in str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );

/* concateneaza str1 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );

/* lungimea str1 dupa concatenare */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );

return 0;
}

</syntaxhighlight>

=== Model de concatenare fără a utiliza strcat ===
<syntaxhighlight lang="C">
#include <stdio.h>
#include <string.h>

int main(){

char str1[10], str2[10], str3[20];
int i, poz;
printf("Introduceti sir1: ");
scanf("%s",str1);
printf("Introduceti sir2: ");
scanf("%s",str2);

for (i = 0; i < strlen(str1); i++)
str3[i] = str1[i];
poz=i;
for (i = 0; i < strlen(str2); i++)
str3[poz+i] = str2[i];
str3[poz+i] ='\0';

printf("Sir concatenat: %s\n",str3);

return 0;
}
</syntaxhighlight>

=== Exemple fgets & puts ===
<syntaxhighlight lang="C">

#include <stdio.h>
#include <string.h>
int main(){
char nume[30];
printf("Numele este: ");
/* Citește string de la utilizator */
fgets(nume, 30, stdin);
printf("Nume: ");
/* Afișează string */
puts(nume);
return 0;
}
</syntaxhighlight>

== Exerciții ==

#Să se scrie un program care citește de la tastatură un cuvânt.Să se afișeze cuvintele ce se obțin prin eliminarea succesiva a primei si ultimei litere din cuvântul citit.
#Să se scrie un program care șterge toate caracterele dintr-o linie citită de la tastatură cu excepția literelor.
#Să se scrie un program care afișează pe ecran frecvența de apariție a unui caracter citit de la tastatură.
#Se citeşte de la tastatură o propoziţie (şir de caractere) terminată cu punct.Să se afişeze fiecare cuvânt din propoziţie pe câte o linie separată.

PC Laborator 7

2016-11-16T16:32:22Z

Lflueratoru: /* Citirea matricilor */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil:
*să înteleagă modul de utilizare a tablourilor de memorie
*să declare şi să iniţializeze vectori/matrici
*să implementeze algoritmi simpli în lucru cu vectori pentru rezolvarea diverselor probleme

== Tablouri ==
Tabloul de memorie este o colecţie de date stocate în locaţii succesive din memorie. Toate elementele acestuia au acelaşi tip de dată numit de obicei tip de bază.
Tablourile pot fi :

*vectori (tablouri unidimensionale): șiruri de valori
*matrici (tablouri bidimensionale): catalogul cu note
*multidimensionale: pixelii unei imagini în timp

=== Vectori ===

Un vector reprezintă o colecție de date de acelaşi tip reprezentate sub forma unei linii.

====Declarația unei variabile de tip vector====

<syntaxhighlight lang="C">
<tip_elemente> <nume_vector>[<număr_maxim_elemente>];
</syntaxhighlight>

=====Exemplu=====

<syntaxhighlight lang="C">
int v[10]; /* astfel se alocă 10 locații de memorie consecutive de tip int, ce vor corespunde valorilor vectorului v */
float nume_vector[100]; /* vector de tip float cu 100 elemente */
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Vectorii declarați astfel sunt denumiți statici (static arrays) deoarece numărul de elemente şi spaţiul de memorie ocupat sunt constante în timpul compilării (număr_maxim_elemente fiind o constantă).''
</div>

<syntaxhighlight lang="C">
#define MAX 100
...
unsigned long nume_vector[MAX]
</syntaxhighlight>

<div class="regula">'''<font color="red"> Recomandare: </font>''' ''Numărătoarea elementelor începe de la 0.'' </div>
<syntaxhighlight lang="C"> int v[10]; // primul element va fi v[0],iar ultimul element v[9] </syntaxhighlight>
Vectorii se pot iniţializa cu valori constante, în acest caz, compilatorul va determina dimensiunea vectorului din numărul elementelor din listă.

'''Un alt mod de declarare este:'''

<syntaxhighlight lang="C">
int v[10] = {1, 5, 6, 8, 6, 10, 22, 32, 34, 13}; // Toate elemente sunt initializate
float nume_vector[] = {1.2, 2.2, 6.1, -9.3}; // Compilatorul determina dimensiunea vectorului = 4
int vect[1000] = {0, 1, 2, 3, 5}; // Sunt initializate doar primele 5 elemente,restul fiind completate automat cu zero
</syntaxhighlight>

==== Parcurgerea vectorilor ====

Cum deja am discutat, prima poziție dintr-un vector este v[0]. Presupunem un vector are N elemente, constatăm că ultimul element este v[N-1]. A trece prin elementele vectorului presupune parcurgerea tuturor celor N elemente , de la V[0] la V[N-1]. Acest lucru este posibil prin:
<syntaxhighlight lang="C">
for (i = 0; i < N; i++)
// instrucțiune v[i];
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Se poate ingnora poziția zero,însă daca avem un vector de 100 elemente declararea uzuală ar fi int v[100];, gândim valorile de la v[0] la v[99]. Daca folosim numărarea de la 1, vom avea doar 99 de locații de memorie disponibile pentru cele 100 de valori. În acest caz declararea corecta ar fi int v[101];.''</div>

==== Modul de adresare ====

{| class="wikitable"
! Indici
! 0
! 1
! 2
! 3
|-
| colspan="5" |
|-
| Valoare
| 12
| 33
| 120
| 460
|}
<syntaxhighlight lang="C">
printf("%d", v); // v stochează adresa primul element
printf("%d", v[1]); // reprezintă valoarea din a 2a locație de memorie a vectoritului v adică 33
</syntaxhighlight>

==== Citirea vectorilor ====

<syntaxhighlight lang="C">
int v[100], n, i; // vectorul a are maxim 100 de intregi

scanf("%d", &n); // citeste nr de elemente

for (i = 0; i < n; i++) {
scanf("%d", &v[i]); // citire elemente
}

for (i = 0; i < n; i++) {
printf("%d ", v[i]); // scrie elemente
}
</syntaxhighlight>

=== Matrici ===

O matrice reprezintă o colecție de date de acelaşi tip, ce este structurată pe linii şi coloane.
Datele sunt identificate prin indicele liniei şi respectiv indicele coloanei.
<div class="regula">'''<font color="red"> Observatie:</font>''' '' Un vector este un caz particular de matrice cu o singură linie.'' </div>

==== Declarația unei matrici ====

<syntaxhighlight lang="C">
<tip_elemente> <nume_matrice>[<număr_linii>][<număr_coloane>];
</syntaxhighlight>

==== Exemplul 1 ====

<syntaxhighlight lang="C">

int matrice[5][10]; // o matrice de întregi cu 5 linii și 10 coloane care ocupă 5 * 10 * 4 = 200 octeți

#define MAX 100
float a[MAX][MAX]; // în acest caz număr linii = număr coloane = 100

</syntaxhighlight>

==== Parcurgerea matricilor ====

<syntaxhighlight lang="C">
int mat[N][M];

for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
// instrucțiune mat[i][j];
}
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Accesarea elementului de pe linia i şi coloana j se face cu mat[i][j];''</div>

==== Adresarea matricilor ====

Adresarea este similară cu cea a vectorilor, doar că în acest caz lucrăm cu două dimensiuni (2D)-matrici.

<syntaxhighlight lang="C">

printf("%d", mat[1][3]) // reprezintă valorea de pe linia 1 și coloana 3 a matricii mat
printf("%d", &mat[1][3]) // reprezintă adresa de memorie a elementului de pe linia 1 și coloana 3 a matricii mat

</syntaxhighlight>

==== Citirea matricilor ====

<syntaxhighlight lang="C">

int mat[10][10];
int i, j;

for (i = 0; i < 10; i++)
for (j = 0; j < 10; j++) {
printf("v[%d][%d] = ", i, j);
scanf("%d", &mat[i][j]);
}
</syntaxhighlight>

=== Tablouri multidimensionale ===

Noţiunea generală de tablou cu mai multe dimensiuni se declară astfel:
<syntaxhighlight lang="C">

<tip_elemente> <nume_tablou>[<dim_1>][<dim_2>]...[<dim_n>];

</syntaxhighlight>

==== Exemplu ====

<syntaxhighlight lang="C">
int cub[3][3][3];
</syntaxhighlight>

În acest caz 3 dimensiuni pot avea un sens fizic,însă tablourile cu mai mult de 3 dimensiuni pot să nu mai aibă un sens clar, ușor perceptibil.

== Exerciții ==

<ol>
<li>Fie v un vector cu N valori intregi. Să se numere cate valori sunt pare/impare.</li>
<li>Să se insereze un nou element z in pozitia k, restul elementelor rămânând în aceeași ordine.</li>
<li>Se citesc 2 vectori de maxim 100 elemente întregi, apoi determina și afișează intersecția celor 2 vectori.</li>
<li>Declarați și afișați o matrice unitate.</li>
<li>Să se scrie un program care citește de la tastatură o matrice de M întregi. Să se asigure că utilizatorul introduce valori doar între 0 și 9 și să se afișeze sub forma unui vector pe ecran elementele de deasupra diagonalei principale.</li>
<li>Se se scrie un program ce permite citirea matrici A si B reale de dimensiune MxN. Să se calculeze matricea produs C și să se stocheze toate elementele matricii mai mari ca x într-un vector v. Să se afiseze vectorul.</li>
<li>Scrieti un program care citeşte de la tastatură un număr natural, n (2≤n≤20), şi construieşte în memorie tabloul bidimensional cu n linii şi n coloane, având proprietătile:
<ul>
<li>toate elementele situate pe diagonala principală sunt nule;</li>
<li>fiecare linie contine, începând cu diagonala principală, de la dreapta la stânga, un şir strict crescător de numere consecutive, iar începând cu diagonala principală, de la stânga la dreapta, tot un şir strict crescător de numere consecutive.</li></ul></li>
Programul afişează pe ecran tabloul construit, fiecare linie a tabloului pe
câte o linie a ecranului, cu elementele aflate pe aceeaşi linie separate prin
câte un spatiu.
Exemplu: dacă n=5 se afişează pe ecran tabloul alăturat.
<syntaxhighlight lang="C">
0 1 2 3 4
1 0 1 2 3
2 1 0 1 2
3 2 1 0 1
4 3 2 1 0
</syntaxhighlight>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se înlocuiască toate vocalele cu caracterul _ și să se afiseze cuvântul obținut.</li>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se determine dacă este sau nu palindrom.</li>
</ol>

== Exerciții pentru acasă==

# Se consideră o matrice de dimenisiune NxM,numere intregi. Să se determine linia (liniile) cu cele mai multe elemente nenule.
# Se consideră o matrice A de NxN elemente, cu componentele numere întregi. Să se calculeze:
#* suma elementelor de pe diagonala principală
#* produsul elmentelor de pe diagonala secundară
#* minimul elementelor aflate deasupra, respectiv sub diagonala principală
# Se consideră o matrice de NxM elemente, cu componentele numere întregi. Se cere să se calculeze suma elementelor de pe marginea matricii.
# Să se construiască o matrice cu n linii şi m coloane care conţine pe prima coloană, de sus în jos, toate numerele naturale de la 1 la n, în ordine crescătoare, pe coloana a doua, de sus în jos, toate numerele naturale de la 2 la n+1, în ordine crescătoare, pe a treia coloană, de sus în jos, toate numerele naturale de la 3 la n+2, în ordine crescătoare, pe a patra coloană, de sus în jos, toate numerele naturale de la 4 la n+3, în ordine crescătoare şi aşa mai departe până la coloana m. Scrieţi programul care citeşte de la tastatură două valori naturale n și m (2<n<25, 2<m<25), construieşte matricea conform cerinţei şi o afişează pe ecran, pe linii, cu spaţii între elementele de pe fiecare linie. De exemplu, dacă se citeşte de la tastatură n=3 și m=5, se va construi şi se va afişa pe ecran matricea:
<syntaxhighlight lang="C">
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
</syntaxhighlight>

PC Laborator 7

2016-11-16T16:31:13Z

Lflueratoru: /* Parcurgerea matricilor */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil:
*să înteleagă modul de utilizare a tablourilor de memorie
*să declare şi să iniţializeze vectori/matrici
*să implementeze algoritmi simpli în lucru cu vectori pentru rezolvarea diverselor probleme

== Tablouri ==
Tabloul de memorie este o colecţie de date stocate în locaţii succesive din memorie. Toate elementele acestuia au acelaşi tip de dată numit de obicei tip de bază.
Tablourile pot fi :

*vectori (tablouri unidimensionale): șiruri de valori
*matrici (tablouri bidimensionale): catalogul cu note
*multidimensionale: pixelii unei imagini în timp

=== Vectori ===

Un vector reprezintă o colecție de date de acelaşi tip reprezentate sub forma unei linii.

====Declarația unei variabile de tip vector====

<syntaxhighlight lang="C">
<tip_elemente> <nume_vector>[<număr_maxim_elemente>];
</syntaxhighlight>

=====Exemplu=====

<syntaxhighlight lang="C">
int v[10]; /* astfel se alocă 10 locații de memorie consecutive de tip int, ce vor corespunde valorilor vectorului v */
float nume_vector[100]; /* vector de tip float cu 100 elemente */
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Vectorii declarați astfel sunt denumiți statici (static arrays) deoarece numărul de elemente şi spaţiul de memorie ocupat sunt constante în timpul compilării (număr_maxim_elemente fiind o constantă).''
</div>

<syntaxhighlight lang="C">
#define MAX 100
...
unsigned long nume_vector[MAX]
</syntaxhighlight>

<div class="regula">'''<font color="red"> Recomandare: </font>''' ''Numărătoarea elementelor începe de la 0.'' </div>
<syntaxhighlight lang="C"> int v[10]; // primul element va fi v[0],iar ultimul element v[9] </syntaxhighlight>
Vectorii se pot iniţializa cu valori constante, în acest caz, compilatorul va determina dimensiunea vectorului din numărul elementelor din listă.

'''Un alt mod de declarare este:'''

<syntaxhighlight lang="C">
int v[10] = {1, 5, 6, 8, 6, 10, 22, 32, 34, 13}; // Toate elemente sunt initializate
float nume_vector[] = {1.2, 2.2, 6.1, -9.3}; // Compilatorul determina dimensiunea vectorului = 4
int vect[1000] = {0, 1, 2, 3, 5}; // Sunt initializate doar primele 5 elemente,restul fiind completate automat cu zero
</syntaxhighlight>

==== Parcurgerea vectorilor ====

Cum deja am discutat, prima poziție dintr-un vector este v[0]. Presupunem un vector are N elemente, constatăm că ultimul element este v[N-1]. A trece prin elementele vectorului presupune parcurgerea tuturor celor N elemente , de la V[0] la V[N-1]. Acest lucru este posibil prin:
<syntaxhighlight lang="C">
for (i = 0; i < N; i++)
// instrucțiune v[i];
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Se poate ingnora poziția zero,însă daca avem un vector de 100 elemente declararea uzuală ar fi int v[100];, gândim valorile de la v[0] la v[99]. Daca folosim numărarea de la 1, vom avea doar 99 de locații de memorie disponibile pentru cele 100 de valori. În acest caz declararea corecta ar fi int v[101];.''</div>

==== Modul de adresare ====

{| class="wikitable"
! Indici
! 0
! 1
! 2
! 3
|-
| colspan="5" |
|-
| Valoare
| 12
| 33
| 120
| 460
|}
<syntaxhighlight lang="C">
printf("%d", v); // v stochează adresa primul element
printf("%d", v[1]); // reprezintă valoarea din a 2a locație de memorie a vectoritului v adică 33
</syntaxhighlight>

==== Citirea vectorilor ====

<syntaxhighlight lang="C">
int v[100], n, i; // vectorul a are maxim 100 de intregi

scanf("%d", &n); // citeste nr de elemente

for (i = 0; i < n; i++) {
scanf("%d", &v[i]); // citire elemente
}

for (i = 0; i < n; i++) {
printf("%d ", v[i]); // scrie elemente
}
</syntaxhighlight>

=== Matrici ===

O matrice reprezintă o colecție de date de acelaşi tip, ce este structurată pe linii şi coloane.
Datele sunt identificate prin indicele liniei şi respectiv indicele coloanei.
<div class="regula">'''<font color="red"> Observatie:</font>''' '' Un vector este un caz particular de matrice cu o singură linie.'' </div>

==== Declarația unei matrici ====

<syntaxhighlight lang="C">
<tip_elemente> <nume_matrice>[<număr_linii>][<număr_coloane>];
</syntaxhighlight>

==== Exemplul 1 ====

<syntaxhighlight lang="C">

int matrice[5][10]; // o matrice de întregi cu 5 linii și 10 coloane care ocupă 5 * 10 * 4 = 200 octeți

#define MAX 100
float a[MAX][MAX]; // în acest caz număr linii = număr coloane = 100

</syntaxhighlight>

==== Parcurgerea matricilor ====

<syntaxhighlight lang="C">
int mat[N][M];

for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
// instrucțiune mat[i][j];
}
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Accesarea elementului de pe linia i şi coloana j se face cu mat[i][j];''</div>

==== Adresarea matricilor ====

Adresarea este similară cu cea a vectorilor, doar că în acest caz lucrăm cu două dimensiuni (2D)-matrici.

<syntaxhighlight lang="C">

printf("%d", mat[1][3]) // reprezintă valorea de pe linia 1 și coloana 3 a matricii mat
printf("%d", &mat[1][3]) // reprezintă adresa de memorie a elementului de pe linia 1 și coloana 3 a matricii mat

</syntaxhighlight>

==== Citirea matricilor ====

<syntaxhighlight lang="C">

int mat[10][10], i, j;
for (i = 0; i < 10; i++)
for (j = 0; j < 10; j++) {
printf("v[%d][%d]=", i, j);
scanf("%d", &mat[i][j]);
}
</syntaxhighlight>

=== Tablouri multidimensionale ===

Noţiunea generală de tablou cu mai multe dimensiuni se declară astfel:
<syntaxhighlight lang="C">

<tip_elemente> <nume_tablou>[<dim_1>][<dim_2>]...[<dim_n>];

</syntaxhighlight>

==== Exemplu ====

<syntaxhighlight lang="C">
int cub[3][3][3];
</syntaxhighlight>

În acest caz 3 dimensiuni pot avea un sens fizic,însă tablourile cu mai mult de 3 dimensiuni pot să nu mai aibă un sens clar, ușor perceptibil.

== Exerciții ==

<ol>
<li>Fie v un vector cu N valori intregi. Să se numere cate valori sunt pare/impare.</li>
<li>Să se insereze un nou element z in pozitia k, restul elementelor rămânând în aceeași ordine.</li>
<li>Se citesc 2 vectori de maxim 100 elemente întregi, apoi determina și afișează intersecția celor 2 vectori.</li>
<li>Declarați și afișați o matrice unitate.</li>
<li>Să se scrie un program care citește de la tastatură o matrice de M întregi. Să se asigure că utilizatorul introduce valori doar între 0 și 9 și să se afișeze sub forma unui vector pe ecran elementele de deasupra diagonalei principale.</li>
<li>Se se scrie un program ce permite citirea matrici A si B reale de dimensiune MxN. Să se calculeze matricea produs C și să se stocheze toate elementele matricii mai mari ca x într-un vector v. Să se afiseze vectorul.</li>
<li>Scrieti un program care citeşte de la tastatură un număr natural, n (2≤n≤20), şi construieşte în memorie tabloul bidimensional cu n linii şi n coloane, având proprietătile:
<ul>
<li>toate elementele situate pe diagonala principală sunt nule;</li>
<li>fiecare linie contine, începând cu diagonala principală, de la dreapta la stânga, un şir strict crescător de numere consecutive, iar începând cu diagonala principală, de la stânga la dreapta, tot un şir strict crescător de numere consecutive.</li></ul></li>
Programul afişează pe ecran tabloul construit, fiecare linie a tabloului pe
câte o linie a ecranului, cu elementele aflate pe aceeaşi linie separate prin
câte un spatiu.
Exemplu: dacă n=5 se afişează pe ecran tabloul alăturat.
<syntaxhighlight lang="C">
0 1 2 3 4
1 0 1 2 3
2 1 0 1 2
3 2 1 0 1
4 3 2 1 0
</syntaxhighlight>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se înlocuiască toate vocalele cu caracterul _ și să se afiseze cuvântul obținut.</li>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se determine dacă este sau nu palindrom.</li>
</ol>

== Exerciții pentru acasă==

# Se consideră o matrice de dimenisiune NxM,numere intregi. Să se determine linia (liniile) cu cele mai multe elemente nenule.
# Se consideră o matrice A de NxN elemente, cu componentele numere întregi. Să se calculeze:
#* suma elementelor de pe diagonala principală
#* produsul elmentelor de pe diagonala secundară
#* minimul elementelor aflate deasupra, respectiv sub diagonala principală
# Se consideră o matrice de NxM elemente, cu componentele numere întregi. Se cere să se calculeze suma elementelor de pe marginea matricii.
# Să se construiască o matrice cu n linii şi m coloane care conţine pe prima coloană, de sus în jos, toate numerele naturale de la 1 la n, în ordine crescătoare, pe coloana a doua, de sus în jos, toate numerele naturale de la 2 la n+1, în ordine crescătoare, pe a treia coloană, de sus în jos, toate numerele naturale de la 3 la n+2, în ordine crescătoare, pe a patra coloană, de sus în jos, toate numerele naturale de la 4 la n+3, în ordine crescătoare şi aşa mai departe până la coloana m. Scrieţi programul care citeşte de la tastatură două valori naturale n și m (2<n<25, 2<m<25), construieşte matricea conform cerinţei şi o afişează pe ecran, pe linii, cu spaţii între elementele de pe fiecare linie. De exemplu, dacă se citeşte de la tastatură n=3 și m=5, se va construi şi se va afişa pe ecran matricea:
<syntaxhighlight lang="C">
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
</syntaxhighlight>

PC Laborator 7

2016-11-16T16:30:31Z

Lflueratoru: /* Citirea vectorilor */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil:
*să înteleagă modul de utilizare a tablourilor de memorie
*să declare şi să iniţializeze vectori/matrici
*să implementeze algoritmi simpli în lucru cu vectori pentru rezolvarea diverselor probleme

== Tablouri ==
Tabloul de memorie este o colecţie de date stocate în locaţii succesive din memorie. Toate elementele acestuia au acelaşi tip de dată numit de obicei tip de bază.
Tablourile pot fi :

*vectori (tablouri unidimensionale): șiruri de valori
*matrici (tablouri bidimensionale): catalogul cu note
*multidimensionale: pixelii unei imagini în timp

=== Vectori ===

Un vector reprezintă o colecție de date de acelaşi tip reprezentate sub forma unei linii.

====Declarația unei variabile de tip vector====

<syntaxhighlight lang="C">
<tip_elemente> <nume_vector>[<număr_maxim_elemente>];
</syntaxhighlight>

=====Exemplu=====

<syntaxhighlight lang="C">
int v[10]; /* astfel se alocă 10 locații de memorie consecutive de tip int, ce vor corespunde valorilor vectorului v */
float nume_vector[100]; /* vector de tip float cu 100 elemente */
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Vectorii declarați astfel sunt denumiți statici (static arrays) deoarece numărul de elemente şi spaţiul de memorie ocupat sunt constante în timpul compilării (număr_maxim_elemente fiind o constantă).''
</div>

<syntaxhighlight lang="C">
#define MAX 100
...
unsigned long nume_vector[MAX]
</syntaxhighlight>

<div class="regula">'''<font color="red"> Recomandare: </font>''' ''Numărătoarea elementelor începe de la 0.'' </div>
<syntaxhighlight lang="C"> int v[10]; // primul element va fi v[0],iar ultimul element v[9] </syntaxhighlight>
Vectorii se pot iniţializa cu valori constante, în acest caz, compilatorul va determina dimensiunea vectorului din numărul elementelor din listă.

'''Un alt mod de declarare este:'''

<syntaxhighlight lang="C">
int v[10] = {1, 5, 6, 8, 6, 10, 22, 32, 34, 13}; // Toate elemente sunt initializate
float nume_vector[] = {1.2, 2.2, 6.1, -9.3}; // Compilatorul determina dimensiunea vectorului = 4
int vect[1000] = {0, 1, 2, 3, 5}; // Sunt initializate doar primele 5 elemente,restul fiind completate automat cu zero
</syntaxhighlight>

==== Parcurgerea vectorilor ====

Cum deja am discutat, prima poziție dintr-un vector este v[0]. Presupunem un vector are N elemente, constatăm că ultimul element este v[N-1]. A trece prin elementele vectorului presupune parcurgerea tuturor celor N elemente , de la V[0] la V[N-1]. Acest lucru este posibil prin:
<syntaxhighlight lang="C">
for (i = 0; i < N; i++)
// instrucțiune v[i];
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Se poate ingnora poziția zero,însă daca avem un vector de 100 elemente declararea uzuală ar fi int v[100];, gândim valorile de la v[0] la v[99]. Daca folosim numărarea de la 1, vom avea doar 99 de locații de memorie disponibile pentru cele 100 de valori. În acest caz declararea corecta ar fi int v[101];.''</div>

==== Modul de adresare ====

{| class="wikitable"
! Indici
! 0
! 1
! 2
! 3
|-
| colspan="5" |
|-
| Valoare
| 12
| 33
| 120
| 460
|}
<syntaxhighlight lang="C">
printf("%d", v); // v stochează adresa primul element
printf("%d", v[1]); // reprezintă valoarea din a 2a locație de memorie a vectoritului v adică 33
</syntaxhighlight>

==== Citirea vectorilor ====

<syntaxhighlight lang="C">
int v[100], n, i; // vectorul a are maxim 100 de intregi

scanf("%d", &n); // citeste nr de elemente

for (i = 0; i < n; i++) {
scanf("%d", &v[i]); // citire elemente
}

for (i = 0; i < n; i++) {
printf("%d ", v[i]); // scrie elemente
}
</syntaxhighlight>

=== Matrici ===

O matrice reprezintă o colecție de date de acelaşi tip, ce este structurată pe linii şi coloane.
Datele sunt identificate prin indicele liniei şi respectiv indicele coloanei.
<div class="regula">'''<font color="red"> Observatie:</font>''' '' Un vector este un caz particular de matrice cu o singură linie.'' </div>

==== Declarația unei matrici ====

<syntaxhighlight lang="C">
<tip_elemente> <nume_matrice>[<număr_linii>][<număr_coloane>];
</syntaxhighlight>

==== Exemplul 1 ====

<syntaxhighlight lang="C">

int matrice[5][10]; // o matrice de întregi cu 5 linii și 10 coloane care ocupă 5 * 10 * 4 = 200 octeți

#define MAX 100
float a[MAX][MAX]; // în acest caz număr linii = număr coloane = 100

</syntaxhighlight>

==== Parcurgerea matricilor ====

<syntaxhighlight lang="C">
int mat[N][M];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
// instrucțiune mat[i][j];
}
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Accesarea elementului de pe linia i şi coloana j se face cu mat[i][j];''</div>

==== Adresarea matricilor ====

Adresarea este similară cu cea a vectorilor, doar că în acest caz lucrăm cu două dimensiuni (2D)-matrici.

<syntaxhighlight lang="C">

printf("%d", mat[1][3]) // reprezintă valorea de pe linia 1 și coloana 3 a matricii mat
printf("%d", &mat[1][3]) // reprezintă adresa de memorie a elementului de pe linia 1 și coloana 3 a matricii mat

</syntaxhighlight>

==== Citirea matricilor ====

<syntaxhighlight lang="C">

int mat[10][10], i, j;
for (i = 0; i < 10; i++)
for (j = 0; j < 10; j++) {
printf("v[%d][%d]=", i, j);
scanf("%d", &mat[i][j]);
}
</syntaxhighlight>

=== Tablouri multidimensionale ===

Noţiunea generală de tablou cu mai multe dimensiuni se declară astfel:
<syntaxhighlight lang="C">

<tip_elemente> <nume_tablou>[<dim_1>][<dim_2>]...[<dim_n>];

</syntaxhighlight>

==== Exemplu ====

<syntaxhighlight lang="C">
int cub[3][3][3];
</syntaxhighlight>

În acest caz 3 dimensiuni pot avea un sens fizic,însă tablourile cu mai mult de 3 dimensiuni pot să nu mai aibă un sens clar, ușor perceptibil.

== Exerciții ==

<ol>
<li>Fie v un vector cu N valori intregi. Să se numere cate valori sunt pare/impare.</li>
<li>Să se insereze un nou element z in pozitia k, restul elementelor rămânând în aceeași ordine.</li>
<li>Se citesc 2 vectori de maxim 100 elemente întregi, apoi determina și afișează intersecția celor 2 vectori.</li>
<li>Declarați și afișați o matrice unitate.</li>
<li>Să se scrie un program care citește de la tastatură o matrice de M întregi. Să se asigure că utilizatorul introduce valori doar între 0 și 9 și să se afișeze sub forma unui vector pe ecran elementele de deasupra diagonalei principale.</li>
<li>Se se scrie un program ce permite citirea matrici A si B reale de dimensiune MxN. Să se calculeze matricea produs C și să se stocheze toate elementele matricii mai mari ca x într-un vector v. Să se afiseze vectorul.</li>
<li>Scrieti un program care citeşte de la tastatură un număr natural, n (2≤n≤20), şi construieşte în memorie tabloul bidimensional cu n linii şi n coloane, având proprietătile:
<ul>
<li>toate elementele situate pe diagonala principală sunt nule;</li>
<li>fiecare linie contine, începând cu diagonala principală, de la dreapta la stânga, un şir strict crescător de numere consecutive, iar începând cu diagonala principală, de la stânga la dreapta, tot un şir strict crescător de numere consecutive.</li></ul></li>
Programul afişează pe ecran tabloul construit, fiecare linie a tabloului pe
câte o linie a ecranului, cu elementele aflate pe aceeaşi linie separate prin
câte un spatiu.
Exemplu: dacă n=5 se afişează pe ecran tabloul alăturat.
<syntaxhighlight lang="C">
0 1 2 3 4
1 0 1 2 3
2 1 0 1 2
3 2 1 0 1
4 3 2 1 0
</syntaxhighlight>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se înlocuiască toate vocalele cu caracterul _ și să se afiseze cuvântul obținut.</li>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se determine dacă este sau nu palindrom.</li>
</ol>

== Exerciții pentru acasă==

# Se consideră o matrice de dimenisiune NxM,numere intregi. Să se determine linia (liniile) cu cele mai multe elemente nenule.
# Se consideră o matrice A de NxN elemente, cu componentele numere întregi. Să se calculeze:
#* suma elementelor de pe diagonala principală
#* produsul elmentelor de pe diagonala secundară
#* minimul elementelor aflate deasupra, respectiv sub diagonala principală
# Se consideră o matrice de NxM elemente, cu componentele numere întregi. Se cere să se calculeze suma elementelor de pe marginea matricii.
# Să se construiască o matrice cu n linii şi m coloane care conţine pe prima coloană, de sus în jos, toate numerele naturale de la 1 la n, în ordine crescătoare, pe coloana a doua, de sus în jos, toate numerele naturale de la 2 la n+1, în ordine crescătoare, pe a treia coloană, de sus în jos, toate numerele naturale de la 3 la n+2, în ordine crescătoare, pe a patra coloană, de sus în jos, toate numerele naturale de la 4 la n+3, în ordine crescătoare şi aşa mai departe până la coloana m. Scrieţi programul care citeşte de la tastatură două valori naturale n și m (2<n<25, 2<m<25), construieşte matricea conform cerinţei şi o afişează pe ecran, pe linii, cu spaţii între elementele de pe fiecare linie. De exemplu, dacă se citeşte de la tastatură n=3 și m=5, se va construi şi se va afişa pe ecran matricea:
<syntaxhighlight lang="C">
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
</syntaxhighlight>

PC Laborator 7

2016-11-16T16:30:01Z

Lflueratoru: /* Tablouri */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil:
*să înteleagă modul de utilizare a tablourilor de memorie
*să declare şi să iniţializeze vectori/matrici
*să implementeze algoritmi simpli în lucru cu vectori pentru rezolvarea diverselor probleme

== Tablouri ==
Tabloul de memorie este o colecţie de date stocate în locaţii succesive din memorie. Toate elementele acestuia au acelaşi tip de dată numit de obicei tip de bază.
Tablourile pot fi :

*vectori (tablouri unidimensionale): șiruri de valori
*matrici (tablouri bidimensionale): catalogul cu note
*multidimensionale: pixelii unei imagini în timp

=== Vectori ===

Un vector reprezintă o colecție de date de acelaşi tip reprezentate sub forma unei linii.

====Declarația unei variabile de tip vector====

<syntaxhighlight lang="C">
<tip_elemente> <nume_vector>[<număr_maxim_elemente>];
</syntaxhighlight>

=====Exemplu=====

<syntaxhighlight lang="C">
int v[10]; /* astfel se alocă 10 locații de memorie consecutive de tip int, ce vor corespunde valorilor vectorului v */
float nume_vector[100]; /* vector de tip float cu 100 elemente */
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Vectorii declarați astfel sunt denumiți statici (static arrays) deoarece numărul de elemente şi spaţiul de memorie ocupat sunt constante în timpul compilării (număr_maxim_elemente fiind o constantă).''
</div>

<syntaxhighlight lang="C">
#define MAX 100
...
unsigned long nume_vector[MAX]
</syntaxhighlight>

<div class="regula">'''<font color="red"> Recomandare: </font>''' ''Numărătoarea elementelor începe de la 0.'' </div>
<syntaxhighlight lang="C"> int v[10]; // primul element va fi v[0],iar ultimul element v[9] </syntaxhighlight>
Vectorii se pot iniţializa cu valori constante, în acest caz, compilatorul va determina dimensiunea vectorului din numărul elementelor din listă.

'''Un alt mod de declarare este:'''

<syntaxhighlight lang="C">
int v[10] = {1, 5, 6, 8, 6, 10, 22, 32, 34, 13}; // Toate elemente sunt initializate
float nume_vector[] = {1.2, 2.2, 6.1, -9.3}; // Compilatorul determina dimensiunea vectorului = 4
int vect[1000] = {0, 1, 2, 3, 5}; // Sunt initializate doar primele 5 elemente,restul fiind completate automat cu zero
</syntaxhighlight>

==== Parcurgerea vectorilor ====

Cum deja am discutat, prima poziție dintr-un vector este v[0]. Presupunem un vector are N elemente, constatăm că ultimul element este v[N-1]. A trece prin elementele vectorului presupune parcurgerea tuturor celor N elemente , de la V[0] la V[N-1]. Acest lucru este posibil prin:
<syntaxhighlight lang="C">
for (i = 0; i < N; i++)
// instrucțiune v[i];
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Se poate ingnora poziția zero,însă daca avem un vector de 100 elemente declararea uzuală ar fi int v[100];, gândim valorile de la v[0] la v[99]. Daca folosim numărarea de la 1, vom avea doar 99 de locații de memorie disponibile pentru cele 100 de valori. În acest caz declararea corecta ar fi int v[101];.''</div>

==== Modul de adresare ====

{| class="wikitable"
! Indici
! 0
! 1
! 2
! 3
|-
| colspan="5" |
|-
| Valoare
| 12
| 33
| 120
| 460
|}
<syntaxhighlight lang="C">
printf("%d", v); // v stochează adresa primul element
printf("%d", v[1]); // reprezintă valoarea din a 2a locație de memorie a vectoritului v adică 33
</syntaxhighlight>

==== Citirea vectorilor ====

<syntaxhighlight lang="C">
int v[100], n, i; // vectorul a are maxim 100 de intregi

scanf("%d", &n); // citeste nr de elemente

for (i = 0; i < n; i++) {
scanf("%d", &v[i]); // citire elemente
}

for (i = 0; i < n; i++) {
printf("%d ", v[i]); // scrie elemente
}
</syntaxhighlight>

=== Matrici ===

O matrice reprezintă o colecție de date de acelaşi tip, ce este structurată pe linii şi coloane.
Datele sunt identificate prin indicele liniei şi respectiv indicele coloanei.
<div class="regula">'''<font color="red"> Observatie:</font>''' '' Un vector este un caz particular de matrice cu o singură linie.'' </div>

==== Declarația unei matrici ====

<syntaxhighlight lang="C">
<tip_elemente> <nume_matrice>[<număr_linii>][<număr_coloane>];
</syntaxhighlight>

==== Exemplul 1 ====

<syntaxhighlight lang="C">

int matrice[5][10]; // o matrice de întregi cu 5 linii și 10 coloane care ocupă 5 * 10 * 4 = 200 octeți

#define MAX 100
float a[MAX][MAX]; // în acest caz număr linii = număr coloane = 100

</syntaxhighlight>

==== Parcurgerea matricilor ====

<syntaxhighlight lang="C">
int mat[N][M];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
// instrucțiune mat[i][j];
}
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Accesarea elementului de pe linia i şi coloana j se face cu mat[i][j];''</div>

==== Adresarea matricilor ====

Adresarea este similară cu cea a vectorilor, doar că în acest caz lucrăm cu două dimensiuni (2D)-matrici.

<syntaxhighlight lang="C">

printf("%d", mat[1][3]) // reprezintă valorea de pe linia 1 și coloana 3 a matricii mat
printf("%d", &mat[1][3]) // reprezintă adresa de memorie a elementului de pe linia 1 și coloana 3 a matricii mat

</syntaxhighlight>

==== Citirea matricilor ====

<syntaxhighlight lang="C">

int mat[10][10], i, j;
for (i = 0; i < 10; i++)
for (j = 0; j < 10; j++) {
printf("v[%d][%d]=", i, j);
scanf("%d", &mat[i][j]);
}
</syntaxhighlight>

=== Tablouri multidimensionale ===

Noţiunea generală de tablou cu mai multe dimensiuni se declară astfel:
<syntaxhighlight lang="C">

<tip_elemente> <nume_tablou>[<dim_1>][<dim_2>]...[<dim_n>];

</syntaxhighlight>

==== Exemplu ====

<syntaxhighlight lang="C">
int cub[3][3][3];
</syntaxhighlight>

În acest caz 3 dimensiuni pot avea un sens fizic,însă tablourile cu mai mult de 3 dimensiuni pot să nu mai aibă un sens clar, ușor perceptibil.

== Exerciții ==

<ol>
<li>Fie v un vector cu N valori intregi. Să se numere cate valori sunt pare/impare.</li>
<li>Să se insereze un nou element z in pozitia k, restul elementelor rămânând în aceeași ordine.</li>
<li>Se citesc 2 vectori de maxim 100 elemente întregi, apoi determina și afișează intersecția celor 2 vectori.</li>
<li>Declarați și afișați o matrice unitate.</li>
<li>Să se scrie un program care citește de la tastatură o matrice de M întregi. Să se asigure că utilizatorul introduce valori doar între 0 și 9 și să se afișeze sub forma unui vector pe ecran elementele de deasupra diagonalei principale.</li>
<li>Se se scrie un program ce permite citirea matrici A si B reale de dimensiune MxN. Să se calculeze matricea produs C și să se stocheze toate elementele matricii mai mari ca x într-un vector v. Să se afiseze vectorul.</li>
<li>Scrieti un program care citeşte de la tastatură un număr natural, n (2≤n≤20), şi construieşte în memorie tabloul bidimensional cu n linii şi n coloane, având proprietătile:
<ul>
<li>toate elementele situate pe diagonala principală sunt nule;</li>
<li>fiecare linie contine, începând cu diagonala principală, de la dreapta la stânga, un şir strict crescător de numere consecutive, iar începând cu diagonala principală, de la stânga la dreapta, tot un şir strict crescător de numere consecutive.</li></ul></li>
Programul afişează pe ecran tabloul construit, fiecare linie a tabloului pe
câte o linie a ecranului, cu elementele aflate pe aceeaşi linie separate prin
câte un spatiu.
Exemplu: dacă n=5 se afişează pe ecran tabloul alăturat.
<syntaxhighlight lang="C">
0 1 2 3 4
1 0 1 2 3
2 1 0 1 2
3 2 1 0 1
4 3 2 1 0
</syntaxhighlight>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se înlocuiască toate vocalele cu caracterul _ și să se afiseze cuvântul obținut.</li>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se determine dacă este sau nu palindrom.</li>
</ol>

== Exerciții pentru acasă==

# Se consideră o matrice de dimenisiune NxM,numere intregi. Să se determine linia (liniile) cu cele mai multe elemente nenule.
# Se consideră o matrice A de NxN elemente, cu componentele numere întregi. Să se calculeze:
#* suma elementelor de pe diagonala principală
#* produsul elmentelor de pe diagonala secundară
#* minimul elementelor aflate deasupra, respectiv sub diagonala principală
# Se consideră o matrice de NxM elemente, cu componentele numere întregi. Se cere să se calculeze suma elementelor de pe marginea matricii.
# Să se construiască o matrice cu n linii şi m coloane care conţine pe prima coloană, de sus în jos, toate numerele naturale de la 1 la n, în ordine crescătoare, pe coloana a doua, de sus în jos, toate numerele naturale de la 2 la n+1, în ordine crescătoare, pe a treia coloană, de sus în jos, toate numerele naturale de la 3 la n+2, în ordine crescătoare, pe a patra coloană, de sus în jos, toate numerele naturale de la 4 la n+3, în ordine crescătoare şi aşa mai departe până la coloana m. Scrieţi programul care citeşte de la tastatură două valori naturale n și m (2<n<25, 2<m<25), construieşte matricea conform cerinţei şi o afişează pe ecran, pe linii, cu spaţii între elementele de pe fiecare linie. De exemplu, dacă se citeşte de la tastatură n=3 și m=5, se va construi şi se va afişa pe ecran matricea:
<syntaxhighlight lang="C">
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
</syntaxhighlight>

PC Laborator 7

2016-11-16T16:23:22Z

Lflueratoru: /* Exemplu */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil:
*să înteleagă modul de utilizare a tablourilor de memorie
*să declare şi să iniţializeze vectori/matrici
*să implementeze algoritmi simpli în lucru cu vectori pentru rezolvarea diverselor probleme

== Tablouri ==
Tabloul de memorie este o colecţie de date stocate în locaţii succesive din memorie. Toate elementele acestuia au acelaşi tip de dată numit de obicei tip de bază.
Tablourile pot fi :

*vectori (tablouri unidimensionale): șiruri de valori
*matrici (tablouri bidimensionale): catalogul cu note
*multidimensionale: pixelii unei imagini în timp

=== Vectori ===

Un vector reprezintă o colecție de date de acelaşi tip reprezentate sub forma unei linii.

====Declarația unei variabile de tip vector====

<syntaxhighlight lang="C">
<tip_elemente> <nume_vector>[<număr_maxim_elemente>];
</syntaxhighlight>

=====Exemplu=====

<syntaxhighlight lang="C">
int v[10]; /* astfel se alocă 10 locații de memorie consecutive de tip int, ce vor corespunde valorilor vectorului v */
float nume_vector[100]; /* vector de tip float cu 100 elemente */
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Vectorii declarați astfel sunt denumiți statici (static arrays) deoarece numărul de elemente şi spaţiul de memorie ocupat sunt constante în timpul compilării (număr_maxim_elemente fiind o constantă).''
</div>

<syntaxhighlight lang="C">
#define MAX 100
...
unsigned long nume_vector[MAX]
</syntaxhighlight>

<div class="regula">'''<font color="red"> Recomandare: </font>''' ''Numărătoarea elementelor începe de la 0.'' </div>
<syntaxhighlight lang="C"> int v[10]; // primul element va fi v[0],iar ultimul element v[9] </syntaxhighlight>
Vectorii se pot iniţializa cu valori constante, în acest caz, compilatorul va determina dimensiunea vectorului din numărul elementelor din listă.

'''Un alt mod de declarare este:'''

<syntaxhighlight lang="C">
int v[10] = {1, 5, 6, 8, 6, 10, 22, 32, 34, 13}; // Toate elemente sunt initializate
float nume_vector[] = {1.2, 2.2, 6.1, -9.3}; // Compilatorul determina dimensiunea vectorului = 4
int vect[1000] = {0, 1, 2, 3, 5}; // Sunt initializate doar primele 5 elemente,restul fiind completate automat cu zero
</syntaxhighlight>

==== Parcurgerea vectorilor ====

Cum deja am discutat prima poziție dintr-un vector este v[0]. Presupunem un vector are N elemente, constatăm că ultimul element este v[N-1]. A trece prin elementele vectorului presupune parcurgerea tuturor celor N elemente , de la V[0] la V[N-1]. Acest lucru este posibil prin:
<syntaxhighlight lang="C">
for(i=0; i < N; i++)
// instrucțiune v[i];
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Se poate ingnora poziția zero,însă daca avem un vector de 100 elemente declararea uzuală ar fi int v[100];, gândim valorile de la v[0] la v[99]. Daca folosim numărarea de la 1, vom avea doar 99 de locații de memorie disponibile pentru cele 100 de valori. În acest caz declararea corecta ar fi int v[101];.''</div>

==== Modul de adresare ====

{| class="wikitable"
! Indici
! 0
! 1
! 2
! 3
|-
| colspan="5" |
|-
| Valoare
| 12
| 33
| 120
| 460
|}
<syntaxhighlight lang="C">
printf("%d",v); // v stochează adresa primul element
printf("%d",v[1]); // reprezintă valoarea din a 2a locație de memorie a vectoritului v adică 33
</syntaxhighlight>

==== Citirea vectorilor ====

<syntaxhighlight lang="C">
int v[100], n, i; // vectorul a are maxim 100 de intregi

scanf("%d", &n); // citeste nr de elemente

for (i = 0; i < n; i++) {
scanf("%d", &v[i]); // citire elemente
}

for (i = 0; i < n; i++) {
printf("%d ", v[i]); // scrie elemente
}
</syntaxhighlight>

=== Matrici ===

O matrice reprezintă o colecție de date de acelaşi tip,ce este structurată pe linii şi coloane.
Datele sunt identificate prin indicele liniei şi respectiv indicele coloanei.
<div class="regula">'''<font color="red"> Observatie:</font>''' '' Un vector este un caz particular de matrice cu o singură linie.'' </div>

==== Declarația unei matrici ====

<syntaxhighlight lang="C">
<tip_elemente> <nume_matrice>[<număr_linii>][<număr_coloane>];
</syntaxhighlight>

==== Exemplul 1 ====

<syntaxhighlight lang="C">

int matrice[5][10]; // o matrice de întregi cu 5 linii și 10 coloane care ocupă 5*10*4=200 octeți

#define MAX 100
float a[MAX][MAX]; // în acest caz număr linii = număr coloane = 100

</syntaxhighlight>

==== Parcurgerea matricilor ====

<syntaxhighlight lang="C">
int mat[N][M];
for (int i=0; i < N; i++) {
for (int j=0; j < M; j++){
// instrucțiune mat[i][j];
}
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Accesarea elementului de pe linia i şi coloana j se face cu mat[i][j];''</div>

==== Adresarea matricilor ====

Adresarea este similară cu cea a vectorilor,doar ca în acest caz lucrăm cu doua dimensiuni (2D)-matrici.

<syntaxhighlight lang="C">

printf("%d",mat[1][3]) // reprezintă valorea de pe linia 1 și coloana 3 a matricii mat
printf("%d",&mat[1][3]) // reprezintă adresa de memorie a elementului de pe linia 1 și coloana 3 a matricii mat

</syntaxhighlight>

==== Citirea matricilor ====

<syntaxhighlight lang="C">

int mat[10][10], i, j;
for (i=0; i < 10; i++)
for (j=0; j < 10; j++){
printf("v[%d][%d]=", i, j);
scanf("%d",&mat[i][j]);
}
</syntaxhighlight>

=== Tablouri multidimensionale ===

Noţiunea generală de tablou cu mai multe dimensiuni, se declară astfel:
<syntaxhighlight lang="C">

<tip_elemente> <nume_tablou>[<dim_1>][<dim_2>]...[<dim_n>];

</syntaxhighlight>

==== Exemplu ====

<syntaxhighlight lang="C">
int cub[3][3][3];
</syntaxhighlight>

În acest caz 3 dimensiuni pot avea un sens fizic,însă tablourile cu mai mult de 3 dimensiuni pot să nu mai aibă un sens clar,ușor perceptibil.

== Exerciții ==

<ol>
<li>Fie v un vector cu N valori intregi. Să se numere cate valori sunt pare/impare.</li>
<li>Să se insereze un nou element z in pozitia k, restul elementelor rămânând în aceeași ordine.</li>
<li>Se citesc 2 vectori de maxim 100 elemente întregi, apoi determina și afișează intersecția celor 2 vectori.</li>
<li>Declarați și afișați o matrice unitate.</li>
<li>Să se scrie un program care citește de la tastatură o matrice de M întregi. Să se asigure că utilizatorul introduce valori doar între 0 și 9 și să se afișeze sub forma unui vector pe ecran elementele de deasupra diagonalei principale.</li>
<li>Se se scrie un program ce permite citirea matrici A si B reale de dimensiune MxN. Să se calculeze matricea produs C și să se stocheze toate elementele matricii mai mari ca x într-un vector v. Să se afiseze vectorul.</li>
<li>Scrieti un program care citeşte de la tastatură un număr natural, n (2≤n≤20), şi construieşte în memorie tabloul bidimensional cu n linii şi n coloane, având proprietătile:
<ul>
<li>toate elementele situate pe diagonala principală sunt nule;</li>
<li>fiecare linie contine, începând cu diagonala principală, de la dreapta la stânga, un şir strict crescător de numere consecutive, iar începând cu diagonala principală, de la stânga la dreapta, tot un şir strict crescător de numere consecutive.</li></ul></li>
Programul afişează pe ecran tabloul construit, fiecare linie a tabloului pe
câte o linie a ecranului, cu elementele aflate pe aceeaşi linie separate prin
câte un spatiu.
Exemplu: dacă n=5 se afişează pe ecran tabloul alăturat.
<syntaxhighlight lang="C">
0 1 2 3 4
1 0 1 2 3
2 1 0 1 2
3 2 1 0 1
4 3 2 1 0
</syntaxhighlight>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se înlocuiască toate vocalele cu caracterul _ și să se afiseze cuvântul obținut.</li>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se determine dacă este sau nu palindrom.</li>
</ol>

== Exerciții pentru acasă==

# Se consideră o matrice de dimenisiune NxM,numere intregi. Să se determine linia (liniile) cu cele mai multe elemente nenule.
# Se consideră o matrice A de NxN elemente, cu componentele numere întregi. Să se calculeze:
#* suma elementelor de pe diagonala principală
#* produsul elmentelor de pe diagonala secundară
#* minimul elementelor aflate deasupra, respectiv sub diagonala principală
# Se consideră o matrice de NxM elemente, cu componentele numere întregi. Se cere să se calculeze suma elementelor de pe marginea matricii.
# Să se construiască o matrice cu n linii şi m coloane care conţine pe prima coloană, de sus în jos, toate numerele naturale de la 1 la n, în ordine crescătoare, pe coloana a doua, de sus în jos, toate numerele naturale de la 2 la n+1, în ordine crescătoare, pe a treia coloană, de sus în jos, toate numerele naturale de la 3 la n+2, în ordine crescătoare, pe a patra coloană, de sus în jos, toate numerele naturale de la 4 la n+3, în ordine crescătoare şi aşa mai departe până la coloana m. Scrieţi programul care citeşte de la tastatură două valori naturale n și m (2<n<25, 2<m<25), construieşte matricea conform cerinţei şi o afişează pe ecran, pe linii, cu spaţii între elementele de pe fiecare linie. De exemplu, dacă se citeşte de la tastatură n=3 și m=5, se va construi şi se va afişa pe ecran matricea:
<syntaxhighlight lang="C">
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
</syntaxhighlight>

PC Laborator 7

2016-11-16T16:22:13Z

Lflueratoru: /* Exemplu */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil:
*să înteleagă modul de utilizare a tablourilor de memorie
*să declare şi să iniţializeze vectori/matrici
*să implementeze algoritmi simpli în lucru cu vectori pentru rezolvarea diverselor probleme

== Tablouri ==
Tabloul de memorie este o colecţie de date stocate în locaţii succesive din memorie. Toate elementele acestuia au acelaşi tip de dată numit de obicei tip de bază.
Tablourile pot fi :

*vectori (tablouri unidimensionale): șiruri de valori
*matrici (tablouri bidimensionale): catalogul cu note
*multidimensionale: pixelii unei imagini în timp

=== Vectori ===

Un vector reprezintă o colecție de date de acelaşi tip reprezentate sub forma unei linii.

====Declarația unei variabile de tip vector====

<syntaxhighlight lang="C">
<tip_elemente> <nume_vector>[<număr_maxim_elemente>];
</syntaxhighlight>

=====Exemplu=====

<syntaxhighlight lang="C">
int v[10]; /* astfel se alocă 10 locații de memorie consecutive de tip int, ce vor corespunde valorilor vectorului v */
float nume_vector[100]; /* vector de tip float cu 100 elemente */
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Vectorii declarați astfel sunt denumiți statici (static arrays) deoarece numărul de elemente şi spaţiul de memorie ocupat sunt constante în timpul compilării (număr_maxim_elemente fiind o constantă).''
</div>

<syntaxhighlight lang="C">
#define MAX 100
...
unsigned long nume_vector[MAX]
</syntaxhighlight>

<div class="regula">'''<font color="red"> Recomandare: </font>''' ''Numărătoarea elementelor începe de la 0.'' </div>
<syntaxhighlight lang="C"> int v[10]; // primul element va fi v[0],iar ultimul element v[9] </syntaxhighlight>
Vectorii se pot iniţializa cu valori constante, în acest caz, compilatorul care va determina dimensiunea vectorului din numărul elementelor din listă.

'''Un alt mod de declarare este:'''

<syntaxhighlight lang="C">
int v[10] = {1, 5, 6, 8, 6, 10, 22, 32, 34, 13}; // Toate elemente sunt initializate
float nume_vector[] = {1.2, 2.2, 6.1, -9.3}; // Compilatorul determina dimensiunea vectorului=4
int vect[1000] = {0, 1, 2, 3, 5}; // Sunt initializate doar primele 5 elemente,restul fiind completate automat cu zero
</syntaxhighlight>

==== Parcurgerea vectorilor ====

Cum deja am discutat prima poziție dintr-un vector este v[0]. Presupunem un vector are N elemente, constatăm că ultimul element este v[N-1]. A trece prin elementele vectorului presupune parcurgerea tuturor celor N elemente , de la V[0] la V[N-1]. Acest lucru este posibil prin:
<syntaxhighlight lang="C">
for(i=0; i < N; i++)
// instrucțiune v[i];
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Se poate ingnora poziția zero,însă daca avem un vector de 100 elemente declararea uzuală ar fi int v[100];, gândim valorile de la v[0] la v[99]. Daca folosim numărarea de la 1, vom avea doar 99 de locații de memorie disponibile pentru cele 100 de valori. În acest caz declararea corecta ar fi int v[101];.''</div>

==== Modul de adresare ====

{| class="wikitable"
! Indici
! 0
! 1
! 2
! 3
|-
| colspan="5" |
|-
| Valoare
| 12
| 33
| 120
| 460
|}
<syntaxhighlight lang="C">
printf("%d",v); // v stochează adresa primul element
printf("%d",v[1]); // reprezintă valoarea din a 2a locație de memorie a vectoritului v adică 33
</syntaxhighlight>

==== Citirea vectorilor ====

<syntaxhighlight lang="C">
int v[100], n, i; // vectorul a are maxim 100 de intregi

scanf("%d", &n); // citeste nr de elemente

for (i = 0; i < n; i++) {
scanf("%d", &v[i]); // citire elemente
}

for (i = 0; i < n; i++) {
printf("%d ", v[i]); // scrie elemente
}
</syntaxhighlight>

=== Matrici ===

O matrice reprezintă o colecție de date de acelaşi tip,ce este structurată pe linii şi coloane.
Datele sunt identificate prin indicele liniei şi respectiv indicele coloanei.
<div class="regula">'''<font color="red"> Observatie:</font>''' '' Un vector este un caz particular de matrice cu o singură linie.'' </div>

==== Declarația unei matrici ====

<syntaxhighlight lang="C">
<tip_elemente> <nume_matrice>[<număr_linii>][<număr_coloane>];
</syntaxhighlight>

==== Exemplul 1 ====

<syntaxhighlight lang="C">

int matrice[5][10]; // o matrice de întregi cu 5 linii și 10 coloane care ocupă 5*10*4=200 octeți

#define MAX 100
float a[MAX][MAX]; // în acest caz număr linii = număr coloane = 100

</syntaxhighlight>

==== Parcurgerea matricilor ====

<syntaxhighlight lang="C">
int mat[N][M];
for (int i=0; i < N; i++) {
for (int j=0; j < M; j++){
// instrucțiune mat[i][j];
}
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Accesarea elementului de pe linia i şi coloana j se face cu mat[i][j];''</div>

==== Adresarea matricilor ====

Adresarea este similară cu cea a vectorilor,doar ca în acest caz lucrăm cu doua dimensiuni (2D)-matrici.

<syntaxhighlight lang="C">

printf("%d",mat[1][3]) // reprezintă valorea de pe linia 1 și coloana 3 a matricii mat
printf("%d",&mat[1][3]) // reprezintă adresa de memorie a elementului de pe linia 1 și coloana 3 a matricii mat

</syntaxhighlight>

==== Citirea matricilor ====

<syntaxhighlight lang="C">

int mat[10][10], i, j;
for (i=0; i < 10; i++)
for (j=0; j < 10; j++){
printf("v[%d][%d]=", i, j);
scanf("%d",&mat[i][j]);
}
</syntaxhighlight>

=== Tablouri multidimensionale ===

Noţiunea generală de tablou cu mai multe dimensiuni, se declară astfel:
<syntaxhighlight lang="C">

<tip_elemente> <nume_tablou>[<dim_1>][<dim_2>]...[<dim_n>];

</syntaxhighlight>

==== Exemplu ====

<syntaxhighlight lang="C">
int cub[3][3][3];
</syntaxhighlight>

În acest caz 3 dimensiuni pot avea un sens fizic,însă tablourile cu mai mult de 3 dimensiuni pot să nu mai aibă un sens clar,ușor perceptibil.

== Exerciții ==

<ol>
<li>Fie v un vector cu N valori intregi. Să se numere cate valori sunt pare/impare.</li>
<li>Să se insereze un nou element z in pozitia k, restul elementelor rămânând în aceeași ordine.</li>
<li>Se citesc 2 vectori de maxim 100 elemente întregi, apoi determina și afișează intersecția celor 2 vectori.</li>
<li>Declarați și afișați o matrice unitate.</li>
<li>Să se scrie un program care citește de la tastatură o matrice de M întregi. Să se asigure că utilizatorul introduce valori doar între 0 și 9 și să se afișeze sub forma unui vector pe ecran elementele de deasupra diagonalei principale.</li>
<li>Se se scrie un program ce permite citirea matrici A si B reale de dimensiune MxN. Să se calculeze matricea produs C și să se stocheze toate elementele matricii mai mari ca x într-un vector v. Să se afiseze vectorul.</li>
<li>Scrieti un program care citeşte de la tastatură un număr natural, n (2≤n≤20), şi construieşte în memorie tabloul bidimensional cu n linii şi n coloane, având proprietătile:
<ul>
<li>toate elementele situate pe diagonala principală sunt nule;</li>
<li>fiecare linie contine, începând cu diagonala principală, de la dreapta la stânga, un şir strict crescător de numere consecutive, iar începând cu diagonala principală, de la stânga la dreapta, tot un şir strict crescător de numere consecutive.</li></ul></li>
Programul afişează pe ecran tabloul construit, fiecare linie a tabloului pe
câte o linie a ecranului, cu elementele aflate pe aceeaşi linie separate prin
câte un spatiu.
Exemplu: dacă n=5 se afişează pe ecran tabloul alăturat.
<syntaxhighlight lang="C">
0 1 2 3 4
1 0 1 2 3
2 1 0 1 2
3 2 1 0 1
4 3 2 1 0
</syntaxhighlight>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se înlocuiască toate vocalele cu caracterul _ și să se afiseze cuvântul obținut.</li>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se determine dacă este sau nu palindrom.</li>
</ol>

== Exerciții pentru acasă==

# Se consideră o matrice de dimenisiune NxM,numere intregi. Să se determine linia (liniile) cu cele mai multe elemente nenule.
# Se consideră o matrice A de NxN elemente, cu componentele numere întregi. Să se calculeze:
#* suma elementelor de pe diagonala principală
#* produsul elmentelor de pe diagonala secundară
#* minimul elementelor aflate deasupra, respectiv sub diagonala principală
# Se consideră o matrice de NxM elemente, cu componentele numere întregi. Se cere să se calculeze suma elementelor de pe marginea matricii.
# Să se construiască o matrice cu n linii şi m coloane care conţine pe prima coloană, de sus în jos, toate numerele naturale de la 1 la n, în ordine crescătoare, pe coloana a doua, de sus în jos, toate numerele naturale de la 2 la n+1, în ordine crescătoare, pe a treia coloană, de sus în jos, toate numerele naturale de la 3 la n+2, în ordine crescătoare, pe a patra coloană, de sus în jos, toate numerele naturale de la 4 la n+3, în ordine crescătoare şi aşa mai departe până la coloana m. Scrieţi programul care citeşte de la tastatură două valori naturale n și m (2<n<25, 2<m<25), construieşte matricea conform cerinţei şi o afişează pe ecran, pe linii, cu spaţii între elementele de pe fiecare linie. De exemplu, dacă se citeşte de la tastatură n=3 și m=5, se va construi şi se va afişa pe ecran matricea:
<syntaxhighlight lang="C">
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
</syntaxhighlight>

PC Laborator 7

2016-11-16T16:16:10Z

Lflueratoru: /* Tablouri */

== Obiective ==
La încheierea acestui laborator studentul va fi capabil:
*să înteleagă modul de utilizare a tablourilor de memorie
*să declare şi să iniţializeze vectori/matrici
*să implementeze algoritmi simpli în lucru cu vectori pentru rezolvarea diverselor probleme

== Tablouri ==
Tabloul de memorie este o colecţie de date stocate în locaţii succesive din memorie. Toate elementele acestuia au acelaşi tip de dată numit de obicei tip de bază.
Tablourile pot fi :

*vectori (tablouri unidimensionale): șiruri de valori
*matrici (tablouri bidimensionale): catalogul cu note
*multidimensionale: pixelii unei imagini în timp

=== Vectori ===

Un vector reprezintă o colecție de date de acelaşi tip reprezentate sub forma unei linii.

====Declarația unei variabile de tip vector====

<syntaxhighlight lang="C">
<tip_elemente> <nume_vector>[<număr_maxim_elemente>];
</syntaxhighlight>

=====Exemplu=====

<syntaxhighlight lang="C">
int v[10]; /* astfel se alocă 10 locații de memorie consecutive de tip int, ce vor corespunde valorilor vectorului v */
float nume_vector[100]; /* vector de tip float cu 100 elemente */
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Vectorii declarați astfel sunt denumiți statici (static arrays) deoarece numărul de elemente şi spaţiul de memorie ocupat este constant în timpul compilării. (număr_maxim_elemente fiind o constantă).''
</div>

<syntaxhighlight lang="C">
#define MAX 100
...
unsigned long nume_vector[MAX]
</syntaxhighlight>

<div class="regula">'''<font color="red"> Recomandare: </font>''' ''Numărătoarea elementelor începe de la 0.'' </div>
<syntaxhighlight lang="C"> int v[10]; // primul element va fi v[0],iar ultimul element v[9] </syntaxhighlight>
Vectorii se pot iniţializa cu valori constante, în acest caz, compilatorul care va determina dimensiunea vectorului din numărul elementelor din listă.

'''Un alt mod de declarare este:'''

<syntaxhighlight lang="C">
int v[10] = {1, 5, 6, 8, 6, 10, 22, 32, 34, 13}; // Toate elemente sunt initializate
float nume_vector[] = {1.2, 2.2, 6.1, -9.3}; // Compilatorul determina dimensiunea vectorului=4
int vect[1000] = {0, 1, 2, 3, 5}; // Sunt initializate doar primele 5 elemente,restul fiind completate automat cu zero
</syntaxhighlight>

==== Parcurgerea vectorilor ====

Cum deja am discutat prima poziție dintr-un vector este v[0]. Presupunem un vector are N elemente, constatăm că ultimul element este v[N-1]. A trece prin elementele vectorului presupune parcurgerea tuturor celor N elemente , de la V[0] la V[N-1]. Acest lucru este posibil prin:
<syntaxhighlight lang="C">
for(i=0; i < N; i++)
// instrucțiune v[i];
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Se poate ingnora poziția zero,însă daca avem un vector de 100 elemente declararea uzuală ar fi int v[100];, gândim valorile de la v[0] la v[99]. Daca folosim numărarea de la 1, vom avea doar 99 de locații de memorie disponibile pentru cele 100 de valori. În acest caz declararea corecta ar fi int v[101];.''</div>

==== Modul de adresare ====

{| class="wikitable"
! Indici
! 0
! 1
! 2
! 3
|-
| colspan="5" |
|-
| Valoare
| 12
| 33
| 120
| 460
|}
<syntaxhighlight lang="C">
printf("%d",v); // v stochează adresa primul element
printf("%d",v[1]); // reprezintă valoarea din a 2a locație de memorie a vectoritului v adică 33
</syntaxhighlight>

==== Citirea vectorilor ====

<syntaxhighlight lang="C">
int v[100], n, i; // vectorul a are maxim 100 de intregi

scanf("%d", &n); // citeste nr de elemente

for (i = 0; i < n; i++) {
scanf("%d", &v[i]); // citire elemente
}

for (i = 0; i < n; i++) {
printf("%d ", v[i]); // scrie elemente
}
</syntaxhighlight>

=== Matrici ===

O matrice reprezintă o colecție de date de acelaşi tip,ce este structurată pe linii şi coloane.
Datele sunt identificate prin indicele liniei şi respectiv indicele coloanei.
<div class="regula">'''<font color="red"> Observatie:</font>''' '' Un vector este un caz particular de matrice cu o singură linie.'' </div>

==== Declarația unei matrici ====

<syntaxhighlight lang="C">
<tip_elemente> <nume_matrice>[<număr_linii>][<număr_coloane>];
</syntaxhighlight>

==== Exemplul 1 ====

<syntaxhighlight lang="C">

int matrice[5][10]; // o matrice de întregi cu 5 linii și 10 coloane care ocupă 5*10*4=200 octeți

#define MAX 100
float a[MAX][MAX]; // în acest caz număr linii = număr coloane = 100

</syntaxhighlight>

==== Parcurgerea matricilor ====

<syntaxhighlight lang="C">
int mat[N][M];
for (int i=0; i < N; i++) {
for (int j=0; j < M; j++){
// instrucțiune mat[i][j];
}
}
</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font>''' ''Accesarea elementului de pe linia i şi coloana j se face cu mat[i][j];''</div>

==== Adresarea matricilor ====

Adresarea este similară cu cea a vectorilor,doar ca în acest caz lucrăm cu doua dimensiuni (2D)-matrici.

<syntaxhighlight lang="C">

printf("%d",mat[1][3]) // reprezintă valorea de pe linia 1 și coloana 3 a matricii mat
printf("%d",&mat[1][3]) // reprezintă adresa de memorie a elementului de pe linia 1 și coloana 3 a matricii mat

</syntaxhighlight>

==== Citirea matricilor ====

<syntaxhighlight lang="C">

int mat[10][10], i, j;
for (i=0; i < 10; i++)
for (j=0; j < 10; j++){
printf("v[%d][%d]=", i, j);
scanf("%d",&mat[i][j]);
}
</syntaxhighlight>

=== Tablouri multidimensionale ===

Noţiunea generală de tablou cu mai multe dimensiuni, se declară astfel:
<syntaxhighlight lang="C">

<tip_elemente> <nume_tablou>[<dim_1>][<dim_2>]...[<dim_n>];

</syntaxhighlight>

==== Exemplu ====

<syntaxhighlight lang="C">
int cub[3][3][3];
</syntaxhighlight>

În acest caz 3 dimensiuni pot avea un sens fizic,însă tablourile cu mai mult de 3 dimensiuni pot să nu mai aibă un sens clar,ușor perceptibil.

== Exerciții ==

<ol>
<li>Fie v un vector cu N valori intregi. Să se numere cate valori sunt pare/impare.</li>
<li>Să se insereze un nou element z in pozitia k, restul elementelor rămânând în aceeași ordine.</li>
<li>Se citesc 2 vectori de maxim 100 elemente întregi, apoi determina și afișează intersecția celor 2 vectori.</li>
<li>Declarați și afișați o matrice unitate.</li>
<li>Să se scrie un program care citește de la tastatură o matrice de M întregi. Să se asigure că utilizatorul introduce valori doar între 0 și 9 și să se afișeze sub forma unui vector pe ecran elementele de deasupra diagonalei principale.</li>
<li>Se se scrie un program ce permite citirea matrici A si B reale de dimensiune MxN. Să se calculeze matricea produs C și să se stocheze toate elementele matricii mai mari ca x într-un vector v. Să se afiseze vectorul.</li>
<li>Scrieti un program care citeşte de la tastatură un număr natural, n (2≤n≤20), şi construieşte în memorie tabloul bidimensional cu n linii şi n coloane, având proprietătile:
<ul>
<li>toate elementele situate pe diagonala principală sunt nule;</li>
<li>fiecare linie contine, începând cu diagonala principală, de la dreapta la stânga, un şir strict crescător de numere consecutive, iar începând cu diagonala principală, de la stânga la dreapta, tot un şir strict crescător de numere consecutive.</li></ul></li>
Programul afişează pe ecran tabloul construit, fiecare linie a tabloului pe
câte o linie a ecranului, cu elementele aflate pe aceeaşi linie separate prin
câte un spatiu.
Exemplu: dacă n=5 se afişează pe ecran tabloul alăturat.
<syntaxhighlight lang="C">
0 1 2 3 4
1 0 1 2 3
2 1 0 1 2
3 2 1 0 1
4 3 2 1 0
</syntaxhighlight>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se înlocuiască toate vocalele cu caracterul _ și să se afiseze cuvântul obținut.</li>
<li>Se citeste un cuvânt de maxim 20 de caractere de la tastatură, să se determine dacă este sau nu palindrom.</li>
</ol>

== Exerciții pentru acasă==

# Se consideră o matrice de dimenisiune NxM,numere intregi. Să se determine linia (liniile) cu cele mai multe elemente nenule.
# Se consideră o matrice A de NxN elemente, cu componentele numere întregi. Să se calculeze:
#* suma elementelor de pe diagonala principală
#* produsul elmentelor de pe diagonala secundară
#* minimul elementelor aflate deasupra, respectiv sub diagonala principală
# Se consideră o matrice de NxM elemente, cu componentele numere întregi. Se cere să se calculeze suma elementelor de pe marginea matricii.
# Să se construiască o matrice cu n linii şi m coloane care conţine pe prima coloană, de sus în jos, toate numerele naturale de la 1 la n, în ordine crescătoare, pe coloana a doua, de sus în jos, toate numerele naturale de la 2 la n+1, în ordine crescătoare, pe a treia coloană, de sus în jos, toate numerele naturale de la 3 la n+2, în ordine crescătoare, pe a patra coloană, de sus în jos, toate numerele naturale de la 4 la n+3, în ordine crescătoare şi aşa mai departe până la coloana m. Scrieţi programul care citeşte de la tastatură două valori naturale n și m (2<n<25, 2<m<25), construieşte matricea conform cerinţei şi o afişează pe ecran, pe linii, cu spaţii între elementele de pe fiecare linie. De exemplu, dacă se citeşte de la tastatură n=3 și m=5, se va construi şi se va afişa pe ecran matricea:
<syntaxhighlight lang="C">
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
</syntaxhighlight>

PC Laborator 6

2016-11-08T19:49:36Z

Lflueratoru: /* Structuri repetitive cu număr necunoscut de pași */

__TOC__
== Obiective ==
La sfârșitul acestui laborator studenții vor fi capabili:
* să înțeleagă funcționarea blocurilor repetitive;
* să conceapă programe care folosesc blocuri repetitive.

== Structura repetitivă ==
Structura repetitivă, cunoscută și sub numele de loop sau buclă, reprezintă o bucată de cod care poate fi executată în mod repetat. Structurile repetitive trebuie sa aibă o condiție de continuare. La fiecare iterație a codului această condiție este verificată, iar în momentul în care condiția devine falsă se oprește execuția buclei și se trece mai departe în program.
Există 2 tipuri de structuri repetitive:
* structuri repetitive cu număr cunoscut de pași;
* structuri repetitive cu număr necunoscut de pași.

=== Structuri repetitive cu număr cunoscut de pași ===
Instrucțiunea ''for'' creează o structură repetitivă cu număr cunoscut de pași. Sintaxa instrucțiunii ''for'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Instrucțiunea ''for'' se parcurge conform schemei următoare:<br/>[[Fișier:For.jpg]]

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x;
for (x = 0; x < 10; x++) {
printf("%d\n", x);
}
return 0;
}
</syntaxhighlight>

=== Structuri repetitive cu număr necunoscut de pași ===
Există două instrucțiuni pentru a crea structuri repetitive cu număr necunoscut de pași:
* instrucțiunea ''while'';
* instrucțiunea ''do..while'';

==== Instrucțiunea ''while'' ====
Instrucțiunea ''while'' verifică înainte de fiecare iterație condiția de intrare: dacă această condiție este îndeplinită se execută codul din corpul instrucțiunii, iar dacă nu se îndeplinește condiția se iese din această buclă. Sintaxa instrucțiunii este următoarea:<br/>
a)
<syntaxhighlight lang="C">
while (condiție)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
while (condiție){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Organigrama instrucțiunii ''while'' se regăsește în imaginea următoare:<br/>[[Fișier:While.jpg]]

'''Exemplu'''<br/>
Ce va afișa următorul cod în urma execuției?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x = 0;
while (x < 10) {
printf("%d\n", x);
x++;
}
return 0;
}
</syntaxhighlight>

==== Instrucțiunea ''do while'' ====
Instrucțiunea ''do while'' verifică după fiecare iterație condiția de continuare. Sintaxa instrucțiunii "do while'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
do {
instrucțiune;
} while (condiție);
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
do {
instrucțiune1;
instrucțiune2;
..............................
} while (condiție);
</syntaxhighlight>

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că sintaxa instrucțiunii ''do while'' este puțin diferită:
* indiferent de numărul de instrucțiuni din cadrul structurii repetitive, se folosesc acoladele;
* după condiția de continuitate se folosește obligatoriu semnul de punctuație <font color="green">''';'''</font> .
</div>
Organigrama instrucțiunii ''do-while'' se regăsește în imaginea următoare:<br/>[[Fișier:Do_while.jpg]]

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că datorită faptului că se verifică abia la sfârșitul structurii condiția de continuitate, orice structură iterativă de tip ''do while'' va fi executată întotdeauna cel puțin o dată.
</div>

'''Exemplu'''<br/>
Ce se va afișa în urma execuției?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x;
x = 0;
do {
printf("Hello, world!\n");
} while (x != 0);
return 0;
}
</syntaxhighlight>

== Cuvintele cheie '''break''' și '''continue''' ==
Pentru structurile repetitive există două cuvinte cheie de mare importanță: '''break''' și '''continue'''.<br/>
'''break''' va ieși din bucla cea mai apropiată indiferent de condițiile de continuare ale acesteia. Utilitatea acestei instrucțiuni apare atunci când trebuie părăsită bucla în anumite circumstanțe.<br/>
'''continue''' oprește iterația curentă, face update contorului (în cazul buclei ''for'') și continuă cu execuția structurii repetitive de la prima instrucțiune. Cu alte cuvinte, ''continue'' ignoră tot ceea ce urmează după el în cadrul buclei și trece la următoarea iterație a buclei.

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int a = 10;
while (a < 20) {
a++;
if (a == 13) {
continue;
}
printf("value of a: %d\n", a);
if (a > 16) {
break;
}
}
return 0;
}
</syntaxhighlight>

==Exerciții==
<ol><li>Să se afișeze pe o linie toate literele în ordine alfabetică, scrise cu majuscule, și pe o altă linie toate literele în ordine invers alfabetică, scrise cu litere mici. Rezolvați exercițiul în 3 moduri (folosind toate tipurile de bucle).</li>
<li>Să se citească un număr întreg fără semn n<20 de la tastatură. Afișați rezultatul operației n!.</li>
<li>Să se citească un număr întreg fără semn de la tastatură și să se verifice dacă acesta este palindrom.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere impare.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se citească apoi n numere întregi de la tastatură și să se afișeze suma numerelor pare introduse.</li>
<li>Refaceți exercițiul anterior în așa fel încât să folosiți instrucțiunea '''continue'''.</li>
<li>Să se citească de la tastatură o serie de numere întregi până la întâlnirea numărului 0. Să se afișeze apoi media aritmetică a acestor numere.</li>
<li>Verificați dacă un număr întreg fără semn introdus de la tastatură este prim.</li>
<li>Să se afișeze cmmdc și cmmmc a două numere întregi fără semn citite de la tastatură.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere prime.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se convertească în baza 2.</li>
<li>Să se realizeze un joc în care un jucător introduce un număr între 1 și 100 de la tastatură, apoi alt jucător încearcă să-l ghicească. Calculatorul va oferi indicii ("prea mic", "prea mare"), până la ghicirea numărului. La final se va afișa numărul de încercări de care a fost nevoie pentru a ghici numărul.</li>
</ol>

PC Laborator 6

2016-11-08T19:48:05Z

Lflueratoru: /* Instrucțiunea do while */

__TOC__
== Obiective ==
La sfârșitul acestui laborator studenții vor fi capabili:
* să înțeleagă funcționarea blocurilor repetitive;
* să conceapă programe care folosesc blocuri repetitive.

== Structura repetitivă ==
Structura repetitivă, cunoscută și sub numele de loop sau buclă, reprezintă o bucată de cod care poate fi executată în mod repetat. Structurile repetitive trebuie sa aibă o condiție de continuare. La fiecare iterație a codului această condiție este verificată, iar în momentul în care condiția devine falsă se oprește execuția buclei și se trece mai departe în program.
Există 2 tipuri de structuri repetitive:
* structuri repetitive cu număr cunoscut de pași;
* structuri repetitive cu număr necunoscut de pași.

=== Structuri repetitive cu număr cunoscut de pași ===
Instrucțiunea ''for'' creează o structură repetitivă cu număr cunoscut de pași. Sintaxa instrucțiunii ''for'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Instrucțiunea ''for'' se parcurge conform schemei următoare:<br/>[[Fișier:For.jpg]]

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x;
for (x = 0; x < 10; x++) {
printf("%d\n", x);
}
return 0;
}
</syntaxhighlight>

=== Structuri repetitive cu număr necunoscut de pași ===
Există două instrucțiuni pentru a crea structuri repetitive cu număr necunoscut de pași:
* instrucțiunea ''while'';
* instrucțiunea ''do..while'';

==== Instrucțiunea ''while'' ====
Instrucțiunea ''while'' verifică înainte de fiecare iterație condiția de intrare: dacă această condiție este îndeplinită se execută codul din corpul instrucțiunii, iar dacă nu se îndeplinește condiția se iese din această buclă. Sintaxa instrucțiunii este următoarea:<br/>
a)
<syntaxhighlight lang="C">
while (condiție)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
while (condiție){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Organigrama instrucțiunii ''while'' se regăsește în imaginea următoare:<br/>[[Fișier:While.jpg]]

'''Exemplu'''<br/>
Ce va afișa următorul cod în urma execuției?
<syntaxhighlight lang="C">
#include<stdio.h>

int main(){
int x = 0;
while (x < 10){
printf("%d\n", x);
x++;
}
return 0;
}
</syntaxhighlight>

==== Instrucțiunea ''do while'' ====
Instrucțiunea ''do while'' verifică după fiecare iterație condiția de continuare. Sintaxa instrucțiunii "do while'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
do {
instrucțiune;
} while (condiție);
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
do {
instrucțiune1;
instrucțiune2;
..............................
} while (condiție);
</syntaxhighlight>

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că sintaxa instrucțiunii ''do while'' este puțin diferită:
* indiferent de numărul de instrucțiuni din cadrul structurii repetitive, se folosesc acoladele;
* după condiția de continuitate se folosește obligatoriu semnul de punctuație <font color="green">''';'''</font> .
</div>
Organigrama instrucțiunii ''do-while'' se regăsește în imaginea următoare:<br/>[[Fișier:Do_while.jpg]]

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că datorită faptului că se verifică abia la sfârșitul structurii condiția de continuitate, orice structură iterativă de tip ''do while'' va fi executată întotdeauna cel puțin o dată.
</div>

'''Exemplu'''<br/>
Ce se va afișa în urma execuției?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x;
x = 0;
do {
printf("Hello, world!\n");
} while (x != 0);
return 0;
}
</syntaxhighlight>

== Cuvintele cheie '''break''' și '''continue''' ==
Pentru structurile repetitive există două cuvinte cheie de mare importanță: '''break''' și '''continue'''.<br/>
'''break''' va ieși din bucla cea mai apropiată indiferent de condițiile de continuare ale acesteia. Utilitatea acestei instrucțiuni apare atunci când trebuie părăsită bucla în anumite circumstanțe.<br/>
'''continue''' oprește iterația curentă, face update contorului (în cazul buclei ''for'') și continuă cu execuția structurii repetitive de la prima instrucțiune. Cu alte cuvinte, ''continue'' ignoră tot ceea ce urmează după el în cadrul buclei și trece la următoarea iterație a buclei.

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int a = 10;
while (a < 20) {
a++;
if (a == 13) {
continue;
}
printf("value of a: %d\n", a);
if (a > 16) {
break;
}
}
return 0;
}
</syntaxhighlight>

==Exerciții==
<ol><li>Să se afișeze pe o linie toate literele în ordine alfabetică, scrise cu majuscule, și pe o altă linie toate literele în ordine invers alfabetică, scrise cu litere mici. Rezolvați exercițiul în 3 moduri (folosind toate tipurile de bucle).</li>
<li>Să se citească un număr întreg fără semn n<20 de la tastatură. Afișați rezultatul operației n!.</li>
<li>Să se citească un număr întreg fără semn de la tastatură și să se verifice dacă acesta este palindrom.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere impare.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se citească apoi n numere întregi de la tastatură și să se afișeze suma numerelor pare introduse.</li>
<li>Refaceți exercițiul anterior în așa fel încât să folosiți instrucțiunea '''continue'''.</li>
<li>Să se citească de la tastatură o serie de numere întregi până la întâlnirea numărului 0. Să se afișeze apoi media aritmetică a acestor numere.</li>
<li>Verificați dacă un număr întreg fără semn introdus de la tastatură este prim.</li>
<li>Să se afișeze cmmdc și cmmmc a două numere întregi fără semn citite de la tastatură.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere prime.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se convertească în baza 2.</li>
<li>Să se realizeze un joc în care un jucător introduce un număr între 1 și 100 de la tastatură, apoi alt jucător încearcă să-l ghicească. Calculatorul va oferi indicii ("prea mic", "prea mare"), până la ghicirea numărului. La final se va afișa numărul de încercări de care a fost nevoie pentru a ghici numărul.</li>
</ol>

PC Laborator 6

2016-11-08T19:39:11Z

Lflueratoru: /* Cuvintele cheie break și continue */

__TOC__
== Obiective ==
La sfârșitul acestui laborator studenții vor fi capabili:
* să înțeleagă funcționarea blocurilor repetitive;
* să conceapă programe care folosesc blocuri repetitive.

== Structura repetitivă ==
Structura repetitivă, cunoscută și sub numele de loop sau buclă, reprezintă o bucată de cod care poate fi executată în mod repetat. Structurile repetitive trebuie sa aibă o condiție de continuare. La fiecare iterație a codului această condiție este verificată, iar în momentul în care condiția devine falsă se oprește execuția buclei și se trece mai departe în program.
Există 2 tipuri de structuri repetitive:
* structuri repetitive cu număr cunoscut de pași;
* structuri repetitive cu număr necunoscut de pași.

=== Structuri repetitive cu număr cunoscut de pași ===
Instrucțiunea ''for'' creează o structură repetitivă cu număr cunoscut de pași. Sintaxa instrucțiunii ''for'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Instrucțiunea ''for'' se parcurge conform schemei următoare:<br/>[[Fișier:For.jpg]]

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x;
for (x = 0; x < 10; x++) {
printf("%d\n", x);
}
return 0;
}
</syntaxhighlight>

=== Structuri repetitive cu număr necunoscut de pași ===
Există două instrucțiuni pentru a crea structuri repetitive cu număr necunoscut de pași:
* instrucțiunea ''while'';
* instrucțiunea ''do..while'';

==== Instrucțiunea ''while'' ====
Instrucțiunea ''while'' verifică înainte de fiecare iterație condiția de intrare: dacă această condiție este îndeplinită se execută codul din corpul instrucțiunii, iar dacă nu se îndeplinește condiția se iese din această buclă. Sintaxa instrucțiunii este următoarea:<br/>
a)
<syntaxhighlight lang="C">
while (condiție)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
while (condiție){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Organigrama instrucțiunii ''while'' se regăsește în imaginea următoare:<br/>[[Fișier:While.jpg]]

'''Exemplu'''<br/>
Ce va afișa următorul cod în urma execuției?
<syntaxhighlight lang="C">
#include<stdio.h>

int main(){
int x = 0;
while (x < 10){
printf("%d\n", x);
x++;
}
return 0;
}
</syntaxhighlight>

==== Instrucțiunea ''do while'' ====
Instrucțiunea ''do while'' verifică după fiecare iterație condiția de continuare. Sintaxa instrucțiunii "do while'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
do{
instrucțiune;
}while (condiție);
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
do{
instrucțiune1;
instrucțiune2;
..............................
}while (condiție);
</syntaxhighlight>

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că sintaxa instrucțiunii ''do while'' este puțin diferită:
* indiferent de numărul de instrucțiuni din cadrul structurii repetitive, se folosesc acoladele;
* după condiția de continuitate se folosește obligatoriu semnul de punctuație <font color="green">''';'''</font> .
</div>
Organigrama instrucțiunii ''do-while'' se regăsește în imaginea următoare:<br/>[[Fișier:Do_while.jpg]]

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că datorită faptului că se verifică abia la sfârșitul structurii condiția de continuitate, orice structură iterativă de tip ''do while'' va fi executată întotdeauna cel puțin o dată.
</div>

'''Exemplu'''<br/>
Ce se va afișa în urma execuției?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x;
x = 0;
do {
printf("Hello, world!\n");
} while (x != 0);
return 0;
}
</syntaxhighlight>

== Cuvintele cheie '''break''' și '''continue''' ==
Pentru structurile repetitive există două cuvinte cheie de mare importanță: '''break''' și '''continue'''.<br/>
'''break''' va ieși din bucla cea mai apropiată indiferent de condițiile de continuare ale acesteia. Utilitatea acestei instrucțiuni apare atunci când trebuie părăsită bucla în anumite circumstanțe.<br/>
'''continue''' oprește iterația curentă, face update contorului (în cazul buclei ''for'') și continuă cu execuția structurii repetitive de la prima instrucțiune. Cu alte cuvinte, ''continue'' ignoră tot ceea ce urmează după el în cadrul buclei și trece la următoarea iterație a buclei.

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int a = 10;
while (a < 20) {
a++;
if (a == 13) {
continue;
}
printf("value of a: %d\n", a);
if (a > 16) {
break;
}
}
return 0;
}
</syntaxhighlight>

==Exerciții==
<ol><li>Să se afișeze pe o linie toate literele în ordine alfabetică, scrise cu majuscule, și pe o altă linie toate literele în ordine invers alfabetică, scrise cu litere mici. Rezolvați exercițiul în 3 moduri (folosind toate tipurile de bucle).</li>
<li>Să se citească un număr întreg fără semn n<20 de la tastatură. Afișați rezultatul operației n!.</li>
<li>Să se citească un număr întreg fără semn de la tastatură și să se verifice dacă acesta este palindrom.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere impare.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se citească apoi n numere întregi de la tastatură și să se afișeze suma numerelor pare introduse.</li>
<li>Refaceți exercițiul anterior în așa fel încât să folosiți instrucțiunea '''continue'''.</li>
<li>Să se citească de la tastatură o serie de numere întregi până la întâlnirea numărului 0. Să se afișeze apoi media aritmetică a acestor numere.</li>
<li>Verificați dacă un număr întreg fără semn introdus de la tastatură este prim.</li>
<li>Să se afișeze cmmdc și cmmmc a două numere întregi fără semn citite de la tastatură.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere prime.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se convertească în baza 2.</li>
<li>Să se realizeze un joc în care un jucător introduce un număr între 1 și 100 de la tastatură, apoi alt jucător încearcă să-l ghicească. Calculatorul va oferi indicii ("prea mic", "prea mare"), până la ghicirea numărului. La final se va afișa numărul de încercări de care a fost nevoie pentru a ghici numărul.</li>
</ol>

PC Laborator 6

2016-11-08T19:37:19Z

Lflueratoru: /* Instrucțiunea do while */

__TOC__
== Obiective ==
La sfârșitul acestui laborator studenții vor fi capabili:
* să înțeleagă funcționarea blocurilor repetitive;
* să conceapă programe care folosesc blocuri repetitive.

== Structura repetitivă ==
Structura repetitivă, cunoscută și sub numele de loop sau buclă, reprezintă o bucată de cod care poate fi executată în mod repetat. Structurile repetitive trebuie sa aibă o condiție de continuare. La fiecare iterație a codului această condiție este verificată, iar în momentul în care condiția devine falsă se oprește execuția buclei și se trece mai departe în program.
Există 2 tipuri de structuri repetitive:
* structuri repetitive cu număr cunoscut de pași;
* structuri repetitive cu număr necunoscut de pași.

=== Structuri repetitive cu număr cunoscut de pași ===
Instrucțiunea ''for'' creează o structură repetitivă cu număr cunoscut de pași. Sintaxa instrucțiunii ''for'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Instrucțiunea ''for'' se parcurge conform schemei următoare:<br/>[[Fișier:For.jpg]]

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x;
for (x = 0; x < 10; x++) {
printf("%d\n", x);
}
return 0;
}
</syntaxhighlight>

=== Structuri repetitive cu număr necunoscut de pași ===
Există două instrucțiuni pentru a crea structuri repetitive cu număr necunoscut de pași:
* instrucțiunea ''while'';
* instrucțiunea ''do..while'';

==== Instrucțiunea ''while'' ====
Instrucțiunea ''while'' verifică înainte de fiecare iterație condiția de intrare: dacă această condiție este îndeplinită se execută codul din corpul instrucțiunii, iar dacă nu se îndeplinește condiția se iese din această buclă. Sintaxa instrucțiunii este următoarea:<br/>
a)
<syntaxhighlight lang="C">
while (condiție)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
while (condiție){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Organigrama instrucțiunii ''while'' se regăsește în imaginea următoare:<br/>[[Fișier:While.jpg]]

'''Exemplu'''<br/>
Ce va afișa următorul cod în urma execuției?
<syntaxhighlight lang="C">
#include<stdio.h>

int main(){
int x = 0;
while (x < 10){
printf("%d\n", x);
x++;
}
return 0;
}
</syntaxhighlight>

==== Instrucțiunea ''do while'' ====
Instrucțiunea ''do while'' verifică după fiecare iterație condiția de continuare. Sintaxa instrucțiunii "do while'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
do{
instrucțiune;
}while (condiție);
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
do{
instrucțiune1;
instrucțiune2;
..............................
}while (condiție);
</syntaxhighlight>

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că sintaxa instrucțiunii ''do while'' este puțin diferită:
* indiferent de numărul de instrucțiuni din cadrul structurii repetitive, se folosesc acoladele;
* după condiția de continuitate se folosește obligatoriu semnul de punctuație <font color="green">''';'''</font> .
</div>
Organigrama instrucțiunii ''do-while'' se regăsește în imaginea următoare:<br/>[[Fișier:Do_while.jpg]]

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că datorită faptului că se verifică abia la sfârșitul structurii condiția de continuitate, orice structură iterativă de tip ''do while'' va fi executată întotdeauna cel puțin o dată.
</div>

'''Exemplu'''<br/>
Ce se va afișa în urma execuției?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x;
x = 0;
do {
printf("Hello, world!\n");
} while (x != 0);
return 0;
}
</syntaxhighlight>

== Cuvintele cheie '''break''' și '''continue''' ==
Pentru structurile repetitive există două cuvinte cheie de mare importanță: '''break''' și '''continue'''.<br/>
'''break''' va ieși din bucla cea mai apropiată indiferent de condițiile de continuare ale acesteia. Utilitatea acestei instrucțiuni apare atunci când trebuie părăsită bucla în anumite circumstanțe.<br/>
'''continue''' oprește iterația curentă, face update contorului (în cazul buclei ''for'') și continuă cu execuția structurii repetitive de la prima instrucțiune. Cu alte cuvinte, ''continue'' ignoră tot ceea ce urmează după el în cadrul buclei și trece la următoarea iterație a buclei.

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main () {
int a = 10;
while( a < 20 ) {
a++;
if( a == 13) {
continue;
}
printf("value of a: %d\n", a);
if( a > 16) {
break;
}
}
return 0;
}
</syntaxhighlight>

==Exerciții==
<ol><li>Să se afișeze pe o linie toate literele în ordine alfabetică, scrise cu majuscule, și pe o altă linie toate literele în ordine invers alfabetică, scrise cu litere mici. Rezolvați exercițiul în 3 moduri (folosind toate tipurile de bucle).</li>
<li>Să se citească un număr întreg fără semn n<20 de la tastatură. Afișați rezultatul operației n!.</li>
<li>Să se citească un număr întreg fără semn de la tastatură și să se verifice dacă acesta este palindrom.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere impare.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se citească apoi n numere întregi de la tastatură și să se afișeze suma numerelor pare introduse.</li>
<li>Refaceți exercițiul anterior în așa fel încât să folosiți instrucțiunea '''continue'''.</li>
<li>Să se citească de la tastatură o serie de numere întregi până la întâlnirea numărului 0. Să se afișeze apoi media aritmetică a acestor numere.</li>
<li>Verificați dacă un număr întreg fără semn introdus de la tastatură este prim.</li>
<li>Să se afișeze cmmdc și cmmmc a două numere întregi fără semn citite de la tastatură.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere prime.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se convertească în baza 2.</li>
<li>Să se realizeze un joc în care un jucător introduce un număr între 1 și 100 de la tastatură, apoi alt jucător încearcă să-l ghicească. Calculatorul va oferi indicii ("prea mic", "prea mare"), până la ghicirea numărului. La final se va afișa numărul de încercări de care a fost nevoie pentru a ghici numărul.</li>
</ol>

PC Laborator 6

2016-11-08T19:34:27Z

Lflueratoru: /* Structuri repetitive cu număr cunoscut de pași */

__TOC__
== Obiective ==
La sfârșitul acestui laborator studenții vor fi capabili:
* să înțeleagă funcționarea blocurilor repetitive;
* să conceapă programe care folosesc blocuri repetitive.

== Structura repetitivă ==
Structura repetitivă, cunoscută și sub numele de loop sau buclă, reprezintă o bucată de cod care poate fi executată în mod repetat. Structurile repetitive trebuie sa aibă o condiție de continuare. La fiecare iterație a codului această condiție este verificată, iar în momentul în care condiția devine falsă se oprește execuția buclei și se trece mai departe în program.
Există 2 tipuri de structuri repetitive:
* structuri repetitive cu număr cunoscut de pași;
* structuri repetitive cu număr necunoscut de pași.

=== Structuri repetitive cu număr cunoscut de pași ===
Instrucțiunea ''for'' creează o structură repetitivă cu număr cunoscut de pași. Sintaxa instrucțiunii ''for'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
for (inițializare contor; condiție logică; modificare contor){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Instrucțiunea ''for'' se parcurge conform schemei următoare:<br/>[[Fișier:For.jpg]]

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int x;
for (x = 0; x < 10; x++) {
printf("%d\n", x);
}
return 0;
}
</syntaxhighlight>

=== Structuri repetitive cu număr necunoscut de pași ===
Există două instrucțiuni pentru a crea structuri repetitive cu număr necunoscut de pași:
* instrucțiunea ''while'';
* instrucțiunea ''do..while'';

==== Instrucțiunea ''while'' ====
Instrucțiunea ''while'' verifică înainte de fiecare iterație condiția de intrare: dacă această condiție este îndeplinită se execută codul din corpul instrucțiunii, iar dacă nu se îndeplinește condiția se iese din această buclă. Sintaxa instrucțiunii este următoarea:<br/>
a)
<syntaxhighlight lang="C">
while (condiție)
instrucțiune;
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
while (condiție){
instrucțiune1;
instrucțiune2;
..............................
}
</syntaxhighlight>
Organigrama instrucțiunii ''while'' se regăsește în imaginea următoare:<br/>[[Fișier:While.jpg]]

'''Exemplu'''<br/>
Ce va afișa următorul cod în urma execuției?
<syntaxhighlight lang="C">
#include<stdio.h>

int main(){
int x = 0;
while (x < 10){
printf("%d\n", x);
x++;
}
return 0;
}
</syntaxhighlight>

==== Instrucțiunea ''do while'' ====
Instrucțiunea ''do while'' verifică după fiecare iterație condiția de continuare. Sintaxa instrucțiunii "do while'' este următoarea:<br/>
a)
<syntaxhighlight lang="C">
do{
instrucțiune;
}while (condiție);
</syntaxhighlight>
b)
<syntaxhighlight lang="C">
do{
instrucțiune1;
instrucțiune2;
..............................
}while (condiție);
</syntaxhighlight>

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că sintaxa instrucțiunii ''do while'' este puțin diferită:
* indiferent de numărul de instrucțiuni din cadrul structurii repetitive, se folosesc acoladele;
* după condiția de continuitate se folosește obligatoriu semnul de punctuație <font color="green">''';'''</font> .
</div>
Organigrama instrucțiunii ''do-while'' se regăsește în imaginea următoare:<br/>[[Fișier:Do_while.jpg]]

<div class="regula">'''<font color="red"> Atenție:</font>''' Se observă că datorită faptului că se verifică abia la sfârșitul structurii condiția de continuitate, orice structură iterativă de tip ''do while'' va fi executată întotdeauna cel puțin o dată.
</div>

'''Exemplu'''<br/>
Ce se va afișa în urma execuției?
<syntaxhighlight lang="C">
#include<stdio.h>

int main(){
int x;
x = 0;
do{
printf( "Hello, world!\n" );
}while (x != 0);
return 0;
}
</syntaxhighlight>

== Cuvintele cheie '''break''' și '''continue''' ==
Pentru structurile repetitive există două cuvinte cheie de mare importanță: '''break''' și '''continue'''.<br/>
'''break''' va ieși din bucla cea mai apropiată indiferent de condițiile de continuare ale acesteia. Utilitatea acestei instrucțiuni apare atunci când trebuie părăsită bucla în anumite circumstanțe.<br/>
'''continue''' oprește iterația curentă, face update contorului (în cazul buclei ''for'') și continuă cu execuția structurii repetitive de la prima instrucțiune. Cu alte cuvinte, ''continue'' ignoră tot ceea ce urmează după el în cadrul buclei și trece la următoarea iterație a buclei.

'''Exemplu'''<br/>
Ce va afisa acest program?
<syntaxhighlight lang="C">
#include <stdio.h>

int main () {
int a = 10;
while( a < 20 ) {
a++;
if( a == 13) {
continue;
}
printf("value of a: %d\n", a);
if( a > 16) {
break;
}
}
return 0;
}
</syntaxhighlight>

==Exerciții==
<ol><li>Să se afișeze pe o linie toate literele în ordine alfabetică, scrise cu majuscule, și pe o altă linie toate literele în ordine invers alfabetică, scrise cu litere mici. Rezolvați exercițiul în 3 moduri (folosind toate tipurile de bucle).</li>
<li>Să se citească un număr întreg fără semn n<20 de la tastatură. Afișați rezultatul operației n!.</li>
<li>Să se citească un număr întreg fără semn de la tastatură și să se verifice dacă acesta este palindrom.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere impare.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se citească apoi n numere întregi de la tastatură și să se afișeze suma numerelor pare introduse.</li>
<li>Refaceți exercițiul anterior în așa fel încât să folosiți instrucțiunea '''continue'''.</li>
<li>Să se citească de la tastatură o serie de numere întregi până la întâlnirea numărului 0. Să se afișeze apoi media aritmetică a acestor numere.</li>
<li>Verificați dacă un număr întreg fără semn introdus de la tastatură este prim.</li>
<li>Să se afișeze cmmdc și cmmmc a două numere întregi fără semn citite de la tastatură.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se afișeze primele n numere prime.</li>
<li>Să se citească un număr întreg fără semn n de la tastatură. Să se convertească în baza 2.</li>
<li>Să se realizeze un joc în care un jucător introduce un număr între 1 și 100 de la tastatură, apoi alt jucător încearcă să-l ghicească. Calculatorul va oferi indicii ("prea mic", "prea mare"), până la ghicirea numărului. La final se va afișa numărul de încercări de care a fost nevoie pentru a ghici numărul.</li>
</ol>

PC Laborator 5

2016-11-02T18:08:10Z

Lflueratoru: /* Exerciții */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
* înțeleagă cum funcționează o structură decizională;
* scrie programe în C folosind construcții decizionale.

== Structura decizională ==

Se întâmplă adesea ca evoluția unui program să depindă de o anumită condiție. Ea poate lua însă diverse forme, rolul programatorului fiind să conducă execuția programului pe calea corectă, ținând cont de acea condiție logică. Apare astfel structura decizionala if, care ramifică evoluția programului în funcție de valoarea de adevăr a condiției testate.

=== Schema logică ===
Prima etapă din parcurgerea unei structuri decizionale de tipul if-else o reprezintă testarea condiției logice. în cazul în care aceasta este evaluată ca adevărată se execută instructiunea1, cea asociată ramurii if. în cazul în care condiția logică este evaluată ca falsă se execută instructiunea2, cea asociată ramurii else. După executarea instrucțiunii asociate, structura if-else se încheie și programul se continuă cu linia următoare blocului decizional.

[[Fișier:structura_decizionala.png]]

=== Sintaxă generală ===
a) <syntaxhighlight lang="C">
if (conditie) instructiune;
</syntaxhighlight>
b)<syntaxhighlight lang="C">
if (conditie) {
instructiune1;
}
else {
instructiune2;
}
</syntaxhighlight>
c) <syntaxhighlight lang="C">
if (conditie1) {
instructiune 1;
}
else if (conditie2) {
instructiune 2;
}
else if (conditie 3) {
instructiune3;
}
................................
else {
instructiune;
}
</syntaxhighlight>

=== Asocierea ramurilor if-else===

<div class="regula"> ''' Observație: ''' în cazul în care un if are mai multe ramuri, un else se asociază celui mai apropiat if.</div>
Această observație ne conduce la următoarele două cazuri:

* dacă nu există blocuri de instrucțiuni, un else este legat de if-ul imediat anterior;
<syntaxhighlight lang="C">
if (a > 5)
if (b > a)
printf ("b este mai mare ca a");
else
printf ("b este mai mic sau egal cu a");

</syntaxhighlight>
* dacă există blocuri de instrucțiuni, un else este legat de ultimul if fără pereche.
<syntaxhighlight lang="C">
if (a > 5) {
if (b > a)
printf ("b este mai mare ca a");
}
else
printf ("a nu este mai mare ca 5");
</syntaxhighlight>

'''Exemplu:'''

Ce va afișa acest program prost indentat?
<syntaxhighlight lang="C">
int number = 4;
double alpha = -1.0;
if (number > 0)
if (alpha > 0)
printf( "Here I am!\n");
else
printf( "No, I’m here!\n");
printf("No, actually, I’m here!\n");
</syntaxhighlight>

== Evaluarea expresiilor logice ==

Am stabilit deja că o condiție logică, prin valoarea ei de adevăr, ramifică evoluția programului.

<div class="regula">'''<font color="red"> Atenție:</font>''' Adevărat în C înseamnă orice rezultat diferit de 0 (nul) al unei evaluări, în timp ce despre fals vorbim când o expresie este evaluată la 0 (nul).
</div>

În C, condiția poate avea mai multe reprezentări, după cum urmează

=== Operandul ===

'''Exemplu:'''
Verificați că un număr citit de la tastatură poate fi numitorul unei fracții.

=== Operația cu operatori relaționali (==, !=, <=, <, >, >=) ===

'''Exemplu:'''
Asociați o valoare variabilei cost în funcție de valoarea variabilei distance după cum urmează:
{| class="wikitable"
|-
! style="text-align: center;" |distance
! style="text-align: center;" |cost
|-
| style="text-align: center;" | Intre 0 si 100
| style="text-align: center;" | 5.50
|-
| style="text-align: center" | Peste 100, dar mai putin de 500
| style="text-align: center;" | 8.00
|-
| style="text-align: center;" | Peste 500, dar nu mai mult de 1000
| style="text-align: center;" | 10.50
|-
| style="text-align: center;" | 1000 sau mai mult
| style="text-align: center;" | 13.00
|}

=== Operația cu operatori logici (&&, ||, !) ===

'''Exemplu:'''
Folosind operatori logici, aduceți următoarea structură decizională la forma cea mai simplă:
<syntaxhighlight lang="C">
if (doesSignificantWork) {
if (makesBreakthrough)
nobelPrizeCandidate = true;
else
nobelPrizeCandidate = false;
}
else if (!doesSignificantWork) {
nobelPrizeCandidate = false;
}
</syntaxhighlight>

<div class="regula"> '''Observație:''' Cuvântul cheie '''bool''', ca și valorile '''true''' și '''false''', au fost introduse în standardul C99, deci dacă doriți să-l folosiți codul trebuie compilat cu <code style="color: green">--std=c99</code> ca argument al compilatorului (gcc).</div>

Pentru a putea lucra cu operatorii logici, este necesar să ne reamintim modul în care aceștia operează.
{| class="wikitable"
! colspan="5" | Tabelul operatorilor logici
|-
| style="text-align: center;" | a
| style="text-align: center;" | b
| style="text-align: center;" | !a
| style="text-align: center" | a && b
| style="text-align: center" | a ll b
|-
| style="text-align: center" | 0
| style="text-align: center;" | 0
| style="text-align: center;" | 1
| style="text-align: center" | 0
| style="text-align: center" | 0
|-
| style="text-align: center" | 0
| style="text-align: center" | 1
| style="text-align: center;" | 1
| style="text-align: center" | 0
| style="text-align: center" | 1
|-
| style="text-align: center" | 1
| style="text-align: center;" | 0
| style="text-align: center;" | 0
| style="text-align: center" | 0
| style="text-align: center" | 1
|-
| style="text-align: center" | 1
| style="text-align: center;" | 1
| style="text-align: center;" | 0
| style="text-align: center" | 1
| style="text-align: center" | 1

|}
<div class="regula"> '''Observație:''' În tabel remarcăm că operatorul logic '''SI ( && )''' întoarce 1 dacă și numai dacă ambele expresii, ''a'' și ''b'' în cazul nostru, întorc o valoare nenulă. în orice alt caz, operatorul '''SI''' întoarce 0. Așadar, pentru a optimiza timpul de execuție a programului, expresia a doua, ''b'' în cazul nostru, va fi evaluată dacă și numai dacă prima expresie, ''a'', a întors o valoare nenulă.
În mod asemănător lucrează și operatorul '''SAU ( || )'''.
</div>
'''Exemplu''': Ce va afișa următorul program?
<syntaxhighlight lang="C">
#include <stdio.h>
int main() {
int a = 5, b = 10;
if (++a || ++b) {
printf("%d %d", a, b);
}
else {
printf("Wayne Rooney");
}
return 0;
}
</syntaxhighlight>

== Alternative la if-else ==

=== Operatorul condițional ( ? : ) ===
Singurul operator ternar din C, operatorul condițional funcționează asemenea unui if cu o singură ramură de tip else if. Sintaxa operatorului condițional este următoarea:
<syntaxhighlight lang="C">
(conditie) ? (expresie1) : (expresie2)
</syntaxhighlight>

Aşadar, blocul decizional
<syntaxhighlight lang="C">
if (a > b)
printf ("a este mai mare decat b");
else
printf ("a este mai mic sau egal cu b");
</syntaxhighlight>
poate fi înlocuit astfel:
<syntaxhighlight lang="C">
printf(a > b ? "a este mai mare decat b" : "a este mai mic sau egal cu b");
//sau
(a > b) ? ( printf ("a este mai mare decat b")) : ( printf ("a este mai mic sau egal cu b"));
</syntaxhighlight>
<div class="regula">'''Observație:''' Deși prima variantă este cea recunoscută ca fiind corectă, remarcăm că și a două variantă se comportă la fel ca prima. Asta se datorează modului în care funcționează operatorul condițional: el cere ca ambele expresii, ''expresie1'' și ''expresie2'', să întoarcă "valori". A doua variantă funcționează deoarece funcția ''printf()'' întoarce întotdeauna o [http://www.tutorialspoint.com/c_standard_library/c_function_printf.htm valoare].
</div>

=== Structura decizională switch-case ===
Această instrucțiune de decizie este similară unui if cu mai multe ramuri de tip else-if. Sintaxa este următoarea:
<syntaxhighlight lang="C">
switch (variabilaTestata) {
case valoare1: instructiune1;
[break;]

case valoare2: instructiune2;
[break;]

case valoare3: instructiune3;
[break;]

.........................................................................
default: instructiune;

}
</syntaxhighlight>
Valorile ''valoare1'', ''valoare2'' etc. sunt proprii tipului de dată întreg, la fel ca ''variabilaTestata''. Ne reamintim însă că întreg nu înseamnă doar variabile de tip '''int''', astfel că ''variabilaTestata'' poate fi de tip '''char'''.
<div class="regula">'''Observație:''' instrucțiunea ''break'' este opțională. Modul care switch-case funcționează este următorul:
<ol type="a">
<li>se compară valoarea variabilei ''variabilaTestata'' cu ''valoarea1'';</li>
<li>dacă cele două sunt egale, se execută ''instructiune1''. Apoi există două cazuri:
<ol type="i">
<li>dacă există ''break;'' structura switch-case se încheie și se sare pe linia urmatoare întregului bloc decizional;</li>
<li>dacă nu există ''break;'' execuția se continuă până se întalnește un ''break;'' sau până când se încheie structura switch-case. Până la acel moment se vor executa toate instrucțiunile întâlnite pe parcurs (''instructiune2, instructiune3'' etc.);</li>
</ol>
</li>
<li>dacă valoarea variabilei ''variabilaTestata'' nu este egală cu niciuna dintre valorile ''valoare1, valoare2'' etc atunci se execută ''instructiune'', asociată etichetei default.</li>
</ol>
</div>

Pentru a verifica echivalența dintre if-else și switch-case, rezolvați folosind ambele structuri decizionale următoarea problemă:

'''Exemplu:'''
Un microbist vrea să afle situația Grupei F de calificare la EURO2016. Astfel, el va introduce o cifră pentru a vedea ce "națională" ocupă acel loc. Folosind următoarea listă, informați-l corect pe suporter.

1. Irlanda de Nord
2. România
3. Ungaria
4. Finlanda
5. Insulele Feroe
6. Grecia

== Exerciții ==

<ol>
<li>Ce va afișa următorul program?
<syntaxhighlight lang="C">
int main() {
int a = 100;
if (a > 10) {
printf("Tiberiu Soare ");
}
else if (a > 20) {
printf("Horia Andreescu ");
}
else if (a > 30) {
printf("Iosif Ion Prunner ");
}
return 0;
}</syntaxhighlight></li>
<li> Ştiind că un student primește 350 lei/lună dacă are media cel puțin 8.50, 450 lei/lună pentru o medie mai mare sau egală cu 9.50 și 600 lei/lună dacă are media cel puțin 9.70, scrieți un program prin care studentul să afle ce bursă urmează să primească (media va fi citită de la tastatură). </li>
<li> Ce va afișa următorul program?
<syntaxhighlight lang="C">
#include <stdio.h>
int main() {
int m = 5, n = 10, q = 20;
if (q / n * m)
printf("Bill Gates ");
else
printf("Amancio Ortega ");
printf("Carlos Slim Helu ");
return 0;
}</syntaxhighlight></li>
<li>Scrieți un program care citește de la tastatură notele unui elev la limba română, matematică și informatică și afișează dacă elevul a promovat sau nu bacalaureatul. </li>
<li>Fie a și b două numere întregi citite de la tastatură. Scrieți un algoritm care să verifice dacă a si b sunt numere consecutive.</li>
<li>Se citesc de la tastatură 3 numere reprezentând lungimea cele 3 laturi ale unui triunghi. Să se afișeze dacă triunghiul este dreptunghic.</li>
<li>Se citește de la tastatură un număr întreg fără semn de 8 biți. Să se afișeze dacă numărul este sau nu un palindrom (dacă are aceeași valoare citit și de la stânga la dreapta si de la dreapta la stanga; de exemplu 101, sau 242).</li>
</ol>

PC Laborator 4

2016-11-02T16:16:32Z

Lflueratoru: /* Exemplu operator AND */

== Obiective ==

Familiarizarea cu noțiunile de bază ale limbajului C: tipuri de date, operatori, dar și folosirea corectă a acestora.

== Tipuri de date ==

Tipurile de date fundamentale ale limbajului C sunt: caractere (char), întregi (int), numere reale
reprezentate în virgulă mobilă cu simplă precizie (float), numere reale reprezentate în virgulă mobilă
cu dublă precizie (double).

{| class="wikitable"
! colspan="3" | Tipuri fundamentale
|-
| style="text-align: center;" |Tip
| style="text-align: center;" |Număr de biți
| style="text-align: center;" |Domeniu
|-
| char
| style="text-align: center;" | 8
| style="text-align: center;" | -128 ... +127
|-
| int
| style="text-align: center" | min. 16
| style="text-align: center;" | -32,768 ... +32,767
|-
| float
| style="text-align: center;" | 32
| style="text-align: center;" | Precizie 6 zecimale
|-
| double
| style="text-align: center;" | 64
| style="text-align: center;" | Precizie 10 zecimale
|}

Tipurile fundamentale pot fi precedate de diferiţi modificatori. Un '''modificator''' se utilizează pentru a adapta cât mai convenabil tipul de bază la situație.

=== Tipuri reale(float,double) și virgulă mobilă ===

<div class="regula">'''<font color="red"> Observatie:</font>''' Principalul dezavantaj al reprezentării în virgulă fixă este faptul că, dacă un număr nu mai încape în spaţiul de biţi rezervat, se pierd cifrele cele mai semnificative.</div>

Un număr este reprezentat în virgulă mobilă printr-un cuvant de n biți conținând semn, mantisă și exponent sub următoarea formă:

[[Fișier:Mantisa.jpg]]

Unde s este bitul de semn al numarului, cu aceeași convenție ca pentru numere in virgulă fixa(s=0 numar pozitiv si s=1 numar negativ),
m este mantisa numarului, reprezentând cifrele semnificative, iar e este exponentul (puterea la care trebuie ridicata o valoare)

Valoarea numarului real reprezentat in virgula mobila este data de expresia:

<math> valoare=(-1)^s*m*(baza)^e </math>

<div class="regula">'''<font color="red"> Observatie:</font>''' Mantisa trebuie să îndeplinească condiția: 1 > m >= 1/baza
</div>

=== Modificatori ===

* '''signed''' (implicit) - tip de dată cu semn, utilizabil excusiv pentru numere întregi, face ca intervalul de definiție să fie între [-2<sup>n-1</sup>:2<sup>n-1</sup>-1]
* '''unsigned''' - tip de dată fără semn, utilizabil excusiv pentru numere întregi, face ca intervalul de definiție să fie între [0:2<sup>n</sup>-1]
* '''long''' - de obicei, dublează domeniul de definiție a unui tip de dată; de exemplu un '''long int''' va avea 64 de biți în loc de 32; este aplicabil doar pentru '''int''' și '''float'''.
* '''short''' - de obicei, înjumătățește domeniul de definiție pentru '''int''', adică rezultatul este un tip de dată pe 16 biți.

{| class="wikitable"
! colspan="3" | Folosirea modificatorilor
|-
| style="text-align: center;" |Tip
| style="text-align: center;" |Număr de biți
| style="text-align: center;" |Domeniu
|-
| unsigned char
| style="text-align: center;" | 8
| style="text-align: center;" | 0 ... 255
|-
| unsigned long int
| style="text-align: center" | 64
| style="text-align: center;" | 0 .. 18,446,744,073,709,551,615
|}

Diferenţa dintre întregii signed şi unsigned constă în interpretarea diferită a bitului semnificativ (adică cel mai din stânga).
Pentru un întreg signed, se va considera bitul semnificativ ca fiind bit de semn.
Dacă acest bit este 0 atunci numărul este pozitiv iar dacă este 1 atunci este negativ.

<div class="regula">'''<font color="red"> Observatie:</font>''' Bit-ul reprezintă cea mai mică unitate de informaţie dintr-un calculator. Denumirea de bit provine de la „binary digit” adică număr binar. Sistemul binar este un sistem de numeraţie unde totul se reprezintă doar cu 1 şi 0.
Simbolul pentru un bit este "b",a nu se confunda cu byte "B" care reprezintă o grupare de 8 biți.</div>

== Tipuri de date de dimensiune fixă în standardul C99 ==

Deoarece există situații când numărul de biți pentru un anumit tip de dată este extrem de important, iar acest număr diferă între procesoare și compilatoare, standardul C99 a introdus următoarele tipuri de date, de dimensiune fixă, care se găsesc în header-ul <code style="color: blue">stdint.h</code>:

{| class="wikitable"
! colspan="3" | Tipuri de dimensiune fixă
|-
| style="text-align: center;" |Tip
| style="text-align: center;" |Numar de biti
| style="text-align: center;" |Domeniu
|-
| int8_t
| style="text-align: center;" | 8
| style="text-align: center;" | -128 .. +127
|-
| uint8_t
| style="text-align: center;" | 8
| style="text-align: center;" | 0 .. 255
|-
| int16_t
| style="text-align: center" | 16
| style="text-align: center;" | -32,768 ... +32,767
|-
| uint16_t
| style="text-align: center" | 16
| style="text-align: center;" | 0 ... +65,535
|-
| int32_t
| style="text-align: center;" | 32
| style="text-align: center;" | -2,147,483,648 .. 2,147,483,647
|-
| uint32_t
| style="text-align: center;" | 32
| style="text-align: center;" | 0 .. 4,294,967,295
|-
| int64_t
| style="text-align: center;" | 64
| style="text-align: center;" | -9,223,372,036,854,775,808 .. 9,223,372,036,854,775,807
|-
| uint64_t
| style="text-align: center;" | 64
| style="text-align: center;" | 0 .. 18,446,744,073,709,551,615
|}

<div class="sfat">'''<font color="blue">Recomandare:</font>''' Utilizați tipurile de date de dimensiune fixă pentru valorile numerice întregi, tipul de date '''char''' pentru a stoca un caracter și tipurile '''float''', '''double''' și '''long double''' pentru valorile numerice fracționare.</div>

== Operatori ==

'''Operatorii aritmetici''':
* + adunarea
* - scăderea
* * înmulţirea
* / împărţirea (rezultatul împărţirii pentru numere reale, câtul împărţirii pentru numere întregi)
* % modulo (restul împărţirii a două numere întregi)
* ++ incrementarea (mărirea unei valori cu o unitate)
* -- decrementarea (micşorarea unei valori cu o unitate)

Operatorii de incrementare/decrementare sunt folosiţi pentru creșterea/micşorarea unei valori cu o unitate.
a++ / ++a - incrementare
a-- / --a - decrementare
De asemenea se pot folosi instrucțiuni de pre sau post incrementare/decrementare.
'''POST-incrementare: x = a++;''' <syntaxhighlight lang="C">
x = a;
a = a + 1;
</syntaxhighlight>

'''PRE-incremenatare: x = ++a;''' <syntaxhighlight lang="C">
a = a + 1;
x = a;
</syntaxhighlight>

'''Operatori relaţionali şi logici''':

* > - mai mare
* >= -mai mare egal
* < -mai mic
* <= -mai mic egal
* == -egal
* != -diferit
* && -si
* || -sau
* ! -negare

=== Exemplu operatori relaționari și logici===

<syntaxhighlight lang="C">

#include <stdio.h>

int main(){
int a = 2, b = 6, c = 0, result;

result = !(a < c) && (a < b) || (b <=c);

printf("result is %d\n", result);
return 0;
}

</syntaxhighlight>
In exemplul de mai sus tineti cont de [http://www.robotics.ucv.ro/flexform/aplicatii/m1/Ion%20Petre%20-%20Utilizarea%20interfetei%20seriale/Cpp/precedenta-oper.html precedenta operatorilor].

'''Operatori la nivel de bit''':

Avem şase operatori la nivel de bit,aceștia se aplică tipurilor char,int,long signed/unsigned,iar rezultatul este un întreg.
Operatorii la nivel de bit sunt următorii.
* & - AND (şi logic)
* | - OR (sau logic)
* ^ - XOR (sau exclusiv)
* << - deplasare la stânga
* >> - deplasare la dreapta
* ~ - negare la nivel de bit

==== Tabele de adevăr ====

{| class="wikitable"
! Operator !! Tabel de adevăr !! Operator !! Tabel de adevăr !! Operator !! Tabel de adevăr
|-
| '''AND'''
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''OR'''
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''XOR'''
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|}

=== Exemplu operator AND ===
Dorim să aflăm valoarea bitului de pe poziția 2 a numarului 20.Pentru a afla valorea acestui bit se poate realiza operația AND (&) între numărul dorit și un alt număr binar care are doar pe poziția dorită valoarea 1 (în cazul nostru poziția 2),astfel dacă rezultatul este diferit de 0 atunci inițial am avut bitul 1, respectiv 0 dacă bitul a fost 0.

<syntaxhighlight lang="C">

#include <stdio.h>

int main() {
int a = 20; /* 1 0 1 0 0 */
int b = 4; /* 0 0 1 0 0 */

if (a & b) {/* 0 0 1 0 0*/
printf("Rezultatul este diferit de 0\n");
} else {
printf("Rezultatul are valoarea 0\n");
}
return 0;
}

</syntaxhighlight>

=== Exemplu operator de deplasare << ===
Operatorii de deplasare (<< şi >>) realizează deplasarea biţilor din operandul stâng cu atâtea
poziţii câte sunt indicate de operandul drept.

<syntaxhighlight lang="C">

int a = 255; /* 0000 0000 1111 1111*/
a = a << 3; /* 0000 0111 1111 1000*/

</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''Deplasarea la stânga (<<) completează la dreapta cu 0, deci biţii din stânga se vor pierde.</div>

=== Exemplu operator de negare ~ ===
Operatorul de negare realizează complementarea biților,biții de 0 se pun 1, iar biții de 1 se pun 0.

<syntaxhighlight lang="C">

int a = 2200; /* 1000 1001 1000*/
a = ~a; /* 0110 0110 0111*/

</syntaxhighlight>

== Exerciții ==

<ol>
<li> Scrieți un program care să citească un număr în virgulă mobilă de la tastatură și să se afișeze, pe linii diferite, în hexazecimal, semnul, mantisa și exponentul. Notă: pentru a putea efectua operații pe biți, operanzii trebuie să fie de tip întreg. Astfel, pentru a interpreta un număr în virgulă mobilă ca secvență de biți, variabila trebuie sa fie de tip int, iar citirea să se facă cu template-ul "%f".</li>
<li> Scrieți un program care să citească de la tastatură un număr întreg fără semn pe 8 biți (în bază 10) și să-l afișeze pe ecran în baza doi, folosind operatori de shiftare și mascare.</li>
<li> Citiți de la tastatură un număr întreg cu semn, pe 32 de biți, apoi negați-l aritmetic și afișați valoarea, fără să folosiți operatorului unar "-" (folosind regulile convenției complement față de 2).</li>
<li> Scrieți un program care să citească un număr întreg pozitiv pe 8 biți de la tastatură, să numere și să afișeze câți biți de 1 și câți biți 0 are reprezentarea lui binară.</li>
<li> Citiți de la tastatură un număr întreg n, calculați și afișați suma numerelor de la 0 la n.</li>
<li> Citiți o valoare de temperatură în grade Celsius, și afișați pe ecran valoarea acelei temperaturi în Kelvin și grade Fahrenheit. </li>
<li> Fie o matrice de 8 linii și 10 coloane, cu elementele numerotate de la 0 (elementul din stânga sus) la 79 (elementul din dreapta jos):
<syntaxhighlight lang="c">
0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
...
70 71 72 73 74 75 76 77 78 79
</syntaxhighlight>
Dându-se de la tastatură un index n între 0 si 79, să se afișeze pe ce linie și pe ce coloană este indexul respectiv.</li>
<li>Dându-se un număr întreg de la tastatură, să se afișeze 0 dacă numărul este impar și 1 dacă este par.</li>
<li>Dându-se un număr întreg de la tastatură, să se afișeze restul împărțirii numărului la 16, folosind doar operații pe biți.</li>
<li><code>dificil</code> Folosind doar operații pe biți (fără construcții condiționale), să se calculeze modulul unui număr întreg pe 32 de biți, introdus de la tastatură.</li>
<ol>

PC Laborator 5

2016-11-01T12:42:16Z

Lflueratoru: /* Asocierea ramurilor if-else */

PC Laborator 5

2016-11-01T12:38:39Z

Lflueratoru: /* Operația cu operatori logici (&&, ||, !) */

PC Laborator 5

2016-11-01T12:37:56Z

Lflueratoru: /* Exerciții */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
* înțeleagă cum funcționează o structură decizională;
* scrie programe în C folosind construcții decizionale.

== Structura decizională ==

Se întâmplă adesea ca evoluția unui program să depindă de o anumită condiție. Ea poate lua însă diverse forme, rolul programatorului fiind să conducă execuția programului pe calea corectă, ținând cont de acea condiție logică. Apare astfel structura decizionala if, care ramifică evoluția programului în funcție de valoarea de adevăr a condiției testate.

=== Schema logică ===
Prima etapă din parcurgerea unei structuri decizionale de tipul if-else o reprezintă testarea condiției logice. în cazul în care aceasta este evaluată ca adevărată se execută instructiunea1, cea asociată ramurii if. în cazul în care condiția logică este evaluată ca falsă se execută instructiunea2, cea asociată ramurii else. După executarea instrucțiunii asociate, structura if-else se încheie și programul se continuă cu linia următoare blocului decizional.

[[Fișier:structura_decizionala.png]]

=== Sintaxă generală ===
a) <syntaxhighlight lang="C">
if (conditie) instructiune;
</syntaxhighlight>
b)<syntaxhighlight lang="C">
if (conditie) {
instructiune1;
}
else {
instructiune2;
}
</syntaxhighlight>
c) <syntaxhighlight lang="C">
if (conditie1) {
instructiune 1;
}
else if (conditie2) {
instructiune 2;
}
else if (conditie 3) {
instructiune3;
}
................................
else {
instructiune;
}
</syntaxhighlight>

=== Asocierea ramurilor if-else===

<div class="regula"> ''' Observație: ''' în cazul în care un if are mai multe ramuri, un else se asociază celui mai apropiat if.</div>
Această observație ne conduce la următoarele două cazuri:

* dacă nu există blocuri de instrucțiuni, un else este legat de if-ul imediat anterior;
<syntaxhighlight lang="C">
if (a > 5)
if (b > a)
printf ("b este mai mare ca a");
else
printf ("b este mai mic sau egal cu a");

</syntaxhighlight>
* dacă există blocuri de instrucțiuni, un else este legat de ultimul if fără pereche.
<syntaxhighlight lang="C">
if (a > 5) {
if (b > a)
printf ("b este mai mare ca a");
}
else
printf ("a nu este mai mare ca 5");
</syntaxhighlight>

'''Exemplu:'''

Ce va afișa acest program prost indentat?
<syntaxhighlight lang="C">
int number = 4;
double alpha = -1.0;
if (number > 0)
if (alpha > 0)
printf( "Here I am!\n");
else
printf( "No, I’m here!\n");
printf("No, actually, I’m here!\n");
</syntaxhighlight>

== Evaluarea expresiilor logice ==

Am stabilit deja că o condiție logică, prin valoarea ei de adevăr, ramifică evoluția programului.

<div class="regula">'''<font color="red"> Atenție:</font>''' Adevărat în C înseamnă orice rezultat diferit de 0 (nul) al unei evaluări, în timp ce despre fals vorbim când o expresie este evaluată la 0 (nul).
</div>

În C, condiția poate avea mai multe reprezentări, după cum urmează

=== Operandul ===

'''Exemplu:'''
Verificați că un număr citit de la tastatură poate fi numitorul unei fracții.

=== Operația cu operatori relaționali (==, !=, <=, <, >, >=) ===

'''Exemplu:'''
Asociați o valoare variabilei cost în funcție de valoarea variabilei distance după cum urmează:
{| class="wikitable"
|-
! style="text-align: center;" |distance
! style="text-align: center;" |cost
|-
| style="text-align: center;" | Intre 0 si 100
| style="text-align: center;" | 5.50
|-
| style="text-align: center" | Peste 100, dar mai putin de 500
| style="text-align: center;" | 8.00
|-
| style="text-align: center;" | Peste 500, dar nu mai mult de 1000
| style="text-align: center;" | 10.50
|-
| style="text-align: center;" | 1000 sau mai mult
| style="text-align: center;" | 13.00
|}

=== Operația cu operatori logici (&&, ||, !) ===

'''Exemplu:'''
Folosind operatori logici, aduceți următoarea structură decizională la forma cea mai simplă:
<syntaxhighlight lang="C">
if (doesSignificantWork) {
if (makesBreakthrough)
nobelPrizeCandidate = true;
else
nobelPrizeCandidate = false;
}
else if (!doesSignificantWork) {
nobelPrizeCandidate = false;
}
</syntaxhighlight>

<div class="regula"> '''Observație:''' Cuvântul cheie '''bool''', ca și valorile '''true''' și '''false''', au fost introduse în standardul C99, deci dacă doriți să-l folosiți codul trebuie compilat cu <code style="color: green">--std=c99</code> ca argument al compilatorului (gcc).</div>

Pentru a putea lucra cu operatorii logici, este necesar să ne reamintim modul în care aceștia operează.
{| class="wikitable"
! colspan="5" | Tabelul operatorilor logici
|-
| style="text-align: center;" | a
| style="text-align: center;" | b
| style="text-align: center;" | !a
| style="text-align: center" | a && b
| style="text-align: center" | a ll b
|-
| style="text-align: center" | 0
| style="text-align: center;" | 0
| style="text-align: center;" | 1
| style="text-align: center" | 0
| style="text-align: center" | 0
|-
| style="text-align: center" | 0
| style="text-align: center" | 1
| style="text-align: center;" | 1
| style="text-align: center" | 0
| style="text-align: center" | 1
|-
| style="text-align: center" | 1
| style="text-align: center;" | 0
| style="text-align: center;" | 0
| style="text-align: center" | 0
| style="text-align: center" | 1
|-
| style="text-align: center" | 1
| style="text-align: center;" | 1
| style="text-align: center;" | 0
| style="text-align: center" | 1
| style="text-align: center" | 1

|}
<div class="regula"> '''Observație:''' În tabel remarcăm că operatorul logic '''SI ( && )''' întoarce 1 dacă și numai dacă ambele expresii, ''a'' și ''b'' în cazul nostru, întorc o valoare nenulă. în orice alt caz, operatorul '''SI''' întoarce 0. Așadar, pentru a optimiza timpul de execuție a programului, expresia a doua, ''b'' în cazul nostru, va fi evaluată dacă și numai dacă prima expresie, ''a'', a întors o valoare nenulă.
În mod asemănător lucrează și operatorul '''SAU ( || )'''.
</div>
'''Exemplu''': Ce va afișa următorul program?
<syntaxhighlight lang="C">
#include <stdio.h>
int main() {
int a = 5, b = 10;
if(++a || ++b) {
printf("%d %d", a, b);
}
else {
printf("Wayne Rooney");
}
return 0;
}
</syntaxhighlight>

== Alternative la if-else ==

=== Operatorul condițional ( ? : ) ===
Singurul operator ternar din C, operatorul condițional funcționează asemenea unui if cu o singură ramură de tip else if. Sintaxa operatorului condițional este următoarea:
<syntaxhighlight lang="C">
(conditie) ? (expresie1) : (expresie2)
</syntaxhighlight>

Aşadar, blocul decizional
<syntaxhighlight lang="C">
if (a > b)
printf ("a este mai mare decat b");
else
printf ("a este mai mic sau egal cu b");
</syntaxhighlight>
poate fi înlocuit astfel:
<syntaxhighlight lang="C">
printf(a > b ? "a este mai mare decat b" : "a este mai mic sau egal cu b");
//sau
(a > b) ? ( printf ("a este mai mare decat b")) : ( printf ("a este mai mic sau egal cu b"));
</syntaxhighlight>
<div class="regula">'''Observație:''' Deși prima variantă este cea recunoscută ca fiind corectă, remarcăm că și a două variantă se comportă la fel ca prima. Asta se datorează modului în care funcționează operatorul condițional: el cere ca ambele expresii, ''expresie1'' și ''expresie2'', să întoarcă "valori". A doua variantă funcționează deoarece funcția ''printf()'' întoarce întotdeauna o [http://www.tutorialspoint.com/c_standard_library/c_function_printf.htm valoare].
</div>

=== Structura decizională switch-case ===
Această instrucțiune de decizie este similară unui if cu mai multe ramuri de tip else-if. Sintaxa este următoarea:
<syntaxhighlight lang="C">
switch (variabilaTestata) {
case valoare1: instructiune1;
[break;]

case valoare2: instructiune2;
[break;]

case valoare3: instructiune3;
[break;]

.........................................................................
default: instructiune;

}
</syntaxhighlight>
Valorile ''valoare1'', ''valoare2'' etc. sunt proprii tipului de dată întreg, la fel ca ''variabilaTestata''. Ne reamintim însă că întreg nu înseamnă doar variabile de tip '''int''', astfel că ''variabilaTestata'' poate fi de tip '''char'''.
<div class="regula">'''Observație:''' instrucțiunea ''break'' este opțională. Modul care switch-case funcționează este următorul:
<ol type="a">
<li>se compară valoarea variabilei ''variabilaTestata'' cu ''valoarea1'';</li>
<li>dacă cele două sunt egale, se execută ''instructiune1''. Apoi există două cazuri:
<ol type="i">
<li>dacă există ''break;'' structura switch-case se încheie și se sare pe linia urmatoare întregului bloc decizional;</li>
<li>dacă nu există ''break;'' execuția se continuă până se întalnește un ''break;'' sau până când se încheie structura switch-case. Până la acel moment se vor executa toate instrucțiunile întâlnite pe parcurs (''instructiune2, instructiune3'' etc.);</li>
</ol>
</li>
<li>dacă valoarea variabilei ''variabilaTestata'' nu este egală cu niciuna dintre valorile ''valoare1, valoare2'' etc atunci se execută ''instructiune'', asociată etichetei default.</li>
</ol>
</div>

Pentru a verifica echivalența dintre if-else și switch-case, rezolvați folosind ambele structuri decizionale următoarea problemă:

'''Exemplu:'''
Un microbist vrea să afle situația Grupei F de calificare la EURO2016. Astfel, el va introduce o cifră pentru a vedea ce "națională" ocupă acel loc. Folosind următoarea listă, informați-l corect pe suporter.

1. Irlanda de Nord
2. România
3. Ungaria
4. Finlanda
5. Insulele Feroe
6. Grecia

== Exerciții ==

<ol>
<li>Ce va afișa următorul program?
<syntaxhighlight lang="C">
int main() {
int a = 100;
if (a > 10) {
printf("Tiberiu Soare ");
}
else if (a > 20) {
printf("Horia Andreescu ");
}
else if (a > 30) {
printf("Iosif Ion Prunner ");
}
return 0;
}</syntaxhighlight></li>
<li> Ştiind că un student primește 350 lei/lună dacă are media cel puțin 8.50, 450 lei/lună pentru o medie mai mare sau egală cu 9.50 și 600 lei/lună dacă are media cel puțin 9.70, scrieți un program prin care studentul să afle ce bursă urmează să primească (media va fi citită de la tastatură). </li>
<li> Ce va afișa următorul program?
<syntaxhighlight lang="C">
#include <stdio.h>
int main() {
int m = 5, n = 10, q = 20;
if (q / n * m)
printf("Bill Gates ");
else
printf("Amancio Ortega ");
printf("Carlos Slim Helu ");
return 0;
}</syntaxhighlight></li>
<li>Scrieți un program care citește de la tastatură notele unui elev la limba română, matematică și informatică și afișează dacă elevul a promovat sau nu bacalaureatul. </li>
<li>Fie a și b două numere întregi citite de la tastatură. Scrieți un algoritm care să verifice dacă a si b sunt numere consecutive.</li>
<li>Se citesc de la tastatură 3 numere reprezentând lungimea cele 3 laturi ale unui triunghi. Să se afișeze dacă triunghiul este dreptunghic.</li>
<li>Se citește de la tastatură un număr întreg fără semn de 8 biți. Să se afișeze dacă numărul este sau nu un palindrom (dacă are aceeași valoare citit și de la stânga la dreapta si de la dreapta la stanga; de exemplu 101, sau 242).</li>
</ol>

PC Laborator 5

2016-11-01T12:34:02Z

Lflueratoru: /* Operatorul condițional ( ? : ) */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
* înțeleagă cum funcționează o structură decizională;
* scrie programe în C folosind construcții decizionale.

== Structura decizională ==

Se întâmplă adesea ca evoluția unui program să depindă de o anumită condiție. Ea poate lua însă diverse forme, rolul programatorului fiind să conducă execuția programului pe calea corectă, ținând cont de acea condiție logică. Apare astfel structura decizionala if, care ramifică evoluția programului în funcție de valoarea de adevăr a condiției testate.

=== Schema logică ===
Prima etapă din parcurgerea unei structuri decizionale de tipul if-else o reprezintă testarea condiției logice. în cazul în care aceasta este evaluată ca adevărată se execută instructiunea1, cea asociată ramurii if. în cazul în care condiția logică este evaluată ca falsă se execută instructiunea2, cea asociată ramurii else. După executarea instrucțiunii asociate, structura if-else se încheie și programul se continuă cu linia următoare blocului decizional.

[[Fișier:structura_decizionala.png]]

=== Sintaxă generală ===
a) <syntaxhighlight lang="C">
if (conditie) instructiune;
</syntaxhighlight>
b)<syntaxhighlight lang="C">
if (conditie) {
instructiune1;
}
else {
instructiune2;
}
</syntaxhighlight>
c) <syntaxhighlight lang="C">
if (conditie1) {
instructiune 1;
}
else if (conditie2) {
instructiune 2;
}
else if (conditie 3) {
instructiune3;
}
................................
else {
instructiune;
}
</syntaxhighlight>

=== Asocierea ramurilor if-else===

<div class="regula"> ''' Observație: ''' în cazul în care un if are mai multe ramuri, un else se asociază celui mai apropiat if.</div>
Această observație ne conduce la următoarele două cazuri:

* dacă nu există blocuri de instrucțiuni, un else este legat de if-ul imediat anterior;
<syntaxhighlight lang="C">
if (a > 5)
if (b > a)
printf ("b este mai mare ca a");
else
printf ("b este mai mic sau egal cu a");

</syntaxhighlight>
* dacă există blocuri de instrucțiuni, un else este legat de ultimul if fără pereche.
<syntaxhighlight lang="C">
if (a > 5) {
if (b > a)
printf ("b este mai mare ca a");
}
else
printf ("a nu este mai mare ca 5");
</syntaxhighlight>

'''Exemplu:'''

Ce va afișa acest program prost indentat?
<syntaxhighlight lang="C">
int number = 4;
double alpha = -1.0;
if (number > 0)
if (alpha > 0)
printf( "Here I am!\n");
else
printf( "No, I’m here!\n");
printf("No, actually, I’m here!\n");
</syntaxhighlight>

== Evaluarea expresiilor logice ==

Am stabilit deja că o condiție logică, prin valoarea ei de adevăr, ramifică evoluția programului.

<div class="regula">'''<font color="red"> Atenție:</font>''' Adevărat în C înseamnă orice rezultat diferit de 0 (nul) al unei evaluări, în timp ce despre fals vorbim când o expresie este evaluată la 0 (nul).
</div>

În C, condiția poate avea mai multe reprezentări, după cum urmează

=== Operandul ===

'''Exemplu:'''
Verificați că un număr citit de la tastatură poate fi numitorul unei fracții.

=== Operația cu operatori relaționali (==, !=, <=, <, >, >=) ===

'''Exemplu:'''
Asociați o valoare variabilei cost în funcție de valoarea variabilei distance după cum urmează:
{| class="wikitable"
|-
! style="text-align: center;" |distance
! style="text-align: center;" |cost
|-
| style="text-align: center;" | Intre 0 si 100
| style="text-align: center;" | 5.50
|-
| style="text-align: center" | Peste 100, dar mai putin de 500
| style="text-align: center;" | 8.00
|-
| style="text-align: center;" | Peste 500, dar nu mai mult de 1000
| style="text-align: center;" | 10.50
|-
| style="text-align: center;" | 1000 sau mai mult
| style="text-align: center;" | 13.00
|}

=== Operația cu operatori logici (&&, ||, !) ===

'''Exemplu:'''
Folosind operatori logici, aduceți următoarea structură decizională la forma cea mai simplă:
<syntaxhighlight lang="C">
if (doesSignificantWork) {
if (makesBreakthrough)
nobelPrizeCandidate = true;
else
nobelPrizeCandidate = false;
}
else if (!doesSignificantWork) {
nobelPrizeCandidate = false;
}
</syntaxhighlight>

<div class="regula"> '''Observație:''' Cuvântul cheie '''bool''', ca și valorile '''true''' și '''false''', au fost introduse în standardul C99, deci dacă doriți să-l folosiți codul trebuie compilat cu <code style="color: green">--std=c99</code> ca argument al compilatorului (gcc).</div>

Pentru a putea lucra cu operatorii logici, este necesar să ne reamintim modul în care aceștia operează.
{| class="wikitable"
! colspan="5" | Tabelul operatorilor logici
|-
| style="text-align: center;" | a
| style="text-align: center;" | b
| style="text-align: center;" | !a
| style="text-align: center" | a && b
| style="text-align: center" | a ll b
|-
| style="text-align: center" | 0
| style="text-align: center;" | 0
| style="text-align: center;" | 1
| style="text-align: center" | 0
| style="text-align: center" | 0
|-
| style="text-align: center" | 0
| style="text-align: center" | 1
| style="text-align: center;" | 1
| style="text-align: center" | 0
| style="text-align: center" | 1
|-
| style="text-align: center" | 1
| style="text-align: center;" | 0
| style="text-align: center;" | 0
| style="text-align: center" | 0
| style="text-align: center" | 1
|-
| style="text-align: center" | 1
| style="text-align: center;" | 1
| style="text-align: center;" | 0
| style="text-align: center" | 1
| style="text-align: center" | 1

|}
<div class="regula"> '''Observație:''' În tabel remarcăm că operatorul logic '''SI ( && )''' întoarce 1 dacă și numai dacă ambele expresii, ''a'' și ''b'' în cazul nostru, întorc o valoare nenulă. în orice alt caz, operatorul '''SI''' întoarce 0. Așadar, pentru a optimiza timpul de execuție a programului, expresia a doua, ''b'' în cazul nostru, va fi evaluată dacă și numai dacă prima expresie, ''a'', a întors o valoare nenulă.
În mod asemănător lucrează și operatorul '''SAU ( || )'''.
</div>
'''Exemplu''': Ce va afișa următorul program?
<syntaxhighlight lang="C">
#include <stdio.h>
int main() {
int a = 5, b = 10;
if(++a || ++b) {
printf("%d %d", a, b);
}
else {
printf("Wayne Rooney");
}
return 0;
}
</syntaxhighlight>

== Alternative la if-else ==

=== Operatorul condițional ( ? : ) ===
Singurul operator ternar din C, operatorul condițional funcționează asemenea unui if cu o singură ramură de tip else if. Sintaxa operatorului condițional este următoarea:
<syntaxhighlight lang="C">
(conditie) ? (expresie1) : (expresie2)
</syntaxhighlight>

Aşadar, blocul decizional
<syntaxhighlight lang="C">
if (a > b)
printf ("a este mai mare decat b");
else
printf ("a este mai mic sau egal cu b");
</syntaxhighlight>
poate fi înlocuit astfel:
<syntaxhighlight lang="C">
printf(a > b ? "a este mai mare decat b" : "a este mai mic sau egal cu b");
//sau
(a > b) ? ( printf ("a este mai mare decat b")) : ( printf ("a este mai mic sau egal cu b"));
</syntaxhighlight>
<div class="regula">'''Observație:''' Deși prima variantă este cea recunoscută ca fiind corectă, remarcăm că și a două variantă se comportă la fel ca prima. Asta se datorează modului în care funcționează operatorul condițional: el cere ca ambele expresii, ''expresie1'' și ''expresie2'', să întoarcă "valori". A doua variantă funcționează deoarece funcția ''printf()'' întoarce întotdeauna o [http://www.tutorialspoint.com/c_standard_library/c_function_printf.htm valoare].
</div>

=== Structura decizională switch-case ===
Această instrucțiune de decizie este similară unui if cu mai multe ramuri de tip else-if. Sintaxa este următoarea:
<syntaxhighlight lang="C">
switch (variabilaTestata) {
case valoare1: instructiune1;
[break;]

case valoare2: instructiune2;
[break;]

case valoare3: instructiune3;
[break;]

.........................................................................
default: instructiune;

}
</syntaxhighlight>
Valorile ''valoare1'', ''valoare2'' etc. sunt proprii tipului de dată întreg, la fel ca ''variabilaTestata''. Ne reamintim însă că întreg nu înseamnă doar variabile de tip '''int''', astfel că ''variabilaTestata'' poate fi de tip '''char'''.
<div class="regula">'''Observație:''' instrucțiunea ''break'' este opțională. Modul care switch-case funcționează este următorul:
<ol type="a">
<li>se compară valoarea variabilei ''variabilaTestata'' cu ''valoarea1'';</li>
<li>dacă cele două sunt egale, se execută ''instructiune1''. Apoi există două cazuri:
<ol type="i">
<li>dacă există ''break;'' structura switch-case se încheie și se sare pe linia urmatoare întregului bloc decizional;</li>
<li>dacă nu există ''break;'' execuția se continuă până se întalnește un ''break;'' sau până când se încheie structura switch-case. Până la acel moment se vor executa toate instrucțiunile întâlnite pe parcurs (''instructiune2, instructiune3'' etc.);</li>
</ol>
</li>
<li>dacă valoarea variabilei ''variabilaTestata'' nu este egală cu niciuna dintre valorile ''valoare1, valoare2'' etc atunci se execută ''instructiune'', asociată etichetei default.</li>
</ol>
</div>

Pentru a verifica echivalența dintre if-else și switch-case, rezolvați folosind ambele structuri decizionale următoarea problemă:

'''Exemplu:'''
Un microbist vrea să afle situația Grupei F de calificare la EURO2016. Astfel, el va introduce o cifră pentru a vedea ce "națională" ocupă acel loc. Folosind următoarea listă, informați-l corect pe suporter.

1. Irlanda de Nord
2. România
3. Ungaria
4. Finlanda
5. Insulele Feroe
6. Grecia

== Exerciții ==

<ol>
<li>Ce va afișa următorul program?
<syntaxhighlight lang="C">
int main(){
int a=100;
if(a>10) {
printf("Tiberiu Soare ");
}
else if(a>20) {
printf("Horia Andreescu ");
}
else if(a>30) {
printf("Iosif Ion Prunner ");
}
return 0;
}</syntaxhighlight></li>
<li> Ştiind că un student primește 350 lei/lună dacă are media cel puțin 8.50, 450 lei/lună pentru o medie mai mare sau egală cu 9.50 și 600 lei/lună dacă are media cel puțin 9.70, scrieți un program prin care studentul să afle ce bursă urmează să primească (media va fi citită de la tastatură). </li>
<li> Ce va afișa următorul program?
<syntaxhighlight lang="C">
#include<stdio.h>
int main(){
int m=5,n=10,q=20;
if(q/n*m)
printf("Bill Gates ");
else
printf("Amancio Ortega ");
printf("Carlos Slim Helu ");
return 0;
}</syntaxhighlight></li>
<li>Scrieți un program care citește de la tastatură notele unui elev la limba română, matematică și informatică și afișează dacă elevul a promovat sau nu bacalaureatul. </li>
<li>Fie a și b două numere întregi citite de la tastatură. Scrieți un algoritm care să verifice dacă a si b sunt numere consecutive.</li>
<li>Se citesc de la tastatură 3 numere reprezentând lungimea cele 3 laturi ale unui triunghi. Să se afișeze dacă triunghiul este dreptunghic.</li>
<li>Se citește de la tastatură un număr întreg fără semn de 8 biți. Să se afișeze dacă numărul este sau nu un palindrom (dacă are aceeași valoare citit și de la stânga la dreapta si de la dreapta la stanga; de exemplu 101, sau 242).</li>
</ol>

PC Laborator 5

2016-11-01T12:33:11Z

Lflueratoru: /* Operația cu operatori logici (&&, ||, !) */

== Obiective ==

în urma acestui laborator, studentul va fi capabil să:
* înțeleagă cum funcționează o structură decizională;
* scrie programe în C folosind construcții decizionale.

== Structura decizională ==

Se întâmplă adesea ca evoluția unui program să depindă de o anumită condiție. Ea poate lua însă diverse forme, rolul programatorului fiind să conducă execuția programului pe calea corectă, ținând cont de acea condiție logică. Apare astfel structura decizionala if, care ramifică evoluția programului în funcție de valoarea de adevăr a condiției testate.

=== Schema logică ===
Prima etapă din parcurgerea unei structuri decizionale de tipul if-else o reprezintă testarea condiției logice. în cazul în care aceasta este evaluată ca adevărată se execută instructiunea1, cea asociată ramurii if. în cazul în care condiția logică este evaluată ca falsă se execută instructiunea2, cea asociată ramurii else. După executarea instrucțiunii asociate, structura if-else se încheie și programul se continuă cu linia următoare blocului decizional.

[[Fișier:structura_decizionala.png]]

=== Sintaxă generală ===
a) <syntaxhighlight lang="C">
if (conditie) instructiune;
</syntaxhighlight>
b)<syntaxhighlight lang="C">
if (conditie) {
instructiune1;
}
else {
instructiune2;
}
</syntaxhighlight>
c) <syntaxhighlight lang="C">
if (conditie1) {
instructiune 1;
}
else if (conditie2) {
instructiune 2;
}
else if (conditie 3) {
instructiune3;
}
................................
else {
instructiune;
}
</syntaxhighlight>

=== Asocierea ramurilor if-else===

<div class="regula"> ''' Observație: ''' în cazul în care un if are mai multe ramuri, un else se asociază celui mai apropiat if.</div>
Această observație ne conduce la următoarele două cazuri:

* dacă nu există blocuri de instrucțiuni, un else este legat de if-ul imediat anterior;
<syntaxhighlight lang="C">
if (a > 5)
if (b > a)
printf ("b este mai mare ca a");
else
printf ("b este mai mic sau egal cu a");

</syntaxhighlight>
* dacă există blocuri de instrucțiuni, un else este legat de ultimul if fără pereche.
<syntaxhighlight lang="C">
if (a > 5) {
if (b > a)
printf ("b este mai mare ca a");
}
else
printf ("a nu este mai mare ca 5");
</syntaxhighlight>

'''Exemplu:'''

Ce va afișa acest program prost indentat?
<syntaxhighlight lang="C">
int number = 4;
double alpha = -1.0;
if (number > 0)
if (alpha > 0)
printf( "Here I am!\n");
else
printf( "No, I’m here!\n");
printf("No, actually, I’m here!\n");
</syntaxhighlight>

== Evaluarea expresiilor logice ==

Am stabilit deja că o condiție logică, prin valoarea ei de adevăr, ramifică evoluția programului.

<div class="regula">'''<font color="red"> Atenție:</font>''' Adevărat în C înseamnă orice rezultat diferit de 0 (nul) al unei evaluări, în timp ce despre fals vorbim când o expresie este evaluată la 0 (nul).
</div>

În C, condiția poate avea mai multe reprezentări, după cum urmează

=== Operandul ===

'''Exemplu:'''
Verificați că un număr citit de la tastatură poate fi numitorul unei fracții.

=== Operația cu operatori relaționali (==, !=, <=, <, >, >=) ===

'''Exemplu:'''
Asociați o valoare variabilei cost în funcție de valoarea variabilei distance după cum urmează:
{| class="wikitable"
|-
! style="text-align: center;" |distance
! style="text-align: center;" |cost
|-
| style="text-align: center;" | Intre 0 si 100
| style="text-align: center;" | 5.50
|-
| style="text-align: center" | Peste 100, dar mai putin de 500
| style="text-align: center;" | 8.00
|-
| style="text-align: center;" | Peste 500, dar nu mai mult de 1000
| style="text-align: center;" | 10.50
|-
| style="text-align: center;" | 1000 sau mai mult
| style="text-align: center;" | 13.00
|}

=== Operația cu operatori logici (&&, ||, !) ===

'''Exemplu:'''
Folosind operatori logici, aduceți următoarea structură decizională la forma cea mai simplă:
<syntaxhighlight lang="C">
if (doesSignificantWork) {
if (makesBreakthrough)
nobelPrizeCandidate = true;
else
nobelPrizeCandidate = false;
}
else if (!doesSignificantWork) {
nobelPrizeCandidate = false;
}
</syntaxhighlight>

<div class="regula"> '''Observație:''' Cuvântul cheie '''bool''', ca și valorile '''true''' și '''false''', au fost introduse în standardul C99, deci dacă doriți să-l folosiți codul trebuie compilat cu <code style="color: green">--std=c99</code> ca argument al compilatorului (gcc).</div>

Pentru a putea lucra cu operatorii logici, este necesar să ne reamintim modul în care aceștia operează.
{| class="wikitable"
! colspan="5" | Tabelul operatorilor logici
|-
| style="text-align: center;" | a
| style="text-align: center;" | b
| style="text-align: center;" | !a
| style="text-align: center" | a && b
| style="text-align: center" | a ll b
|-
| style="text-align: center" | 0
| style="text-align: center;" | 0
| style="text-align: center;" | 1
| style="text-align: center" | 0
| style="text-align: center" | 0
|-
| style="text-align: center" | 0
| style="text-align: center" | 1
| style="text-align: center;" | 1
| style="text-align: center" | 0
| style="text-align: center" | 1
|-
| style="text-align: center" | 1
| style="text-align: center;" | 0
| style="text-align: center;" | 0
| style="text-align: center" | 0
| style="text-align: center" | 1
|-
| style="text-align: center" | 1
| style="text-align: center;" | 1
| style="text-align: center;" | 0
| style="text-align: center" | 1
| style="text-align: center" | 1

|}
<div class="regula"> '''Observație:''' În tabel remarcăm că operatorul logic '''SI ( && )''' întoarce 1 dacă și numai dacă ambele expresii, ''a'' și ''b'' în cazul nostru, întorc o valoare nenulă. în orice alt caz, operatorul '''SI''' întoarce 0. Așadar, pentru a optimiza timpul de execuție a programului, expresia a doua, ''b'' în cazul nostru, va fi evaluată dacă și numai dacă prima expresie, ''a'', a întors o valoare nenulă.
În mod asemănător lucrează și operatorul '''SAU ( || )'''.
</div>
'''Exemplu''': Ce va afișa următorul program?
<syntaxhighlight lang="C">
#include <stdio.h>
int main() {
int a = 5, b = 10;
if(++a || ++b) {
printf("%d %d", a, b);
}
else {
printf("Wayne Rooney");
}
return 0;
}
</syntaxhighlight>

== Alternative la if-else ==

=== Operatorul condițional ( ? : ) ===
Singurul operator ternar din C, operatorul condițional funcționează asemenea unui if cu o singură ramură de tip else if. Sintaxa operatorului condițional este următoarea:
<syntaxhighlight lang="C">
(conditie) ? (expresie1) : (expresie2)
</syntaxhighlight>

Aşadar, blocul decizional
<syntaxhighlight lang="C">
if (a>b)
printf ("a este mai mare decat b");
else
printf ("a este mai mic sau egal cu b");
</syntaxhighlight>
poate fi înlocuit astfel:
<syntaxhighlight lang="C">
printf(a > b ? "a este mai mare decat b" : "a este mai mic sau egal cu b");
//sau
(a>b) ? ( printf ("a este mai mare decat b")) : ( printf ("a este mai mic sau egal cu b"));
</syntaxhighlight>
<div class="regula">'''Observație:''' Deși prima variantă este cea recunoscută ca fiind corectă, remarcăm că și a două variantă se comportă la fel ca prima. Asta se datorează modului în care funcționează operatorul condițional: el cere ca ambele expresii, ''expresie1'' și ''expresie2'', să întoarcă "valori". A doua variantă funcționează deoarece funcția ''printf()'' întoarce întotdeauna o [http://www.tutorialspoint.com/c_standard_library/c_function_printf.htm valoare].
</div>

=== Structura decizională switch-case ===
Această instrucțiune de decizie este similară unui if cu mai multe ramuri de tip else-if. Sintaxa este următoarea:
<syntaxhighlight lang="C">
switch (variabilaTestata) {
case valoare1: instructiune1;
[break;]

case valoare2: instructiune2;
[break;]

case valoare3: instructiune3;
[break;]

.........................................................................
default: instructiune;

}
</syntaxhighlight>
Valorile ''valoare1'', ''valoare2'' etc. sunt proprii tipului de dată întreg, la fel ca ''variabilaTestata''. Ne reamintim însă că întreg nu înseamnă doar variabile de tip '''int''', astfel că ''variabilaTestata'' poate fi de tip '''char'''.
<div class="regula">'''Observație:''' instrucțiunea ''break'' este opțională. Modul care switch-case funcționează este următorul:
<ol type="a">
<li>se compară valoarea variabilei ''variabilaTestata'' cu ''valoarea1'';</li>
<li>dacă cele două sunt egale, se execută ''instructiune1''. Apoi există două cazuri:
<ol type="i">
<li>dacă există ''break;'' structura switch-case se încheie și se sare pe linia urmatoare întregului bloc decizional;</li>
<li>dacă nu există ''break;'' execuția se continuă până se întalnește un ''break;'' sau până când se încheie structura switch-case. Până la acel moment se vor executa toate instrucțiunile întâlnite pe parcurs (''instructiune2, instructiune3'' etc.);</li>
</ol>
</li>
<li>dacă valoarea variabilei ''variabilaTestata'' nu este egală cu niciuna dintre valorile ''valoare1, valoare2'' etc atunci se execută ''instructiune'', asociată etichetei default.</li>
</ol>
</div>

Pentru a verifica echivalența dintre if-else și switch-case, rezolvați folosind ambele structuri decizionale următoarea problemă:

'''Exemplu:'''
Un microbist vrea să afle situația Grupei F de calificare la EURO2016. Astfel, el va introduce o cifră pentru a vedea ce "națională" ocupă acel loc. Folosind următoarea listă, informați-l corect pe suporter.

1. Irlanda de Nord
2. România
3. Ungaria
4. Finlanda
5. Insulele Feroe
6. Grecia

== Exerciții ==

<ol>
<li>Ce va afișa următorul program?
<syntaxhighlight lang="C">
int main(){
int a=100;
if(a>10) {
printf("Tiberiu Soare ");
}
else if(a>20) {
printf("Horia Andreescu ");
}
else if(a>30) {
printf("Iosif Ion Prunner ");
}
return 0;
}</syntaxhighlight></li>
<li> Ştiind că un student primește 350 lei/lună dacă are media cel puțin 8.50, 450 lei/lună pentru o medie mai mare sau egală cu 9.50 și 600 lei/lună dacă are media cel puțin 9.70, scrieți un program prin care studentul să afle ce bursă urmează să primească (media va fi citită de la tastatură). </li>
<li> Ce va afișa următorul program?
<syntaxhighlight lang="C">
#include<stdio.h>
int main(){
int m=5,n=10,q=20;
if(q/n*m)
printf("Bill Gates ");
else
printf("Amancio Ortega ");
printf("Carlos Slim Helu ");
return 0;
}</syntaxhighlight></li>
<li>Scrieți un program care citește de la tastatură notele unui elev la limba română, matematică și informatică și afișează dacă elevul a promovat sau nu bacalaureatul. </li>
<li>Fie a și b două numere întregi citite de la tastatură. Scrieți un algoritm care să verifice dacă a si b sunt numere consecutive.</li>
<li>Se citesc de la tastatură 3 numere reprezentând lungimea cele 3 laturi ale unui triunghi. Să se afișeze dacă triunghiul este dreptunghic.</li>
<li>Se citește de la tastatură un număr întreg fără semn de 8 biți. Să se afișeze dacă numărul este sau nu un palindrom (dacă are aceeași valoare citit și de la stânga la dreapta si de la dreapta la stanga; de exemplu 101, sau 242).</li>
</ol>

PC Laborator 4

2016-10-26T15:33:39Z

Lflueratoru: /* Tipuri de date */

== Obiective ==

Familiarizarea cu noțiunile de bază ale limbajului C: tipuri de date, operatori, dar și folosirea corectă a acestora.

== Tipuri de date ==

Tipurile de date fundamentale ale limbajului C sunt: caractere (char), întregi (int), numere reale
reprezentate în virgulă mobilă cu simplă precizie (float), numere reale reprezentate în virgulă mobilă
cu dublă precizie (double).

{| class="wikitable"
! colspan="3" | Tipuri fundamentale
|-
| style="text-align: center;" |Tip
| style="text-align: center;" |Număr de biți
| style="text-align: center;" |Domeniu
|-
| char
| style="text-align: center;" | 8
| style="text-align: center;" | -128 ... +127
|-
| int
| style="text-align: center" | min. 16
| style="text-align: center;" | -32,768 ... +32,767
|-
| float
| style="text-align: center;" | 32
| style="text-align: center;" | Precizie 6 zecimale
|-
| double
| style="text-align: center;" | 64
| style="text-align: center;" | Precizie 10 zecimale
|}

Tipurile fundamentale pot fi precedate de diferiţi modificatori. Un '''modificator''' se utilizează pentru a adapta cât mai convenabil tipul de bază la situație.

=== Tipuri reale(float,double) și virgulă mobilă ===

<div class="regula">'''<font color="red"> Observatie:</font>''' Principalul dezavantaj al reprezentării în virgulă fixă este faptul că, dacă un număr nu mai încape în spaţiul de biţi rezervat, se pierd cifrele cele mai semnificative.</div>

Un număr este reprezentat în virgulă mobilă printr-un cuvant de n biți conținând semn, mantisă și exponent sub următoarea formă:

[[Fișier:Mantisa.jpg]]

Unde s este bitul de semn al numarului, cu aceeași convenție ca pentru numere in virgulă fixa(s=0 numar pozitiv si s=1 numar negativ),
m este mantisa numarului, reprezentând cifrele semnificative, iar e este exponentul (puterea la care trebuie ridicata o valoare)

Valoarea numarului real reprezentat in virgula mobila este data de expresia:

<math> valoare=(-1)^s*m*(baza)^e </math>

<div class="regula">'''<font color="red"> Observatie:</font>''' Mantisa trebuie să îndeplinească condiția: 1 > m >= 1/baza
</div>

=== Modificatori ===

* '''signed''' (implicit) - tip de dată cu semn, utilizabil excusiv pentru numere întregi, face ca intervalul de definiție să fie între [-2<sup>n-1</sup>:2<sup>n-1</sup>-1]
* '''unsigned''' - tip de dată fără semn, utilizabil excusiv pentru numere întregi, face ca intervalul de definiție să fie între [0:2<sup>n</sup>-1]
* '''long''' - de obicei, dublează domeniul de definiție a unui tip de dată; de exemplu un '''long int''' va avea 64 de biți în loc de 32; este aplicabil doar pentru '''int''' și '''float'''.
* '''short''' - de obicei, înjumătățește domeniul de definiție pentru '''int''', adică rezultatul este un tip de dată pe 16 biți.

{| class="wikitable"
! colspan="3" | Folosirea modificatorilor
|-
| style="text-align: center;" |Tip
| style="text-align: center;" |Număr de biți
| style="text-align: center;" |Domeniu
|-
| unsigned char
| style="text-align: center;" | 8
| style="text-align: center;" | 0 ... 255
|-
| unsigned long int
| style="text-align: center" | 64
| style="text-align: center;" | 0 .. 18,446,744,073,709,551,615
|}

Diferenţa dintre întregii signed şi unsigned constă în interpretarea diferită a bitului semnificativ (adică cel mai din stânga).
Pentru un întreg signed, se va considera bitul semnificativ ca fiind bit de semn.
Dacă acest bit este 0 atunci numărul este pozitiv iar dacă este 1 atunci este negativ.

<div class="regula">'''<font color="red"> Observatie:</font>''' Bit-ul reprezintă cea mai mică unitate de informaţie dintr-un calculator. Denumirea de bit provine de la „binary digit” adică număr binar. Sistemul binar este un sistem de numeraţie unde totul se reprezintă doar cu 1 şi 0.
Simbolul pentru un bit este "b",a nu se confunda cu byte "B" care reprezintă o grupare de 8 biți.</div>

== Tipuri de date de dimensiune fixă în standardul C99 ==

Deoarece există situații când numărul de biți pentru un anumit tip de dată este extrem de important, iar acest număr diferă între procesoare și compilatoare, standardul C99 a introdus următoarele tipuri de date, de dimensiune fixă, care se găsesc în header-ul <code style="color: blue">stdint.h</code>:

{| class="wikitable"
! colspan="3" | Tipuri de dimensiune fixă
|-
| style="text-align: center;" |Tip
| style="text-align: center;" |Numar de biti
| style="text-align: center;" |Domeniu
|-
| int8_t
| style="text-align: center;" | 8
| style="text-align: center;" | -128 .. +127
|-
| uint8_t
| style="text-align: center;" | 8
| style="text-align: center;" | 0 .. 255
|-
| int16_t
| style="text-align: center" | 16
| style="text-align: center;" | -32,768 ... +32,767
|-
| uint16_t
| style="text-align: center" | 16
| style="text-align: center;" | 0 ... +65,535
|-
| int32_t
| style="text-align: center;" | 32
| style="text-align: center;" | -2,147,483,648 .. 2,147,483,647
|-
| uint32_t
| style="text-align: center;" | 32
| style="text-align: center;" | 0 .. 4,294,967,295
|-
| int64_t
| style="text-align: center;" | 64
| style="text-align: center;" | -9,223,372,036,854,775,808 .. 9,223,372,036,854,775,807
|-
| uint64_t
| style="text-align: center;" | 64
| style="text-align: center;" | 0 .. 18,446,744,073,709,551,615
|}

<div class="sfat">'''<font color="blue">Recomandare:</font>''' Utilizați tipurile de date de dimensiune fixă pentru valorile numerice întregi, tipul de date '''char''' pentru a stoca un caracter și tipurile '''float''', '''double''' și '''long double''' pentru valorile numerice fracționare.</div>

== Operatori ==

'''Operatorii aritmetici''':
* + adunarea
* - scăderea
* * înmulţirea
* / împărţirea (rezultatul împărţirii pentru numere reale, câtul împărţirii pentru numere întregi)
* % modulo (restul împărţirii a două numere întregi)
* ++ incrementarea (mărirea unei valori cu o unitate)
* -- decrementarea (micşorarea unei valori cu o unitate)

Operatorii de incrementare/decrementare sunt folosiţi pentru creșterea/micşorarea unei valori cu o unitate.
a++ / ++a - incrementare
a-- / --a - decrementare
De asemenea se pot folosi instrucțiuni de pre sau post incrementare/decrementare.
'''POST-incrementare: x = a++;''' <syntaxhighlight lang="C">
x = a;
a = a + 1;
</syntaxhighlight>

'''PRE-incremenatare: x = ++a;''' <syntaxhighlight lang="C">
a = a + 1;
x = a;
</syntaxhighlight>

'''Operatori relaţionali şi logici''':

* > - mai mare
* >= -mai mare egal
* < -mai mic
* <= -mai mic egal
* == -egal
* != -diferit
* && -si
* || -sau
* ! -negare

=== Exemplu operatori relaționari și logici===

<syntaxhighlight lang="C">

#include <stdio.h>

int main(){
int a = 2, b = 6, c = 0, result;

result = !(a < c) && (a < b) || (b <=c);

printf("result is %d\n", result);
return 0;
}

</syntaxhighlight>
In exemplul de mai sus tineti cont de [http://www.robotics.ucv.ro/flexform/aplicatii/m1/Ion%20Petre%20-%20Utilizarea%20interfetei%20seriale/Cpp/precedenta-oper.html precedenta operatorilor].

'''Operatori la nivel de bit''':

Avem şase operatori la nivel de bit,aceștia se aplică tipurilor char,int,long signed/unsigned,iar rezultatul este un întreg.
Operatorii la nivel de bit sunt următorii.
* & - AND (şi logic)
* | - OR (sau logic)
* ^ - XOR (sau exclusiv)
* << - deplasare la stânga
* >> - deplasare la dreapta
* ~ - negare la nivel de bit

==== Tabele de adevăr ====

{| class="wikitable"
! Operator !! Tabel de adevăr !! Operator !! Tabel de adevăr !! Operator !! Tabel de adevăr
|-
| '''AND'''
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''OR'''
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''XOR'''
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|}

=== Exemplu operator AND ===
Dorim să aflăm valoarea bitului de pe poziția 2 a numarului 20.Pentru a afla valorea acestui bit se poate realiza operația AND (&) între numărul dorit și un alt număr binar care are doar pe poziția dorită valoarea 1 (în cazul nostru poziția 2),astfel dacă rezultatul este diferit de 0 atunci inițial am avut bitul 1, respectiv 0 dacă bitul a fost 0.

<syntaxhighlight lang="C">

#include <stdio.h>

int main(){
int a=20; /* 1 0 1 0 0 */
int b=4; /* 0 0 1 0 0 */

if(a & b){/* 0 0 1 0 0*/
printf("Rezultatul este diferit de 0\n");
}else{
printf("Rezultatul are valoarea 0\n");
}
return 0;
}

</syntaxhighlight>

=== Exemplu operator de deplasare << ===
Operatorii de deplasare (<< şi >>) realizează deplasarea biţilor din operandul stâng cu atâtea
poziţii câte sunt indicate de operandul drept.

<syntaxhighlight lang="C">

int a = 255; /* 0000 0000 1111 1111*/
a = a << 3; /* 0000 0111 1111 1000*/

</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''Deplasarea la stânga (<<) completează la dreapta cu 0, deci biţii din stânga se vor pierde.</div>

=== Exemplu operator de negare ~ ===
Operatorul de negare realizează complementarea biților,biții de 0 se pun 1, iar biții de 1 se pun 0.

<syntaxhighlight lang="C">

int a = 2200; /* 1000 1001 1000*/
a = ~a; /* 0110 0110 0111*/

</syntaxhighlight>

== Exerciții ==

<ol>
<li> Scrieți un program care să citească un număr în virgulă mobilă de la tastatură și să se afișeze, pe linii diferite, în hexazecimal, semnul, mantisa și exponentul. Notă: pentru a putea efectua operații pe biți, operanzii trebuie să fie de tip întreg. Astfel, pentru a interpreta un număr în virgulă mobilă ca secvență de biți, variabila trebuie sa fie de tip int, iar citirea să se facă cu template-ul "%f".</li>
<li> Scrieți un program care să citească de la tastatură un număr întreg fără semn pe 8 biți (în bază 10) și să-l afișeze pe ecran în baza doi, folosind operatori de shiftare și mascare.</li>
<li> Citiți de la tastatură un număr întreg cu semn, pe 32 de biți, apoi negați-l aritmetic și afișați valoarea, fără să folosiți operatorului unar "-" (folosind regulile convenției complement față de 2).</li>
<li> Scrieți un program care să citească un număr întreg pozitiv pe 8 biți de la tastatură, să numere și să afișeze câți biți de 1 și câți biți 0 are reprezentarea lui binară.</li>
<li> Citiți de la tastatură un număr întreg n, calculați și afișați suma numerelor de la 0 la n.</li>
<li> Citiți o valoare de temperatură în grade Celsius, și afișați pe ecran valoarea acelei temperaturi în Kelvin și grade Fahrenheit. </li>
<li> Fie o matrice de 8 linii și 10 coloane, cu elementele numerotate de la 0 (elementul din stânga sus) la 79 (elementul din dreapta jos):
<syntaxhighlight lang="c">
0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
...
70 71 72 73 74 75 76 77 78 79
</syntaxhighlight>
Dându-se de la tastatură un index n între 0 si 79, să se afișeze pe ce linie și pe ce coloană este indexul respectiv.</li>
<li>Dându-se un număr întreg de la tastatură, să se afișeze 0 dacă numărul este impar și 1 dacă este par.</li>
<li>Dându-se un număr întreg de la tastatură, să se afișeze restul împărțirii numărului la 16, folosind doar operații pe biți.</li>
<li><code>dificil</code> Folosind doar operații pe biți (fără construcții condiționale), să se calculeze modulul unui număr întreg pe 32 de biți, introdus de la tastatură.</li>
<ol>

PC Laborator 4

2016-10-26T15:31:31Z

Lflueratoru: /* Tipuri de date de dimensiune fixă în standardul C99 */

== Obiective ==

Familiarizarea cu noțiunile de bază ale limbajului C: tipuri de date, operatori, dar și folosirea corectă a acestora.

== Tipuri de date ==

Tipurile de date fundamentale ale limbajului C sunt: caractere (char), întregi (int), numere reale
reprezentate în virgulă mobilă cu simplă precizie (float), numere reale reprezentate în virgulă mobilă
cu dublă precizie (double).

{| class="wikitable"
! colspan="3" | Tipuri fundamentale
|-
| style="text-align: center;" |Tip
| style="text-align: center;" |Număr de biți
| style="text-align: center;" |Domeniu
|-
| char
| style="text-align: center;" | 8
| style="text-align: center;" | -128 ... +127
|-
| int
| style="text-align: center" | 16
| style="text-align: center;" | -32,768 ... +32,767
|-
| float
| style="text-align: center;" | 32
| style="text-align: center;" | Precizie 6 zecimale
|-
| double
| style="text-align: center;" | 64
| style="text-align: center;" | Precizie 10 zecimale
|}

Tipurile fundamentale pot fi precedate de diferiţi modificatori. Un '''modificator''' se utilizează pentru a adapta cât mai convenabil tipul de bază la situație.

=== Tipuri reale(float,double) și virgulă mobilă ===

<div class="regula">'''<font color="red"> Observatie:</font>''' Principalul dezavantaj al reprezentării în virgulă fixă este faptul că, dacă un număr nu mai încape în spaţiul de biţi rezervat, se pierd cifrele cele mai semnificative.</div>

Un număr este reprezentat în virgulă mobilă printr-un cuvant de n biți conținând semn, mantisă și exponent sub următoarea formă:

[[Fișier:Mantisa.jpg]]

Unde s este bitul de semn al numarului, cu aceeași convenție ca pentru numere in virgulă fixa(s=0 numar pozitiv si s=1 numar negativ),
m este mantisa numarului, reprezentând cifrele semnificative, iar e este exponentul (puterea la care trebuie ridicata o valoare)

Valoarea numarului real reprezentat in virgula mobila este data de expresia:

<math> valoare=(-1)^s*m*(baza)^e </math>

<div class="regula">'''<font color="red"> Observatie:</font>''' Mantisa trebuie să îndeplinească condiția: 1 > m >= 1/baza
</div>

=== Modificatori ===

* '''signed''' (implicit) - tip de dată cu semn, utilizabil excusiv pentru numere întregi, face ca intervalul de definiție să fie între [-2<sup>n-1</sup>:2<sup>n-1</sup>-1]
* '''unsigned''' - tip de dată fără semn, utilizabil excusiv pentru numere întregi, face ca intervalul de definiție să fie între [0:2<sup>n</sup>-1]
* '''long''' - de obicei, dublează domeniul de definiție a unui tip de dată; de exemplu un '''long int''' va avea 64 de biți în loc de 32; este aplicabil doar pentru '''int''' și '''float'''.
* '''short''' - de obicei, înjumătățește domeniul de definiție pentru '''int''', adică rezultatul este un tip de dată pe 16 biți.

{| class="wikitable"
! colspan="3" | Folosirea modificatorilor
|-
| style="text-align: center;" |Tip
| style="text-align: center;" |Număr de biți
| style="text-align: center;" |Domeniu
|-
| unsigned char
| style="text-align: center;" | 8
| style="text-align: center;" | 0 ... 255
|-
| unsigned long int
| style="text-align: center" | 64
| style="text-align: center;" | 0 .. 18,446,744,073,709,551,615
|}

Diferenţa dintre întregii signed şi unsigned constă în interpretarea diferită a bitului semnificativ (adică cel mai din stânga).
Pentru un întreg signed, se va considera bitul semnificativ ca fiind bit de semn.
Dacă acest bit este 0 atunci numărul este pozitiv iar dacă este 1 atunci este negativ.

<div class="regula">'''<font color="red"> Observatie:</font>''' Bit-ul reprezintă cea mai mică unitate de informaţie dintr-un calculator. Denumirea de bit provine de la „binary digit” adică număr binar. Sistemul binar este un sistem de numeraţie unde totul se reprezintă doar cu 1 şi 0.
Simbolul pentru un bit este "b",a nu se confunda cu byte "B" care reprezintă o grupare de 8 biți.</div>

== Tipuri de date de dimensiune fixă în standardul C99 ==

Deoarece există situații când numărul de biți pentru un anumit tip de dată este extrem de important, iar acest număr diferă între procesoare și compilatoare, standardul C99 a introdus următoarele tipuri de date, de dimensiune fixă, care se găsesc în header-ul <code style="color: blue">stdint.h</code>:

{| class="wikitable"
! colspan="3" | Tipuri de dimensiune fixă
|-
| style="text-align: center;" |Tip
| style="text-align: center;" |Numar de biti
| style="text-align: center;" |Domeniu
|-
| int8_t
| style="text-align: center;" | 8
| style="text-align: center;" | -128 .. +127
|-
| uint8_t
| style="text-align: center;" | 8
| style="text-align: center;" | 0 .. 255
|-
| int16_t
| style="text-align: center" | 16
| style="text-align: center;" | -32,768 ... +32,767
|-
| uint16_t
| style="text-align: center" | 16
| style="text-align: center;" | 0 ... +65,535
|-
| int32_t
| style="text-align: center;" | 32
| style="text-align: center;" | -2,147,483,648 .. 2,147,483,647
|-
| uint32_t
| style="text-align: center;" | 32
| style="text-align: center;" | 0 .. 4,294,967,295
|-
| int64_t
| style="text-align: center;" | 64
| style="text-align: center;" | -9,223,372,036,854,775,808 .. 9,223,372,036,854,775,807
|-
| uint64_t
| style="text-align: center;" | 64
| style="text-align: center;" | 0 .. 18,446,744,073,709,551,615
|}

<div class="sfat">'''<font color="blue">Recomandare:</font>''' Utilizați tipurile de date de dimensiune fixă pentru valorile numerice întregi, tipul de date '''char''' pentru a stoca un caracter și tipurile '''float''', '''double''' și '''long double''' pentru valorile numerice fracționare.</div>

== Operatori ==

'''Operatorii aritmetici''':
* + adunarea
* - scăderea
* * înmulţirea
* / împărţirea (rezultatul împărţirii pentru numere reale, câtul împărţirii pentru numere întregi)
* % modulo (restul împărţirii a două numere întregi)
* ++ incrementarea (mărirea unei valori cu o unitate)
* -- decrementarea (micşorarea unei valori cu o unitate)

Operatorii de incrementare/decrementare sunt folosiţi pentru creșterea/micşorarea unei valori cu o unitate.
a++ / ++a - incrementare
a-- / --a - decrementare
De asemenea se pot folosi instrucțiuni de pre sau post incrementare/decrementare.
'''POST-incrementare: x = a++;''' <syntaxhighlight lang="C">
x = a;
a = a + 1;
</syntaxhighlight>

'''PRE-incremenatare: x = ++a;''' <syntaxhighlight lang="C">
a = a + 1;
x = a;
</syntaxhighlight>

'''Operatori relaţionali şi logici''':

* > - mai mare
* >= -mai mare egal
* < -mai mic
* <= -mai mic egal
* == -egal
* != -diferit
* && -si
* || -sau
* ! -negare

=== Exemplu operatori relaționari și logici===

<syntaxhighlight lang="C">

#include <stdio.h>

int main(){
int a = 2, b = 6, c = 0, result;

result = !(a < c) && (a < b) || (b <=c);

printf("result is %d\n", result);
return 0;
}

</syntaxhighlight>
In exemplul de mai sus tineti cont de [http://www.robotics.ucv.ro/flexform/aplicatii/m1/Ion%20Petre%20-%20Utilizarea%20interfetei%20seriale/Cpp/precedenta-oper.html precedenta operatorilor].

'''Operatori la nivel de bit''':

Avem şase operatori la nivel de bit,aceștia se aplică tipurilor char,int,long signed/unsigned,iar rezultatul este un întreg.
Operatorii la nivel de bit sunt următorii.
* & - AND (şi logic)
* | - OR (sau logic)
* ^ - XOR (sau exclusiv)
* << - deplasare la stânga
* >> - deplasare la dreapta
* ~ - negare la nivel de bit

==== Tabele de adevăr ====

{| class="wikitable"
! Operator !! Tabel de adevăr !! Operator !! Tabel de adevăr !! Operator !! Tabel de adevăr
|-
| '''AND'''
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| A || B || A AND B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''OR'''
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| A || B || A OR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 1
|}
| '''XOR'''
|
{| class="wikitable" align=right
|- bgcolor="#ddeeff" align="center"
|- bgcolor="#ddeeff" align="center"
| A || B || A XOR B
|- bgcolor="#ddffdd" align="center"
|0 || 0 || 0
|- bgcolor="#ddffdd" align="center"
|0 || 1 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 0 || 1
|- bgcolor="#ddffdd" align="center"
|1 || 1 || 0
|}
|}

=== Exemplu operator AND ===
Dorim să aflăm valoarea bitului de pe poziția 2 a numarului 20.Pentru a afla valorea acestui bit se poate realiza operația AND (&) între numărul dorit și un alt număr binar care are doar pe poziția dorită valoarea 1 (în cazul nostru poziția 2),astfel dacă rezultatul este diferit de 0 atunci inițial am avut bitul 1, respectiv 0 dacă bitul a fost 0.

<syntaxhighlight lang="C">

#include <stdio.h>

int main(){
int a=20; /* 1 0 1 0 0 */
int b=4; /* 0 0 1 0 0 */

if(a & b){/* 0 0 1 0 0*/
printf("Rezultatul este diferit de 0\n");
}else{
printf("Rezultatul are valoarea 0\n");
}
return 0;
}

</syntaxhighlight>

=== Exemplu operator de deplasare << ===
Operatorii de deplasare (<< şi >>) realizează deplasarea biţilor din operandul stâng cu atâtea
poziţii câte sunt indicate de operandul drept.

<syntaxhighlight lang="C">

int a = 255; /* 0000 0000 1111 1111*/
a = a << 3; /* 0000 0111 1111 1000*/

</syntaxhighlight>

<div class="regula">'''<font color="red"> Observatie:</font> '''Deplasarea la stânga (<<) completează la dreapta cu 0, deci biţii din stânga se vor pierde.</div>

=== Exemplu operator de negare ~ ===
Operatorul de negare realizează complementarea biților,biții de 0 se pun 1, iar biții de 1 se pun 0.

<syntaxhighlight lang="C">

int a = 2200; /* 1000 1001 1000*/
a = ~a; /* 0110 0110 0111*/

</syntaxhighlight>

== Exerciții ==

<ol>
<li> Scrieți un program care să citească un număr în virgulă mobilă de la tastatură și să se afișeze, pe linii diferite, în hexazecimal, semnul, mantisa și exponentul. Notă: pentru a putea efectua operații pe biți, operanzii trebuie să fie de tip întreg. Astfel, pentru a interpreta un număr în virgulă mobilă ca secvență de biți, variabila trebuie sa fie de tip int, iar citirea să se facă cu template-ul "%f".</li>
<li> Scrieți un program care să citească de la tastatură un număr întreg fără semn pe 8 biți (în bază 10) și să-l afișeze pe ecran în baza doi, folosind operatori de shiftare și mascare.</li>
<li> Citiți de la tastatură un număr întreg cu semn, pe 32 de biți, apoi negați-l aritmetic și afișați valoarea, fără să folosiți operatorului unar "-" (folosind regulile convenției complement față de 2).</li>
<li> Scrieți un program care să citească un număr întreg pozitiv pe 8 biți de la tastatură, să numere și să afișeze câți biți de 1 și câți biți 0 are reprezentarea lui binară.</li>
<li> Citiți de la tastatură un număr întreg n, calculați și afișați suma numerelor de la 0 la n.</li>
<li> Citiți o valoare de temperatură în grade Celsius, și afișați pe ecran valoarea acelei temperaturi în Kelvin și grade Fahrenheit. </li>
<li> Fie o matrice de 8 linii și 10 coloane, cu elementele numerotate de la 0 (elementul din stânga sus) la 79 (elementul din dreapta jos):
<syntaxhighlight lang="c">
0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
...
70 71 72 73 74 75 76 77 78 79
</syntaxhighlight>
Dându-se de la tastatură un index n între 0 si 79, să se afișeze pe ce linie și pe ce coloană este indexul respectiv.</li>
<li>Dându-se un număr întreg de la tastatură, să se afișeze 0 dacă numărul este impar și 1 dacă este par.</li>
<li>Dându-se un număr întreg de la tastatură, să se afișeze restul împărțirii numărului la 16, folosind doar operații pe biți.</li>
<li><code>dificil</code> Folosind doar operații pe biți (fără construcții condiționale), să se calculeze modulul unui număr întreg pe 32 de biți, introdus de la tastatură.</li>
<ol>

PC Laborator 3

2016-10-19T13:42:05Z

Lflueratoru: /* Exemplu */

= Obiective =

În urma parcurgerii acestui laborator studentul va fi capabil:
* să utilizeze stream-urile standard ale unui proces în Linux și în programe C;
* să înțeleagă funcționalitatea preprocesorului și să folosească directive de preprocesare;

= [https://en.wikipedia.org/wiki/Standard_streams Stream-urile standard] ale unui proces =

[[Fișier:standard_streams.png]]

După cum se poate observa în schema de mai sus, un proces care rulează într-un sistem de operare dispune de trei stream-uri de intrare ieșire implicite:
* Stream-ul standard de intrare ('''stdin''') - este utilizat pentru a introduce date în proces și este implicit atașat tastaturii;
* Stream-ul standard de ieșire ('''stdout''') - este utilizat pentru a extrage rezultate ale execuției procesului și este implicit atașat consolei;
* Stream-ul standard de eroare ('''stderr''') - este tradițional utilizat pentru a extrage informații legate de erorile apărute în execuția procesului și este implicit atașat consolei;

Se observă că ambele stream-uri de ieșire sunt implicit trimise către consolă, unde utilizatorul procesului le poate vedea. Motivul pentru care sunt două este acela că aceste stream-uri pot fi redirectate către alte procese sau către fișiere, astfel se poate face o separare simplă și rapidă a mesajelor de eroare, în scopul depanării programului.

Toate aceste stream-uri sunt formatate pe octet (byte). În cele mai multe din cazuri, acești bytes reprezintă caractere codate [https://en.wikipedia.org/wiki/ASCII ASCII].

== Scrierea pe '''stdout''' ==

Pentru a scrie pe stream-ul standard de ieșire se folosește generic funcția <code style="color: green">fprintf</code>:

Funcția <code style="color: green">fprintf</code> este definită în header-ul <code style="color: blue">stdio.h</code> (standard input/output) și este implimentată în biblioteca standard a limbajului C. Pentru scrierea pe stream-ul standard de ieșire, se folosește în felul următor:

<syntaxhighlight lang="C">
fprintf(stdout, "[format]", val1, val2, ...);
</syntaxhighlight>

<div class="sfat">'''<font color="blue">Observație:</font>''' Deoarece scrierea pe stream-ul standard de ieșire este atât de utilizată, s-a creat o funcție specială pentru aceasta, numită <code style="color: green">printf</code>:
<syntaxhighlight lang="C">
printf("[format]", val1, val2, ...);
</syntaxhighlight>
</div>

Formatul reprezintă modelul de date pe care îl dorim afișat în consolă.

Specificatorul de format pentru <code style="color: green">fprintf</code>, respectiv <code style="color: green">printf</code> urmează următorul prototip:

%[flags][width][.precision][length]specifier

unde caracterul ''specifier'' de la sfârșit este componenta cea mai importantă deoarece definește ce caractere sunt extrase din stream, interpretarea lor, și tipul de date corect al argumentului corespunzător:

{| class="wikitable"
! ''specifier'' !! Afișare !! Exemplu
|-
|i, d || întreg decimal cu semn || -694
|-
|u || întreg decimal fără semn || 1659
|-
|o || întreg în baza 8 || 254
|-
|x || întreg în baza 16 (litere mici) || 1af43
|-
|X || întreg în baza 16 (litere mari) || 1AF43
|-
|f || număr în virgulă mobilă || 23.65
|-
|e || număr în virgulă mobilă, notație științifică (mantisa - exponent), litere mici || 3.9265e+2
|-
|E || număr în virgulă mobilă, notație științifică (mantisa - exponent), litere mari || 3.9265E+2
|-
|g || număr în virgulă mobilă, cea mai scurtă reprezentare (%f sau %e) || 23.65
|-
|G || număr în virgulă mobilă, cea mai scurtă reprezentare (%F sau %E) || 23.65
|-
|a || număr în virgulă mobilă în baza 16, litere mici || -0xc.90fep-2
|-
|A || număr în virgulă mobilă în baza 16, litere mari || -0xc.90FEP-2
|-
|c || caracter || a
|-
|s || șir de caracere || castravete
|-
|p || adresă în memorie (pointer) || 00000000b8000000
|-
|n || nu se printează nimic || numărul de caractere citit până în momentul curent este stocat în variabila specificată
|-
|% || % ||Un caracter % urmat de alt caracter % afișează un singur %.
|}

Specificatorul de format poate conține și sub-specificatori: ''flags'', ''width'', ''.precision'' și ''modifiers'' (în această ordine), care sunt opționale și respectă următoarele reguli:

{| class="wikitable"
! ''flag'' !! Descriere
|-
| - || Aliniere la stânga cu dimensiunea dată de câmpul ''width'' (implicit aliniera este la dreapta). Vezi descrierea lui ''width''.
|-
| + || Forțează printarea unui semn (+ sau -), chiar și pentru valori pozitive (implicit se afișează semnul doar pentru numere negative).
|-
| (spațiu) || Dacă semnul nu se afișează, în locul lui se inserează un spațiu.
|-
| # || Folosit cu o, x, sau X, printează 0, 0x sau respectiv 0X în fața valorii, pentru numere diferite de 0. Folosit cu a, A, e, E, f, g sau G, forțează printarea punctului decimal, chiar dacă după el nu mai urmează alte cifre. Implicit, dacă după punct nu mai urmează alte cifre (numărul este întreg), punctul nu se mai afișează.
|-
| 0 || Când se specifică o dimensiune (''width''), numărul se completează la stânga cu 0 în loc de spațiu. Vezi descrierea lui ''width''.
|}

{| class="wikitable"
! ''width'' !! Descriere
|-
| (număr) || Numărul minim de caractere care trebuie scrise. Dacă lungimea numărului este mai mică decât această valoare, el este completat cu spații. Dacă lungimea este mai mare, numărul este afișat în întregime.
|-
| * || Valoarea ''width'' nu este specificată în string-ul ''format'', ci într-un argument suplimentar al funcției, care precede argumentul ce trebuie formatat.
|}

{| class="wikitable"
! ''.precision'' !! Descriere
|-
| (număr) || Pentru valori întregi (d, i, o, u, x, X), ''precision'' specifică numărul minim de cifre care trebuie afișate. Dacă numărul ce trebuie afișat este mai scurt decât această valoare, rezultatul este completat la stânga cu cifra 0. Dacă numărul este mai lung, el este afișat în întregime. O precizie 0 înseamnă că pentru valoarea 0 nu se va afișa nimic. Pentru specificatorii a, A, e, E, f și F, aceasta este numărul de cifre ce a fi afișat după punct (implicit valoarea aceasta este 6). Pentru specificatorii g și G, acesta este numărul maxim de cifre semnificative ce trebuie afișat. Pentru s, acesta este numărul maxim de caractere ce trebuie afișat. Implicit toate caracterele sunt afișate, până la întâlnirea unui terminator de string. Dacă punctul este scris fără o valoare pentru precizie, aceasta se consideră implicit 0.
|-
| * || Valoarea ''precision'' nu este specificată în string-ul ''format'', ci într-un argument suplimentar al funcției, care precede argumentul ce trebuie formatat.
|}

Specificatorul ''length'' modifică dimensunea tipului de date. Tabelul următor arată tipurile folosite pentru a interpreta argumentele corespunzătoare, cu și fără specificatorul ''length'' (dacă un alt tip este folosit, se realizează promovarea sau conversia tipului, dacă este posibil):
<table class="wikitable">
<tr><th></th><th colspan="7">specifiers</th></tr>
<tr><th><i>length</i></th><th><tt>d i</tt></th><th><tt>u o x X</tt></th><th><tt>f F e E g G a A</tt></th><th><tt>c</tt></th><th><tt>s</tt></th><th><tt>p</tt></th><th><tt>n</tt></th></tr>
<tr><td><i>(none)</i></td><td class="yes"><tt>int</tt></td><td class="yes"><tt>unsigned int</tt></td><td class="yes"><tt>double</tt></td><td class="yes"><tt>int</tt></td><td class="yes"><tt>char*</tt></td><td class="yes"><tt>void*</tt></td><td class="yes"><tt>int*</tt></td></tr>
<tr style="background-color: yellow;"><td><tt>hh</tt></td><td class="yes"><tt>signed char</tt></td><td class="yes"><tt>unsigned char</tt></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="yes"><tt>signed char*</tt></td></tr>
<tr><td><tt>h</tt></td><td class="yes"><tt>short int</tt></td><td class="yes"><tt>unsigned short int</tt></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="yes"><tt>short int*</tt></td></tr>
<tr><td><tt>l</tt></td><td class="yes"><tt>long int</tt></td><td class="yes"><tt>unsigned long int</tt></td><td class="no"></td><td class="yes"><tt>wint_t</tt></td><td class="yes"><tt>wchar_t*</tt></td><td class="no"></td><td class="yes"><tt>long int*</tt></td></tr>
<tr style="background-color: yellow;"><td><tt>ll</tt></td><td class="yes"><tt>long long int</tt></td><td class="yes"><tt>unsigned long long int</tt></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="yes"><tt>long long int*</tt></td></tr>
<tr style="background-color: yellow;"><td><tt>j</tt></td><td class="yes"><tt>intmax_t</tt></td><td class="yes"><tt>uintmax_t</tt></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="yes"><tt>intmax_t*</tt></td></tr>
<tr style="background-color: yellow;"><td><tt>z</tt></td><td class="yes"><tt>size_t</tt></td><td class="yes"><tt>size_t</tt></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="yes"><tt>size_t*</tt></td></tr>
<tr style="background-color: yellow;"><td><tt>t</tt></td><td class="yes"><tt>ptrdiff_t</tt></td><td class="yes"><tt>ptrdiff_t</tt></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="yes"><tt>ptrdiff_t*</tt></td></tr>
<tr><td><tt>L</tt></td><td class="no"></td><td class="no"></td><td class="yes"><tt>long double</tt></td><td class="no"></td><td class="no"></td><td class="no"></td><td class="no"></td></tr>
</table>

<div class="sfat">'''<font color="blue">Observație:</font>''' Tabelele de mai sus pot fi înțelese abia după parcurgerea cursurilor și laboratoarelor legate de tipuri și dimensiuni de date. Ele vor fi folosite pe parcursul cursului drept referință și nu trebuie memorate.</div>

<div class="sfat">'''<font color="blue">Observație:</font>''' Rândurile marcate cu galben au fost introduse în standardul C99.</div>

== Scrierea pe '''stderr''' ==

Scrierea pe stream-ul standard de eroare se face identic cu scrierea pe '''stdout''', specificând numele streamului ca prim argument al funcției <code style="color: green">fprintf</code>:

<syntaxhighlight lang="C">
fprintf(stderr, "[format]", val1, val2, ...);
</syntaxhighlight>

<div class="sfat">'''<font color="blue">Observație:</font>''' Nu se poate folosi funcția <code style="color: green">printf</code> pentru scrierea pe stream-ul standard de eroare.</div>

== Citirea din '''stdin''' ==

Pentru a citi de pe stream-ul standard de intrare se folosește generic funcția <code style="color: green">fscanf</code>:

Funcția <code style="color: green">fscanf</code> este definită în header-ul <code style="color: blue">stdio.h</code> (standard input/output) și se folosește în felul următor:

<syntaxhighlight lang="C">
fscanf(stdin, "[format]", val1, val2, ...);
</syntaxhighlight>

<div class="sfat">'''<font color="blue">Observație:</font>''' Deoarece citirea de pe stream-ul standard este atât de utilizată, s-a creat o funcție specială pentru aceasta, numită <code style="color: green">scanf</code>:
<syntaxhighlight lang="C">
scanf("[format]", val1, val2, ...);
</syntaxhighlight>
</div>

Formatul reprezintă modelul de date pe care ne așteptăm să-l primim de la tastatură. Acesta este un șir de caractere unde fiecare caracter este tratat în următorul fel:
* '''caracter alb''' - se va citi și ignora din stream orice caractere albe până la întâlnirea unui caracter care nu este alb (caracerele albe includ spații, linie nouă, caractere tab); un singur caracter alb în format validează oricâte caractere albe extrase din stream (inclusiv nici unul).
* '''caracter care nu este alb, exceptând specificatorul de format (%)''' - orice caracter care nu este alb (spațiu, linie nouă sau tab) sau care nu face parte dintr-un specificator de format (care începe cu %) face ca următorul caracter să fie citit din stream, comparat cu acest caracter din format, iar dacă sunt identice, ele sunt ignorate și se continuă cu următorul caracter; dacă nu sunt identice, <code style="color: green">fscanf</code> se va opri cu eroare;
* '''specificator de format''' - o secvență care începe cu caracterul "la sută" (%) indică un specificator de format, utilizat pentru a indica tipul și formatul unei date care trebuie citită și stocată într-una din variabilele specificate în apelul lui <code style="color: green">fscanf</code>.

Specificatorul de format pentru <code style="color: green">fscanf</code> urmează următorul prototip:

%[*][width][length]specifier

unde caracterul ''specifier'' de la sfârșit este componenta cea mai importantă deoarece definește ce caractere sunt extrase din stream, interpretarea lor, și tipul de date corect al argumentului corespunzător:

{| class="wikitable"
! ''specifier'' !! Descriere !! Caractere extrase din stream
|-
|i, u || întreg || Orice număr de cifre, opțional precedate de un semn (+ sau -). Baza zece este considerată implicit (0-9), dar un 0 ca prefix marchează baza ca fiind opt (0-7), iar "0x" ca prefix marchează baza șaisprezece (0-f).
|-
|d || întreg în baza 10 || Orice număr de cifre decimale (0-9), opțional precedate de un semn (+ sau -).
|-
|o || întreg în baza 8 || Orice număr de cifre octale (0-7), opțional precedate de un semn (+ sau -).
|-
|x || întreg în baza 16 || Orice număr de cifre hexazecimale (0-7, a-f, A-F), opțional precedate de "0x" sau "0X", și totul opțional precedat de un semn (+ sau -).
|-
|f, e, g, a (C99) || număr în virgulă mobilă || O serie de cifre decimale, conținând opțional un punct decimal, opțional precedat de un semn (+ sau -), opțional urmat de un caracter e sau E, și un întreg în baza 10. În standardul C99 se acceptă și numere în virgulă mobilă în baza hexazecimală, precedate de 0x sau 0X.
|-
|c || caracter || Următorul caracter. Dacă '''width''' este specificat, se vor citi exact '''width''' caractere și vor fi stocate în locații succesive în vectorul primit ca argument. Nu este adăugat terminator de șir la final.
|-
|s || șir de caractere ||Orice număr de caractere care nu sunt albe, oprindu-se la primul caracter alb înlâlnit. Este automat adăugat terminator de șir la final.
|-
|p || adresă în memorie ||O secvență de caractere reprezentând o adresă în memorie. Formatul folosit depinde de sistem și de implementarea bibliotecii, dar este identic cu cel folosit de formatul %p în <code style="color: green">fprintf</code>.
|-
|[characters] || set de caractere || Orice număr de caractere dintre cele specificate între parantezele drepte. O liniuță (-) care nu este pe prima poziție între paranteze poate produce comportamente nedefinite în unele implementări de bibliotecă standard.
|-
|[^characters] || set de caractere negat || Orice număr de caractere care nu sunt specificate între parantezele drepte.
|-
|n || număr caractere citite || Nu este consumat nimic din stream. Numărul de caractere citit până în momentul curent este stocat în variabila specificată.
|-
|% || % ||Un caracter % urmat de alt caracter % consumă un singur % din stream.
|}
În afară de n, cel puțin un caracter va fi consumat din stream de către oricare alt specificator. Altfel, operația eșuează și citirea se încheie în acel punct.

Specificatorul de format poate conține de asemenea și sub-specificatori: steluță (*), '''width''' și '''length''' (în această ordine), care sunt opționale și respectă următoarele specificații:

{| class="wikitable"
! sub-specifcator !! Descriere
|-
| * || O steluță ca sub-specifiator indică faptul că data citită nu este stocată într-o variabilă ci este ignorată.
|-
| ''width'' || Specifică numărul maxim de caractere ce vor fi citite din stream de operația curentă.
|-
| ''length'' || Unul din hh, h, l, ll, j, z, t, L. Acest caracter modifică tipul de date așteptat ca argument. Comportamentul acestora este identic cu cel definit la capitolul [[#Scrierea pe stdout]]
|}

<div class="regula">'''<font color="red">Atenție:</font>''' Variabilele care nu sunt de tip vector sau pointer și sunt folosite în apelul funcției <code style="color: green">fscanf</code> pentru a stoca date din stream, trebuie obligatoriu precedate de operatorul &. Explicația pentru această regulă va fi prezentată în cursul legat de pointeri și adrese de memorie.</div>

== Exemple ==

<ol>
<li>
Scrieți următorul program într-un fișier numit <code style="color: blue">exemplu_stdin.c</code>
<syntaxhighlight lang="C">
#include <stdio.h>

int main(){
int integerValue;
fprintf(stdout, "Introduceti o valoare numerica: ");
fscanf(stdin, "%d", &integerValue);
printf("Valoarea introdusa este %d\n", integerValue);
return 0;
}
</syntaxhighlight>
</li>
</ol>

== Exerciții ==

<ol>
<li>Citiți de la tastatură două numere întregi și afișați suma lor pe stream-ul standard de ieșire (operatorul pentru sumă este +).</li>
<li>Citiți de la tastatură trei numere întregi și afișați produsul lor pe stream-ul standard de eroare (operatorul pentru produs este *).</li>
<li>Citiți de la tastatură patru numere fracționare. Primele 3 sunt coeficienții unui polinom de gradul II. Al patrulea este valoarea unui punct în care se calculează valoarea polinomului. Afișați rezultatul cu două zecimale pe stream-ul standard de ieșire. </li>
<li>Fie următoarea funcție: <code>f(x) = (3.6 * e<sup>x</sup> + cos(2*x)) / (x + 1)</code>. Scrieți un program care să citească o valoarea fracționară de la tastatură, să calculeze valoarea funcției în punctul respectiv și sa afișeze rezultatul pe stream-ul standard de eroare în format științific. Observație: pentru a utiliza funcțiile cos și exp (exponențială), trebuie să adăugați programului vostru, pe prima linie, directiva <code>#include <math.h></code> și să compilați programul adăugând comenzii de compliare flag-ul <code>-lm</code>. Pentru a calcula e<sup>2</sup> se folosește funcția exp: <code>exp(2)</code>.</li>
</ol>

= [https://en.wikipedia.org/wiki/C_preprocessor Preprocesorul C] =

Preprocesarea unui fișier cu cod C este prima etapă din lanțul de ''build'', și reprezintă, așa cum îi spune și numele, o etapă de dinainte de procesarea (compilarea) efectivă. Motivul pentru care se realizează această etapă inițială este faptul că prin preprocesarea codului se pot elimina secțiuni din program care ori nu sunt necesare, ori nu sunt compilabile pe un anumit procesor sau sistem de operare. Spre exemplu, pentru a folosi o interfață serială, în sistemul de operare Windows, și compilatorul Visual Studio, există un tip de date care se numește <code style="color: green">HANDLE</code>. Acest tip de date nu există în Linux, aici fiind înlocuit simplu cu <code style="color: green">int</code>. În acest caz, compilarea unui program care folosește <code style="color: green">HANDLE</code> pe Linux va eșua cu eroare. Aici intervin directivele de preprocesare, după cum vom vedea în continuare.

În acest laborator se va discuta despre:
* <code style="color: green">#include</code>
* <code style="color: green">#define</code>
* <code style="color: green">#undef</code>
* <code style="color: green">#ifdef</code>
* <code style="color: green">#ifndef</code>
* <code style="color: green">#else</code>
* <code style="color: green">#endif</code>

== Directiva <code style="color: green">#include</code> ==

Probabil <code style="color: green">#include</code> este cea mai frecvent utilizată directivă de preprocesare, dar și cea mai ușor de înțeles. Efectiv, preprocesorul caută fișierul specificat între paranteze unghiulare sau ghilimele în lista de directoare dintr-o listă cunoscută și apoi înlocuiește directiva <code style="color: green">#include</code> cu conținutul fișierului respectiv.

=== Exemplu ===

* Scrieți un fișier nou într-un editor de text care să conțină următorul cod:
<syntaxhighlight lang="C">
int main(){
return 0;
}
</syntaxhighlight>
* Salvați fișierul cu numele <code style="color: blue">test_preprocessor.c</code> în directorul <code style="color: blue">~/work/''prenume_nume''</code>
* Scrieți un fișier <code style="color: blue">Makefile</code> cu o singură rețetă care să producă un fișier numit <code style="color: blue">processed.c</code> din fișierul de mai sus, apelând compilatorul C (gcc) cu fanionul corespunzător pentru a face doar preprocesare (vezi [[PC Laborator 1#Generarea fișierului executabil|PC Laborator 1]]).
* Ce diferențe există între fișierul original și fișierul preprocesat?
* Scrieți un nou fișier numit <code style="color: blue">header_file.h</code>, care să conțină următorul text:
<syntaxhighlight lang="C">
// This is the start of the header file
int variable;
// This is the end of the header file
</syntaxhighlight>
* Modificați fișierul <code style="color: blue">test_preprocesor.c</code> prin înserția pe prima linie a unei directive '''include''':
<syntaxhighlight lang="C">
#include <header_file.h>
int main(){
return 0;
}
</syntaxhighlight>
* Rulați din nou comanda <code style="color: green">make</code>. Observați mesajul de eroare: fișierul <code style="color: blue">header_file.h</code> nu este găsit de preprocesor, cu toate că este în directorul curent.
<div class="regula">'''<font color="red">Atenție:</font>''' Fișierele antet (header) sunt căutate doar în anumite căi predefinite în compilator (de exemplu <code style="color: blue">/usr/include</code>). Pentru a face preprocesorul să caute și în alte directoare, calea până la acestea trebuie specificată la compilare, folosind fanionul <code style="color: green">-I</code></div>
* Adăugați comenzii de compilare din <code style="color: blue">Makefile</code> următorul fanion: <code style="color: green">-I.</code> Asta va spune compilatorului (care mai departe va spune preprocesorului) să caută fișiere antet și în directorul curent (.)
* Rulați din nou comanda <code style="color: green">make</code>.
* Afișați conținutul celor două fișiere C. Ce diferențe observați?

== Directivele <code style="color: green">#define</code> și <code style="color: green">#undef</code> ==

Directiva <code style="color: green">#define</code> este utilizată pentru a defini '''macro'''-uri de preprocesor. Acestea se folosesc în trei feluri distincte:
* <code style="color: green">#define ''token'' ''value''</code> - este definit '''macro'''-ul ''token'' existența acestuia putând fi testată cu directivele <code style="color: green">#ifdef</code> și <code style="color: green">#ifndef</code>; dacă ''token'' este utilizat în program, după definirea lui, el va fi înlocuit cu ''value'' (efectiv, această operație este identică cu un "Search and Replace" dintr-un editor de text, unde ''token'' este înlocuit cu ''value''.
<syntaxhighlight lang="C">
#define PI 3.1415

float a = 2 * PI;
</syntaxhighlight>
* <code style="color: green">#define ''token''</code> - este definit '''macro'''-ul ''token'', existența acestuia putând fi testată cu directivele <code style="color: green">#ifdef</code> și <code style="color: green">#ifndef</code>; dacă ''token'' este utilizat în program, după definirea lui, va fi șters de peste tot unde apare (este de fapt cazul de mai sus unde ''value'' este de fapt un string de lungime zero).
<syntaxhighlight lang="C">
#include <stdio.h>
#define DEBUG

int main(){
#ifdef DEBUG
printf("Debug is ON!\n");
#endif
return 0;
}

</syntaxhighlight>
* <code style="color: green">#define ''token(arg1,arg2,..) expression''</code> - este definit '''macro'''-ul ''token'', existența acestuia putând fi testată cu directivele <code style="color: green">#ifdef</code> și <code style="color: green">#ifndef</code>; ''token'' este utilizat în program ca o funcție, iar el va fi înlocuit de ''expression'', în care ''arg1,arg2,...'' vor fi înlocuite cu valorile din program.
<syntaxhighlight lang="C">
#include <stdio.h>
#define MAX(a,b) (a < b ? b : a)

int main(){
printf("Value is %d!\n", MAX(4,5)); // Replaced to: printf("Value is %d!\n", (4 < 5 ? 5 : 4));
// printf("Value is %d!\n", MAX(4 + 1, 5 + 1)); // Replaced to: printf("Value is %d!\n", (4 + 1 < 5 + 1 ? 5 + 1 : 4 + 1));
return 0;
}
</syntaxhighlight>

<div class="regula">'''<font color="red">Atenție:</font>''' O greșeală frecventă în definirea macrourilor este adăugarea unui caracter ; la sfârșitul liniei. Acesta se va înlocui și el în momentul în care '''macro'''-ul se expandează în text:
<syntaxhighlight lang="C">
#include <stdio.h>
#define PI 3.1415;

int main(){
float f = PI * 2; // Replaced to: float f = 3.1415; * 2;
return 0;
}
</syntaxhighlight>
Se vede imediat că sintaxa este greșită și compilatorul va genera o eroare.
</div>

Pentru a anula definiția unui '''macro''', se folosește directiva <code style="color: green">#undef</code> astfel:
<syntaxhighlight lang="C">
#undef PI
#undef DEBUG
#undef MAX
</syntaxhighlight>

=== Exemplu ===

* Modificați fișierul <code style="color: blue">test_preprocessor.c</code> în felul următor:
<syntaxhighlight lang="C">
#define PI 3.1415
#define INC(x) (x + 1)
#define DEBUG

int main(){
printf("PI is %f\n", PI);
printf("%d comes after 4\n", INC(4));

#ifdef DEBUG
printf("This runs in debug mode\n");
#else
printf("This runs in release mode\n");
#endif
return 0;
}
</syntaxhighlight>
* Rulați comanda <code style="color: green">make</code> în consolă.
* Afișați cele două fișiere .c. Observați diferențele.

== Directivele <code style="color: green">#ifndef</code> și <code style="color: green">#define</code> pe post de gardă pentru dublă incluziune ==

Luând ca punct de plecare [[#Exemplu|primul exemplu]] de la directiva <code style="color: green">#include</code>, oare ce se întâmplă dacă header-ul <code style="color: blue">header_file.h</code> este inclus de două ori?
<syntaxhighlight lang="C" line>
#include "header_file.h"
#include "header_file.h"
int main(){
return 0;
}
</syntaxhighlight>

Răspunsul este simplu, preprocesorul va înlocui ambele linii cu conținutul fișierului, lucru care va face ca variabila '''variable''' să fie definită de două ori, lucru care sintactic greșit în C. Sigur, nimeni nu va include în mod voit un header de două ori, dar este posibil ca indirect lucrul acesta să se întâmple. Spre exemplu, dacă în fișierul <code style="color: blue">header_file.h</code> este inclus <code style="color: blue">stdio.h</code>, iar în <code style="color: blue">test_preprocessor.c</code> sunt incluse și <code style="color: blue">header_file.h</code> și <code style="color: blue">stdio.h</code>. În această situație, <code style="color: blue">stdio.h</code> ajunge să fie inclus de două ori. Pentru a evita problemele apărute în această situație, se folosește garda de incluziune ([https://en.wikipedia.org/wiki/Include_guard include guard]). Aceasta se adaugă în fiecare fișier header:

<syntaxhighlight lang="C" line>
#ifndef _HEADER_FILE_H_
#define _HEADER_FILE_H_

// This is the start of the header file
int variable;
// This is the end of the header file

#endif
</syntaxhighlight>

Includerea acestui fișier de către preprocesor se realizează acum în următoarea secvență:
# Prima directivă include din fișerul sursă C va copia conținutul fișierului de mai sus în locul unde este inclus (test_preprocesor.c, linia 1).
# Directiva ifndef verifică dacă '''macro'''-ul _HEADER_FILE_H_ ''nu'' este definit (header_file.h, linia 1).
# Deoarece nu este definit, tot textul dintre ifndef și endif se păstrează (header_file.h, liniile 2-7).
# Prima linie din text-ul păstrat este o directivă define care definește '''macro'''-ul_HEADER_FILE_H (header_file.h, linia 2).
# A doua directivă include din fișerul sursă C va copia conținutul fișierului de mai sus în locul unde este inclus (test_preprocesor.c, linia 2).
# Directiva ifndef verifică dacă '''macro'''-ul _HEADER_FILE_H_ ''nu'' este definit (header_file.h, linia 1).
# Deoarece el acum ESTE definit în cadrul include-ului anterior, tot textul dintre ifndef și endif se elimină (header_file.h, liniile 2-7).

=== Alternativă la '''include guards''' - ''#pragma once'' ===

Problema cu '''include guards''' este că pe lângă faptul ca este o construcție complicată care are nevoie de linii adăugate în fișierul header și la început și la sfârșit, numele macro-ului definit se poate repeta accidental în două sau mai multe fișiere, în această situație neincluzându-se decât primul din aceste fișiere.

O alternativă non-standard dar suportată de majoritatea compilatoarelor (inclusiv C++) este utilizarea directivei <code style="color: #00AA00">#pragma once</code>:

<syntaxhighlight lang="C" line>
#pragma once

// This is the start of the header file
int variable;
// This is the end of the header file

</syntaxhighlight>

=== Exemplu ===

* Modificați fișierul <code style="color: blue">test_preprocessor.c</code> pentru a include header-ul <code style="color: blue">header_file.h</code> de două ori, conform exemplului de mai sus.
* Rulați comanda <code style="color: green">make</code> și confirmați dubla declarare a variabilei '''variable'''.
* Adăugați gardă de incluziune fișierului header, conform exemplului de mai sus.
* Rulați comanda <code style="color: green">make</code> și confirmați că variabila '''variable''' este declarată o singură dată.
* Înlocuiți garda de incluziune cu <code style="color: #00AA00">#pragma once</code>
* Rulați comanda <code style="color: green">make</code> și confirmați că variabila '''variable''' este declarată o singură dată.