S e r g i u G .

I s t r a t i








P R O G R A M A R E
Ini!ializare n limbajele C "i C++



Ciclu de prelegeri la disciplina Programare








Chi"in#u 2003



2


Adnotare

Lucrarea de fa!" este destinat" studen!ilor anilor I #i II sec!iile de nv"!"mnt de zi #i
f"r" frecven!" a Universit"!ii Tehnice a Moldovei ce studiaz" disciplina Programare #i
n special studen!ilor Facult"!ii de Radioelectronc" #i Telecomunica!ii catedra
Sisteme Otpoelectronice cu specializ"rile $87$ Inginerie #i Management n
Telecomunica!ii #i 2$05 Sisteme Optoelectronice.






Autor: lector superior Sergiu G.Istrati


Redactor responsabil: conf. univ. dr. Pavel Nistiriuc


Recenzent: academician, dr. hab. Victor I. Bor#evici













U.T.M. 2003



3
Cuprins

Limbajul de programare C/C++
ntroducere 5
$. Alfabetul limbajului 6
2. Structura unui program 8
3. Tipuri de date $2
3.$. Tipuri de date simple predefinite. Constante $2
3.$.$. Constante ntregi $2
3.$.2. Constante reale $4
3.$.2. Constante character $5
3.$.3. %iruri de caractere $6
4. Variabile $6
4.$. Nume de variabile (identificatori) $6
4.2. Descrierea variabilelor $6
4.3. Ini!ializarea variabilelor $7
5. Opera!ii #i expresii $8
5.$. Opera!ii aritmetice $8
5.2. Opera!ia de atribuire $8
5.3. Opera!ii de incrementare(decrementare) $8
5.4. Rela!ii #i opera!ii logice $9
5.5. Opera!iile logice pozi!ionale 20
5.6. Opera!ia dimensiune 22
5.7. Opera!ia virgul" 22
5.8. Expresii condi!ionate 23
5.9. Conversii de tip 23
5.$0. Priorit"!ile opera!iilor 25
6. Instruc!iuni 26
6.$. Tipurile instruc!iunilor 26
6.2. Instruc!iuni expresie 27
6.3. Instruc!iuni de ramificare (condi!ionale) 28
6.3.$. Instruc!iunea de ramificare IF #i IF-ELSE 28
6.3.2. Instruc!iunea de salt necondi!ionat GOTO 29
6.3.3. Instruc!iunea de selectare SWITCH 30
6.3.4. Instruc!iunea de ntrerupere BREAK 32
6.4. Instruc!iuni iterative(ciclice) 33
6.4.$. Instruc!iunea ciclic" FOR 33

4
6.4.2. Instruc!iunea ciclic" WHILE 34
6.4.3. Instruc!iunea de ciclare DO_WHILE 35
6.4.4. Instruc!iunea de continuare CONTINUE 36
7. Masive 36
7.$. Descrierea masivelor 36
7.2. Accesul la elementele masivului 37
7.3. Ini!ializarea masivelor 38
7.4. Exemple de prelucrare a masivelor 40
8. %iruri de caractere 4$
8.$. Masive de #iruri 43
9. Structuri n C/C++ 44
9.$. Declararea variabilelor de tip structur" 45
9.2. Ini!ierea variabilelor tip nregistrare 45
9.3. Folosirea structurilor 46
9.4. Structuri imbricate 47
9.5. Masive de structuri 47
$0. Func!ii n C/C++ 49
$0.$. Transmiterea parametrilor n func!ie 52
$0.2. ntoarcerea valorilor din func!ie 54
$0.3. Prototipul func!iei 56
$0.4. Variabile locale #i domeniul de vizibilitate 57
$0.5.Variabile globale 59
$0.6. Conflicte dintre variabile locale #i globale 60
$$. Indicatori (pointeri) 6$
$$.$. Indicatori #i func!ii 64
$2. Fi#iere n C/C++ 68
$2.$. Deschiderea fi#ierelor 70
$2.2. Func!ii de nscriere/citire din fi#ier 73
$2.2.$. nscriere/citire de caractere 74
$2.2.2. nscriere/citire de #iruri 75
$2.2.3. ntrare/ie#ire cu format 77
$2.2.4. Fi#iere #i structuri 78
Anexa$. Func!ii de intrare-ie#ire n C/C++ 8$
Anexa 2. Func!ii matematice 89
Anexa 3. Func!ii folosite la prelucrarea #irurilor de caractere 97



5
ntroducere

Scopul prezentei lucr"ri este familiarizarea studen!ilor cu principalele
instrumente #i metode de programare n limbajele C #i C++.
Limbajul de programare C a fost elaborat de c"tre Denis M.Ritchi n $972 #i
descris detaliat n cartea Limbajul de programare C de Ritchi #i Brian B.Kernigan.
Realizarea limbajului n conformitate cu regulile descrise n carte poart" denumirea
de Standard C K&R #i este realizarea standard minimal". n $983 a fost creat un
nou standard C de c"tre American National Standards Institute numit Standard
ANSI-C. Mai apoi a fost elaborat limbajul C++ ca o derivat" a limbajului C.
n a#a fel limbajul C++ posed" marea majoritate a posibilit"!ilor limbajului
ANSI-C #i n plus la acestea alte instrumente de programare cu posibilit"!i mai
avansate.
Lucrarea de fa!" con!ine descrierea att a instrumentelor din limbajul ANSI-C
ce snt sus!inute #i de copmpilatoarele C++, ct #i descrierea instrumentelor de
programare ale limbajului C++.
Deasemenea n lucrare este atras" o deosebit" aten!ie exemplelor practice de
rezolvare a diferitor tipuri de probleme cu l"murire detaliat".
Prezenta lucrare este o parte din suita de lucr"ri didactico- metodice elaborate
de c"tre lectorul superior Sergiu G. Istrati ndreptate spre optimizarea procesului de
instruire a studen!ilor la disciplina Programare. Au fost elaborate urm"toarele lucr"ri:
Ciclu de prelegeri la disciplina Programare. Limbajul Pascal.
Ciclu de prelegeri la disciplina Programare. Limbajul C. (prezenta lucrare)
ndrumar metodic privind ndeplinirea lucr"rilor de laborator.
ndrumar metodic privind ndeplinirea lucr"rilor individuale.
ndrumar metodic privind ndeplinirea lucr"rii de curs.
Toate aceste lucr"ri pot fi accesate n Internet pe adresa www.istrati.com











6
Limbajul de programare C.
$. Alfabetul limbajului.
Numim limbaj de programare un limbaj prin care putem comunica unui
calculator metoda de rezolvare a unei probleme. Iar metoda de rezolvare a problemei,
dup" cum #tim deja o numim algoritm. ntreaga teorie informatic" se ocup" de fapt cu
elaborarea unor noi calculatoare, limbaje de programare #i algoritmi. Datoria oric"rui
limbaj de nivel nalt este s" ne pun" la dispozi!ie o sintax" ct mai comod" prin care
s" putem descrie datele cu care lucreaz" programul nostru #i instruc!iunile care
trebuiesc executate pentru a rezolva o anumit" problem".
Limbajul de programare C ca #i orice alt limbaj de programare #i are alfabetul
s"u #i specificul de utilizare a simbolurilor. Alfabet al unui limbaj de programare se
nume#te un set de simboluri permis pentru utilizare #i recunoscut de compilator, cu
ajutorul c"ruia pot fi formate m"rimi, expresii #i operatori ai acestui limbaj de
programare. Alfabetul oric"rui limbaj de programare con!ine cele mai simple
elemente cu semnifica!ie lingvistic", iar sintaxa limbajului define#te modul n care se
combin" elementele vocabularului pentru a ob!ine fraze corecte (instruc!iuni,
secven!e de instruc!iuni, declar"ri de tipuri, variabile, constante, etichete, func!ii,
proceduri etc.). Elementele vocabularului sunt alc"tuite din caractere. Orice caracter
este reprezentat n calculator, n mod unic, printr-un num"r natural cuprins ntre 0 #i
$27, numit cod ASCII. Mul!imea elementelor alfabetului limbajului de programare C
se poate mp"r!i n 5 grupe:
$) Simboluri folosite la formarea identificatorilor #i cuvintelor cheie. n componen!a
aceastei grupe intr" literele minuscule #i majuscule ale alfabetului latin (englez) #i
simbolul subliniere _. Este de men!ionat faptul c" literele minuscule #i majuscule
de acela#i fel (Exemplu: a #i A) sunt interpretate ca simboluri diferite din cauza c" au
diferite coduri ASCII.
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
a b c d e f g h i j k l m n o p q r s t u v w x y z _
2) Literele minuscule #i majuscule ale alfabetului rus (sau altui alfabet na!ional) #i
cifrele arabe.
& ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C
D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b
0 $ 2 3 4 5 6 7 8 9
3) Simboluri speciale ce se folosesc le organizarea proceselor de calcul #i la
transmiterea compilatorului unui set de instrunc!iuni.



7
Simbolul Denumirea Simbolul Denumirea
, Virgul" ) Parantez" rotund" nchis"
. Punct ( Parantez" rotund" deschis"
; Punct-virgul" } Parantez" figurat" nchis"
: Dou" puncte { Parantez" figurat" deschis"
? Semnul ntreb"rii < Mai mic
' Apostrof > Mai mare
! Semnul exclam"rii [ Parantez" patrat" deschis"
| Linie vertical" ] Parantez" patrat" nchis"
/ Slash # Num"r (diez)
\ Slash inversat % Procent
~ Tilda & Ampersand
* Stelu!a ^ Negare logic"
+ Plus = Egal
- Minus " Ghilimele

4) Simboluri de conducere #i de desp"r!ire. n componen!a acestei grupe intr" spa!iul
(blank-ul), simbolul tabulare, simbolul de trecere n rnd nou, ntoarcerea
c"ruciorului, linie nou" #i pagin" nou". Aceste simboluri au destina!ia de a desp"r!i
obiectele determinate de utilizator a#a ca constante #i identificatori. O consecutivitate
de simboluri de desp"r!ire este precautat" de c"tre compilator ca un singur simbol.
(Exemplu: mai multe blank-uri consecutive).
5) Pe lng" grupele de simboluri prec"utate limbajul C pe larg folose#te
consecutivit"!i de conducere, adic" combina!ii de simboluri speciale folosite n
func!iile de intrare-ie#ire a informa!iei. Consecutivitatea de conducere este alc"tuit"
dintr-un slash inversat (\), care se afl" neap"rat pe primul loc, dup" care urmeaz" o
combina!ie din litere latine #i cifre.

Consecutivitatea de
conducere
Denumirea
Echivalentul
hexazecimal
\a Sunet (beep) 007
\b ntoarcere cu o pozi!ie 008
\t Tabulare orizontal" 009
\n Trecere n rnd nou 00A
\v Tabulare vertical" 00B

8
\r ntoarcerea c"ruciorului 00C
\f Trecerea n alt format 00D
\" Ghilimele 022
\' Apostrofa 027
\0 Simbolul zero 000
\\ Slash inversat 05C
\ddd (d-cifr") Simbolul grupului de coduri PC n sistemul octal
\xddd (d-cifr")
Simbolul grupului de coduri PC n sistemul
hexazecimal


Consecutivitatea de tipul \ddd #i \xddd (aici prin d este notat" o cifr" orecare)
permite a scrie un cod al calculatorului ca o consecutivitate de cifre octale sau
hexazecimale respectiv. De exemplu simbolul de ntoarcere a c"ruciorului poate fi
interpretat n diferite moduri: \r consecutivitatea general" de conducere, \0$5 -
consecutivitatea octal" de conducere, \x00D - consecutivitatea hexazecimal" de
conducere.
n afar" de aceasta n limbaj sunt rezervate cuvinte de serviciu, numite cuvinte
cheie care pot fi folosite ntr-un sens strict definit: int, float, double, char, long,
signed, unsigned, const, volatile, sizeof, if, else, goto, case, default, for, while, do,
break, continue, near, far, void, return, pascal, cdecl, intrrupt, auto, extern, static,
register, union, enum, typedef, asm, _cs. _ds, _es, _ss, _AH, _AX, _BX, _BL, _CH,
_CL, _CX, _DX, _DL, _BP, _DI, _SI, _SP.
Cuvintele cheie definesc sensul semantic al instruc!iunilor din C. Cuvintele
cheie ce ncep cu semnul _ (subliniere) se folosesc pentru acces la segmentele de date
#i la registrele calculatorului.
Prin sintaxa unui limbaj de programare se n!elege, n general, un ansamblu de
reguli de agregare a unit"!ilor lexicale pentru a forma structuri mai complexe
(instruc!iuni, declara!ii, programe etc.) Structura unui program n limbajul de
programare C deasemenea #i are regulile ei de sintax" dup" cum urmeaz": un antet,
urmat de func!iile secundare dup" care urmeaz" corpul func!iei principale (care
con!ine n componen!a sa #i o parte declarativ"). %i pentru descrierea n detaliu a
acestor componente sunt necesare, desigur #i alte reguli.

2. Structura unui program.
Pentru a primi o reprezentare general" a programului n C s" urm"rim un
exemplu concret. Presupunem, c" exist" un masiv unidimensional x cu n elemente de

9
tip ntreg #i e necesar s" alc"tuim un program, care calculeaz" #i afi#az" suma
elementelor ntregului masiv. Aceasta este o problem" tipic" pentru prelucrarea
masivelor unidimensionale.
n concep!iile limbajului C fiecare algoritm eviden!iat se realizeaz" de o unitate
de program numit" func!ie. Stilul de programare n C se caracterizeaz" prin tendin!a
de a eviden!ia un num"r mare de func!ii nu prea voluminoase, astfel, ca prelucrarea
datelor n aceste func!ii s" nu depind" de celelalte p"r!i a programului. Acest lucru
face programul destul de n!eles #i d" posibilitatea de a introduce u#or corec!ii n
unele func!ii f"r" a tangenta celelalte. Prin func!iile eviden!iate unica cu care ncepe
ndeplinirea programului se nume#te principal" #i are denumirea fixat": main. Toate
celelalte func!ii au denumire arbitrare, pe care programatorul singur le nume#te. Ele
pot fi nscrise n fi#ierul ini!ial pn" la func!ia main (n ordine arbitrar") sau se pot
afla n fi#iere diferite pe un suport magnetic. n programul de mai jos, ce realizeaz"
rezolvarea problemei intr" func!ia main() #i func!ia numit" suma(). S" analiz"m acest
program:
# include<stdio.h>
# include<conio.h>
int suma (int y[10], int m) {
int i, suma=0;
for (i=0;i<m;i++) {
suma +=y[i]; } return (suma); }
void main (void) {
int w,n,i,x[10]; clrscr( );
printf("Culege marimea masivului n<10\n");
scanf("%d", &n);
printf("Culege masivul x[%d]\n",n);
for (i=0;i<n;i++) {
printf("Culege elementul x[%d]\n",i);
scanf("%d",&x[i]); }
w=suma(x,n);
printf("suma=%d\n",w);
getch( ); }
Primele dou" rnduri: #include <stdio.h> #i #include <conio.h>
nu snt instruc!iuni ale limbajului C. Simbolul # indic" c" acestea snt directive ale
procesorului. Procesorul execut" prelucrarea prealabil" a textului programului nainte
de compilare. n cazul dat, aceste directive ne dau de n!eles c" n fi#ierul ce se
compileaz" trebuie introdus" informa!ia din fi#ierele sistemului Turbo C stdio.h

$0
(Standard Input/Output Header titlu de introducere-extragere) #i conio.h (Console
Input / Output Header- titlu de introducere-extragere de la consol"). Existen!a acestor
directive este condi!ionat" de faptul c" n textul programului snt folosite func!iile
ncorporate printf() #i clrscr(), informa!ia despre care se con!ine n fi#ierele indicate.
Urmatorul rnd int suma (int y[10], int m) con!ine declararea functiei suma() cu 2
parametri: un masiv y[10] #i o variabila simpla m de tip ntreg. Aici e necesar de
men!ionat faptul, c" n limbajul C orice program ncepe de la func!ia principal"
main(), independent de faptul cte func!ii auxiliare se con!in n program. Lund n
considera!ie acest fapt, func!ia suma() va fi analizat" la momentul cnd apelul ei va fi
efectuat din corpul func!iei principale main().
Rndul din program: void main (void) define#te titlul func!iei principale cu
numele main(). Cuvntul void din fa!a func!iei semnific" faptul, c" aceast" func!ie nu
va ntoarce valori n procesul execu!iei sale. Parantezele rotunde ce urmeaza dup"
main() indic" compilatorului c" aceasta este o func!ie, iar cuvntul void din paranteze
faptul c" func!ia nu folose#te parametri. Perechea acoladelor: prima ce se deschide
dup" main() #i corespunz"tor acolada ce se nchide dup" func!ia getch(); m"rgine#te
instruc!iunile care formeaz" corpul func!iei principale main(). n limbajul C perechea
de accolade {} m"rgine#te o secven!" de instruc!iuni care se precaut" ca un tot ntreg.
Urm"toarul rnd con!ine descrierea variabilelor folosite n func!ia principal" main():
int w,n,i,x[10]; care transmite compilatorului c" n program vor fi folosite
variabilele w,n #i i de tip ntreg #i un masiv x cu m"rimea de $0 elemente de tip
ntreg. Dup" descrierea datelor urmeaz" instruc!iunea de adresare la func!ia clrscr()
ncorporat" n biblioteca conio.h din Turbo C.
Aceast" func!ie are destina!ia de cur"!ire a ecranului. Dup" ea urmeaz" func!ia
printf(), care afi#az" pe ecran un comentariu. n acest caz func!ia printf("Culege
marimea masivului n<10\n"); afi#az" pe ecran propunerea de a culege m"rimea
masivului #i simbolul \n de trecere n alt rind. Func!ia urm"toare scanf("%d", &n);
este o func!ie de intrare #i face posibil" introducerea de la tastatur" a valorii m"rimii
masivului n. Simbolul %d indic" func!iei c" valoarea citit" este de tip ntreg, iar
simbolul & indic" adresa de memorie unde va fi nscris" valoarea lui n. Func!ia
printf("Culege masivul x[%d]\n",n); deasemenea afi#az" un comentariu pe ecran #i
propune culegerea valorilor elementelor masivului x cu marimea n deja cunoscut".
Urm"toarea instruc!iune este instruc!iunea ciclic" for. Aceast" instruc!iune este
compus" #i are ca sarcin" repetarea unui set de instruc!iuni de cteva ori cu diferite
valori ale parametrilor.
for (i=0;i<n;i++) {printf("Culege elementul x[%d]\n",i); scanf("%d",&x[i]);}

$$
aici cuvntul for este cuvnt rezervat, i-parametrul ciclului, care-#i schimb" valoarea
de la 0 la n cu pasul $ datorit" instruc!iunii de incrementare i++. Corpul ciclului, care
va fi repetat de n ori este m"rginit de perechea de accolade deschis" #i nchis", #i este
compus din 2 func!ii: prima printf(), care afi#az" un comentariu pentru culegerea
valorii elementului current al masivului #i a doua scanf(), care face posibil" nscrierea
valorii elementului current al masivului de la tastatur" n memorie. n a#a fel, la
sfr#itul ndeplinirii ciclului toate elementele masivului x[n] vor avea valori, fapt ce
face posibil" calcularea sumei totale a elementelor din masiv. Dup" executarea
instruc!iunii ciclice for urmeaz" instruc!iunea de atribuire w=suma(x,n);. n partea
dreapt" a acestei atribuiri este amplasat" func!ia suma(). Anume valoarea acestei
func!ii, dup" executarea cu folosirea parametrilor locali x #i n, va fi atribuit"
variabilei w. S" analiz"m func!ia suma():
int suma (int y[10], int m) { int i, suma=0;
for (i=0;i<m;i++) { suma +=y[i]; } return (suma); }
Ca #i la declararea oric"rei func!ii n limbajul C nti de toate urmeaz" antetul
func!iei: int suma (int y[10], int m) , unde cuvntul int din fa!a numelui func!iei suma
este tipul valorii ntors de func!ie n programul principal main(). Parantezele rotunde
dup" numele func!iei m"rginesc lista de parametri formali folosi!i de func!ie. Ace#ti
parametri snt un masiv de tip ntreg y cu lungimea $0 elemente #i o variabil" de tip
ntreg m. Este de men!ionat faptul c" la momentul chem"rii func!iei suma() din cadrul
programului principal main(), valorile parametrilor actuali (n cazul nostru x-masivul
prelucrat #i n-m"rimea lui) snt atribuite parametrilor formali din func!ie (n cazul
nostru masivul y #i marimea lui m) #i este necesar" ndeplinirea urm"toarei condi!ii:
parametrii actuali trebuie s" corespund" ca cantitate, pozi!ie #i tip cu parametrii
formali. Acoladele deschis" dup" antetul func!iei #i corespunz"tor nchis" dup"
operatorul return(); delimiteaz" corpul func!iei suma(), care #i are #i ea sec!iunea de
declarare a datelor. Aici int i, suma=0; declar" variabila local" i de tip ntreg #i
ini!ializeaz" func!ia suma() cu valoarea 0. Urm"toarea este instruc!iunea ciclic" for
care con!ine n corpul s"u delimitat de accolade o singur" instruc!iune: instruc!iunea
compus" de atribuire suma+=y[i]; echivalent" cu instruc!iunea suma=suma+y[i];
care calculeaz" suma elementelor din masiv. Ciclul va fi repetat de m ori cu diferite
valori a parametrului i, unde m este m"rimea masivului, adic" cantitatea elementelor
din masiv, iar i-num"rul de ordine a elementului current din masiv. Dup" executarea
ciclului variabila suma va con!ine valoarea final" a sumei tuturor elementelor din
masiv. Transmiterea acestei valori func!iei principale main() este efectuat" de c"tre
operatorul retun(suma); . Dup" executarea acestui operator valoarea sumei va fi

$2
inclus" n locul de unde a fost chemat" func!ia suma(), n cazul nostru aceasta este
instruc!iunea de atribuire w=suma(x,n);
Deci, valoarea sumei elementelor masivului va fi atribuit" variabile w. Dup"
aceasta urmeaz" afi#area pe ecran a rezultatului final: printf("suma=%d\n",w); .
Ultima instruc!iune din program este apelul la func!ia getch(), care opre#te executarea
programului cu scopul vizualiz"rii rezultatului pn" cnd nu va fi culeas" tasta Enter.
n a#a fel poate fi descris" structura general" a unui program n C dup" cum
urmeaz": orice program ncepe cu includerea bibliotecilor de func!ii care vor fi
folosite n program, dup" aceasta urmeaz" declararea tuturor func!iilor auxiliare
folosite n program, care au urm"toarea componen!": antetul func!iei, sec!ia de
declarare a variabilelor, constantelor locale, dup" care urmeaz" corpul func!ei; dup"
declararea tuturor func!iilor auxiliare urmeaz" corpul func!iei principale main()
delimitat de o pereche de accolade, care con!ine descrierea variabilelor, constantelor
#i ns"#i instruc!iunile programului principal.

3. Tipuri de date.
Un program n limbajul C con!ine o descriere a ac!iunilor ce trebuie s" fie
executate de calculator #i o descriere a datelor ce sunt prelucrate de aceste ac!iuni.
Ac!iunile snt descrise prin instruc!iuni, iar datele prin declara!ii (sau defini!ii).Prin
tip de date se n!elege o mul!ime de valori care pot fi atribuite unei variabile sau
constante. Tipurile de date n C pot fi mp"r!ite n dou" categorii: simple
(elementare) #i compuse (structurate). n general, tipurile de date sunt definite explicit
de c"tre programator #i sunt specifice programului n care apar. Exist" ns" tipuri de
date elementare de interes mai general, numite tipuri predefinite a c"ror defini!ie se
consider" cunoscut" #i nu cade n sarcina programatorului.

3.$. Tipuri de date simple predefinite. Constante.
Un program n C con!ine n mod explicit diferite valori textuale #i numerice.
A#a valori, ce apar n program, snt numite constante. Constanta este o valoare
numeric" sau textual", care ntotdeauna este definit" #i n mersul ndeplinirii
programului r"mne neschimbat". Tipul constantei se define#te de forma ei de
nscriere, iar valoarea ei este ncheiat" n ea nse#i.

3.$.$. Constante ntregi.
Constanta ntreag" este un num"r nscris n program f"r" punct zecimal #i f"r"
indicatorul de putere. Constantele ntregi n C pot fi: Zecimale, Octale,
Hexazecimale.

$3
Sistemul de enumerare a constantelor este recunoscut de compilator dup"
forma lor de nscriere.Dac" constanta este nscris" prin intermediul cifrelor 0..9 #i
prima cifr" nu e zero, atunci constanta se consider" zecimal". De exemplu: $23, 45,
37. Dac" constanta este nscris" folosind cifrele 0..7 #i prima cifr" este zero, atunci
constanta se consider" octal". De exemplu: 045, 037. Dac" constanta este nscris" cu
ajutorul cifrelor 0..9 #i literelor a..f sau A..F #i se ncepe cu 0x sau 0X, atunci
constanta este hexazecimal". De exemplu: 0x45, 0x37. n aceste exemple constantele
nscrise cu unele #i acelea#i cifre au valori diferite, ce se definesc de baza sistemului
de enumerare.
Pentru determinarea constantelor de tip ntreg sunt folosite diferite cuvinte
rezervate, care determin" diapazonul valorilor #i volumul de memorie rezervat pentru
constant".

Tipul Volumul de memorie (octe!i) Diapazonul de valori
int 2 -32768 32767
Short (short int) 2 0 255
Long (long imt) 4
-2 $47 483 648
2 $47 483 647
unsigned int 2 0 65 535
unsigned long 4 0 4 294 967 295

n dependen!" de valoarea constantei, compilatorul aloc" pentru reprezentarea
ei n calculator doi sau patru octe!i de memorie. Pentru valorile -32768...32767 se
aloc" doi octe!i, unde primul bit se interpreteaz" ca semnul constantei, iar $5 bi!i
r"ma#i definesc valoarea ei. n a#a caz constanta este de tipul int (ntreg). Pentru
valorile de la 0 65535 se aloc" doi octe!i de memorie, ns" to!i $6 bi!i definesc
valoarea constantei. A#a fel de constant" are tipul unsigned int (ntreg f"r" semn).
Constantele acestui diapazon, nscrise cu semnul minus se cerceteaz" ca f"r" semn, la
care se aplic" opera!ia minus unar.
Pentru valorile de la -2 $47 483 648 pna la 2 $47 483 647 se aloc" 4 octe!i, la
care primul bit se interpreteaz" ca semn, iar 3$ de bi!i r"ma#i ca valoare a
num"rului. A#a constante au tipul long (lung).
Pentru valorile de la 0 pna la 4 294 967 295 se aloc" 4 octe!i, la care to!i 32 de
bi!i se interpreteaz" ca valoare. A#a constant" are tipul unsigned long (lung f"r"
semn). Pentru acest tip la constantele negative se aplic" opera!ia minus unar.
Analogic se aloc" memorie pentru constantele octale #i hexazecimale, aflate n
diapazonul zecimal respectiv.

$4
Constantele, ce snt nscrise n program sub forma unui num"r mai mare ca
4 294 967 295 aduc la supranc"rcare, ns" compilatorul nu face prentmpinare, iar n
memorie se nscriu bi!ii inferiori ai constantei trunchiate. Programatorul are
posibilitate de a indica explicit compilatorului, c" pentru o oarecare constant" este
necesar de alocat 4 octe!i #i de a indica interpretarea lor ca f"r" semn (unsigned).
Pentru aceasta se folosesc modificatori speciali, nscri#i dup" cifra mai mic" a
constantei. Pentru a indica, c" constanta are tipul long, trebuie de nscris
modificatorul L sau I ( se permite de asemenea #i l sau i).
n standardul K&R C ini!ializarea constantelor de tipul ntreg are urm"toarea
sintax":
#define name value care este plasat" pn" la func!ia main(). Unde #define este
directiva compilatorului, name numele constantei, value valoarea constantei. De
exemplu: #define K 35 sau #define salariu 700. ntre directiv", nume #i valoarea
constantei este necesar" prezen!a la minim un spa!iu. n exemplele de mai sus
compilatorul implicit va atribui variabilelor K #i salariu valori de tipul ntreg, ntruct
numerele 35 #i 700 au sintaxa #i formatul constantelor de tip ntreg.
Unele compilatoare C, ce sus!in standardul ANSI-C permit ini!ializarea
constantelor n 2 moduri. Primul mod cu folosirea directivei #define a fost descris
mai sus. Al doilea mod folose#te cuvntul rezervat const pentru ini!ializarea
constantei, descrierea tipului ei #i atribuirea valorii #i are urm"toarea sintax":
const int name = value; care este plasat" dup" func!ia main(), unde const este
cuvnt rezervat pentru ini!ializarea constantelor, int cuvntul rezervat pentru
desemnarea constantelor de tip ntreg #i value valoarea constantei. De exemplu:
main() {
const int K = 35;
;
const int salariu = 700;
; }

3.$.2. Constante reale.
Constantele reale (flotante) reprezint" numere zecimale frac!ionare ce pot fi
scrise sub dou" forme: form" cu punct #i form" cu ordin. Constanta real" n form" cu
punct se scrie ca frac!ie zecimal" cu semn sau f"r" semn, la care partea ntreag" #i
partea frac!ionar" se despart prin punct. Dac" semnul constantei este omis ea se
socoate pozitiv". Constanta real" n form" cu ordin este comod" pentru scrierea
numerelor foarte mari sau foarte mici. n C, ca #i n majoritatea limbajelor de
programare, pentru a#a nscrieri se folosesc constante reale n form" cu ordin, ce au

$5
aspectul: mantisa_e_ordinul sau mantisa_E_ordinul. n aceste nota!ii n calitate de
mantis" poate fi scris" sau o constant" zecimal" f"r" modificator sau o constant" real"
n form" cu punct. n calitate de ordin se scrie o constant" ntreag" zecimal", posibil
cu semn, ce determin" puterea num"rului zece. Dac" semnul ordinului lipse#te se
subn!elege semnul +. De exemplu 7.32E+14 = 7.32*10
$4
; 55.000000E-3 = 0.055;
Pentru determinarea constantelor de tip real sunt folosite diferite cuvinte
rezervate, care determin" diapazonul valorilor #i volumul de memorie rezervat pentru
constant".

Tipul Volumul de memorie (octe!i) Diapazonul de valori
Float 4 3.4E-38 3.4E+38
Double 8 $.7E-308 $.7E+308
Long double $0 3.4E-4932 3.4E+4932

Constantele reale au un nivel orecare de aproxima!ie, care depinde de
compilator. n a#a fel cifra 6.$23456789$2345 n diapazonul de aproxima!ie pentru
tipul float va fi interpretat" de compilator ca 6.$23456, acest tip se mai nume#te tip cu
aproxima!ie unitar" #i are aproxima!ia 6 pozi!ii dup" punct. Tipul double se mai
nume#te tip cu aproxima!ie dubl" #i are aproxima!ia de pn" la $5 $6 pozi!ii dup"
punct. Sintaxa de ini!ializare a constantelor de tip flotant (real) este urm"toarea:
Dup" standardul K&R-C : #define PI 3.14.
Dup" standardul ANSI-C const float PI = 3.14; inclusiv cel din K&R C.

3.$.3. Constante caracter.
O constant" caracter este un oarecare caracter al alfabetului luat n apostrofe.
Exemplu: caracter .
Valoarea unei constrante de tip caracter (char) poate fi o liter", o cifr" sau un
alt simbol al tastaturii. Pentru fiecare constant" de tip caracter n memorie se aloc"
cte un octet. Mul!imea valorilor unei constante de tip carecter este urm"toarea:
literele minuscule #i majuscule ale alfabetului latin, zece cifre arabe 0..9 #i simboluri
speciale ! @ # $ % ^ & * ( ) _ + = | \ / }{ : ; ? > . < , ~ `
Exist" doua metode de scriere a caracterelor.
Prima metod": Orice caracter al tabelului codurilor ASCII poate fi reprezentat
n form" de constanta caracter astfel: \ddd sau \xHHH ,
unde dddcodul octal, HHHcodul hexazecimal al caracterului. Zerourile ce stau n
fa!a codului caracterului pot fi omise.

$6
Metoda a doua: Caracterele des folosite ce nu se reflect" pe ecran nu trebuie
scrise sub form" de cod. n acest caz se folosesc nota!iile lor rezervate. Aceste
caractere n C sunt repartizate n clasa caracterelor de control. Dac" caractere de
control se ntlnesc, spre exemplu, n rndul de extragere, atunci ele provoac" o
ac!iune corespunz"toare.
Sintaxa de ini!ializare a constantelor de tip caracter (char) este urm"toarea:
Dup" standardul K&R-C : #define Lit C.
Dup" standardul ANSI-C const char Lit = C; inclusiv cel din K&R C.

3.$.4. %iruri de caractere.
Un #ir este o succesiune de caractere ale alfabetului cuprinse ntre ghilimele.
Spre deosebire de alte limbaje de programare, limbajul C nu con!ine un tip de date
special ce desemneaz" #irurile de caractere. Limbajul C opereaz" cu #irurile cum ar
lucra cu o succesiune de date de tip caracter amplasate ntr-o structur" numit" masiv.
Aici fiecare simbol din #ir este o component" aparte a masivului de tip char. Tipul
masiv este un tip structurat n C #i va fi studiat n capitolul Tipuri structurate
Not!: Unele compilatoare C #i C++ sus!in tipuri de date speciale pentru operare cu
#iruri de caractere #i con!in biblioteci de func!ii pentru prelucrarea #irurilor.

4. Variabile.
Variabila este o m"rime care n procesul ndeplinirii programului poate primi
valori diferite. Pentru variabile programatorul trebuie s" determine nota!ii
caracteristice proprii care se numesc identificatori. Deseori identificatorii sunt numi!i
nume simbolice sau pur #i simplu nume.

4.$. Nume de variabile (identificatori).
Numele variabilei (identificatorul variabilei) este o succesiune de caractere #i
cifre ale alfabetului ce se ncepe cu o liter" sau cu caracterul de subliniere. n Turbo C
se permit urm"toarele caractere la formarea identificatorilor : Literele mari A..Z,
literele mici a..z, cifrele arabe 0..9 precum #i caracterul de subliniere_. n privin!a
lungimii numelui nu-s nici un fel de limite, dar pentru compilatorul Turbo C au
valoare doar primele 32 de caractere. Ex: A, b, x, y, Suma, Gama, Text_no, beta, a$,
b_$.

4.2. Descrierea variabilelor.
Toate variabilele din program trebuie s" fie descrise. Descrierea variabilelor de
obicei se efectueaz" la nceputul programului cu ajutorul instruc!iunilor de descriere.

$7
Instruc!iunea de descriere a variabilelor are urm"toarea form" general" de
nscriere: tip v1,v2,,vn;
unde : tip - determin" tipul valorilor pe care le pot primi variabilele v$,v2,..,vn. n
calitate de tip se folose#te unul din cuvintele cheie deja cunoscute int, float, double
sau char. Punctul #i virgula este semnul sfr#itului instruc!iunii. ntre cuvntul cheie ce
determin" tipul variabilelor #i lista numelor variabilelor, trebuie s" fie cel pu!in un
blanc. De exemplu:
main() {
float salary, suma, total;
int timc, count;
char znak, litera; }

4.3. Ini!ializarea variabilelor.
Atribuirea valorii ini!iale unei variabile n timpul compil"rii se nume#te
ini!ializare. La descrierea variabilelor compilatorului i se poate comunica despre
necesitatea ini!ializ"rii.
Exemple de instruc!iuni de descriere cu ini!ializarea variabilelor:
main() {
char bara=\, litera=T;
int anul=2000, luna=9;
float alfa,beta,gama=1,7e-12; }
n ultima instruc!iune de descriere e ini!ializat" doar variabila gama, cu toate c"
la prima vedere pare c" toate trei sun egale cu 1,7e-12. Din aceats" cauz" e mai bine
de evitat amestecarea variabilelor ini!ializate #i neini!ializate n una #i aceia#i
instruc!iune de descriere.
Exist" cazuri, cnd folosirea unei variabile neini!ializate poate duce la erori
grave din punct de vedere logic la calcularea unor valori. n timpul includerii
calculatorului, celulele de memorie nefolosite de sistemul opera!ional con!in date
aleatoare. Cnd variabila este declarat" #i ei i se rezerveaz" loc n memorie, con!inutul
acestor celule de memorie nu se schimb" pn" cnd variabila nu este ini!ializat" sau
pn" cnd ei nu i se atribuie vre-o valoare. Din aceast" cauz", dac" variabila ce n-a
fost ini!ializat" #i nu i s-a atribuit nici o valoare pe parcursul programului este folosit"
n calculul unei valori, rezultatul va fi incorect. Acest fapt impune necesitatea
ini!ializ"rii oric"rei variabile n timpul declar"rii acesteia. Aceste ini!ializ"ri presupun
atribuirea valorii 0 (zero) pentru variabile numerice #i (spa!iu) pentru cele
caracteriale sau de tip #ir de caractere.


$8
5. Opera!ii "i expresii.
5.$. Opera!ii aritmetice.
n calitate de opera!ii aritmetice limbajul C folose#te urm"toarele:
$) Adunare (+).
2) Sc"derea (-).
3) nmul!irea (*).
4) mp"r!irea (/).
5) Luarea modulului (%).
6) Plusul unar (+).
7) Minusul unar (-).

