Curs Programare C

CPP
Cuprins
Cap. 1 Reprezentarea informaiilor
1.1 Reprezentarea numerelor ntregi n sistemul binar
1.2 Deplasarea numeral binare cu semn
1.3 Reprezentarea numerelor reale
1.4 Reprezentarea caracterelor
Cap. 2 Constante, variabile i e!presii
2.1 "ipuri fun#amentale
2.2 $ariabile
2.3 %o#ificatori #e tip
2.4 &peratorul t'pe#ef
2.( Constante
2.) Constante cu nume
2.* +!presii aritmetice
2., "ablouri
2.- .nstruciunea #e atribuire
2.1/ Prototipuri #e funcii
2.11 &peraii #e intrare 0 ieire
2.12 1uncia main
2.13 +!ecuia unui program
2.14 &peratorii 22 i 3 3
2.1( &peraii cu numere ntregi la nivel #e bit
2.1(.1 &peratori #e #epasare
2.1(.2 &peraii logice la nivel #e bit
Cap. 3 4tructuri #e control fun#amentale
3.1 5lgoritme
3.2 +!presii relaionale
3.3 +!presii booleene
3.4 &peratorul #o367ile
3.( &peratorul 67ile
3.) &peratorul for
3.* &peratorul if
3., &peratorul 8
3.- &peratorul s6itc7
3.1/ &peratorul ,
Cap. 4 1uncii
4.1 Definirea funciilor
4.2 Pasarea parametrilor funciilor
4.3 Recursivitatea
4.4 4abloane #e funcii
Cap. ( Pointeri i referine
(.1 Pointeri
(.2 Referine
(.3 Parametri funciilor
(.4 Pointeri la funcii
(.( Declalararea variabilelor tip pointer la funcie
(.) Pointeri i tablouri uni#imensionale
(.* 4iruri tip C
(., Pointeri i tablouri multi#imensionale
(.- Parametrii funciei main
Cap. ) 1iiere tip C
).1 1iiere te!t
).1.1 1uncii intrare 0 ieire cu format
).1.2 1uncii intrare 0 ieire tip c7aracter
).2 1iiere binare
Cap. * 4tructuri tip C
Cap. , Clase
,.1 Definirea unei clase
,.1.1 Definirea unei clase
,.1.2 Pointerul t7is
,.1.3 4paii #e nume
,.2 Constructori i #estructori
,.3 1uncii prietene
,.4 1iiere stan#ar# n C22
Cap. - 4upranc9rcarea operatorilor
-.1 4upranc9rcarea operatorului #e atribuire
-.2 4upranc9rcarea operatorilor aritmetici
-.3 4upranc9rcarea operatorilor :: i ;;
Cap. 1/ %otenirea
1/.1 Pointeri la obiecte
1/.2 %otenirea
1/.3 1uncii virtuale. Polimorfism
1/.4 Date i funcii statice
Cap. 11 1iiere tip CPP
11.1 1iiere te!t
11.1.1 1uncii intrare 0 ieire cu format
11.1.2 1uncii intrare 0 ieire tip caracter
11.2 1iiere binare
Cap. 12 4iruri tip C22
Cap. 13 "ratarea e!cepiilor
13.1 +!cepii
13.2 +!cepii lansate #e funcii
13.3 +!cepii stan#ar#
Cap. 14 5plicaii
14.1 1uncii #e timp
14.2 1ire #e e!ecuie
Cap. 1( <iblioteca #e abloane stan#ar#
1(.1 1uncii generice
1(.2 $ectori
1(.3 =iste
Cap 1. Reprezentarea informaiilor
1.1 Reprezentarea numerelor ntregi n sistemul binar
Un numr natural se reprezint ca o colecie de cifre. In sistemul poziional, poziia unei
cifre determin ponderea cifrei n mrimea numrului. Fie numrul
r n n
d d d N ) ... (
0 2 1
rimea numrului natural corespunztor este!
+ + +
1
0
0
0
2
2
1
1
...
n
i
i
i
n
n
n
n
r d r d r d r d N
unde! r"1 este #aza, n este numrul de cifre, iar i
d
este cifra de pe poziia i. $%em
totdeauna
r d
i
< 0
. In sistemul zecimal cifrele utilizate sunt 0, 1, 2, &, '. In sistemul
#inar cifrele utilizate sunt 0 (i 1, n sistemul octal 0, 1, 2, &, ), iar n sistemul
*e+azecimal cifrele utilizate sunt! 0, 1, 2, &, ',$,,,-,.,/,F unde! $010, ,011, -012,
.011, /012 (i F013. -ifrele sistemului #inar se numesc #ii.
Conversia zecimal3binar>
Fie un numr natural reprezentat n sistemul #inar
0
1
1
1
1
1
0
2 ... 2 2 b b b b N
n
n
n
i
i
i
+ + +

In partea dreapt a%em un polinom de puteri ale lui 2. -oeficientul

i
b
este 0 sau 1. .in
e+presia de mai sus a numrului se o#ser% c cifrele o
b
,
1
b , etc se pot o#ine ca
resturile impririlor repetate ale numrului 4 cu 2. 5om nota!
0
q N
(i %om scrie!
0 1 0
2 r q q +
de unde deducem!
0 0
b r
1
2
1 1
... 2 b b q
n
n
+ +

5om scrie
1 2 1
2 r q q +
de unde deducem!
1 1
b r
2
1
1 2
... 2 b b q
n
n
+ +

.up n astfel de operaii %om a%ea!

1 1
2

+
n n n
r q q
unde!
1 1

n n
b r
0
n
q
.up cum se o#ser%, resturile o#inute reprezint c*iar cifrele numrului #inar.
/+emplu. 6 con%ertim numarul 12 din #aza 10 n #aza 2.
0 2 7 ) 2 12
0 1
+ + r q
$%em deci!
0
0 0
r b
1 2 7 1 2 )
1 2
+ + r q
$%em! 1
1 1
r b
1 2 7 1 2 1
2 1
+ + r q
de unde o#inem!
1
2 2
r b
In final!
1 2 7 0 2 1
1 2
+ + r q
de unde o#inem!
1
1 1
r b
deci reprezentarea numrului 12 n #inar este!
( ) ( )
2 10
1110 12
In acela(i fel o#inem!
( )
2 10
) 1010 ( 10
( ) ( )
2 10
1011 11
( ) ( )
2 10
1100 12
( ) ( )
2 10
1101 11
( ) ( )
2 10
1111 13
$l8oritmul de con%ersie a unui numr din #aza 10 n #aza 2 este urmtorul!
1.
N q
0
2. 0 i
1. c9t timp
0
i
q
:
2
1
i
i
q
q
+
2 ;
i i
q r
1 + i i
<
=esturile o#inute sunt cifrele numrului #inar, primul rest fiind cifra cea mai puin
semnificati%.
-on%ersia din #aza 10 n #aza > sau 1? se face prin mpriri repetate cu > (i respecti% 1?.
Unitatea de #az a informaiei n calculator este un octet sau #@te, ce cuprinde > cifre
#inare (#ii). 4umerele ntre8i se reprezint n calculator pe >, 1?, 12 sau ?2 de #ii.
$%9nd un numr n #aza 2, pentru reprezentarea sa n #aza 1? se 8rupeaz c9te 2 cifre
#inare.
/+emplu.
( ) ( ) ( )
1? 2 10
1100 12 C
( ) ( ) ( ) ( )
10 10 1? 2
13> 12 1? 7 ' ' 10011110 + E
=eprezentarea n #aza 1? este important deoarece un octet poate fi reprezentat prin dou
cifre *e+azecimale.
$%9nd un numr n #aza 2, pentru reprezentarea n #aza > se 8rupeaz c9te 1 cifre #inare.
/+emplu.
( ) ( ) ( )
> 2 10
12 11100 2>
Aentru %erificare
( ) ( ) ( )
10 10
1
>
2> 2 > 7 1 12 +
-on%ersia unui numr din #aza 1? n #aza 2 se face reprezent9nd fiecare cifr
*e+azecimal prin 2 cifre #inare.
-on%ersia unui numr din #aza > n #aza 2 se face con%ertind fiecare cifr octal prin 1
cifre #inare. Aentru con%ersii de numere ntre #azele 2, >, 10 (i 1? (i operaii cu numere
n aceste #aze se poate folosi aplicaia -alculator a sistemului de operare BindoCs.
Reprezentarea numerelor binare cu semn
In cazul numerelor #inare cu semn, #itul cel mai semnificati% este #itul de semn. /l este 0
pentru numere poziti%e (i 1 pentru numere ne8ati%e. /+ist trei reprezentri ale
numerelor #inare cu semn.
Reprezentarea n m>rime i semn
4umrul poziti% D se reprezint ca!
+
2
0
1
2 2 7 0
n
i
i
i
n
a X
4umrul ne8ati% D se reprezint ca!
+
2
0
1
2 2 7 1
n
i
i
i
n
a X
/+emple. 5om considera numere ntre8i reprezentate pe > #ii, un #it de semn (i ) #ii ai
numrului!
4umr zecimal =eprezentare #inar =eprezentare *e+azecimal
11 0000 1101 0.
E11 1000 1101 >.
23 0001 1001 1'
E) 1000 0111 >)
12) 0111 1111 )F
E12) 1111 1111 FF
Fama numerelor ntre8i reprezenta#ile pe un octet n mrime (i semn este GE12), 12)H.
Autem scrie formula de reprezentare a numerelor #inare n mrime (i semn ca!
+
2
0
1
1
2 2 ) 1 (
n
i
i
i
n
n
a a X
unde coeficientul 1 n
a
are %aloarea 0 sau 1. Arimul #it %a fi interpretat ca (i coeficientul
lui
1
2

n
.
Reprezentarea n complement fa> #e 1
4umrul poziti% D se reprezint n complement fa de 1 ca!
+
2
0
1
2 2 7 0
n
i
i
i
n
a X
4umrul ne8ati% D se reprezint ca!
+
2
0
1
2 2 7 1
n
i
i
i
n
a X
unde!
i i
a a 1
. Aentru a reprezenta un numr ne8ati% n complement fa de 1
complementm toate cifrele lui.
/+emple de numere reprezentate n complement fa de 1 pe un octet.
13 0000 1111 0F
E13 1111 0000 F0
E1' 1000 1100 >-
1' 0001 0011 11
Reprezentarea numerelor binare n complement fa> #e 2
4umerele poziti%e se reprezint n complement fa de 2 ca!
+
2
0
1
2 2 7 0
n
i
i
i
n
a X
4umerele ne8ati%e se reprezint n complement fa de 2 ca!
+ +
2
0
1
1 2 2 7 1
n
i
i
i
n
a X
unde!
i
i a a 1
.
/+emple de numere reprezentate n complement fa de 2 pe un octet.
11 0000 1101 0.
E11 1111 0011 F1
E) 1111 1001 F'
12) 0111 1111 )F
E12) 1000 0001 >1
enionm c n calculatoare numerele ntre8i se reprezint n 8eneral n complement
fa de 2. -onsiderm formula ce reprezint un numr ne8ati% n complement fa de 2.
$%em relaia!
1
2
0
2 1 2

n
n
i
i
In consecin, putem scrie!

+ + +
2
0
2
0
1 1
2
0
1
2 2 2 2 7 1 1 2 ) 1 ( 2 7 1
n
i
i
i
n
i
i
i
n n
n
i
i
i
n
a a a
1.2 Deplasarea numerelor binare cu semn
Inmulirea unui numr #inar cu semn cu
1
2
sau
1
2
este ec*i%alent cu deplasarea

numrului #inar la st9n8a sau la dreapta cu o cifra. Ia deplasarea numrului #inar #itul de
semn rmane nesc*im#at.
Cazul numerelor pozitive.
6e deplaseaz toate cifrele numrului, iar cifrele adau8ate sunt zerouri. =e8ula este
e%ident din formula de reprezentare a numerelor poziti%e. Fie numrul poziti%
+
2
0
1
2 2 7 0
n
i
i
i
n
a X
(i fie numrul nmulit cu 2
+
2
0
1
2 2 7 0 7 2
n
i
i
i
n
b X Y
de unde se deduce!
i i
a b
+1
0
0
b
$m presupus c prin nmulirea cu 2 a numrului D nu apare depsire. In acela(i fel se
arat c re8ula este %ala#il pentru mprirea cu 2.
/+emple. 6 deplasm numrul 2> cu o cifr #inar la dreapta (i la st9n8a.
4umr zecimal 4umr #inar 4umr *e+azecimal
2> 0001 1100 1-
12 0000 1110 0/
3? 0011 1000 1>
?umere negative reprezentate n complement fa> #e 2
=e8ula de nmulire a acestor numere cu
1
2
sau
1
2
este urmtoarea!
la deplasarea la st9n8a cifrele adu8ate sunt zerouri,
la deplasarea la dreapta cifrele adau8ate sunt unuri,
reamintim ca #itul de semn rm9ne nesc*im#at.
/+emplu.
4umr zecimal 4umr #inar 4umr *e+azecimal
E2> 1110 0100 /2
E12 1111 0010 F2
E3? 1100 1000 ->
1.1 Reprezentarea numerelor reale
4umerele reale se reprezint n calculator n %ir8ul mo#il. 4umarul real = este pus su#
forma
e
b f R 7
unde! f este un numr su#unitar (mantisa), # este #aza iar e este e+ponent sau
caracteristic. Aentru e+emplificare %om considera #aza zece.
/+emple de reprezentare a numerelor reale.
2
10 7 1223 . 0 23 . 12
1
10 7 13 . 0 013 . 0

antisa f are totdeauna un numr finit de cifre (i n plus!
1 < f
In continuare, pentru e+emplificare %om considera c mantisa are > cifre. .eoarece
mantisa are un numr finit de cifre, n unele cazuri se pierd cifrele mai puin
semnificati%e din numr.
/+emplu. 4umrul
... 1111111111 . 0 ) 1 .( 0
1
1

se reprezint ca!
0
10 7 11111111 . 0
Aentru mrirea preciziei calculelor se caut ca prima cifr din mantis s fie diferit de
zero (%ezi e+emplul de mai sus). 4umerele n aceast form se numesc normalizate.
+fectuarea operaiilor cu numere n virgul> mobil>
Aentru adunare numerele se aduc la acela(i e+ponent (numrul mai mic la e+ponentul
celui mai mare) (i apoi se adun mantisele. $ducerea numrului mai mic la e+ponentul
celui mai mare poate duce la pierderea cifrelor cel mai puin semnificati%e din mantis.
/+emplu. 6 efectum adunarea!
12.2>J0.13
Arimul numr este reprezentat ca!
2
10 7 122> . 0
iar al doilea
0
10 7 13 . 0
Aentru adunare se aduc numerele la acela(i e+ponent
0.122> 2
0.013 2
(i se adun mantisele.
0.12>1 2
5om prezenta un e+emplu n care se pierd cifrele cele mai puin semnificati%e din
rezultat. 6 adunm numerele!
121).33 J 0.000223
4umerele sunt reprezentate astfel!
0.1223 2
E0.13 E1
0.122> 2
0.13 0
2
10 7 121)33 . 0
1
10 7 223 . 0

Ia adunare mantisa celui deEal doilea numr este deplasat la dreapta cu ) cifre.
-onsider9nd lun8imea mantisei de > cifre, se pierd doua cifre semnificati%e din al doilea
numr la aducerea la acela(i e+ponent.
0.121)33 2
0.00000002 2
=ezultatul adunrii este!
0.121)3302 2
K#ser%m c sEau pierdut dou cifre, cele mai puin semnificati%e.
Kperaia de scdere se face aduc9nd numerele la acela(i e+ponent (i scz9nd mantisele.
Ia nmulire se adun e+ponenii (i se nmulesc mantisele. Ia mprire se scad
e+ponenii (i se mpart mantisele. .up efectuarea unei operaii aritmetice se caut ca
prima cifra din mantis s fie diferit de zero, pentru o precizie ma+im a rezultatului
(normalizare).
Aentru cre(terea preciziei operaiilor, n unitatea de calcul mantisa mai are nc o cifr.
Kperaiile se fac deci cu o mantis mai lun8, dup care se rein opt cifre din rezultat.
/+emplu. Fie de efectuat operaia de scdere!
101.23?)> L 21.23?)>'
4umerele se reprezint astfel!
0.10123?)> 1
0.2123?)>' 2
.ac mantisa are doar opt cifre semnificati%e, c9nd deplasm la dreapta cu o cifr,
mantisa celui deEal doilea numr, pierdem o cifr semnificati%.
0.02123?)> 1
=ezultatul scderii celor dou numere este!
0.0> 1
(i dup normalizare o#tinem rezultatul >0. Aresupunem acum c n unitatea de calcul se
lucreaz cu o mantis cu nou cifre semnificati%e. In acest caz cele dou numere sunt
0.10123?)>0 1
0.02123?)>' 1
.up scderea celor dou numere o#inem!
0.0)''''''1 1
iar dup normalizare o#inem rezultatul corect!
0.)''''''1 2
entionm c e+ponentul poate fi poziti% sau ne8ati%. Aentru a nu a%ea dou semne, unul
pentru numr (i altul pentru e+ponent, se adau8 un numr constant la e+ponent astfel ca
s fie totdeauna poziti%. .e e+emplu, dac 8ama e+ponentului este GE?1, ?1H se adau8
%aloarea ?1 astfel nc9t 8ama e+ponentului %a fi G0, 12?H.
0.121)33 2
0.223 E1
In calculatoarele personale numerele reale se reprezint n %ir8ul mo#il n felul urmtor
= 0 semn 7 1.mantisa 7 2
e+ponent
In reprezentarea n %ir8ul mo#il scurt (simpla precizie) numrul se reprezinta pe 12
#ii. .omeniul e+ponentului este GE12), 12)H. Ia e+ponent se adau8 totdeauna %aloarea
12) astfel ncat e+ponentul are domeniul G0,232H. ,itul de semn are %aloarea 0 pentru
numere poziti%e (i 1 pentru cele ne8ati%e. ,itul de semn ocup #itul 11, e+ponentul
ocup #iii 21E10 iar mantisa #iii 0E22. Fama numerelor reale ce se pot reprezenta n
acest format este
) 10 , 10 (
1) 1)
iar mantisa corespunde la opt cifre zecimale.

/+emple. Fie numrul
0
2 7 0 . 1 0 . 1 R . ,itul de semn este zero iar e+ponentul 0J12).
In consecin, primii nou #iti din numr sunt
001111111
4umrul = %a fi reprezentat n *e+azecimal ca 1F>00000.
Fir numrul
1
2 7 0 . 1 3 . 0

R . ,itul de semn este zero iar e+ponentul este
E1J12)012?. Arimii nou #ii din numr sunt
001111110
4umrul se reprezint n *e+azecimal ca 1F000000.
enionm c dac e+ponentul este 233 iar mantisa este 0, numrul este t .ac
e+ponentul este 233 (i mantisa este diferit de zero numrul este 4a4 (not a num#er).
5aloarea 4a4 apare atunci c9nd efectum urmatoarele operaii

M
0 M 0
7 0
sau c9nd un operand este 4a4.
In reprezentarea n %ir8ul mo#il lun8 (du#l precizie) numrul se reprezint pe ?2 #ii.
.omeniul e+ponentului este GE1021, 1021H. Ia e+ponent se adau8 cantitatea 1021, deci
e+ponentul are domeniul G0, 202?H. ,itul de semn este #itul ?1, e+ponentul ocup #iii
32E?2 iar mantisa ocup #iii 0E31. Fama numerelor reale ce se pot reprezenta este
) 10 , 10 (
10) 10)
1.2 Reprezentarea caracterelor

Unul dintre sistemele de reprezentare a caracterelor este codul $6-II n care fiecare
caracter este reprezentat pe un octet. .e e+emplu caracterul $ are codul *e+azecimal 21,
caracterul a are codul *e+azecimal ?1, cifra 0 are codul *e+azecimal 10, etc. -odurile
$6-II ale caracterelor sunt prezentate n ta#ela de mai Nos.
@O+ 0 1 2 1 2 3 ? )
0 4ul .le 0 A p
1 6o* dc1 P 1 $ Q a R
2 6t+ dc2 S 2 , = # r
1 /t+ dc1 T 1 - 6 c s
2 /ot dc2 U 2 . V d t
3 /nR 4aW ; 3 / U e u
? $cW 6@n X ? F 5 f %
) ,el /l# Y ) F B 8 C
> ,s -an ( > Z D * +
' Zt /m ) ' I [ i @
10 If 6u# 7 ! \ ] N z
11 5t /sc J ! ^ G W :
12 Ff Fs , _ I O l `
11 -r Fs E 0 H m <
12 6o =s . " 4 a n b
13 6i Us M c K d o del
Va#elul 1.1 -odul $6-II
-odul zecimal unui caracter este 1?7+J@. .e e+emplu caracterul $ are codul zecimal ?3
sau, ec*i%alent, codul *e+azecimal 21.
Un alt sistem de reprezentare a caracterelor este U4I-K./. n %arianta U4I-K./E1?
fiecare caracter este reprezentat pe 2 octei.
Cap 2. Constante variabile i e!presii
2.1 "ipuri fun#amentale
In matematic %aria#ilele se clasific dup tipul lor. Vipul unei %aria#ile este mulimea
%alorilor pe care le poate lua acea %aria#il (i operaiile ce se pot efectua cu acele %alori.
Vipul unei %aria#ile este fcut e+plicit cu o declaraie de tip. Vipurile predefinite n
lim#aNul -JJ sunt cele din ta#elul 1.
Va#elul 1. Vipuri de #az ale lim#aNului -JJ
Vip .imensiune
n octei
.omeniu de
%alori
Kperaii
int 4umere ntre8i 2
H 1 2 2 G
11 11

JE7M;
float 4umere reale n %ir8ul
mo#il scurt
2 ) 10 10 (
1> 1>
JE7M
dou#le 4umere reale n %ir8ul
mo#il lun8
> ) 10 10 (
10) 10)
JE7M
c*ar -aractere n cod $6-II (i
numere ntre8i pe un octet
1 H 1 2 2 G
) )
JE7M;
Cc*ardt 4umere poziti%e (i caractere
U4I-K./ pe doi octei
2 H 1 2 0 G
1?
JE7M;
#ool 5aloare #oolean 1 false,true and, or,
not
Aentru fiecare tip e+ist constante predefinite ce dau limitele minima (i ma+im ale
domeniului de %alori.
enionm c, pentru tipurile c7ar (i int, primul #it este utilizat pentru semn, ceilali #ii
sunt #ii ai numrului. In cazul tipului bool %aloarea false este reprezentat prin zero iar
true prin unu.
2.2 $ariabile
4umele unei %aria#ile este format din cifre, litere (i caracterul d (underscore), (i ncepe
totdeauna cu o liter sau caracterul d. Iiterele mari sunt diferite de cele mici.
Instruciunea de declarare a tipului are forma
tip list de %aria#ilee
Iista de %aria#ile este format din nume de %aria#ile separate de %ir8ule. .ia8rama
sintactic este cea de mai Nos.
.e e+emplu, instruciunile
int ae
c*ar #e
declar o %aria#il a de tipul int (i o %aria#il # de tipul c7ar. -onform instruciunii de
declarare a tipului de mai sus, mai multe %aria#ile de acela(i tip pot fi declarate cu o
sin8ur instruciune, scriind numele lor separate de %ir8ule. .e e+emplu, instruciunea
float f1, f2, f1e
declar trei %aria#ile de tipul float. K %aria#il poate fi iniializat la declararea tipului ei,
conform urmtoarei dia8rame sintactice
.e e+emplu, instruciunea
dou#le d 0 1 J sin(2.2)e
declar o %aria#il de tip #ouble pe care o iniializeaz la %aloarea 1Jsin(2.2).
%enion9m c9 tipul bool nu este #efinit n limba@ul C.
2.3 %o#ificatori #e tip
odificatorii de tip sc*im# domeniul de %alori pe care le poate lua o %aria#il de tip int
sau c7ar. $ce(ti modificatori sunt!
unsigne#. Ia utilizarea acestui modificator, %alorile %aria#ilelor sunt poziti%e.
Voi #iii sunt #ii ai numrului. Vipul unsigne# int are domeniul de %alori
H 1 2 0 G
12
, iar tipul unsigne# c7ar are domeniul de %alori H 1 2 0 G
>

signe#. 5alorile %aria#ilelor sunt numere cu semn. Arimul #it este #it de semn.
s7ort. 6e aplic tipului int. .e e+emplu, tipul s7ort int are domeniul de %alori
H 1 2 2 G
13 13
, iar tipul unsigne# s7ort int are domeniul de %alori
H 1 2 0 G
1?
. Vipul 6c7arAt este tipul unsigne# s7ort int predefinit.
long
2.4 &peratorul t'pe#ef
Kperatorul t@pedef permite s definim tipuri de date #azate pe tipuri e+istente. Forma
instruciunii este
t@pedef tipEe+istent tipEnou
/+emple. Instructiunea
t@pedef float =/$I12
define(te tipul =/$I12 ce poate fi utilizat n locul tipului float.
In lim#aNul - nu e+ist tipul predefinit #ool. Autem s definim tipul #ool folosind tipul
c*ar
t@pedef c*ar #ool
2.( Constante
Vipurile de constante din lim#aN corespund tipurilor de date.
constantele ntre8i sunt numere ntre8i, poziti%e sau ne8ati%e. /le nu pot ncepe cu
cifra 0. /+emple de constante ntre8i sunt
2)3, E123, J12
constante *e+azecimale sunt numere ntre8i reprezentate n #aza 1?. /le ncep cu
0+ sau 0D. /+emple de constante *e+azecimale
0+/ sau 0+e sau 0De sau 0D/ care reprezint %aloarea zecimal 12
E0+f sau E0+F, reprezint %aloarea zecimal E13.
constante octale sunt numere ntre8i reprezentate n #aza >. /le ncep o#li8atoriu
cu 0. /+emple. -onstanta octal 01? reprezint numrul zecimal 12 (deoarece
10 >
) 12 ( ) 1? (
) iar constanta octal E012 reprezint numrul zecimal E12
(deoarece
> 10
) 12 ( ) 12 (
)
constante reale n %ir8ul mo#il scurt. Aartea su#unitar este separat de cea
ntrea8 prin punct zecimal. /+emple.
1.3 E2.21 2).0
-onstantele reale pot a%ea e+ponent, un numr ntre8 ce reprezint puterea lui
zece cu care se nmule(te constanta. .e e+emplu numrul
1
10 7 11 , 2 se scrie ca
2.11e1 sau 2.11eJ1 sau J2.11/1
4umrul real
1
10 7 2 , 21

se scrie ca (i constant real
E21.2eE1 sau E2.12
constante reale n %ir8ul mo#il lun8. 6e scriu ca (i constantele reale n %ir8ul
mo#il scurt (i cu sufi+ul I sau l. .e e+emplu, numrul real 1,3 se scrie ca (i
constant n %ir8ul mo#il lun8
1.3I sau 13eE1I
constante de tip c*aracter reprezint un c*aracter al codului $6-II scris ntre
apostrofuri. .e e+emplu, caracterul $6-II a se scrie
Yaf sau ec*i%alent, ca (i constante ntre8i, 0+?1 sau ')
-aracterul $6-II $ se scrie
Y$f sau ec*i%alent, 0+21 sau ?3.
Un alt mod de a defini constante tip c*aracter este de a le scrie su# forma YO+**f
unde * este o cifr *e+azecimal. 4umrul *e+azecimal ** reprezint ec*i%alentul
*e+azecimal al caracterului n codul $6-II. .e e+emplu, caracterele Yaf (i Y$f se
reprezint ca (i YO+?1f (i respecti%e YO+21f. -aracterele speciale ale codului $6-II
se reprezint folosind sec%ena de e%itare
YOnf -=
YOrf IF
YOtf ta# orizontal
YOgf 8*ilimele
YOff apostrof
YOOf #acWslas*
constante tip (ir de caractere. /le reprezint un (ir de caractere $6-II scris ntre
8*ilimele. .e e+emplu
Sa#cdg
Un (ir de caractere este reprezentat de codurile $6-II ale caracterelor pe c9te un
octet, urmate de un octet ce conine %aloarea 0. -aracterele speciale se reprezint
n interiorul unui (ir folosind sec%ena de e%itare. .e e+emplu
Sa#Ogcg
SaOO#cg
Sa#cOng
enionm diferena ntre constanta tip caracter Yaf (i constanta tip (ir de
caractere Sag. -onstanta tip caracter Yaf se reprezint pe un sin8ur octet,
constanta Sag se reprezint pe doi octei.
constante tip caracter U4I-K./ corespund tipului Cc*ardt. /le se definesc su#
forma IfO+****f unde * reprezint o cifr *e+azecimal.
constante #ooleene sunt true (i false (i se reprezint prin %alorile unu (i
respecti%e zero.
2.) Constante cu nume
In pro8ram putem defini constante cu nume n urmtoarele feluri
utilizarea directi%ei #efine . -ompilatoarele lim#aNelor - (i -JJ au un
preprocessor care modific pro8ramul surs nainte de compilare. Areprocesorul
cite(te di%ersele directi%e (i modific pro8ramul surs corespunztor acestora.
.irecti%a #efine ce define(te o constant are forma
T define nume %aloare
unde %aloare este interpretat de preprocessor ca un (ir de caractere. .e e+emplu,
directi%a
T define AI 1.12
are ca efect nlocuirea numelui AI n pro8ram cu (irul de caractere 1.12
enumerri. K enumerare define(te un tip ntre8 (i %alorile asociate acelui tip.
Instruciunea enum de declarare a unui tip are forma
enum numetip :list de nume<e
.ia8rama sintactic corespunztoare este urmtoarea
.e e+emplu,
enum -I=D :aaa, ###, ccc<e
define(te trei constante aaa, ###, ccc, prima are %aloarea zero (i fiecare constant
urmtoare are o %aloare mrit cu unu.
aaa 0 0
### 0 1
ccc 0 2
In pro8ram constantele sunt nlocuite cu %alorile lor. 5aloarea fiecrei constante
poate fi specificat printrEo e+presie ntrea8 constant. .e e+emplu
enum cst%al :ppp 0 2, dd, cc 0 E1, nn 0 2 J 1 7 2<e
define(te constantele
ppp 0 2
dd 0 1
cc 0 E1
nn 0 12
Autem defini %aria#ile corespunz9nd tipului definit prin enum. $ceste %aria#ile
pot primi ca %alori doar constantele definite n instruciunea enum. Fie de
e+emplu tipul enum+ definit mai Nos
enum enum+ 0 :ena, en#, enc<e
Instruciunea urmtoare define(te %aria#ila z de tipul enum+
enum+ ze
Autem atri#ui o %aloare %aria#ilei z astfel
z 0 enae
Instruciunea enum are (i o form mai simpl
enum :list de nume<e
care define(te doar constante (i nu un tip.
utilizarea cu%antului c*eie const. K asemenea instruciune are forma
const tip nume 0 %aloaree
unde tip este un tip al lim#aNului iar %aloare este o e+presie constant. .e
e+emplu, instruciunile
const int a 0 )e
const c7ar # 0 Yafe
const float c 0 2.3eE2 7 2.12e
const float + 0 sin(0.2) J cos(1.3)e
const float z 0 lo8(12.3) M 2.1e
definesc constantele a, #, c, + (i z, ce au %alorile specificate n instruciune.
2.* +!presii aritmetice
/+presiile aritmetice sunt formate din constante, %aria#ile (i funcii. Kperatorii sunt J, E 7
(i M, (i n cazul operanzilor de tip ntre8, (i ; (restul mpririi a dou numere ntre8i).
=estul mpririi a dou numere ntre8i, a (i #, se define(te astfel
a ; # 0 a L (a M #) 7 #
.e e+emplu,
13 ; 2 0 1
11 ; 3 0 2
Aentru 8ruparea termenilor se folosesc paranteze rotunde ( (i ). .e e+emplu, e+presia
b a
b a
+
se scrie ca
(a L #) M (a J #)
iar e+presia
2
2
2
7 7
m
x c x b a
+
+ +
se scrie ca
(a J # 7 + J c 7 + 7 +) M (2 J m7m)
Funciile matematice standard uzuale ale lim#aNelor - (i -JJ sunt cele de mai Nos
acos cos e+p ceil fa#s poC
asin sin lo8 floor sRrt
atan tan lo810
Funcia floor(+) calculeaz %aloarea ]
x
(cel mai mare numr ntre8 cuprins n +), iar
funcia ceil(+) calculeaz %aloarea 1
x
(cel mai mic numr ntre8 mai mare ca +). Voate
funciile de mai sus au ar8umente de tip dou#le (i rezultatul de tip dou#le. Funcia poC
are prototipul
dou#le poC(dou#le a, dou#le #)
(i calculeaz e+presia
b
a . $pelarea unei funcii se face scriind numele funciei ca termen
ntrEo e+presie urmat n paranteze de parametrii actuali. /+emple de e+presii aritmetice (i
scrierea lor sunt prezentate mai Nos. 5om presupune c %aria#ilele din aceste e+presii au
fost declarate n preala#il de tip dou#le (i au primit %alori.
x
x b x a
+
+
)3 . 2
) sin( 7 ) ( cos 7
2
(a7cos(+)7cos(+)J#7sin(+))M(2.)3Jfa#s(+))
3
2x x
e e

+
(e+p(+)Je+p(E27+))M3
) cos( 1 ln ) 2 lo8( x x + + +
lo810(fa#s(+)J2)Jlo8(fa#s(1Jcos(+)))
enionm c n e+presii putem folosi orice fel de constante ntre8i, reale sau c*aracter.
.e e+emplu, e+presia a J 2) se poate scrie
a J 2)
sau
a J 0+1#
sau
a J 011
-onstantele *e+azecimal 0+1# (i octal 011 reprezint %aloarea zecimal 2). /+presia
+ J 100 se poate scrie
+ J 100
sau
+ J 0+?2
sau
+ J Ydf
-odul $6-II al caracterului d este 0+?2. Ia e%aluarea unei e+presii constantele
*e+azecimale, octale sau c*aracter sunt con%ertite n numrul ntre8 corespunztor.
/%aluarea e+presiilor aritmetice se face inand cont de prioritile operatorilor (i de
asociati%itatea lor.
Arioritatea operatorilor $sociati%itate
J unar, E unar
7 M ; $sociati% la st9n8a
J E $sociati% la st9n8a
-onform ta#elei de mai sus operatorii 7, M (i ; au o prioritate mai mare dec9t J (i E
$sociati%itatea la st9n8a a operatorilor nseamn urmtorul mod de e+ecuie. /+presia
a M # M c
este interpretat ca
(a M #) M c
=eamintim c, pentru a modifica ordinea de e+ecuie o operaiilor, se utilizeaz paranteze
rotunde.
.eoarece n e+presii inter%in operanzi de di%erse tipuri, se fac con%ersii. =e8ulile dup
care se fac aceste con%ersii sunt urmtoarele!
Vipul float se con%erte(te la #ouble
Vipurile c7ar (i s7ort int se con%ertesc la int
Vipurile unsigne# c7ar (i unsigne# s7ort int se con%ertesc la unsigne# int
.ac n e+presie e+ist un operand de tipul long int, tipul int (i unsigne# int se
con%ertesc la long int. Vipul e+presiei se determin conform ta#elei de mai Nos
int lon8 dou#le
int int lon8 dou#le
lon8 lon8 lon8 dou#le
dou#le dou#le dou#le dou#le
enionm n final c tipurile c*ar, s*ort int (i %ariantele lor unsi8ned c*ar, unsi8ned
s*ort int (i float sunt doar pentru memorare. -alculele se efectueaz doar cu %aria#ile
de tip int, lon8 int (i dou#le.
5aloarea unei e+presii poate fi con%ertit ntrEun tip diferit dac este ne%oie.
.ia8rama sintactic este
(tip) e+presie
.e e+emplu, dac i este o %aria#il ntrea8 cu %aloarea ) (i f este o %aria#il de tip
dou#le cu %aloarea 1.2), e+presia
(i J f) ; 2
nu este corect deoarece are tipul dou#le. /+presia
(int)(i J f) ; 2
are tipul int (i este corect, rezultatul ei este 3. In lim#aNul -JJ este posi#il nc o
form de con%ertire a e+presiilor, cu dia8rama sintactic
tip(e+presie)
.e e+emplu, con%ersia e+presiei anterioare la tipul int se poate scrie
int(i J f)
enionm c se pot face con%ersii n toate tipurile standard e+istente n lim#aNe.
2., "ablouri
Un ta#lou este o mulime de elemente de acela(i tip. Va#lourile sunt tipuri structurate
simple. Instruciunea de declarare a unui ta#lou cu o dimensiune este urmtoarea
tip nume G ntre8H e
unde ntre8 reprezint numrul de elemente ale ta#loului. /lementele ta#loului sunt
numeG0H, numeG1H, &, numeGntre8 L 1H. .e e+emplu instruciunea
int aG10He
declar un %ector cu zece elemente de tip int. /lementele %ectorului sunt aG0H, aG1H, &,
aG'H. Un ta#lou poate fi iniializat la declararea sa scriind %alorile elementelor ntre
accolade, :<, (i separate de %ir8ule. /+emple de instruciuni ce declar ta#louri (i le
atri#uie %alori
float +G1H 0 :1.12, E2.13, 2.23<e
c*ar cG2H 0 :Yaf, Y#f, Ycf, Y+f<e
In cazul n care lista de %alori este mai scurt decat numrul de elemente declarate,
ultimele elemente sunt iniializate cu zero. In cazul iniializrii unui ta#lou, la declararea
lui putem omite numrul de elemente al ta#loului. .e e+emplu, putem scrie
c*ar +GH 0 :YTf, Y"f, Ymf<e
-ompilatorul calculeaz dimensiunea ta#loului din numrul de %alori utilizate pentru
iniializare. Instruciunea precedent este ec*i%alent cu instruciunea
c*ar +G1H 0 :YTf, Y"f, Ymf<e
enionm c un %ector de caractere poate fi iniializat cu o constant tip (ir de caractere.
.e e+emplu, putem scrie
c*ar sGH 0 Sa#cge
=eamintim c o constant (ir de caractere este terminat printrEun octet 0, deci %ectorul
declarat are 2 componente, Yaf, Y#f, Ycf (i 0. Instruciunea precedent este ec*i%alent cu
c*ar sG2H 0 Sa#cge
sau cu instruciunea
c*ar sG2H 0 :Yaf, Y#f, Ycf , YO0f<e
Un ta#lou poate a%ea oric9te dimensiuni. .ia8rama sintactic a declaraiei unui ta#lou
este urmtoarea
.e e+emplu, instruciunea
float #G)HG1H
declar o matrice cu (apte linii (i trei coloane. /lementele matricei sunt
#G0HG0H #G0HG1H #G0HG2H
& & &
#G?HG0H #G?HG1H #G?HG2H
Un ta#lou cu mai multe dimensiuni poate fi de asemenea iniializat la declararea sa. Fie
de definit matricea cu elemente ntre8i
1
]
1
1 ) 1
3 2 1
m
Instruciunea corespunztoare este
int mG2HG1H 0 ::1, 2, 3<,:1, ), E1<<e
Ia utilizarea ntrEo e+presie, indicii elementelor ta#lourilor pot fi orice e+presii ntre8i.
Aresupunem urmtoarele declaraii de ta#louri
dou#le aG10H, #e
int i, N, @G1HG2He
/+emple de e+presii ce conin elemente de ta#louri.
) sin( ) cos(
7
b b
y b a
ij i
+
(aGiHJ#7@GiHGNH)M(cos(#)Esin(#))
1 ,
) cos(
+
+
j i
b
y e
e+p(cos(#)) J @GiHGN J 1H
=a utilizarea elementelor unui tablou, BC este un operator #e selecie ce are #oi
operanziD un nume #e tablou i un in#ice. +l se aplic9 asupra unui nume #e tablou i
selecteaz9 un element al acelui tablou. De e!emplu aB/C selecteaz9 primul element al
tabloului a, iar bB/C selecteaz9 prima linie a tabloului b. 5plicEn# nc9 o #at9
operatorul #e selecie asupra lui bB/C, #e e!emplu bB/CB/C selecteaz9 primul element
#in prima linie a lui b. &peratorul BC este asociativ la stEnga.
.n acelai mo#, operatorul #e apelare a unei funcii FG, aplicat asupra unui nume #e
funcie returneaz9 valoarea calculat9 #e funcie. De e!emplu cosF1.2G reprezint9
aplicarea operatorului FG asupra numelui funciei cos.
Priorit9ile i asociativitatea operatorilor
Kperator $sociati%itate
GH () $sociati%i la st9n8a
J unar, E unar
7 M ; $sociati%i la st9n8a
J E $sociati%i la st9n8a
2.- .nstruciunea #e atribuire
Kperatorul de atri#uire 0 atri#uie o %aloare unei %aria#ile. Forma instruciunii de atri#uire
este
%aria#il 0 e+presiee
.e e+emplu, urmtoarele instruciuni atri#uie %alori %aria#ilelor
float +, @e
+ 0 E1.12e
@ 0 sin(+) J cos(+ 7 +)e
Iim#aNele - (i -JJ au operatori speciali pentru scriera prescurtat a instruciunilor de
atri#uire, J0, E0, 70, M0 (i ;0. $ce(ti operatori se definesc astfel!
-onsiderm o %aria#il + (i o e+presie e.
+ opH e
este ec*i%alent cu
+ 0 + op e
Va#elul urmtor prezint ace(ti operatori
Kperatori de atri#uire
Instruciune Forma prescurtat
+ 0 + J e + J0 e
+ 0 + E e + E0 e
+ 0 + 7 e + 70 e
+ 0 + M e + M0 e
+ 0 + ; e + ;0 e
$li operatori de acest tip %or fi prezentai ulterior. enionm n final c un operator de
atri#uire are doi operanzi (i ca rezultat %aloarea operandului din st9n8a. Kperanzii de
atri#uire sunt asociati%i la dreapta (se e+ecut de la dreapta la st9n8a). Fie de e+emplu
declaraia
int +, @, z 0 1e
Instruciunea
+ 0 @ 0 ze
atri#uie %aria#ilelor + (i @ %aloarea 1. Instruciunea
+ J0 @ J0 ze
atri#uie %aria#ilei @ %aloarea 2 (i %aria#ilei z %aloarea 1. .e cec
2.1/ Prototipuri #e funcii. <iblioteci #e prototipuri
$tunci c9nd compilatorul nt9lne(te un apel la funcie, el tre#uie s poat %erifica
concordana ntre parametrii actuali (i cei formali (i are ne%oie de tipul rezultatului
funciei pentru a face con%ersiile necesare e%alurii e+presiei. Aentru aceasta el are
ne%oie de o definiie a funciei n care apar tipurile parametrilor (i tipul rezultatului.
$ceast definiie se nume(te (a#lon sau prototip (i are forma
tip nume(tip, tip, &, )e
.e e+emplu, prototipul funciei sin este
dou#le sin(dou#le)e
Iim#aNele - (i -JJ au #i#lioteci standard cu prototipurile funciilor lim#aNului. $ceste
#i#lioteci sunt semnalate compilatorului cu directi%a inclu#e
T include _numed#i#liotec"
$ceste #i#lioteci sunt fi(iere cu e+tensia * (i se numesc fi(iere *eader.
.e e+emplu, #i#lioteca cu prototipurile funciilor matematice este :mat7.7;. Aentru a fi
semnalat compilatorului %om scrie instruciunea
T include _mat*.*"
,i#lioteca cu funcii intrareMie(ire tip - este _stdio.*", #i#lioteca cu funcii de prelucrat
(iruri tip - este _strin8.*", #i#lioteca cu funcii intrareMie(ire tip -JJ este _iostream.*",
etc. Autem defini propriile #i#lioteci cu prototipuri pe care s le semnalm compilatorului
cu directi%e include. 4umele propriilor #i#lioteci cu prototipuri sunt scrise ntre
8*ilimele.
In lim#aNul -JJ este posi#il (i un nou stil de includere a #i#liotecilor standard.
,i#liotecile specifice lim#aNului - sunt redefinite ca _cstdio", _cmat*", _cstrin8", etc.
In plus, toate funciile standard ale lim#aNelor - (i -JJ sunt 8rupate ntrEun spaiu de
nume denumit st#. In consecin, putem semnala compilatorului #i#liotecile standard ca
T include _numed#i#lioteca"
usin8 namespace stde
unde n directi%e include a%em #i#liotecile specifice lim#aNului -JJ.
2.11 &peraii #e intrare 0 ieire
Krice aplicaie are un director curent asociat (i fi(iere standard de intrare (i ie(ire.
Fi(ierul standard de intrare este tastatura iar cel de ie(ire este ecranul. In pro8ram orice
fi(ier este asociat unui o#iect numit stream. /+ist dou tipuri de fi(iere! te+t (i #inare.
Fi(ierul te+t este este compus dintrEun (ir de caractere 8rupate n linii. Iiniile constau din
zero sau mai multe caractere plus un caracter YOnf. Fi(ierele standard sunt de tipul te+t.
6treamul de intrare asociat tastaturii are denumirea cin, streamul de ie(ire asociat
ecranului se nume(te cout. ai e+ist alte doua streamuri cerr (i clog pentru scrierea
mesaNelor de eroare.
Kperatorul de scriere este ::. /l insereaz date n streamul cout. .e e+emplu, sec%ena
de instruciuni
int i 0 121e
cout __ Si 0 g __ ie
afi(az pe ecran
i 0 121
Aentru a despri te+tul afi(at n linii, tre#uie s scriem caracterul YOnf, care este predefinit
ca en#l. .e e+emplu, pentru a afi(a cele de mai sus pe dou linii, %om scrie
cout __ Si 0 S __ endl __ i __ endle
sau
cout __ Si 0 S __ YOnf __ i __ YOnfe
sau, ec*i%alent
cout __ Si 0g __ endl
cout __ i __ endle
Kperatorul __ poate scrie orice tip predefinit de date! int, float, (iruri de caractere, etc.
Kperatorul de citire dintrEun stream este ;;. /l e+tra8e date din stream. Kperatorul ""
este urmat de numele %aria#ilei ce %a memora %aloarea citit. .e e+emplu, sec%ena de
instruciuni
int ae
cin "" ae
%a citi %aloarea introdus de la tastatur (i o %a atri#ui %aria#ilei a. 6e pot citi oric9te date
din streamul cin. Instruciunea
cin "" a "" #e
este ec*i%alent cu
cin "" ae
cin "" #e
-ele dou %alori introduce pentru e+emplul de mai sus tre#uie separate de spaii , Ot sau On
(acesta din urm este 8enerat la apsarea tastei =eturn).
,i#lioteca de prototipuri pentru streamurile cin, cout, etc are numele :iostream.7;.
Aentru a modifica formatul de scriere sai citire a datelor putem utilize manipulatori.
Aentru scrierea sau citirea unui numr ntre8 n instruciunile cout sau cin n diferite #aze
se utilizeaz manipulatorii
7e! pentru #aza 1?
#ec pentru #aza 10
oct pentru #aza >
Ia nceperea e+ecuiei unui pro8ram implicit este #aza 10. Aentru scrierea #azei se
uitlizeaz manipulatorii
s*oC#ase pentru scrierea #azei
nos*oC#ase pentru a nu scrie #aza
/+emplu. Fie instruciunea
int W 0 20e
Va#loul urmtor prezint e+emple de utilizare a manipulatorilor.
cout __ We 20
cout __ *e+ __ We 12
cout __ oct __ We 22
cout __ s*oC#ase __ *e+ __ We 0+12
cout __ s*oC#ase __ oct __ We 022
In cazul numerelor reale a%em manipulatorii
fi+ed numrul este scris fr e+ponent
scientific numrul este scris cu e+ponent
float + 0 122.?1e
Va#loul urmtor prezint e+emple de utilizare a manipulatorilor.
cout __ +e 122.?1
cout __ fi+ed __ +e 122.?1
cout __ scientific __ +e 1.22?100eJ002
Funciile urmtoare sunt apelate de operatorul de scriere __
set#ase(int)e
setfill(c*ar)e
setprecision(int)e
setC(int)e
Funcia set#ase(int) indic #aza n care %a fi afi(at un numr ntre8, >, 10 sau 1?. Funcia
setfill(c*ar) indic un caracter cu care se umplu spaiile unui camp. 5aloarea implicit a
acestui manipulator este spaiul. Funcia setprecision(int) d numrul de cifre cu care este
scris un numr real. Funcia setC(int) d dimensiunea campului n caractere pe care este
scris un numr. 5aloarea implicit a acestui manipulator este 0. .ac dimensiunea
campului nu este specificat, sau este prea mic, numrul este scris pe c9te caractere este
necesar.
int + 0 21e
Va#loul urmtor prezint e+emple de utilizare a funciilor.
cout __ setC(3) __ +e 21
cout __ +e 21
cout __ set#ase(1?) __ +! 1)
cout __ dec __ setC(1) __ setfill(Y7f) __ +e 721
float z 0 12.?2e
Va#loul urmtor prezint e+emple de utilizare a funciilor.
cout __ setprecision(1) __ ze 12.?
cout __ setC(>) __ ze 12.?2
cout __ setC(>) __ setfill(Y7f) __ ze 77712.?2
cout __ setC(13) __ scientific __ ze 1.2?2000eJ001
enionm c dimensiunea campului prescris de funcia setC(int) se aplic doar
urmtorului numr de scris. -eilali manipulatori rman la %aloarea prescris pan sunt
modificai.
2.12 1uncia main
Krice pro8ram scris n lim#aNele - sau -JJ se compune din funcii care se apeleaz unele
pe altele. .efiniia unei funcii este
tip nume (lista de parametri)
:
instruciuni
<
Una din funcii are numele main iar e+ecuia pro8ramului ncepe cu aceast funcie.
Arototipul acestei funcii este
int main()e
6emnificaia prototipului este urmtoarea. Funcia main are ca rezultat o %aloare ntrea8
care este codul de terminare a pro8ramului (i nu are parametri. -orpul funciei este o
instruciune compus, adic o sec%en de instruciuni scrise ntre accolade, : (i <.
Aro8ramul poate conine comentarii. -omentariile plasate ntre delimitatorii M7 (i 7M se pot
ntinde pe mai multe linii. -omentariile ce ncep cu caracterele MM se ntind pe o sin8ur
linie. Autem scrie acum primul pro8ram care cite(te o %aloare ntrea8 de la tastatur (i
afi(eaz ptratul ei.
T include _iostream.*"
int main()
:
int i, Ne
cout __ Sintroduceti o %aloare intrea8ag __ endle
M7 se citeste o %aloare intrea8a 7M
cin "" ie
cout __ S%aloarea introdusa este S __ i __ endle
M7 se calculeaza patratul %alorii citite 7M
N 0 i 7 ie
M7 se scrie %aloarea calculata 7M
cout __ Spatratul %alorii este S __ N __ endle
return 0e
<
enionm c funcia main() returneaz %aloarea 0 cu instruciunea
return 0e
Autem include #i#lioteca cu prototipurile funciilor intrareMie(ie ca
T include _iostream"
In #i#lioteca _iostream" prototipurile funciilor intrareMie(ire sunt 8rupate in spaiul de
nume std.
2.13 +!ecuia unui program
Arima etap este compilarea pro8ramului. In aceast etap pro8ramul este
%erificat pentru erori sintactice. .ac pro8ramul nu conine erori sintactice
compilatorul 8enereaz un pro8ram o#iect traduc9nd fiecare instruciune a
pro8ramului ntrEo serie de instruciuni elementare ale calculatorului.
/tapa a doua este editarea le8turilor. In aceast etap sunt ata(ate pro8ramului
funciile din #i#lioteci. $tunci c9nd compilatorul ntalne(te un apel de funcie (de
e+emplu sin, cos, etc.), sau o operaie intrareMie(ire, el 8enereaz doar o sec%en
de apel la funcie. Funciile respecti%e sunt compilate n #i#lioteci speciale.
Aro8ramul editor de le8turi ata(eaz aceste funcii pro8ramului o#iect.
Aro8ramul 8enerat de editorul de le8turi se nume(te pro8ram e+ecuta#il. /l este
un fi(ier cu e+tensia e+e.
In etapa a treia pro8ramul e+cuta#il este ncrcat n memorie (i e+ecutat.
2.14 &peratorul sizeof
Kperatorul sizeof se aplic asupra unei e+presii sau asupra unui tip (i are ca rezultat
numrul de octei de memorie utilizai. .e e+emplu, e+presia
sizeof(int)
are ca rezultat %aloarea 2. In cazul unui ta#lou rezultatul este numrul total de octei
ocupat de ta#lou.
/+emplu. 5om scrie un pro8ram care s afi(eze numrul de octei utilizai pentru
memorarea tipurilor fundamentale. Aentru a afi(a datele deplasate la st9n8a cu un numr
de spaii %om scrie un caracter ta#, YOtf.
int main()
:
float aG10H, #e
cout __ S4umarul de octeti utilizati!g __ endle
MM scrie dimensiunea tipurilor standard
cout __ YOtint! f __ sizeof(int) __ endle
cout __ YOtc*ar! f __ sizeof(c*ar) __ endle
cout __ YOtfloat! f __ sizeof(float) __ endle
cout __ YOtdou#le! f __ sizeof(dou#le) __ endle
MM scrie dimensiunea unui %ector
cout __ YOt%ectorul float aG10H! f __ sizeof(a) __ endle
MM scrie dimensiunea rezultatului unei e+presii
cout __ YOt e+presief __ sizeof(aG0HJ #) __ YOnfe
<
enionm c este ec*i%alent dac n instruciunea cout utilizm caracterul YOnf, sau endl,
sau (irul de caractere SOng.
2.14 &peratorii 22 i 3 3
Kperatorul JJ incrementeaz o %aria#il ntrea8 cu unu, operatorul E E decrementeaz o
%aria#il ntrea8 cu unu. $ce(ti operatori pot fi prefi+, adic putem scrie
JJ+, EE+
sau postfi+
+JJ, +E E
-azul operatorilor prefi+, JJ+, EE+. 6e incrementeaz sau decrementeaz %aloarea
%aria#ilei cu unu, %aloarea incrementat sau decrementat fiind (i rezultatul
e+presiei.
/+emplu. Fie declaraia de %aria#ile
int i 0 1, +e
Instruciunea
+ 0 JJie
reprezint scrierea prescurtat a sec%enei de instruciuni
i 0 i J 1e
+ 0 ie
.up e+ecuia instruciunii + 0 JJi %aria#ilele au %alorile i 0 2 (i + 0 2.
/+emplu. Fie declaraia de %aria#ile
int N 0 1, We
Instruciunea
W 0 EENe
reprezint scrierea prescurtat a sec%enei de instruciuni
N 0 N L 1e
W 0 Ne
.up e+ecuia instruciunii %aria#ilele au %alorile N 0 2 (i W 0 2.
/+emplu. Fie urmtoarele declaraii.
float aG2H 0 :1.2, E3, >, 1<e
float re
int i 0 1, W 0 1e
6ec%ena de instruciuni
i 0 i J1e
r 0 aGiHe
se poate scrie
r 0 aGJJiHe
/+presia JJi este e%aluat la 2, iar r prime(te %aloarea aG2H 0 >.
6ec%ena de instruciuni
W 0 W L 1e
r 0 aGWHe
se poate scrie
r 0 aGEEWHe
. /+presia EEW este e%aluat la 0 iar r prime(te %aloarea aG0H 0 1.2
-azul operatorilor postfi+, +JJ, +EE. 5aloarea e+presiei este c*iar %aloarea
%aria#ilei (neincrementate sau decrementate). 6e incrementeaz M decrementeaz
apoi %aria#ila.
/+emplu. Fie cele dou sec%ene de instruciuni de mai Nos
int a, #e
# 0 1e
a 0 #JJe
/+presia
a 0 #JJe
corespunde sec%enei de instruciuni
a 0 #e
# 0 # J 1e
In consecin, e+presia #JJ are %aloarea 1 (valoarea neincrementat9 a
variabilei) (i apoi se incrementeaz #. $%em rezultatul
a 0 1
# 0 2
/+emplu. Fie cele dou sec%ene de instruciuni de mai Nos
int ie int Ne
dou#le +G2H 0 :2.2e1, 12.2, E1.1 0<e dou#le +G2H 0 :2.2e1, 12.2, E1.1 0<e
dou#le de dou#le de
i 0 1e N 0 1e
d 0 +GiJJHe d 0 +GJJNHe
In primul caz instruciunea
d 0 +GiJJHe
d 0 +GiHe
i 0 i J 1e
/+presia iJJ are %aloarea 1 (i apoi se incrementeaz i. $%em deci
d 0 12.2
(i
i 0 2
In al doilea caz instruciunea
d 0 +GJJNHe
N 0 N J 1e
d 0 +GNHe
In consecin e+presia JJN are %aloarea 2 (i a%em
d 0 E1.1
(i
N 0 2
$lte e+emple de utilizare a acestor operatori %or fi prezentate ulterior.
2.14 &peraii cu numere ntregi la nivel #e bit
2.14.1 &peratori #e #epasare
.eplasarea la st9n8a, respecti% dreapta, a unui ntre8 cu un #it reprezint nmulirea,
respecti% mprirea, acelui numr cu doi.
Kperatorii de deplasare a unui numr ntre8 cu un numr de #ii sunt __ pentru depasare
la st9n8a (i "" pentru depasare la dreapta. /+presia de deplasare a unui numr ntre8 are
forma
=ezultatul e+presiei din st9n8a este confi8uraia de #ii ce %a fi deplasat. /+presia din
dreapta d numrul de #ii cu care se face deplasarea. .eplasarea se face dup re8ulile
deplasrii numerelor #inare cu semn. (Ia deplasarea la dreapta se propa8 #itul de semn,
la deplasarea la st9n8a se adau8 zerouri). .ac e+presia de deplasat este de tipul
unsigne# #iii adu8ai sunt zerouri.
/+emple. Fie instruciunile de mai Nos
int a 0 0+ffe int a 0 0+ffe
int #e int #e
# 0 a __ 2e # 0 a "" 2e
4umrul a reprezentat pe patru octei are %aloarea *e+azecimal
a 0 000000ff
4umrul deplasat la st9n8a cu 2 #ii este
00000ff0
iar deplasat la dreapta cu 2 #ii este
0000000f
4umrul 0+ff con%ertit n zecimal este 233. -are este %aloarea numerelor 0+f (i 0+ff0 n
zecimalc.
-a un alt e+emplu, s definim constantele D, [, ] (i = care s ai#e %alorile 1, 2, 2, >,
folosind instruciunea enum.
enum :D 0 1, [ 0 D __ 1, ] 0 [ __ 1, = 0 D __ 1<e
Iim#aNele - (i -JJ au operatorii de atri#uire __0 (i ""0 care realizeaz operaiile
urmtoare. Instruciunile
+ 0 + __ n
(i
+ 0 + "" n
se scriu
+ __0 n
(i respecti%
+ "" n
5om nc*eia acest para8raf cu un pro8ram care deplaseaz numere ntre8i (i le afi(az
%aloarea in zecimal (i *e+azecimal. Aentru scrierea sau citirea unui numr ntre8 n
instruciunile cout sau cin n diferite #aze se utilizeaz manipulatorii
7e! pentru #aza 1?
#ec pentru #aza 10
oct pentru #aza >
Ia nceperea e+ecuiei unui pro8ram implicit este #aza 10.
5om e+emplifica utilizarea operatorilor de deplasare (i %om afi(a rezultatele n #aza 1?.
M7 uitlizarea operatori de deplasare 7M
int main()
:
int a 0 10e
cout __ Sa 0 S __ dec __ a __ S S __ *e+ __ a __ endle
MM deplaseaz %aria#ila a la stan8a cu un #it
a 0 a __ 1e
cout __ Sa deplasat la stan8a cu 1 #it 0 S
__ dec __ a __ S S __ *e+ __ a __ endle
int # 0 30e
cout __ S# 0 S __ dec __ # __ S S __ *e+ __ # __ endle
MM deplaseaz %aria#ila # la dreapta cu 1 pozitii
# 0 # "" 1e
cout __ S# deplasat la dreapta cu 1 #iti 0 S
__ dec __ # __ S S __ *e+ __ # __ endle
return 0e
<
2.14.2 &peraii logice la nivel #e bit
Iim#aNele - (i -JJ au urmtorii operatori pentru operaii lo8ice la ni%el de #it
(i lo8ic (and) notat X
sau lo8ic (or) notat `
sau e+cusi% (+or) notat a
complement fa de unu notat b
$ce(ti operatori se definesc cu ta#elele urmtoare
a # aX# a`# aa#
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 0
a ba
0 1
1 0
Kperatorii X, ` a sunt operatori #inar@, b este operator unar. /+presiile cu operatori lo8ici
la ni%el de #it au formele urmtoare
/+emple. Fie urmtoarea sec%en de pro8ram
int a, #, c, d, ee
a 0 0+f000e
# 0 0+a#cde
c 0 a X #e
d 0 a ` #e
e 0 a a #e
=ezultatele sunt
c 0 0+a000
d 0 0+f#cd
e 0 0+3#cd
In primul caz, pentru a calcula c 0 a X # a%em de calculat
0+f X 0+a 0 0+a
conform sc*emei de mai Nos.
0 1 0 1
0 1 0 1
X 1 1 1 1
Aentru a calcula e 0 a a # tre#uie s calculm
0+f a 0+a 0 0+3
conform sc*emei de mai Nos
1 0 1 0
0 1 0 1
a 1 1 1 1
/+presia ba are %aloarea 0+0fff. .e cec
Iim#aNele - (i -JJ au operatorii X0, `0 (i a0 pentru scrierea prescurtat a instruciunilor
de atri#uire. .e e+emplu e+presia
+ 0 + X a
6e scrie prescurtat
+ X0 a
enionm c operatorii __, "", X, ` (i b sunt operatori aritmetici.
/+emplu. Fie %aria#ila ntrea8 a 0 0+?d#c. 5rem ca n %aria#ila ntrea8 # s selectm
ultimul octet al %aria#ilei a (i apoi ultimii 10 #ii ai %aria#ilei a. 6electarea unui numr de
#ii dintrEun (a#lon se face definind un (ir de #ii numit masc (i efectu9nd operaia X
ntre %aria#ila iniial (i masc.
int main()
:
int a 0 0+?d#c, #e
cout __ Sa 0 S __ *e+ __ a __ endle
MM selecteaza ultimul octet
# 0 a X 0+ffe
cout __ S# 0 S __ *e+ __ # __ endle
# 0 a X 0+1ffe
MM selecteaza ultimii 10 #iti
cout __ S# 0 S __ *e+ __ # __ endle
return 0e
<
6 se e+plice de ce n cazul al doilea masca este 0+1ffe
-ap. 1 4tructuri #e control fun#amentale
3.1 5lgoritme
Aro8ramele reprezint formulri concrete ale unor al8oritme ce prelucreaz structuri de
date. Un al8oritm este format dintrEun (ir finit de aciuni #ine definite (i neam#i8ue
pentru rezol%area unei pro#leme. Fiecare aciune tre#uie s poat fi e+ecutat ntrEun
inter%al finit de timp.
Krice al8oritm se poate descompune ntrEun numr finit de etape. /l poate fi reprezentat
printrEun (ir de aciuni astfel ncat efectul 8eneral al acestor aciuni s conduc la
rezultatul dorit al calculului.
In cazul cel mai simplu un al8oritm poate fi descompus ntrEun numr de aciuni
sec%eniale care se reprezint n felul urmtor
s1e s2e & sne
Aentru e+ecutarea unei aciuni n funcie de ndeplinirea unei condiii a%em operatori
condiionali
Kperatorul if cu formele
if condiie s1e
sau
if condiie s1e else s2e
condiie este o e+presie #oolean care are %aloarea ad%rat sau fals. $ciunea s1
se e+ecut c9nd condiie are %aloarea ade%rat.
Kperatorul s6itc7 este 8eneralizarea operatorului if
sCitc*(i)
i 0 1! s1e
i 0 2! s2e
&&&..
i 0 n! sne
In funcie de %aloarea lui i se e+ecut una dintre aciunile s1, s2, &, sn.
$ce(ti operatori se caracterizeaz prin faptul c au o sin8ur intrare (i o sin8ur ie(ire.
Fiecare operator este interpretat n (irul de calcule ca o sin8ur aciune, indifferent de
coninutul su. Kperatorii anteriori sunt suficieni pentru a descrie clasele de calcule ce se
pot descompune ntrEun numr cunoscut de aciuni.
Aentru a descrie calculele repetate c9nd numrul de aciuni nu este cunoscut e+ist
operatorii C*ile (i do.
Kperatorul 67ile are forma
C*ile condiie
se
$ciunea s se e+ecut atata timp cat e+presia #oolean condiie are %aloarea
ade%rat.
Kperatorul #o are forma
do
se
C*ile condiie
6i n acest caz aciunea s se e+ecut at9ta timp cat condiie are %aloarea ade%rat.
enionm c n cazul operatorului do aciunea s se e+ecut cel puin o dat, n
timp ce pentru operatorul C*ile este posi#il ca aciunea s s nu se e+ecute
niciodat.
Kperatorul for se utilizeaz atunci c9nd numrul de e+ecuii ale unei aciuni este
dinainte cunoscut. Kperatorul are o %aria#il de control ce se poate modifica la
fiecare iteraie. Forma acestui operator este
for i 0 instruciune1e condiiee instruciune2
se
Kperatorul include o instruciune1 ce specific %aloarea iniial a %aria#ilei de
control, (i o instruciune2 ce poate modifica %aloarea %aria#ilei de control dup
fiecare iteraie. $ciunea s se e+ecut at9t timp c9t e+presia #oolean condiie are
%aloarea ade%rat. Kperatorul for este ec*i%alent cu urmtoarele instruciuni
instruciune1e
C*ile(condiie)
se
instruciune2e
enionm c testul condiiei se face nainte de e+ecuia aciunii s.
Kperatorii prezentai se numesc structuri de control fundamentale. In construcia unui
pro8ram structurile de control (i structurile de date sunt insepara#ile. 6tructurile
fundamentale de date sunt
6tructuri simple! numere ntre8i, reale, caractere.
6tructuri comple+e ta#louri, fi(iere.
Va#lourile au un numr cunoscut de elemente. /le se prelucreaz de re8ul cu operatorul
for. Fi(ierele sec%eniale au un numr de elemente necunoscut n a%ans. /le se
prelucreaz de re8ul cu operatorul C*ile.
3.2 +!presii relaionale
Kperatorii relaionali ai lim#aNelor - (i -JJ sunt
_, _0, ", "0
0 0, P0
K e+presie relaional are urmtoarea form
=ezultatul e%alurii unei e+presii relaionale este fals sau ade%rat. Arioritile
operatorilor aritmetici sunt mai mari dect ale operatorilor relaionali.
/+emple. Fie urmtoarele instruciuni de atri#uire
int a 0 2, # 0 1, c 0 ?e
In ta#ela de mai Nos sunt prezentate e+emple de e+presii relaionale (i rezultatul e%alurii
lor.
/+presie relaional 5aloare
a7# "0 c Vrue
#J2 " a 7c False
aJ# 0 0 1 False
a P0 # Vrue
#Ma 0 0 1 Vrue
=eamintim c n lim#aNul -JJ %aloarea true este reprezentat prin 1 iar %aloarea false
prin 0. Fie urmtoarea instruciune de declarare a unei %aria#ile de tip #ool
#ool re
Autem a%ea urmtoarele instruciuni de atri#uire
r 0 a J # 0 0 ce
r 0 a L # "0 2e
r 0 a 7 a P0 E#e
5aria#ila r poate a%ea %alori #ooleene, true sau false.
3.3 +!presii booleene
Kperatorii #ooleeni ai lim#aNelor - (i -JJ sunt
P
XX
` `
care reprezint operatorii not, and (i respecti% or. Kperatorul not este operator unar.
$ce(ti operatori se definesc folosind ta#elele de ade%r.
+ @ + XX @ + ` ` @
false false false false
false true false Vrue
true false false Vrue
true true false Vrue
+ P+
false true
true false
=ezultatul e%alurii unei e+presii #ooleene este true sau false. In cursurile de lo8ic
operatorii #ooleeni se noteaz astfel
or
and
not
/+emple de e+presii #ooleene (i scrierea lor sunt prezentate mai Nos.
) `` X( X ) (
``P P
`` X X
) `` ( P ) (
X X
c b a c b a
b a b a
c b a c b a
b a b a
b a b a

Pentru scrierea simpl9 a e!presiilor booleene sunt importante #ou9 teoreme numite
legile lui De%organ
b a b a
b a b a

) (
) (
care se #emonstreaz9 cu a@utorul tabelelor #e a#ev9r.
In final menionm c operatorii #ooleeni and (i or sunt
-omutati%i
a b b a
a b b a

asociati%i la st9n8a
c b a c b a
c b a c b a

) (
) (
distri#uti%i
) ( ) ( ) (
) ( ) ( ) (
c a b a c b a
c a b a c b a

In final prezentm prioritatea (precedena) (i asociati%itatea operatorilor
Kperator asociati%itate
G H ( ) st9n8a
JJ EE J E P b sizeof dreapta
7 M ; st9n8a
J E st9n8a
__ "" st9n8a
_ _0 " "0 st9n8a
0 0 P0 st9n8a
X st9n8a
a st9n8a
` st9n8a
XX st9n8a
` ` st9n8a
0 J0 E0 70 M0 ;0 st9n8a
3.4 &peratorul #o367ile
$cest operator este definit de dia8rama sintactic
#o
instruciune
67ile(e+presie)e
Instruciunea se e+ecut at9ta timp c9t e+presia este diferit de zero. Instruciunea din
dia8rama sintactic este o sec%en de instruciuni.
-a e+emplu %om calcula %aloarea 3P.
3
1
P 3
i
i
5om utiliza o %aria#il n pus iniial la %aloarea 1 (i %om e+ecuta repetat instruciunea
n 0 n 7 i
pentru i lu9nd %alori de la 1 la 3. Aro8ramul pseudocod este urmtorul.
n 0 1e
i 0 1
do
n 0 n 7 ie
i 0 i J 1e
C*ile(i _ ?)
Aro8ramul corespunztor este urmtorul
M7 calculul %alorii 3P 7M
int main()
:
int i, ne
i 0 1e
n 0 1e
do
n 0 n 7 ie
i 0 i J 1e
C*ile(i _ ?)e
cout __ S3P are %aloarea S __ n __ endle
return 0e
<
Autem rescrie partea de calcul din pro8ram astfel
int i 0 1, n 0 1e
do
n 70 ie
iJJe
C*ile(i _ ?)e
sau
int i 0 1, n 0 1e
do
n 70iJJe
C*ile(i _ ?)e
=eamintim c instruciunea
n 70 iJJe
este ec*i%alent cu instruciunile
n 70 ie
iJJe
conform modului de e+ecuie a operatorului postfi+ JJ ! %aloarea e+presiei este c*iar
%aloarea %aria#ilei i neincrementate, dup care %aria#ila i este incrementat.
3.( &peratorul 67ile
Forma operatorului 67ile este cea din dia8rama de mai Nos
C*ile(e+presie)
instruciune
instruciunea se e+ecut at9ta timp c9t e+presia este diferit de zero. Instruciunea din
dia8rama sintactic poate fi o instruciune compus, format dintrEo sec%en de
instruciuni cuprinse ntre acolade, : (i <.
5om e+emplifica utilizarea acestui operator calcul9nd suma elementelor unui %ector a cu
2 componente. /lementele %ectorului a au indicii 0, 1, 2 (i 1.
1
0 i
i
a s
5om utilize o %aria#il f de tip float pentru a calcula suma, care %a fi pus iniial la
%aloarea zero (i %om e+ecuta repetat instruciunea
i
a s s +
pentru i lu9nd %alori de la 0 la 1. Aro8ramul pseudocod este urmtorul.
s 0 0e
i 0 0e
C*ile(i _ 2)
s 0 s J aGiHe
i 0 i J 1e
Aro8ramul este urmtorul
Tinclude _iostream.*"
M7 calculul sumei componentelor unui %ector 7M
int main()
:
float aG2H 0 :2.12, E).12, 2.3eE1, )1<e
int ie
float se
s 0 0e
i 0 0e
C*ile(i _ 2)
:
s 0 s J aGiHe
i 0 i J 1e
<
cout __ Ssuma componentelor este S __ s __ endle
return 0e
<
Autem rescrie partea de calcul din pro8ram astfel
s 0 0e
i 0 0e
C*ile(i _ 2)
:
s J0 aGiHe
iJJe
<
sau
s 0 0e
i 0 0e
C*ile(i _ 2)
:
s J0 aGiJJHe
<
3.) &peratorul for
Kperatorul for are forma
for(e+presie1e e+presie2e e+presie1)
instruciune
Kperatorul poate conine %aria#ile de control ce sunt modificate dup fiecare iteraie.
Kperatorul for e+ecut repetat o instruciune, at9t timp c9t e+presie2 este diferit de zero.
e+presie1 are rolul de a iniializa %aria#ile de control. e+presie1 are rolul de a modifica
%aloarea %aria#ilelor de control. Instruciunea din dia8rama sintactic poate fi o
instruciune compus constand dintrEo sec%en de instruciuni ntre acolade, : (i <.
-a e+emplu %om calcula %aloarea e+presiei x e
x
7 2 + pentru + cuprins ntre unu (i doi cu
pasul 0.2. Aro8ramul pseudocod este urmtorul
for i 0 0e i _?e i 0 i J 1
+ 0 1 J 0.2 7 i
@ 0 x e
x
7 2 +
T include _mat*.*"
int main()
:
int ie
float +, @
cout __ S+g __ YOtf __ S@g __ endle
for(i 0 0e i _ ?e i 0 i J 1)
:
+ 0 1 J 0.2 7 ie
@ 0 e+p(+) J 2 7 + J sRrt(+)e
cout __ + __ YOtf __ @ __ endle
<
return 0e
<
5rem ca rezultatul s fie afi(at n dou coloane cu antetul + (i @. Aentru aceasta utilizm
instruciunea
__ S+g __ YOtf __ S@g __ endle
care scrie caracterele + (i @ separate de caracterul YOtf (ta#). In pro8ram rezultatele sunt
scrise de asemenea separate de ta#.
enionm c instruciunea for se putea scrie astfel
for(i 0 0e i _ ?e iJJ)
sau
for(i 0 0e i _ ?e JJi)
Un alt mod de a calcula %alorile e+presiei de mai sus este urmtorul.
T include _mat*.*"
int main()
:
float +, @
cout __ S+g __ YOtf __ S@g __ endle
for(+ 0 1.0e + _0 2.0e + 0 + J 0.2)
:
@ 0 e+p(+) J 2 7 + J sRrt(+)e
cout __ + __ YOtf __ @ __ endle
<
return 0e
<
5om nc*eia acest para8raf cu un pro8ram care s calculeze suma a doi %ectori.
M7 calculul sumei a doi %ectori 7M
int main()
:
float +G1H 0 :1.1eJ1, E2.3), 11.2<e
float @G1H 0 :E2.12, 11.3, 1.21<e
float zG1He
for(int i 0 0e i _ 1e iJJ)
zGiH 0 +GiH J @GiHe
cout __ zGiH __ YOtfe
cout __ YOnfe
return 0e
<
In final menionm instruciunile breaI (i continue. Instruciunea breaI produce ie(irea
imediat din instruciunile for, C*ile sau doEC*ile. Instruciunea continue trece la
urmtoarea iteraie a instruciunii for, C*ile sau doEC*ile.
3.* &peratorul if
$cest operator e+ecut o anumit instruciune n funcie dac o anumit condiie este
ndeplinit. Forma operatorului if este
if(e+presie)
instruciune1e
else
instruciune2e
.ac e+presie este diferit de zero se e+ecut instruciune1 altfel instruciune2.
Instruciunile din dia8rama sintactic pot fi instruciuni compuse.
5om e+emplifica utilizarea acestui operator calcul9nd suma componentelor pare (i
impare ale unui %ector + cu (ase elemente. Aro8ramul pseudocod este urmtorul
s1 0 0e
s2 0 0e
for i 0 0e i _ ?e i0iJ1
if i ; 2 0 0 0
s1 0 s1 J i
x
else
s2 0 s2 J i
x
M7 calculul sumei componentelor pare si impare ale unui %ector 7M
int main()
:
float s1 0 0, s2 0 0e
int ie
float +G10H 0 :1, E12, 21.2, 0.22, 1.2, E2.1<e
for(i 0 0e i _ ?e i 0 i J 1)
if(i ; 2 0 0 0)
s1 0 s1 J +GiHe
else
s2 0 s2 J +GiHe
cout __ Ssuma elementelor pare este S __ s1 __ endl
__ Ssuma elementelor impare este S __ s2 __ endle
return 0e
<
enionm c o instruciune if poate conine alte instruciuni if. .e e+emplu putem a%ea
instruciunea compus
if (e1) if (e2)
s1
else
s2
else if(e1)
s1
else
s2
unde e1, e2, e1 sunt e+presii #ooleene. .ac e+presia #oolean e1 are %aloarea ade%rat,
(este diferit se zero), se e+ecut instruciunea if(e2), n caz contrar se e+ecut
instruciunea if(e1).
3., &peratorul 8
$cest operator este o form simplificat a operatorului if. Forma lui este
e+presie 8 instruciune1 D instruciune2e
.ac e+presie are o %aloare diferit de zero se e+ecut instruciune1 altfel instruciune2.
5om rescrie pro8ramul anterior astfel
M7 calculul sumei componentelor pare si impare ale unui %ector 7M
int main()
:
float s1 0 0, s2 0 0e
int ie
float +G10H 0 :1, E12, 21.2, 0.22, 1.2, E2.1<e
for(i 0 0e i _ ?e i 0 i J 1)
i ; 2 0 0 0 c s1 0 s1 J +GiH ! s2 0 s2 J +GiHe
cout __ Ssuma elementelor pare este S __ s1 __ endl
__ Ssuma elementelor impare este S __ s2 __ endle
return 0e
<
3.- &peratorul s6itc7
$cest operator e+ecut o instruciune din mai multe posi#ile. Fiecare instruciune este
etic*etat cu o constant ntrea8. Instruciunea conine o e+presie ntrea8 ce determin
ce etic*et tre#uie aleas.
s6itc7(e+presie)
:
case e+pint! instructiune
&.
<
Una dintre etic*ete poate fi #efault. In acest caz, dac e+presia din instruciunea sCitc*
nu are nici una din %alorile etic*etelor din instruciunile case, se trece la e+ecuia
instruciunilor cu etic*eta default.
Instruciunea breaI este utilizat pentru ie(irea din instruciunea sCitc*.
/+emplu. 5om citi dou numere ntre8i (i un operator J, E, 7, M sau ; (i %om calcula
rezultatul operaiei corespunztoare.
int main()
:
int +, @e
c*ar opere
cout __ Sintoduceti doi intre8i ! ge
cin "" + "" @e
cout __ Sintroduceti un operator ! Se
cin "" opere
sCitc*(oper)
:
case YJf !
cout __ + J @e
#reaWe
case YEY !
cout __ + L @e
#reaWe
case Y7f !
cout __ + 7 @e
#reaWe
case YMf !
cout __ + M @e
#reaWe
case Y;f !
cout __ + ; @e
#reaWe
default !
cout __ Seroarege
#reaWe
<
return 0e
<
enionm c instruciunile corespunztoare etic*etelor sunt urmate de instruciunea
#reaW ce asi8ur ie(irea din operatorul sCitc*.
3.1/ &peratorul ,
Kperatorul , are urmtoarea form
e+presie1, e+presie2
=ezultatul operatorului , este e+presie2, rezultatul e%alurii e+presie1 se ne8liNaz.
Kperatorul , se poate utiliza oriunde lim#aNul admite o sin8ur e+presie, dar sunt necesare
dou e+presii.
-ap. 2 1uncii
4.1 Definirea funciilor
Funciile se definesc ntrEun pro8ram atunci c9nd un 8rup de instruciuni se utilizeaz n
mai multe locuri din pro8ram. Arototipul definiiei unei funcii este
tip nume (lista de parametri)
instruciune
Instruciunea este o instruciune compus format dintrEo sec%en de instruciuni ntre
acolade. Iista de parametri are forma
tip1 ar81, tip2 ar82, &, tipn ar8n
unde tip1, tip2, &, tipn reprezint tipurile parametrilor ar81, ar82, &, ar8n. Aarametrii
din definiia funciei se numesc parametri formali. K parte din parametri sunt %aria#ile ce
%or fi prelucrate de funcie (ace(ti parametri se numesc parametri de intrare). K funcie
poate calcula o %aloare asociat numelui (i mai multe %alori asociate unor parametri
(ace(ti parametri se numesc parametri de ie(ire). Vipul %alorii asociate numelui este (i
tipul funciei. .ac o funcie nu are o %aloare asociat numelui, tipul ei este voi#.
$socierea unei %alori calculate numelui funciei se face cu instruciunea return cu forma
urmtoare
return e+presiee
unde e+presie este %aloarea calculat. -9nd tipul funciei este %oid, se utilizeaz
instruciunea
returne
1unciile sunt recursive, a#ic9 o funcie se poate apela pe ea ns9i.
5pelarea unei funcii se face utiliz9n#3o ca termen ntr3o e!presie. Parametri #e
apelare a funciei se numesc parametri actuali. Parametrii #e intrare actuali ai unei
funcii pot fi orice constante, variabile sau e!presii. Parametrii actuali #e ieire sunt
variabile.
/+emplu. 5om scrie o funcie care s calculeze suma componentelor unui %ector cu
elemente numere reale. Aarametrii funciei %or fi %ectorul (i dimensiunea sa. =ezultatul
este o %aloare real ata(at numelui funciei.
M7 funcie ce calculeaza suma componentelor unui %ector
Aarametri de intrare
a L %ector
n L dimensiunea %ectorului a
7M
float suma(float aGH, int n)
:
int ie
float s 0 0e
MM calculeaza suma componentelor
for (i 0 0e i _ ne i 0 iJJ)
s 0 s J aGiHe
return se
<
int main()
:
float +G3H 0 :11.1, E2.?), 0.12, E2.3, 12<e
float ze
z 0 suma(+, 3)e
MM scrie componentele %ectorului
cout __ Ssuma componentelor %ectorului S __ endle
for(i 0 0, i _ 3e iJJ)
cout __ +GiH __ SOtge
cout __ endle
MM scrie rezultatul
cout __ Seste S __ z __ endle
<
-omponentele %ectorului sunt scrise separate de caracterul ta# pe un r9nd iar rezultatul pe
r9ndul urmtor. In e+emplul anterior definiia funciei este scris nainte de utilizarea ei n
funcia main. enionm c este posi#il de a scrie definiia unei funcii dup ce ea este
utilizat. In acest caz tre#uie s scriem nainte de prima utilizare un (a#lon al funciei.
ha#lonul unei funcii are urmtoarea definiie
tip nume(lista de parametri)e
Aentru e+emplul anterior (a#lonul poate fi
float suma(float aGH, int n)e
sau
float suma(float GH, int)e
In (a#lon putem s identificm doar tipurile parametrilor.
.ntr3un program putem avea mai multe funcii cu acelai nume #ar cu parametri
#iferii sau cu un num9r #e parametri #iferit. 5cest lucru se numete
supranc9rcarea funciilor.
4.2 Pasarea parametrilor funciilor
Ia apelarea unei funcii, parametrii actuali (i %aria#ilele locale ale funciei sunt memorate
ntrEo sti%. /+ist dou moduri de a pasa paremetrii unei funcii! prin %aloare (i prin
referin (adres). In cazul pasrii unui parametru prin %aloare, n sti% se pune c*iar
%aloarea parametrului, n cazul pasrii prin adres n sti% se pune adresa parametrului.
-azul parametrilor pasai prin %aloare. .ac n corpul funciei modificm ace(ti
parametri, %aloarea lor se modific doar n sti% (i nu n pro8ramul apelant. In
consecin, parametrii pasai prin valoare nu pot fi parametri #e ieire ai
funciei.
-azul parametrilor pasai prin referin. .ac n corpul funciei modificm ace(ti
parametri, %aloarea lor se modific n pro8ramul apelant (n sti% este adresa
acestor parametri). In consecin, pentru ca un parametru al unei funcii s fie
parametru de ie(ire, el tre#uie pasat prin adres
Aentru a %edea care este diferena ntre cele dou moduri considerm o funciei care s
permute %aloarea a dou %aria#ile de tip ntre8. & variant9 necorect9 este urm9toarea
%oid perm(int a, int #)
:
int ce
c 0 ae
a 0 #e
# 0 ce
returne
<
int main()
:
int + 0 ), @ 0 12e
cout __ S%aloarile initiale + 0 S __ + __ S @ 0 S __ @ __ endle
perm(+, @)e
cout __ S%aloarile permutate + 0 S __ + __ S @ 0 S __ @ __ endle
<
In am#ele cazuri se tipre(te aceea(i %aloare, + 0 ) (i @ 0 12. oti%ul este acela c
parametrii fiind pasai prin %aloare, n funcie instruciunile
a0 #e
# 0 ce
modific %aloarea lor doar n sti%a (i nu n pro8ramul apelant. In consecin, parametrii
pasai prin valoare nu pot fi parametri #e ieire ai funciei. Aentru ca un parametru al
unei funcii s fie parametru de ie(ire, el tre#uie pasat prin referin (adres). /+ist dou
moduri de a pasa parametri prin adres! utilizarea parametrilor tip referin (i tip pointer.
=eferinele (i %aria#ilele tip pointer %or fi prezentate pe lar8 n para8raful urmtor. 5om
prezenta acum doar parametrii tip referin.
Fie un parametru de un tip " al unei funcii. =eferina la un astfel de parametru are tipul
"J. .ac un parametru este tip referin, la apelarea funciei n sti% se %a pune adresa
acestui parametru, (i atunci c9nd este modificat n corpul funciei el este modificat n
pro8ramul apelant (este parametru de ie(ire).
$arianta corect9 a funciei care permut9 valorile a #ou9 variabile este urm9toarea
M7 functie ce permute %aloarea a doua %aria#ile 7M
%oid perm(intX a, intX #)
:
int ce
c 0 ae
a 0 #e
# 0 ce
returne
<
$pelarea acestei funcii se face astfel
int main()
:
int + 0 ), @ 0 12e
cout __ S%aloarile initiale + 0 S __ + __ S @ 0 S __ @ __ endle
perm(+, @)e
cout __ S%aloarile permutate + 0 S __ + __ S @ 0 S __ @ __ endle
<
In sti% se pun de aceast dat adresele %aria#ilor + (i @ deoarece parametri funciei sunt
de tip referin. enionm c apelarea funciei se face utiliz9nd pentru parametrul
referin o %aria#il din pro8ramul apelant (nu o constant sau e+presie), n cazul nostru
perm(+,@)
5om recapitula acum diferenele ntre parametrii pasai prin %aloare (i cei pasai prin
adres (referin).
Un parametru pasat prin %aloare este un parametru de intrare. 5aloarea lui actual
este rezultatul e%alurii unei constante, %aria#ile sau e+presii n pro8ramul
apelant.
Un parametru tip referin este un parametru de ie(ire. $r8umentul pasat este o
%aria#il din pro8ramul apelant.
%enion9m c9 n cazul n care un parametru este un tablou, n stiv9 se pune a#resa
primului element al tabloului. .n consecin9, parametri formali tablouri pot fi
parametri #e ieire.
/+emplu. 5o defini o funcie ce calculeaz suma a doi %ectori + (i @ de numere reale de
dimensiune n. Vipul funciei este %oid. 5ectorul sum %a fi z.
M7
-alculul sumei a doi %ectori
+ L %ector
@ L %ector
n L dimensiunea %ectorilor +, @, z
Aarametri de iesire
z L %ector, z 0 + J @
Areconditii
Aarametri de intrare sunt initializati
7M
%oid sum%ect(dou#le +GH, dou#le @GH, dou#le zGH, int n)
:
int ie
for(i 0 0e i _ ne iJJ)
zGiH 0 +GiH J @GiHe
<
5om nc*eia acest para8raf definind o funcie care s calculeze media (i dispersia unui (ir
de numere n
x x x , ,
2 1 . 5aloarea medie a elementelor (irului este
n
i
i
x
n
m
1
1
iar dispersia
n
i
i
m x
n
d
1
2
) (
1
1
Vipul funciei %a fi %oid. edia (i dispersia %or fi asociate unor parametri de ie(ire ai
funciei. Arototipul funciei %a fi
%oid md(float +GH, int n, floatX m, floatX d)e
unde + este %ectorul de numere de dimensiune n pentru care calculm media (i dispersia.
M7
-alculul mediei si dispersiei componentelor unui %ector
+ L %ector
n L dimensiunea %ectorului +
Aarametri de iesire
m L media componentelor lui +
d L dispersia componentelor lui +
Areconditii
Aarametrii de intrare sunt initializati
7M
%oid md(float +GH, int n, floatX m, floatX d)
:
float s 0 0e
int ie
MM calculeaza media
s 0 s J +GiHe
m 0 s M ne
MM calculeaza dispersia
float d 0 0e
d 0 d J (+GiH L m) 7 (+GiH L m)e
d 0 d M (n L 1)e
returne
<
int main()
:
float aG2H 0 :1.2eE1, E2.12, 1.3, 1.11<e
float media, dispersiae
md(a, 2, media, dispersia)e
cout __ S media 0 S __ media __ S dispersia 0 S __ dispersia __ endle
<
4.3 Recursivitatea
Funciile lim#aNelor - (i -JJ sunt recursi%e. K funcie se poate apela pe ea ns(i. 5om
e+emplifica acest lucru cu o funcie care s calculeze %aloarea nP n %ariant recursi% (i
nerecursi%.
5arianta nerecursi% 5arianta recursi%
n
i
i n
1
P
'
>
1 )P 1 ( 7
1 1
P
n n n
n
n
MM calculul factorialului MM calculul factorialului
int fact(int n) int fact(int n)
: :
int s 0 1e int se
for(int i 0 1e i _0 ne JJn) if(n 0 0 1)
s 0 s 7 ie s 0 1e
return ie else
< s 0 n 7 fact(n L 1)e
return se
<
5om prezenta sti%a la apelarea %ariantei recursi%e pentru n 0 1. =eamintim c parametrul
n (i %aria#ila local s sunt memorai n sti%. .up apelul
fact(1)
sti%a este
4 0 1 6 0 c
.eoarece n este diferit de unu, se e+ecut instruciunea
6 0 n 7 fact(n L 1)
adic se apeleaz nc o dat funcia, fact(2). 6ti%a este
401 60c 402 60c
6e apeleaz nc o dat funcia, fact(1), (i sti%a este
401 60c 402 60c 401 601
.up aceast ultim apelare se aNun8e la nstruciunea return, dup care %aria#ilele
corespunz9nd ultimei apelri a funciei se ster8 din sti%. 6ti%a de%ine
401 60c 402 602
.in nou se aNun8e la instruciunea return, %aria#ilele corespunz9nd acestei apelri se
strer8 din sti%
401 60?

.up care se o#ine rezultatul final, %aloarea ?.
4.4 Kabloane #e funcii
ha#loanele ne permit s definim funcii 8enerice n care putem defini tipuri 8enerale ale
parametrilor (i a %alorii returnate de funcie. .efinirea unui (a#lon de funcie se face cu
instruciunea
template _t'pename identificator, & " declaraie de funcie
6 definim de e+emplu o funcie 8eneric pentru calculul ma+imului a dou %aria#ile
M7 functie 8enerica ce calculeaza ma+imul a doua %aria#ile 7M
template _t@pename V"
V ma+%al(V a, V #)
:
return (a " # c a ! #)e
<
$pelarea unui (a#lon de funcie se face astfel
numedfuncie _tip"(parametri)e
.e e+emplu, putem calcula ma+imul a dou numere ntre8i sau reale astfel.
int main()
:
MM ma+imul a doua numere intre8i
int a 0 13, + 0 20, ce
c 0 ma+%al_int"(a, +)e
cout __ S ma+imul dintre S __ a __ S si S __ # __ S este S __ c __ endle
MM ma+imul a doua numere reale
float fa 0 1.21, f# 0 E'.1e
cout __ Sma+imul dintre S __ fa __ S si S __ f# __ S este S
__ ma+%al_float"(fa, f#) __ endle
<
Cap. ( Pointeri i referine
In orice pro8ram compilatorul aloc oricrei %aria#ile definite n pro8ram o zon de
memorie e8al cu numrul de octei corespunz9nd tipului %aria#ilei. In cazul unui ta#lou
se aloc memorie fiecrui component al ta#loului. Fie de e+emplu instruciunea
int a, #, +G1He
-ompilatorul aloc zone de memorie %aria#ilelor ca mai Nos
-ompilatorul creaz o ta#el cu numele %aria#ilelor (i adresele lor n memorie, de
e+emplu
a 1000
# 1002
+ 100>
K instruciune de atri#uire de forma
a 0 #e
este e+ecutat astfel! se ia %aloarea de la adresa %aria#ilei a (n cazul nostru adresa 1000)
(i se pune la adresa %aria#ilei # (n cazul nostru adresa 1002). Iim#aNele - (i -JJ permit
definirea unor %aria#ile ce conin adrese ale altor %aria#ile. $cestea au tipul pointer (i
referin. .up cum %om %edea, aceste %aria#ile se utilizeaz la transmiterea parametrilor
funciilor prin adres, care pot fi parametric de ie(ire ai funciilor. Aointerii sunt utili (i la
prelucrarea ta#lourilor.
(.1 Pointeri
Un pointer este o %aria#il ce conine adresa unei alte %aria#ile. .e e+emplu, dac n este
o %aria#il de tip int, ce are %aloarea 1, iar pn este o %aria#il de tipul pointer la int, ce
conine adresa lui n, putem reprezenta cele dou %aria#ile astfel
K %aria#il de tip pointer se define(te cu instruciunea
tip 7 numee
.e e+emplu
int 7 pne
define(te o %aria#il tip pointer la int ce poate conine adresa unei %aria#ile de tip int.
Aentru a calcula adresa unei %aria#ile se utilizeaz operatorul J. .ac + este o %aria#il
oarecare, e+presia X+ este adresa lui +. 5aria#ilele tip pointer pot fi iniializate doar cu
adrese. .e e+emplu putem scrie
int ne
int 7 pne MM pn este de tipul pointer la int
pn 0 Xne MM initializeaza pn cu adresa lui n
Aentru a o#ine %aloarea %aria#ilei indicate de un pointer se utilizeaz operatorul 7 (numit
(i operator de adresare indirect).
Fie de e+emplu instruciunile
int W, n0 12e
int 7 pn, 7pWe
Instruciunile
W 0 ne
(i
pn 0 Xne
W 0 7pne
sunt ec*i%alente, W prime(te %aloarea 12. (5aria#ila pn a fost iniializat n preala#il cu
adresa lui n). Instruciunile
W 0 ne
(i
pW 0 XWe
7pW 0 ne
sunt ec*i%alente. In final, instruciunile
W 0 ne
(i
pW 0 XWe
pn 0 Xne
7pW 0 7pne
sunt ec*i%alentee
/+emplu. Fie urmtoarea sec%en de instruciuni
float +e
float 7 @e
$ doua instruciune declar c @ poate conine adresa unei %aria#ile de tip float.
Instruciunile
+ 0 1.3e
(i
@ 0 X+e
7@ 0 1.3e
sunt ec*i%alente.
/+emplu. 5om scrie o funcie care s permute %alorile a dou %aria#ile ce %or fi
parametri de ie(ire ai funciei. .e aceea ace(ti parametri %or fi %aria#ile tip pointer.
%oid perm(int7 a, int7 #)
:
int ce
c 0 7ae
7a 0 7#e
7# 0 ce
<
Utilizarea acestei funcii se face astfel
int main()
:
int + 0 1, z 0 E2e
MM scrie %aria#ilele inainte de permutare
cout __ S+ 0 S __ + __ S @ 0 S __ @ __ endle
perm(X+, X@)e
MM scrie %aria#ilele dupa permutare
cout __ S+ 0 S __ + __ S @ 0 S __ @ __ endle
<
=imba@ul C nu are referine. .n consecin9, singurul mo# #e a #eclara parametri #e
ieire ai unei funcii n limba@ul C, este ca acetia s9 fie #e tip pointer.
&peratorii L i J sunt asociativi la #reapta. &peratorii L i J sunt inveri.
/+emplu. Fie instruciunile
int a, #e
a 0 )e
Instruciunile
# 0 ae
(i
# 0 7Xae
sunt ec*i%alente.
/+emplu. 5om afi(a %aloarea unor %aria#ile tip pointer.
int main()
:
int a, #e
MM definim %aria#ile tip pointer
int 7pa, 7p#e
pa 0 Xae
p# 0 X#e
MM se scrie adresa %aria#ilei a
cout __ S adresa %aria#ilei a S __ Xa __ S S __ pa __ endle
MM se scrie %aloarea %aria#ilei #
# 0 13e
cout __ S %aloarea %aria#ilei # S __ # __ S S __ 7p# __ endle
<
Arima instruciune cout %a afi(a de dou ori accea(i adres. $ doua instruciune cout %a
afi(a de dou ori aceea(i %aloare, 13.
%enion9m c9 numele unui tablou este, prin #efiniie, un pointer la primul element
al tabloului. Fie de e+emplu instruciunile
float +G)H, 7 pfe
Un pointer la ta#loul + are %aloarea X+G0H sau + . Autem deci scrie
pf 0 X+G0He
sau, ec*i%alent,
pf 0 +e
.ac scriem
pf 0 X+G1He
pf %a conine adresa celui de al patrulea element al ta#loului. Ie8tura ntre ta#louri (i
%aria#ile tip pointer %a fi prezentat pe lar8 n para8rafele urmtoare.
/+emplu. 6 afi(m adresele elementelor unui %ector de ntre8i.
int main()
:
int +G3He
cout __ Sindice S __ i __ S adresa S __ X+GiH __ endle
return 0e
<
int +, @e
int 7 ae
int 77 #e
Instruciunea a doua declar c a poate conine adresa unei %aria#ile de tip int. $ treia
instruciune declar c # poate conine adresa unei %aria#ile de tip int L (pointer la int).
Fie instruciunea
+ 0 10e
Instruciunile
@ 0 +e
(i
a 0 X+e
@ 0 7 ae
(i respecti%
a 0 X+e
# 0 Xae
@ 0 77 #e
sunt ec*i%alente. Aentru a arta aceasta, considerm alocarea %aria#ilelor +, @, a, # n
memorie. $dresele acestor %aria#ile pot fi cele din ta#ela de mai Nos
5aria#ila $dresa n memorie -oninut
+ 1000 5aloarea 10
@ 1002 5aloarea 10
a 100> $dresa 1000
# 1012 $dresa 100>
In cazul instruciunii
@ 0 +e
la e+ecuia pro8ramului %aloarea de la adresa %aria#ilei + se depune la adresa %aria#ilei @.
/a este ec*i%alent cu instruciunile
a 0 X+e
@ 0 7 ae
5aloarea de la adresa a indic adresa unei alte %aria#ile (+ n cazul nostru, deoarece sEa
e+ecutat instruciunea a 0 X+). 6e aplic operatorul 7 asupra %aria#ilei a (i se o#ine
coninutul acestei %aria#ile care este adresa lui +. -oninutul de la aceast adres se pune
la adresa lui @. =eamintim c operatorul 7 este asociati% la dreapta.
Instruciunea anterioar este ec*i%alent (i cu instruciunile
a 0 X+e
# 0 Xae
@ 0 77#e
.up e+ecuia instruciunii
a 0 X+e
%aria#ila a conine adresa lui + dup cum sEa e+plicat mai nainte.
.up e+cuia instruciunii
# 0 Xae
%aria#ila # conine adresa lui a. Instruciunea @ 0 77# se e+ecut aplic9nd operatorul 7
asupra %aria#ilei #, rezultatul fiind %aloarea %aria#ilei #, adic adresa %aria#ilei a. 6e
aplic operatorul 7 asupra acestei %alori (ceea ce este ac*i%alent cu 7a) (i se o#ine
coninutul lui a care este adresa %aria#ilei +. 5aloarea de la adresa lui + se depune n @.
-a un ultim e+emplu considerm urmtoarele instruciuni
int +, @e
int 7ae
int 77aae
int 777aaae
int 7777aaaae
$ceste instruciuni declar c a poate conine o adres de %aria#il tip int, aa poate
conine o adres de tip int 7, aaa poate conine o adres de tip int 77, etc. 5om iniializa
pe + (i %aria#ilele tip pointer astfel!
+ 0 10e
a 0 X+e
aa 0 Xae
aaa 0 Xaae
aaaa 0 Xaaae
Instruciunile
@ 0 +e
@ 0 7ae
@ 0 77aae
@ 0 777aaae
@ 0 7777aaae
produc acela(i rezultat, adic
@ 0 10e
Instruciunile
cout __ +
cout __ 7a
cout __ 77aa
cout __ 777aaa
cout __ 7777aaaae
produc afi(area aceleia(i %alori
+ 0 10
Ia tiprirea %alorilor %aria#ilelor de tip pointer, se tipresc adresele coninute de acestea
n *e+azecimal. Instruciunile
cout __ X+ __ YOtf __ a __ endle
cout __ Xa __ YOtf __ aa __ endle
cout __ Xaa __ YOtf __ aaa __ endle
cout __ Xaaa __ YOtf __ aaaa __ endle
afi(az respecti% urmtoarele %alori!
adresa lui +
adresa lui a
adresa lui aa
adresa lui aaa
-onsiderm urmtoarele instruciuni
int +, @ 0 2e
+ 0 @e
Kperatorul 0 aplicat asupra celor doi operanzi, n cazul nostru + (i @, ia %aloarea de la
adresa corespunz9nd %aria#ilei din st9n8a (i o memoreaz (i o memoreaz la adresa
corespunztoare %aria#ilei din dreapta. In consecin, n partea st9n8 a semnului e8al
putem utiliza %alorile unor %aria#ile tip pointer.
-onsiderm urmtoarele instruciuni
int +, @e
int 7 ae
a 0 X@e
+ 0 10e
7a 0 +e
Instruciunea
cout __ S+ 0 S __ + __ S @ 0 S __ @ __ endle
%a afi(a %alorile
+ 0 10 @ 0 10
odul de e+cuie a acestor instruciuni este urmtorul! instruciunea
a 0 X@e
memoreaz n %aria#ila a adresa lui @. Instruciunea
7a 0 +e
se e+ecut n felul urmtor! operatorul 7 are o prioritate mai mare dec9t operatorul 0, n
consecin se aplic operatorul 7 asupra %aria#ilei a (i se o#ine adresa lui @. 6e aplic
apoi operatorul 0 asupra adresi lui @ ((i asupra adresei lui +) (i @ prime(te %aloarea 10. In
consecin, instruciunile
a 0 X@e
7a 0 +e
sunt ec*i%alente cu instruciunea
@ 0 +e
Fie de e+emplu urmtoarele instruciuni!
float +, @e
float 7 ae
float 77 aae
float 777 aaae
float 7777 aaaae
$ceste instruciuni declar c a poate conine adresa unei %aria#ile tip float, aa poate
conine adresa unei %aria#ile de tip float 7, etc. Fie instruciunile
a 0 X+e
aa 0 Xae
aaa 0 Xaae
aaaa 0 Xaaae
Fie acum instruciunea
@ 0 1.23eE1e
Instruciunile
7a 0 @e
77aa 0 @e
777aaa 0 @e
7777aaaa 0 @e
au acela(i effect, %aria#ila + prime(te %aloarea %aria#ilei @. .e e+emplu
77aa 0 @e
aplic de dou ori operatorul 7. /a se e+ecut astfel!
se aplic operatorul 7 asupra %aria#ilei aa (i se o#ine coninutul acesteia, adic adresa
%aria#ilei a. 6e aplic nc o dat operatorul 7 asupra rezultatului (i se o#ine adresa
%aria#ilei +. In final operatorul 0 atri#uie %aria#ilei + %aloarea lui @.
&rice variabil9 tip pointer trebuie iniializat9 nainte #e a fi utilizat9. De e!emplu,
urm9toarea secven9 #e instruciuni nu este corect9
int LpnM
Lpn H (M
#eoarece variabila pn nu a fost iniializat9. & secven9 corect9 este
int LpnM
int !M
pn H J!M
Lpn H (M
.n acest caz variabila pn a fost iniializat9 cu a#resa unei variabile #e tip ntreg.
(.2 Referine
& referin9 Fsau a#res9G este un alt nume pentru o variabil9. Instruciunea de
declarare a unei referine este
VipX numedreferin 0 numed%aria#il
unde
Vip este tipul %aria#ilei numed%aria#il
numedreferin este numele %aria#ilei referin (adres).
$ariabila numeAvariabil9 trebuie s9 fie #eclarat9 nainte i s9 aibe tipul "ip. .e
e+emplu
intX r+ 0 +e
declar pe r+ ca fiind o referin a lui + (%aria#ila + de tip ntre8 a fost declarat anterior).
4umele + (i r+ sunt dou nume diferite pentru aceea(i %aria#il. /le au totdeauna aceea(i
%aloare. Aentru a %erifica acest lucru %om considera urmtorul e+emplu.
int main()
:
float f 0 12.>e
floatX fr 0 fe
cout __ Sf 0 S __ f __ S fr 0 S __ fr __ endle
fr 0 fr J 23.1e
f 0 f L 1.21e
<
.up fiecare instruciune de scriere, %alorile f (i fr %or fi acelea(i. .up cum %om %edea
n para8raful urmtor, dac un parametru formal al unei funcii este de tip referin, el
poate fi un parametru de ie(ire.
& referin9 nu este o variabil9 separat9. Fie urmtorul pro8ram n care scriem adresa
unei %aria#ile (i a referinei la %aria#il.
int main()
:
dou#le d#l 0 21.22.
dou#leX d#ref 0 d#le
MM tipareste adresele lui d#l si d#lref
cout __ Sadresa lui d#l 0 S __ Xd#l
__ S adresa lui d#lref 0 S __ Xd#lref __ endle
dou#leX d#2 0 d#le
dou#leX d#1 0 d#refe
cout __ SXd#l 0 S __ Xd#l __ S Xd#2 0 S __ d#2
__ S Xd#1 0 S __ d#1 __ S X d#ref 0 S __ d#ref __ endle
<
In toate cazurile se %a tipri aceea(i %aloare.
5om nc*eia acest para8raf definind o funcie care s calculeze %aloarea medie (i
dispersia unui (ir de numere reale. Formulele corespunztoare au fost prezentate anterior.
Funcia %a a%ea ca parametri de intrare %ectorul + (i dimensiunea Wui n, iar ca parametri
de ie(ire %alorile calculate, media (i dispersia. Funcia %a a%ea tipul %oid.
%oid md(float +GH, int n, floatX m, floatX d)
:
float s 0 0e
int ie
s 0 s J +GiHe
s 0 s M ne
m 0 se
MM calculeaza dispersia
float ds 0 0e
ds 0 ds J (+GiH L s) 7 (+GiH L s)e
d 0 s M (n L 1)e
<
int main()
:
float aG1H 0 :1.22, E1.)?, 1?.02<e
float med, dispe
md(a, 1, med, disp)e
cout __ Smedia 0 S __ med __ endl
__ Sdispersia 0 S __ disp __ endle
<
(.3 Parametri funciilor
Ia apelarea unei funcii, parametrii acesteia se pun ntrEo sti%, mpreun cu %aria#ilele
locale ale funciei. .up tipul parametrului, n sti% se pune %aloarea sau adresa
parametrului. -onsiderm de e+emplu urmtoarea funcie care adun dou numere reale!
float funad(float a, float #)
:
float ce
c 0 a J #e
return ce
<
-onsiderm o instruciune ce apeleaz aceast funcie
+ 0 funad(10.1, 20.22)e
Ia apelarea funciei n sti% se aloc spaiu pentru parametrii funciei, a (i #, (i pentru
%aria#ila local c
In acest caz, dac modificm un parametru, de e+emplu a, %aloarea parametrului se
modific doar n sti%, (i nu n pro8ramul apelant. In acest caz parametrii funciei sunt
doar parametri de intrare. Aentru ca parametri unei funcii s fie parametri de ie(ire, ei
tre#uie s fie de tip pointer sau referin. In acest caz dac se modific %aloarea
parametrului n funcie, modificarea %alorii se face n pro8ramul apelant. 5om rescrie
funcia anterioar astefel nc9t rezultatul s fie asociat unui parametru. 4u %om mai a%ea
o %aloare calculat asociat numelui, deci tipul funciei %a fi %oid.
a010.1 #020.22 c
%oid funad1(float a, float #, float 7 c)
:
float re
r 0 a J #e
7c 0 re
returne
<
$pelarea acestei funcii se face astfel!
float +, @, reze
+ 0 1.21e
@ 0 E12.3?e
funad1(+, @, Xrez)e
K alt posi#ilitate este de a defini o %aria#il tip pointer care s conin adresa %aria#ilei
rez.
float 7 me
m 0 Xreze
funad1(+, @, m)e
In acest caz sti%a %a fi urmtoarea.
$ 0 1.21 , 0 E12.3? $dresa lui c
(.4 Pointeri la funcii
K funcie are un punct de intrare care este linia ei de definiie. $cest punct de intrare este
o adres de memorie care poate fi atri#uit unei %aria#ile tip pointer (i care poate fi
utilizat la apelarea funciei. In pro8ramul care apeleaz funcia tre#uie s definim o
%aria#il pointer de tipul funciei respecti%e. -onsiderm (a#lonul definiiei unei funcii
"ip numeFlista #e parametriGM
Vipul unei %aria#ile pointer la aceast funcie este
"ip FLi#entG Flista #e parametriGM
unde tip (i lista de parametri din %aria#ila pointer corespund cu tip (i lista de parametri
din (a#lonul definiia funciei.
/+emplu. Fie o funcie f ce calculeaz suma a dou numere ntre8i +, @.
int f(int +, int @)
:
return + J @e
<
ha#lonul acestei funcii este
int f(int, int)e
enionm c n (a#lon putem specifica (i numele parametrilor. 4umele parametrilor din
(a#lon pot fi diferite de cele din definiia funciei. Autem declara ca (a#lon pentru funcia
anterioar
int f(int a, int #)e
Vipul unei %aria#ile pointer la aceast funcie este
int (7ident)(int , int)e
unde ident este numele %aria#ilei tip pointer. $pelarea unei funcii folosind o %aria#il de
tip pointer se face atri#uind %aria#ilei pointer ca %aloare numele funciei (i aplic9nd
opoeratorul () asupra %aria#ilei tip pointer.
5om apela acum funcia f de mai sus direct (i folosind o %aria#il tip pointer.
int main()
:
int a 0 3, # 0 ), sme
MM apelarea directa a funciei
sm 0 f(a, #)e
cout __ Ssuma numerelor S __ a __ S si S __ # __ S este S sm __ endle
MM prt este o %aria#ila pointer la functia f
int (7ptr)(int, int)e
MM se initializeaza ptr
prt 0 fe
MM se apeleaza functia f prin pointer
sm 0 (7ptr)(a, #)e
cout __ Ssuma numerelor S __ a __ S si S __ # __ S este S sm __ endle
return 0e
<
In consecin, apelarea unei funcii se poate face astfel
scriind numele funciei urmat n paranteze de parametri actuali ca termen ntrEo
e+presie. (aplic9nd asupra numelui funciei operatorul ()).
$tri#uind unei %aria#ile tip pointer ca %aloare adresa punctului de intrare n
funcie. $dresa punctului de intrare este c*iar numele funciei. $pelarea se face
aplic9nd operatorul 7 asupra %aria#ilei tip pointer.
(.( Declararea variabilelor tip pointer la funcie
K instruciune de declarare a unui tip pointer la funcie poate conine urmtorii operatori,
scri(i aici n ordinea prioritilor
1. GH, ()
2. 7, const
1. tipuri de date
Kperatorii GH (i () sunt asociati%i la st9n8a. Kperatorii 7 (i const sunt asociati%i la dreapta.
Instruciunea poate conine (i un identificator care este numele %aria#ilei. Interpretarea
(a#loanelor se face consider9nd operatorii n ordinea prioritii lor, GH reprezint ta#louri,
() reprezint funcii, 7 reprezint un pointer, etc.
/+emplu. Fie (a#lonul
float 7f()e
Interpretarea lui se face astfel!
float 7f() f este
float 7 () funcie care returneaz
float 7 pointer la o %aloare
float tip float
f este o funcie ce returneaz un pointer de tip float.
/+emplu. Fie (a#lonul
float (7pf) ()e
pf este pointer la o funcie ce returneaz o %aloare de tip float.
/+emplu.
int (7r)(int, int)e
r este un pointer la o funcie cu doi parametri de tip int, int (i care returneaz o %aloare de
tip int.
/+emplu. Fie urmtoarea instruciune
const c*ar 7 pc 0 Sa#cdge
=eamintim c (irul de caractere Sa#cdg este un %ector cu 3 componente tip caracter, Yaf,
Y#f, Ycf, Ydf (i YO0f ((irurile sunt terminate prin zero). Arin aceast instruciune
compilatorul 8enereaz un %ector cu 3 componente tip c*aracter (i atri#uie acestui %ector
%aria#iler tip pointer pc. Interpretarea tipului %aria#ilei pc se face astfel!
const c*ar 7 pc pc este
const c*ar 7 pointer la
const c*ar constant
c*ar c*ar
$ceast instruciune declar un pointer la un %ector constant de caractere (am inut cont
c operatorii 7 (i const se citesc de la dreapta la st9n8a). In consecin, nu putem scrie
pcG1H 0 Ycfe
deoarece (irul de caractere este constant, dar putem scrie
pc 0 S8*iNge
adic pointerul poate fi iniializat cu o alt %aloare.
/+emplu. Fie acum instruciunea
c*ar 7 const cp 0 Sa#cdge
Interpretarea ei se face astfel!
c*ar 7 const cp cp este
float (7pf)() pf este
float (7) () pointer la
float () funcie care returneaz o %aloare
float tip float
c*ar 7 const constant
c*ar 7 pointer la
c*ar c*ar
Instruciunea declar un pointer constant la un %ector de caractere. In consecin putem
modifica %ectorul, de e+emplu putem scrie
cpG1H 0 Ycfe
dar nu putem scrie
cp 0 S8*iNge
deoarece pointerul este o constant.
/+emplu. -onsiderm (a#lonul
c*ar (7(7f())GH)()e
c*ar (7(7f())GH)() f este
c*ar (7(7())GH)() funcie ce returneaz
c*ar (7(7)GH)() pointer la
c*ar (7GH)() 5ector de
c*ar (7)() pointeri la
c*ar () funcie ce returneaza o %aloare
c*ar tip c*ar
f este o funcie ce returneaz un pointer la un %ector de pointeri la o funcie ce returneaz
o %aloare de tip c*ar.
(.) Pointeri i tablouri uni#imensionale
Prin #efiniie, o variabil9 tip tablou conine a#resa primului element al tabloului
Felementul cu in#icele zero al tablouluiG. 5aria#ila este un pointer constant la primul
element al ta#loului. Fie de e+emplu instruciunea
c*ar #ufferG20He
5aria#ila #uffer conine adresa primului element al ta#loului (adresa elementului
#ufferG0H). In consecin, aceast %aloare poate fi atri#uit unei %aria#ile tip pointer la
tipul elementelor ta#loului. .ac scriem
c*ar 7 p+e
p+ 0 #uffere
%aria#ila p+ conine adresa %aria#ilei #ufferG0H (i, n consecin,
7p+
este %aloarea %aria#ilei #ufferG0H.
Ia e+ecuia unui pro8ram, numele unui ta#lou este con%ertit la un pointer la primul
element al ta#loului. Arin definiie, n cazul unui ta#lou +, scrierile
+GiH
(i
7(+ J i)
sunt ec*i%alente.
/+emplu. Fie un %ector cu 3 componente tip float (i un %ector z cu 1 componente ntre8i.
6e cere s scriem componentele %ectorilor. Un pro8ram posi#il este urmtorul
int main ()
:
float +G3H 0 :1.21, ?.>', E>.3e2, 0, '.01<e
int zG1H 0 :E11, 2, 2<e
int ie
MM scrie componentele %ectorului +
for(i 0 0e i _ 3e iJJ)
cout __ YOtf __ +GiHe
cout __ endle
MM scrie componentele %ectorului z
cout __ YOtf __ 7(z J i)e
cout __ endle
<
Aro8ramul poate fi rescris astfel. .efinim o %aria#il tip pointer la tipul float ce %a
conine pe rand adresele componentelor + %ectorului (i o %aria#il tip pointer la tipul int
pentru %ectorul z. 5aria#ilele %or fi initializate cu adresele %ectorilor.
int main()
:
float +G3H 0 :1.21, ?.>', E>.3e2, 0, '.01<e
int zG1H 0 :E11, 2, 2<e
int ie
float 7 p+e
int 7 pze
p+ 0 +e
pz 0 ze
cout __ YOtf __ 7(p+ J i)
cout __ endle
MM scrie componentele %ectorului z
cout __ YOtf __ pzGiHe
cout __ endle
return 0e
<
Kperaiile cu %aria#ilele tip pointer sunt adunarea (i scderea unor %alori ntre8i. Ia
adunarea sau scderea unei %alori ntre8i dintrEo %aria#il tip pointer, la %aria#il se
adun sau se scade %aloarea respecti% nmulit cu dimensiunea n octei a tipului
%aria#ilei (unu pentru tipul c*ar, patru pentru tipul int sau float, etc.) astfel nc9t %aria#ila
conine adresa unui alt element de ta#lou. Fie din nou instruciunile
c*ar #ufferG20He
c*ar 7 p+e
p+ 0 #uffere
/+presia p+ J 1 este adresa %aria#ilei #ufferG1H, iar 7(p+ J 1) este c*iar %aloarea
componentei #ufferG1H, p+ J i este adresa %aria#ilei #ufferGiH iar 7(p+ J i) este c*iar
%aloarea componentei #ufferGiH. Autem deci s rescriem pro8ramul precedent astfel
int main()
:
float +G3H 0 :1.21, ?.>', E>.3e2, 0, '.01<e
int ie
float 7 p+e
p+ 0 +e
:
cout __ YOtf __ 7p+e
p+ 0 p+ J 1e
<
cout __ endle
return 0e
<
/c*i%alent, instruciunea de scriere poate fi
:
cout __ YOtf __ 7p+JJe
<
Aentru a %edea c ultima form este corect reamintim modul de e+ecuie a operatorului
postfi+ JJ. Instruciunea
7p+JJ
este ec*i%alent cu instruciunile
7p+e
p+JJe
In e+presie se utilizeaz %aloarea neincrementat a %aria#ilei, dup care %aria#ila este
incrementat. In consecin, se utilizeaz e+presia 7p+ dup care %aria#ila p+ este
incrementat. 5om inc*eia acest para8rap* cu un pro8ram care s scrie adresele
componentelor unui %ector utilizand o %aria#il tip pointer
int main()
:
float +G3H 0 :1.21, ?.>', E>.3e2, 0, '.01<e
int ie
float 7 p+e
p+ 0 +e
MM scrie adresele componentele %ectorului +
cout __ Sadresele componentelor %ectoruluig __ endle
:
cout __ i __ YOtf __ p+ __ endle
p+ 0 p+ J 1e
<
return 0e
<
(.* 4iruri tip C
hirurile tip - sunt %ectori de caractere $6-II la care ultimul caracter este YO0f.
,i#liotecile standard ale lim#aNelor - (i -JJ au numeroase funcii pentru lucrul cu (iruri
tip -. -9te%a dintre aceste funcii, ale cror prototipuri se afl n #i#lioteca _strin8.*",
sunt prezentate n cele ce urmeaz.
Funcia
c*ar 7 strcp@(c*ar 7 s1, const c*ar 7 s2)e
copiaz (irul s2 n s1, inclusi% caracterul YO0f. Funcia returneaz adresa (irului s1.
Aarametrul s2 este declarat de tip const, adic funcia nu modific (irul s2.
Funcia
int strcmp(const c*ar 7 s1, const c*ar 7 s2)e
compar cele dou (iruri, caracter cu caracter, p9n la primul caracter diferit. =ezultatul
este un numr _ 0, 0 0, sau " 0, dup cum sunt caracterele diferite comparate. /+emple
de utilizare a funciei strcmp sunt prezentate n ta#elul de mai Nos
strcmp(Sa#cg, S#cdg) _ 0 Yaf _ Y#f
strcmp(S+@zg, S+@zg) 0 0 (irurile sunt e8ale
strcmp(Sa#cdg, Sa#cg) " 0 (irul Sa#cdg este mai lun8
Funcia
sizedt strlen(const c*ar 7 s)e
calculeaz lun8imea (irului s (numrul de caractere ce preced YO0f).
Funcia
c*ar 7 strc*r(const c*ar 7 s, int c)e
caut prima apariie a caracterul c (con%ertit la c*ar) n (irul s. Funcia returneaz un
pointer la caracterul 8sit sau 4UII n caz contrar.
Urmtoarele funcii manipuleaz caractere tip $6-II. Arototipurile lor se afl n
#i#lioteca _ct@pe.*".
Funcie .escriere
int isalnum (int c)e Vest dac un caracter este alfanumeric
int isalp*a (int c)e Vest dac un caracter este alfa#etic
int isdi8it (int c)e Vest dac un caracter este o cifr zecimal
int is+di8it(int c)e Vest dac un caracter este o cifr *e+azecimal
int isloCer (int c)e Vest dac un caracter este liter mic
int isspace (int c)e Vest dac un caracter este spaiu (Y Y, YOnf, YOtf)
int isupper (int c)e Vest dac un caracter este liter mare
Funciile au un rezultat diferit de zero dac ar8umentul este conform descrierii funciei.
Urmtoarele funcii con%ertesc literele mari n litere mici (i in%ers.
Funcie .escriere
int toloCer(int c)e -on%erte(te n litere mici
int toupper(int c)e -on%erte(te n litere mari
5om e+emplifica utilizarea acestor funcii tiprind caracterele alfa#etice, alfanumerice,
cifrele, literele mici (i mari ale codului $6-II. 5om utiliza constanta predefinit
U-Z=d$D din #i#lioteca _limits.*" care d %aloarea ma+im a unui o#iect de tipul
unsi8ned c*ar (aceast %aloare este 233). 5om construi o funcie care 8enereaz toate
caracterele codului $6-II (toate numerele de la 0 la 233) (i le %om tipri n fiecare caz
caracterele pentru care funciile de mai sus returneaz o %aloare poziti% (%aloarea
ade%rat). Funcia pe care o %om construi %a a%ea ca parametru un pointer de tipul
funciilor de mai sus. Arototipul acestor funcii este
int nume(int)e
iar un pointer la o asemenea funcie are tipul
int (7 fn)(int)e
Tinclude _stdli#.*"
%oid prtcars(const c*ar 7 nume, int (7fn)(int))
:
c*ar ce
MM scrie numele functiei
cout __ nume __ S ! Se
M7 8enereaza toate caracterele si scrie pe cele pentru
care functia are %aloarea ade%arat 7M
for(c 0 0e c _ U-Z=d$De JJc)
if((7fn)(c))
cout __ ce
cout __ endle
<
int main()
:
ptrcars(Sisdi8itg, Xisdi8it)e
ptrcars(SisloCerg, XisloCer)e
ptrcars(Sisupperg, Xisupper)e
ptrcars(Sisalp*ag, Xisalp*a)e
ptrcars(Sisalnumg, Xisalnum)e
ptrcars(Sis+di8itg, is+di8it)e
<
/+erciiu. 6 se scrie un pro8ram care s con%erteasc literele mici ale unui (ir n litere
mari.
5om e+emplifica utilizarea pointerilor la ta#louri unidimensionale construind o funcie
care copiaz un (ir n altul (ca (i funcia standard strcp@). Arototipul ei %a fi
%oid cop@(c*ar 7 s1, c*ar 7 s2)e
unde (irul s2 este sursa iar (irul s1 este destinaia.
K prim %ariant este
%oid cop@(c*ar 7 s1, c*ar 7 s2)
:
int len 0 strlen(s2)e
for(i 0 0e i _ len J 1e iJJ)
s1GiH 0 s2GiHe
<
K alt %ariant este
:
int ie
for(i 0 0e (s1GiH 0 s2GiH) P0 YO0fe iJJ)
e
<
-ondiia care se testeaz pentru e+ecuia instruciunii for este
(s1GiH0s2GiH) P0 YO0fe
/a este testat astfel. 6e e+ecut instruciunea de atri#uire
s1GiH 0 s2GiH
dup care rezultatul s1GiH este comparat cu %aloarea YO0f, care este caracterul de terminare
al (irului s2. =eamintim c operatorul de atri#uire are ca rezultat %aloarea atri#uit.
K alt %ariant utilizeaz pointeri (i faptul c (irurile tip - sunt terminate prin zero.
:
C*ile(7s1 0 7s2)
:
s1JJe
s2JJe
<
<
/+presia testat pentru e+ecuia instruciunii C*ile este
7s1 0 7s2
=ezultatul e%alurii e+presiei este %aloarea 7s1 (un caracter copiat n (irul s1).
Instruciunea C*ile se e+ecut pan c9nd caracterul YO0f al (irului s2 este copiat n s1.
In final putem scrie %arianta
:
C*ile(7s1JJ 0 7s2JJ)
e
<
care este o scriere condensat a %ariantei anterioare.
$lte funcii ce prelucreaz (iruri de caractere sunt
int atoi(c*ar 7 s)e
dou#le atof(c*ar 7 s)e
care con%ertesc un (ir de caractere ntrEun numr ntre8 (i respecti% real. Arototipurile
acestor funcii se afl n #i#lioteca :st#lib.7;. Un e+emplu de utilizare a acestor funcii
poate fi urmtorul. Fie dou (iruri ce conin numere. 5om con%erti aceste (iruri n
numere (i %om efectua produsul lor.
T include _stdli#.*"
int main()
:
c*ar 7 s1 0 SE121ge
c*ar 7 s2 0 S1.22eE1ge
int +e
dou#le @e
MM scrie sirurile
cout __ Ssirul s1 ! g __ s1 __ endl
__ Ssirul s2 ! g __ s2 __ endle
MM con%erteste sirurile in numere
+ 0 atoi(s1)e
@ 0 atof(s2)e
MM scrie numerele
cout __ S+ 0 S __ + __ S @ 0 S __ @ __ endle
cout __ S+ 7 @ 0 S __ + 7 @ __ endle
<
(., Pointeri i tablouri multi#imensionale
Va#lourile se definesc conform urmroarei dia8rame sintactice
/lementele ta#lourilor sunt memorate pe linii. .e e+emplu, ta#loul
int +G2HG1He
este compus din elementele
+G0HG0H, +G0HG1H, &, +G1HG0H, &+G1HG2H
/l este considerat ca un %ector cu 2 elemente, +G0H (i +G1H, fiecare element fiind un %ector
cu trei elemente de tip int. Kperatorul GH selecteaz un element al unui ta#lou (operator de
selecie). /l este un operator #inar, operandul st9n8 fiind un ta#lou, operandul drept fiind
un indice. .e e+emplu, +G0H selecteaz primul element din + care este %ectorul
+G0HG0H, +G0HG1H, +G0HG2H
$plic9nd operatorul de selecie asupra lui +G0H, selectm un element al acestuia, de
e+emplu +G0HG1H. =eamintim c operatorul de selecie este asociati% la st9n8a. Indicii unui
element de ta#lou pot fi orice e+presii ntre8i poziti%e.
/+emplu. 6 construim o funcii care s citeasc matrice cu dou linii (i dou coloane.
Funcia poate fi urmtoarea
%oid rdmat(float aG2HG2H)
:
int i, Ne
for(N 0 0e N _ 2e NJJ)
cin "" aGiHGNHe
<
4umele unui ta#lou este prin definiie un pointer la primul element al ta#loului.
/lementele ta#loului pot fi selectate folosind operatorul 7. Fie de e+emplu ta#loul
dou#le +G1He
.up cum am spus anterior, prin definiie, e+presiile
+GiH
(i
7(+Ji)
sunt ec*i%alente.
-onsiderm ta#loul
float aG2HG1He
/+presia
aGiHGNH
este ec*i%alent cu
(aGiH)GNH
care, conform celor de mai sus, este ec*i%alent cu
7((aGiH) J N)
care este ec*i%alent cu e+presia
7(7(a J i) JN)
-a e+emplu de utilizare a pointerilor la ta#louri #idimensionale s construim o funcie
care s scrie elementele unei matrice cu dou linii (i dou coloane. Funcia poate fi
%oid Crmat(float +G2HG2H)
:
int i, Ne
:
cout __ aGiHGNH __ S Se
cout __ endle
<
<
Utilizand cele de mai sus putem rescrie funcia ca
%oid Crmat(float +G2HG2H)
:
int i, Ne
:
cout __ 7(7(a J i) JN) __ S Se
cout __ endle
<
<
=eamintim c
aGiH
selecteaz un element al ta#loului a, aici o linie, deci
7(a J i)
selecteaz o linie a ta#loului a.
(.- Parametrii funciei main. Parametrii liniei #e coman#9
Arototipul funciei main() utilizat pan acum este
Int main()e
Funcia main poate a%ea urmtoarul prototip
int main(int ar8c, c*ar 7 ar8%GH)e
-onsiderm al doilea parametru din aceast definiie
c*ar 7 ar8%GH
c*ar 7 ar8% GH ar8% este
c*ar 7 GH %ector de
c*ar 7 pointeri la
c*ar c*ar
ar8% reprezin un %ector de pointeri la c*aracter, iar ar8c este dimensiunea acesui %ector.
Aointerii sunt adresele unor (iruri de caractere ce corespund ar8umentelor liniei de
comand. Arimul (ir de caractere este c*iar numele pro8ramului. -a e+emplu fie un
pro8ram ce tipre(te ar8umentele liniei de comand.
int main(int ar8c, c*ar 7 ar8%GH)
:
int ie
for(i 0 0e i _ ar8ce JJi)
cout __ ar8%GiH __ endle
<
Un mod de a furniza parametri liniei de comand este de a rula pro8ramul ntrEo fereastr
.K6, de la linia de comand
aplicatie.e+e parametru1 parametru2 & parametrun
$lt mod este de a introduce ace(ti parametri ntrEo cutie de dialo8 a mediul de
pro8ramare.
Cap. ) 1iiere tip C
In lim#aNele - (i -JJ fi(ierele sunt considerate ca un (ir ordonat de octei. /+ist dou
tipuri de fi(iere, te+t (i #inare.
Un fi(ier tip te+t este un (ir ordonat de caractere 8rupate n linii. Fiecare linie
const din zero sau mai multe caractere plus un caracter YOnf (return).
Un fi(ier #inar este un (ir ordonat de octei.
enionm c fiecare fi(ier pe disc are o etic*et ce conine numele fi(ierului, adresa de
nceput (i adresa de sfar(it a fi(ierului.
In pro8ram fiecare fi(ier este asociat unui stream. Un stream este asociat unui fi(ier prin
operaia de desc*idere a fi(ierului. Aentru prelucrare, un fi(ier se desc*ide n citire. -9nd
se creaz un fi(ier el se desc*ide n scriere. Ia desc*iderea unui fi(ier n scriere se creaz
o etic*et corespunztoare acestui fi(ier (i se completez numele fi(ierului (i adresa de
nceput. Ia desc*iderea n citire sistemul de operare caut pe disc fi(ierul cu numele
specificat (i memoreaz adresele de nceput (i de sfar(it ale fi(ierului. Un stream este
disociat de un fi(ier prin operaia de nc*idere a fi(ierului. Ia nc*iderea unui fi(ier n
creare se completeaz etic*eta fi(ierului cu adresa ultimului octet al fi(ierului.
Fi(ierele #inare au un indicator de poziie ce d adresa urmtorului octet de citit sau scris.
$cest indicator este iniial pus la zero (i este actualizat de operaiile de citire sau scriere.
Un fi(ier poate a%ea o zon de memorie asociat (#uffer) n care se citesc date din fi(ier
sau din care se scriu date n fi(ier.
Iim#aNele - (i -JJ au tipul de structur FII/ ce poate nre8istra toate informaiile
necesare pentru controlul unul stream, inclusi%!
4umele fi(ierului
Indicatorul de poziie al fi(ierului
Indicator de eroare poziionat dac a aprut o eroare intrareMie(ire
Indicatorul de sf9r(it de fi(ier, eof, (end of file)
Prototipurile funciilor ce efectueaz9 operaii intrare0ieire se afl9 n biblioteca
:st#io.7;. Funciile importante pentru prelucrarea fi(ierelor sunt urmtoarele.
FII/7 fopen(const c*ar 7 filename, const c*ar 7 mode)e
$ceast funcie desc*ide un fi(ier. /a creaz o structur tip FII/ cu informaii despre
fi(ier. Aarametrii acestei funcii sunt
1. filename E un pointer la (irul de caractere ce d numele fi(ierului.
2. mode E un pointer la un (ir de caractere ce d modul de desc*idere.
Aarametrul mode poate a%ea urmtoarele %alori!
Srg L fi(ier te+t desc*is n citire
SCg E fi(ier te+t desc*is n scriere
Sr#g L fi(ier #inar desc*is n citire
SC#g E fi(ier #inar desc*is n scriere
int fclose(FII/ 7 stream)e Funcia nc*ide un fi(ier. /a returneaz %aloarea zero
dac operaia a a%ut succes.
int feof(FII/ 7 stream)e Funcia returneaz o %aloare diferit de zero dac sEa
detectat sf9r(itul unui fi(ier n timpul operaiei de citire precedente.
int remo%e(c*ar 7 filename)e (ter8e fi(ierul cu filename. Funcia returneaz o
%aloare diferit de zero dac operaia a%ut succes.
Ia lansarea n e+ecuie a unui pro8ram e+ist trei streamuri standard tip te+t desc*ise!
stdin L fi(ierul standard de intrare asociat tastaturii
stdout E fi(ierul standard de ie(ire asociat ecranului
stderr E fi(ierul standard de ie(ire pentru scrierea mesaNelor de eroare
/+emplu. Ia prelucrarea oricrui fi(ier te+t n citire %om a%ea urmtoarele instruciuni
FII/ 7 fpe
fp 0 fopen(Snumefisierg, Srg)e
MM prelucreaza fisierul
fclose(fp)e
%enion9m c9 la citirea secvenial9 a unui fiier, #up9 fiecare operaie #e citire
trebuie s9 test9m in#icatorul #e sfarit al fiierului. =a ntalnirea sfaritului #e fiier
funciile #e citire returneaz9 o valoare specific9. Citirea secvenial9 a unui fiier se
face cu instruciunea 67ile ce va testa acest in#icator.
).1 1iiere tip te!t
In cazul fi(ierelor tip te+t a%em dou tipuri de funcii pentru operaiile de intrare M ie(ire!
funcii pentru intrri M ie(iri cu format la care operaiile de citire M scriere se fac
su# controlul unui format
funcii care citesc M scriu caractere
).1.1 1uncii intrare 0 ieire cu format
$ceste funcii scriu sau citesc %alori n sau din fi(iere pe disc, fi(ierele standard sau (iruri
de caractere. Aentru scriere, aceste funcii sunt!
int fprintf(FII/ 7 stream, const c*ar 7 format, ar8umente)e
int printf( const c*ar 7 format, ar8umente)e
int sprintf(c*ar 7 s, const c*ar 7 format, ar8umente)e
Aentru citire, funciile sunt
int fscanf(FII/ 7 stream, const c*ar 7 format, ar8umente)e
int scanf( const c*ar 7 format, ar8umente)e
int sscanf(c*ar 7 s, const c*ar 7 format, ar8umente)e
Aarametrul format este un (ir de caractere compus din specificatori de con%ersie definii
de ; (i alte caractere. 6pecificatorii de con%ersie sunt
;d L ntre8 cu semn n #aza 10
;i L ntre8 cu semn
;o L ntre8 n #aza >
;u L ntre8 n #aza 10 far semn
;+ L ntre8 n #aza 1? cu semn
;c L caracter
;s L (ir de caractere
;f L numr real
;e L numr real cu e+ponent
.up ; poate urma un numr ntre8 care d lun8imea minim a c9mpului n cazul
instruciunii printf (i lun8imea ma+im a campului n cazul instruciunii scanf. Ia
scrierea numerelor cu specificatorul ;f putem specifica (i numrul de cifre ale prii
su#unitare. .e e+emplu specificatorul ;)f descrie un numr real ce ocup ) poziii, iar
specificatorul ;).1f descrie un numr real ce ocup ) poziii din care 1 sunt pentru partea
su#unitar.
/+emplu. 5om scrie un pro8ram care calculeaz %aloarea unei e+presii
x x
x x
ln
) sin( 2 ) 2 cos( 1
+
+ +
pentru %alori ale lui + cuprinse ntre 1 (i 2 cu pasul 0.2. 5alorile e+presiei %or fi scrise pe
ecran (i ntrEun fi(ier cu numele rez.t+t. 6pecificatorii de format %or fi ;2f pentru
%aria#ila + (i ;?f pentru e+presie. 5aloarea lui + %a ocupa 2 caractere iar cea a lui z ?
caractere. 5alorile %or fi separate de un caracter ta#, YOtf. Formatul se nc*eie cu un
caracter YOnf.
Tinclude _stdio.*"
Tinclude _mat*.*"
int main %oid()
:
FII/ 7 fpe
fp 0 fopen(Srez.t+tg, SCg)e
int ie
float +, ze
MM scrie antetul
printf(S+Otf(+) Ong)e
fprintf(fp, S+Otf(+) Ong)e
MM calculeaza %alorile e+presiei si scrie aceste %alori in fisiere
for(i 0 0e i _ ?e iJJ)
:
z 0 (1 J cos(2 7 +) J 2 7 sin(+)) M (+ J lo8(fa#s(+)))e
printf(S ;2f Ot ;?f Ong, +, z)e
fprintf(fp, S ;2.1f Ot ;?.2f Ong, +, z)e
+ 0 + J 0.2e
<
fclose(fp)e
return 0e
<
In pro8ramul anterior puteam defini un (ir de caractere cu specificatorii de format
c*ar 7 format 0 S ;2f Ot ;?f Onge
(i apoi instruciunile de scriere sunt
printf(format, +, z)e
fprintf(fp, format, +, z)e
/+emplu. 6 citim un numr *e+azecimal de la tastatur (i sEl scriem n format zecimal
(i *e+azecimal pe ecran.
Tinclude_stdio.*"
int main()
:
int ie
printf(Sintroduceti un numar *e+azecimalOng)e
scanf(S;+g, Xi)e
printf(SOn numarul zecimal ;dOn numarul *e+azecimal;+Ong, i, i)e
<
enionm c parametrii funciei scanf sunt de tip pointer (sunt parametri de ie(ire). In
consecin, la apelarea funciei scanf n pro8ram utilizm adresa %aria#ilei i.
scanf(S;+g, Xi)e
/+emplu. -onsideram un %ector cu 3 componente numere reale. 5om afi(a componentele
%ectorului su# forma
/lement 5aloare
+G0H &..
+G1H &..
T include _stdio.*"
int main()
:
dou#le +G3H 0 :1.21, E21, 0.'>, 2.12, 3.1<e
int ie
printf(S/lementOt5aloareg)e
MM scrie componentele %ectorului
printf(S+G;dH OtOt;dOtg, i, +GiH)e
return 0e
<
).1.2 1uncii intrare 0 ieire tip caracter
Funcia
int f8etc(FII/ 7 stream)e
cite(te un c*aracter din fi(ierul de intrare (i a%anseaz indicatorul de poziionare al
fi(ierului cu %aloarea unu. .ac se nt9lne(te sf9r(itul de fi(ier, funcia returneaz
%aloarea /KF care este o constant predefinit n #i#lioteca _stdio.*".
Funcia
int 8etc*ar()e
cite(te un c*aracter din streamul stdin. /a este ec*i%alent cu funcia f8etc(stdin)e
Funcia
int fputc(int c, FII/ 7 stream)e
scrie caracterul c n streamul specificat de stream. Funcia returneaz caracterul scris sau
constanta /KF n caz de eroare.
Funcia
int putc*ar(int c)e
scrie caracterul c in streamul stdout.
Funcia
int un8etc(int c, FII/ 7 stream)e
pune caracterul c n streamul de intrare.
Urmtoarele funcii citesc sau scriu linii din fi(iere tip te+t.
Funcia
c*ar 7 f8ets(c*ar 7 s, int n, FII/ 7 stream)e
cite(te cel mult n L 1 caractere n %ectorul s. /a se opre(te dac nt9lne(te caracterul YOnf
sau sf9r(itul de fi(ier. .up ultimul caracter citit se adau8 caracterul YO0f n %ectorul s.
Funcia returneaz adresa %ectorului s. Ia nt9lnirea sf9r(itului de fi(ier sau la o eroare
funcia retuurneaz %aloarea 4UII.
Funcia
int fputs(const c*ar 7 s, FII/ 7 stream)e
scrie (irul de caractere s (terminat cu YO0f) n flu+ul stream. -aracterul YO0f nu este scris.
Funcia
int puts(c*ar 7 s)e
scrie (irul de caractere s (terminat cu YO0f) n flu+ul stdout. -aracterul YO0f nu este scris.
Funcia scrie (i caracterul YOnf dup ce a scris (irul s.
=eamintim c funcia fputs nu scrie caracterul YOnf n fi(ier, n timp ce funcia puts scrie
caracterul YOnf n fi(ierul stdout dup (ir. In consecin, pentru a afi(a c9te un (ir de
caractere pe rand, la scrierea n fi(ierul stdout cu funcia fputs %om scrie
fputs(+, stdout)e
fputs(SOng, stdout)e
6c*ema principial de citire a unui fi(ier sec%enial este urmtoarea. Aresupunem c
utilizm o funcie read(file) ce cite(te c9te un #loc de date din fi(ier. Kperaia de citire
poziioneaz indicatorul de sfar(it de fi(ier la %aloarea true dac n cursul operaiei de
citire sEa detectat sfar(tul fi(ierului.
read(file)
C*ile(P eof(file))
:
prelucreaza #locul citit
read(file)
<
In cazul citirii caracterelor de la tastatur, sfar(itul de fi(ier este indicat prin -V=IJ].
/+emplu. 5om e+emplifica utilizarea acestor funcii cu un pro8ram care s calculeze
dimensiunea n octei a unui fi(ier. Aro8ramul %a citi numele unui fi(ier de la tastatur, (i
%a desc*ide fi(ierul n citire. $poi se %a citi c9te un caracter pan la ntalnirea sfar(itului
de fi(ier (i se %or numra octeii citii. -itirea sec%enial a fi(ierului se %a face cu
instruciunea C*ile.
M7 calculul dimensiunii unui fisier 7M
Tinclude _stdio.*"
int main()
:
c*ar nameG?2He
FII/7 filee
c*ar care
int n# 0 0e
printf(iintroduceti numele fisieruluiOni)e
scanf(i;si, name)e
MM desc*ide fisierul in citire
file 0 fopen(name, iri)e
MM test daca fisierul e+ista
if(file 00 4UII)
:
printf(inume de fisier eronatOni)e
return 0e
<
MM citeste cate un caracter p9n la sfarsitul fisierului
MM citeste un caracter
car 0 f8etc(file)e
C*ile(car P0 /KF)
:
MM numara caracterul citit
n# 0 n# J 1e
MM citeste un caracter
car 0 f8etc(file)e
<
fclose(file)e
printf(ifisierul ;s contine ;d octetiOni, name, n#)e
return 0e
<
/+emplu. 5om face un pro8ram care s copieze un fi(ier e+istent n altul. Fie un fi(ier cu
numele file1.t+t n directorul curent. 5om copia acest fi(ier n fi(ierul cu numele file2.t+t
tot n directorul curent. 5om desc*ide cele dou fi(iere (i %om testa dac operaia a a%ut
succes. Funcia fopen are ca rezultat %aloarea 4UII dac operaia nu a a%ut succes. $poi
se cite(te c9te un caracter din primul fi(ier (i se scrie n al doilea.
T include _stdio.*"
int main ()
:
FII/ 7 fin, 7 foute
c*ar nume1G?2H, nume2G?2He
MM citeste numele primului fisier
printf(Sintroduceti numele fisierului ce %a fi copiatOng)e
scanf(S;sg, nume1)e
fin 0 fopen(nume1, iri)e
if(fin 00 4UII)
:
printf(ifisierul ;s nu e+istaOni, nume1)e
return 0e
<
MM citeste numele noului fisier
printf(Sintroduceti numele noului fisierOng)e
scanf(S;sg, nume2)e
fout 0 fopen(nume2, iCi)e
if(fout 00 4UII)
:
printf(ifisierul ;s nu se poate creai, nume2)e
return 0e
<
MM copiaza fisierul
int ce
c 0 f8etc(fin)e
C*ile(c P0 /KF)
:
fputc(c, fout)e
c 0 f8etc(fin)e
<
fclose(fin)e
fclose(fout)e
return 0e
<
Instruciunile ce citesc (i scriu din fi(iere pot fi rescrise ca
int ce
C*ile((c 0 f8etc(fin)) P0 /KF)
fputc(c, fout)e
).2 1iiere binare
Aentru scrierea (i citirea de date din fi(iere #inare e+ist funciile fread (i fCrite. $ceste
funcii pot citi sau scrie unul sau mai multe #locuri de date.
Funcia
sizedt fread(%oid 7 ptr, sizedt size, sizedt nm#, FII/ 7 stream)e
cite(te n %ectorul ptr cel mult nm# #locuri de dimensiune size din fi(ierul stream. Funcia
returneaz numrul efecti% de #locuri citite. Indicatorul de poziie al fi(ierului este
a%ansat cu numrul de octei citii. In cazul nt9lnirii sfar(itului de fi(ier, funcia
returneaz %aloarea 0.
Funcia
sizedt fCrite(const %oid 7 ptr, sizedt size, sizedt nm#, FII/ 7 stream)e
scrie n %ectorul ptr cel mult nm# #locuri de dimensiune size n fi(ierul stream. Funcia
returneaz numrul efecti% de #locuri scrise. Indicatorul de poziie al fi(ierului este
a%ansat cu numrul de octei scri(i.
Aentru citirea elementelor n ordine aleatoare e+ist posi#ilitatea de a modifica
indicatorul de poziie al fi(ierului cu funcia
int fseeW (FII/ 7 stream, lon8 int offset, int C*ence)e
4oua %aloare a indicatorului fi(ierului este o#inut adu89nd %aloarea offset la poziia
specificat de C*ence care poate fi
6//^d6/V nceputul fi(ierului
6//^d-U= poziia curent a indicatorului
6//^d/4. sf9r(itul fi(ierului
.up o instruciune fseeW, urmtoarea instruciune poate fi o operaie de citire sau scriere.
Funcia
lon8 ftell(FII/7 stream)e
are ca rezultat %aloarea indicatorului de poziie al fi(ierului.
/+emplu. 5om crea un fi(ier #inar pe care l citim apoi sec%enial. 5om scrie n fi(ier 10
#locuri de c9te 13 octei fiecare. ,locurile %or consta din (iruri de c9te 12 caractere,
primul #loc caractere Y0f, al doilea #loc caractere Y1f, etc. -itirea sec%enial se %a face
cu instruciunea C*ile. .up fiecare citire testm rezultatul funciei fread. Un rezultat
zero al acestei funcii semnific nt9lnirea sf9r(itului de fi(ier. enionm c putem
8enera caracterele Y0f, Y1f, etc., o e+presie de forma
Y0f J i
unde i ia %alorile 0, 1, 2, &
Tinclude _stdio.*"
int main()
:
FII/ 7 file
int i, Ne
c*ar +G13He
MM desc*ide fisierul in creare
fil 0 fopen(Sfil.t+tg, SC#g)e
if(fil 00 4UII)
:
printf(Sfisierul nu se poate creaOng)e
return 0e
<
:
MM creaza un #loc
for(N 0 0e N _ 12e JJN)
+GNH 0 Y0f J i e
+G12H 0 0e
MM scrie #locul in fisier
fCrite(+, 13, 1, fil)e
<
MM inc*ide fisierul
fclose(fil)e
fil 0 fopen(Sfil.t+tg, Sr#g)e
if(fil 00 4UII)
:
printf(Sfisierul nu se poate desc*ideOng)e
return 0e
<
int +cte
MM citeste un sir
+ct 0 fread(+, 13, 1, fil)e
C*ile(+ct P0 0)
:
MM scrie sirul pe ecran (in streamul stdout)
printf(S;sOng, +)e
MM citeste un sir
+ct 0 fread(+, 13, 1, fil)e
<
MM inc*ide fisierul
fclose(fil)e
<
/+emplu. 5om crea un fi(ier #inar n care %om scrie 13 #locuri de c9te 10 caractere (i
apoi %om citi #locurile pare. ,locurile %or conine (iruri de caractere de forma
a#cde&
#cdef&
cdef8&
8enerate cu o e+presie de forma
Yaf J i J N
unde i (i N iau %alorile 0, 1, 2, &
Tinclude _stdio.*"
int main()
:
FII/ 7 file
int i, Ne
c*ar +G10He
MM desc*ide fisierul in creare
fil 0 fopen(Sfilg, SC#g)e
if(fil 00 4UII)
:
printf(ifisierul nu se poate creaOni)e
return 0e
<
:
MM creaza un #loc
for(N 0 0e N _ 'e JJN)
+GNH 0 Yaf J i J Ne
+G'H 0 0e
fCrite(+, 10, 1, fil)e
MM scrie sirul pe ecran (in flu+ul stdout)
puts(+)e
<
MM inc*ide fisierul
fclose(fil)e
fil 0 fopen(Sfilg, Sr#g)e
if(fil 00 4UII)
:
printf(ifisierul nu se poate citiOni)e
return 0e
<
printf(ifisierul cititOni)e
MM citeste sirurile pare
for(i 0 0e i _ 13e i J0 2)
:
MM pozitioneaza indicatorul fisierului
fseeW(fil, (lon8)(i 7 10), 6//^d6/V)e
MM citeste un sir
fread(+, 10, 1, fil)e
MM scrie sirul pe ecran (in flu+ul stdout)
fputs(+, stdout)e
fputs(SOng, stdout)e
<
MM inc*ide fisierul
fclose(fil)e
<
enionm c puteam a%ansa indicatorul fi(ierului la sfar(itul ciclului for cu 10 octei.
MM a%anseaza indicatorul fisierului cu 10
fseeW(fil, (lon8)(10), 6//^d-U=)e
Cap. * 4tructuri tip C
K structur este un tip de date definit de utilizator. K structur este o colecie de date de
tipuri diferite. .atele dintrEo structur %or fi numite componente sau c9mpuri. .efinirea
unei structuri se face cu instruciunea
struct nume :liste de declaraii de tip <e
unde nume este noul tip de date.
.e e+emplu, o structur poate defini tipul numere comple+e
struct comple+ :
float reale
float ima8e
<e
enionm c o structur poate conine componente de orice tip, c*iar (i alte structuri.
Autem defini apoi %aria#ile corespunz9nd acestui nou tip cu o instruciune
struct nume list de %aria#ilee
.e e+emplu, ntrEun pro8ram putem defini numere comple+e a (i #
struct comple+ a, #e
K structur poate fi iniializat la declarare. Autem scrie
comple+ n 0 :1.1, E2.12<e
$dresarea unui element al unei structuri se face cu operatorul .
nume.membru
Autem da %alori %aria#ilelor definite anterior
a.real 0 1.0e
a.ima8 0 E1.2 J sin(0.1)e
Autem utilize %alorile componentelor unei structuri n e+presii
float +e
+ 0 a.real 7 a.ima8e
Pentru a #efini funcii ce au ca argumente sau rezultat structuri n limba@ul C,
#efinim un nou tip #e #ate corespunzan# structurii cu instruciunea t'pe#ef. Aentru
e+emplificare %om defini (cu instruciunea t@pedef) un tip numit %ector ce %a fi o
structur ce conine dou numere reale.
T include _stdio.*"
t@pedef struct
:
float compae
float comp#e
< %ectore
5om construi o funcie care s adune doi %ectori. Funcia %a a%ea ca parametri dou
structuri (i ca rezultat o structur. 5om declara %aria#ile de acest tip n funcia main (i n
funcia ce adun %ectorii.
%ector addcmp(%ector +, %ector @)
:
%ector ce
c.compa 0 +.compa J @.compae
c.comp# 0 +.comp# J @.comp#e
return ce
<
int main()
:
%ector c+, c@, cze
c+.compa 0 1e
c+.comp# 0 1e
c@.compa 0 0e
c@.comp# 0 1e
cz 0 addcmp(c+, c@)e
printf(Ssuma este (;f , ;f) Ong, cz.compa ,cz.comp#)e
<
Ia fel ca (i n cazul %aria#ilelor putem defini %aria#ile tip pointer la o structur, ce %or
conine adresa unei structuri. Instruciunea de definire a unui pointer la o structur este
struct nume 7 identificatore
sau
numetip 7 identificatore
dac am definit un tip de structur cu instruciunea t@pedef.
unde nume este numele structurii iar identificator este numele %aria#ilei tip pointer.
.e e+emplu,
struct comple+ 7 pce
define(te un pointer de tip struct comple+. 5aria#ila tip pointer poate fi iniializat ca
orice %aria#il tip pointer, folosind operatorul de calcul al adresei X
pc 0 Xae
In cazul unui pointer p la o structur, un camp al structurii este adresat astfel
(7p).mem#ru
Arin definiie, aceast scriere se prescurteaz
pE"mem#ru
Kperatorii . (i E" au aceea(i prioritate ca operatorii () (i GH.
comple+ @e
struct comple+ 7 p@e
p@ 0 X@e
Autem iniializa structura @, utilizand pointerul p@
p@E"real 0 E21.2e
p@E"ima8 0 1.2e
Autem iniializa direct componentele structurii
@.ima8 0 1.22e
@.real 0 0.21e
Autem utiliza %alorile %aria#ileleor definite de structura @.
float fm 0 pcE"ima8e
6unt corecte (i scrierile
(7pc).real 0 cos(1.21)e
dou#le d 0 (7pc).ima8 J (7pc).reale
/+emplu. 5om defini un tip de structur numcmp ce descrie numerele comple+e cu
instruciunea t@pedef. 5om iniializa o %aria#il de acest tip (i %om scrie %alorile ei pe
ecran folosind un pointer la structur.
T include _stdio.*"
t@pedef struct
:
float reale
float ima8e
< numcmpe
int main ()
:
numcmp cr 0 :1.1, E1.2<e
numcmp 7 p%e
p% 0 Xcre
printf(i(;f , ;f)Oni, p%E"real, p%E"ima8)e
<
5om prezenta un e+emplu de utilizare a operatorilor de incrementare JJ n cazul
pointerilor la structuri. Fie structura
struct str+ :
int ce
float de
<e
Fie o %aria#il tip str+ (i o %aria#il tip pointer la structura str+e
struct str+ ae
struct str+ 7#e
5om iniializa pe # cu adresa lui a.
# 0 Xae
(i elementul c al structurii la %aloarea zero.
#E"c 0 0e
Autem incrementa pe c astfel!
#E"c 0 #E" J 1e
#E"c J0 1e
(7#).c J0 1e
JJ(7#).ce
JJ#E"ce
Kperatorul JJ are o prioritate mai mic dec9t E" (i . astfel nc9t ultimele e+presii sunt
JJ((7#).c)e
JJ(#E"c)e
Cap. , Clase
Aentru a rezol%a o pro#lem tre#uie s crem un model al pro#lemei. Arocesul de
modelare se numeste a#stractizare. In acest proces tre#uie s definim
datele afectate
operaiile identificate de pro#lem.
$#stractizarea este structurarea pro#lemei n entiti definind datele (i operaiile asociate
acestor entiti. Vipurile de date a#stracte pe care le definim au urmtoarele proprieti
definesc o structura a datelor
datele sunt accesi#ile prin operaii #ine definite. 6etul de operaii definite se
nume(te interfa. Kperaiile interfeei sunt sin8urul mecanism de acces la
structura de date.
.efiniiile pe care le %om utilize sunt urmtoarele
Clasa este o reprezentare a unui tip de date a#stracte. /a asi8ur detaliile de
implementare pentru structura de date (i pentru operaii. -lasa define(te atri#ute si
metode care implementeaz structura de date (i operaiile tipului a#stract.
Instanele clasei se numesc o#iecte. K clasa define(te proprietile (i comportarea
unei mulimi de o#iecte. IntrEo clas e+ist o parte de definire a datelor (i
operaiilor (i o parte de implementare. Aartea de definire se nume(te interfa.
&biect. Un o#iect este o instana a unei clase (a unui tip a#stract). /l este unic
identificat prin nume (i define(te o stare reprezentat de %alorile atri#utelor la un
moment dat. -omportarea unui o#iect este definit de metodele ce se pot aplica
asupra lui.
%esa@e. Un pro8ram este o multime de o#iecte create, distruse (i care
interacioneaz. Interaciunea este #azat pe mesaNe trimise de la un o#iect la altul
cerand destinatarului sa aplice o metod asupra lui (apelarea unei functii). Un
mesaN este o cerere ctre un o#iect ca el s in%oce una din metodele lui. esaNul
conine
E numele metodei
E ar8umentele metodei
%eto#a. K metoda este asociat unei clase. Un o#iect in%oca o metod ca reacie
la primirea unui mesaN.
Clasa este un tip de date definit de utilizator. -lasa define(te %aria#ile (i funcii ce
prelucreaz aceste %aria#ile. Funciile definite de clas se numesc meto#e sau funcii
membre ale clasei. 5aria#ilele clasei se numesc cEmpuri sau atribute sau propriet9i.
Definiia unei clase se numete interfa9.
/+ist o notaie pentru tipurile de date a#stracte pe care le definim

In pro8rame crem %aria#ile de tipul unor clase care se numesc obiecte. 5om spune c
o#iectele sunt instane ale unor clase. K#iectele unei clase sunt create (i iniializate de
funcii mem#re ale clasei special definite pentru acest scop numite constructori.
K#iectele sunt distruse c9nd nu mai sunt necesare de funcii mem#re ale clasei numite
#estructori. 5alorile proprietilor dau starea o#iectului la un moment dat.
.atele (i funciile mem#re ale clasei pot fi pu#lice, pri%ate sau proteNate. em#ri
pu#lici ai clasei pot fi utilizai de orice funcie din pro8ram. em#ri pri%ai ai clasei pot
fi utilizai doar de funciile mem#re ale clasei. em#ri proteNai %or fi prezentai ulterior.
Implicit, toate datele (i funciile unei clase sunt pri%ate.
Arincipiile pro8ramrii orientate o#iect sunt urmtoarele
Arimul principiu al pro8ramrii orientate o#iect este ncapsularea. $cesta cere
com#inarea datelor (i metodelor ntrEo sin8ur structur de date. $cest principiu
cere ascunderea structurii de date (i asi8urarea unei interfee pentru adresarea
datelor. /+emplu. 4umere comple+e. Un numr comple+ este o perec*e ordonat
de numere reale. Aentru a nmuli dou numere comple+e tre#uie s adresm
structura (i s adunm produse ale prile reale si cele ima8inare. .efinind o
operaie mult ncapsulm detaliile (i nmulim dou numere comple+e fr s ne
intereseze cum se face operaia n detaliu.
o(tenirea. $cest principiu cere definirea unei clase 8enerale ce conine
caracteristicile comune ale mai multor elemente. $poi aceast clas este
mo(tenit de alte clase particulare, fiecare adau8 doar elementele proprii. -lasa
care este mo(tenit se nume(te clas de #az, iar clasele care mo(tenesc se
numesc clase deri%ate.
Aolimorfismul. $%em funcii cu acela(i nume n clasa de #az (i n clasele deri%ate.
Funciile din clasele deri%ate redefinesc operaiile necesare claselor deri%ate. -9nd
apelm funcia respecti% se apeleaz %ersiunea corespunztoare tipului o#iectului.
,.1 Definirea unei clase
,.1.1 Definirea unei clase
.ia8rama sintactic a definiiei unei clase este
-lasele sunt definite utilizand cu%antul c*eie class. 6pecificatorii de acces sunt public,
protecte# (i private, identificator este numele clasei, iar mem#ru este o declaraie de
funcie mem#ru sau dat a clasei. Implicit toi mem#ri clasei sunt pri%ai. -a e+emplu
%om defini o clas care reprezint numere raionale ca un c9t a dou numere ntre8i.
.efiniia clasei este urmtoarea
class =atio
:
pri%ate!
int num, dene
pu#lic!
%oid assi8n(int, int)e
dou#le con%ert()e
%oid in%ert()e
%oid print()e
<e
4umele clasei este =atio. .efiniia clasei este inclus ntre accolade : (i <, urmate de e.
.ate mem#re ale clasei sunt num (i den (i ele %or memora numrtorul (i numitorul
numrului raional descris de clas. /le sunt de tip int (i sunt declarate pri%ate. In acest
fel ele %or fi accesi#ile doar funciilor mem#re ale clasei. .nterzicerea accesului #in
afara clasei este un principiu al program9rii orientate obiect numit ascun#erea
informaiilor. Funciile mem#re ale clasei sunt assi8n(), ce atri#uie %alori numrului
raional, con%ert(), ce d %aloarea numrului, in%ert(), ce in%erseaz numrul (i print(), ce
scrie numrul ca un c9t de dou numere ntre8i. /le sunt declarate pu#lice (i %or putea fi
utilizate de o#iecte n afara clasei. Funciile mem#re pot fi definite n interiorul clasei sau
n afara ei. Funciile definite n interiorul clasei sunt funcii inline. -ompilatorul
8enereaz direct te+tul lor n pro8ram, (i nu un apel la funcie.
.n limba@ul C22 avem posibilitatea #e a grupa anumite nume n spaii #e nume.
Prin #efiniie, #atele i funciile unei clase constituie un spaiu #e nume ce are
numele clasei. &peratorul #e rezoluie DD arat9 c9 un nume #e #at9 sau #e funcie
aparine unui spaiu #e nume. &peratorul #e rezoluie DD se utilizeaz9 pentru a
#efini o funcie membru a clasei n afara clasei.
Implementarea clasei este urmtoarea
%oid =atio!!assi8n(int num%al, int denum%al)
:
num 0 num%ale
den 0 den%ale
<
dou#le =atio!!con%ert()
:
return dou#le(num) M dene
<
%oid =atio!!in%ert()
:
int tempe
temp 0 num e
num 0 dene
den 0 tempe
<
%oid =atio!!print()
:
cout __ num __ SMg __ dene
<
$pelul unei funcii a clasei de ctre un o#iect se face conform urmtoarei dia8rame
sintactice

Utilizarea unui c9mp al un o#iect se face conform urmtoarei dia8rame sintactice
5om e+emplifica utilizarea clasei definind un numr rational (i calcul9nd in%ersul lui.
int main()
:
MM creaza un o#iect + de tipul =atio
=atio +e
+.assi8n(2, ))e
MM scrie +
cout __ S+ 0 S e
+.print()e
cout __ S 0 S __ +.con%ert() __ endle
MM in%erseaza numarul
+.in%ert()e
cout __ S1M+ 0 S __e
+.print()e
cout __ endle
<
Declararea unui obiect se face n acelai fel cu #eclararea tipurilor stan#ar#. $om
spune c9 un obiect este o instan9 a unei clase. &rice obiect are propriile variabile.
In funcia main(), + este declarat ca un o#iect de tipul =atio (+ este o instan a clasei
=atio). /l are cele dou data mem#re num (i den (i poate apela funciile mem#re assi8n(),
in%ert() (i print() care au fost declarate pu#lice n definiia clasei.
$cesta este un principiu al pro8ramrii orientate o#iect. ?u utiliz9m variabile i funcii
globale, ci fiecare obiect are propriile lui #ate i funcii.
enionm c n funcia main() nu puteam scrie o instruciune
cout __ +.num __ S S __ +.den __ endle
deoarece %aria#ilele clasei num (i den sunt declarate pri%ate. /le pot fi utilizate doar de
funciile clasei (i nu de o#iecte de tipul clasei. Aentru a putea utiliza datele clasei de ctre
o#iecte ca mai sus, ele ar tre#ui declarate pu#lice.
enionm c n lim#aNul -JJ putem defini clase (i cu cu%9ntul c*eie struct. In acest
caz toi mem#rii clasei sunt declarai implicit ca pu#lici. 6pre deose#ire de lim#aNul -, n
lim#aNul -JJ cu%antul c*eie struct define(te clase.
,.1.2 Pointerul t7is
-onsiderm instruciunile n care un o#iect apeleaz o funcie mem#ru a clasei, de
e+emplu
+.print()e
Funciile clasei au un parametru implicit un pointer de tipul clasei. In acest fel aceste
funcii pot adresa %aria#ilele o#iectului (n cazul nostru ale o#iectului +). Fiecare o#iect
are o %aria#il implicit , numit t7is care este un pointer de tipul clasei ce conine adresa
o#iectului. $tunci c9nd un o#iect apeleaz o funcie a clasei, parametrul implicit al
funciei prime(te ca %aloare pointerul t*is. Aointerul t*is poate fi utilizat n orice funcie
mem#r a clasei pentru a apela %aria#ile sau funcii mem#re. -a e+emplu %om rescrie
funcia in%ert() ca s utilizeze pointerul t*is la apelarea %aria#ilelor num (i den.
%oid =atio!!in%ert()
:
int tempe
temp 0 t*isE"nume
t*isE"num 0 t*isE"dene
t*isE"den 0 tempe
<
,.1.3 4paii #e nume
In lim#aNul -JJ putem defini spaii de nume. Un spaiu de nume ne permite s 8rupm o
mulime de clase, o#iecte (i funcii 8lo#ale su# un nume. .efiniia unei clase creaz
automat un spaiu cu numele clasei ce cuprinde toate %aria#ilele (i funciile mem#re ale
clasei. .eclararea unui spaiu de nume se face astfel
namespace identificator
:
MM declaraii de clase, funcii, o#iecte
<
.e e+emplu, putem defini urmtorul spaiu
namespace 8eneral
:
int a, #e
<
Aentru a adresa %aria#ilele din afara spaiului se utilizeaz operatorul de rezoluie DD
.e e+emplu, scriem
8eneral!!a
.irecti%a using namespace asociaz un spaiu de nume cu un anumit ni%el al
pro8ramului, astfel nc9t o#iectele (i funciile din acel spaiu sunt accesi#ile direct ca (i
c9nd ar fi fost definite ca 8lo#ale. $ceast directi% are forma
usin8 namespace identificatore
"oate clasele, obiectele i funciile #in bibliotecile C22 stan#ar# sunt #efinite n
spaiul st#. In consecin, o#iectul cout corespunztor streamului de ie(ire standard poate
fi utilizat astfel
Folosind directi%a usin8 namespace
&&&&&&&&&&&&&&
cout __ endle
Utiliz9nd numele spaiului
&&&&&&&&&&&&&&
cout std!!cout __ std!!endle
Utiliz9nd stilul clasic tip - n care toate clasele, o#iectele (i funciile din
#i#liotecile standard sunt definite ntrEun spaiu 8lo#al.
&&&&&&&&&&&&&&..
cout __ endle
enionm c la utilizarea stilului clasic tip - se utilizeaz #i#liotecile standard cu
e+tensia *, de e+emplu _stdio.*", _iostream.*", _mat*.*", etc. Ia utilizarea cu spaii de
nume se utilizeaz #i#liotecile paralele, fr e+tensia *, de e+emplu _cstdio",
_iostream", _cmat*", etc.
,.2 Constructori i #estructori
,.2.1 Constructori
In 8eneral o#iectele tre#uie s iniializeze %aria#ilele lor la declararea o#iectului. In
e+emplul precedent iniializarea sEa fcut cu funcia assi8n(). /ste mai natural ca
iniializarea s se fac la declararea o#iectului. Aentru aceasta se definesc funcii
constructor ale clasei. Nn constructor este o funcie membru a clasei apelat9 automat
atunci cEn# obiectul este #eclarat. Constructorul are acelai nume cu al clasei i nu
are nici un tip.
-lasa precedent poate a%ea un constructor definit ca mai Nos.
Tinclude _iostream"
class =atio
:
pri%ate!
int num, dene
pu#lic!
%oid assi8n(int, int)e
dou#le con%ert()e
%oid in%ert()e
%oid print()e
=atio(int, int)e
<e
5om prezenta n continuare doar definiia constructorului, restul definiiilor fiind cele
anterioare.
=atio!!=atio(int a, int #)
:
num 0 ae
den 0 #e
<
5om e+emplifica utilizarea acestei clase definind dou o#iecte (i afi(9nd %alorile lor.
int main()
:
=atio +(E2, 12), @(2, 3)e
cout __ S+ 0 Se
+.print()e
cout __ endle
cout __ S@ 0 Se
@.print()e
cout __ endle
return 0e
<
&rice clas9 are cel puin #oi constructori. +i sunt i#entificai #e #eclaraia lor
OFGM 00 constructorul implicit
OFconst OJGM 00 constructorul copiere
un#e O numele clasei.
Constructorul implicit nu are parametri. +l este apelat ori #e cEte ori #eclar9m un
obiect cu instruciunea
O obiectM
Dac9 nu #efinim niciun constructor, constructorul implicit este #efinit #e
compilator.
Constructorul copiere este apelat atunci cEn# un obiect este copiat. De e!emplu
instruciunea
O aFbGM
#eclar9 un obiect a #e tipul O i i atribuie ca valoare obiectul b. Dac9 nu #efinim un
constructor copiere, el este #efinit #e compilator. %enion9m cuvEntul c7eie const
#in #efiniia constructorului copiere. +l interzice mo#ificarea argumentului n
timpul copierii.
&rice clas9 inclu#e un operator implicit #e atribuire H care are ca parametru un
obiect #e tipul clasei.
/+emplu. Fie din nou clasa =atio n care definim un constructor copiere, un constructor
fr parametri, (i un constructor cu parametri.
class =atio
:
pu#lic!
=atio(int, int)e
=atio(const =atioX +)e
=atio()e
%oid print()e
%oid in%ert()e
pri%ate!
int nume
int dene
<e
5om prezenta doar definiiile constructorilor, definiiile funciilor print() (i in%ert() sunt
cele anterioare.
=atio!!=atio(const =atioX +)
:
num 0 +.nume
den 0 +.dene
<
=atio!! =atio()
:
num 0 0e
den 0 1e
<
=atio!!=atio(int +, int @)
:
num 0 +e
den 0 @e
<
int main()
:
=atio +(12, 23)e
=atio ze
=atio @(+)e MM se apeleaza constructorul copiere
+.print()e
@.print()e
z 0 +e
z.print()e
<
-onstructorul copiere este apelat ori de c9te ori
un o#iect este copiat
un o#iect este pasat prin %aloare unei funcii (o#iectul este copiat n sti%)
un o#iect este returnat ca %aloare de o funcie
/+emplu. Aresupunem clasa =atio definit anterior. Fie o funcie 8lo#al f care are ca
parametru un o#iect de tip =atio (un numr raional) (i ca rezultat un o#iect de tip =atio
care este in%ersul parametrului funciei. .efinitia funciei este urmtoarea
=atio f(=atio r) MM se apeleaza constructorul copiere
:
=atio s 0 re MM se apeleaza constructorul copiere
s.in%ert()e
return se MM se apeleaza constructorul copiere
<
int main()
:
=atio +(11, 22)e
=atio @(+)e
=atio ze
MM scrie numarul +
+.print()e
z 0 f(@)e
MM scrie numrul z
z.print()e
return 0e
<
-onstructorul copiere este apelat
1) atunci c9nd se declar o#iectul
=atio @(+)e
2) c9nd se apeleaz funcia
z 0 f(@)e
Aarametrul funciei f (r n definiia funciei) este pasat prin %aloare, deci n sti% se pune o
copie a o#iectului creat cu constructorul copiere.
1) c9nd se e+ecut instruciunea
return se
o#iectul s se copiaz n sti% utilizand constructorul copiere.
enionm c definiia funciei f putea fi
=atio f(const =atio r)e
deoarece funcia nu modific parametrul r.
Putem #efini tablouri #e obiecte n mod o#i(nuit, de e+emplu
=atio +G20He
Pentru aceasta, clasa trebuie s9 #efineasc9 un constructor f9r9 parametri. Va#loul
definit poate fi prelucrat, de e+emplu putem a%ea instruciunile
=atio ae
a 0 +G3He
,.2.2 Destructori
.estructorul unei clase este apelat automat c9nd un o#iect este distrus. Fiecare clas are
un sin8ur destructor. .estructorul nu are tip (i nici parametri. .ia8rama sintactic a
destructorului este urmtoarea
b numedclasa():M7 corpul destructorului7M<
.ac el nu este definit e+plicit, compilatorul 8enereaz unul. Aentru a %edea cum sunt
apelai constructorii (i destructorul fie urmtoarea clas n care constructorul (i
destructorul scriu un mesaN.
class =atio
:
pu#lic!
=atio() :cout __ So#iectul este creatg __ endle<
b=atio() :cout __ So#iectul este distrusg __ endle<
pri%ate!
int nume
int dene
<e
Fie dou #locuri de instruciuni n funcia main. In fiecare #loc crem c9te un o#iect.
int main()
:
:
cout __ Sincepe #locul 1g __ endle
=atio +e
cout __ Siesire #locul 1g __ endle
<
:
cout __ Sincepe #locul 2g __ endle
=atio @e
cout __ Ssfar(it #locul 2g __ endle
<
<
esaNe le scrise %or fi!
incepe #locul 1
o#iectul este creat
iesire #locul 1
o#iectul este distrus
incepe #locul 2
o#iectul este creat
iesire #locul 2
o#iectul este distrus
enionm c toate %aria#ilele locale unei funcii sau unui #loc sunt create intrEo sti% la
intrarea n funcie sau #loc (i sunt (terse din sti% la ie(irea din funcie sau #loc. 6ti%a se
nume(te *eap.
,.3 1uncii prietene
In 8eneral a%em ne%oie s utilizm (i s modificm datele unui o#iect n timpul e+ecuiei
pro8ramului. .ac datele sunt declarate pri%ate, nu putem face acest lucru direct. .e
aceea se definesc funcii care s modifice (i s furnizeze %alorile datelor unui o#iect. In
cazul clasei =atio putem defini funcii mem#re ale clasei
int 8etnum()e
int 8etden()e
%oid setnum(int)e
%oid setden(int)e
$ceste funcii se numesc funcii de acces (i de re8ul sunt pu#lice.
.efiniiile acestor funcii pot fi
int =atio!!8etnum()
:
return nume
<
%oid =atio!!setnum(int +)
:
num 0 +e
<
/+emplu. 5om defini o funcie 8lo#al care s adune dou numere raionale. Arototipul
funciei %a fi
=atio sum(const =atio +, const =atio @)e
Aarametrii + (i @ sunt cele dou numere raionale ce sunt adunate. .eoarece o#iectele nu
%or fi modificate, ele au fost declarate const.
-onsiderm dou numere rationale,
b
a
r
(i
d
c
s
. 6uma lor %a fi
bd
bc ad
t
+
. In
implementarea funciei nu putem folosi direct %aria#ilele num (i den, deoarece ele sunt
declarate pri%ate n definiia funciei. 5om utiliza funciile 8etnum() (i 8etden() pentru a
o#ine %aloarea lor. Implementarea funciei este urmtoarea
=atio sum(=atio +, =atio @)
:
int a 0 +.8etnum()e
int # 0 +.8etden()e
int c 0 @.8etnum()e
int d 0 @.8etden()e
=atio temp(a 7 d J # 7 c, # 7 d)e
return tempe
<
K alt soluie este urmtoarea. Pentru ca o funcie e!tern9 s9 aibe acces la membri
privai ai clasei, ea trebuie #eclarat9 n #efiniia clasei ca funcie prieten9, frien#.
.ia8rama sintactic a definiiei unei funcii prietene este
friend tip numedfuncie ( parametri)e
4oua definiie a clasei =atio este
class =atio
:
pu#lic!
=atio(int, int)e
=atio()e
%oid print()e
%oid in%ert()e
friend =atio sum(=atio +, =atio @)
pri%ate!
int nume
int dene
<e
In aceast definiie funcia sum a fost declarat prieten, deci poate utiliza %aria#ilele
pri%ate ale clasei. Implementarea funciei sum este urmtoarea
=atio sum(=atio +, =atio @)
:
=atio temp(+.num 7 @.den J +.den 7 @.num, +.den 7 @.den)e
return tempe
<
,.4 1iierele stan#ar# C22
Iim#aNul -JJ define(te clasele istream (i ostream pentru operaii intrare (i ie(ire cu
fi(ierele standard, tastatura (i ecranul. 6treamul cin este un o#iect de tipul istream, iar
streamurile cout, cerr (i clo8 sunt o#iecte de tipul ostream. $ceste o#iecte sunt definite n
#i#liotecile _iostream.*" (i _iostream".
-lasa istream define(te operatorul de citire "" (i funcii ce citesc caractere $6-II (i
(iruri tip -. Funciile
int 8et()e
istreamX 8et(c*arX)e
citesc un c*aracter. Funciile
istreamX 8et(c*ar7 s, int size, c*ar c*)e
istreamX 8etline(c*ar7 s, int size, c*ar c*)e
cite(te cel mult size E 1 caractere n %ectorul s. -itirea se opre(te dup citirea a size E 1
caractere sau la ntalnirea caracterului c*. 5aloarea implicit a caracterului c* este YOnf.
-lasa ostream define(te operatorul de scriere __ (i funcia
ostreamX put(c*ar)e
ce scrie un c*aracter.
c*ar ce
Instruciunile
cin.8et(c)e
(i
c 0 cin.8et()e
citesc un caracter de la tastatur n %aria#ila c.
enionm c operatorul "" este un operator #inar. Kperandul st9n8 este un o#iect tip
istream, oparandul drept este o %aria#il, rezultatul este o referin la un o#iect tip
istream. jin9nd cont de prototipul funciei 8et
istreamX 8et(c*arX)e
este posi#il s scriem
c*ar ce
int +e
cin.8et(c) "" +e
deoarece operandul st9n8 este o referin tip istream, rezultatul e%alurii funciei
8et(c*arX).
Voate operaiile de scriere de p9n acum n streamul cout nu au utilizat un format. /ste
posi#il de a preciza formatul informaiei scrise n felul urmtor
putem insera spaii sau caracterul YOtf
cout __ s __ S S __ YOtf __ + __ endle
putem insera manipulatori definii n #i#lioteca _iomanip" sau _iomanip.*".
Implicit, orice %aloare este scris pe un numr de caractere specificat sau pe
numrul de caractere necesare. .e e+emplu, numrul ntre8 121 este totdeauna
scris pe cel puin 1 caractere. Funcia
setC(int C)e
d dimensiunea c9mpului n care este scris %aloarea. .imensiunea implicit a
c9mpului este 0. Funcia
setfill(c*ar c)e
d caracterul c cu care sunt umplute spaiile li#ere. 5aloarea implicit este spaiu.
/+emplu. Fie %aria#ila
int W 0 1'2e
scris cu di%erse dimensiuni ale campului (i caractere de umplere.
Instruciunea de scriere =ezultat
cout __ iGi __ setC(?) __ W __ iHi __ endle G 1'2H
cout __ iGi __ setC(?) __ setfill(k7k) __ W __ iHi __ endle G7771'2H
Funcia setC() care d dimensiunea c9mpului este %ala#il doar pentru c9mpul
urmtor.
Funcia
setprecision(int p)e
d numrul p de caractere pe care este scris un numr real, tip float sau dou#le.
/+emple. Fie %aria#ila
float + 0 1.123'e
scris cu diferite precizii. .e remarcat c %aloarea scris este rotunNit.
cout __ pi __ endle 1.123'
cout __ setprecision(1) __ pi __ endle 1.13
cout __ setprecision(2) __ pi __ endle 1.12?
cout __ setprecision(?) __ pi __ endle 1.123'
-lasa ios define(te urmtoarii specificatori
dec E pentru #aza 10
*e+ E pentru #aza 1?
oct E pentru #aza >
s*oC#ase pentru specificarea #azei
6pecificatorul s*oC#ase scrie 0+ pentru numere n #aza 1? (i 0 pentru numere n
#aza >. /+emple. Fie %aria#ila
int W 0 2'e
scris n #aze diferite
cout __ *e+ __ ie 11
cout __ *e+ __ s*oC#ase __ ie 0+11
cout __ oct __ ie 13
cout __ oct __ s*oC#ase __ ie 013
6pecificatorii urmtori specific modul de cadrare a %alorii scrise
left E cadrare la st9n8a
ri8*t E cadrare la dreapta
6pecificatorii urmtori specific modul de scriere a numerelor reale
fi+ed E scriere fr e+ponent
scientific E scriere cu e+ponent
/+emple. Fie instruciunea
float f 0 22.13e
cout __ fi+ed __ f __ endle 22.13
cout __ scientific __ f __ endle 2.213eJ001
Cap. - 4upranc9rcarea operatorilor
Kperatorii lim#aNului -JJ sunt automat definii pentru tipurile fundamentale! int, dou#le,
c*ar, etc. -9nd definim o clas nou, crem un nou tip. Kperatorii lim#aNului pot fi
definii (i pentru tipurile nou create. $ceast operaie se nume(te supranc9rcarea
operatorilor Foperator overloa#ingG. Aentru a suprancarca un operator definim o
functie de forma
tip operator semn (parametri) :M7 corpul funciei 7M<
unde semn este operatorul dorit J,E, 7, M , GH, (), __, "", 0, etc. Kperatorii suprancrcai
au aceea(i prioritate ca cei ori8inali (i acela(i numr de parametri. enionm c orice
operator suprancrcat poate fi definit ca funcie mem#r a clasei sau ca funcie 8lo#al.
/+emplu. 6 suprancrcm operatorul J pentru clasa =atio, care s adune dou numere
raionale. Kperatorul %a fi definit ca o funcie 8lo#al.
=atio operatorJ(=atio +, =atio @)
:
int a 0 +.8etnum()e
int # 0 +.8etden()e
int c 0 @.8etnum()e
int d 0 @.8etden()e
=atio temp(a 7 d J # 7 c, # 7 d)e
return tempe
<
6e %a compara aceast funcie cu funcia sum definit anterior. Funcia are doi parametri,
numerele de adunat deoarece este o funcie 8lo#al. Autem utiliza funcia definit astfel
int main()
:
=atio +(2, 1), @(1, E3), ze
z 0 + J @e
z.print()e
return 0e
<
Autem defini operatorul ca funcie prieten a clasei. In definiia clasei %om scrie
instruciunea
friend =atio operatorJ (=atio, =atio)e
In acest caz definiia funciei este
=atio operatorJ(=atio +, =atio @)
:
=atio temp(+.num 7 @.den J +.den 7 @.num, +.den 7 @.den)e
return tempe
<
$l doilea mod de a defini operatorul J este ca funcie mem#r a clasei. K funcie mem#r
a clasei este apelat de un o#iect. Fie a, #, c o#iecte de tip =atio. Autem scrie
c 0 a.operatorJ(#)e
sau, ec*i%alent
c 0 a J #e
.e accea, atunci c9nd operatorul este o funcie mem#r a clasei, funcia corespunztoare
are un sin8ur parametru, operandul drept, (i este apelat de operandul st9n8. .efiniia
clasei =atio cu operatorul J este
class =atio
:
pu#lic!
=atio(int, int)e
=atio()e
%oid print()e
%oid in%ert()e
=atio operatorJ(=atio)e MM functia are un sin8ur parametru
pri%ate!
int nume
int dene
<e
Implementarea funciei este
=atio =atio!!operatorJ(=atio +)
:
=atio temp(num 7 +.den J den 7 +.num, num 7 +.den)e
return tempe
<
=atio a(1, 1), #(2, E1), ce
Instruciunile
c 0 a J #e
(i
c 0 a.operatorJ(#)e
sunt ec*i%alente.
-.1 4upranc9rcarea operatorului #e atribuire
-onsiderm clasa definit anterior n care definim constructorul implicit, constructorul
copiere (i operatorul de atri#uire. enionm c operatorul de atri#uire este automat
definit pentru orice clas. 6uprancrcarea lui aici este doar un e+erciiu. K definiie
incorect9 a operatorului de atri#uire este urmtoarea
class =atio
:
pri%ate!
int num, dene
pu#lic!
=atio()e
=atio(const =atioX)e
%oid operator 0 (const =atioX)e
<e
K implementare a definiei incorecte a operatorului de atri#uire suprancrcat este
urmtoarea
%oid =atio!!operator 0 (const =atioX r)
:
num 0 r.nume
den 0 r.dene
<
/a copiaz o#iectul r n o#iectul ce apeleaz operatorul. Fie de e+emplu instruciunea
=atio +, @, ze
-u aceast definiie putem scrie
+ 0 ze
@ 0 ze
dar nu putem scrie
+ 0 @ 0 ze
deoarece rezultatul funciei este %oid.
Aentru a %edea care este definiia corect a operatorului de atri#uire considerm
instruciunea
int +, @, z 0 2e
Iim#aNul permite o instruciune de atri#uire de forma
+ 0 @ 0 z 0 2e
Kperatorul 0 este asociati% la dreapta (i are ca rezultat %aloarea atri#uit operandului
st9n8. Arima dat se e+ecut instruciunea
z 0 2e
apoi
@ 0 ze
etc. Autem scrie instruciunea de mai sus
f(+, f(@, f(z, 2)))e
In consecin, operatorul tre#uie s ai#e ca rezultat o referin de acela(i tip cu %aloarea
pe care o atri#uie (tipul operandului st9n8). In acest fel operatorul este asociati% la
dreapta. Definiia corect9 a operatorului #e atribuire al clasei Ratio este
RatioJ operator H Fconst Ratio J GM
.efiniia clasei %a fi
class =atio
:
pri%ate!
int num, dene
pu#lic!
=atio()e
=atio(const =atioX)e
=atioX operator 0 (const =atioX)e
<
Prototipul operatorului #e atribuire al unei clase " este
"J operator H Fconst "JGM
Kperatorul are ca rezultat o referin la o#iectul ce apeleaz operatorul. Aentru aceasta se
utilizeaz pointerul t7is. Implementarea corect a operatorului de atri#uire suprancrcat
este urmtoarea.
=atioX =atio!!operator 0 (const =atioX r)
:
MM o#iectul ce a apelat operatorul primeste %aloarea o#iectului r
num 0 r.nume
den 0 r.dene
MM rezultatul funciei este referinta o#iectului ce a apelat operatorul
return 7t*ise
<
Autem scrie acum
=atio +, @, z(2, 1)e
+ 0 @ 0 ze
-.2 4upranc9rcarea operatorilor aritmetici
Aresupunem c %rem s definim o clas pentru lucrul cu numere comple+e. 5rem s
putem efectua operatii cu numere comple+e la fel ca (i cu tipurile fundamentale, de
e+emplu s definim numere comple+e
-omple+ a(1.0, E1.0), #(2.0, E1), ce
(i s scriem pentru adunare
c 0 a J #e
Iim#aNul ne d posi#ilitatea de a defini funcii care s efectueze operaiile standard J,E,
etc., pentru operanzi ce sunt o#iecte ale unor clase. $cest lucru se nume(te
supranc9rcarea operatorilor Foperator overloa#ingG. Un operator poate fi definit ca o
funcie 8lo#al sau ca o funcie mem#ru a clasei. 5om e+emplifica suprancrcarea
operatorului J pentru o clas ce descrie numere comple+e. K reprezentare a clasei este
cea de mai Nos.
/+emplu. 6uprancrcarea operatorului J pentru clasa -omple+ n cazul n cazul n care
operatorul este o funcie 8lo#al. Funcia are numele operatorJ (i doi parametri de tip
-omple+, numerele ce se adun. Vipul funciei este -omple+. .efiniia funciei este
-omple+ operatorJ(-omple+, -omple+)e
-onsiderm definiia clasei -omple+ de mai Nos.
class -omple+
:
pri%ate!
float reale
float ima8e
pu#lic!
-omple+()e
-omple+ (float, float)e
<e
Aro#lema scrierii funciei este aceea c datele clasei -omple+ sunt declarate pri%ate (i nu
pot fi utilizate direct de funcie, care este 8lo#al. K soluie este de a scrie dou funcii
mem#re ale clasei, de e+emplu
float 8etreal()e
float 8etima8()e
care au ca rezultat %aria#ilele real (i ima8 ale clasei. $ceast soluie rmane ca e+erciiu.
K alt soluie este urmtoarea. Pentru ca o funcie e!tern9 s9 aibe acces la membrii
privai ai clasei, ea trebuie #eclarat9 n #efiniia clasei ca funcie prieten9, frien#.
.ia8rama sintactic a definiiei unei funcii prietene este
In consecin, definiia clasei -omple+ %a fi
class -omple+
:
pri%ate!
float reale
float ima8e
pu#lic!
-omple+()e
friend -omple+ operatorJ(-omple+, -omple+)e
<e
.efiniia funciei %a fi cea de mai Nos.
-omple+ operatorJ(-omple+X +, -omple+X @)
:
-omple+ tempe
temp.real 0 +.real J @.reale
temp.ima8 0 +.ima8 J @.ima8e
return tempe
<
Vre#uie ca n definiia clasei s includem un constructor implicit, fr parametri
-omple+()e
-onstructorul implicit nu mai este 8enerat automat de compilator deoarece am definit un
constructor. -onstructorul implicit este apelat la declararea o#iectului temp
-omple+ tempe
n funcia operatorJ.
/+emplu. 6uprancrcarea operatorului J pentru clasa -omple+ n cazul n care
operatorul este definit ca o funcie mem#r a clasei, al crei nume este operatorJ. K
funcie mem#ru a clasei este apelat de un o#iect. In consecin, %om scrie
c 0 a.operatorJ(#)e
sau, ec*i%alent
c 0 a J #e
.e accea, atunci c9nd operatorul este o funcie mem#r a clasei, funcia corespunztoare
are un sin8ur parametru, operandul drept, (i este apelat de operandul st9n8. Fie definiia
clasei -omple+ n care definim (i funcia operatorJ
class -omple+
:
pri%ate!
float reale
float ima8e
pu#lic!
-omple+()e
-omple+ operatorJ (-omple+)e
<e
Implementarea constructorilor este
-omple+!!-omple+(float +, float @)
:
real 0 +e
ima8 0 @e
<
-omple+!!-omple+()
:
real 0 0e
ima8 0 0e
<
Implementarea operatorul J este urmtoarea.
-omple+ -omple+!!operatorJ(-omple+ p)
:
-omple+ tempe
temp.real 0 real J p.reale
temp.ima8 0 ima8 J p.ima8e
return tempe
<
Vre#uie ca n definiia clasei s includem un constructor implicit, fr parametri
-omple+()e
-omple+ tempe
n funcia operatorJ.
/+erciiu. 6 se scrie implementarea operatorilor de scdere, E, nmulire, 7 (i mprire, M
a dou numere comple+e.
-.3 4upranc9rcarea operatorilor :: i ;;
Kperatorul __ este numit operator de inserie, el insereaza caractere ntrEun stream.
Kperatorul "" este numit operator de e+tracie, el e+tra8e caractere dintrEun stream.
Voate functiile de inserie au forma
ostreamX operator __ (ostreamX stream, tip o#iect)
:
MM corpul functiei
return streame
<
Arimul parametru este o referin la streamul de ie(ire. $l doilea este o#iectul ce tre#uie
inserat. Ultima instruciune este
return streame
/+emplu. Kperatorul de inserie __ pentru clasa -omple+. In definiia clasei definim
funcia
friend ostreamX operator __ (ostreamX stream, -omple+ +)e
Implementarea funciei este
ostreamX operator __ (ostreamX stream, -omple+ +)
:
stream __ i(i __ +.real __ i,i __ +.ima8 __ i)ie
return streame
<
/+emplu. Kperatorul de e+tracie "" este suprancrcat astfel
friend istreamX operator "" (istreamX stream, -omple+X +)e
Implementarea lui este urmtoarea
istreamX operator "" (istreamX stream, -omple+X +)
:
stream "" +.real "" +.ima8e
return streame
<
-9nd un operator este mem#ru al unei clase, operandul st9n8 (transmis prin t*is) este cel
care apeleaza operatorul. Kperatorii __ (i "" pe care iEam definit nu pot fi mem#ri ai
clasei deoarece operandul st9n8 ostream, respecti% istream nu este un mem#ru al clasei.
In consecin, ace(ti operatori %or fi funcii e+terne. Reamintim c9 pentru ca o funcie
e!tern9 s9 aibe acces la membrii privai ai clasei, ea trebuie #eclarat9 n #efiniia
clasei ca funcie prieten9 frien#. .ia8rama sintactic a definiiei unei funcii prietene
este
.efiniia clasei este
class -omple+
:
pri%ate!
float reale
float ima8e
pu#lic!
-omple+ operatorJ (-omple+)e
friend ostreamX operator __ (ostreamX, -omple+X)e
friend istreamX operator "" (istreamX, -omple+X)e
<
Autem utiliza operatorii definii astfel
int main()
:
-omple+ a(1.0, 1.0)e
-omple+ #(0.0, 1.0)e
-omple+ ce
c 0 a J #e
MM ec*i%alent putem scrie
c 0 a.operatorJ(#)e
cout __ c __ endle
return 0e
<
Vre#uie ca n definiia clasei s includem un constructor implicit, fr parametri, de
e+emplu
-omple+() :real 0 0e ima8 0 0e<
-omple+ tempe
n funcia operatorJ (i n funcia main(). /ste de dorit ca acest constructor s iniializeze
%aria#ilele o#iectului.
&rice clas9 inclu#e un operator implicit #e atribuire H care are ca parametru un
obiect #e tipul clasei.
Cap. 1/ %otenirea
1/.1 Pointeri la obiecte. &peratorii ne6 i #elete
K clas, odat definit, este un tip %alid. Autem defini %aria#ile tip pointer la clase la fel
cu pointeri la orice tip. K %aria#il tip pointer la o clas poate fi iniializat cu adresa unui
o#iect iar datele (i funciile acelui o#iect pot apelate utiliz9nd pointerul.
Instruciunea de definire a unui pointer la o clas este
tip 7 identificatore
unde tip este numele clasei iar identificator este numele %aria#ilei tip pointer.
5aria#ila tip pointer poate fi iniializat ca orice %aria#il tip pointer, folosind operatorul
de calcul al adresei X.
Fie p un pointer la un o#iect. Un c9mp al o#iectului este adresat astfel
(7p).mem#ru
Arin definiie, aceast scriere se prescurteaz
pE"mem#ru
K funcie mem#r a clasei se apeleaz astfel
(7p).funcie(parametri)e
Arin definiie, aceast scriere se prescurteaz astfel
pE"funcie(parametri)e
&peratorii . i 3; au aceeai prioritate ca operatorii FG i BC.
/+emplu. Fie o clas ce define(te un dreptun8*i. -lasa are ca %aria#ile lun8imea (i
limea dreptun8*iului, funcii de acces la %aria#ilele clasei, (i o funcie care calculeaz
aria.
class =ectan8le
:
pri%ate!
float *e
float #e
pu#lic!
float aria()e
=ectan8le(float, float)e
float 8et*()e
float 8et#()e
%oid set*(float)e
%oid set#(float)e
<e
=ectan8le!!=ectan8le(float +, float @)
:
* 0 +e
# 0 @e
<
float =ectan8le!!aria()
:
return * 7 #e
<
float =ectan8le!!8et*()
:
return *e
<
%oid =ectan8le!!set*(float +)
:
* 0 +e
<
Funciile 8et#() (i set#() se definesc la fel ca 8et*() (i set*().
5om apela funciile clasei direct (i prin pointer.
int main()
:
=ectan8le d1(1.2, 2.3)e
MM defineste un pointer la o#iect
=ectan8le 7 pd1e
pd1 0 Xd1e
MM apeleaza functiile direct
cout __ Sinaltimea 0 S __ d1.8et*() __ endl
__ Slatimea 0 S __ d1.8et#() __
__ Saria 0 S__ d1.aria() __ endle
MM apeleaza functiile prin pointer
cout __ Sinaltimea 0 S __ pd1E"8et*() __ endl
__ Slatimea 0 S __ pd1E"8et#() __
__ Saria 0 S__ pd1E"aria() __ endle
<
/+ist trei moduri de a crea o#iecte.
K#iecte 8lo#ale declarate la ni%elul pro8ramului, n afara oricrei funcii. /le sunt
create la inceputul e+ecuiei pro8ramului (i distruse la sf9r(itul e+ecuiei.
K#iecte locale, declarate n funcii sau n #locuri din funcii, ntre : (i < /le sunt
create la intrarea n #loc (i distruse la ie(irea din #loc.
K#iecte create n memorie cu operatorul ne6. /le tre#uie distruse cu operatorul
#elete c9nd nu mai sunt necesare. /le sunt create ntrEo zon special de memorie
denumit *eap.
Kperatorul ne6 creaz un o#iect n memorie apeland constructorul (i furnizeaz adresa
o#iectului nou creat, adic un pointer. .ia8rama sintactic este
ptr 0 neC tip (list de parametri)e
tip este numele unei clase iar ptr este %aria#il tip pointer. Kperatorul delete are forma
delete ptre
unde ptr este %aria#ila tip pointer cu adresa o#iectului.
/+emplu. 5om considera aceea(i clas =ectan8le, %om crea un o#iect, (dreptun8*i), cu
operatorul neC (i %om scrie dimensiunile (i aria lui.
int main()
:
=ectan8le 7 ptre
MM creaza o#iectul cu operatorul neC
ptr 0 neC =ectan8le(2.3, 1).1)e
MM functii apelate prin pointer
cout __ Sinaltimea 0 S __ ptrE"8et*() __ endl
__ Slatimea 0 S __ ptrE"8et#() __
__ Saria 0 S__ ptrE"aria() __ endle
MM distru8e o#iectul
delete ptre
return 0e
<
Autem crea %ectori de o#iecte cu operatorul neC. Aentru aceasta clasa tre#uie s ai# un
constructor fr parametri. .e e+emplu, putem crea un %ector cu zece o#iecte de tip
-omple+
-omple+ 7 %ecte
%ect 0 neC -omple+G10He
$cest %ector se (ter8e cu operatorul delete cu forma
delete GH %ecte
1/.2 %otenirea
%otenirea este un concept al program9rii cu obiecte. %otenirea permite s9 cre9m
clase care sunt #erivate #in alte clase e!istente, astfel ncEt ele inclu# unii #intre
membri claselor p9rinte, variabile i funcii. Clasa #erivat9 motenete membrii
clasei p9rinte, funcii i variabile. .n acest fel putem construi programe comple!e
#in obiecte simple. Clasa care este motenit9 se numete clas9 #e baz9, iar clasele
care motenesc se numesc clase #erivate. Clasa #e baz9 conine caracteristicile
comune ale mai multor elemente. Clasele care motenesc sunt clase particulare ce
a#aug9 #oar elementele proprii.
.ia8rama sintactic a definirii unei clase deri%ate este
class numedclasadderi%ata ! acces numedclasad#aza
:
MM definitia clasei deri%ate
<e
In aceast definiie cu%9ntul c*eie acces poate fi pu#lic, protected sau pri%ate.
6emnificaia acestui termen %a fi prezentat ulterior.
/+emplu. 5rem s definim dou clase =ectan8le (i Vrian8le care s descrie dreptun8*iuri
(i respecti%e triun8*iuri. -lasele au n comun dou %aria#ile ce conin #aza (i nalimea (i
o funcie ce d %alori acestor %aria#ile. 5om defini deci o clas de #az numit Aol@8on
ce are dou %aria#ile * (i #, nlimea (i limea, declarate aici cu acces proteNat,
(protected), un constructor fr parametri, o funcie set%al() ce d %alori acestor %aria#ile
(i o funcie print() ce afi(az %alorile %aria#ilelor.
class Aol@8on
:
protected!
float *, #e
pu#lic!
%oid set%al(float +, float @):* 0 +e # 0 @e<
Aol@8on() :* 0 0e # 0 0e<
%oid print() :cout __ S# 0 S __ # __ S,g __ S * 0 S, __ * __ endle<
<e
5om defini cele dou clase care descriu triun8*iuri (i dreptun8*iuri deri%ate din clasa
Aol@8on. -lasele %or a%ea o funcie ce calculeaz aria. K reprezentare 8rafic a acestei
dependene este cea de mai Nos.
.efiniia claselor deri%ate este urmtoarea.
class =ectan8le ! pu#lic Aol@8on
:
pu#lic!
float area:return * 7 #e<
<e
class Vrian8le ! pu#lic Aol@8on
:
pu#lic!
float area:return * 7 # M 2e<
<e
Un e+emplu de utilizare a acestor clase n care calculm aria unui triun8*i (i a unui
dreptun8*i este urmtorul.
int main()
:
=ectan8le drpte
Vrian8le tr8*e
drpt.set%al(1.1, 2.2)e
tr8*.set%al(2.1, 12)e
cout __ Striun8*ig __ endle
cout __ tr8*.area() __ endle
cout __ Sdreptun8*ig __ endle
cout __ drpt.area() __ endle
<
$m definit %aria#ilele clasei de #az * (i # de tipul protecte#. In acest caz ele pot fi
utilizate n clasele deri%ate, dar nu pot fi utilizate de o#iecte. .e e+emplu, nu putem scrie
instruciunea
cout __ tr8*.* __ endle
Aentru a afi(a %alorile %aria#ilelor # (i * am definit funcia print().
5om prezenta acum semnificaia cu%9ntului c*eie acces din definiia clasei deri%ate. Fie
definiia unei clase
class ,aza
:
pu#lic!
int +e
protected!
int @e
<
(i fie o clas deri%at cu specificatorul de acces pu#lic
class .eri% ! pu#lic ,aza
:
M7 declaratii din clasa .eri% 7M
<
In acest caz %aria#ilele + (i @ au n clasa .eri% specificatorul de acces definit n clasa
,aza, respecti% pu#lic (i protected (i pot fi utilizate de funciile definite n clasa .eri%,
dar numai %aria#ila + poate fi utilizat de o#iectele de tipul .eri%.
-onsiderm clasa deri%at definit cu specificatorul de acces protected
class .eri% ! protected ,aza
:
<
In acest caz %aria#ilele + (i @ au n clasa .eri% specificatorul de acces protected. /le pot
fi utilizate de funciile definite n clasa .eri%, dar nu pot fi utilizat de o#iecte de tipul
.eri%.
-onsiderm clasa deri%at definit cu specificatorul de acces pri%ate
class .eri% ! pri%ate ,aza
:
<
In acest caz toate %aria#ilele + si @ din clasa ,aza au n clasa .eri% specificatorul de
acces pri%ate.
%enion9m c9 #atele i funciile #eclarate private n clasa #e baz9 nu pot fi utilizate
n clasele #erivate sau #e obiecte #e tipul claselor #erivate.
6pecificatorul de acces din definiia clasei deri%ate d ni%elul minim de acces pentru
mem#rii mo(tenii din clasa de #az. Ia utilizarea specificatorului de acces pu#lic, clasa
deri%at mo(tene(te toi mem#rii clasei de #az cu ni%elul de acces a%ut n clasa de #az.
Autem sumariza acum accesul la %aria#ilele unui o#iect n funcie de specificatorii lor
specificatorul de acces al %aria#ilei
Au#lic protected pri%ate
em#ri ai aceleia(i clase da da da
em#ri claselor deri%ate da da nu
4emem#ri da nu nu
/+emplu. Fie clasele D (i [ definite dup cum urmeaz
class D
:
pu#lic!
int +e
protected!
int @e
pri%ate!
int ze
<e
class [ ! pu#lic D
:
pu#lic!
int Ce
<e
Fie dou o#iecte definite astfel
D ae
[ #e
-9mpurile celor dou o#iecte, a (i # sunt cele de mai Nos.
K#iectul a are cele trei c9mpuri din declaraia clasei, +, @, z cu specificatorii respecti%
pu#lic, protected, pri%ate. K#iectul # are c9mpurile + (i C cu specificatorul de acces
pu#lic (i @ cu specificatorul protected. -9mpul z nu este mo(tenit de o#iectul #.
K clas deri%at mo(tene(te toi mem#ri clasei de #az e+cept9nd constructorii,
destructorul (i operatorul 0. .e(i constructorii nu sunt mo(tenii, constructorul implicit (i
destructorul sunt totdeauna apelai c9nd un o#iect de tipul clasei deri%ate este creat sau
distrus. In constructorul clasei deri%ate se apeleaz la nceput constructorul implicit al
clasei de #az. .ac este ne%oie, putem apela e+plicit un constructor al clasei de #az
pentru iniializarea %aria#ilelor. $pelarea sa se face astfel
constructordclasadderi%ata(lista de parametri)
! constructordclasadded#aza (lista de parametri)
:
M7 definitia constructorului clasei deri%ate 7M
<
/+emplu. 6 definim o clas numit Aoint care descrie un punct pe ecran prin
coordonatele sale (i o clas Ai+el ce descrie un pi+el (i mo(tene(te din clasa Aoint
coordonatele pi+elului. -lasa Aoint %a a%ea dou c9mpuri de tip ntre8, + (i @, ce sunt
coordonatele punctului pe ecran, doi constructori (i o funcie clear() ce pune la %aloarea
zero cele dou coordinate.
class Aoint
:
pu#lic!
int +, @e
%oid clear()e
Aoint(int, int)e
Aoint():+ 0 0e @ 0 0e<
%oid print()e
<e
%oid Aoint!!clear()
:
+ 0 0e
@ 0 0e
<
Aoint!!Aoint(int p1, int p2)
:
+ 0 p1e
@ 0 p2e
<
%oid Aoint!!print()
:
cout __ S + 0 S __ + __ S,g __ S @ 0 S __ @ __ endle
<
CEn# un obiect #intr3o clas9 #erivat9 este creat sau #istrus, constructorul implicit
Ff9r9 parametriG i #estructorul clasei #e baz9 sunt tot#eauna apelai. .e aceea am
definit (i constructorul implicit n definiia clasei Aoint.
5rem s definim acum o clas Ai+el care s descrie un pi+el pe ecran. Un pi+el este
caracterizat de coordonatele sale (i de culoare. -uloarea %a fi un c9mp de tip ntre8. -lasa
Ai+el %a mo(teni coordonatele punctului din clasa Aoint. Funcia clear() %a pune la
%aloarea zero coordonatele (i culoarea o#iectului tip Ai+el.
class Ai+el ! pu#lic Aoint
:
pu#lic!
int colore
%oid clear()e
Ai+el(int, int, int)e
%oid print()e
<e
In definiia constructorului clasei Ai+el %om apela constructorul cu parametri al clasei
Aoint.
Ai+el!!Ai+el(int a, int #, int c) ! Aoint(a, #)
:
color 0 ce
<
%oid Ai+el!!clear()
:
Aoint!!clear()e
color 0 0e
<
%oid Ai+el!!print()
:
Aoint!!print()e
cout __ Sculoarea ! S __ color __ endle
<
enionm c nu puteam defini funcia clear() a clasei Ai+el astfel
%oid Ai+el!!clear()
:
clear()e
color 0 0e
<
deoarece ar fi nsemnat o apelare recursi%. Un e+emplu de utilizare a clasei Ai+el este
prezentat mai Nos.
int main()
:
Ai+el p(1, 2, 13)e
p.print()e
return 0e
<
1/.3 1uncii virtuale. Polimorfism
-onsiderm e+emplul anterior n care, pentru a apela funcia area() prin pointer pentru
cele dou o#iecte am definit dou %aria#ile pointer de tipuri diferite. +ste posibil ca un
pointer la clasa #e baz9 s9 conin9 a#resa unui obiect al unei clase #erivate.
/+emplu. Fie clasele Aoint (i Ai+el definite anterior. 5om crea o#iecte de tip Aoint (i
Ai+el (i %om scrie %alorile lor utiliz9nd o %aria#il pointer de tip Aoint.
int main()
:
MM defineste un pointer de tip Aoint
Aoint 7 prte
MM creaza un o#iect de tip Aoint
Aoint p(12, 220)e
MM atri#uie %aria#ilei prt adresa o#iectului p de tip Aoint
prt 0 Xpe
MM afisaza coordonatele utilizand %aria#ila pointer
prtE"print()e
M7 creaza un o#iect de tip Ai+el 7M
Ai+el p+(13, 122, 3)e
M7 atri#uie %aria#ilei prt adresa o#iectului p+ de tip Ai+el 7M
prt 0 Xp+e
M7 afisaza coordonatele utilizand %aria#ila pointer 7M
prtE"print()e
return 0e
<
%enion9m c9 ambele instruciuni
prt3;printFGM
apeleaz9 funcia printFG a clasei Point, c7iar #ac9 ne atept9m ca n cazul al #oilea s9
se apeleze funcia printFG a clasei Pi!el.
1uncia apelat9 este #eterminat9 #e tipul variabilei pointer, nu #e tipul obiectului.
Putem face ca funcia apelat9 s9 fie #eterminat9 #e tipul obiectului i nu #e tipul
variabilei pointer #efinin# funcii virtuale.
/+emplu. 5om redefini clasele Aoint (i Ai+el astfel. Funcie clear(), ce pune la %aloarea
zero %aria#ilele, (i funcia print() ce afi(az %aloarea %aria#ilelor %or fi declarate %irtuale.
.efiniia clasei Aoint este urmtoarea
class Aoint
:
pri%ate!
int +, @e
%irtual %oid clear()e
%irtual %oid print()e
Aoint(int, int)e
Aoint():+ 0 0e @ 0 0e<
<e
.efiniiile funciilor sunt cele anterioare. /le %or fi repetate aici.
%oid Aoint!!clear()
:
+ 0 0e
@ 0 0e
<
Aoint!!Aoint(int p1, int p2)
:
+ 0 p1e
@ 0 p2e
<
%oid Aoint!!print()
:
cout __ S+ 0 S __ + __ S,g __ S @0 S __ @ __ endle
<
-lasa Ai+el mo(tene(te clasa Aoint. -onstructorul ei apeleaz constructorul cu parametri
al clasei Aoint, iar funciile clear() (i print() apeleaz funciile cu acela(i nume din clasa
Aoint.
class Ai+el ! pu#lic Aoint
:
pri%ate!
int colore
%irtual %oid print()e
%irtual %oid clear()e
Ai+el(int, int, int)e
<e
.efiniiile funciilor sunt cele anterioare.
Ai+el!!Ai+el(int a, int #, int c) ! Aoint(a, #)
:
color 0 ce
<
%oid clear()
:
Aoint!!clear()e
color 0 0e
<
%oid Ai+el!!print()
:
Aoint!!print()e
cout S culoare 0 S __ p.color __ endle
<
In funcia main() %om crea o#iecte de tip Aoint (i apoi Ai+el. 5om scrie datele din aceste
o#iecte apel9nd funcia print() printrEun pointer la clasa de #az.
int main()
:
Aoint 7 ptre
MM creaza un o#iect de tipul Aoint
Aoint p(2, ))e
MM atri#uie %aria#ilei ptr adresa o#iectului p de tip Aoint
ptr 0 Xpe
MM afisaza coordonatele punctului
ptrE"print()e
MM creaza un o#iect de tipul Ai+el
Ai+el p+(1, 2, 13)e
MM atri#uie %aria#ilei ptr adresa o#iectului p+ de tip Ai+el
ptr 0 Xp+e
MM afisaza coordonatele si culoarea pi+elului
prtE"print()e
return 0e
<
Arima instruciune
ptrE"print()e
apeleaz funcia print() a clasei Aoint. $ doua instruciune
ptrE"print()e
apeleaz funcia print() a clasei Ai+el.
5om spune c apelul de funcie
ptrE"print()e
este polimorfic, deoarece se modific dup natura o#iectului indicat de pointer. &rice
clas9 ce #efinete sau motenete funcii virtuale se numete polimorf9.
/+emplu. 5rem s definim clase care s conin informaii despre an8aNaii unei
intreprinderi, numele (i departamentul, n cazul tuturor an8aNailor, iar n cazul
mana8erilor (i poziia. $ceste informaii %or fi (iruri de caractere. 5a tre#ui s a%em
dou tipuri de o#iecte, unul ce %a conine numele (i departamentul, (i altul ce %a conine
numele, departamentul (i poziia. Aentru aceasta %om defini o clas de #az numit
Aerson ce conine numele unei persoane (un (ir de caractere) (i o funcie ce afi(az
numele.
class Aerson
:
protected!
c*ar 7 namee
pu#lic!
Aerson(c*ar 7 s)
: name 0 neC c*arGstrlen(s) J 1He strcp@(name, s)e<
%irtual %oid print()
:cout __ Sname ! S __ name __ SOnge<
<e
5om defini o clas ce mo(tene(te clasa Aerson, clasa Zired cu date despre an8aNai (i o
clas numit ana8er cu date despre mana8eri ce mo(tene(te din clasa Zired conform
dia8ramei de mai Nos.
class Zired ! pu#lic Aerson
:
protected!
c*ar 7 depte
pu#lic!
Zired(c*ar 7 s, c*ar 7 d) ! Aerson(s)
:dept 0 neC Gstrlen(d) J 1He strcp@(dept, d)e<
:Aerson!!print()e cout __ S department ! S __ dept __ SOnge <
<e
class ana8er ! pu#lic Zired
:
protected!
c*ar 7 positione
pu#lic!
ana8er(c*ar 7 s, c*ar 7 d, c*ar 7 p) ! Zired(s, d)
:position 0 neC Gstrlen(p) J 1He strcp@(position, p)e<
:Zired!!print()ecout __ S position ! S __ position __ SOnge <
<e
-a e+emplu de utilizare a claselor create %om defini o#iecte de cele dou tipuri.
int main()
:
Zired +1(S$le+g, Sproiectareg)e
ana8er m1(S,o#g, Sproiectareg, Ssefg)e
Aerson 7 pse
MM scrie datele pentru +1
ps 0 X+1e
psE"print()e
MM scrie datele despre m1
ps 0 X m1e
psE"print()e
return 0e
<
1/.4 Date i funcii statice
1/.4.1 Date statice
K#iectele de tipul unei clase au propriile %aria#ile ce conin %alori ce dau starea fiecrui
o#iect. Uneori este necesar s e+iste o %aria#il a clasei ntrEun sin8ur e+emplar pentru
toate o#iectele. $cest lucru se poate realiza simplu definind acea %aria#il de tip static.
.efinirea se face scriind cu%9ntul c*eie static la nceputul declaraiei %aria#ilei. Datele
#e tip static iniializate n afara clasei. .atele statice sunt la fel ca (i %aria#ilele 8lo#ale,
dar n spaiul de nume al clasei.
class $
:
static int +e
<e
int $!!+ 0 0e
.atele statice e+ist c*iar dac nu e+ist nici un o#iect de tipul clasei. Aentru e+emplul de
mai sus putem utiliza %aria#ila static + ca $!!+ sau $.+ sau, dac e+ist o#iecte de tipul
clasei, ca numedo#iect.+
K aplicaie a datelor statice este aceea de a numra o#iectele e+istente de tipul clasei.
/+emplu. 5om defini o clas cu o %aria#il static ce %a numra o#iectele e+istente de
tipul clasei. -onstructorul adun o unitate, iar destructorul scade o unitate din %aria#ila
static.
class D
:
pu#lic!
static int n#e
D():n# JJe<
bD():n#EEe<
<e
int D!!n# 0 0e
In funcia main() %om crea o#iecte (i %om afi(a numrul lor.
int main()
:
D a, #e
cout __ Se+ista S __ D.n# __ S o#iecteg __ endle
:
D c, de
cout __ Se+ista S __ D.n# __ S o#iecteg __ endle
<
cout __ Se+ista S __ D!!n# __ S o#iecteg __ endle
return 0e
<
=ezultate afi(ate %or fi
e+ista 2 o#iecte
e+ista 2 o#iecte
e+ista 2 o#iecte
.up instruciunea
D a, #e
e+ist dou o#iecte, a (i #. .up instruciunea
D c, de
e+ist patru o#iecte. .up ie(irea din #locul interior e+ist dou o#iecte, o#iectele c (i d
fiind distruse. enionm c putem adresa %aria#ila n# ca D.n# sau D!!n#.
1/.4.2 1uncii statice
Funciile statice sunt la fel ca (i funciile 8lo#ale. /le pot prelucra doar datele statice ale
clasei. /le pot fi apelate utiliz9nd numele clasei sau al unui o#iect de tipul clasei.
.efinirea unei funcii statice se face scriind cu%antul c*eie static naintea definiiei
funciei. Un e+emplu de utilizare a funciilor statice este te*nica de pro8ramare
-lassFactor@. /a const n urmtoarele. Fie o clas de #az (i dou clase deri%ate din ea,
.eri%1 (i .eri%2. 5rem s definim o funcie care s ai#e ca rezultat un o#iect de tipul
.eri%1 sau .eri%2 n funcie de %aloarea unui parametru.
/+emplu. 5om defini o clas cu o metod ce calculeaz suma a dou numere (i o clas cu
o metod ce calculeaz produsul a dou numere. In am#ele cazuri metoda se %a numi
oper(). /le %or mo(teni o clas ce memoreaz cele dou numere. -lasa de #az are
urmtoarea definiie
class ,ase
:
protected!
float a, #e
pu#lic!
,ase() :a 0 0e # 0 0e<
,ase(float, float)e
%irtual float oper():return 0e<
<e
,ase!!,ase(float +, float @)
:
a 0 +e
# 0 @e
<
-lasele deri%ate definesc funcia oper() ce efectueaz adunarea sau produsul a dou
numere. /le au urmtoarele definiii
class $dd ! pu#lic ,ase
:
pu#lic!
$dd(float +, float @) ! ,ase(+, @) :<
float oper():return a J #e<
<e
class ul ! pu#lic ,ase
:
pu#lic!
ul(float +, float @) ! ,ase(+, @) :<
float oper() :return a 7 #e<
<e
5om defini o clas cu o metod static ce creaz un o#iect de tip $dd sau ul n funcie
de %aloarea unui parametru (i are ca rezultat un pointer de tipul clasei de #az (,ase).
class clf
:
pu#lic!
static ,ase 7 operfactor@(float, float, c*ar)e
<e
,ase 7 clf!!operfactor@(float +, float @, c*ar c)
:
if(c 00 kJk)
return neC $dd(+, @)e
else
return neC ul(+, @)e
<e
Funcia main() creaz un o#iect de tipul $dd (i memoreaz adresa lui ntrEun pointer de
tipul clasei de #az. $poi utilizeaz o#iectul la calculul sumei a dou numere.
int main()
:
float ze
,ase 7 #asee
clf cfe
MM creaza un o#iect care sa calculeze suma a doua numere
#ase 0 cf.operfactor@(1.2, E2.13, kJk)e
MM calculeaza suma numerelor
z 0 #aseE"oper()e
cout __ z __ endle
return 0e
<
Cap. 11 1iiere tip C22
Iim#aNul -JJ define(te clasele istream (i ostream pentru operaii intrare (i ie(ire cu
fi(ierele standard, tastatura (i ecranul. K#iectul cin este o instan a clasei istream, iar
cout o instan a clasei ostream. Aentru lucrul cu fi(iere de date lim#aNul -JJ define(te
urmtoarele clase
ofstream pentru operaii de scriere de fi(iere
ifstream pentru operaii de citire din fi(iere
fstream pentru operaii de citire (i scriere a fi(ierelor
$ceste clase mo(tenesc din clasele istream (i ostream. .efiniiile acestor clase se 8sesc
n #i#lioteca _fstream". K serie de constante utilizate de aceste clase sunt definite n
clasa ios. Aentru prelucrarea unui fi(ier se creaz un o#iect instan a uneia din clasele de
mai sus care este denumit stream. .ia8rama mo(tenirii acestor clase este cea de mai Nos.
Funciile mem#re importante ale claselor sunt
funcia mem#r open() cu prototipul
open(c*ar 7 filename, int mode)e
asociaz o#iectul cu fi(ierul. Aarametrul filename este un (ir de caractere cu numele
fi(ierului. $l doilea parametru este opional (i d modul de desc*idere. /l poate a%ea
%alorile
ios!!in E desc*idere n citire
ios!!out L desc*idere n scriere
ios!!#inar@ L fi(ier #inar@
$ce(ti parametri se pot com#ina folosind operatorul ` . .e e+emplu, pentru un fi(ier
#inar desc*is n scriere %om a%ea
ios!!#inar@ ` ios!out
iar pentru desc*iderea unui fi(ier #inar n citire
ios!!#inar@ ` ios!!in
$cest al doilea parametru este opional pentru o#iecte de tipul ifstream (i ofstream care
sunt automat desc*ise n citire (i respecti% scriere.
funcia
close()e
nc*ide un fi(ier.
funcia
eof()
are %aloarea ade%rat dac sEa detectat sf9r(itul fi(ierului
funcia
isdopen()
are %aloarea ade%rat dac fi(ierul este desc*is
11.1 1iiere te!t
/+ist dou tipuri de operaii intrareM ie(ire pentru fi(iere tip te+t
funcii pentru intrri M ie(iri cu format
funcii ce scriu M citesc caractere
11.1.1 1uncii intrare 0 ieire cu format
Fi(ierele tip te+t se prelucreaz n acela(i mod ca fi(ierele standard de intrare (i ie(ire, cin
(i cout. Kperatorii de citire (i scriere sunt "" (i __.
/+emplu. 5om calcula %aloarea e+presiei
) sin(
1
) ( cos
2
x
x
x x
e +
+
+
pentru + cuprins n inter%alul G0, 2H cu pasul 0.2. 5om scrie %alorile calculate ntrEun
fi(ier cu numele rez.t+t.
T include _fstream"
T include _cmat*"
int main()
:
c*ar 7 filename 0 Srez.t+tge
ofstream fil1e
fil1.open(filename)e
if(Pfil1.isdopen)
:
cout __ S 4u se poate crea fisierul S __ filename __ endle
return 0e
<
MM creaza fisierul
int ie
dou#le +, ee
:
MM calculeaza e+presia si scrie in fisier
+ 0 i 7 0.2e
e 0 (cos(+) 7 cos(+) J +) M (1.0 J fa#s(+)) J sin(+)e
fil1 __ + __ YOtf __ e __ endle
<
fil1.close()e
MM citeste fisierul creat si afisaza rezulatele
ifstream fil2e
fil2.open(filename)e
if(Pfil2.isdopen())
:
cout __ S nu se poate desc*ide fisierul S __ filename __ endle
return 0e
<
MM scrie antetul
cout __ i+i __ kOtk __ iei __ endle
fil2 "" + "" ee
C*ile(Pfil2.eof())
:
cout __ + __ YOt Y __ e __ endle
fil2 "" + "" ee
<
fil2.close()e
return 0e
<
11.1.2 1uncii intrare 0 ieire tip caracter
-lasele istream (i ifstream au urmtoarele funcii mem#re pentru citirea caracterelor.
Funcia
8et(c*arX)e
cite(te un caracter, iar funcia
8etline(c*ar 7 #loc, int size)e
cite(te cel mult size caractere n %ectorul #loc.
-lasele ostream (i ofstream au funcia mem#r
put(c*ar)e
ce scrie un caracter.
/+emplu. 5om copia un fi(ier n altul (i %om calcula lun8imea fi(ierului.
T include _fstream"
int main()
:
c*ar filename G22He
cout __ SIntroduceti numele fisierului de copiatg __ endle
cin "" filenamee
ifstream fila(filename)e
if(Pfila.isdopen())
:
cout __ endl __ SFisierul S __ filename __ S nu e+ista S __ endle
return 0e
<
cout __ endl __ SIntroduceti numele noului fisierg __ endle
cin "" filenamee
ofstream fil#(filename)e
if(Pfil#.isdopen())
:
cout __ SFisierul S __ filename __ S nu se poate creag __ endle
return 0e
<
c*ar care
int nl 0 0e
fila.8et(car)e
C*ile(Pfila.eof())
:
fil#.put(car)e
nlJJe
fila.8et(car)e
<
fila.close()e
fil#.close()e
cout __ ifisierul i __ filename __ S are g __ nl __ i caracterei __ endle
return 0e
<
enionm c e+presia
fila.8et(car)
are %aloarea fals la nt9lnirea sfar(itului de fi(ier. In consecin, puteam copia fi(ierul
astfel
C*ile(fila.8et(car))
:
fil#.put(car)e
nlJJe
<
11.2 1iiere binare
6crierea (i citirea datelor din fi(ierele #inare se face cu funciile
Crite(c*ar 7 #locW, int size)e
read(c*ar 7 #locW, int size)e
Arimul parametru este adresa unui %ector de caractere de unde sunt scrise datele sau unde
sunt citite datele. $l doilea parametru d numrul de caractere de citit sau de scris.
Fi(ierele au indicatori interni care dau adresa urmtorului octet de citit sau de scris.
5oloarea acestor indicatori este dat de funciile
tell8()e
pentru indicatorul urmtorului octet de citit.
tellp()e
pentru indicatorul urmtorului octet de scris.
Indicatorii de poziie sunt modificai de funciile
seeW8(int offset, int direction)e
pentru indicatorul de citire (i respecti%
seeWp(int offset, int direction)e
pentru indicatorul de scriere. Aarametrul offset d %aloarea cu care se modific
indicatorul. Aarametrul direction are %alorile
ios!!#e8 L relati% la nceputul fi(ierului
ios!!end L relati% la sfar(itul fi(ierului
ios!!cur L relati% la poziia curent
/+emplu. 5om crea un fi(ier #inar cu 10 #locuri de c9te 10 caractere fiecare, dup care
citim fi(ierul (i l afi(m pe ecran. Arimul #loc %a conine cractere Y0f, al doilea #loc
caractere Y1f, etc. -itirea fi(ierului se face dup sc*ema cunoscut, test9nd sfar(itul de
fi(ier dup fiecare citire.
T include _fstream"
int main()
:
c*ar filenameGH 0 Sfis.t+tge
c*ar +G11He
ofstream filae
MM creaza fisierul
fila.open(filename, ios!!out M ios!!#inar@)e
if(Pfila.isdopen())
:
return 0e
<
int i, Ne
MM creaza fisierul
:
MM creaza un #loc
+GNH 0 Y0f J ie
+G10H 0 0e
fila.Crite(+, 11)e
<
fila.close()e
ifstream fil#e
MM citeste si afisaza fisierul
fil#.open(filename, ios!!#inar@ M ios!!in)e
if(Pfil#.isdopen())
:
cout __ S4u se poate citi fisierul S __ filename __ endle
return 0e
<
fil#.read(+, 11)e
C*ile(Pfil#.eof())
:
cout __ + __ endle
fil#.read(+, 11)e
<
fil#.close()e
return 0e
<
/+emplu. 5om crea un fi(ier #inar format din 2? de #locuri conin9nd (iruri de 10
caractere fiecare. 5om citi apoi fiecare al patrulea #loc modific9nd indicatorul de citire.
Arimul #loc %a conine caractere Yaf, al doilea #loc %a conine caractere Y#f, etc.
T include _fstream"
int main()
:
c*ar filenameGH 0 Sfil.t+tge
c*ar +G11He
ofstream fil+e
MM creaza fisierul
fil+.open(filename, ios!!out ` ios!!#inar@)e
if(Pfil+.isdopen())
:
return 0e
<
int i, Ne
for(i 0 0e i _ 2?e iJJ)
:
MM creaza un #loc
+GNH 0 Yaf J ie
+G10H 0 0e
fil+.Crite(+, 11)e
<
fil+.close()e
ifstream fil@e
fil@.open(filename, ios!!#inar@ ` ios!!in)e
if(Pfil@.isdopen())
:
cout __ S4u se poate citi fisierul S __ filename __ endle
return 0e
<
for(i 0 0e i _ 2?e i 0 i J 2)
:
MM modifica indicatorul fisierului
fil@.seeW8(i 7 11, ios!!#e8)e
fil@.read(+, 11)e
cout __ + __ endle
<
fil@.close()e
return 0e
<
Cap. 12 4iruri tip C22
Iim#aNul -JJ define(te clasa string pentru lucrul cu (iruri. 6pre deose#ire de (irurile tip
- care sunt terminate printrEun octet cu %aloarea zero, o#iectele acestei clase au un c9mp
ce conine lun8imea (irului. -lasa strin8 este definit n fi(ierul *eader _strin8". -lasa
are urmtorii constructori!
constructorul implicit care creaz un (ir %id
strin8()e
constructor copiere cu ar8ument (ir tip - sau (ir tip strin8
strin8(const strin8X)e
strin8(const c*ar 7)e
Kperatorul 0 are ca ar8ument drept un (ir tip - sau (ir tip strin8.
/+emple de definiri de o#iecte tip strin8
strin8 + 0 ia#cdie
strin8 @(+)e
strin8 z 0 +e
strin8 +1(ia#ci)e
-lasa implementeaz operatorii J (i J0(concatenarea (irurilor).
/+emple.
strin8 a 0 + J S+@zge
a J0 Sa#cge
-lasa define(te operatori de comparare, _, _0, ", "0 , 0 0 (i P0 ce au ca rezultat %alorile
true sau false.
/+emple.
if(+ _ +1)
cout __ +1e
else
cout __ +e
Funcii mem#re importante ale clasei sunt
int len8t*()e L d lun8imea (irului
int size()e L d lun8imea (irului
const c*ar 7 cdstr()e E con%erte(te (irul ntrEun (ir tip -
#ool empt@()e E are %aloarea true dac (irul este %id
/+emplu. 6 copiem un (ir -JJ ntrEun (ir tip -.
c*ar cG100He
strin8 str(Sa#cdg)e
strcp@(c, str.cdstr())e
-lasa are operatorul de selecie GH ce poate selecta un caracter din (ir sEau atri#ui o
%aloare unui caracter din (ir.
/+emplu. 6 scriem un (ir, caracter cu caracter.
strin8 s 0 Sa#cdge
for(N 0 0e N _ s.len8t*()e NJJ)
cout __ sGNHe
Kperatorii __ (i "" scriu (i citesc (iruri tip strin8.
5om prezenta acum funcii de cutare de su#(iruri (i de modificare a (irurilor.
Fie un o#iect tip strin8. Funcia find() cu prototipul
int find(c*ar 7 su#strin8)e
d indicele primei apariii a (irului su#strin8 n (irul respecti%. .ac (irul su#strin8 nu
e+ist n (ir funcia are ca rezultat lun8imea (irului.
/+emple. Fie (irul
strin8 str 0 Sa#cdef8ge
Instruciunea
cout __ str.find(Scdg) __ endle
afi(az %aloarea 2. (indicele caracterului Ycf este 2). Instruciunea
cout __ str.find(S+@zg) __ endle
afi(az %aloarea ) (lun8imea (irului).
Funcia erase (ter8e un su#(ir din (ir. /a are prototipul
erase(int inde+, int size)
Funcia (ter8e size caractere ncep9nd cu caracterul cu indicele inde+.
/+emplu. Fie (irul
strin8 str 0 S$,-.7FFZI\^ge
Instruciunea
str.erase(2, 2)e
(ter8e dou caractere ncep9nd cu caracterul Y7f ce are indicele 2. 4oul (ir este
S$,-.FZI\^g
Funcia replace nlocuie(te un su#(ir cu altul. /a are prototipurile
replace(int inde+, int size, c*ar 7 sir)e
replace(int inde+, int size, strin8 sir)e
(i nlocuie(te su#(irul de lun8ime size ce ncepe cu caracterul inde+ cu su#(irul sir.
/+emple. Fie (irul
strin8 str 0 S$,-.FZI\^ge
Instruciunea
str.replace(3, 2, S+@zg)e
nlocuie(te su#(irul SZIg cu su#(irul S+@zg. 4oul (ir este
S$,-.F+@z\^g
Fie (irul
strin8 s2 0 Sa#cge
Instruciunea
str.replace(3, 1, s2)e
nlocuie(te su#(irul S+@zg cu (irul Sa#cg. 4oul (ir este
S$,-.Fa#c\^g
/+emplu. 5om rescrie un e+emplu anterior n care am utilizat (iruri tip - (i %om utiliza
acum (iruri tip strin8. 5om defini o clas de #az numit Aerson ce conine numele unei
persoane (un (ir de caractere) (i o funcie ce afi(az acest (ir (numele persoanei).
class Aerson
:
protected!
strin8 namee
pu#lic!
Aerson(strin8 s)
: name 0 se<
:cout __ Sname ! S __ name __ SOnge<
<e
5om defini o clas ce mo(tene(te clasa Aerson, clasa Zired cu date despre an8aNai (i o
clas numit ana8er cu date despre mana8eri ce mo(tene(te din clasa Zired.
class Zired ! pu#lic Aerson
:
protected!
strin8 depte
pu#lic!
Zired(strin8 s, strin8 d) ! Aerson(s)
:dept 0 de<
:Aerson!!print()e cout __ S department ! S __ dept __ SOnge <
<e
class ana8er ! pu#lic Zired
:
protected!
strin8 positione
pu#lic!
ana8er(strin8 s, strin8 d, strin8 p) ! Zired(s, d)
:position 0 pe<
:Zired!!print()e cout __ S position ! S __ position __ SOnge <
<e
5om e+emplifica acum claselor create.
int main()
:
ana8er m1(S,o#g, Sproiectareg, Ssefg)e
Aerson 7 pse
MM scrie datele pentru +1
ps 0 X+1e
psE"print()e
MM scrie datele despre m1
ps 0 X m1e
psE"print()e
return 0e
<
=eamintim c funcia print() este %irtual, astfel nc9t apelul
psE"print()e
apeleaz funcia print() din clasa corespunztoare tipului o#iectului, produc9nd rezultatul
corect. enionm de asemenea c instruciunea
este corect deoarece constructorul copiere al clasei strin8 are ca ar8ument un (ir de tip -
sau de tip -JJ.
Cap 13. "ratarea e!cepiilor
13.1. +!cepii
In timpul e+ecuiei pro8ramului pot apare di%erse erori. Un tip de erori sunt cele asociate
operaiilor intrareM ie(ire ! ncercm s citim un fi(ier ine+istent, %rem s crem un fi(ier
pe disc dar discul este plin, etc. $l tip de erori sunt cele le8ate de operaiile aritmetice !
mprirea prin zero, indici eronai, dep(irea 8amei de reprezentare a numerelor, etc.
Iim#aNul -JJ are un mecanism de tratare a e+cepiilor ce permite ca atunci c9nd apare o
eroare (o e+cepie) pro8ramul s apeleze automat o funcie de tratare a erorii. $ceast
funcie are ca parametru un o#iect cu informaii despre eroare. Vratarea e+cepiilor se
face cu instruciunile tr', catc7 (i t7ro6. Instruciunea pe care o urmrim pentru apariia
unei e+cepii tre#uie inclus ntrEun #loc tr'. .ac apare o e+cepie (o eroare), ea este
lansat cu instruciunea t7ro6 care 8enereaz un o#iect cu informaii despre eroare (i
este prins cu instruciunea catc7 care are ca parametru o#iectul cu informaii despre
eroare 8enerat de instruciunea t7ro6. Forma 8eneral a instruciunilor tr' (i catc7 este
urmtoarea
tr@
:
MM #loc cu instruciuni
<
catc*(tip1 ar8)
:
MM prelucreaza e+ceptia
<
catc*(tip2 ar8)
:
<
&&&&&
catc*(tipn ar8)
:
<
"ipurile argumentelor #in instruciunile catc7 trebuie s9 fie #iferite. $tunci c9nd
apare o e+cepie tre#uie s e+ecutm instruciunea t*roC cu forma
t*roC o#iecte
/+cepia este un o#iect cu informaii despre eroare 8enerat de instruciunea t*roC. /a
poate fi un o#iect simplu de tip int, c*ar, dou#le, etc., sau un o#iect instan a unei clase
definit de pro8ramator. IntrEun #loc pot apare mai multe tipuri de e+cepii. Fiecare tip de
e+cepie este tratat de o anumit instruciune catc*. /a se determin dup ar8umentului,
care este tipul o#iectului 8enerat de instruciunea t*roC.
/+emplu. Vratarea unei e+cepii mprire prin zero.
int main()
:
int + 0 2, @ 0 0, ze
tr@
:
if(@ 00 0)
t*roC @e
z 0 + M @e
cout __ i+ 0 i __ + __ i @ 0 i __ @ __ i + M @ 0 i __ z __ endle
<
catc*(int a)
:
cout __ idi%ide #@ zeroi __ endle
cout __ iline ! i __ ddII4/dd __ endle
<
return 0e
<
Iim#aNul define(te dou constante utile n cazul e+cepiilor. -onstanta ddII4/dd
conine numrul liniei curente compilate, iar constanta ddFII/dd conine numele
fi(ierului curent compilat.
,locul catc* ncearc repararea erorii aprute. .ac nu este posi#il acest lucru, se pot
utiliza funciile e+it() sau a#ort() pentru a termina pro8ramul.
Aentru a prinde o e+cepie tre#uie ca tipul o#iectului lansat de instruciunea t*roC s
coincid cu tipul o#iectului specificat ntrEo instruciune catc*, astfel e+cepia nu este
prins.
Preluarea tuturor e!cepiilor
.ac dorim ca un sin8ur #loc catc* s preia toate e+cepiile unui #loc tr@ %om scrie
#locul catc* astfel
catc*(&)
:
MM trateaza e+ceptiile
<
13.2 +!cepii lansate #e funcii
IntrEun #loc tr@ pot e+ista apeluri la multe funcii (i orice funcie poate lansa e+cepii.
/+cepiile lansate de o funcie sunt precizate la definirea funciei n felul urmtor
tip numedfunctie(lista de parametric) t*roC (lista de tipuri)
:
MM corpul functiei
<
/+emplu. 5om defini o funcie ce calculeaz c9tul a dou numere ntre8i (i lanseaz o
e+cepie de tip strin8 dac numitorul este zero. Vipul e+cepiei lansate de funcie este
precizat n linia de definiie a funciei (i este un (ir tip strin8 ce conine un mesaN.
T include _strin8"
int fun(int +, int @) t*roC(strin8)
:
if(@ 0 0 0)
t*roC strin8(Simpartire prin zerog)e
else
return + M @e
<
int main()
:
int a 0 10, # 0 0, ce
tr@
:
MM functie ce poate lansa o e+ceptie
c 0 fun(a, #)e
cout __ a __ SMg __ # __ S0g __ c __ endle
<
catc*(strin8 mesaN)
:
cout __ mesaN __ endle
<
return 0e
<
enionm c funcia ce lanseaz o e+cepie este apelat ntrEun #loc tr@, iar e+cepia
este prins n #locul catc* corespunztor.
13.3 +!cepii stan#ar#
Iim#aNul -JJ define(te o clas de #az special proiectat pentru a declara o#iecte care s
fie lansate de instruciunea t*roC. -lasa se nume(te e+ception iar prototipul ei se afl n
#i#lioteca _e+eception". -lasa define(te un constructor implicit, un constructor cu
parametru (ir de caractere (i unul copiere, operatorul 0 (i funcia %irtual C*at() cu
prototipul
%irtual c*ar 7 C*at()e
care are ca rezultat un mesaN despre e+cepie.
/+empul. 5om rescrie e+emplul anterior utiliz9nd clasa e+ception.
T include _e+ception"
int fun(int +, int @) t*roC(e+ception)
:
if(@ 0 0 0)
t*roC e+ception(Simpartire prin zerog)e
else
return + M @e
<
int main()
:
int a 0 10, # 0 0, ce
tr@
:
MM functie ce poate lansa o e+ceptie
c 0 fun(a, #)e
cout __ a __ SMg __ # __ S0g __ c __ endle
<
catc*(e+ception e+m)
:
cout __ e+m.C*at() __ endle
<
return 0e
<
Cap. 14 5plicaii
14.1 1uncii #e timp
Iim#aNele - (i -JJ au funcii predefinite pentru a o#ine timpul. Arototipurile acestor
funcii se 8sesc n #i#liotecile _time.*" sau _ctime". Vimpul este msurat n
milisecunde de la data de 1 Ianuarie 1')0 FV. Vipul %aria#ilelor ce memoreaz timpul
este lon8 int (i este redefinit ca timedt.
t@pedef lon8 timedte M7 time %alue 7M
Funcia standard ce completeaz aceast %aria#il este
timedt time(timedt 7 timeptr)e
Funcia time are ca rezultat timpul n parametrul timeptr (i ca %aloare.
/+emplu.
timedt t1, t2e
t1 0 time(Xt2)e
5aria#ilele t1 (i t2 primesc ca %aloare timpul curent.
Funcia ctime con%erte(te timpul unei %aria#ile timedt ntrEun (ir de caractere.
c*ar7 ctime(timedt 7 timeptr)e
/+emplu. Instruciunea
cout __ ctime(Xt1) __ endle
afi(az timpul din %aria#ila t1.
6tructura predefinit tm conine urmtoarele informaii
struct tm :
int tmdsece M7 seconds after t*e minute E G0,3'H 7M
int tmdmine M7 minutes after t*e *our E G0,3'H 7M
int tmd*oure M7 *ours since midni8*t E G0,21H 7M
int tmdmda@e M7 da@ of t*e mont* E G1,11H 7M
int tmdmone M7 mont*s since \anuar@ E G0,11H 7M
int tmd@eare M7 @ears since 1'00 7M
int tmdCda@e M7 da@s since 6unda@ E G0,?H 7M
int tmd@da@e M7 da@s since \anuar@ 1 E G0,1?3H 7M
int tmdisdste M7 da@li8*t sa%in8s time fla8 7M
<e
Funcia
struct tm 7 localtime(timedt 7 timeptr)e
con%erte(te timpul unei %aria#ile timedt n structura tm.
/+emplu.
timedt t1e
struct tm t2e
struct tm 7 ptrte
t1 0 time(4UII)e
ptrt 0 localtime(Xt1)e
t2 0 7 ptrte
cout __ t2.tmd*our __ i!i __ t2.tmdmin __ i!i __ t2.tmdsec __ endle
Funcia
timedt mWtime(struct tm 7 t)e
con%erte(te timpul dintrEo %aria#il tm ntrEo structur timedt.
Funcia
struct tm 7 8mtime(const timedt 7 timeptr)e
are ca rezultat un pointer la o structur tm ce conine timpul FV.
14.2 1ire #e e!ecuie
Aro8ramele de p9n acum au fost procese cu un sin8ur fir de e+ecuie (t*read). /ste
posi#il s cream pro8rame cu mai multe fire de e+ecuie simultan. Fiecare fir e+ecut o
anumit funcie cu prototipul
%oid f(%oid 7)e
Arototipurile funciilor pentru lucrul cu fire de e+ecuie se afl n #i#lioteca _process.*".
Iim#aNul - define(te urmtoarele funcii pentru lucrul cu fire de e+ecuie
funcia
unsi8ned lon8 d#e8int*read(%oid (7f) (%oid 7), unsi8ned int stacW, %oid 7 ar8list)e
lanseaz n e+ecuie un fir. Arimul parametru este un pointer la funcia ce %a fi e+ecutat
de fir. $l doilea parametru este dimensiunea unei sti%e ce poate fi utilizat de fir. Ultimul
parametru este o list de ar8umente pasat firului.
funcia
dsleep(int ms)e
suspend e+ecuia firului de a(teptare pentru un numr de milisecunde dat de parametrul
ms.
/+emplu. 5om face un pro8ram care s lanseze n e+ecuie dou fire. Funciile e+ecutate
de fire %or e+ecuta un ciclu n care se scrie un mesaN (i apoi se pune firul n a(teptare un
numr de milisecunde. In e+emplul nostru dimensiunea sti%ei firelor de e+ecuie %a fi
zero iar lista de parametri pasai firelor %a fi 4UII.
T include _stdio.*"
T include _stdli#.*"
T include _process.*"
MM functie e+ecutata de un fir
%oid ft*r1(%oid 7 ar8)
:
int ie
:
printf(it*read1Oni)e
dsleep(1000)e
<
returne
<
MM functie e+ecutata de un fir
%oid ft*r2(%oid 7 ar8)
:
int ie
:
printf(it*read2Oni)e
dsleep(300)e
<
returne
<
int main()
:
d#e8int*read(Xft*r1, 0, 4UII)e
d#e8int*read(Xft*r2, 0, 4UII)e
return 0e
<
Cap. 1( <iblioteca #e abloane stan#ar#
In acti%itatea de pro8ramare apar frec%ent anumite structuri de date! liste simplu sau
du#lu nlnuite, cozi, sti%e, mulimi, %ectori, etc. Iim#aNul -JJ are o #i#liotec cu clase
special proiectate pentru crearea (i manipularea acestor structuri. $ceste clase sunt clase
8enerice care au ca parametru tipul o#iectelor manipulate. ,i#lioteca de (a#loane
standard are trei componente
-ontainere. Un container este o structur de date ce conine alte o#iecte. $ceste
o#iecte se numesc elementele containerului. /+emple de containere sunt %ectorii
(i listele.
Iteratori. Iteratorii permit parcur8erea elementelor unui container
$l8oritme. $l8oritmele sunt funcii ce se aplic asupra elementelor unui
container, de e+emplu sortarea elementelor unei liste sau ale unui %ector.
1(.1 Clase generice
-lasele din #i#lioteca de (a#loane standard sunt clase 8enerice n care tipurile datelor (i
funciilor sunt parametri. K clas 8eneric se define(te cu instruciunea template cu forma
template _class V1, class V2, &, class Vn"
class numedclasa
:
MM definitia clasei
<e
In aceast definiie V1, V2, &, Vn sunt tipuri ce se pot utiliza la declararea de o#iecte de
tipul clasei 8enerice. Un o#iect de tipul unei clase 8enerice se declar cu urmtoarea
dia8ram sintactic
numedclasa _tip1, tip2, &, tipn" numedo#iecte
/+emplu. 6 definim o clas 8eneric D ce poate calcula ptratul unui numr ntre8 sau
real.
template _class V"
class D
:
pri%ate!
V ae
pu#lic!
D(V #) :a 0 #e<
V sRuare() :return a 7 ae<
V 8eta() :return ae<
<e
6 definim o#iecte de tipul D ce conin elemente de tip int sau dou#le utiliz9nd clasa
8eneric D.
int main()
:
MM creaz un o#iect cu (a#lonul _int"
D_int" n(2)e
cout __ ipatratul %aloriii __ n.8eta() __ i este i __ n.sRuare() __ endle
MM creaz un o#iect cu (a#lonul _dou#le"
D_dou#le" d(1.12)e
cout __ ipatratul %aloriii __ d.8eta() __ i este i __ d.sRuare() __ endle
return 0e
<
,i#lioteca de (a#loane standard are trei componente
containere. /le sunt o#iecte ce memoreaz alte o#iecte. /+emple de containere
sunt %ectori, liste, cozi, sti%e.
iteratori sunt o#iecte ce permit parcur8erea elementelor unui container
al8oritmi ce implementeaz operaii asupra elementelor containerelor (de e+emplu
sortarea elementelor unui %ector)
In cele ce urmeaz %om prezenta %ectorii (i listele.
1(.2 $ectori
-lasa 8eneric %ector implementeaz %ectori cu elemente de un anumit tip. Un o#iect de
tip %ector are un numr iniial de componente (i dimensiunea lui cre(te dac este ne%oie.
-lasa %ector are ca parametru tipul componentelor %ectorului.
-lasa define(te urmtorii constructori
constructorul implicit (fr parametri)
%ector()e
creaz un %ector %id
constructorul copiere
%ector(%ector p)e
creaz un %ector n care copiaz elementele unui %ector p care este parametru
Fie V tipul componentelor %ectorului (parametrul clasei 8enerice). -lasa define(te
urmtoarele funcii
%oid pus*d#acW(VX)e adau8 un element la sf9r(itul %ectorului
%oid popd#acW()e (tre8e ultimul element al %ectorului
int size()e d numrul de componente ale %ectorului
#ool empt@()e are %aloarea true dac %ectorul este %id
operatorul GH (i funcia VX at(int) selecteaz un element al %ectorului
VX front()e are ca rezultat primul component al %ectorului
VX #acW()eare ca rezultat ultimul component al %ectorului
enionm c un %ector poate a%ea dou sau mai multe elemente e8ale.
/+emplu. 6 crem (i s listm un %ector cu componente ntre8i.
T include _%ector"
int main()
:
MM definim un %ector cu componente intre8i
%ector _int" %e
MM adau8a 2 elemente
%.pus*d#acW(12)e
%.pus*d#acW(E3)e
%.pus*d#acW())e
%.pus*d#acW(11)e
MM afisaza componentele %ectorului
int We
for(W 0 0e W _ %.size()e WJJ)
cout __ %GWH __ endle
return 0e
<
enionm c e+presia %GWH putea fi nlocuit cu e+presia %.at(W).
Ia definirea o#iectului %, %ectorul are alocate un numr implicit de componente
.up e+ecuia instruciunilor pus*d#acW() %ectorul este urmtorul
(i are dimensiunea 2. enionm c %ectorul are un element ficti% naintea primului
element (i altul dup ultimul element.
.teratori
Aentru parcur8erea componentelor unui container (%ector, list, etc.) se pot utiliza
iteratori. Un iterator este asemenea unui pointer la un element al containerului.
-lasa iterator define(te urmtorii operatori
operatorii JJ (i E E modific iteratorul la urmtoarea M precedenta poziie din
container
operatorii relaionali 0 0, P0, _, _0, ", "0 permit compararea a doi iteratori
operatorul de adresare indirect 7 permite adresarea M modificarea %alorii de la
poziia curent a containerului
Un iterator poate fi iniializat la orice poziie iniial din container. 5om meniona c
e+ist dou tipuri de iteratori ce permit parcur8erea %ectorilor n sens direct (i respecti% n
sens in%ers.
Parcugerea unui vector n sens #irect
-lasa iterator este o clas intern a containerului (n cazul nostru a clasei %ector). Un
o#iect de tipul acestei clase se define(te astfel
%ector_tip"!!iterator numedo#iecte
-lasa %ector define(te funciile
#e8in()e
end()e
ce au ca rezultat un iterator ce indic primul element al %ectorului (i respecti% elementul
ficti% primul ce urmeaz dup ultimul element al %ectorului. Aentru %ectorul anterior
a%em situaia din fi8ura de mai Nos
Parcurgerea unui vector n sens invers
-lasa re%ersediterator este o clas intern a containerului (n cazul nostru a clasei %ector).
Un o#iect de tipul acestei clase se define(te astfel
%ector_tip"!!re%ersediterator numedo#iecte
-lasa %ector define(te funciile
r#e8in()e
rend()e
ce au ca rezultat un iterator ce indic ultimul element al %ectorului (i respecti% elementul
ficti% ce precede primul element al %ectorului. Aentru %ectorul anterior a%em situaia de
mai Nos
/+emplu. 6 parcur8em %ectorul anterior utiliz9nd iteratori.
T include _%ector"
int main()
:
MM definim un %ector cu componente intre8i
%ector _int" %e
MM se adau8a 2 elemente
%.pus*d#acW(12)e
%.pus*d#acW(E3)e
%.pus*d#acW())e
%.pus*d#acW(11)e
MM afisaza componentele %ectorului utilizand iteratori
%ector _int"!!iterator ite
for(it 0 %.#e8in()e it P0 %.end()e itJJ)
cout __ 7it __ endle
MM afisaza conponentele %ectorului in ordine in%erse utilizand iteratori
%ector_int"!!re%ersediterator iter1e
for(iter1 0 %.r#e8in()e iter1 P0 %.rend()e iter1JJ)
cout __ 7iter1 __ endle
return 0e
<
Autem reprezenta parcur8erea %ectorului ca mai Nos
4ortarea componentelor unui vector
,i#lioteca de (a#loane standard define(te funcii de sortare a componentelor unui %ector.
$ceste funcii sunt definite n #i#lioteca _al8orit*m". Arima dintre acestea, funcia sort()
are urmtorul prototip
sort(iter1, iter2)e
unde iter1 (i iter2 sunt iteratori ce dau primul element din %ector (i ultimul element din
%ector ce %or fi sortai. Arototipul funciei sort() este definit n #i#lioteca _al8orit*m".
/+emplu. 5om crea un %ector cu componente tip strin8 (i l %om sorta.
T include _%ector"
T include _al8orit*m"
T include _strin8"
int main()
:
int ie
%ector_strin8" %ste
%st.pus*d#acW(ia#ci)e
%st.pus*d#acW(irsti)e
%st.pus*d#acW(iccdi)e
%st.pus*d#acW(imnpi)e
MM afisaza %ectorul
cout __ i%ectorul initiali __ endle
for(i 0 0e i _ %st.size()e iJJ)
cout __ %st.at(i) __ endle
MM sorteaza %ectorul
sort(%st.#e8in(), %st.end())e
MM afisaza %ectorul
cout __ i%ectorul sortati __ endle
for(i 0 0e i _ %st.size()e iJJ)
cout __ %st.at(i) __ endle
return 0e
<
$ doua funcie sort() are urmtorul prototip
sort(iter1, iter2, comp)e
unde iter1 (i iter2 sunt iteratori ce dau primul element din %ector (i ultimul element din
%ector ce %or fi sortai iar comp este o funcie cu prototipul
#ool comp(V +, V @)e
Aarametri + (i @ sunt dou elemente de tipul V al componentelor %ectorului. Funcia sort
permut elementele + (i @ dac funcia comp are rezultatul false. Arototipul funciei sort()
este definit n #i#lioteca _al8orit*m".
/+emplu. 5om crea un %ector cu componente ntre8i (i l %om sorta n ordine cresctoare
(i apoi descresctoare. 5om defini dou funcii de comparare pentru cele dou cazuri
T include _%ector"
T include _al8orit*m"
M7
funcie de comparare pentru sortarea elementelor
%ectorului in ordine crescatoare
7M
#ool comp(int W, int n)
:
return W _ ne
<
M7
funcie de comparare pentru sortarea elementelor
%ectorului in ordine descrescatoare
7M
#ool comp2(int W, int n)
:
return W " ne
<
int main()
:
%ector_int" %e
MM creaza %ectorul
%.pus*d#acW(12)e
%.pus*d#acW(E1)e
%.pus*d#acW(2)e
%.pus*d#acW(12)e
MM afisaza %ectorul
cout __ S5ectorul initialg __ endle
int ie
for(i 0 0e i _ %.size()e iJJ)
MM cout __ %GiH __ endle
cout __ %.at(i) __ endle
MM afisaza %ectorul cu iterator
%ector_int"!!iterator itere
cout __ i5ectorul initialOnie
for(iter 0 %.#e8in()e iter P0 %.end()e iterJJ)
cout __ 7iter __ endle
MM sorteaza %ectorul in ordine crescatoare
sort(%.#e8in(), %.end(), comp)e
MM afisaza %ectorul sortat
cout __ i5ectorul sortat in ordine crescatoareOnie
cout __ %GiH __ endle
MM sorteaza %ectorul in ordine descrescatoare
sort(%.#e8in(), %.end(), comp2)e
MM afisaza %ectorul sortat
cout __ i5ectorul sortat in ordine descrescatoareOnie
cout __ %GiH __ endle
return 0e
<
1(.3 =iste
-lasa 8eneric list implementeaz o list du#lu nlnuit, adic o list ce poate fi
parcurs n am#ele sensuri. Iista poate a%ea oric9te elemente de acela(i tip. Arototipul
clasei este definit n #i#lioteca _list". -lasa define(te urmtorii constructori
constructorul implicit
list()e
define(te o list %id
constructorul
list(list p)e
creaz o list n care copiaz elementele listei p
Fie V tipul elementelor listei. Funciile definite de clasa list sunt urmtoarele.
%oid pus*d#acW(VX)e adau8 un element la sf9r(itul listei
%oid pus*dfront(VX)e adau8 un element la nceputul listei
%oid popdfront()e (ter8e primul element din list
%oid popd#acW()e(ter8e ultimul element din list
VX front()e are ca rezultat primul element din list
VX #acW()eare ca rezultat ultimul element din list
1(.3.1 Parcurgerea listelor
Aentru parcur8erea componetelor unei liste se pot utiliza iteratori. Un iterator este un
pointer la un element al listei.
Parcurgerea listelor n or#ine #irect9

Aentru parcur8erea unei liste n ordine direct se utilizeaz clasa iterator care este o clas
intern a clasei list. Un o#iect de tipul acestei clase se define(te astfel
list_tip"!!iterator numedo#iecte
Kperaiile implementate de clasa iterator sunt cele prezentate n para8raful anterior.
Aentru parcur8erea direct a listelor clasa list define(te funciile
#e8in()e
end()e
ce au ca rezultat un iterator ce indic primul element al listei (i respecti% ultimul element
al listei.
Parcurgerea listelor n or#ine invers9
Aentru parcur8erea in%ers a listelor se utilizeaz clasa re%ersediterator care este tot o
clas intern a clasei list. Un o#iect de tipul acestei clase se define(te ca
list_tip"!!re%ersediterator numedo#iecte
Kperaiile implementate de clasa iterator sunt cele prezentate n para8raful anterior.
-lasa list define(te funciile
r#e8in()e
rend()e
ce au ca rezultat un iterator pentru parcur8erea n sens in%ers a listei ce indic ultimul
element al listei (i respecti% primul element al listei.
1(.3.2 4ortarea listelor
Aentru sortarea n ordine direct (i in%ers a listelor clasa list define(te funciile
%oid sort()e
%oid re%erse()e
ce sortez elementele listei n ordine direct (i in%ers.
/+emplu. 5om crea o list cu elemente ntre8i, o %om sorta ascendant (i descendent (i
%om afi(a elementele listei.
T include _list"
int main()
:
list _int" lse
MM adau8a elemente la sfarsitul si inceputul listei
ls.pus*d#acW(11)e
ls.pus*d#acW())e
ls.pus*dfront(2)e
ls.pus*dfront(12)e
MM parcur8erea listei
cout __ ilista initialaOnie
list_int"!!iterator itere
for(iter 0 ls.#e8in()e iter P0 ls.end()e iterJJ)
MM sortarea elementelor
ls.sort()e
MM parcur8erea listei sortate
cout __ ilista sortataOnie
MM sortarea elementelor in ordine in%ersa
ls.re%erse()e
MM parcur8erea listei sortate
cout __ ilista sortata in ordine in%ersaOnie
MM parcur8erea listei
cout __ iparcur8erea listei in ordine in%ersaOnie
list_int"!!re%ersediterator iter1e
for(iter1 0 ls.r#e8in()e iter1 P0 ls.rend()e iter1JJ)
cout __ 7iter1 __ endle
return 0e
<

Curs Programare C

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Curs Programare C

Încărcat de

Drepturi de autor:

Formate disponibile

CPP

rimea numrului natural corespunztor este!

In partea dreapt a%em un polinom de puteri ale lui 2. -oeficientul

.up n astfel de operaii %om a%ea!

este ec*i%alent cu deplasarea

iar mantisa corespunde la opt cifre zecimale.

1.2 Reprezentarea caracterelor

S-ar putea să vă placă și