5.2. Opera!ia de atribuire.
Opera!ia de atribuire poate fi simpl" sau compus", n dependen!" de semnul opera!iei
de atribuire. Opera!ia de atribuire simpl" se noteaz" cu semnul = #i e folosit" pentru a
atribui variabilei valoarea vreunei expresii. Ex: x=7; n limbajul de programare C n
expresii se permite folosirea unui num"r arbitrar de opera!ii de atribuire. Opera!iile de
atribuire au o prioritate mai joas" dect cele descrise anterior #i se ndeplinesc de la
dreapta spre stnga. Opera!ia de atribuire leag" variabila cu expresia, atribuind
variabilei valoarea expresiei, ce st" n dreptul semnului de atribuire.
Opera!iilor binare: + - * / % >> << & | le corespunde opera!ia de atribuire
compus", care se noteaz" ca op=, unde op este una din opera!iile enumerate mai sus,
de exemplu, += #i *= etc.
Opera!ia de atribuire compus" sub forma: _variabila_op=_expresie_ se define#te
prin opera!ia de atribuire simpl" astfel: _variabila_=_variabila_op_expresie_
De exemplu, d+=2 este echivalent cu d=d+2. De regul" pentru opera!iile de atribuire
compuse calculatorul construie#te un program mai efectiv.

5.3. Opera!ii de incrementare(decrementare).
Opera!ia de incrementare notat" prin dou" semne plus consecutive, se aplic"
asupra unei singure variabile #i m"re#te valoarea cu o unitate. Opera!ia de
decrementare se noteaz" prin dou" semne minus mic#ornd valoarea ei cu o unitate.
Opera!ia de incrementare poate fi folosit" att ca prefix ct #i ca sufix. Diferen!a dintre
acestea const" n momentul schimb"rii valorii variabilei. Forma prefix" asigur"
schimbarea variabilei pn" la folosirea ei. Iar forma sufix" - dup" folosirea ei.
Opera!iile de incremenatare decrementare se aplic" asupra unor variabile de tip
ordonat(a#a ca int). Exemple:
Opera!ia x++; asigur" incrementarea variabilei x cu o unitate.

$9
n expresia s=y*x++; incrementarea lui x se va face numai dup" calcularea
valorii lui s;
Iar n expresia s=y*++x; nti se va incrementa x #i numai dup" aceia va fi
calculat" valoarea pentru s.
%i dac" pentru m=5 vom scrie expresia m+++2, compilatorul trateaz" primele dou"
plusuri ca forma sufix" de incrementare a variabilei m. Valoarea expresiei va fi 7, #i
doar apoi variabila m se va m"ri cu unu. Expresia (i+j)++ este gre#it" c"ci opera!ia
de incrementare se aplic" doar c"tre numele variabilei. Opera!ia de incrementare are o
prioritate mai nalt" dect cea aritmetic".

5.4. Rela!ii "i opera!ii logice.
Opera!iile de rela!ie snt:
$) Mai mare (>).
2) Mai mare sau egal (>=).
3) Mai mic (<).
4) Mai mic sau egal (<=).
5) Egal (==).
6) Diferit (!=).
Opera!iile de rela!ie formeaz" o valoare adev"rat" sau fals" n dependen!a de
faptul n ce raport se afl" m"rimile ce se compar". Dac" expresia de rela!ie e
adev"rat" atunci valoarea ei este unu, n alt caz - 0.
Opera!iile de rela!ie au o prioritate mai mic" dect cele aritmetice #i de
incrementare. ntre opera!iile de rela!ie primele patru au aceia#i prioritate #i se
ndeplinesc de la stnga la dreapta. Ultimele dou" opera!ii au o prioritate nc" mai
mic" #i expresia a va primi valoarea unu doar atunci cnd #i prima expresia #i a doua
expresie este adev"rat". Opera!iile de rela!ie se pot folosi pentru toate tipurile de date
de baz", cu excep!ia #irurilor de caractere (Pentru compararea #irurilor se folosesc
func!ii incorporate).
Exemple de expresii de rela!ii:
a>b;
(a + b )<2.5;
7.8<=(c+d);
a>b==2;
Expresia de rela!ie a>b==2 ntotdeauna va avea valoarea zero (fals). C"ci
independent de valoarea variabilelor, subexpresia a>b va avea valoarea zero sau unu
#i compararea oric"rei din aceste valori cu 2 ne d" 0.

20
Astfel observ"m c" n limbajul de programare Turbo C putem scrie expresii ce
par f"r" sens din punct de vedere al limbajelor de programare tradi!ionale.
S" cercet"m opera!iile logice. Ele , de obicei, se folosesc n calitate de
leg"turi pentru reuniune a dou" sau mai multe expresii . Tabelul ce urmeaz"
determin" opera!iile logice n Turbo C.
Opera!iile logice:

Numele opera!ii logice Semnul opera!ii n Turbo C
$.Conjunc!ie (SI logic)
2.Disjunc!ie (SAU logic)
3.Negare (NU logic)
&&
||
|

Dac" expr1 #i expr2 sunt careva expresii , atunci
expr1 && expr2 e adev"rat" n cazul cnd ambele sunt adev"rate
expr1||expr2 e adev"rat" n cazul cnd m"car una din expresii e adev"rat".
!expr1 e adev"rat" dac" expr1 e fals" #i invers.
Noi am stabilit pentru expr1 #i pentru expr2 cazul cel mai general f"r" a mai indica ce
fel de expresii ele sunt. Deci avem dreptul s" scriem: 5&&2 . Valoarea acestei
expresii va fi $, din cauza c" n Turbo C valoarea nenul" se trateaaz" ca adev"r iar
cea nul" ca fals. Priorit"!ile opera!iilor logice se aranjeaaz" n ordine descresc"toare
astfel: Negare (!). Conjunc"ie (&&). Disjunc"ie (||). Opera!iile logice au o prioritate
mai mic" dect opera!iile de rela!ie.
Calcularea expresiilor logice, n care sunt numai opera!ii &&, se termin" dac"
se descoper" falsitatea aplic"rii urm"toarei opera!ii &&. Ree#ind din defini!ia
semanticii opera!ia &&, cum numai apare valoarea fals prelungirea calculelor nu are
rost. Analog pentru expresiile logice ce con!in numai opera!ii ||, calculele se termin"
odat" ce apare valoarea adev"r. Exemple de expresii logice:
(5>2)&&47 adevarata; !(4>7) - adevarata; 4<7 adevarata;

5.5. Opera!iile logice pozi!ionale.
Opera!iile logice pozi!ionale se folosesc pentru lucrul cu bi!i separa!i sau cu
grupuri de bi!i de date. Opera!iile pozi!ionale nu se aplic" c"tre datele float #i double.
Opera!iile logice pozi!ionale:

Numele opera!iei logice pozi!ionale Semnul opera!iei n Turbo C
#I pozi"ional
Sau pozi"ional
&
|

2$
Sau exclusiv pozi"ional
Deplasare la stnga
Deplasare la dreapta
Inversare
^
<<
>>
~

Opera!ia pozi!ional" %I se realizeaz" asupra fiec"rii perechi de bi!i a datelor, de
exemplu dac" n program avem descrierea variabilelor : int n,d; %i variabila n are
valoarea 5, iar variabila d are valoarea 6, atunci expresia n&d ne d" valoarea 4,
deoarece reprezentarea interioar" a valorii variabilei n este 0000000000000$0$ iar a
variabilei d este 0000000000000$$0. Rezultatul aplic"rii opera!iei pozi!ionale %I va
fi : n 0000000000000$0$
d 0000000000000$$0
4 0000000000000$00
Opera!ia pozi!ional" %I deseori se folose#te pentru eviden!ierea vreunui grup de bi!i.
Opera!ia pozi!ional" SAU se aplic" asupra fiec"rei perechi de bi!i a datelor #i
deseori se folose#te pentru instalarea unor bi!i, de exemplu, expresia: X=X | mask
instaleaz" n unu acei bi!i ai lui x, c"rora le corespunde unu n mask. Nu trebuie s"
confund"m opera!ile logice pozi!ionale cu opera!iile logice && #i || . De exemplu,
expresia 1&2 are valoarea 0, iar expresia 1&&2 are valoarea $.
SAU exclusiv pozi!ional realizeaz" asupra fiec"rei perechi de bi!i opera!ia de
adunare dup" modulul 2. Rezultatele ndeplinirii opera!iei SAU exclusiv pozi!ional se
determin" n tabelul urm"tor :

Bitul primului operand Bitul operandului al doilea Bitul rezultatului
0
0
$
$
0
$
0
$
0
$
$
0

Opera!iile de deplasare la s"nga(>>) #i la dreapta (<<) ndeplinesc deplasarea
primului operand la stnga sau la dreapta cu un num"r de pozi!ii binare determinat de
operandul al doilea.
n timpul deplas"rii la stnga bi!ii, ce se elibereaz", se completeaz" cu zerouri.
De exemplu, x<<2 deplaseaz" x la snga cu dou" pozi!ii, completnd pozi!iile
eliberate cu zerouri,ceea ce-i echivalent cu nmul!irea la 4. n caz general, a deplasa x
cu n pozi!ii la stnga e echivalent nmul!irii valorii lui x cu 2 la puterea n.

22
Deplasarea la dreapta a unei m"rimi f"r" semn (unsigned) aduce la completarea
cu zerouri a bi!ilor elibera!i. Deplasarea la dreapta a unei m"rimi cu semn la unele
m#ini aduce la multiplicarea bitului semnului, iar la altele bi!ii se completeaz" cu
zerouri. Turbo C multiplic" bitul semnului #i de aceea pentru nemerele pozitive,
deplasarea la dreapta cu n pozi!ii e echivalent" mp"r!irii la 2 la puterea n.
Opera!ia unar" inversare (~) [tilda] transform" fiecare pozi!ie unar" n nul" #i
invers fiecare pozi!ie nul" n unar".

5.6. Opera!ia dimensiune.
Opera!ia unar" dimensiune, notat" prin cuvntul-cheie sizeof, d" m"rimea
operandului s"u n octe!i. Opera!ia dimensiune se folose#te sub forma:
sizeof_expresie sau sizeof_tip
Valoarea opera!iei sizeof este o constant" ntreag", care determin" lungimea
tipului rezultatului expresiei. Dac" n calitate de operand al opera!iei sizeof folosim
_tip, atunci primim m"rimea obiectului de tipul indicat. n calitate de _tip pot fi
folosite acelea#i tipuri de obiecte, ce se folosesc la descrierea variabilelor.
Opera!ia sizeof poate fi folosit" peste tot, unde se admite folosirea unei
constante ntregi. Construc!iile sizeof_expresie #i sizeof_tip se cerceteaz" ca ceva
unitar #i, astfel, expresia sizeof_tip -2 nseamn" (sizeof(_tip)-2). Sau, de exemplu,
expresia sizeof(a+b+c)+d e echivalent" expresiei constana_+d, unde constanta_ are
valoarea lungimii tipului rezultatului a+b+c. Expresia a+b+c e luat" n paranteze
pentru a indica c" avem nevoie de lungimea tipului rezultatului a+b+c, #i nu
a+b+c+d.

5.7. Opera!ia virgul#.
Opera!ia virgul" (,) permite de a uni cteva expresii n una singur" #i, astfel, n
Turbo C se introduce no!iunea de expresie cu virgul", ce are urm"toarea form"
general" : expresie_,expresie_,expresie_, Perechea de expresii, desp"r!ite prin
virgul", se calculeaz" de la stnga spre dreapta. Tipul #i valoarea rezultatului expresiei
cu virgul" este tipul #i valoarea a celei mai din dreapta expresii.
De exemplu: k=a+b,d=m+n,5.2+7 este o expresie cu virgul" #i se calculeaz" de
la stnga spre dreapta. Valoarea ei este $2.2 de tip float. n procesul calcul"rii acestei
expresii variabilelor k #i d li se atribuie valorile respective. Pentru expresia:
d=(k=5+2,5+3) valoarea variabilei d va fi 8, deoarece ei i se atribuie valoarea
expresiei cu virgul", care, la rndul s"u, este egal" cu valoarea celei mai din dreapta
expresii-operand.

23
Virgula n Turbo C se folose#te n dou" contexte: ca separator a datelor #i ca
opera!ie, ce determin" calculul consecutiv al expresiilor. De aceea e admis", de
exemplu, a#a o expresie: int a,b,c=(1,2,5),d;
unde variabila c se ini!ializeaz" cu o expresie constant" cu virgul" $,2,5 #i prime#te
valoarea 5. Contextul opera!iei virgul" (separator sau opera!ie) compilatorul l
simte dup" paranteze. n interiorul parantezelor avem opera!ia virgul", n exteriorul
lor separatorul.
n continuare vom vedea, c" o situa!ie analogic" poate ap"rea n lista
argumentelor reale n timpul adres"rii c"tre func!ie. Adresarea la func!ie, ce con!ine
trei argumente, unde al doilea are valoarea 5, poate ar"ta, de exemplu, astfel:
F(a,(t=3,t+2),c);

5.8. Expresii condi!ionate.
Expresiile condi!ionate au urm"toarea form" general":
expr1_?:expr2_:expr3_;
Valoarea expresiei condi!ionale se calculeaz" astfel: prima se calculeaz" expr1_.
Dac" ea este diferit" de zero (e adev"rat"), atunci se calculeaz" expr2_ #i valoarea ei
va fi valoarea ntregii expresii, n caz contrar se calculeaz" expr3_. Astfel, semnele
de opera!ie ? #i : determin" opera!ia ternar", adic" opera!ie cu trei operanzi. De
exemplu, pentru a calcula z maximum din a #i b e suficient de a scri expresia:
z=(a>b)?a:b; unde (a>b)?a:b expresie condi!ional". Parantezele din jurul primei
expresii nu sunt obligatorii, deoarece prioritatea opera!iei ternare ?: este foarte joas",
nc" mai joas" este prioritatea opera!iei de atribuire. Totu#i, se recomand" de a pune
parantezele, c"ci n a#a fel condi!ia se eviden!iaz" vizual. Expresia de mai sus o
putem scrie mai pu!in efectiv astfel: a>b?(z=a):(z=b);

5.9. Conversii de tip.
La scrierea expresiilor ar fi binevoit" folosirea datelor omogene, adic" a
variabilelor #i constantelor de acela#i tip. ns", dac" n expresie se amestec" diferite
tipuri de date, atunci compilatorul produce conversia automat" a tipurilor n
corespundere cu regulile care, n fond, se reduc la urm"toarele: dac" opera!ia se
ndepline#te asupra datelor de diferite tipuri, atunci ambele date se reduc la cel mai
superior din aceste dou" tipuri. O astfel de conversie se nume#te ridicarea tipului. O
consecutivitate de tipuri ordonate de la superior la inferior e determinat" n
corespundere cu prezen!a interioar" a datelor #i arat" astfel : double, float, long, int,
short, char. Modificatorul unsigned m"re#te rangul tipului corespunz"tor cu un semn.

24
Pentru opera!ia de atribuire (simpl" sau compus") rezultatul calcul"rii expresiei din
partea dreapt" se aduce la tipul variabilei c"reia i se atribuie aceast" valoare. n acest
timp poate avea loc ridicarea tipului sau coborrea tipului.
Ridicarea tipului de atribuire, de obicei, se produce f"r" pierderi, pe cnd
coborrea lui poate denatura esen!ial rezultatul din cauza c" acel element de tip
superior poate s" nu ncap" n zona de memorie a elementului de tip inferior.
Pentru p"strarea preciziei calculului la efectuarea opera!iilor aritmetice, toate datele
de tip float se transform" n double, ceea ce mic#oreaz" gre#eala de rotungire.
Rezultatul final se transform" n tip float, dac" acesta e condi!ionat de instruc!iunea
de descriere respectiv". De exemplu, datele snt descrise astfel:
float a,b,c; #i avem expresia: a*b+c
La calcularea valorii expresiei variabilele a, b #i c vor fi convertate n double, iar
rezultatul va avea tip float. ns" dac" datele sunt descrise astfel : float a,b; double c;
atunci rezultatul a*b+c va fi de tip double din cauza ridic"rii tipului.
n afar" de conversia automat" a tipurilor, ndeplinit" de compilator, Turbo C
pune la dispozi!ia programatorului posibilitatea indic"rii explicite a tipului, la care e
necesar de adus o careva m"rime sau expresie. Ob!inem acest lucru folosind opera!ia
de conversie a tipului, ce are urm"toarea form" general" de scriere:
(_tip_)_expresie
Folosirea unei astfel de construc!ii garanteaz", c" valoarea expresiei va fi
convertat" la tipul indicat n paranezele din fa!a expresiei. n aceast" opera!ie n
calitate de _tip_ pot fi folosite acelea#i cuvinte cheie, ca #i n instruc!iunile de
descriere a tipului, mpreun" cu modificatorii admisibili.
S" cercet"m dou" expresii n Turbo C.
d=1.6+1.7 #i d=(int)1.6+(int)1.7 cu condi!ia c" variabila d este de tip ntreg.
n rezultatul ndeplinirii primei expresii valoarea variabilei d va fi 3, deoarece $.6+$.7
nu necesit" conversia tipurilor #i d" rezultatul 3.3 de tip float, iar coborrea tipului
pn" la int, realizat" n timpul ndeplinirii opera!iei de atribuire, d" variabilei d
valoarea 3 din cauza truchierii p"r!ii frac!ionare. n rezultaul ndeplinirii expresiei a
doua valoarea variabilei d va fi 2, deoarece indic" conversia explicit" a constantelor
float n tip int pn" la adunarea lor. n timpul ndeplinirii opera!iei de atribuire nu va
avea loc conversia tipului, deoarece tipul variabilei coincide cu tipul expresiei.
Opera!ia de reducere a tipului cel mai des se folose#te n cazurile, cnd dup"
context nu se presupune conversia automat" a tipurilor. De exemplu, pentru
asigurarea lucrului corect a func!iei sqrt ea are nevoie de un argument de tip double.
De aceea, dac" avem descrierea: int n; atunci pentru calcularea r"d"cinii patrate din n
trebuie s" scriem sqrt((double)n);

25
Men!ion"m, c" n timpul aducerii la tipul necesar se converteaz" valoarea lui n,
dar nu se schimb" con!inutul ei, c"ci ea r"mne de tip int.

5.$0. Priorit#!ile opera!iilor.
Priorit"!iile opera!iilor se cercetau n procesul expunerii lor. n paragraful de
fa!" sunt reprezentate opera!iile descrise mai sus #i e indicat" ordinea ndeplinirii lor.
Pentru compararea priorit"!ilor opera!iilor le prezent"m n tabel n ordinea
descre#terii priorit"!ii. Coloana tabelului Ordinea execu!iei determin"
consecutivitatea ndeplinirii pentru opera!iile cu aceia#i prioritate. De exemplu n
expresia k=d+=b-=4; consecutivitatea ndeplinirii opera!iilor se va determina n
ordinea de la dreapta la snga #i n rezultat b se va mic#ora cu 4, d se va m"ri cu b-4,
k=d+b-4. Ordinea de evaluare, descris" de o simpl" opera!ie de atribuire, va fi
urm"toarea: b=b-4; d=d+(b-4); k=d;

Prioritatea Semnul opera!iei Tipul opera!iei Ordinea execu!iei
$ ( ) Expresie De la stnga la dreapta
2
! ~ ++ -- - + (unar) sizeof
(tip)
Unare De la dreapta la stnga
3 * / % Multiplicative
4 + - Aditive
5 << >> Deplasare
6 < > <= >= Rela!ii
7 == != Rela!ii (egalitate)
8 & %I pozi!ional
9 ^ SAU exclusiv pozi!ional
$0 | SAU pozi!ional
$$ && %I logic
$2 || SAU logic
$3 ?: Condi!ie
De la stnga la dreapta
$4
= *= /= %= += -= &=
|= >>= <<= ^=
Atribuire simpl" #
compus"
De la dreapta la stnga
$5 , Virgul" De la stnga la dreapta




26
6. Instruc!iuni.
Prin instruc!iune n C se subn!elege o oarecare nscriere, ce se termin" cu
caracterul; (punct #i virgul"), sensul c"reiea determin" ac!iunile compilatorului n
timpul prelucrarii textului ini!ial al programului sau actiunile procesorului n timpul
ndeplinirii programului. Instruc!iunile pot fi mp"r!ite n dou" grupe:
$) Instruc!iunile perioadei de compilare
2) Instruc!iunile perioadei de ndeplinire a programului.
La instruc!iuni de compilare se refer" instruc!iuni, ce caracterizeaz" datele din
program, iar la instruc!iuni de ndeplinire se refer" instruc!iuni, ce determin" ac!iuni
de prelucrare a datelor n conformitate cu algorilmul dat. Instruc!iunile de compilare
au fost precautate n compartimentele de descriere #i declarare a datelor. n
continuare vor fi studiate instruc!iunile de ndeplinire.
Fiecare instruc!iune are sintaxa #i semantica sa. Sintaxa reflect" metoda
nscrierii corecte a construc!iilor instruc!iunii, iar semantica este descrierea ac!iunilor
efectuate de instruc!iune.

6.$. Tipurile instruc!iunilor.
Instruc!iunea reprezint" o unitate de ndeplinire a programului. Instruc!iuni pot
fi simple, compuse #i blocuri.
Simpl! se nume#te instruc!iunea, care nu con!ine n componen!a sa o alt"
instruc!iune. La instruc!iunile simple se refer" instruc!iunea expresie, instruc!iunea
continu"rii continue, instruc!iunea de terminare break, instruc!iunea de ntoarcere
return, instruc!iunea de salt necondi!ionat goto, pe care le vom cerceta mai departe.
Compus! se nume#te instruc!iunea, ce con!ine n componen!a sa alte
instruc!iuni. La instruc!iunile compuse se refer" instruc!iunea condi!ional" if else
instruc!iunile ciclului for, while, do while #i instruc!iunea de selec!ie switch.
Bloc se nume#te un #ir de instruc!iuni luate n acolade({}). Instruc!iunile
blocului se ndeplinesc consecutiv n ordinea nscrierii lor n interiorul blocului. La
nceputul blocului pot fi descrise variabilele interioare. n a#a caz se spune, c" aceste
variabile sunt localizate n interiorul blocului, exist" #i lucreaz" numai n interiorul
blocului #i se pierd n afara lui.
n Turbo C instruc!iunea compus" #i blocul pot fi folosite oriunde, unde este
admis" folosirea instruc!iunii simple. Prin urmare, instruc!iunea compus" poate
con!ine alte instruc!iuni compuse, iar blocul poate con!ine instruc!iuni compuse #i alte
blocuri.

27
Orice instruc!iune poate fi marcat" de un identificator, nunit etichet!. Eticheta
este separat" de instruc!iune prin dou" puncte #i, astfel, n caz general instruc!iunea
are forma: etichet!_:corpul_instruc"iunii;
Eticheta se folose#te doar n cazul cnd se folose#te saltul necondi!ionat la
aceaast" instruc!iune cu ajutorul instruc!iunii goto. n exemplul de mai sus pot lipsi
ori eticheta_, ori corpul_instruc!iunii, ori ambele. n cazul lipsei corpul instruc!iunii,
avem o instruc!iune vid", adic" a#a o instruc!iune ce nu ndepline#te nici o ac!iune. n
cazul cnd avem lipsa instruc!iunii #i prezen!a etichetei avem o instruc!iune vid"
etichetat". Exemplu: Empty : ;
Dac" n calitate de corpul instruc!iunii e folosit un bloc, atunci (;) nu se pune.
n acest caz, rolul sfr#itului l va juc" acolada dreapt", de nchidere (}). De exemplu:
label:{k=a=b;k+=8;}

6.2. Instruc!iuni expresie.
Orice expresie va deveni instruc!iune dac" se va termina cu (;). n a#a fel,
instruc!iunea-expresie va avea urm"toara form": expresie_;
Dup" cum sa men!ionat, orice instruc!iune poate fi etichetat". Instruc!iunea-
expresie ader" la clasa instruc!iunilor simple ai limbjului Turbo C. n rezultatul
ndeplinirii n program a instruc!iunii-expresie se calculeaz" valoarea expresiei n
conformitate cu opera!iile, care sunt definite n ea. De obicei, pot fi una sau mai
multe opera!ii de atribuire #i atunci instruc!iunea-expresie n limbajul Turbo C are
acela#i sens #i n alte limbaje. S" studiem secven!e din program unde e folosit"
instruc!iunea-expresie: Exemplu $:
int x,y,z; x =-3+4*5-6; y =3+4%5-6; z =-3*4%-6/5;
n rezultat vom avea x=$$, y=$, iar z=0. Vom scrie ordinea ndeplinirii a acestei
secven!e n conformitate cu prioritatea opera!iilor, folosind parantezele rotunde:
Pentru x=-3+4*5-6 : x=(((-3)+(4*5))-6);
Pentru y=3+4%5-6 : y=((3+(4%5))-6)
Pentru z=-3*4%5-6/5 : z=((((-3)*4)%(-6))/5);
Exemplu 2:
int x=2,y,z; x*=3+2,x*=y=z=4;
Aici instruc!iunea-expresie con!ine o expresie cu virgul" compus" din dou"
subexpresii. n primul rnd se calculeaz" prima subexpresie, apoi- subexpresia a doua.
n rezultat vom ob!ine z=4, y=4, x=40. Men!ion"m faptul, c" la declarare x are
valoarea 2: x=(x*(3+2))*(y=(z=4));



28
6.3. Instruc!iuni de ramificare (condi!ionale).
6.3.$. Instruc!iunea de ramificare IF "i IF-ELSE.
n structurile ramificate de calcul, unele etape nu ntotdeauna se ndeplinesc n
una #i aceia#i ordine. n dependen!" de careva condi!ii, care sunt controlate(verificate)
pe parcursul calculelor, se aleg pentru executare diferite consecutivit"!i de
instruc!iuni. Pentru descrierea astfel de procese n limbajul C se folosesc
instruc!iunile ramificate (condi!ionale). O instruc!iune condi!ional" selecteaz" o
singur" instruc!iune dintre alternativele sale, pe care apoi o execut". Astfel de
instruc!iuni sunt if #i if else. Instruc!iunea if e compus" #i sintaxa ei admite unul din
urm"toarele formate:
if_(expresie)_instruc"iune sau
if_(expresie)_instruc"iune1_else_instruc"iune2;
n instruc!iunile de ramificare lipse#te (;), deoarece construc!ia instruc"iune_
care a fost descris" deja include n sine acest semn (;). Dac" instruc"iunea_ este
simpl", atunci ea se va sfr#i cu (;), iar dac" instruc"iunea_ reprezint" un bloc, atunci
acest bloc va fi definit de acolade, unde acolada dreapta va juca rolul sfr#itului.
Instruc!iunea if lucreaz" n felul urm"tor:
$. Formatul if(expresie)_instruc"iune. Mai nti se
calculeaz" valoarea expresiei. Dac" rezultatul ei este ADEVcR
( adic" expresia != 0), atunci se ndepline#te _instruc!iunea, iar
n caz contrar se sare peste instruc!iune #i nu avem nici o
ac!iune. Schema algoritmic" a formatului
if(expresie)_instruc!iune este prezentat" pe desen. Fie c" d este
egal" cu c. Atunci vom m"ri d cu o unitate, iar c cu trei unit"!i.
n celelalte cazuri d #i c r"mn neschimbate. Instruc!iunea de ramificare a acestui caz:
if(d==c) ++d,c+=3;
n calitate de instruc"iune_ aici se folose#te instruc!iunea expresie cu virgul".
Vom descrie aceast" instruc!iune astfel: if(d= =c)++d;c+=3;
Diferen!a const" n aceea c" n exemplu al doilea avem 2 instruc!iuni: if #i
instruc!iunea-expresie c+=3;
n acest caz dac" (d==c) va avea valoare ADEVcR, atunci totul va r"mne ca mai
nainte: d se va m"ri cu o unitate, iar c se va m"ri cu trei unit"!i. n caz contrar, d nu
se schimb", #i numai c se m"re#te cu 3.
Vom considera acest exemplu din nou:
if(d= =c){++d;c+=3;}

29
n cazul c" (d == c) va avea valoarea FALS, d #i c vor r"mne neschimbate, deoarece
aceste instruc!iuni snt incluse n acolade, adic" formeaz" un bloc, #i din punct de
vedere logic sunt privite ca o singur" instruc!iune bloc.
2. Formatul if(expresie)_instuc"iune1_else_instruc"iune2.
Ca #i n cazul precedent, n primul rnd se calculeaz" valoarea expresiei. Dac" ea
difer" de zero, adic" este ADEVcR, atunci se ndepline#te instruc!iunea$, n caz
contrar se ndepline#te instruc!iunea2.
Schematic aceast" instruc!iune e preszentat" pe desen.
De exemplu : fie c" e necesar de a calcula z, care este
egal cu maximum dintre dou" numere a #i b.
Atunci putem scrie :
if(a>b)z=a;else z=b; Prezen!a (;) dup" z=a este
necesar", deoarece aceasta este o instruc!iune ce intr" n
coponen!a instruc!iunii if.
Prima form" prescurtat" a instruc!iunii if ne d" posibilitatea ndeplinirii sau
nendeplinirii oric"rei opera!ii, pe cnd a doua form" ofer" posibilitatea alegerii #i
ndeplinirii unei opera!ii din dou" posibile. Totu#i, cte odat" apare necesitatea
alegerii unei opera!ii din mai multe.Vom examina un lan! de instruc!iuni:
if(expresie1)_instruc"iune1_else_if(expresie2)_instruc"iune2_else_if(expresie3)
_instruc"iune3_else _instruc"iunea4
A#a un lan! de instruc!iuni e admis, deoarece n locul instruc!iunii n instruc!iunea if
poate fi orice instruc!iune, inclusiv #i if. ns" o a#a nscriere e complicat". Pentru a#a
procese n C exist" o instruc!iune special" care va fi studiat" ceva mai trziu. S"
prec"ut"m 2 exemple:
a) if(n>0) if(a>b) z=a; else z=b;
b) if(n>0){if(a>b) z=a;}else z=b;
Deosebirea const" n faptul c" n cazul a) avem instruc!iunea if de form" scurt",
care are ca instruc!iune forma if_else; . n cazul b) avem instruc!iunea if_else n form"
plin", avnd n calitate de instruc"iune1 forma if prescurtat". Secven!a b difer" de a
numai prin prezen!a acoladelor, ce definesc un bloc, ns", evident, joac" un rol
important la interpretarea acestor intruc!iuni.

6.3.2. Instruc!iunea de salt necondi!ionat GOTO.
Instruc!iunea goto ne d" posibilitatea transmiterii controlului execu!iei
programului la o instruc!iune marcat" cu o etichet". Instruc!iunea goto are formatul:
goto_etichet!;

30
Dup" instruc!iunea goto, evident, se ndepline#te instruc!iunea, eticheta c"reia
coincide cu eticheta din goto. Folosirea cestei instruc!iuni n Turbo C nicidecum nu
se deosebe#te de folosirea ei n alte limbaje algoritmice. ns" e dorita folosirea ct mai
redus", a acestei instruc!iuni, deoarece limbajul Turbo C face parte din clasa
limbajelor structurate. Totodat", avnd la dispozi!ie instruc!iunile goto #i if,
programatorul poate programa diferite opera!ii complicate.
Exemplu :Folosirea instruc!iunilor if #i goto la organizarea ciclurilor. Acest program
calculeaz" valoarea lui y care este egal" cu n/(n+5),unde n=$,..,50
#define lim 50
main() {
int n=0; float y=0;
m1:++n;
if(n<=lim) {
y+=n/(n+50); goto m1;} }
Prima linie a programului e menit" preprocesorului, c"ruia i se indic" valoarea
constantei lim=50. Astfel se procedeaz" n cazul cnd vom necesita schimbarea
limitei de sumare. Pentru aceasta trebuie schimbat" doar directiva #define, iar
substituirile corespunz"toare n textul programului preprocesorul le va face f"r"
participarea noastr".
Programul const" dintr-o singur" func!ie main(), corpul c"reia e definit cu
ajutorul acoladelor exterioare. Instruc!iunea if are aici forma prescurtat", avnd ca
instruc!iune un bloc, care con!ine instruc!iunea goto, ce ne d" posibilitatea calcul"rii
ciclice a sumei.
n ncheiere men!ion"m c" utilizarea if #i goto la organizarea ciclurilor e un
semn de cultura insuficient" de programare. Exemplu dat arat" numai cum se poate
organiza un ciclu cu ajutorul instruc!iunilor if #i goto, dar n nici un caz nu serve#te
drept exemplu pentru copiere. La organizarea ciclurilor n limbajul de programare
Turbo C se folosesc alte posibilit"!i, cu mult mai fine.

6.3.3. Instruc!iunea de selectare SWITCH.
Instruc!iunea de selectare e destinat" pentru selectareaa unei singure variante
dintr-o mul!ime posibil" de ramific"ri n program. Orice ramificare poate fi
organizat" cu ajutorul lan!ului de instruc!iuni if_else_if__else_, ns" n cazurile cnd
sunt prezente mai mult de 3 condi!ii e mai ra!ional" folosirea lui switch. Instruc!iunea
de selectare este compus" #i are formatul prezentat mai jos:
switch (expresie) {
case expr_const1:instruc"iune1;
case expr_const2:instruc"iune2;

3$
case expr_const_n:instruc"iune_n;
default:instruc"iune; }
Dup" cuvntul cheie switch n paranteze este scris" o expresie, valoarea c"reia
trebuie s" fie de tip int sau char. Mai departe n acolade se nscriu instruc!iunile
varantele marcate cu prefixele: case expresia_constant!: unde expresia constant"
deasemenea trebuie s" fie de tip ntreg, iar toate prefixele trebuie s" fie diferite. O
variant" poate avea prefixul default, prezen!a careia nu este obligatorie, dar n
majoritatea cazurilor acest prefix este prezent n construc!ia switch.
Instruc!iunea de selectare lucreaz" n felul urm"tor. La nceput se afl" valoarea
expresiei din paranteze, apoi aceast" valoare se compar" cu expresiile constante ale
case prefixelor #i se ndepline#te variantaa i, pentru care aceste valori coincid. Dup"
ce sau ndeplinit instruc!iunile ce se con!in n case-
ul respectiv, se ndeplinesc instruc!iunile variantei
urm"toare #i a#a pn" ce se termin" toate
instruc!iunile variantei. Dac" valoarea expresiei n
switch nu coincide cu nici o valoare a case
prefixelor, atunci ori se ndepline#te instruc!iunea
variantei cu prefixul default (dac" default este
prezent), ori nu se ndepline#te nici o variant"
(dac" default este absent). Schema algoritmic" de
ndeplinire a instruc!iunii switch este prezent" pe
desen.
S" examin"m exemplul de ntrebuin!are a instruc!iunei switch : se scrie un
fragment de program, ce tip"re#te patru rnduri din poezie, ncepnd de la rndul k:
switch(k) {
case 1: printf(A fost o dat! ca-n pove$ti,\n);
case 2: printf(A fost ca niciodat!,\n);
case 3: printf(Din rude mari mp!r!te$ti,\n);
case 4: printf(O preafrumoas! fat!.\n);
default printf(Poezia nu con"ine rnd cu a$a num!r); }
n acest exemplu e folosit" func!ia printf(), ce asigur" tiparul rndului cu format. Dac"
k ar fi egal cu 3, atunci vom avea ca rezultat :
Din rude mari mp!r!te$ti
O preafrumoas! fat!.
Poezia nu con"ine rnd cu a$a num!r




32
6.3.4. Instruc!iunea de ntrerupere BREAK.
n practica program"rii cteodat" apare necesitatea ndeplinirii numai a unei
variante case f"r" indeplinirea celor ce urmeaz" dup" ea, adic" trbuie ntrerupt" logica
stabilit" de lucrul a instruc!iunii switch. Evident c" pentru a#a ceva e necesar
inroducerea unei instruc!iuni ntre instruc!iunile variantei, care ar servi ca sfr#it al
ndeplinirii lui switch. A#a o instruc!iune este BREAK, executarea c"reia rovoac"
terminarea instruc!iunii switch. n acest caz instruc!iunea switch va avea urm"torul
format:
switch (expresie) {
case expr_const1:instruc"iune1; break;
case expr_const2:instruc"iune2; break ;
.................
case expr_const_n:instruc"iune_n; break;
default:instruc"iune; break; }
Instruc!iunea BREAK se nscrie n variante atunci cnd este nevoie de ea.
ndeplinirea ei aduce la trecerea controlului la instruc!iunea urm"toare dup" switch.
La prima vedere pare c" nu este necesar de a scri instruc!iunea BREAK dup" varianta
default. Default poate fi situat n orice loc al instruc!iunii switch, chiar #i pe primul
loc ntre variante, #i atunci BREAK este necesar pentru a evita ndeplinirea celorlalte
variante. Exemplu: Schimb"m formularea problemei precedente n felul urm"tor : fie
c" e necesar de tip"rit rndul k dinte cele patru rnduri ale poeziei date:
switch(k){
case 1 : printf(A fost o dat! ca-n pove$ti,\n);break;
case 2 : printf(A fost ca niciodat!,\n); break;
case 3 : printf(Din rude mari mp!r!te$ti,\n); break;
case 4 : printf(O preafrumoas! fat!.\n); break;
default:printf(Poezia nu con"ine rnd cu a$a num!r\n); }
Trebuie de men!ionat, c" instruc!iunile din variantele case sau default pot lipsi.
Aceasta este necesar cnd avem nevoie de a ob!ine acela#i rezultat la trecerea la
diferite prefixe. Exemplu:
switch (L) {
case `C`:
case `c`: printf(Calculator\n);break; }
n acest caz, dac" L=c va fi tip"rit cuvntul calculator. n caszul cnd
L=`C`, atunci va fi ndeplinit" instruc!iunea ce urmeaz" dup" primul case, dar
deoarece aici lipse#te instruc!iunea, se vor ndeplini instruc!iunile situate mai jos, pn"
ce nu se ntlne#te instruc!iunea break.



33
6.4. Instruc!iuni iterative(ciclice).
Instruc!iunile prec"utate mai sus redau opera!ii care trebuie efectuate conform
algoritmului #i fiecare din ele se ndeplinesc numai odat". n cazul, cnd una #i
aceia#i instruc!iune trebuie s" fie executat" de n ori cu diferite valori ale parametrilor
se folosesc instruc!iunile ciclice. Distingem 3 instruc!iuni ciclice n C :
$) Instruc!iunea ciclic" cu parametru (FOR)
2) Instruc!iunea ciclic" precedat" de condi!ie (WHILE)
3) Instruc!iunea ciclic" cu postcondi!ie (DO-WHILE)

6.4.$. Instruc!iunea ciclic# FOR.
Ciclul FOR posed" urm"toarele caracteristici:
num"rul de repet"ri ale ciclului este cunoscut de la nceputul execut"rii lui;
conducerea ciclului este efectuat" cu ajutorul unei variabile de tip int, numit"
parametrul ciclului, care, n acest proces ciclic prime#te valori consecutive de la
valoarea ini!ial" dat" pn" la valoarea final" dat". Sintaxa instruc!iunii este
urm"toarea: for(expresie1;expresie2;expresie3) instruc"iune; unde expresie$
expresie de ini!ializare a parametrului ciclului, expresie2- expresie de control,
expresie3- expresie de incrementare/decrementare(corec!ie) a parametrului ciclului.
Instruc!iunea ciclic" for lucreaz" n felul urm"tor: la nceput se calculeaz"
expresia de ini!ializare. Apoi, dac" expresia de control este adev"rat", atunci se
ndepline#te instruc!iunea. Dup" ndeplinirea instruc!iunei se execut" expresia de
corec!ie #i din nou se controleaz" expresia de control, juste!ea c"reia duce la
ndepliniea repetat" a instruc!iunii. Dac" expresia de control are valoarea fals" atunci
ndeplinirea ciclului for se termin", adic" controlul se transmite instruc!iunii
programului ce urmeaz" dup" instruc!iunea for. De exemplu: de calculat y=i/(i+$);
unde i=$..50;
y=0; for(i=1;i<=50;i++) {y+=i/(i+1) };
aici i=$ este expresie de ini!ializare, i<=50 expresie de control, i++ - expresie de
corec!ie. Acoladele m"rginesc corpul ciclului (instruc!iunea). n caz cnd corpul
ciclului e compus numai dintr-o instruc!iune, acoladele nu sunt
necesare.
Schema algoritmic" ndeplinrii instruc!iuni for este
prezentat" pe desen. Din schema algoritmic" se vede, c"
instruc!iunea for este un ciclu cu precondi!ie : decizia de a
ndeplini din nou ciclul sau nu se ia naintea nceperii
ndeplinirii lui #i evident, se poate ntmpla ca corpul ciclului s" nu
fie ndeplinit nici o dat".

34
Cteodat" apare necesitatea ie#irii din ciclu nainte de termen. Pentru aceasta
n corpul ciclului, n locul unde se dore#te ie#irea din ciclu se folose#te instruc!iunea
BREAK, dup" ndeplinirea T"reia are loc transmiterea controlului la instruc!iunea
urm"toare dup" ciclu.
Limbajul C nu pune restruc!ii la tipul instruc!iunilor din cadrul corpului
ciclului. n a#a mod, corpul ciclului poate fi alc"tuit din instruc!iuni #i simple #i
compuse, n particular- corpul unui ciclu poate fi alt ciclu. n unele algoritme apar
situa!ii, cnd e necesar" imbricarea unui ciclu n altul. De exemplu la prelucrarea unei
matrice un ciclu exterior r"spunde de prelucrarea rndurilor, iar altul interior a
coloanelor. n acest caz sintaxa va fi urm"toarea:
For(i=1;i<=n;i++){
For(j=1;j<=m;j++){
corpul ciclului } };
unde n-num"rul de rnduri n matrice, m- num"rul de coloane, acoladele interioare
m"rginesc corpul ciclului cu parametrul j, iar acoladele exterioare m"rginesc corpul
ciclului exterior cu parametru i.

6.4.2. Instruc!iunea ciclic# WHILE.
Ciclul while este folosit n cazul, cnd nu este cunoscut num"rul de repet"ri ale
ciclului #i nu exist" necesitatea ca ciclul s" fie executat m"car o singur" dat".
Instruc!iunea de ciclare while are urm"toarul format:
while (expresie) instruc"iune;
Instruc!iunea de ciclu while lucreaz" n felul urm"tor: dac" expresia este
adev"rat" (sau diferit" de zero, ce din punct de vedere al limbajului Turbo C este una
#i aceia#i), atunci instruc!iunea se ndepline#te o dat" #i apoi expresia din nou se
testeaz".
Aceast" succesiune de ac!iuni, ce const" n testarea expresiei #i ndeplinirea
instruc!iunei, se repet" periodic p"n" ce expresia nu devine fals"(din punct de vedere
al limbajului Turbo C devine egal" cu zero). Instruc!iunea se nume#te corpul ciclului
#i n majoritatea cazurilor reprezint" un bloc, n componen!a c"ruia intr" cteva
instrc!iuni. Schema algoritmic" a execut"rii instruc!iuniii while
e prezentat" pe desen.
Se observ", c" instruc!iunea while este un ciclu cu
precondi!ie. Testul de control este executat naintea intr"rii n
corpul instruc!iunii. De aceea este posibil ca corpul ciclului nu
va fi ndeplinit niciodat". n afar" de aceasta, pentru a nu
admite ndeplinirea la infinit a ciclului, ci numai de anumite

35
ori, este necesar la fiecare ndeplinire nou" a ciclului de a modifica variabila
parametru , ce intr" n componen!a expresiei. Spre deosebire de ciclul for, unde
variabila parametru putea fi numai de tip ntreg, parametrul ciclului while poate fi #i
de tip float, adic" pasul ciclului poate fi diferit de $ #i chiar un num"r frac!oinar.
Exemplu:
i=1; while(i<=50) {y+=i(i+1); i++; } ;
Ca #i n cazul ciclului for, corpul unui ciclu while poate fi deasemenea un ciclu.
Exemplu:
i=1; while(i<=n) { j=1; while(j<=m) { corpul ciclului; j++;} i++ };

6.4.3. Instruc!iunea ciclic# DO_WHILE.
Instruc!iunea ciclic" DO_WHILE se folose#te n cazul cnd num"rul de repet"ri
ale ciclului nu-i cunoscut, dar n acela#i timp e necesar ca ciclul s" fie ndeplinit
m"car o singur" dat". Instruc!iunea de ciclare do_while are urm"toarea form":
do instruc"iune while(expresie);
Instruc!iunea do_while lucreaz" n felul urm"tor: la nceput se ndepline#te
instruc!iunea, apoi se calculeaz" valoarea expresiei. Dac" valoarea expresiei este
adev"rat", atunci instruc!iunea se ndepline#te din nou, dac" expresia este fals!",
atunci ndeplinirea ciclului se termin".
Schema algorimtic" de ndeplinire a instruc!iunii do_while este reprezentat" pe
desen. Instruc!iunea do while determin" un ciclu cu postcondi!ie, deoarece controlul
necesit"!ii ndeplinirii repetate a instruc!iunei are loc dup" ndeplinirea corpului
ciclului #i, astfel, corpul ciclului ntotdeauna se ndeplie#te cel pu!in o dat". Analogic,
ca #i pentru ciclul while, programatorul trebuie s" aib" grij" de terminarea ciclului,
schimbnd parametrul ciclului n corpul ciclului. Parametrul ciclului do while, ca #i
parametrul ciclului while poate fi de tip float, fapt ce permite de a opera cu pa#
zecimali la organizarea ciclului.
Exemplu: i=1;do {y+=i(i+1); i++;} while(i<=50);
Ciclul do_while deasemenea poate fi imbricat:
i=1; do { j=1;
do {corpul ciclului;j++;} while(j<=m)
i++; }
while(i<=n);
Deci, fiind cunoscute cele 3 instruc!iuni ciclice FOR,WHILE #i DO_WHILE le
putem folosi n diferite scopuri aparte sau mpreun" pentru cazuri concrete. n cazul
cnd cunoa#tem num"rul de repet"ri al ciclului, pasul indexului fiind =$ folosim
instruc!iunea ciclic" FOR. n cazul cnd num"rul de repet"ri al ciclului e necunoscut,

36
dar corpul ciclului trebuie s" fie executat m"car o singur" dat" folosim instruc!iunea
ciclic" DO_WHILE. %i n cazul cnd nu este cunoscut num"rul de repet"ri al ciclului,
iar corpul ciclului e necesar s" fie executat de 0 sau mai multe ori, n dependen!" de o
condi!ie folosim instruc!iunea ciclic" WHILE.Mai mult ca att, n cazul ciclurilor
imbricate sunt posibile combina!ii de instruc!iuni ciclice: for-while; do_while-while;
s.a.

6.4.4. Instruc!iunea de continuare CONTINUE.
Instruc!iunea CONTINUE este folosit" n corpul ciclului cu scopul de a preda
controlul la nceputul ciclului. Exist" cazuri, cnd la ndeplinirea a careva condi!ii
trebuie de ntrerupt executarea itera!ii curente #i de trecut la ndeplinirea itera!iei
urm"toare a ciclului. n a#a cazuri este folosit" instruc!iunea CONTINUE.
Instruc!iunea de continuare are urm"toarea form": continue;
Instruc!iunea continue poate fi realizat" n toate cele trei tipuri de cicluri, dar
nu #i n instruc!iunea switch. Ea serve#te la dep"#irea p"r!ii r"mase a itera!iei curente
a ciclului, ce o con!ine nemijlocit. Dac" condi!iile ciclului admit o nou" itera!ie, ea se
ndepline!te, n caz contrar el se termin". S" prec"ut"m urm"torul exemplu:
int a,b; b=0;
for(a=1;a<100;a++) {b+=a; if (b%2) continue;
... prelucrarea sumelor pare ... }
n cazul, cnd suma b va fi impar", operatorul continue transmite controlul
itera!iei urm"toare a ciclului for f"r" a executa partea urm"toare a corpului ciclului,
unde are loc prelucrarea sumelor pare.

7. Masive.
7.$. Descrierea masivelor.
Masivul reprezint" un #ir ordonat de elemente de acela#i tip. Faptul, ca masivul
este un tot intreg, compus din cteva elemente ne permite s" numim variabila de tip
masiv variabila de tip compus.
Masivul se poate caracteriza prin nume, tip, dimensiune. Formatul comun de
descriere a masivelor este:
tip nume[d1][d1][dn]; unde :
tip este tipul comun pentru toate elementele masivului, adica tipul masivului. Tip al
unui masiv poate fi orice tip de date deja definit: ntreg, real, caracterial #.a.
nume este numele masivului. In calitate de nume al masivului este folosit orice
identificator. Mai mult ca att, deoarece numele masivului este identificator, asupra
lui se r"spnde#te totul ce-i indicat n compartimentul Nume de variabile

37
(identificatori), d1,d2,dn- dimensiunile masivului. Dimensiunea masivului indica
numarul de elemente prezente in masiv. Dimensiunea masivului poate fi o expresie
constanta cu rezultat intreg. In dependenta de cantitatea de dimensiuni, masivele se
clasifica in:
$. masive unidimensionale(cu $ dimensiune);
masivul unidimensional reprezint" un #ir de elemente aranjate uniform ntr-un rnd.
Fiecare element al unui masiv unidimensional are $ coordonat": num"rul de ordine a
elementului n #ir.
2. masive bidimensionale (cu 2 dimensiuni);
masivul bidimensional reprezint" o structur" format" din rnduri #i coloane. Fiecare
element al unui masiv bidimensional are 2 coordonate: numarul rndului #i num"rul
coloanei.
3. masive tridimensionale (cu 3 dimensiuni);
masivul tridimensional reprezint" o structur" echivalent" cu un cub n volum cu 3
dimensiuni: lungimea, l"!imea, n"l!imea. Fiecare element al unui masiv
tridimensional are 3 coordonate: numarul rndului(n lungime), num"rul coloanei(n
l"!ime) #i num"rul n"l!imei(n adncime).
4. masive multidimensionale.
Exemple de descriere a masivelor:
int vector[20]; vector - masiv unidimensional din 20 de numere ntregi;
float x[10]; x masiv cu 10 elemente de tip ntreg;
float matrix[7][9]; matrix - masiv bidimensional din 63 (7*9) de numere flotante;
char fraza[25]; fraza - masiv(propozi"ie) din 25 de caractere ;
int spase[15][30][18]; space - masiv tridimensional de numere ntregi (masiv
unidimensional de masive bidimensionale);

7.2. Accesul la elementele masivului.
Cu toate c" masivul este un tot ntreg, nu se poate vorbi despre valoarea
masivului ntreg. Masivele con!in elemente cu valorile c"rora se opereaz" n program.
Fiecare element n masiv #i are indicele #i valoarea sa. n calitate de indice a unui
element se folose#te un num"r ntreg ce indic" num"rul de ordine al elementului n
masiv. Enumerarea elementelor n masiv conform num"rului de ordine se ncepe de
la zero. Deci, indicele unui element poate avea valori de la 0 pna la d-$, unde d este
dimensiunea masivului.
n calitate de valoare a unui element din masiv poate servi orice num"r de tipul
indicat la descrierea masivului, adica tipul valori atribuit" oric"rui element din masiv
trebuie s" fie compatibil cu tipul masivului. Sintaxa de acces la orice element a unui

38
masiv este urm"toarea: nume[i1][i2]..[in]. Unde nume este numele masivului, i1
indicele elementului n dimensiunea $, i2-indicele elementului n dimensiunea 2, in -
indicele elementului n dimensiunea n. n cele mai dese cazuri se opereaz" cu masive
unidimensionale #i bidimensionale. Accesul la un element al unui masiv
unidimensional se face n felul urm"tor: nume[i]; unde nume - numele masivului, i-
numarul de ordine a elementului n masiv. Exemplu:
vector[5]; se acceseaz" elementul cu num"rul de ordine 5 din masivul vector.
fraza[20]; se acceseaz" elementul cu indicele 20 din masivul fraza.
Accesul la un element al unui masiv bidimensional se face prin nume[i][j];
unde i este numarul rndului pe care se afl" elementul; j este num"rul coloanei pe care
se afl" elementul. Exemplu:
matrix[4][7]; se acceseaz" elementul de pe rndul 4 #i coloana 7 a masivului
matrix.
y[0][0]; se acceseaz" primul element al masivului, adic" rndul 0, coloana 0;
n cazul cnd masivul este de tip simplu, atribuirea valorii unui element al
masivului se face ca #i n cazul atribuirii valorii unei variabile simple. Exemple:
x[0]=7.125;
vector[19]+=1;
matrix[1][1]=5.5;
fraza[3]=b;
space [3][5][2]=8;
n cazurile cnd masivul este de tip structurat, atribuirea valorii #i accesul la un
element al masivului se face conform regulilor de atribuire #i accesare pentru
variabile structurate.
Un element al masivului poate ap"rea n orice expresie, unde e admisibil"
prezen!a unei variabile de tip compatibil cu tipul valorii elementului.

7.3. Ini!ializarea masivelor.
Deseori e necesar ca elementele masivului s" posede valori chiar la momentul
descrierii masivului.
Procesul de atribuire a valorilor elementelor masivului n timpul descrierii lui
se nume#te ini!ializarea masivului. Sintaxa de ini!ializare a unui masiv
unidimensional este:
tip nume[d]={v0,v1,v2,,vn-1}; unde tip este tipul masivului, nume este
numele masivului, v0,v1,v2,vn-1 valorile respective ale elementelor nume[0],nume[1]
etc. Exemplu:
int x[8]={1,3,15,7,19,11,13,5};

39
n acest caz elementele masivului vor avea urm"toarele valori: x[0]=1;
x[1]=3; x[2]=15; x[3]=7; x[4]=19; x[5]=11; x[6]=13; x[7]=5;
E de men!ionat faptul, c" indicii masivului se schimb" ncepnd dela zero.Adic" la
descrierea masivului valoarea maxim" a indicelui masivului coincide cu num"rul de
elemente n masiv minus unu.
La ini!ializarea masivului nu e numaidect de indicat dimensiunile
masivului.Compilatorul va determina num"rul elementelor dup" descrierea masivului
#i va forma un masiv cu m"rimea respectiv". De exemplu:
int x[]={1,3,15,7,19,11,13,5};
Elementele masivului vor primi valori ca #i n cazul precedent.
Vom examena nc" cteva exemple de ini!ializare a masivelor:
float vector[4]={1.2,34.57,81.9,100.77}; // vector masiv din 4 elemente de
tip float;
int digit[5]={1,2,3}; // digit masiv de tip ntreg din 5 numere,ultimelor dou"
elemente li se atribuie valoarea zero.
char m[5]={A,B,C,D}; // m masiv din 5 caractere, ultimul element are
valoarea nul-caracter;
float const y[4]={25,26,17,18}; // ini!ializarea masivului y[4], elementele
c"ruia sunt constante de tip float #i nu pot fi schimbate n decursul ndeplinirii
programului.
S" examen"m ini!ializarea masivului bidimensional:
Int a[3][3]={ {1,4,2},
{7,5,3},
{8,6,9} };
Ini!ializarea masivului bidimensional se efectueaz" pe rnduri. Elementele
acestui masiv au urm"toarele valori: a[0][0]=1; a[0][1]=4; a[0][2]=2; a[1][0]=7;
a[1][1]=5; a[1][2]=3; a[2][0]=8; a[2][1]=6; a[2][2]=9;
La ini!ializarea masivului dat fiecare rnd se include n acolade . Dac" n
rndurile indicate de noi nu vor ajunge elemente pentru completarea rndurilor, n
acest caz n locul elementelor pentru care n-au ajuns valori vor ap"rea zerouri.
Dac" n acest exemplu vom omite acoladele interioare, rezultatul va fi acela#i. Dac"
lipsesc acoladele interioare ,elementelor masivului se vor atribui valorile n mod
succesiv extrase din list" .Completarea masivului se efectuiaz" pe rnduri. Elementele
masivului pentru care n list" n-au ajuns valori, primesc valorile zero.Dac" n list"
snt mai multe valori dect elemente, atunci o astfel de list" se socoate gre#it". Cele
men!ionate mai sus se refer" la toate tipurile de masive.Exemple:
Ini!ializarea masivului bidimensional:

40
int a[3][3]={ 1,4,2,7,5,3,8,6,9};
Trei metode echivalente de ini!ializare a masivului tridimensional:
int p[3][2][2]={ { {1,2},{3,4} }, { {5,6},{7,8} }, { {9,10},{11,12} } };
int p[3][2][2]={ {1,2,3,4}, {5,6,7,8}, {9,10,11,12} };
int p[3][2][2]={1,2,3,4,5,6,7,8,9,10,11,12};

7.4. Exemple de prelucrare a masivelor.
Prezent"m 2 exemple de prelucrare a masivelor unidimensional #i
bidimensional:
Exemplu $. Prelucrarea unui masiv unidimensional:
Este dat un masiv unidimensional x cu n elemente. Compara!i suma primei
jum"t"!i a masivului cu media aritmetic" jumat"!ii a doua a masivului.
#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<stdlib.h>
void main(void) {
int x[20],n,k,i,s=0;
float m,s1=0,r=0;
printf("\nCulege m!rimea masivului n<=20\n");
scanf("%d",&n);
for(i=0;i<n;i++){
printf("Culege elementul %d\n",i);
scanf("%d",&x[i]);}
printf("Masivul ini"ial este:\n");
for(i=0;i<n;i++){
printf("%d ",x[i]);}
if (fmod(n,2)==0) k=floor(n/2); else k=floor(n/2)+1;
for(i=0;i<n;i++){
if (i<k) s+=x[i]; else {s1+=x[i]; r++;} }
m=s1/r;
printf("\nSuma primei jum!t!"i este %d\n",s);
printf("Media la a doua jum!tate este %f",m);
getch();}

Exemplu 2. Prelucrarea unui masiv bidimensional:
Este dat un masiv bidimensional. X[n,n].
Calcula!i produsul elementelor pozitive pare din aria ha#urat".
#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<stdlib.h>
void main(void) {
int x[20][20],n,i,j,p,k;

4$
printf("\nCulege m!rimea masivului n<=20\n");
scanf("%d",&n);
printf("\nCulege elementele masivului\n");
for(i=0;i<n;i++){
for(j=0;j<n;j++){
printf("\nCulege elementul x[%d][%d]\n",i,j);
scanf("%d",&x[i][j]);}}
printf("\nMasivul ini"ial este:\n");
for(i=0;i<n;i++){
for(j=0;j<n;j++){
printf("%d ",x[i][j]);}
printf("\n");}
p=1; k=floor((float)n/float(2));
for(i=0;i<n;i++){
for(j=k;j<n;j++){
if ( (x[i][j]>0)&&(fmod(x[i][j],2)==0) ) p=p*x[i][j];
}} printf("\nProdusul elementelor din aria ha$urata este=%d k=%d\n",p,k);
getch(); }

8. %iruri de caractere.
Numim #ir o succesiune de caractere ale alfabetului, adic" o propozi!ie. Spre
deosebire de alte limbaje de programare, limbajul C nu contine un tip de date special
ce desemneaz" #iruri de caractere. Limbajul C opereaza cu #irurile cum ar lucra cu o
succesiune de date de tip caracter amplasate ntr-un masiv. Aici fiecare simbol din #ir
este o component" aparte a masivului. Deci, pentru a defini o variabil", valoarea
careia va fi un #ir de caractere, n limbajul C trebuie de declarat un masiv de tip char
cu o lungime egal" cu cantitatea maximal posibil" de caractere n #ir. Urm"torul
exemplu arat" cum s-ar putea declara un asemenea masiv cu scopul de a culege un
nume de la tastatur" #i apoi de-l afi#at la monitor:
void main(void) {
char a[20]; int i;
printf ("Culege numele");
for(i=0; i<20; i++)
scanf ("%c",a[i]);
printf("Numele dumneavoastra este:");
for(i=0; i<20; i++)
printf("%c",a[i]); }
n acest program se observ" multe neajunsuri #i incomodit"!i. Pentru a
culege numele aici este folosit un ciclu cu 20 repet"ri care cite#te cte un caracter de
la tastatur" #i-l nscrie n celula corespunz"toare a masivului a[20]. Rezult" c" cu
ajutorul acestui program se poate culege numai nume alc"tuite din 20 de caractere,

42
sau nume din k caractere cu 20-k spa!ii dup" ele. Iar afi#area numelui este f"cut" cu
ajutorul func!iei printf( ) inclus" n ciclu, care afi#az" la monitor cte un caracter din
numele cules.
Not": La declararea masivului de tip char pentru descrierea unui $ir se indic!
m!rimea masivului cu o celul! mai mult de ct lungimea maxim! presupus! a $irului
din cauz! c! ultima celul! din masiv este rezervat! pentru simbolul nul "/0".
Evident c" imposibil de programat ntr-un limbaj de nivel nalt folosind
astfel de mecanisme. Din cauza c" programele pentru prelucrarea informa!iei textuale
au o popularitate foarte mare, limbajul C con!ine mecanisme care u#ureaz" lucru cu
#irurile de caractere. Aici #irurile snt prec"utate ca un tip special de masive, fapt ce
permite ntroducerea si afi#area #irurilor ca un tot ntreg. Pentru ntroducerea #irului
n memoria calculatorului este folosit" func!ia gets( ). Aceast" func!ie are urm"toarea
sintax":
gets (nume); unde nume este parametrul func!iei #i reprezint" numele
variabilei tip #ir, adic" a masivului de tip char. Exemplu:
void main(void) {
int i; char name [15];
printf ("Culege numele:");
gets(name);
printf ("Numele dumnevoastra este:");
for (i=0; i<15; i++)
printf ("%C", name[i]); }
Aici func!ia gets( ) va prec"uta primele $4 caractere culese de la tastatur" ca
valoare a #irului cu nume name, iar ultima celul" din masiv va con!ine simbolul nul
\0. n timpul lucrului functiei gets( ) executarea programului se stopeaz". Func!ia
gets( ) a#teapt" pn" utilizatorul va culege un #ir de la tastatur". Pentru ca textul cules
s" fie atribuit ca valoare unei variabile de tip #ir, utilizatorul trebuie s" culeag" tasta
ENTER. Dup" aceasta propozi!ia culeas" va deveni valoare a variabilei de tip #ir, iar
cursorul va trece n rnd nou pe monitor. Anume in timpul culegerii tastei ENTER
compilatorul C adaog" la sfr#itul #irului simbolul nul. n exemplu de mai sus
culegerea #irului se precaut" ca culegerea unei variabile de tip #ir aparte #i nu ca
culegerea a mai multor variabile de tip caracter. ns" afi#area numelui r"mne
incomod". Aici, dac" vor fi culese mai pu!in de $5 simboluri de la tastatur", atunci
elementele masivului name[15] ce urmeaz" dup" simbolul nul vor con!ine m"rimi
aleatoare.
n afar" de func!ia gets() limbajul C mai con!ine o modalitate de a ntroduce o
propozi!ie n memorie ca valoare a unei variabile de tip #ir. Folosind func!ia de

43
ntroducere cu format scanf(), se poate aplica urm"toarea sintax": scanf("%s",name);
care a#tept" culegerea de la tastatur" a unui #ir de caractere, pe care apoi (dupa
culegerea tastei ENTER l atribuie ca valoare variabilei name. Aici %s este formatul
tipului #ir de caractere.
Pentru afi#area la monitor a unui #ir de caractere este folosit" func!ia puts().
Func!ia puts( ) poate avea n calitate de parametru numai un #ir de caractere. Sintaxa
func!iei este urmatoarea: puts(parametru); unde n calitate de valoare poate fi folosit
un #ir de caractere sau numele unei variabile de tip #ir de caractere. Exemplu:
puts("Elena"); puts(name);
Majoritatea compilatoarelor C trec cursorul din rnd nou dup" executarea
func!iei puts(). ns" exist" #i a#a versiuni de compilatoare, care nu ndeplinesc aceast"
trecere din rnd nou. n acest caz e binevoit" folosirea simbolului de trecere n rnd
nou \n. Exemplu: puts("Elena|n");
Folosind func!iile gets( ) #i puts( ) exemplul de mai sus se poate scrie n felul
urm"tor:
void main (void) {
char name[15];
puts (" Culege numele");
gets (name);
puts ("Numele dvs este:");
puts (name); }

8.$. Masive de "iruri.
Declarnd un masiv char S[20] putem p"stra n el valoarea unui #ir de caractere.
n cazul, cnd este nevoie de prelucrat o totalitate din cteva #iruri, e comod de folosit
masive de #iruri.
Un masiv de #iruri este un masiv bidimensional tip char compus din linii #i
coloane. Pe fiecare linie din a#a masiv va fi nscris cte un #ir de caractere. Num"rul
maximal de #iruri astfel nscrise n masiv va fi egal cu cantitatea liniilor din masiv.
De exemplu: char propozi"ie[10][35]este un masiv, n care pot fi scrise $0
variabile de tip #ir de caractere, fiecare avnd lungimea maximal" de 34 de caractere.
Pentru a accesa un #ir din a#a masiv se va folosi sintaxa: propozi!ie[i], unde i este
num"rul rndului din masiv unde se va afla #irul. Pentru a accesa un caracter al #irului
i din masiv se va folosi sintaxa: propozi"ie[i][j] unde j este pozi!ia caracterului n
#irul i.


44
9. Structuri n C/C++.
Pn" n momentul de fa!" au fost studiate tipurile de date compuse, elementele
c"rora apar!in aceluia#i tip de date(simplu sau compus). n cazul unui masiv,
elementele acestuia erau de acela#i tip: ntreg, real, caracterial etc; f"r" a fi posibil"
atribuirea diferitor elemente ale masivului valori de tipuri diferite. ns" deseori apar
situa!ii cnd este necesar" prelucrarea #i p"strarea unei informa!ii mai complexe, a#a
c" orarul lec!iilor, reu#ita unui student etc. Dac" prec"ut"m cazul cu reu#ita
studentului, atunci este simplu de presupus c" va fi necesar" urm"toarea informa!ie:
numele studentului, grupa, notele la examen, balul mediu calculat. Aceste date snt
legate ntre ele prin faptul c" apar!in aceleia#i persoane. Ca urmare ar fi justificat"
tratarea lor ca o singur" valoare compus". ns" tipurile datelor defer" ntre ele:
numele #i grupa vor fi de tip #ir, notele la examen - de tip ntreg, iar balul mediu
calculat - de tip real(float). Gruprea acestor componente ntro variabil" compus" este
posibil" folosind un tip nou de date numit n limbajul C structur!.
Primul pas n gruparea componentelor de diferite tipuri ntr-o variabil"
compus" este declararea #i descrierea structurii. Declarnd o structur", se creeaz" un
tip nou de date a utilizatorului, care pn" n momentul dat n-a fost cunoscut de
compilator. Declararea structurilor se face n partea declar"rii tipurilor, nainte de
nceputul func!iei principale main().
Declararea unei structuri ncepe cu cuvntul chee struct, dup" care urmeaz"
numele structurii, care se mai nume#te tip nregistrare. Elementele unei variabile de
tip nregistrare snt nscrise dup" numele structurii ntre acolade. Sintaxa de descriere
a elementelor structurii e analogic" cu sintaxa declar"rii variabilelor: se indic"
numele #i tipul elementelor din structur" desp"r!ite prin simbolul ;. Descrierea
structurii de asemenea se termin" cu simbolul ;. Sintaxa descrierii unei structuri n
caz general este urm"toarea: struct nume {tip_1 nume_1; tip_2 nume_2;; tip_n
nume_n;};
Lista elementelor din structur" poart" numele de #ablon. O structur", ca atare
nu declar" nici o variabil". Elementele unei structuri nu snt variabile aparte, ele snt
componente ale unei sau a mai multor variabile. Astfel de variabile se numesc
structurale #i trebuie declarate ca fiind de tipul structurii respective. %ablonul
respectiv va descrie aceste componente, astfel va fi determinat volumul de memorie
necesar de rezervat pentru fiecare variabil" structurat" de tip nregistrare.
Dac" prec"ut"m exemplu cu reu#ita unui student, declararea unei structuri va fi
urm"toarea : struct stud {char name [20] ; int ex1, ex2; float med; char grup [10];};



45
9.$. Declararea variabilelor de tip structur#.
Declararea structurii nu rezerveaz" spa!iu de memorii pentru ea. nainte de a
folosi orice tip de date, e necesar de declarat o variabil" corespunz"toare. Este
imposibil de a folosi o structur" n program f"r" a declara o variabil" de tip
nregistrare, fix a#a cum e imposibil" folosirea unei valori de tip float naintea
declar"rii variabilei de tip float.
Sintaxa de declararea a unei variabile-structuri e urm"toarea:
struct nume_structura nume_variabil!;
Aici cuvntul cheie struct indic" compilatorului faptul c" merge vorba despre o
structur", iar tipul nregistr"rii stud determin" #ablonul dup" care va fi compus"
variabila.
Dup" tipul nregistr"rii urmeaz" numele variabilei, care va fi folosit n program.
De exemplu, pentru a primi acces la datele despre reu#ita unui student trebuie
declarat" o variabil": struct stud a; Acum avem variabila a compus" din 5 cmpuri,
pentru care a fost rezervat" memorie.
Dac" n program trebuie folosite cteva variabile de unul #i acela#i tip
nregistrare, e posibil de folosit urm"toarea sintax": struct stud a, b, c; Aici snt
declarate 3 variabile de tip nregistrare stud: a, b, c. n cazul cnd e necesar" folosirea
variabililor de tip nregistrare diferit, ele se vor declara aparte.
Exist" posibilitatea declar"rii variabilei de tip nregistrare odat" cu descrierea
structurii. Pentru aceasta numele variabilei va fi amplasat ntre acolada de nchidere #i
simbol ; la sfr#itul declar"rii structurii. Exemplu:
struct stud { char name [20];
char grup [10] ;
int ex1, ex2;
float med;}a;
Aici stud este tipul nregistr"rii #i numele unui nou tip de date numit structur".
Elementele, din care se compune structura se mai numesc cmpuri structurate, a este
numele variabilei , care va fi folosit" n program #i e compus" conform #ablonului din
5 componente.

9.2. Ini!ierea variabilelor tip nregistrare.
n cazul, cnd valorile ini!iale ale componentelor unei variabile-structu" snt
cunoscute, este posibil" atribuirea lor n timpul declar"rii variabilei. n cazul cnd se
declar" o simpl" variabil" tip nregistrare ini!ierea va fi o parte a declar"rii structurii:
struct stud { char name [20]; char grup [10];
int ex1, ex2; float med;}

46
a={Ivanov, SOE-991, 8,7,7.5};
Aici a fost descris" structura stud #i concomitent declarat" variabila a cu ini!ializarea
valorilor pentru componentele sale.
O alt" variant" de ini!ializare a componentelor structurii este ini!ializarea lor n
tipul declar"rii unei variabile tip nregistrare. Exemplu:
struct stud { char name [20]; char grup [10];
int ex1, ex2; float med;}
main () { struct stud a={Ivanov, SOE-991, 8,7,7.5}; }
O structur" este global", dac" e declarat" nainte de func!ia principal" main(),
#i este local" dac" e declarat" n"untru func!iei main(), sau n"untru altei func!ii. ns"
dac" e necesar" ini!ializarea unei structuri ce con!ine #iruri, ea trebuie declarat"
nainte de func!ia main() sau ca variabil" static": static struct stud;

9.3. Folosirea structurilor.
O structur" poate fi prelucrat" n program, numai dac" exist" declarat" o
variabil" de tip nregistrare. Aceast" variabil" e compus" din cteva elemente fiecare
avnd valoare de tip diferit. ns" adresarea c"tre valorile ce se con!in n cmpurile
structurii este imposibil" folosind nemijlocit numele cmpului respectiv. De asemenea
e imposibil" accesarea valorilor din variabila tip nregistrare folosind numai numele
ei. Conform regulilor de sintax" a limbajului C++, pentru a accesa un element al
structurii, este necesar de indicat numele variabilei tip nregistrare #i numele cmpului
respectiv folosind urm"toarea sintax": nume_var.nume_cmp , unde nume_var este
numele variabilei tip nregistrare, iar nume_cmp numele cmpului respectiv din
variabil".
Not!: La prelucrarea valorilor din cmpurile structurii se vor folosi toate func!iile,
instruc!iunile #i opera!iile aplicabile tipului c"rui i apar!in cmpurile structurii.
Exemplu: De alc"tuit o structur" care ar con!ine informa!ii despre un student (nume,
grupa) #i ar calcula nota medie dup" rezultatele la dou" examene:
struct stud {char name [20], group[10];
int ex1, ex2; float med;};
void main (void) { struct stud a;
puts(Culege numele $i grupa);
gets(a.name); gets(a.group);
puts(Culege notele la dou! examene);
scanf(%d%d,&a.ex1,&a.ex2);
a.med=(a.ex1+a.ex2)/2;
printf(media=%f,a.med);}

47

9.4. Structuri imbricate.
Tipul structur" este un tip compus, aceasta nseamn" c" o variabil" de acest tip
poate fi alc"tuit" din cteva elemente simple sau compuse, care la rndul s"u pot
deasemenea s" con!in" alte elemente. Acest fapt ne d" posibilitate s" folosim unele
structuri n calitate de cmpuri pentru altele structuri. Astfel de structuri se vor numi
imbricate. Cantitatea de niveluri de structuri imbricate teoretic poate fi infinit", ns"
nu se recomand" de a folosi foarte multe nivele de imbricare din cauza sintaxei
incomode.
n cazul cnd structura A contine n componen!a sa un cmp, care la rndul s"u
este deasemenea o structur" B, atunci structura A trebuie declarat" numai dup" ce va
fi declarat" structura B. Urm"torul exemplu folose#te variabila a de tip structur" stud
imbricat", care con!ine informa!ia despre un student #i rezultatele unei sesiuni.
Informa!ia despre rezultatele sesiunii este grupat" ntr-o structur" aparte cu numele
sesia #i e folosit" n calitate de cmp nota n structura stud:
struct sesia {int ex1,ex2,ex3;
float med;};
struct stud {char name [20], group[10];
struct sesia nota;};
void main (void) { struct stud a;
puts(Culege numele $i grupa);
gets(a.name); gets(a.group);
puts(Culege notele la 3 examene);
scanf(%d%d%d,&a.nota.ex1, &a.nota.ex2, &a.nota.ex3);
a.nota.med=( a.nota.ex1+a.nota.ex2+a.nota.ex3)/3;
printf(\nmedia=%f,a.nota.med);}
Aici a fost calculat" nota medie reie#ind din rezultatele la 3 examene. Din acest
exemplu este simplu de observat sintaxa de adresare la o valoare dintr-un cmp a unei
structuri imbricate: se folosesc numele fiec"rui cmp imbricat, separat prin punct #i
scrise n ordine descresc"toare pn" la cmpul destina!ie. Sintaxa a.nota.med
nseamn" ca se face o adresare la cmpul med ce apar!ine unei structuri (sesia), care la
rndul s"u este cmp (nota) n componen!a altei structuri (stud) apelat" prin
intermediul variabilei a.

9.5. Masive de structuri.
n timpul declar"rii unei variabile tip nregistrare, n memorie se nregistreaz"
spa!iu pentru p"strarea #i prelucrarea datelor ce se vor con!ine n cmpurile structurii

48
conform #ablonului numai pentru o nscriere: un student, o persoan" #.a.m.d. n cele
mai dese cazuri este necesar" prelucrarea informa!iei despre un grup de persoane, n
cazul nostru despre un grup de studen!i. n acest caz este necesar" declararea a mai
multor variabile de tip nregistrare, fiecare reprezentnd nscrierea concret", pentru un
student aparte.
Pentru a sistematiza informa!ia p"strat" ntr-o mul!ime de nscrieri este
binevenit" declararea unui masiv de structuri. n acest caz fiecare element al
masivului unidimensional tip structur" va p"stra informa!ia despre o persoan" #i
num"rul maximal persoane nregistrate in a#a fel va fi egal cu cantitatea de elemente
ce se con!in din masiv.
Un masiv unidimensional de structuri se poate declara n modul urm"tor:
struct nume_structur! nume_ masiv [N]; unde N - num"rul de elemente din masiv.
Exemplu: struct stud x[10]; n a#a fel au fost rezervate $0 regiuni de memorie,
fiecare avnd volumul necesar pentru a p"stra o structur" ntreag" pentru prelucrarea
informa!iei despre reu#ita unui student.
Adresarea in program la un element al masivului de structuri va fi f"cut" ca #i
n cazul unui masiv simplu: se va indica numele masivului cu num"rul de ordine al
elementului in paranteze p"trate. Exemplu: x[3]. ns" a#a o adresare c"tre structur"
va fi ncorect". Prelucrarea structurii are loc prin intermediul prelucr"rii cmpurilor
aparte din ea. Accesarea unui cmp din variabila de tip nregistrare care este n acela#
timp cmp al masivului va fi posibil" folosind sintaxa: nume_msiv[k].Nume_cmp,
unde k este num"rul de ordine a nregistrii necesare.
Exemplu: Pentru a nscrie n cmpul name din structura stud numele
studentului cu num"rul de ordine 2 vom folosi urm"toarea sintax": struct stud x[10];
gets(x[2].name).
Not": De nu uitat c" num"rarea elementelor n masiv se face ncepnd cu
indexul zero. n cazul nostru find alc"tuit un masiv din $0 structuri , num"rul de
ordine va varia de la 0 la 9.
Exemplu: Este dat" o baz" de date cu n nscrieri ce con!in informa!ia despre reu#ita
unui grup de studen!i. Dup" notele date la examenele unei sesiuni de calculat nota
medie pentru fiecare student. Cmpuri necesare: Numele, Grupa, Notele la examene,
Balul mediu calculat:
#include<conio.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
struct stud {char name[20], grupa[10];

49
int ex1,ex2; float med;};
void main (void){ clrscr();
struct stud x[50]; int i,N;
printf("Culege numarul studentilor\n");
scanf("%d",&N);
printf("Culege informatia despre %d studenti:\n",N);
for (i=0; i<N; i++){
printf("Culege numele studentului %d\n",i);scanf("%s",x[i].name);
printf("Culege grupa studentului %d\n",i); scanf("%s",x[i].grupa);
printf("Culege 2 note pentru studentul %d\n",i);
scanf ("%d%d",&x[i].ex1,&x[i].ex2);
x[i].med=(x[i].ex1+x[i].ex2)/2;}
printf("\nMasivul final este:\n");
printf("******************************************************\n");
printf("** Numele ** Grupa ** nota1 ** nota2 ** media **\n");
printf("******************************************************\n");
for (i=0;i<N;i++) {
printf("**%10s**%9s**%7d**%7d**%9.2f**\n",
x[i].name,x[i].grupa,x[i].ex1,x[i].ex2,x[i].med);
printf("******************************************************\n");
}
getch(); }

$0. Func!ii n C/C++.
Rezolvarea eficient" a problemelor cu ajutorul tehnicii de calcul presupune
folosirea tuturor tuturor posibilit"!ilor #i instrumentelor limbajului n care are loc
programarea. n timpul studierii instruc!iunilor #i tipurilor noi n C/C++ apar
posibilit"!i de rezolvare eficient" a unor probleme complicate. ns" odat" cu cre#terea
complicit"!ii problemei de rezolvat, se m"re#te volumul programului #i complicitatea
lui. n acest caz exist" necesitatea de a eviden!ia careva sarcini concrete din program
mp"r!indu-l n module separate numite func!ii.
Fiecare func!ie din program trebuie s" ndeplineasc" o singur" sarcin". De
exemplu, dac" se afl" notele medii la un grup de studen!i, atunci se poate de creat 3
func!ii: prima pentru culegerea valorilor ini!iale despre studen!i; a doua - pentru
calcularea notei medii #i a treia - pentru afi#area rezultatelor. Folosind aceste func!ii,
dac" n program trebuie de ndeplinit o sarcin" oarecare, atunci se apeleaz" la func!ia

50
respectiv" asigurnd-o cu informa!ia necesar" pentru prelucrare. Folosirea func!iilor
n C++ presupune respectarea urm"toarelor concep!ii de baz":
a) Func!iile grupeaz" setul de operatori pentru ndeplinirea unei sarcini concrete.
b) Programul principal apeleaz" la func!ie, adresndu-se la numele ei, dup" care
urmeaz" paranteze rotunde. Exemplu: afi$are().
c) Dup" terminarea prelucr"rii informa!iei, majoritatea func!iilor ntorc
programului principal valori de tipuri concrete. De exemplu: int sau float, care
pot fi folosite n calcule.
d) Programul principal transmite func!iilor parametrii (informa!ia ini!ial"), inclus"
n paranteze rotunde, care urmeaz" dup" numele func!iei.
e) Limbajul C++ folose#te prototipi de func!ie pentru determinarea tipului valorii
returnate de ctre func!ie, deasemenea a cantit"!ii si tipurilor parametrilor
transmi#i func!iei.
Odat" cu m"rirea volumului #i complicit"!ii programului, folosirea func!iilor va
deveni condi!ia principala pentru rezolvarea eficient" #i corect". n acela#i moment
crearea #i folosirea func!iilor snt proceduri simple.
n timpul cre"rii programului e necesar de rezervat fiecare func!ie pentru
rezolvarea unei sarcini. Dac" apar situa!ii, cnd func!ia rezolv" cteva sarcini, ea
trebuie divizat" n cteva func!ii mai mici. Fiecare func!ie creat" trebuie s"
primeasc" un nume unical. Ca #i n cazul cu variabilele, numele unei func!ii este
un identificator #i e de dorit s" corespund" cu sensul logic al sarcinei pe care o
ndepline#te.
Func!iile n C++ se aseam"n" la structur" cu func!ia principal" main(). n fa!a
numelui func!iei se indic" tipul ei, iar dup" numele func!iei urmeaz" lista de
parametri descri#i n"untrul parantezelor rotunde. Corpul func!iei compus din
operatori este amplasat dup" descrierea parametrilor #i-i nconjurat cu acolade
deschis" #i nchis". Sintaxa descrierii unei func!ii este urm"toarea:
tip_f nume_f (lista parametri) {declarare de variabile; operatori;}
unde tip_f este tipul func!iei sau tipul valorii returnate de func!ie, nume_f este
numele func!iei. Dac" facem analogie dintre func!ie #i programul principal main( ),
atunci putem scrie: void main (void) {corpul programului}, unde func!ia nu
ntoarce rezultate (cuvntul void naintea func!iei main() ) #i nu prime#te parametri
din exterior (cuvntul void ntre paranteze rotunde dup" func!ia main() ).
Urm"torii operatori determin" func!ia cu numele afi$are(), care afi#az" la
monitor un mesaj: void afi$are (void) {printf(Hello World\n);}
Dup" cum a fost spus, cuvntul void ce precedeaz" numele afi#are indic"
func!iei c" nu trebuie de ntors vre-o valoare n program, iar cuvntul void dup"

5$
numele afi#are indic" (compilatorului C++ #i programatorului ce cite#te acest cod) c"
func!ia nu folose#te parametri (informa!ie ini!ial" pentru ndeplinirea sarcinei).
Urm"torul program folose#te func!ia afi$are() pentru afi#area mesajului pe ecran:
# include<stdio.h>
# include<conio.h>
void afisare (void) {
printf(\ Hello World\n);
void main (void) {
puts (inaintea folosirii func"iei);
afisare( );
puts (dupa folosirea func"iei);
getch(); }
Ca #i orice program n C++ acest exemplu va fi ndeplinit ncepnd de la func!ia
principal" main( ). n"untru programului operatorul de apel la func!ie apeleaz" la
func!ia de afi#are astfel: afi$are(); unde parantezele rotunde dup" identificator indic"
compilatorului c" n program se folose#te func!ia afi$are(). Cnd programul va ntlni
apelul la func!ie, se va ncepe ndeplinirea tuturor operatorilor din corpul func!iei, #i
dup" aceasta executarea programului principal va fi continuat" cu operatorul
amplasat nemijlocit dup" operatorul de apel la func!ie. Urm"torul program-exemplu
con!ine dou" func!ii, prima afi#az" pe ecran o salutare, iar a doua tema lec!iei:
# include<stdio.h>
# include<conio.h>
void hello (void){
printf(\n Hello\n);}
void tema (void){
printf(Func"ii in C++\n);}
void main (void){
hello();
tema(); }
n rezultatul ndeplinirii acestui exemplu vor fi afi#ate pe ecran dou" mesaje:
Hello #i Func"ii n C++ , n ordinea cum apar n program.
Func!iile prezentate mai sus ndeplinesc sarcini foarte simple. n aceste cazuri
programul putea fi alc"tuit f"r" folosirea func!iilor, cu includerea acelora#i operatori
n corpul func!iei main(). ns" func!iile au fost folosite pentru a analiza descrierea #i
folosirea ulterioar" a func!iilor. n timpul rezolv"rii problemelor complicate va fi
posibil, n a#a fel, de simplificat rezolvarea, mp"r!ind sarcina n module aparte
realizate de func!ii. n acest caz va fi simplu de observat c" analiza #i modificarea

52
func!iilor este cu mult mai simpl" dect prelucrarea unui program voluminos #i
complicat. Mai mult ca att, func!ia creat" pentru un program poate fi folosit" #i n alt
program f"r" schimb"ri. n a#a mod pot fi alc"tuite biblioteci de func!ii, folosirea
c"rora cu mult va mic#ora timpul folosit pentru alc"tuirea programelor.

$0.$. Transmiterea parametrilor n func!ie.
Pentru a m"ri posibilit"!ile func!iilor din program, limbajul C++ permite de a
transmite informa!ie n ele. Informa!ia ini!ial" transmis" din program n func!ie la
momentul apelului acesteia se nume#te parametru. Dac" func!ia folose#te parametri,
ei trebuie descri#i n timpul descrierii func!iei. n timpul descrierii parametrelor
func!iei se indic" numele #i tipul fiec"rui parametru n urm"torul mod:
tip_parametru nume_parametru;
Dac" func!ia con!ine c!iva parametri, ei vor fi descri#i mpreun" ntre
parantezele rotunde dup" numele func!iei desp"r!i!i prin virgul" dup" cum urmeaz":
tip_func"ie nume_func"ie (tip_parametru1 nume_parametru1,
tip_parametru2 nume_parametru2
.........................................................
tip_parametruN nume_parametruN );
Func!ia din exemplu urm"tor folose#te un parametru de tip ntreg, care
n rezultatul ndeplinirii sale, l afi#eaz" la monitor.
# include<stdio.h>
void num!r (int a) {
printf(Parametru=%d\n,a);}
void main (void) {
num!r (1);
num!r (17);
num!r (-145); }
n rezultatul ndeplinirii acestui exemplu vor fi primite 3 fraze ca
r"spuns:
Parametru=1
Parametru=17
Parametru=-145
n timpul execut"rii acestui program, func!ia num!r() este apelat" de 3
ori cu diferite valori a parametrului. De fiecare dat" cnd n program este ntlnit"
func!ia num!r() valoarea parametrului este nlocuit" n func!ie #i rezultatul est diferit.
Parametrii func!iei pot fi de tipuri diferite. n cazul exemplului precedent
parametrul a este de tip ntreg. Dac" n program va fi f"cut" ncercarea de a

53
transmite func!iei un parametrul de alt tip, de exemplu float, compilatorul va ntoarce
o eroare. Majoritatea func!iilor folosesc mai mul!i parametri, n acest caz trebuie s"
fie indicat tipul fiec"rui parametru. Urm"torul exemplu folose#te func!ia muncitor();
care afi#eaz" numele #i valoarea salariului unui muncitor:
# include<stdio.h>
void muncitor (char nume[15], float salariu)
{printf(Muncitorul %s are salariu= %f lei\n,nume,salariu);}
void main (void) {
muncitor(Ivanov, 355.35);
muncitor(Petrov, 560.00); }
n rezultatul ndeplinirii acestui program func!ia muncitor() este apelat"
de dou" ori #i snt afi#ate mesajele:
Muncitorul Ivanov are salariul= 355.35 lei.
Muncitorul Petrov are salariul= 560.00 lei.
Not!: n unele surse de descriere a limbajului de programare C/C++
parametrii ce se transmit din program n func!ie se numesc actuali, iar parametrii ce
snt declara!i n antetul func!iei #i c"rora le se atribuie valorile parametrilor actuali se
numesc parametri formali.
A#adar n exemplul precedent valorile Ivanov #i 355.35 snt parametri
actuali, iar char num[15] #i float salariu snt parametri formali.
Urmatorul exemplu folose#te func!ia max(), care compar" 2 numere ntregi:
# include<stdio.h>
void max (int a, int b) {
if (a>b) printf (%d este mai mare ca %d\na,b);
else if (b>a) printf(%d este mai mare ca %d \n,b,a); }
else printf(%d este egal cu %d \n,a,b); }
void main (void) {
max(17,21);
max(5,3);
max(10,10); }
Deci n timpul folosirii parametrilor n func!ie este necesar" respectarea
urm"toarelor reguli:
Dac" func!ia folose#te parametri, ea trebuie s" indice numele unical #i tipul
fiec"rui parametru.
Cnd programul apeleaz" la func!ie, compilatorul atribuie valoarea
parametrlor de la stnga la dreapta.

54
Valorile transmise din program n func!ie, trebuie s" coincid" ca num"r, loc
#i tip cu parametrii din func!ie.

$0.2. ntoarcerea valorilor din func!ie.
Destina!ia oric"rei func!ii este ndeplinirea unei sarcini concrete. n majoritatea
cazurilor func!iile vor efectua careva calcule. Dup" aceasta func!ia va ntoarce
rezultatul func!iei din care a fost apelat" fie aceasta func!ia principal" main(), fie
alt" func!ie. La momentul cnd func!ia ntoarce o valoare, trebuie s" fie cunoscut
tipul ei. Tipul valorii returnate de func!ie se indic" n timpul descrierii func!iei
nainte de numele ei. Tipul valorii returnate se mai nume#te #i tipul func!iei.
Func!ia din urm"torul exemplu adun" 2 numere ntregi #i ntoarce rezultatul
programului principal:
# include<stdio.h>
# include<conio.h>
int suma (int a, int b) {
int R;
R=a+b;
Return (R);}
void main (viod) { int K;
K=suma(15,8);
printf(suma=,K);}
n acest caz, cuvntul int, ce se afl" naintea numelui func!iei suma() n timpul
descrierii acestuia, este tipul valorii returnate de func!ie n programul principal.
Func!iile folosesc operatorul return pentru a ntoarce valori func!iilor din care
au fost apelate. Cnd compilatorul ntlne#te operatorul return, el ntoarce valoarea
dat" #i ncheie executarea func!iei curente, controlul execut"rii programului fiind
transmis func!iei din care a fost chemat" func!ia curent". Dac" dup" operatorul
return, n func!ie mai exist" operatori, ei vor fi ignora!i, func!ia terminndu-se
odat" cu ndeplinirea operatorului return.
Func!ia suma() din exemplu precedent este alc"tuit" din 3 instruc!iuni. Exist"
posibilitatea de a mic#ora corpul acestei func!ii dup" cum urmeaz" n exemplu
urm"tor:
int suma (int a, int b) {return(a+b);}
n acest caz, n calitate de parametru pentru operatorul return a fost folosit" o
expresie ce calcul" suma a dou" numere. n general, parametrul return folose#te n
calitate de parametrul o expresie ce are rezultate tip identic cu tipul func!iei, adic"
tipul valorii returnate de func!ie.

55
Nu toate func!iile returneaz" valori de tip ntreg. Urm"torul exemplu folose#te
func!ia media() , care returneaz" media aritmetic" a 3 numere ntregi. Evident
rezultatul func!iei poate fi #i un num"r real:
# include<stdio.h>
# include<conio.h>
float media (int a, int b, int c,){
return (float(a+b+c)/3.0); }
float R;
R=media(5,7,10);
printf(media este =%f,R); }
n rezultatul ndeplinirii acestui exemplu, va fi primit rezultatul R=7,333. n
func!ie a fost folosit" conversia (float(a+b+c)) a uni num"r ntreg n echivalentul
s"u real pentru a primi ca rezultat media aritmetic" a 3 numere de tip real. n acest
exemplu cuvntul float ce se afl" naintea numelui func!iei media() n momentul
descrierii acestea, indic" tipul valorii returnate.
Exist" situa!ii cnd operatorul return este folosit n func!ii ce nu ntorc valori.
Urm"torul exemplu demonstreaz" aceast" posibilitate:
# include<stdio.h>
# include<conio.h>
max (int a, int b) {
if (a>b) printf(%d>%d\n,a,b);
else if (a<b) printf(%d<%d\n,a,b);
else printf (%d=%d\n,a,b);
return 0;}
void main (void) {
max (17,21);
max (3,-7);
max (5,5); }
Valoarea ntoars" de func!ie poate fi folosit" n orice loc al programului, unde e
posibil" folosirea unei valori de tip identic cu valoarea returnat". Cnd func!ia
ntoarce o valoare, aceast" valoare poate fi atribuit" unei variabile de acela#i tip
folosind operatorul de atribuire. Exemplu: R=media (5,7,10);
n continuare la acele spuse, ns"#i numele func!iei poate fi folosit, n cazul cnd
exist" necesitatea folosirii valorii returnate de func!ie, de exemplu valoarea returnat"
poate fi folosit" n interiorul func!iei de afi#are:
printf(Media este =%f,media (5,7,$0));

56
Mai mult ca att func!ia poate folosi valoarea returnat" n condi!ii, dup"
cum urmeaz":
if (media(5,7,-14)<0) printf(media este negativa\n);

$0.3. Prototipul func!iei.
nainte de a face apelul unei func!ii compilatorul C++ trebuie s" cunoasc" tipul
valorii returnate, cantitatea #i tipul parametrilor folosi!i de func!ie. n fiecare
exemplu prec"utat pn" n prezent descrieria func!iei era f"cut" naintea apelului ei
din programul principal. ns" snt situa!ii, cnd unele func!ii n program snt apelate
reciproc. n a#a cazuri este posibil" situa!ia cnd o func!ie va fi apelat" nainte
descrierii sale.
Pentru a garanta faptul, c" compilatorul C++ cunoa#te particularit"!ile fiec"rei
func!ii folosite n program, se folosesc prototipi ai func!iilor. Prototipul unei
func!ii este amplasat la nceputul programului #i con!ine informa!ia despre tipul
valorii returnate, cantitatea #i tipul parametrilor folosi!i de func!ie.
Exemplul urm"tor demonstreaz" cum s-ar putea alc"tui prototipi pentru func!iile
folosite anterior.
void afi$are (void);
void hello (void);
void tema (void);
void num!r (int);
void muncitor (char, float);
void max (int, int);
int suma (int, int);
float media (int, int, int);
Dup" cum se vede din exemplu fiecare func!ie #i are prototipul s"u care
descrie tipul valorii returnate, cantitatea #i tipul parametrilor. Este important de nu
uitat de simbolul ; la sfr#itul fiec"rui prototip. Lispa lui duce la eroare n
compilare, la fel cum duce la eroare lipsa prototipului unei func!ii dac" aceasta
apare n program naintea descrierii sale. Fiind declarat prototipul unei func!ii
nainte de a fi nceput corpul programului, descrierea ei poate fi f"cut" dup"
acolada de nchidere a programului principal. Exemplu:
# include<stdio.h>
# include<conio.h>
float media (int,int,int);
void main (void) {float r;
clrscr(); r=media (5,17,10);

57
printf (media=%f/n,r);
getch ( ); }
float media (int a, int b, int c) {
return (float(a+b+c)/3.0);}

$0.4. Variabile locale "i domeniul de vizibilitate.
Func!iile folosite n exemplele precedente ndeplinesc ni#te sarcini relativ
simple. La momentul, cnd func!iile vor trebui s" ndeplineasc" ni#te sarcini mai
complicate, va ap"rea necesitatea folosirii n func!ii a variabilelor proprii.
Variabilele declarate n cadrul func!iei se numesc locale. Numele #i valoarea
unei variabile locale snt cunoscute numai func!iei n care ea a fost declarat". Chiar
faptul c" variabila local" exist" este cunoscut numai func!iei n care ea a fost
declarat". Declararea variabilelor are loc la nceputul func!iei, ndat" dup" acolada ce
deschide corpul acesteia. Numele variabilei locale trebuie s" fie unical numai n
func!ia n care a fost declarat". O variabil" se nume#te local", din cauz" c" este v"zut"
numai din func!ia n care a fost descris". Sintaxa de declarare a unei variabile locale
este:
tip_f numele_f (lista parametrilor) {tip_vl numele_vl;}
unde: tip_f - tipul func!iei; nume_f - numele func!iei; tip_vl - tipul variabilei;
numele_vl - numele variabilei;
Principiile de declarare #i folosire a unei variabile locale oric"rei func!ii snt
identice cu principiile de declarare #i utilizare a unei variabile declarate n corpul
func!iei principale main(); O variabil" declarat" n corpul func!iei main()este local"
acestei func!ii.
n general, tot ceia ce a fost spus despre variabilele declarabile n func!ia
main(): tipurile, numele, principiile de utilizare #.a. este aplicabil pentru o variabil"
local" din orice alt" func!ie.
Urm"torul exemplu folose#te func!ia fact() pentru calcularea factorialului unui
num"r.
#include<stdio.h>
#include<conio.h>
int fact (int R) {
int i, k=1;
for (i=1;i<=R;i++){k*=i;}
return (k);}
void main (void) {
int n; clrscr();

58
printf (Culege o cifra\n);
scanf(%d,&n);
printf (%d!=%d\n,n,fact(n));
getch( );}
n exemplu precedent func!ia fact() folose#te 2 variabile locale i #i k de tip
ntreg. Variabila k se ini!ializeaz" cu valoarea $ chiar n momentul declar"rii sale.
Anume n aceast" variabil" va fi p"strat" valoarea factorialului pe parcursul execu!iei
func!iei fact().
S" analiz"m acest exemplu. La nceputul execut"rii programului, utilizatorul
culege o cifr" de tip ntreg din care mai apoi va fi calculat factorialul. Cifra culeas" de
utilizator se p"streaz" ini!ial n variabila n, apoi odat" cu apelul func!iei fact() se
transmite ca parametru fiind atribuit" parametrului formal R din func!ie. La nceputul
execut"rii func!iei, variabilei locale k, n care va fi p"strat" valoarea factorialului i se
atribuie valoarea ini!ial" $ pentru a evita orice valori ntmpl"toare. Anume prin
intermediul variabilei locale k func!ia ntoarce valoarea final" a factorialului n
programul principal. n continuare ciclul for e repetat de n ori pentru a calcula
valoarea factorialului n!, nmul!ind de fiecare dat" valoarea nou" a parametrului
ciclului i la valoarea veche a lui k. La sfr#it valoarea final" a lui k va fi ntoars" n
program cu ajutorul operatorului return ().
n timpul declar"ri variabilei locale pentru func!ii exist" probabilitatea, c"
numele variabilei locale declarate ntr-o func!ie s" fie identic cu numele variabilei
locale din alt" func!ie. Dup" cum a fost spus, o variabil" local" este cunoscut" numai
n func!ia, n care a fost declarat". A#adar, dac" dou" func!ii folosesc acela#i nume
pentru variabilele sale locale, aceasta nu aduce la situa!ie de conflict. Compilatorul
C++ precaut" numele fiec"rei variabile ca local" pentru func!ia corespunz"toare.
Urm"torul exemplu folose#te func!ia suma() pentru adunarea a dou" numere
ntregi. Aceast" func!ie atribuie rezultatul ndeplinirii sale variabilei locale x. ns"
func!ia main() folose#te n calitate de parametru transmis func!iei suma() deasemenea
o variabil" cu numele x. Din cele spuse mai sus rezult" c" ambele variabile vor fi
prec"utate ca locale #i nu va ap"rea situa!ie de conflict.
#include <stdio.h>
#include<conio.h>
int suma(int a, int b) {
int x;
x=a+b;
return(x); }
void main (void) {

59
int x,y;
printf(Culege 2 cifre\n);
scanf(%d%d,&x,&y);
printf(%d+%d=%d,x,y,suma(x,y));
getch(); }
Exemplul urm"tor folose#te func!ia suma() pentru a calcula suma elementelor
unui masiv unidimensional de tip ntreg. n calitate de parametri se folosesc masivul
#i m"rimea sa.
# include<stdio.h>
# include<conio.h>
int suma (int y[10], int m) {
int i, sum=0;
for (i=0;i<m;i++){
sum+=y[i];}
return(sum); }
void main (void) {
int w,n,i,x[10]; clrscr();
printf(Culege marimea masivului n<10\n);
scanf(%d, &n);
for (i=0;i<n;i++){
printf(Culege elementul x[%d]\n,i);
scanf(%d,&x[i]); }
w=suma(x,n);
printf(suma masivului = %d\n,w);
getch( ); }

$0.5. Variabile globale.
Numim variabil" global" o variabil", numele #i valoarea c"reia snt cunoscute
pe parcursul ntregului program. Despre existen!a unei variabile globale ntr-un
program C++ #tie orice func!ie din acest program. Pentru a crea o variabil" global" se
folose#te declararea ei la nceputul programului n afara oric"rei func!ii. Orice
func!ie, care va urma dup" a#a o declarare poate folosi aceast" variabil" global".
Declararea unei variabile globale are urm"toarea sintax":
# include<stdio.h>
tip_vg nume_vg;
void main (void)
{}

60
unde tip_vg este tipul variabilei globale, iar nume_vg numele variabilei globale.
Fiind declarat" o variabil" global", valoarea ei nu numai e cunoscut" oric"rei
func!ii din program, dar #i poate fi schimbat" din oricare din func!iile prezente n
program.
Exemplu urm"tor folose#te variabila cu numele cifra. Fiind accesibil" din
oricare din 2 func!ii prezente n program, valoarea variabilei globale cifra este
schimbat" pe rnd din ambele func!ii:
# include<stdio.h>
int cifra=100;
void f1 (void) {
printf(cifra=%d\n, cifra);
cifra*=2; }
void f2 (void) {
printf(cifra=%d\n,cifra);
cifra+=2;}
void main (void) {
printf(cifra= %d\n, cifra); //100
cifra ++;
f1(); //101, 202
f2 ( ); //202, 204
printf(cifra=%d\n,cifra); //204
getch( ); }
Cu toate c" prezen!a variabilelor globale n program adaog" noi posibilit"!i, e
de dorit de a evita folosirea lor frecvent". Din cauza, c" orice func!ie din program
poate schimba valoarea variabilei globale este foarte greu de urm"rit toate func!iile,
care ar putea schimba aceast" valoare, ceia ce duce la control dificil asupra execu!iei
programului. Pentru a rezolva aceast" problem" se poate declara variabila n corpul
func!iei main() #i apoi de a o transmite altor func!ii, n calitate de parametru. n acest
caz n stiv" va fi amplasat" copia temporar" a acestei variabile, iar valoarea ini!ial"
(originalul) va r"mne neschimbat".

$0.6. Conflicte dintre variabile locale "i globale.
n cazul cnd un program trebuie s" foloseasc" o variabil" global", poate ap"rea
situa!ie de conflict, dintre numele variabilei globale #i numele variabilei locale. n a#a
cazuri limbajul C++ ofer" prioritate variabilei locale. Adic", dac" exist" variabil"
global" cu acela#i nume ca #i variabila local", compilatorul consider", c" orice apel a
variabilei cu a#a nume este un apel al variabilei locale. ns" apar situa!ii, cnd exist"

6$
necesitatea de a se adresa la o variabil" global" ce se afl" n conflict cu o variabil"
local". n acest caz se poate folosi operatorul global de acces (::).
Urm"torul exemplu folose#te variabila global" num. Pe lng" aceast" func!ia
afi$are() folose#te variabila local" num. Folosind operatorul global de acces (::)
func!ia apeleaz" la variabila global" num f"r" conflict cu variabila local" num:
# include<stdio.h>
int num=505;
void afisare (void) {
int num=37;
printf(variabila locala num=%d\n,num);
printf(variabila globala num=%d\n,::num);}
void main (void) { afisare(); }

$$. Indicatori (pointeri).
Un program n limbajul de programe C/C++ con!ine n cele mai frecvente
cazuri o mul!ime de variabile mpreun" cu descrierea lor. Fie variabila x descris" n
program prin declararea de forma int x; n acest caz compilatorul rezerveaz" un spa!iu
de 2 octe!i n memoria calculatorului. La rndul s"u, celula de memorie unde va fi
alocat" valoare variabilei x, #i are adresa sa. De exemplu: 2$650. Cnd variabila x
prime#te o valoare, aceast" valoare neap"rat se nscrie n celula de memorie rezervat"
variabilei x. Deoarece, n cazul nostru variabila x #i p"streaz" valorile pe adresa
2$650, celula cu aceast" adres" va con!ine valoarea atribuit" variabilei x.
n a#a caz, c"tre orice variabil" din program se poate de se adresat n 2 moduri:
folosind numele variabilei sau folosind adresa din memorie unde este p"strat"
valoarea variabilei x. Folosind numele variabilei, noi ne adres"m la valoarea
variabilei care se p"streaz" n memorie. Folosind adresa, noi ne adres"m la celula de
memorie cu adresa respectiv", unde se p"streaz" valoarea variabilei.
Limbajul de programare C/C++ con!ine tehnici mai avansate de lucru cu
valoarea unei variabile #i adresa de memorie unde se p"streaz" aceast" valoare. n
aceste scopuri se folosesc indicatori. Indicatorul reprezint" o variabil", ce con!ine
adresa altei variabile. Sintaxa de declarare a unui indicator este urm"toarea:
tip *nume; unde tip este tipul de date a variabilei la care se poate referi
indicatorul (adic" tipul de date a variabilei, adresa de memorie a c"reia va con!ine
indicatorul); astericsul * indic" c" identificatorul ce urmeaz" dup" el este un
indicator.
nume este un identificator ce desemneaz" numele variabilei indicator.
Exemple de declarare a indicatorilor:

62
int *x; // indicator la date de tip ntreg.
float *p; // indicator la date de tip flotant.
char *z; // indicator la date de tip caracterial.
int *y[3]; // masiv de indicatiori la date de tip ntreg.
void *k; //indicator la obiectul datelor tipul c!rora nu-i necesar de definit
char *S[5]; // masiv de indicatori la date de tip caracter.
char (*S)[5]; // indicator la date de tip caracter din 5 elemente.
Odat" ce indicatorul a fost declarat ca referin!" la date de tip ntreg, el nu se va
putea referi la o variabil" tip float, cauza fiind volumul diferit rezervat n memorie
pentru variabile ntregi #i flotante. Exist" indicatori #i c"tre elemente f"r" tip - void.
Putem atribui unui pointer void valoarea altui pointer non-void, f"r" a fi necesar"
opera!ia de conversie de tip. Exemplu:
int *a; void *b;
b=a; //corect
a=b; //incorect, lipse$te conversia de tip.
Fie c" a avut loc o atribuire de forma: int x=5;. n acest caz pentru variabila x a
fost rezervat" o zon" de memorie cu volumul de 2 octe!i, care #i are adresa sa.
Adresa zonei de memorie, unde se p"streaz" valoarea variabilei x se poate ob!ine cu
operatorul ob!inerii adresei &. Rezultatul opera!iei ob!inerii adresei este adresa
loca!iei de memorie ce a fost alocat" pentru variabila respectiv". De exemplu:
presupunnd c" x e nscris" n memorie pe adresa 2$650, atunci &x va fi egal" cu
2$650. Este important, c" &x este constant" de tip indicator #i valoarea sa nu se
schimb" n timpul execu!iei procramului. Exemplu:
# include <stdio.h>
void main (void)
int x=5; float r=1.7;
int *q; float *w;
q=&x; w=&r;
printf (%f se afl! pe adresa % d \n,r,w);
printf (% d se afl! pe adresa %d \n,x,q);}
Din exemplu u#or se observ" c" adresa celulei de memorie se reprezint" printr-
o valoare de tip ntreg. n acela#i timp aceast" valoare nu poate fi schimbat" n
program #i expresia &x=55; este incorect".
Analiznd toate aceste no!iuni, apare ntrebarea: Cu ce scop se folosesc
indicatori, dac" valoarea variabilei #i valoarea adresei sale se poate p"stra n variabile
simple?.

63
Prioritatea folosirii indicatorului const" n faptul, c" la el se poate adresa n 2
moduri: q #i *q. Astericsul * n acest caz indic" c" se apeleaz" la con!inutul celulei de
memorie, adresa c"reia este valoarea indicatorului. Adic" valoarea variabilei x de tip
ntreg este 5; valoarea indicatorului q este 2$650; iar valoarea lui *q este egal" cu
cifra de tip ntreg 5 nscris" pe adresa de memorie 2$650.
n a#a mod:
$) Variabila q poate primi valori numai n form" de adres" q=&x #i atribuirea
de forma q=21650; este incorect" din cauza c" aici se ncearc" atribuirea unei
valori ntregi unui indicator #i nu a adresei.
2) Variabila *q poate primi valori de tip ntreg. De exemplu: *q=6; Aceast"
atribuire se descifreaz" astfel: de amplasat valoarea ntreag" 6 n celula de
memorie ce are adresa indicat" n variabila q. Din cauza, c" variabila q indic"
la celula cu adresa 2$650, valoarea variabilei ce-#i p"streaz" valoarea n celula
de memorie cu aceast" adres" va fi egal" cu 6. Exemplu:
#include <stdio.h>
main void (main){
int x=5;
int *q;
q=&x;
printf (x=%d\n,x); // x=5;
*q=6;
printf (x=%d\n,x) } // x= 6;
n rezultatul ndeplinirii exemplului vor fi afi#ate 2 expresii: x=5 #i x=6. Prima
valoare primit" de variabila x este valoarea 5 atribuit" la momentul ini!ializ"rii
acesteia. A doua valoare primit" de variabila x este valoarea 6 atribuit" celulei de
memorie la care indic" indicatorul q.
Desigur variabila x ar putea primi valoare nou" prin simpla atribuire, x=6; dar
efectul deplin de la folosirea indicatorilor se poate observa la transmiterea lor n
calitate de parametri unei func!ii, la crearea unui fi#ier, etc.
Este de remarcat faptul, c" n anumite cazuri indicatorul neini!ializat reprezint"
un pericol n program. De exemplu, dac" exist" necesitatea de a transmite datele pe
adresa, ce con!ine indicatorul, n condi!iile cnd acesta nu e corect ini!ializat, se poate
de #ters informa!ia important" pentru func!ionarea sistemului opera!ional, sau altor
programe, fiindc" indicatorul neini!ializat poate indica la orice adres" de memorie
inclusiv la adresa unde snt p"strate date importante ale sistemului de operare. Un
exemplu de ini!ializare a indicatorului este: int *q=&x.

64
Cu scopul folosirii eficiente a memoriei limbajul C/C++ ofer"
programatorilor posibilitatea eliber"rii memoriei alocate, dac" e necesar. Pentru
aceasta se folose#te func!ia free(), prototipul c"reia se afl" n biblioteca alloc.h.
Exemplu:
# include <stdio.h>
# include <alloc.h>
main void (main){
int x=5, *q=&x;
*q=6;
printf(x=%d \n, x); // x=6;
free (q);
printf (x=%d \n, x); // x=-16;
printf (adresa x = %d/n, &x) // -12.
n rezultatul execut"rii acestui program vor fi primite mesajele:
x=6; x=-16, adresa x=-12. Primul mesaj va fi acela#i, dac" programul va fi executat
pe orice calculator. Ultimele 2 mesaje vor fi diferite de la un calculator la altul n
dependen!" de alocarea memoriei. Aici dup" folosirea func!iei free(q) valoarea
p"strat" n celula de memorie la care indic" indicatorul q va fi pierdut", adic"
valoarea variabilei x va fi pierdut".

$$.$. Indicatori "i func!ii.
Din temele precedente se #tie c" n timpul lucrului cu o func!ie, la apelul ei se
poate transmite at!i parametri, de c!i este nevoie n program. n acela#i timp cu
ajutorul operatorului return, se poate ntoarce numai o singur" valoare din func!ie. %i
situa!iile, cnd func!ia trebuie s" calculeze #i s" ntoarc" cteva valori n program par a
fi nesolu!ionate. n calitate de alternativ" se pot folosi variabile globale, ns" n acest
caz deseori se pierde controlul asupra ndeplinirii programului #i se complic" c"utarea
gre#elilor.
n cazul, cnd exist" necesitatea de a ntoarce din func!ie mai multe valori, este
util de folosit indicatori. F"r" folosirea indicatorilor, noi trebuie s" transmitem
parametri func!iei dup" valoare. Aceasta nseamn", c" valoarea parametrului actual se
atribuie parametrului formal. Ace#ti parametri ocup" zone de memorie diferite, #i
deci schimbarea valorii parametrului formal din func!ie nu duce la schimbarea valorii
parametrului actual.
n cazul transmiterii parametrilor dup" adres" cu ajutorul indicatorilor, nu se
creaz" copii de valori ce dubleaz" parametrii. n acest caz se creaz" o a doua variabil"
ce indic" la aceia#i celul" de memorie. n a#a fel, dac" este schimbat" valoarea

65
parametrului formal din func!ie prin indicator, deasemenea este schimbat" #i valoarea
parametrului actual. Exemplu:
# include <stdio.h>
int schimb (int w, int *z)
(*z)*=2; w=w*2;
return(w);}
void main (void)
int x=5, y=8,a;
printf (x=%d, y=%d,x,y);
a=schimb(x, &y);
printf (x=%d,y=%d\na,y);}
n acest exemplu snt date 2 variabile x=5 #i y=8. Func!ia schimb() schimb"
valorile lor nmul!indu-le la 2. ns", dac" valoarea lui x este schimbat" n func!ie #i
ntoars" n program prin intermediul operatorului return, atunci valoarea lui y este
schimbat" prin intermediul indicatorului. Apelnd func!ia schimb(), noi transmitem n
calitate de parametru nu valoarea variabilei y, ci adresa celulei de memorie, unde ea
#i p"streaz" valoarea. n a#a fel, orice schimbare a valorii indicatorului *z din func!ie
va duce la schimbarea valorii variabilei y din program.
Un caz aparte n lucrul cu indicatorii este folosirea indicatorului la un #ir de
caractere. %irul de caractere prezint" un masiv tip caracterial. Cnd programul
transmite un masiv n func!ie, compilatorul transmite adresa primului element al
masivului. n rezultat este admisibil ca func!ia s" foloseasc" indicator la #ir de
caractere. Exemplul urm"tor calculeaz" de cte ori ntr-o fraz" dat" se ntlne#te
caracterul a:
# include <stdio.h>
int litera (char *s){
int k=0;
wutile (*s!=\0) {
prinf (caracterul % c pe adresa %d,*s,s);
if (*s ==a) k++;
s++;}
return (k);}
void main (void)
int p; char x [25];
puts (culege o fraz!);
gets (x);
p=litera(x);

66
printf (fraza con"ine %d caractere a,p); }
Aici, la apelul func!iei litera() n calitate de parametru se transmite nu adresa
#irului de caractere x, ci ns"#i #irul. Aceasta e condi!ionat de faptul, c" la
transmiterea masivelor n calitate de parametru actual, se transmite nu masivul ntreg,
ci adresa primului element al masivului. Deci indicatorul s va con!ine adresa
elementelor masivului, iar *s valorile lor. n a#a mod, la prima itera!ie a ciclului
while variabila *s va avea valoarea egal" cu primul caracter din #irul x transmis
func!iei. Dup" ndeplinirea primei itera!ii func!ia m"re#te valoarea variabilei s cu $
unitate. Aceasta nseamn" c" valoarea adresei primului caracter din #ir va fi
ncrementat", n rezultat primindu-se adresa caracterului al doilea din #ir. Ciclul se va
termina cnd va fi depistat caracterul nul n #ir.
Acela#i lucru se poate de f"cut #i cu un masiv tip ntreg:
# include <stdio.h>
# include <conio.h>
int masiv (int *s, int z)
{int k=0, i;
for (i=0; i<z; i++){
printf (elementul %d=%d si se afla pe adresa %d,i,*s,s);
if (*s==0) k++;
s++;}
return (k);}
void main (void){
int p,n,i, x[25]; clrscr ();
printf (culege m!rimea masivului x\n);
scanf ( %d,&n);
printf (culege masivul x[%d]\n,n);
for(i=0; i<n; i++)
scanf (%d,&x[i]);
p=masiv (x, n);
printf (masivul con"ine %d zerouri,p);
getch(); }
n acest exemplu se calculeaz" cantitatea de zerouri din masiv. M"rimea
masivului se transmite n func!ie de la parametrul actual n la parametrul formal z. Iar
pentru transmiterea masivului x n func!ie se folose#te atribuirea valorii primului
element x[0] variabilei *s;
Folosind indicatori se pot alc"tui func!ii, sarcina c"rora ar fi culegerea valorilor
elementelor unui masiv unidimernsional. Aceste func!ii ar fi util de folosit n

67
programele unde se prelucreaz" cteva masive. Urm"torul exemplu ilustreaz" acest
fapt #i face posibil prelucrarea a 2 masive: x #i y.
# include <stdio.h>
# include <conio.h>
int masiv(int *k){
int i,z;
printf (Culege m!rimea masivului <50 \n);
scanf (%d,&z);
for (i=0;i<n; i++) { printf (culege elementul %d \n,i);
scanf (%d,k); k++;}
return (z);}
void main (void){
int n1, n2, i, x[50], y[50]; clrscr ();
printf (ntroducem masivul x \n); n1=masiv(x);
printf (ntroducem masivul y \n); n2=masiv(y);
printf (Afi$are masiv x:\n);
for (i=0; i<n; i++) printf (x[%d]=%d\n,i,x[i]);
printf (Afi$are masiv y:\n);
for (i=0;i <n; i++) printf (y[%d]= %d\n,i, y[i]);
getch();}
n exemplu precedent elementele masivul #i m"rimea lui snt ntroduse n
func!ie, iar programul principal afi#az" rezultatul execut"rii func!iei. n calitate de
parametri func!ia masiv() folose#te un indicator de tip ntreg *k, c"rui i se transmite
din program adresa primului element al masivului prelucrat. n interiorul ciclului
valoarea adresei din indicator se incrementeaz", n a#a fel primindu-se adresa
urm"torului element al masivului ce se prelucreaz". Func!ia ntoarce n program
valoarea m"rimii masivului curent ce se atribuie variabilelor n1 pentru masivul x #i
n2 pentru masivul y.
Avnd la dispozi!ie un a#a algoritm este u#or de compus programe ce
prelucreaz" mai multe masive #i chiar masive bidimensionale. ns" n cazul masivelor
bidimensionale trebuie de men!ionat, c" valorile elementelor masivului snt p"strate
n celule de memorie adresele c"rora se schimb" liniar pentru elementele masivului
pe rnduri apoi pe coloane, adic" de la stnga la dreapta #i de sus n jos. Exemplu:
# include <stdio.h>
# include <conio.h>
int masiv (int(*k)[50]) {
int i,j,z;

68
printf ("Culege marimea masivului\n");
scanf ("%d",&z);
for (i=0; i<z; i++) {
for (j=0; j<z ; j++){
printf ("Culege elementul [%d][%d]\n",i,j);
scanf ("%d",(k[i]+j)); }}
return (z); }
void main (void){ clrscr();
int n,n1,n2,i,j,x[50][50],y[50][50];
printf ("Introducem masivul x\n");
n1=masiv(x);
printf ("Introducem masivul y/n");
n2=masiv(y);
printf ("Masivul x este:\n");
for (i=0; i<n1; i++) {
for (j=0; j<n1; j++) {
printf ("%d ", x[i][j]);}
printf ("\n"); }
printf ("Masivul y este:\n");
for (i=0; i<n2; i++) {
for (j=0; j<n2; j++) {
printf ("%d ", y[i][j]);}
printf ("\n"); }
getch(); }
Aici n calitate de parametru func!ia folose#te un indicator (*k)[50] la masiv
unidimensional din 50 elemente. Deci, fiecare schimbare a adresei prin k++, va duce
la pozi!ionarea pe primul element al urm"torului rnd din masivul bidimensional. Iar
fiecare indicator (k[i]+j) n ciclu va duce la pozi!ionare pe elementul coloanei j din
rndul i al masivului bidimensional.

$2. Fi"iere n C/C++.
n timpul execut"rii programelor, n majoritatea cazurilor, exist" necesitatea
afi#"rii rezultatelor. ns" posibilit"!ile simplei afi#"ri a datelor la monitor snt destul
de mici. Chiar #i folosirea opririi temporare a execu!iei programului, cu scopul de a
da posibilitate utilizatorului s" citeasc" toat" informa!ia afi#at", nu rezolv" pn" la
sfr#it problema. Dac" mesajul afi#at dispare din limitele monitorului, afi#area lui
repetat" va fi posibil" numai dup" lansarea din nou a programului ntreg. Mai mult ca

69
att, valorile atribuite variabilelor din program snt p"strate numai pe parcursul
ndeplinirii programului. Odat" cu terminarea execu!iei programului, toat" informa!ia
ntrodus" se pierde.
Pentru a p"stra informa!ia odat" ntrodus", cu scopul folosirii ulterioare este
necesar" nscrierea ei pe disc n structuri de date speciale, ce poart" denumirea de
fi#iere. Folosirea fi#ierelor permite p"strarea informa!iei de orice natur" pentru un
timp ndelungat, transferarea datelor de pe un purt"tor informa!ional pe altul, citirea
#i afi#area datelor n caz de necesitate. Tat" informa!ia, n ceea ce prive#te lucrul cu
fi#ierele n limbajul C/C++ este p"strat" n biblioteca stdio.h. Deaceea nainte de a
ncepe prelucrarea unui fi#ier n C/C++, este necesar de inclus aceast" bibliotec" n
program cu ajutorul directivei #include<stdio.h>, care va face posibil" nscrierea
informa!iei n fi#ier #i citirea ei. n timpul intr"rii datelor n program dintr-un fi#ier de
pe disc, are loc copierea lor n memoria operativ" a calculatorului, iar informa!ia din
fi#ier ce se afl" pe discul rigid r"mne neschimbat" pe parcursul execut"rii
programului. La ie#irea datelor din program pe disc, n fi#ier snt nscrise datele
ce se p"strau pn" n acel moment n memoria operativ".
nscrierea sau citirea informa!iei din fi#ier este efectuat" cu ajutorul
indicatorului la fi#ier. n timpul nscrierii sau citirii informa!iei din fi#ier compilatorul
folose#te un nivel intermediar de leg"tur" ntre program #i discul rigid, unde este
p"strat fi#ierul. Acest nivel reprezint" o zon" de memorie numit" zona tampon care
are destina!ia de p"strare temporar" a informa!iei cu scopul de a o nscrie sau citi apoi
din fi#ier.
Pentru a trimite sau a citi informa!ia din zona tampon compilatorul folose#te o
structur" special" numit" structur"-fi#ier. n aceast" structur" este p"strat" informa!ia
necesar" calculatorului pentru a efectua nscrierea/citirea datelor din fi#ier, inclusiv
adresa zonei de memorie, unde este amplasat fi#ierul.
Sintaxa de declarare a unui indicator de fi#ier este urm"toarea:
FILE *file_pointer;
unde cuvntul cheie FILE indic" compilatorului c" variabila declarat" este un
indicator la fi#ier, iar file_pointer este numele indicatorului. n caz cnd programul
presupune lucrul cu cteva fi#iere, este necesar" declararea a mai multor indicatori la
fi#iere dup" cum urmeaz":
FILE *f1, *f2, *f3;
unde f1, f2, f3 snt numele indicatorilor la fi#iere diferite.
Prelucrarea fi#ierelor n limbajul C/C++ presupune ndeplinirea urm"torilor
pa#i:

70
$) Deschiderea fi#ierului. (Pentru a putea fi posibil" nscrierea sau citirea informa!iei
din fi#ier, el trebuie deschis.)
2) Prelucrarea fi#ierului (opera!iunile de citire/nscriere).
3) nchiderea fi#ierului. Pentru ca informa!ia nscris" n fi#ier s" fie p"strat", acesta
trebuie nchis.

$2.$. Deschiderea fi"ierelor.
Deschiderea unui fi#ier se realizeaz" cu ajutorul func!iei fopen() care are
urm"toarea sintax":
pointer=fopen(nume_f, mod);
unde pointer este numele indicatorului la fi#ier, nume_f este numele fi#ierului real de
pe discul rigid, mod este modul de acces la fi#ier.
Rezultatul ndeplinirii acestei func!ii este atribuirea adresei structurei tip fi#ier
indicatorului la fi#ier. Primul parametru este numele fi#ierului, care de obicei are
urm"toarea structur": nume.ext, unde ext este extensia fi#ierului compus" din 3
caractere. n calitate de parametru doi func!ia prime#te modalitatea de acces la fi#ier,
adic" informa!ia despre opera!iile ce pot fi efectuate cu fi#ierul.
Exist" 3 modalit"!i generale de deschidere a fi#ierului:
$) Modul w permite deschiderea fi#ierului cu scopul nscrierii n el a informa!iei
sau scoaterea informa!iei la mprimant". Dac" fi#ierul indicat nu exist", el va fi
creat. Dac" fi#ierul deja exist", toat" informa!ia existent" n el va fi nimicit".
2) Modul rindic" compilatorului, c" fi#ierul va fi deschis cu scopul citirii din el a
informa!iei. Dac" fi#ierul nu exist"la momentul deschiderii va fi generat" o eroare
de execu!ie.
3) Modul a permite deschiderea fi#ierului cu scopul complet"rii, adic" a nscrierii
informa!iei la sfr#itul lui. n caz c" fi#ierul nu exist", el va fi creat din nou. Dac"
fi#ierul indicat exist", atunci informa!ia nscris" va fi amplasat" la sfr#itul
fi#ierului f"r" a fi nimicit" informa!ia deja existent" n fi#ier.
De exemplu, pentru a crea un fi#ier nou cu nume info.txt va fi folosit"
urm"toarea sintax":
FILE *fi$ier;
fi$ier=fopen(info.txt, w);
n cazul cnd exist" necesitatea de a citi careva date din fi#ier trebuie folosit modul de
acces r:
FILE*fi$ier;
fi$ier=fopen(info.txt,r);

7$
Pentru a imprima informa!ia din fi#ier pe hrtie cu ajutorul imprimantei,
numele fi#ierului va fi PRN, iar modul de acces w:
FILE *fi$ier;
fi$ier=fopen(PRN,w);
E de men!ionat faptul, c" #i numele fi#ierului #i caracterul ce determin" modul
de acces la fi#ier snt delimitate de ghilimele duble. Aceasta este condi!ionat de
faptul, c" parametrii n func!ia fopen() se transmit n calitate de #iruri de caractere.
Folosind aceste posibilit"!i, se poate culege de la tastatur" numele fi#ierului dorit de
utilizator:
char name [12];
FILE *f;
printf (Culege numele fi$ierului\n);
gets (name);
f=fopen (name,w);
n timpul lucrului cu fi#ierela n C/C++ este folosit un indicator special, n care
se p"streaz" informa!ia despre pozi!ia curent" de citire din fi#ier. n timpul citirii a
datelor din fi#ier indicatorul determin" por!ia urm"toare de date care trebuie citit" de
pe disc.
Dac" fi#ierul e deschis pentru prima dat" cu regimul de acces r, indicatorul
se amplaseaz" pe primul simbol din fi#ier. n timpul ndeplinirii opera!iei urm"toare
de citire, indicatorul se amplaseaz" la nceputul urm"toarei por!ii de date. M"rimea
pasului de citire din fi#ier depinde de cantitatea de informa!ie citit" din fi#ier. Dac"
dintr-un pas se cite#te numai un caracter, atunci indicatorul se va amplasa pe
caracterul urm"tor, dac" se cite#te o structur", indicatorul va fi amplasat pe
urm"toarea structur". La momentul, cnd toat" informa!ia a fost citit" din fi#ier,
indicatorul nimere#te pe un cod special numit sfr#it de fi#ier: (eof). ncercarea de
citire din fi#ier dup" sfr#itul fi#ierului duce le eroare.
Dac" fi#ierul este deschis cu regimul de acces w, indicatorul deasemenea se
amplaseaz" la nceputul fi#ierului n a#a fel primele date nscrise n fi#ier vor fi
amplasate la nceputul lui. n timpul nchiderii fi#ierului, la sfr#itul lui va fi nscris
simbolul de sfr#it de fi#ier (eof). Dac" la momentul deschiderii n regimul de acces
w fi#ierul exist", toat" informa!ia deja existent" n el va fi nimicit" #i deasupra ei
va fi nscris" informa!ia nou". Orice date precedente ce pot r"mne ne#terse n fi#ier
vor fi amplasate dup" codul sfr#it de fi#ier (eof), deci accesul la ele va fi nchis. n
a#a fel toat" informa!ia din fi#ierul deschis n regim de acces w va fi nimicit", chiar
#i n cazul cnd fi#ierul va fi deschis f"r" nscrierea n el a careva date.

72
Dac" fi#ierul se deschide n regim de acces a, indicatorul se amplaseaz" pe
simbolul sfr#it de fi#ier (eof). Orice informa!ie n a#a fel nscris" n fi#ier va fi
amplasat" dup" datele deja existente, iar dup" nscriere la sfr#itul fi#ierului se adaog"
codul sfr#it de fi#ier (eof).
n unele cazuri apare situa!ia cnd sistemul opera!ional nu poate deschide
fi#ierul indicat n func!ia fopen(). Aceasta poate condi!ionat de lipsa de loc pe discul
rigid, sau de faptul c" fi#ierul indicat pur #i simplu nu exist". Este posibil"
deasemenea situa!ia cnd e necesar" imprimarea datelor la imprimant", iar aceasta nu-
i inclus" sau lipse#te hrtie. n cazul ncerc"rii folosirii fi#ierului ce nu poate fi
deschis, programul va fi stopat n rezultatul unei gre#eli de execu!ie. Pentru a evita
stoparea avariat" a programului poate fi controlat" starea de deschidere a fi#ierului cu
ajutorul instruc!iunii condi!ionate if, care va opri programul n caz de e#ec. Aici va fi
folosit" particularitatea sistemului opera!ional, care ntoarce valoarea NULL n caz
cnd apare gre#al" #i fi#ierul nu poate fi deschis. n acest caz codul NULL este ntors
n loc de adresa structurei-fi#ier #i programul se stopeaz". Condi!ia pentru evitarea
ie#irii avariate din program va avea urm"toarea sintax":
if ( (fi$ier=fopen(info.txt,w))==NULL )
puts (Fi$ierul nu poate fi deschis);
exit();
Dup" ce toat" informa!ia este nscris" n fi#ier sau citit" din el e necesar de
nchis fi#ierul, adic" de a ntrerupe leg"tura dintre fi#ier #i program. nchiderea
fi#ierului se realizeaz" cu ajutorul func!iei fclose() care are urm"toarea sintax":
fclose(f_pointer); unde f_pointer este numele indicatorului la fi#ier.
Odat" cu nchiderea fi#ierului, noi primim garan!ia c" toat" informa!ia din zona
tampon ntr-adev"r a fost nscris" n fi#ier. Dac" programul se termin" pn" la
nchiderea fi#ierului, e posibil" situa!ia cnd o parte din informa!ie ce nu a fost
nscris" pe disc r"mne n zona tampon #i n rezultat este pierdut". n afar" de aceasta
dac" fi#ierul nu se nchide corect, la sfr#itul lui nu va fi nscris n modul necesar
codul sfr#it de fi#ier (eof) #i urm"toarea deschidere a fi#ierului va fi eronat". Deci
sistemul opera!ional va pierde accesul la fi#ier.
Mai mult ca att, nchiderea fi#ierului elibereaz" indicatorul #i dup" aceasta el
poate fi folosit pentru accesul la alt fi#ier sau pentru ndeplinirea altor opera!ii cu
fi#ierul. Spre exemplu fie c" trebuie de creat un fi#ier, de nscris informa!ia n el, apoi
de o citit din fi#ier. Men!ion"m faptul, c" dup" nscrierea datelor, fi#ierul trebuie
nchis #i numai dup" aceasta de-l deschis pentru citire, astfel avnd acces respectiv la
datele din fi#ier:
#include<stdio.h>

73
void main (void) {
FILE *fi$ier;
if ((fi$ier=fopen(info.txt,w))==NULL) {
puts (Fi$ierul nu poate fi deschis\n);
exit(); }
//Aici vor fi amplasate instruc"iunile de nscriere a infirma"iei n fi$ier.
fclose (fi$ier);
if ((fi$ier=fopen(info.txt,r))==NULL) {
puts (Fi$ierul nu poate fi deschis\n);
exit(); }
//Aici vor fi amplasate instruc"iunile de citire a informa"iei din fi$ier.
fclose (fi$ier); }
Aici fi#ierul se deschide n interiorul condi!iei if, adic" n timpul deschiderii
este controlat" valoarea ntoars" de sistemul opera!ional la deschiderea fi#ierului #i
dac" este ntoars" valoarea NULL se genereaz" mesajul corespunz"tor #i programul
este stopat.
Men!ion"m faptul, c" unele compilatoare permit nscrierea datelor n fi#ier prin
cur"!irea zonei tampon cu ajutorul func!iei flush(). Aceast" func!ie permite, f"r" a
nchide fi#ierul, s" nscrie toat" informa!ia din zona tampon n fi#ier, apoi aceast"
zon" este eliberat" de careva date.

$2.2. Func!ii de nscriere/citire din fi"ier.
Limbajul C/C++ con!ine mai multe posibilit"!i de transmitere a datelor n fi#ier #i
citire din fi#ier n dependen!" de func!ia folosit":
- Func!iile fputc() #i putc() se folosesc n cazul nscrierii unui caracter n fi#ier sau
scoaterii la imprimant".
- Func!iile fgetc() #i getc() se folosesc pentru citirea unui caracter din fi#ier.
- Pentru a nscrie un #ir de caractere n fi#ier sau a-l imprima la imprimant" este
folosit" func!ia fputs().
- Pentru a citi un #ir de caractere din fi#ier se folose#te func!ia fgets().
- Func!ia fprintf() este folosit" n cazul ie#irii cu format a caracterelor, #irurilor de
caractere #i cifrelor pe disc sau la imprimant".
- Func!ia fscanf() se folose#te pentru citirea cu format a caracterelor, #irurilor de
caractere sau cifrelor din fi#ier.
- nscrierea unei structuri n fi#ier e posibil" folosind func!ia fwrite().
- Citirea unei structuri din fi#ier se efectueaz" cu ajutorul func!iei fread().


74
$2.2.$. nscriere/citire de caractere.
nscrierea/citirea caracterelor din fi#ier este forma de baz" pentru lucru cu
fi#iere. Cu toate c" nu se bucur" de o popularitate mare, aceste opera!ii bine ilustreaz"
principiile de baz" n lucrul cu fi#ierele.
Un caracter poate fi nscris n fi#ier dup", cum a fost spus, cu ajutorul func!iei
fputc() folosind urm"toarea sintax":
fputc(v,fp); unde v este o variabil" tip caracterial (char), #i fp numele
indicatorului la fi#ier.
Urm"torul exemplu face posibil" nscrierea n fi#ier a unui set de caractere pn"
cnd nu va fi ap"sat" tasta Enter:
# include <stdio.h>
# include <conio.h>
void main (void) {
FILE *f;
char lit; clrscr();
f=fopen(info txt,w);
printf (culege cteva caractere \n);
do {
lit=getch();
putch (lit);
fputc(lit,f);} while(lit!=/ r);
fclose (f); }
Aici, fi#ierul este deschis n regimul de acces w. %i dac" la momentul
deschiderii fi#ierul cu numele info.txt nu exist", el va fi creat. n ciclul do are loc
citirea consecutiv" a caracterelor de la tastatura cu ajutorul func!iei getch() #i
nscrierea lor n fi#ier cu ajutorul func!iei fputc() Este de men!ionat faptul, c" cu
acela#i succes aici ar putea fi folosit" func!ia putc() cu aceia#i parametri. Ciclul do va
continua pn" cnd va fi detectat" culegerea tastei ENTER #i dup" aceasta fi#ierul este
nchis.
Cu scopul citirii din fi#ier a caracterelor snt folosite func!iile getc() #i fgetc()
care au urm"toarea sintax":
ch_var=getc(fp); unde ch_var este variabil" tip catacterial, iar fpindicator la
fi#ier.
Exemplul urm"tor demonstreaz" cum ar putea fi citit" informa!ia din fi#ierul
creat n exemplul precedent:
# include <stdio.h>
# include <conio.h>

75
void main (void) {
FILE *f1; char lit;
clrscr();
f1=fopen(info.txt,r);
printf(informa"ia citit!:\n);
while( (lit=fgetc(f1))!=EOF)
printf (%c,lit);
fclose(f1); getch(); }
Fiind deschis fi#ierul n regimul r, este posibil" citirea informa!iei din el.
Ciclul while, n care are loc citirea consecutiv" a caracterelor din fi#ier este ndeplinit
pn" cnd nu este detectat simbolul sfr#it de fi#ier EOF, care este nscris la sfr#itul
oric"rui fi#ier n momentul nchiderii acestuia.
Func!ia de citire fgetc(f1) folose#te alt indicator la acela#i fi#ier f1. Acest fapt
este condi!ionat de faptul, c" chiar dac" la opera!iile de nscriere #i citire din fi#ier
este folosit acela#i nume de fi#ier, nscrierea sau citirea este recomandat de efectuat
cu ajutorul diferitor indicatori.

$2.2.2. nscriere/citire de "iruri.
n cazul, cnd e necesar de nscris n fi#ier seturi de caractere, adic" #iruri este
binevenit" func!ia fputs(); care are urm"toarea sintax":
fputs (s_var, fp); unde s_var este o variabil" tip #ir de caractere, iar fp
indicator la fi#ier.
Func!ia fputs() efectueaz" nscrierea #irurilor n fi#ier sau imprimarea lor pe
hrtie f"r" nserarea caracterului sfr$it de linie. Pentru ca fiecare #ir nscris n a#a mod
n fi#ier s" nceap" din rnd nou, este necesar" nserarea manual" a simbolului sfr$it
de linie.
Urm"torul exemplu face posibil" nscrierea n fi#ier a unui set de familii:
# include <stdio.h>
# include <conio.h>
# include <string.h>
void main (void) {
FILE *k; char fam[15];
clrscr();
printf (culege"i familia\n);
gets (fam);
k=fopen(familia.txt,w);
while(strlen(fam)>0){

76
fputs(fam,k); fputs(\n,k);
printf(culege"i urm!toarea familie\n);
gets (fam);}
fclose (k);}
Aici ciclul while va fi repetat pn" cnd va fi ntrodus un #ir de lungime 0.
Func!ia fputs() va nscrie n fi#ier #irurile fiecare din rnd nou datorit" inser"rii
fputs(\n,k); La sfr#itul prelucr"rii sale, fi#ierul familia.txt este neap"rat nchis
fclose(k); Este de men!ionat faptul, c" pentru a imprima pe hrtie familiile culese
folosind imprimanta, este necesar de indicat numele fi#ierului prn n felul urm"tor:
k=fopen (prn,w);. Pentru imprimarea corect" la imprimant" este necesar"
folosirea #irurilor cu lungime de 8$ caractere, cu scopul ca #irul s" ncap" n
ntregime n l"!imea monitorului, nainte de a fi culeas" tasta ENTER.
Ciritea #irurilor de caractere din fi#ier este realizat" de func!ia fgets() ce are
urm"toarea sintax":
fgets(s_var, l, fp); unde s_var este o variabil" tip #ir de caractere, l este o
variabil" sau constant" de tip ntreg, ce indic" cantitatea maxim" posibil" de caractere
n #ir, fp este un indicator la fi#ier.
Urm"torul exemplu face posibil" citirea familiilor din fi#ierul familia.txt
creat n exemplul precedent:
# include <stdio.h>
# include <conio.h>
void main (void) {
FILE *r; char name[15];
clrscr();
r=fopen(familia.txt,r);
printf(Informa"ia citit!din fi$ier:/n);
while ( fgets(name, 15, r)!=NULL )
printf (%sname);
fclose(r); getch(); }
Aici ciclul while va fi repetat pn" cnd nu va fi defectat codul sfr#it de
fi#ier. n cazul citirii informa!iei din fi#ier la nivel de #iruri de caractere, pentru a
indica sfr#itul fi#ierului se folose#te codul NULL, iar codul EOF este folosit la citire
caracterial". Func!ia fgets() va citi #irul n ntregime pn" la codul linie nou", dac"
lungimea lui nu dep"#e#te valoarea l-1 indicat" n parametrii func!iei.
Atrage!i aten!ia la faptul, c" func!ia printf(%s,name); nu folose#te codul
/n pentru deplasarea n rnd nou, fiindc" fiecare #ir citit din fi#ier deacum con!ine

77
codul \n - linie nou" nscris n fi#ier n exemplul precedent cu ajutorul func!iei
fputs(\n,k).

$2.2.3. ntrare/ie"ire cu format.
Func!iile pentru prelucrarea caracterelor #i #irurilor au destina!ia de nscriere-
citire din fi#ier numai a informa!iei textuale. n caz, cnd e necesar de nscris n fi#ier
date ce con!in valori numerice este folosit" func!ia fprintf() cu urm"toarea sintax":
fprintf (fp, format, data); unde fp este indicatorul la fi#ierul n care se
realizeaz" nscrierea, format este #irul de control a formatului datelor nscrise #i data
este lista variabilelor sau valorilor ce trebuie nscrise n fi#ier. Exemplu:
fprinf (f, %d, cost);
Urm"torul exemplu demonstreaz" modul de nscriere n fi#ier a informa!iei
despre un set de produse. n fi#ier vor fi nscrise denumirile, pre!urile #i cantit"!ile
produselor p"strate ntr-un depozit:
# include<stdio.h>
# include<conio.h>
# include<string.h>
void main (void) {
FILE *f; clrscr();
char name[20], r!spuns= y ;
float pret; int unit;
f=fopen(produs.txt,w);
while (r!spuns==y ){
printf (Culege denumirea produsului\n);
scanf (%s, name);
printf (Culege pre"ul produsului %s\n,name);
scanf (%f, &pret);
prinf (Culege cantitatea produsului %s\n, name);
scanf (%d, &unit);
fprintf (f, %s %f %d\n, name, pret, unit);
printf (Dori"i s! continuati? y/n\n);
r!spuns=getch();}
fclose(f);}
n rezultatul ndeplinirii acestui program n fi#ier va fi nscris" informa!ia
despre cteva produse spre exemplu n felul urm"tor:
discheta 4.500000 100
mouse 140.000000 3

78
monitor 2000 1
Atrage!i aten!ia la simbolul \n- sfr#it la linie la sfr#itul #irului de control a
formatului din func!ia fprintf(), anume datorit" lui, informa!ia despre fiecare produs
este nscris din rnd nou n fi#ier.
Citirea informa!iei cu format din fi#ier se realizeaz" cu func!ia fscanf(), care are
acelea#i restric!ii ca #i func!ia scanf(), #i folose#te urm"toarea sintax":
fscanf (fp, format, data); care este identic" cu sintaxa func!iei fprintf() n
ciea ce prive#te descrieria parametrilor.
n exemplu urm"tor se realizeaz" citirea informa!iei din fi#ierul produs.txt
despre produsele din depozit nscrise n fi#ier n exemplu precedent:
# include<stdio.h>
# include<conio.h>
void main (void) {
clrscr();
FILE *a; char name[20];
float pret; int unit;
a=fopen(produs.txt,r);
while( fscanf( a, %s%f%d, name, &pret, &unit)!=EOF) {
printf(Denumire: %s\n,name);
printf(pret: %f\n,pret);
printf(cantitatea:%d\n,unit); }
fclose(a); getch(); }
Aici citirea datelor din fi#ier are loc chiar odat" cu controlul condi!iei de
continuare a ciclului while. Ciclu while va fi ndeplinit pn" cnd nu va fi detectat
codul de sfr#it de fi#ier care n acest caz este EOF.
Datele din fi#ier snt citite n variabilele name, pre" #i unit #i apoi afi#ate la
monitor.

$2.2.4. Fi"iere "i structuri.
Pentru a nscrie o variabil" tip structur" (nscriere) n fi#ier este folosit" func!ia
fwrite(), care are urm"toarea sintax":
fwrite (&struct_var, struct_size, n, fp); unde:
- &struct_var este numele variabilei tip structur" cu operatorul de adres", care
comunic" compilatorului adresa celulei de start din memoria unde este
amplasat" structura.
- struct_size este m"rimea structurii. Pentru determinarea m"rimii structurii se
folose#te func!ia sizeof(s); unde s este numele variabilei de tip structur".

79
- n este un num"r ntreg, care determin" cantitatea de structuri ce vor fi nscrise
n fi#ier dintr-o ncercare. Aici este recomandat de folosit valoarea $. Valori mai
mari ca $ se folosesc n cazul nscrierii n fi#ier a unui masiv de structuri dintr-o
singur" ncercare.
- fp este numele indicatorului la fi#ier.
Exemplu: fwrite(&a,size(a),1,f);
n urm"torul exemplu este creat un masiv de structuri cu inform!ia despre un
grup de studen!i ce con!ine numele studentului, anul na#terii, #i balul mediu. nti de
toate masivul de structuri se completeaz" cu informa!ie, apoi structurile, cte una cu
ajutorul ciclului for #i func!iei fwrite() snt nscrise n fi#ier. Numele fi#ierului este
numit de utilizator #i p"strat n variabila filename de tip #ir de caractere:
#include<stdio.h>
#include<conio.h>
sctruct stud {
char nume [15];
int an; float med;};
void main (void) { clrscr();
struct stud x[10]; int i,n;
FILE *f; char filename[12];
float m;
printf(culege num!rul de studen" \n);
scanf(%d&n);
for (i=0; i<n; i++) {
printf (culege numele studentului\n);
scanf (%s, x[i] nume);
prinf (culege anul na$teri \n);
scanf (%d, x[i]. an);
printf (culege nota medie\n);
scanf(%f, &m); x[i].med=m; }
printf (culege numele fi$ierului \n);
scanf (%s,filename);
f=fopen(filename,w);
for(i=0; i<n; i++) fwrite (&x[i], sizeof (x[i]), 1, f);
fclose(f); getch(); }
n rezultatul ndeplinirii acestui program, va fi creat un fi#ier cu numele, care a
fost atribuit variabilei filename #i n el nscrise structurile cu informa!ia despre
studen!i. Dac" vom deschide fi#ierul cu ajutorul unui redactor de texte obi#nuit vom

80
observa n el un con!inut nen!eles. n realitate informa!ia (sau mai bine zis
structurile) ce se afl" n acest fi#ier este n!eleas" de compilator #i poate fi citit" cu
ajutorul func!iei fread() ce are aceia#i sintax" ca #i func!ia fwrite(), n ceea ce prive#te
descrierea parimetrilor:
fread (&struct_var, struct_size, n, fp);
n urm"torul exemplu se realizeaz" citirea tuturor nscrierilor (structurilor) din
fi#ierul creat n exemplul precedent #i afi#area lor la monitor. Este de men!ionat
momentul c" func!ia fread(), n rezultatul execut"rii sale ntoarce o valoare ce
corespunde cantit"!ii structurilor citite cu succes din fi#ier. n cazul nostru are loc
citirea structurilor cte una din fi#ier, deci func!ia n caz de succes va ntoarce
valoarea $. n caz de creare sau de detectare a sfr#itului de fi#ier func!ia va ntoarce
valoarea 0.
#include<stdio.h>
#include<conio.h>
sctruct stud {
char nume[15];
int an; float med;};
void main (void) {clrscr();
struct stud y [10];
FILE *k; char fn[12]; int i=0;
printf (culege numele fi$ierului \n);
scanf (%s, fn);
k=fopen (fn,r);
printf (Informa"ia citit! din fi$ier:\n);
while ( fread (&y[i], sizeof(y[i]), 1, k)==1) {
printf (Numele studentului: %s\n,y[i].nume);
printf (Anul na$terii: %d\n,y[i].an);
printf (Media: %f \n,y[i].med); i++;}
fclose(k); getch(); }
Urm"torul tabel con!ine descrierea tuturor posibilit"!ilor de intrare a datelor
referitor la fi#iere, inclusiv valorile ntoarse de func!ii n caz de citire eronat":

Tipul de date Func!ii de ie#ire Func!ii de intrare Valoarea ntoars" la citire
caractere putc(); fputc(); getc(); fgetc(); EOF
$iruri de caractere fputs(); fgets(); NULL
date cu format fprintf(); fscanf(); EOF
structuri fwrite(); fread(); 0

8$
Anexa$. Func!ii de intrare-ie"ire n C/C++
Func!ii de ie"ire n C
Func!iile de ie#ire n orice limbaj de programare au destina!ia de a transfera
datele din memoria calculatorului la alte dispozitive periferice de ie#ire cum ar fi
monitorul, imprimanta, un fi#ier pe disc etc. n timpul procedurii de ie#ire se face o
copie a datelor care vor fi trimise la dispozitivul de ie#ire, p"strndu-se originalul lor
n memoria calculatorului. n limbajul de programare C exist" mai multe func!ii de
ie#ire. %i folosirea unei sau altei func!ii depinde de tipul datelor ce vor fi extrase #i
metoda de prezentare a lor. Cea mai simpl" sintax" o au func!iile de extragere a
caracterelor #i #irurilor de caractere.
Not!: Toate func!iile de ie#ire din limbajul C sn sus!inute #i n limbajul C++.

Func!ia puts()
Func!ia puts() are destina!ia de a afi#a un #ir de caractere la monitor. Sintaxa
acestei func!ii este urm"toarea: puts(P); unde P este parametrul func!iei #i poate fi:
$) un literal;
2) o constant" de tip #ir;
3) o variabil" de tip #ir.
Defini"ie: Literal se nume#te un set concret de caractere care este inclus nemijlocit n
instruc!iunile limbajului C/C++ n locul numelui constantei sau a variabilei.n cazul
folosirii unui literal n calitate de parametru pentru func!ia puts() fraza ce trebuie
afi#at" pe ecran este inclus" n parantezele rotunde #i delinitat" de ghilimele. De
exemplu: puts(Hello world!); Folosirea unei constante de tip #ir n calitate de
parametru al func!iei puts() folose#te regulile dup" cum urmeaz" n exemplu:
#define MESAJ Hello world void main(void) {puts(MESAJ);}
Aici fraza Hello world a fost atribuit" constantei MESAJ, care apoi este
folosit" ca parametru al func!iei puts() far" delimitarea cu ghilimele. A treia metod"
de folosire a func!iei puts() cu variabil" de tip #ir n calitate de parametru este
ilustrat" n exemplul urm"tor:
void main (void) { char MESAJ[]=Hello world; puts(MESAJ);}.
Folosirea constantelor #i variabilelor de alt tip n calitate de parametru al
func!iei puts() va duce la eroare de compilare. Unica diferen!a la folosirea literalelor
#i constantelor sau variabilelor este faptul c" literalul trebuie delimitat de ghilimele
iar variabila #i constanta se folosesc fara ghilimele. Majoritatea compilatoarelor
efectuiaz" trecerea n alt rind dup" ndeplinirea func!iei puts(). Aceasta nseamn", c"
dup" afi#area datelor pe ecran, cursorul n mod automat se deplaseaz" la nceputul
urm"torului rind. ns" aceast" regul" este respectat" nu de toate compilatoarele. n

82
acest caz, pentru trecerea cursorului n alt rind trebuie folosit" consecutivitatea de
simboluri \n destinat" afi#"rii pe ecran a simbolului de conducere trecere n alt
rind, n acest caz func!ia puts() va avea urm"toarea sintax": puts(Hello world!\n);
Prototipul func!iei puts() este descris n biblioteca stdio.h din aceast" cauz" este
necesar" includerea acestei biblioteci n cadrul programului cu ajutorul directivei
#include<stdio.h>.

Func!ia putchar()
Are destina!ia afi#"rii unui singur simbol la ecran . Ca #i n cazul func!iei puts()
n calitate de parametru al func!iei poate fi folosit un literal, o constant" sau o
variabil" de tip caracter. De exemplu:
literal n calitate de parametru:
putchar(C);
constant" tip caracter n calitate de parametru:
#define lit C void main(void) {putchar(lit);}
variabil" tip caracter n calitate de parametru:
void main(void) {char lit; lit=C; putchar(lit);}
Men!ion"m faptul, c" cu ajutorul func!iei putchar() este posibil" afi#area numai
a unui singur caracter #i instruc!ia de tipul putchar(Da); va duce la eroare de
compilare.
Diferen!a principal" la folosirea caracterelor #i #irurilor de caractere const" n
faptul, c" #irurile de caractere snt delimitate de ghilimele, pe cnd caracterele se
delimitate de apostrofe.
Majoritatea compilatoarelor nu efectuiaz" deplasarea cursorului n rind nou
dup" executarea func!iei putchar() #i el r"mne nemijlocit dup" simbolul afi#at.
Pentru trecerea n alt rind dup" afi#are se recomand" folosirea simbolului \n. Unele
compilatoare folosesc pentru afi#area caracterelor #i func!ia putch(), care are sintaxa
de folosire identic" cu cea a func!iei putchar(). Prototipul func!iei putchar() este
descris n biblioteca standard stdio.h, ceea ce face necesar" includerea acestei
biblioteci n textul programului cu ajutorul directivei #include<stdio.h>. Iar
prototipul func!iei putchar() este descries n biblioteca standard stdio.h, ceea ce face
necesar" includerea acestei biblioteci n textul programului cu ajutorul directivei
#include<stdio.h>. Iar prototipul func!iei putc() este descries n biblioteca conio.h #i
folosirea ei va fi nso!it" de directiva #include<conio.h>.




83
Func!ia printf()
Func!iile putch() #i puts() snt folosite destul de des, n s" posibilit"!ile lor , cu
p"rere de r"u snt limitate. Aceste func!ii nu asigur" afi#area unei valori numerice la
ecran #i pot prelucra numai un singur argument (parametru). n limbajul C exist" o
func!ie mult mai universal" numit" printf(). Ea permite afi#area pe ecran a datelor de
orice tip #i poate prelucra o list" din c!iva parametri. n afar" de aceasta cu ajutorul
func!iei printf() se poate determina formatarea datelor afi#ate pe display. n cel mai
simplu caz func!ia printf() poate fi folosit" n locul func!iei puts() pentru afi#area unui
#ir de caractere:
#define MESAJ Hello world!;
void main(void) { printf(MESAJ); printf(Bine ati venit); }
Ca #i n cazul func!iei puts(), func!ia printf() poate avea n calitate de
parametru un literal, o constant", o variabil" de tip #ir de caractere.
Pentru a afi#a pe display m"rimi numerice #i a avea posibilitate de a formata datele de
diferite tipuri, lista de parametri a func!iei printf() se mparte n dou" p"r!i:
printf($irul cu format, lista datelor);
Primul parametru se nume#te #ir de conducere sau #ir cu format. Acest parametru se
delimiteaz" cu ghilimele # indic" compilatorului n ce pozi!ie din #ir trebuie s" apar"
datele. %irul cu format poate con!ine orice text mpreun" cu ni#te etichete numite
indicatori de format care determin" tipul datelor #i amplasarea lor. Orice indicator de
format ncepe cu simbolul procent (%), dup" care urmeaz" un caracter ce indic" tipul
datelor. A#a indicatori snt: %d num"r ntreg; %u num"r ntreg f"r" semn; %f
num"r real de tipul float sau double;%e num"r real n form" exponen!ial"; %g
num"r real afi#at n format %f sau %e n dependen!" de faptul care form" de scriere
este cea mai scurt"; %c caracter; %s #ir de caractere.
n a#a fel prima parte a func!iei printf se poate scrie n felul urm"tor
printf(%d,); simbolul procent (%) spune compilatorului c" dup" el va urma un
indicator de format, iar pantru a afi#a pe ecran ns"#i simbolul procent (%) este
necesar de-l scris de 2 ori n felul urm"tor: printf(%%); Litera d indic"
compilatorului faptul c" va trebui afi#at" o valoare de tip ntreg, adic" un num"r scris
n sistemul zecimal.
Partea a doua din lista parametrilor este lista datelor, care poate con!ine literale,
nume de variabile sau constante, valorile c"rora este necesar de afi#at pe ecran. Lista
datelor se desparte de #irul cu forma prin virgul". Toate elementele din lista datelor
deasemenea se despart ntre ele prin virgul". Cnd compilatorul prelucreaz" aceast"
func!ie, el nlocuie#te indicatorii de format cu valorile din lista datelor. De exemplu:
printf(%d,5); n timpul ndeplinirii acestei func!ii valoarea 5 va fi amplasat" n

84
locul indicatorului de format (%d). %irul cu format poate con!ine nu numai indicatori
de format, ci #i text obi#nuit care con!ine #i indicatori de format. De exemplu:
printf(Este ora %d,5); n rezultatul execut"rii acestui exempplu pe ecran va fi
afi#at mesajul Este ora 5. Acela#i effect poate fi primit #i la folosirea func!iei
puts(Este ora 5); ns" pentru combinarea textului cu valori, constante #i variabile
numerice e necesar" folosirea func!iei printf(). Exemplu:
void main(void) {
int ora; ora=5; printf(Este ora %d,ora); }
Acest exemplu folose#te n calitate de parametru o variabil" de tip ntreg ora, care
este amplasat" n lista datelor. Binen!eles lista datelor poate con!ine c!iva parametri.
De exemplu:
void main(void) {
int ora,min; ora=5; min=25;
printf(Este ora %d $i %d minute,ora,min);}
n rezultat vom avea afi#at la ecran mesajul: Este ora 5 $i 25 minute. n
cazul folosirii ctorva parametri n lista datelor #i respectiv n #irul cu
format,parametri din lista datelor trebuie s" corespund" ca cantitate, pozi!ie #i tip cu
indicatorii din #irul cu format. n cazul nostru primul simbol %d corespunde
variabilei ora, iar al doilea variabilei min.
n cadrul unei func!ii printf() pot fi folosi!i nu numai c!iva parametri de acela#i
tip, ci #i parametri de tipuri diferite. De exemplu:
void main(void) {
int cant; float pret; pret=5.21; cant=3;
printf(Pre"ul este de %f lei pentru %d kg.,pret,cant);
n rezultat va fi afi#at mesajul: Pre"ul este de 5.210000 lei pentru 3 kg. Aici
ntradev"r parametrii din lista datelor corespund ca cantitate, pozi!ie #i tip cu
indicatorii de format din #irul cu format.
Func!ia printf() nu trece automat cursorul n alt rind dup" afi#area datelor.
Adic" dip" afi#are cursorul r"mne n acela#i rind nemijlocit dup" ultimul caracter
afi#at. Pentru trecerea cursorului alt rind aici va fi folosit" consecutivitatea de
conducere \n, care trece cursorul pe prima pozi!ie a rndului urm"tor ca #i n cazul
func!iei puts(). De exemplu: printf(Pre"ul este de %f lei \npentru %d kg.,5.21,3);
Aici dup" afi#are mesajul va vi amplasat n 2 rnduri:
Pre"ul este de 5.210000 lei
pentru 3 kg.
La fel ca #i simbolul \n aici pot fi folosite #i simbolurile: \a , \b , \t , \v , \r
#.a.

85
Func!ia printf() poate fi folosit" pentru dirijarea cu formatul datelor. Aici,
determinarea cantit"!ii de pozi!ii pe care va fi afi#at num"rul se determin" cu
indicatorul de l"!ime a cmpului.
F"r" folosirea indicatorului de l"!ime a cmpului cifrele vor fi afi#ate n
formatul standard pentru tipul de date corespunz"tor. De exemplu cifrele reale vor fi
afi#ate cu 6 pozi!ii dup" virgul". n exemplul precedint pre!ul 5.210000 este afi#at
ntradev"r cu 6 pozi!ii dup" virgul", acest format se poate de schimbat dup" dorin!a
utilizatorului. Folosind indicatorul de l"!ime a cmpului se poate determina cantitatea
de pozi!ii pe care va fi afi#at" o valoare de orice tip de date. De exemplu:
printf(Pre"ul este de %.2f lei \npentru %d kg.,5.21,3);
Aici num"rul real va fi afi#at cu 2 pozi!ii dup" virgul": 5.21. Iar n versiunea
printf(Pre"ul este de %6.2f lei \npentru %d kg.,5.21,3); vom avea _ _5.21 unde _
este spa!iu. n general indicatorul de l"!ime a cmpului pentru numerele reale are
urm"toarea form" %k.rf, unde k este num"rul total de pozi!ii (inclusive virgula) pe
care va fi afi#at" cifra real", r este num"rul de pozi!ii dup" virgul". Dac" k va fi mai
mare dect r+2 atunci vor fi inserate spa!ii naintea num"rului n cantitate de k-r+2.
Sub cifra 2 aici se are n vedere 2 pozi!ii din num"rul real: o pozi!ie de la cifra
ntreag" pn" la virgul" #i o pozi!ie este ns"#i virgula. Dac" k va fi mai mic ca r+2,
indicatorul de l"!ime a cmpului pur #i simplu va fi ignorat. Indicatorul de l"!ime a
cmpului de forma %6.4f va prezenta cifra 5.21 n form" de 5.2100. Pentru numerele
ntregi, caractere #i #iruri de caractere indicatorul de l"!ime a cmpului are forma
%kd, %kc, %ks, unde k este num"rul total de pozi!ii pe care va fi afi#at" valoarea. n
acela#i timp dac" k va fi mai mare ca lungimea real" a valorii afi#ate, naintea acestei
valori vor fi inserate spa!ii n cantitate de k-p, unde p este num"rul de pozi!ii pe care
real este amplasat" valoarea afi#at". Iar dac" k va fi mai mic ca lungimea real" a
valorii, indicatorul de l"!ime a cmpului pur #i simplu va fi ignorat.De exemplu:
printf(Este ora %3d,5); //n rezultat Este ora _ _5;
printf(M! numesc %2s,Anatol); //n rezultat M! numesc Anatol;
printf(Litera %2c,A); //n rezultat Litera _A;
unde simbolul _ reprezint" spa!iu.

Afi"area informa!iei n C++
Toate func!iile de ie#ire analizate mai sus snt valabile att pentru limbajul C,
ct #i pentru C++. ns" limbajul C++ are o posibilitate ad"ug"toare de afi#are a datelor
de orice tip. Limbajul C++ con!ine fluxul standard de ie#ire cout, care permite
mpreun" cu operatorul inser"rii, compus din dou" simboluri (<<) mai mic, afi#area
literalelor, valorilor constantelor #i variabilelor f"r" folosirea indicatorilor de format.

86
Pentru folosirea fluxului cout este necesar de inclus n textul programului C++
fi#ierul <iostream.h> cu ajutorul directivei #include<iostresm.h>, din cauza c" el
con!ine descrierea fluxurilor de intrare #i ie#ire n C++. Structura instruc!iunei ce
folose#te fluxul cout este urm"toarea: cout<<lista_de _date; unde simbolul <<
este operatorul inser"rii #i indic" compilatorului necesitatea afi#"rii listei de date ce
urmeaz" dup" el. n calitate de informa!ia afi#at" cu ajutorul fluxului cout pot servi
literali, nume de constante #i variabile de orice tip. Mai mult ca att, folosind unul #i
acela#i flux de ie#ire se poate afi#a pe ecran c!iva argumen!i, cu condi!ia c" ei vor fi
delimita!i ntre ei prin operatorul inser"rii. De exemplu:
#include<conio.h>
#include<iostream.h>
void main(void) { clrscr();
const cant=3;
int ora, min; float suma;
suma=5.21; ora=9; min=20;
cout<<"Hello world\n";
cout<<"Este ora "<<9;
cout<<"\nEste ora "<<ora<<" si "<<min<<" minute\n";
cout<<"Pretul este de "<<suma<<" lei pentru "<<cant<<" kg";
getch();}
Deasemenea ca #i func!ia printf() fluxul cout nu trece cursorul n rind nou
automat dup" afi#area datelor. Pentru prezentarea comod" a datelor aici este necesar"
folosirea consecutivit"!ii de conducere \n dup" cum este ar"tat n exemplul
precedent.

Func!ii de intrare n C.
Procesul de intrare a datelor presupune ntroducerea informa!iei necesare
pentru lucrul normal al programului. Informa!ia ntrodus" se amplaseaz" n variabile,
aceasta nseamn" c" valorile venite de la utilizator n urma afi#"rii comentariului
corespunz"tor pentru ntroducere snt atribuite ca valori variabilelor ce se p"streaz" n
memorie. n general intrarea datelor poate fi efectuat" de la diferite surse a#a ca
tastatura, memoria, unitatea de disc rigid sau flexibil, scanner, CD-ROM #.a.
Intrarea datelor este un process ce determin" lucrul de mai departe al programului.
Corectitudinea datelor de intrare influien!eaz" direct asupra corectitudinii rezultatelor
ob!inute cu folosirea acestor date de intrare. Datele de intrare pot fi atribuite ca valori
numai variabilelor #i nici ntr-un caz constantelor, valorile c"rora nu se schimb" pe
ntreg parcursul de ndeplinire a programului. Dac" variabila n care va fi amplasat" o

87
valoare de la un dispozitiv de intrare deja are o valoare oarecare, atunci valoarea nou
venit" va nlocui valoarea veche. n continuare vor fi studiate #i analizate numai
posibilit"!ile de intrare de la tastatur", l"snd pentru temele viitoare studierea
mecanismelor intr"rii datelor din alte surse.

Func!ia getchar()
Func!ia getchar() face posibil" introducerea de la tastatur" a unui singur
simbol. Majoritatea compilatoarelor nu fac diferen!" ntre valori de tipul int #i char la
folosirea func!iei getchar(), fapt condi!ionat de standardul K&R C. Daca variabila va
fi declarat" de tip int, func!ia getchar() va primi-o n calitate de valoare de intrare #i
compilatorul nu va semnala eroare, ns" valoarea caracterului culeas" de la tastatur"
va fi conversat" ntr-un num"r ntreg egal cu codul corespunz"tor acestui caracter din
tabelul cu caractere ASCII.
Sintaxa de folosire a acestei func!ii este urm"toarea: var=getchar(); , unde var
este numale variabilei c"rei i va fi atribuit caracterul cules de la tastatur".
Aici func!ia getchar() este chemat" folosind alt" sintax" n compara!ie cu func!iile
puts(), putch(), printf(). Inscrip!ia folosit" nseamn": de a atribui variabilei cu numele
var valoarea primit" n rezultatul execut"rii func!iei getchar(). Func!ia getchar() nu
folose#te argument, din aceast" cauz" parantezele rotunde de dup" numele func!iei
r"mn goale. Dup" ce utilizatorul culege o tast" de la tastatur", getchar() afi#az"
simbolul ntrodus pe ecran. n acest caz nu e necesar" culegerea tastei Enter dup"
ndeplinirea func!iei, din cauza c" getchar() face posibil" ntroducerea numai unui
singur simbol, dup" ce programul trece la ndeplinirea de mai departe. Valoarea
ntrodus" este atribuit" variabilei ndat" dup" ce a fost cules un caracter. n timpul
folosirii func!iei getchar(), n textul programului trebuie inclus fi#ierul <stdio.h>,
care con!ine descrierea prototipului acestei func!ii.
Unele compilatoare C #i C++ folosesc func!ia getch() analogic" cu func!ia
getchar(). ns" descrierea prototipului func!iei getch() se afl" n fisierul <conio.h>,
care trebuie inclus n textul programului: #include<conio.h>. Exemplu:
#include<stdio.h>
#include<conio.h>
void main(void) {char lit, lit1; lit=getchar(); lit1=getch(); putchar(lit);
putchar(\n); putchar(lit1);}
n timpul ndeplinirii programului compilatorul nu are indica!ii implicite de a
opri ndeplinirea acestuia dup" executarea ntregului program. Acest fapt este necesar
pentru a fi posibil" vizualizarea #i analiza rezultatelor nemijlocit dup" sfr#itul

88
execut"rii programului. Func!iile getch() #i getchar() ne dau posibilitatea de a ob!ine
acest efect folosind urm"toarea sintax": getch() sau getchar(). Exemplu:
#include<stdio.h>
#include<conio.h>
void main(void) {char lit, lit1; lit=getchar(); lit1=getch();
putchar(lit); putchar(\n); putchar(lit1);
getch();}
n acest caz, ajungnd la sfr#itul programului #i ntlnind func!ia getch(), compilatorul
va opri executarea programului pn" cnd va fi culeas" tasta Enter.
Not!: Limbajul C/C++ con!ine func!ia gets() destinat" ntroducerii de la
tastatur" a #irurilor de caractere. Sintaxa #i principiul de lucru al acestei func!ii vor fi
studiate la tema %iruri de caractere.

Func!ia scanf()
Func!ia de intrare scanf() face posibil" ntroducerea n calculator a datelor de
orice tip. Func!ia scaneaz" tastatura, determin" tastele care au fost culese #i apoi
interpreteaz" informa!ia culeas" cu ajutorul indicatorilor de format, ce se afl" n
componen!a func!iei. Ca #i n cazul func!iei printf() func!ia scanf() poate avea mai
mul!i argumen!i f"cnd posibil" ntroducerea valorilor de tip ntreg, caracterial #i #ir
de caractere n acela#i timp, adic" n cadrul unei func!ii. Lista de parametri ai func!iei
scanf() este compus din dou" p"r!i ca #i la func!ia printf(). Prima parte este #irul cu
format, iar a doua lista cu date. %irul cu format con!ine indicatori de format numi!i
convertori de simboluri, care determin" modul n care trebuie s" fie interpretate datele
de intrare. Lista datelor con!ine lista variabilelor n care vor fi p"strate valorile
ntroduse. Sintaxa func!iei scanf() este urm"toarea:
scanf($irul cu format, lista datelor);
De exemplu:
#include<stdio.h>
void main(void) { int a; float b;
printf(Culege valorile a ntreg $i b real\n);
scanf(%d%f,&a,&b);
printf(a=%d b=%f\n,a,b); getchar(); }
S" analiz"m func!ia scanf(%d%f,&a,&b);
Folosind func!ia scanf() n timpul cnd se ntroduc datele, este necesar n lista
de date de indicat adresa variabilei c"reia i va fi atribuit" valoarea curent". Adresa de
memorie rezervat" variabilei n timpul declar"rii sale se poate afla folosind operatorul
de adres" &. n timpul cnd func!ia scanf() ntlne#te formatul variabile a, ea l

89
determin" ca format al unui num"r ntreg #i scaneaz" tastatur" a#teptnd culegerea
unui num"r ntreg pe care apoi l nscrie pe adresa de memorie rezervat" variabilei a
ocupnd doi octe!i. Odat" fiind nscris n celula de memorie rezervat variabilei a,
num"rul corespunz"tor devine valoare a acestei variabile. La fel se ntimpl" #i n
cazul cu variabila de tip real b. Dup" prelucrarea tuturor variabilelor din lista
parametrilor, func!ia scanf() #i termin" lucrul n cazul dac" a fost culeas" tasta Enter.

Procedura de intrare n C++
Compilatoarele limbajului C++ sus!in func!iile de intrare gets(), getchar() #i
scanf() despre care s-a vorbit mai sus. n afar" de aceste func!ii C++ mai con!ine o
posibilitate de intrare a datelor. Fluxul standard de intrare cin n ansamblu cu dou"
simboluri (>>) mai mare ce se numesc operatori de extragere, face posibil" intrarea
datelor de orice tip de la tastatur" #i are urm"toarea sintax": cin>>var; unde var este
numele variabilei c"rei i va fi atribuit" valoarea citit" de la tastatur". De exemplu:
#include<stdio.h>
#include<iostream.h>
void main(void) { int a; float b;
printf(Culege valorile a ntreg $i b real\n);
cin>>a>>b;
cout<<a=<<a<< b=<<b; getchar(); }
n acest exemplu cu ajutorul fluxului standard de intrare cin au fost scanate de
la tastatur" #i atribuite valori variabilelor a #i b. n acest caz nu e necesar de indicat
adresa de memorie unde va fi amplasat" valoarea scanat" ca n cazul func!iei scanf(),
ci se indic" numai numele variabilei. n afar" de aceasta fluxul standard de intrare are
posibilitatea de a determina automat tipul valorii introduse #i nu e necesar" folosirea
indicatorilor de format. Iar n caz de lucru cu mai multe variabile, ele trebuie
desp"r!ite cu ajutorul operatorului de extragere.

Anexa 2. Func!ii matematice.
Dup" cum a mai fost spus stilul de programare n C se caracterizeaz" prin
tendin!a de a eviden!ia un num"r mare de func!ii nu prea voluminoase, astfel, ca
prelucrarea datelor n aceste func!ii s" nu depind" de celelalte p"r!i ale programului.
Acest lucru face programul destul de n!eles #i d" posibilitatea de a introduce u#or
corec!ii n unele func!ii f"r" a tangenta celelalte. n marea majoritate acest fapt este
cert n cazul func!iilor create de utilizator pentru a mp"r!i problema n cteva sarcini
mai mici dar mai simple. ns" limbajul C con!ine #i o mul!ime de func!ii standarde
care u#ureaz" cu mult programarea. Aceste func!ii ofer" o varietate de facilit"!i. n

90
plus, fiecare programator #i poate construi propria sa bibliotec" de func!ii care s"
nlocuiasc" sau s" extind" colec!ia de func!ii standard ale limbajului.
Ca atare limbajul de programare C con!ine n arsenalul s"u de instruc!iuni
foarte pu!ine instrumente pentru a putea fi numit limbaj ce se afl" pe primele locuri n
top-ul limbajelor de programare de nivel nalt. Renumita capacitate de a prelucra
expresii matematice complicate n limbajul C este datorat" bibliotecilor de func!ii
standarde, care u#ureaz" cu mult rezolvarea unor situa!ii destul de complicate. Unele
din a#a func!ii matematice ale limbajului C ntlnite mai des n practica de programare
vor fi studiate n prezentul paragraf. Men!ion"m faptul, c" aceste func!ii snt valabile
#i n limbajul C++ #i folosirea lor ntr-un program n C sau C++ necesit" includerea
fi#ierului mat.h cu ajutorul directivei #include<math.h>.
$. Func!ia abs(x).
Prototip: int abs(int x); double fabs(double x); long int labs(long int x);
Efect: ntoarce valoarea absolut" a num"rului x.
Exemplu:
#include<math.h>
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
int x,y;
cout<<"Culegeti valoarea x\n";
cin>>x; y=abs(x);
cout<<"modulul lui "<<x<<" este = "<<y;
getch(); }
2. Func!ia cos(x).
Prototip: double cos(double x); long double cosl(long double x);
Efect: ntoarce valoarea cosinus a num"rului x [cos(x)];
Exemplu:
#include<math.h>
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double x,y;
cout<<"Culegeti valoarea x\n";
cin>>x; y=cos(x);
cout<<"cosinusul lui "<<x<<" este = "<<y;
getch(); }

9$
3. Func!ia sin(x).
Prototip: double sin(double x); long double sinl(long double x);
Efect: ntoarce valoarea sinus a num"rului x [sin(x)];
Exemplu: vezi func!ia cos(x).
4. Func!ia tan(x).
Prototip: double tan(double x); long double tanl(long double x);
Efect: ntoarce valoarea tangentei a num"rului x [tg(x)];
Exemplu: vezi func!ia cos(x).
5. Func!ia acos(x).
Prototip: double acos(double x); long double acosl(long double x);
Efect: ntoarce valoarea arccosinus a num"rului x [arccos(x)];
Exemplu:
#include<math.h>
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double x,y;
cout<<"Culegeti valoarea x\n";
cin>>x; y=acos(x);
cout<<"arccosinusul lui "<<x<<" este = "<<y;
getch(); }
6. Func!ia asin(x).
Prototip: double asin(double x); long double asinl(long double x);
Efect: ntoarce valoarea arcsinus a num"rului x [arcsin(x)];
Exemplu: vezi func!ia acos(x).
7. Func!ia atan(x).
Prototip: double atan(double x); long double atanl(long double x);
Efect: ntoarce valoarea arctangentei a num"rului x [arctg(x)];
Exemplu: vezi func!ia acos(x).
8. Func!ia log(x).
Prototip: double log(double x); long double logl(long double x);
Efect: ntoarce logaritmul natural al num"rului x;
Exemplu:
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double x,y;

92
cout<<"Culegeti valoarea x\n";
cin>>x; y=log(x);
cout<<"logaritmul natural a lui "<<x<<" este = "<<y;
getch(); }
9. Func!ia log$0(x).
Prototip: double log$0(double x); long double log$0l(long double x);
Efect: ntoarce logaritmul zecimal al num"rului x;
Exemplu: Vezi func!ia log(x);
$0. Func!ia exp(x).
Prototip: double exp(double x); long double expl(long double x);
Efect: ntoarce valoarea e
x
, unde e=2.7 este constant".
Exemplu:
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double x,y;
cout<<"Culegeti valoarea x\n";
cin>>x; y=exp(x);
cout<<"exponenta lui "<<x<<" este = "<<y;
getch(); }
$$. Func!ia ldexp(a,b);
Prototip: double ldexp(double a, int b); long double ldexpl(long double a, int b);
Efect: ntoarce valoarea 2
b
*a;
Exemplu:
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double a,y;
cout<<"Culegeti valoarea a\n";
cin>>a; y=ldexp(a,3);
cout<<"2 la puterea 3 nmul"it cu "<<a<<" este = "<<y;
getch(); }
$2. Func!ia frexp(x,y).
Prototip: double frexp(double x, int *y);
long double frexpl(long double x, int *y);
Efect: ntoarce valoarea x*2
y
calculnd deasemenea #i valoarea lui y.

93
Exemplu: n calitate de necunoscut" aici este folosit" numai variabila x. Avnd un
x=8, opera!ia k=frexp(x,y) calculeaz" cifra real" (k), care trebuie nmul!it" la
2
y
pentru a primi rezultatul egal cu x=8, determinndu-l n acela#i timp #i pe y
(valoarea puterii la care va trebui ridicat" cifra 2). n cazul nostru x=8 #i
k=frexp(x,y); va avea urm"toarele rezultate: y=4; k=0.5; adic" 0.5=
4
2
8

#include<conio.h>
#include <math.h>
#include <stdio.h>
int main(void){clrscr();
double k,x; int y;
x = 8.0;
k = frexp(x,&y);
printf("numarul %f va fi primit in rezultatul\n" ,x);
printf("inmultirii lui 2 la puterea %d si %f ",y,k);
getch(); }
$3. Func!ia pow(x,y).
Prototip: double pow(double x, double y); long double powl(long double x, long
double y);
Efect: ntoarce valoarea x
y
;
Exemplu:
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double x,y,k;
cout<<"Culegeti valoarea x\n";
cin>>x;
cout<<"Culegeti valoarea y\n";
cin>>y;
k=pow(x,y);
cout<<x<<" la puterea "<<y<<" este = "<<k;
getch(); }
$4. Func!ia pow$0(x).
Prototip: double pow$0(int x); long double pow$0l(int x);
Efect: ntoarce valoarea $0
x
;
Exemplu:
#include<iostream.h>
#include<conio.h>

94
void main(void) {clrscr();
double y; int x
cout<<"Culegeti valoarea x\n";
cin>>x; y=pow10(x);
cout<<"10 la puterea <<x<<" este = "<<y;
getch(); }
$5. Func!ia sqrt(x).
Prototip: double sqrt(double x);
Efect: ntoarce valoarea x ;
Exemplu:
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double y,x;
cout<<"Culegeti valoarea x\n";
cin>>x; y=sqrt(x);
cout<<"r!d!cina patrat! din <<x<<" este = "<<y;
getch(); }
$6. Func!ia ceil(x).
Prototip: double ceil(double x); long double ceill(long double x);
Efect: ntoarce valoarea ROUND UP a num"rului x. Adic" l rotunge#te pe x n
partea de sus.
Exemplu:
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double y,x;
cout<<"Culegeti valoarea x\n";
cin>>x; y=ceil(x);
cout<<"valoarea rotungit! a lui <<x<<" este = "<<y;
getch(); }
$7. Func!ia floor(x).
Prototip: double floor(double x); long double floorl(long double x);
Efect: ntoarce valoarea ROUND DOWN a num"rului x. Adic" l rotunge#te pe x
n partea de jos.
Exemplu: vezi func!ia ceil(x).


95
$8. Func!ia fmod(x,y).
Prototip: double fmod(double x, double y); long double fmodl(long doublex, long
double y);
Efect: ntoarce valoarea restului de la mp"r!irea lui x la y.
Exemplu:
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double y,x,k;
cout<<"Culegeti valoarea x\n";
cin>>x;
cout<<"Culegeti valoarea y\n";
cin>>y;
k=fmod(x,y);
cout<<"restul de la mp!r"irea <<x<<" la "<<y<< etse = <<k;
getch(); }
$9. Func!ia modf(x,y).
Prototip: double modf(double x, double *y); long double modfl(long double x,
long double *y);
Efect: ntoarce partea frac!ionar" a num"rului real x, p"strndu-se n y #i valoarea
p"r!ii ntregi a num"rului real x.
Exemplu:
#include<iostream.h>
#include<conio.h>
void main(void) {clrscr();
double y,x,k;
cout<<"Culegeti valoarea x\n";
cin>>x;
k=modf(x,&y);
cout<<"Cifra <<x<<" are partea ntreag! = "<<y<<
$i partea frac"ionar! = <<k; getch(); }
20. Func!ia div(x,y).
Prototip: div_t div(int x, int y); ldiv_t ldiv(long int x, long int y);
unde tipul div_t este declarat n felul urm"tor:
typedef struct { long int quot; /* partea ntreag"
long int rem; /* restul
}div_t;

96
Not": Este necesar" includerea bibliotecii <stdlib.h>;
Efect: ntoarce o valoare compus" de tip structur" div_t, care con!ine 2 valori:
partea ntreag" #i restul de la mp"r!irea lui x la y.
Exemplu:
#include<stdlib.h>
#include<conio.h>
#include<stdio.h>
div_t a;
void main (void) { clrscr();
a=div(16,3);
printf("16 div 3 =%d, restul=%d\n",a.quot,a.rem);
getch();}
2$. Func!ia randomize(). Ini!ializator de generator al numerelor aleatoare.
Prototip: void randomize(void);
Efect: ini!ializeaz" generatorul de numere aleatoare.
Not": Este necesar" includerea bibliotecii <stdlib.h>;
Exemplu: Se folose#te mpreun" cu func!ia random(x). Vezi func!ia random(x);
22. Func!ia random(x). Generator de numere aleatoare.
Prototip: int random(int x);
Efect: ntoarce o valoare ntreag" aleatoare n intervalul de la 0 la (x-$);
Not": Este necesar" includerea bibliotecii <stdlib.h>;
Exemplu:
#include <stdlib.h>
#include <stdio.h>
#include<conio.h>
void main(void)
{int i; clrscr();
randomize();
for(i=50;i<60;i++)
printf("cifra aleatoare: %d\n",random(i));
getch();}
23. Func!ia rand(). Generator de numere aleatoare.
Prototip: int rand(void)
Efect: ntoarce o valoare ntreag" aleatoare n intervalul de la 0 la RAND_MAX,
unde RAND_MAX depinde de realizarea limbajului.
Not": Este necesar" includerea bibliotecii <stdlib.h>. Nu necesit" ini!ializare.
Exemplu:

97
#include <stdlib.h>
#include <stdio.h>
#include<conio.h>
void main(void)
{int i; clrscr();
for(i=0;i<15;i++)
printf("cifra aleatoare: %d\n",rand());
getch(); }

Anexa 3. Func!ii folosite la prelucrarea "irurilor de caractere.
Majoritatea compilatoarelor C/C++ au incorporate func!ii speciale pentru
lucrul cu #irurile. Evident, c" pentru a#a scopuri se poate crea func!ii proprii, dar este
mai efectiv de folosit func!iile din bibliotecile standarde. Prototipurile acestor func!ii
snt descrise n biblioteca string.h #i deci pentru folosirea lor, n program trebuie
inclus" aceast" bibliotec" folosind sintaxa: #include<string.h>. Unele din aceste
func!ii snt:
$. Func!ia strcat();
Prototip: char *strcat (char *dest, const char *sursa);
Efect: Adaog" #irul surs" la sfr#itul #irului destina!ie
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void) {
char dest [50]; char sursa [5];
dess=Turbo ; sursa =C++;
strcat (dest,sursa); puts(dest); getch(); }
Aici rezultatul va fi: dest=Turbo C++.
2. Func!ia strcmp();
Prototip: int strcmp (const char * S$, const char* S2);
Efect: Compar" dou" #iruri.
Limbajul C nu permite compararea a dou" #iruri n forma: if (S1==S2) ;
Aici compararea este f"cut" cu ajutorul func!iei strcmp() care ntoarce valoare
nul", n caz c" #irurile snt identice, sau o valoare diferit" de zero, n caz c"
#irurile nu coincid. Dup" executarea func!iei strcmp(), va fi ntoars" o valoare
ntreag" care va fi: mai mic" ca 0 dac" S$<S2;
mai mare ca 0 dac" S$>S2;

98
egal" cu 0 daca S$==S2;
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void) {
char S1 [30]; char S2 [30]; int k;
gets (S1); gets (S2); k=strcmp(S1,S2);
If (k==0) puts (sirurile coincid); else puts (sirurile nu coincid);
getch();}
3. Func!ia strcmpi();
Prototip: int strcmpi (const char *S$, const char *S2);
Efect: compar" 2 #iruri f"r" a lua n considera!ie registrele simbolurilor.
Exemplu: E identic" cu func!ia strcmp().
4. Func!ia strncmp();
Prototip: int strncmp( const char *S$, const char *S2, size_t k);
Efect: func!ia strncmp() compar" un num"r dat de cartere n 2 variabile de tip
#ir de caractere.
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char a [40]=Turbo, b[40]=Pascal ; int k;
k=strncmp(a,b,1); printf(%d,k); }
aici va fi comparat primul caracter din #irul a cu primul caracter din #irul b.
Dup" executarea func!iei strncmp(), va fi ntoars" o valoare ntreag" care va fi:
mai mic" ca 0 dac" a<b;
mai mare ca 0 dac" a>b;
egal" cu 0 daca a=b;
Aici va fi primit raspuns k>0;
5. Func!ia strncmpi();
Prototip: int strncmpi( const char *S$, const char *S2, size_t k);
Efect: Compar" un num"r dat de caractere, ncepnd cu primul, din 2 #iruri de
caractere f"r" a face diferen!" ntre caractere minuscule #i cele majuscule.
Exemplu: Echivalent cu func!ia strncmp().


99
6. Func!ia strlen();
Prototip: size_t strlen(const char *S);
Efect: Determin" lungimea #irului de caractere S.
n majoritatea cazurilor lungimea #irului nu coincide cu lungimea masivului n
care se afl" #irul. Adic" lungimea masivului este mai mare. Func!ia strlen()
determin" lungimea real" a #irului #i ntoarce o valoare de tip ntreg egal" cu
cantitatea de caractere ce se afl" n #ir.
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void) {
char name[20]; int k;
puts (culege numele); gets (name);
k=strlen(name); printf (Numele dvs are % d caractere,K); getch(); }
7. Func!ia strcpy();
Prototip: char *strcpy(char *S$, const char *S2);
Efect: Copie #irul S2 n #irul S$. Dup" ndeplinirea func!iei strcpy (S1,S2);
#irul S$ #i va pierde valoarea ini!ial" #i va avea valoarea nou" din S2. Iar S2
va r"mne neschimbat.
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void) {
char name [30]; char fam [30];
puts (Culege numele); gets (nume);
puts (culege familia); gets (fam);
strcpy (nume, fam);
puts(nume); puts(fam); getch(); }
n rezultatul ndeplinirii acestui exemplu numele va fi identic cu familia.
8. Func!ia strcspn();
Prototip: size_t strcspn (const char *S$, const char *S2);
Efect: Determin" pozi!ia caracterului din #irul S$, care primul a fost ntlnit n
#irul S2. ntoarce o valoare de tip ntreg egal" cu num"rul de ordine a acestui
caracter.


$00
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char name[20],fam[20]; int k;
puts ("culege numele"); gets (name);
puts ("culege familia"); gets (fam);
k=strcspn(name,fam);
printf ("Simbolul %c din %s primul a fost gasit in %s",
name[k],name,fam);
getch(); }
Dac" n cazul nostru name=Stepan #i fam=Ivanov, atunci rezultatul
func!iei k=strcspn(name,fam); va fi k=4, din cauz" c" pe locul patru n numele
Stepan se afl" caracterul a care primul a fost depistat n Ivanov .
9. Func!ia strspn();
Prototip: size_t strspn(const char *S$, const char *S2);
Efect: Determin" pozi!ia caracterului din #irul S$ ncepnd cu care S$ difer" de
S2. ntoarce o valoare tip ntreg egal" cu pozi!ia acestui caracter.
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char name[20],fam[20]; int k;
puts ("culege numele"); gets (name);
puts ("culege familia"); gets (fam);
k=strspn(name,fam);
printf ("ncepnd cu simbolul %c $irul %s difer! de %s",
name[k],name,fam);
getch(); }
n caz c" name=Stepan, iar fam=Stoianov lui k va fi atribuit" valoarea 2
din cauz" c" anume ncepnd cu caracterul cu num"rul de ordine 2 variabila
nume difer" de variabila fam.
$0. Func!ia strdup();
Prototip: char *strdup (const char *S);

$0$
Efect: Dubleaz" #irul de caractere S. n caz de succes func!ia strdup() ntoarce
ca valoare indicatorul adresei de memorie, ce con!ine #irul dublat. %i ntoarce
valoare nul" n caz de eroare. Func!ia strdup(S) face o copie a #irului S,
ob!innd spa!iu prin apelul func!iei malloc(). Dup" folosirea #irului dublat
programatorul trebuie s" elibereze memoria alocat" pentru el.
Exemplu :
#include < alloc.h>
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char a []=UTM; char *b;
b=strdup(a); puts (b); free (b);}
Aici a este un #ir de caractere, iar b un indicator la adresa de mmorie unde se
va nscrie #irul dublat. La executarea func!iei strdup() valoarea #irului din a
este copiat ntr-o loca!ie de memorie, adresa c"reia se afl" n b. Func!ia puts()
afi#az" con!inutul #irului dublat la monitor. Func!ia free() eliberez" memoria
ocupat" pn" acum de #irul dublat.
$$. Func!ia strlwr();
Prototip: char *strlwr (char *S);
Efect: Trece toate caracterele din #irul S n echivalentul lor minuscul. n
calitate de parametru func!ia folose#te o variabil" de tip #ir de caractere. n
rezultatul execut"rii acestei func!ii, dac" n #ir se vor con!ine caractere
majuscule, ele vor fi transformate n echivalentul lor minuscul, iar dac" n #ir
caractere majuscule nu se vor con!ine - #irul va r"mne neschimbat.
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char a[10]= Pascal;
strlwr(a);
puts (a); getch(); }
$2. Func!ia strupr();
Prototip: char *strupr(char *S);
Efect: transform" toate caracterele din #ir n echivalentul lui majuscul.
Exemplu: Echivalent cu func!ia strlwr();

$02
$3. Func!ia strncat()
Prototip: char *strncat (char *dest, const char *sursa, size_t k);
Efect: func!ia strncat() adaog" un num"r egal cu k caratere de la nceputul
#irului sursa la sf"r#itul #irului dest.
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char a[20]=Turbo; b[10]=Pascal;
strncat (a, b, 3); puts (a); }
n rezultatul execut"rii acestui exemplu primele 3 caractere din #irul b[10],
(adica sub#irul Pas) vor fi adaogate la sfr#itul #irului a[20]. Rezultatul
execut"rii func!iei strncat() va fi de tip #ir de caractere #i se va con!ine n
vaiabila a. Dup" executarea exemplului variabila a va con!ine valoarea
TurboPas.
$4. Func!ia strncpy();
Prototip: char *strncpy (char *dest, const char *sursa, size_t n);
Efect: Copie un numar dat de caractere dintr-un #ir n altul;
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char a[40]=turbo; b [40]=basic ;
strncpy (a,b,2); puts (a); }
Func!ia strncpy() nscrie un num"r N dat de caractere din #irul surs" la
nceputul #irului destina!ie. Dac" #irul destina!ie va avea lungime mai mare ca
N, atunci rezultatul va avea nceputul egal cu caracterele copiate, iar sfr#itul
ini!ial. Valoarea rezultatului se va con!ine n #irul destina!ie. n exemplu de mai
sus variabila a va avea valoare egal" cu barbo.
$5. Func!ia strnset();
Prototip: char *strnset (char* s, int ch, size_t n) ;
Efect: Func!ia strnset() copie caracterul ch pe primele n locuri din #irul *S. n
caz c" n>strlen (s), atunci n va deveni egal cu strlen(s)



$03
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char a[15] = student , b=W ;
strnset (a,b,3); puts (a) ;}
n urma execut"rii func!iei strnset() va fi ntoars" o valoare de tip #ir care va fi
nscris" n #irul destina!ie . Din exemplu de mai sus a =WWWdent.
$6. Func!ia strrev();
Prototip char *strrev( char *s);
Efect: Func!ia strrev() inverseaz" #irul de caractere S. Dup" execu!ia func!iei
strrev() primul caracter din #ir va fi schimbat cu locul cu ultimul caracter,
caracterul 2 cu penultimul, etc. f"r" a lua n considera!ie caracterul nul.
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char s1[10]=student;
printf(#irul ini"ial - %s\n,s1);
strrev(s1);
printf(#irul final - %s\n,s1);}
Dup" executarea programului va fi primit mesajul: %irul final tneduts.
$7. Func!ia strstr ();
Prototip: char *strstr(const char *s$, const char *s2);
Efect: Func!ia strstr() determin" dac" #irul S2 se con!ine n #irul S$. Func!ia
ntoarce un indicator la caracterul din S$ ncepnd cu care a fost depistat #irul
S2.
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char S1[20], S2[20], rez;
S1 = international; S2 = nation;
rez = strstr (S1,S2); printf (subsirul este : %s,rez); }

$04
Rezultatul: sub#irul este: national ;. Dac" #irul S2 n-a fost depistat n S$,
func!ia strstr() ntoarce valoarea null.
$8. Func!ia strchr();
Prototip: char *strchr(const char *S, int c);
Efect: Scaneaz" #irul S n c"utarea caracterului c. n caz de succes func!ia
ntoarce un indicator la caracterul din S care primul a fost g"sit identic cu
caracterul c. n caz de eroare (dac" a#a caracter nu exist" n #irul S) func!ia
ntoarce valoare nul".
Exemplu:
#include <string.h>
#include <conio.h>
#include <stdio.h>
void main(void)
{ clrscr();
char S[15];
char *ptr, c = 'r';
strcpy(S, "TurboC++");
ptr = strchr(S, c);
if (ptr) {printf("Caracterul %c are pozitia %d in sirul %s\n", c, ptr-S, S);
puts(ptr);}
elseprintf("Caracterul n-a fost gasit\n");
getch(); }
n rezultatul ndeplinirii acestui exemplu la monitor va fi afi#at mesajul:
Caracterul r are pozi"ia 2 n $irul TurboC++ #i apoi datorit" func!iei
puts(ptr); va fi afi#at #irul S trunchiat de la caracterul r la care indic" ptr:
rboC++.
$9. Func!ia strerror();
Prototip: char *strerror(int errnum);
Efect: Determin" eroarea dup" num"rul erorii #i returneaz" un indicator la #irul
de caractere ce con!ine descrierea erorii.
Exemplu:
#include <stdio.h>
#include <conio.h>
#include <errno.h>
void main(void)
{ clrscr();
char *numerr;

$05
numerr = strerror(11);
printf("Eroarea este: %s\n", numerr);
getch(); }
n rezultaul execut"rii acestui exemplu func!ia strerror(11); va determina
eroarea dup" num"rul ei, iar func!ia printf va afi#a: Eroarea este: Invalid
format.
20. Func!ia strpbrk();
Prototip: char *strpbrk(const char *s$, const char *s2);
Efect: Func!ia caut" n #irul S$ primul caracter ce exist" #i n #irul S2;
n caz de succes func!ia ntoarce un indicator la primul caracter din S$ ap"rut
n S2.
Exemplu:
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main(void)
{ clrscr();
char *S1="Universitate";
char *S2="Moldova";
char *ptr;
ptr=strpbrk(S1,S2);
if (ptr) printf("Primul caracter din S1 gasit n S2 este: %c\n", *ptr);
else printf("Caracter nu a fost gasit\n");
getch(); }
n rezultat va fi g"sit caracterul v .
2$. Func!ia strrchr();
Prototip: char *strrchr(const char *s, int c);
Efect: Func!ia caut" ultima apari!ie a caracterului c n #irul S. n caz de succes
func!ia ntoarce un indicator la ultimul caracterdin S identic cu caracterul c.
Exemplu:
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main(void)
{ clrscr();
char S[15];
char *ptr, c = 'r';

$06
strcpy(S,"Programare");
ptr = strrchr(S, c);
if (ptr) {printf("Caracterul %c este pe pozitia: %d\n", c, ptr-S);
puts(ptr);}
else printf("The character was not found\n");
getch();}
n rezultatul ndeplinirii acestui exemplu la monitor va fi afi#at mesajul:
Caracterul r este pe pozi"ia 8 #i apoi datorit" func!iei puts(ptr); va fi afi#at
#irul S trunchiat de la ultimul caracter r la care indic" ptr: re.
22. Func!ia strset();
Prototip: char *strset(char *s, int ch);
Efect: Schimb" toate caracterele din #irul S n valoarea caracterului c.
Rezultatul final se va p"stra n acela#i #ir S.
Exemplu:
#include<string.h>
#include<stdio.h>
#include<conio.h>
void main(void){
char s[10]=student;
printf(#irul ini"ial - %s\n,s);
strset(s,a);
printf(#irul final - %s\n,s);
getch();}
n rezultat va fi primit: #irul ini"ial student, #irul final aaaaaaa.