Book Basics of Programming in C++ Tudor 2010

See
discussions, stats, and author profiles for this publication at: http://www.researchgate.net/publication/256780425
Bazele programrii n limbajul C++

BOOK JANUARY 2010
CITATION
READS
873
1 AUTHOR:
Nicoleta Liviana Tudor
Petroleum - Gas University of Ploiesti
27 PUBLICATIONS 17 CITATIONS
SEE PROFILE
Available from: Nicoleta Liviana Tudor

Retrieved on: 07 December 2015
Tudor L., Bazele programrii n limbajul C++, Editura MATRIX ROM, Bucureti, ISBN 978-973-755-644-8, 2010
LIVIANA TUDOR
BAZELE PROGRAMRII
N LIMBAJUL C++
MATRIX ROM
Bucureti 2010
LIVIANA TUDOR
Editura MATRIX ROM

Bucureti 2010
Referent tiinific
prof. dr. ing. Mircea Petrescu
Universitatea POLITEHNICA Bucureti
Tehnoredactare computerizat
lect. dr. Tudor Nicoleta Liviana
Universitatea Petrol-Gaze din Ploiesti
ltudor@upg-ploiesti.ro
tudorlivia@yahoo.com
1.
2.
3.
4.
Sisteme de calcul. Reprezentarea datelor n memoria calculatorului

1.1.
Componenta hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.
Componenta software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
1.3.
Reprezentarea datelor n memoria calculatorului . . . . . . .
17
Principiile programrii structurate. Metode de reprezentare a

algoritmilor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
2.1. Principiile programrii structurate . . . . . . . . . . . . . . . . . . .
22
2.2. Reprezentarea algoritmilor . . . . . . . . . . . . . . . . . . . . . . . . . .
23
2.3. Aplicaii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
28
Limbajul C++. Alfabet i vocabular . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
3.1. Alfabetul limbajului C++ . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
3.2. Vocabularul limbajului C++ . . . . . . . . . . . . . . . . . . . . . . . . .
35
Tipuri de date. Operaii de intrare-ieire . . . . . . . . . . . . . . . . . . . . . . . .
47
4.1. Tipuri fundamentale de date . . . . . . . . . . . . . . . . . . . . . . . .
47
4.2. Structura programelor n limbajul C++ . . . . . . . . . . . . . . .
50
4.3. Funcii uzuale de intrare-ieire . . . . . . . . . . . . . . . . . . . . . .
52
4.4. Operaii cu consola ( header <iostream.h>) . . . . . . . . . . . .

5.
6.
Structuri decizionale: if, switch, operatorul ?: . . . . . . . . . . . . . . . . . . .
57
59
5.1. Instruciunea if i directiva #if . . . . . . . . . . . . . . . . . . . . . . .
59
5.2. Instruciunea switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
64
5.3. Operatorul ?: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
69
Structuri iterative. Instruciuni pentru transferul execuiei . . . . . . . .
71
6.1. Instruciunea for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
71
7.
8.
9.
10.
6.2. Instruciunea while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
76
6.3. Instruciunea do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
81
6.4. Instruciuni pentru transferul execuiei . . . . . . . . . . . . . . .
84
Tablouri ( vectori, matrice, iruri de caractere) . . . . . . . . . . . . . . . . . . .
89
7.1. Tablouri unidimensionale ( vectori) . . . . . . . . . . . . . . . . . . .
90
7.1.1. Cutare n vectori . . . . . . . . . . . . . . . . . . . . . . . . . . .
96
7.1.2. Sortarea unui vector . . . . . . . . . . . . . . . . . . . . . . . . .
99
7.1.3. Interclasarea a doi vectori ordonai . . . . . . . . . . . .
102
7.2. Tablouri bidimensionale ( matrice) . . . . . . . . . . . . . . . . . . .
105
7.3. iruri de caractere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
109
Structuri i uniuni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
117
8.1. Structuri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
117
8.2. Uniuni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
126
Funcii C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
129
9.1. Prototipul, definiia i apelul unei funcii . . . . . . . . . . . . . .
129
9.2. Transferul parametrilor unei funcii . . . . . . . . . . . . . . . . . .
132
9.2.1. Transferul parametrilor prin valoare . . . . . . . . . .
133
9.2.2. Transferul parametrilor prin referin . . . . . . . . .
136
9.2.3. Transferul parametrilor de tip tablou . . . . . . . . .
138
9.2.4. Transferul parametrilor de tip structur . . . . . . .
142
9.3. Funcii cu un numr neprecizat de parametri . . . . . . . . . .
145
9.4. Pointeri la funcii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
146
9.5. Funcii recursive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
148
9.5.1. Funcii direct recursive . . . . . . . . . . . . . . . . . . . . . .
150
9.5.2. Recursivitatea i metoda relurii (backtracking)
155
Structuri de date alocate dinamic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
159
10.1. Operaii cu variabile de tip pointer . . . . . . . . . . . . . . . . . .
159
10.2. Pointeri ctre tablouri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
165
11.
12.
10.3. Structuri autoreferite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
166
Liste i arbori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
169
11.1. Liste, stive, cozi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
169
11.2. Tabele de dispersie (Hash) . . . . . . . . . . . . . . . . . . . . . . . . .
188
11.3. Arbori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
191
11.3.1. Arbori binari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
192
11.3. 2. Arbori oarecare . . . . . . . . . . . . . . . . . . . . . . . . . . .
202
Programare orientat pe obiecte n limbajul C++ . . . . . . . . . . . . . . . .
207
12.1. Clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2. Motenire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3. Suprancrcare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.4. Polimorfism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Bibliografie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
207
211
216
229
239
Capitolul 1
Sisteme de calcul. Reprezentarea datelor

n memoria calculatorului
Un sistem de calcul este un ansamblu de componente hardware

(echipamente fizice) i componente software (componente logice), ce
coordoneaz i controleaz executarea operaiilor prin intermediul programelor
i ofer servicii utilizatorului:
componenta hardware (echipamente de calcul, dispozitive) asigur prelucrarea
automat a informaiei, precum i comunicarea utilizatorului cu sistemul de calcul;
componenta software (sistem de operare i programe specializate).
Programele realizeaz prelucrarea automat, folosind echipamentele de
calcul. Sistemul de operare [Boian F. M., 1994] este un ansamblu de proceduri i
programe care ofer unui grup de utilizatori posibilitatea de utilizare eficient a
sistemului de calcul.
n funcie de metoda de reprezentare a informaiei, sistemele de calcul au
fost clasificate n:
sisteme de calcul analogice ( informaia este codificat sub forma unor
mrimi fizice);
sisteme de calcul numerice, care codific informaia sub form discret
(numeric).
Un sistem de calcul numeric prelucreaz automat informaia codificat
sub form de valori discrete, conform unui program ce indic o succesiune
determinat de operaii aritmetice i logice, avnd la baz un algoritm de
prelucrare. Structura unui calculator numeric a fost definit n anul 1945 de ctre
von Neumann, ca fiind constituit din: UI (unitate de intrare), M (memorie),
UAL (unitate aritmetico-logic), UC (unitate central) i UE (unitate de ieire).
1.1. Componenta hardware

Schema de principiu a unui sistem de calcul este prezentat n figura 1:
Unitatea central (UC) gestioneaz activitatea componentelor sistemului
de calcul, asigur execuia programelor din memoria central i execut
operaiile de prelucrare automat a informaiilor.
UC = CPU (unitate central de prelucrare ) + MI ( memorie intern )

CPU = UCC ( unitate de comand i control ) + UAL ( unitate aritmetico-logic)
Fig. 1. Schema unui sistem de calcul.

Unitatea central conine memoria central, unitatea aritmetico-logic i
unitatea de comand i control.
Memoria central conine regitrii pentru memorarea temporar a datelor
programului care se execut i pstreaz datele n locaii codificate binar,
identificate prin adrese de memorie.
Dispozitivele aritmetico-logice execut operaiile aritmetice i/sau logice
sau alte operaii specificate de instruciunile executate.
Unitatea de comand i control coordoneaz activitatea celorlalte
componente ale sistemului de calcul i asigur buna funcionare a unitii
centrale.
Unitile de schimburi multiple permit comunicarea ntre sistemul de
calcul i exterior, coordonnd funcionarea dispozitivelor periferice.
Dispozitivele periferice sunt imprimanta, monitorul (display ecran),
unitile de discuri, tastatura, mouse, scanner, plotter, boxe, camer Web.
Unitatea de memorie : Unitatea fundamental de msur a memoriei este
bitul.
Bit (binary digit) = cantitatea de informaie ce poate fi memorat ntr-o
celul binar.
O locaie de memorie = o succesiune de celule binare folosite n timpul
operaiilor de citire din memorie sau scriere n memorie.
Un octet (byte) 1o = 1 B = 8 bii = cantitatea de informaie memorat ntr-o

locaie.
Capacitatea total a memoriei reprezint numrul maxim de octei ce pot
fi nregistrai.
Un Kilo-octet 1 Ko = 1 Kb (kilo-byte) = 1024 o = 210 o
Un Mega-octet (1 Mo) = 1024 Ko = 210 Ko
Un Giga-octet = 1024 Mo = 210 Mo
Un Tera-octet = 1024 Go = 210 Go
Memoria este de dou tipuri :
memorie intern pstreaz datele i instruciunile programelor n locaii de
memorie identificate prin adrese sub form de cifre binare, grupate n octei
(byte), date care sunt prelucrate de procesor.
Din punct de vedere logic, memoria intern este organizat n blocuri de
memorie, 1 bloc = 64 Kb.
Se cunosc urmtoarele tipuri de memorii interne:
- memoria RAM (Random Access Memory) este memoria cu acces aleator,
ce conine datele programului ce este executat la momentul curent,
procedurile/programele sistemului de operare. Este volatil (coninutul ei
dispare la nchiderea calculatorului) i asigur accesul rapid la date, prin
operaii de citire i scriere. Din punct de vedere fizic, memoria RAM este un
circuit integrat alctuit din milioane de tranzistoare i condensatoare.
Memoria RAM poate fi: SRAM i DRAM:
SRAM (static) utilizeaz mai muli tranzistori pentru o celul de memorie
i este folosit n special n memoria CACHE. Memoria cache stocheaz
datele refolosite de ctre procesor
DRAM (dinamic) utilizeaz o pereche tranzistor/condensator pentru
fiecare celul de memorie i necesit un refresh continuu deoarece
tranzistorul se descarc foarte rapid. O celul stocheaza 1 bit. Celulele sunt
dispuse ntr-o matrice de linii i coloane la intersecia crora se afl adresa
de memorie.
- memoria ROM (Read Only Memory) din care se pot doar citi date, nu i
scrie. Nu este volatil. Include:
PROM (Programmable Read Only Memory)
EPROM (Eraseable Programmable Read Only Memory) permite n plus
tergerea datelor
EEPROM (Electricaly Eraseable Programmable Read Only Memory) pot fi
att citite ct i terse n mod selectiv i programate de ctre sistemul care le
utilizeaz.
- memoria CMOS conine informaii despre caracteristicile fizice ale
calculatorului (configuraia calculatorului, tipul i capacitatea HDD,
capacitatea memoriei interne, data calendaristic, parola de acces etc.),
informaii utilizate de BIOS (Basic Input Output System). Memoria CMOS
are capacitate foarte mic (64B), permite operaii de citire i scriere a datelor
i este nevolatil.
memorie extern constituit din suporturi electromagnetice sau optice
reutilizabile, pe care se pstreaz datele codificate n form binar. Memoria
extern este mai lent dect memoria intern, dar conine cantiti mari de date.
Memoria extern utilizeaz:
- suporturi electromagnetice (floppy-disk, hard-disk HDD) suprafaa
discului este mprit n piste (cercuri concentrice), care sunt mprite n
sectoare egale. Pistele care au aceeai raz formeaz un cilindru. Locaia de
memorare de pe disc este sectorul, care are o capacitate de 512 octei
- suporturi optice discurile optice (discuri compact-CD si discuri DVDdisc video digital). Suprafaa discului este mprit n piste continue, n
form de spiral. Spaiul de memorare este divizat n blocuri pentru
adresarea unei locaii.
- suporturi electronice cardurile de memorie flash. Celulele binare (biii)
utilizai corespund strii anumitor circuite (nchis-deschis, prezena sau
absena curentului electric n circuite).
Hard Disk-ul ( disc dur, rigid) conine un strat magnetic pe un suport
rigid. Disk-ul hard este construit dintr-un metal dur i uor, de obicei din
aluminiu, fiind singura component a unui PC care nu este 100% electronic. Din
aceast cauz, ea este i mai nceat, n comparaie cu restul componentelor
calculatorului personal.
1.2. Componenta software

Componenta software este format din sistemul de operare ( S.O.) i
programele pentru aplicaii.
Definiie 1 Sistemul de operare este un set de proceduri manuale i
automate care ofer unui grup de utilizatori posibilitatea s foloseasc n acelai
timp i n mod eficient sistemul de calcul.
Definiie 2 Sistemul de operare este un ansamblu de programe care
faciliteaz accesul la sistemul de calcul unuia sau mai multor utilizatori i asigur
o exploatare eficient a echipamentului de calcul.
Caracteristicile sistemului de operare:
- este rezident n memoria intern (RAM) a calculatorului (se ncarc automat
la fiecare deschidere sau resetare a calculatorului)
- conine un ncrctor (care se afl pe prima pist a fiecrui disc de boot)
- n memoria ROM, exist un prencrctor care este folosit la iniializarea
lucrului cu calculatorul (iniializarea echipamentelor periferice, identificarea
configuraiei sistemului de calcul, cutarea unui disc de boot (cu sistemul de
operare). Acesta ncarc n RAM nucleul sistemului de operare i l lanseaz n

execuie. Nucleul va ncrca programele de aplicaie i utilitarele.
-
Componentele sistemului de operare sunt:

nucleul ( Kernel )
interfaa ( shell )
Nucleul ( Kernel) conine programele necesare pentru gestionarea

resurselor calculatorului i pentru controlarea activitii echipamentelor.
Funciile nucleului constau n:
- administrarea resurselor fizice: procesorul, memoria intern i sistemul I/O
(Input/Output)
- depistarea i tratarea evenimentelor deosebite (inexistena hrtiei la
imprimant, citirea dintr-un fiier inexistent, rezultatul unei operaii aritmetice ce
depete capacitatea zonei de memorie alocat)
- asigur operaiile de I/O la nivel fizic (cu echipamentele periferice)
- asigur operaiile de I/O la nivel logic (unitatea logic de acces la
echipamentele periferice este fiierul)
- gestionarea fiierelor de pe disc.
Interfaa sistemului de operare (SHELL)
- definete modul n care utilizatorul interacioneaz cu S.O.
- interfaa poate folosi: un limbaj de comand (ex. s. o. MS-DOS) sau interfaa
grafic (G.U.I. - graphical user interface, ex. s. o. Windows ).
Funciile sistemului de operare sunt:
- pregtirea i lansarea n execuie a programelor de aplicaii ( figura 2):
- funcia de gestiune a memoriei ( stabilirea procesului cruia i se aloc
memorie, momentul de timp i cantitatea, n cazul multiprogramrii, alocarea
resursei asigurnd accesul i protecia proceselor solicitante i dezalocarea
resursei)
- funcia de gestiune a procesorului ( U. C. ) aloc resursele procesorului la
un proces, prin pregtirea i ncrcarea unor regitrii hardware i dezaloc
resursa
- funcia de gestiune a dispozitivelor periferice, a unitilor de control i a
canalelor ( I/O Traffic Controller) aloc resura i iniiaz operaia de I/O i
dezaloc resursa
- funcia de gestiune a informaiei const n:
localizarea informaiei, starea, utilizarea ( File System)
metode de acces i protecie
Fig. 2. lansarea n execuie a unui program.
alocarea resursei prin deschiderea fiierului ( OPEN)

dezalocarea resursei prin nchiderea fiierului ( CLOSE).
Programele S. O.
Componentele majore ale unui S.O. sunt:
programe de comand i control ( PCC ) - coordoneaz i controleaz

funciile S.O., fiind programe supervizoare, monitoare i executive). Au
componente
- rezidente ( sunt ncrcate n memoria intern nc de la generarea
S.O. i pstrate acolo pe tot parcursul execuiei lucrrilor de ctre
S.O., ele formeaz nucleul S.O.)
- tranzitorii ( componente ce rmn n memoria auxiliar, fiind apelate
i executate de ctre nucleul S.O.)
programe de servicii ( folosite pentru dezvoltarea programelor de aplicaie,

fiind executate sub supravegherea PCC ). Ele pot fi clasificate n:
- translatoare (asamblor, macroasamblor, compilator, interpretor )
- editoare de legturi
- ncrctoare
- editoare de texte
- programe pentru organizarea coleciilor de date ( fiiere, baze de
date)
- alte utilitare.
Translatoarele de limbaje
traduc programele surs n programe obiect, ale cror instruciuni n limbaj

main pot fi executate de sistemul de calcul
sunt dou categorii de translatoare:

- compilative ( realizeaz numai traducerea programului surs n

program obiect), de exemplu:
- asambloare traduc programele surs, scrise n limbaje de
asamblare specifice S.C.
- compilatoare traduc programele surs scrise n limbaje
evoluate; unele compilatoare efectueaz i lansarea n execuie a
programelor ( LOAD and GO)
- interpretative (odat cu compilarea, are loc si execuia programului ).
Compilatoarele creeaz o form intermediar arborescent a
instruciunilor din programul surs, astfel:
- orice variabil este un nod terminal al arborelui
- orice operator creeaz un arbore binar a crui ramur stng este primul
operand, iar cea din dreapta este operandul 2.
Exemplu: S se construiasc arborele binar corespunzator aciunii unui
compilator, pentru calculul expresiei x ( figura 3):
x = a * ( b c ) + d * ( e + 10)
Fig. 3. arbore binar corespunztor aciunii unui compilator.

Etapele unui proces de compilare i componentele implicate sunt
evideniate n figura 4:
Analiza lexical descompune programul surs n atomi lexicali
(identificatori, cuvinte rezervate, constante, operatori ) i i introduce n tabela de
simboluri sub form codificat.
Analiza sintactic irul de atomi lexicali este analizat pentru depistarea
unor structuri sintactice, cum ar fi expresii, liste, proceduri, plasndu-le ntr-un
arbore de derivare.
Analiza semantic genereaz un grup de instruciuni simple cu format
fix (cod intern); dac arborele sintactic nu respect gramatica limbajului, se
semnaleaz eroare.
Fig. 4. Etapele procesului de compilare.

Optimizarea codului presupune eliminarea variabilelor inutile, n
vederea unei execuii mai eficiente.
Generarea codului aloc zone de memorie pentru pstrarea datelor n
timpul execuiei i produce codul obiect (n limbaj de asamblare).
Gestiunea structurilor de date vizeaz o colecie de proceduri care creeaz
i actualizeaz bazele de date cu care lucreaz celelalte faze. n baze de date se
memoreaz tabelele identificatorilor, ale constantelor, ale cuvintelor cheie i ale
procedurilor standard.
Tratarea erorilor este realizat de o colecie de proceduri ce sunt activate
cnd se depisteaz o eroare n program; utilizatorul primete mesaje de
avertizare, iar compilatorul continu analiza sintactic pentru a depista alte erori.
Exemple de sisteme de operare pot fi:

sistemul de operare Windows: are o interfa utilizator grafic GUI
(Graphical User Interface) i cu un set bogat de aplicaii:
- suprafaa de lucru se numete desktop i conine pictograme
(dosare)
- aplicaia My Computer conine informaii referitoare la cele mai
importante componente ale sistemului de calcul ( uniti de disc,
imprimante instalate, etc.)
- aplicaia My Network Places afieaz informaii despre conexiunea
la reele locale i calculatoarele accesate
- butonul START se afl pe taskbar i conine aplicaiile instalate
sistemul de operare Unix este scris n proporie de 90% n limbajul C++.
Componentele S.O. Unix sunt:
- nucleul (Kernel), care realizeaz funciile de baz ale S.O.
- interfaa asigurat de limbajul de comand Shell, pentru
comunicarea utilizator sistem de calcul
- programe utilitare, ce ofer posibiliti suplimentare de utilizare a
sistemului de calcul
- programe de aplicaii, pentru dezvoltare de aplicaii consol sau
vizuale
sistemul de operare Netware, utilizat pentru administrarea serverelor de

fiiere, stocarea fiierelor, asigurnd prelucrarea distribuit i centralizat a
datelor, securitatea sistemului (exemplu, reele Novell Netware).
Comunicarea este asigurat de:
- folosirea de protocoale i drivere LAN
- ncrcarea lui Netware Dos Requester pe fiecare client al reelei
- folosire Link Support Layer (LSL)
- exemple de tipuri de clieni acceptai de S.O. Netware 3.12. sunt:
clientul DOS, OS/2, Macintosh, Unix
Protocolul de comunicaie este un set de reguli ce determin modul de
comunicare n reea, ntre staii de lucru i server.
1.3. Reprezentarea datelor n memoria calculatorului

Fie p N, p 2.
Definiie. Se definete o baz de numeraie: Bp={ bi / 0 i < p},
corespunztoare primelor p numere naturale [Perjeriu E., Vaduva I., 1986]:
Np = {0, 1, . , p-1}.
Funcia f: Np Bp asociaz fiecrui numr i Np simbolul bi = f( i )
Bp,
f( i ) = bi.
Observaie: Sistemele de calcul utilizeaz bazele de numeraie 2 i 16:
B2 = { 0, 1}
B16 = { 0, 1, 2, ...., 9, A, B, C, D, E, F}.
Reprezentarea numerelor ntregi intr-o baz de numeraie dat
Fie x N i p N, p 2, p este o baz de numeraie. Ne propunem s
reprezentm numrul ntreg x n baza p.
Prin mpriri repetate ale numrului x la p se obin :
x = p * co + ro, co < x, 0 ro < p
co = p * c1 + r1, c1 < co , 0 r1 < p
..
cn-1 = p * cn + rn, cn = 0 < cn-1, 0 rn < p
x se poate reprezenta ca un polinom:
x = p * co + ro = p * (p * c1 + r1 ) + ro = ... = pn rn + ... + p1r1 + p0r0.
n irul resturilor : rn, rn-1, ... , r1 , r0, se aplic funcia f :
f( ri) = fi Bp (0 i < n) i se concateneaz se obine reprezentarea
numrului x n baza p:
xp = fn f1f0
co
ro
f0
c1
r1
f1
cn = 0
rn
fn
Exemplul 1: S se reprezinte numrul x = 27 n baza 2

x = 27
co = 13 c1 = 6
r0 = 1 r1 = 1
1
1
c2 = 3
r2 = 0
0
c3 =1
r3 = 1
1
c4 = 0
r4 = 1
1
Reprezentarea numrului 27 n baza 2 este: 272 = 11011= 1*2o+1*21 + 0*22 +

1* 23+ 1*24 = 1 + 2 + 8 + 16 = 27
x=6
co = 3
r0 = 0
0
c1 = 1
r1 = 1
1
c2 = 0
r2 = 1
1
Reprezentarea numrului 6 n baza 2: 62 = 110 = 0*2o+1*21 + 1*22 = 6

x = 27
co = 1 c1 = 0
r0 = 11 r1 = 1
B
1
Scrierea numrului 27 n baza 16: 2716 = 1B = B*160 + 1*161 = 11 + 16 = 27

Reprezentarea numerelor reale intr-o baz de numeraie dat
Fie x R+ i p N, p 2, p este o baz de numeraie. Atunci numrul
real x se poate scrie:
x = [x] + {x}, 0 {x} < 1,
unde [x] este partea ntreag a lui x i {x} este partea fracionar a lui x.
Reprezentarea numrului real x n baza p se reduce la reprezentarea
numrului {x} n baza p i folosete urmtorul algoritm:
se nmulete n mod repetat partea fracionar a lui x cu baza p
se descompune n parte ntreag i parte fracionar, .a.m.d.
Notm x1 = p * {x} = [x1] + {x1} = r -1 + {x1}, 0 r -1 < p
x2 = p * {x1} = [x2] + {x2} = r -2 + {x2}, 0 r -2 < p
x3 = p * {x2} = [x3] + {x3} = r -3 + {x3}, 0 r -3 < p

..
xn = p * {xn-1} = [xn] + {xn} = r -n + {xn}, 0 r -n < p.
Se obine reprezentarea polinomial a lui {x}:
{x} = p-1 r-1 + p-2 r-2 + ... + p-nr-n + ...
Notm f( r -i) = f -i Bp (1 i < n) reprezentarea aproximativ a lui {x}p
cu n cifre la partea zecimal este:
{x}p = p-1 r-1 + p-2 r-2 + ... + p-nr-n + ... = f( r 1) f( r 2) f( r -n) = f 1 f 2 f -n
{x}
x1
x2
xn
r -1
r -2
r -n
f 1
f 2
f -n
Exemplu: S se reprezinte x = 27.513 cu 4 cifre zecimale n baza 16
x = 27.513 = 27 + 0.513 = [x] + {x}
[x] = 27
1
11
B
0
1
1
[x] 16 = [ 27 ]16 = 1B
{x} = 0.513
0513*16 = 8.228
8
8
0.228*16 = 3.648
3
3
0.648*16 = 10.368
10
A
5.888
5
5
{ x } 16 = { 0.513 } 16 = 0.83A5
x 16 = [x] 16 + { x } 16 = 1B + 0.83A5 = 1B.83A5
Reprezentarea numerelor ntregi n memoria calculatorului

Pe un cuvnt-memorie ( 4o = 32 biti), se pot nregistra numere ntregi
pozitive cu maximum 32 cifre binare sau 8 cifre hexazecimale < 232 1.
Se partiioneaz intervalul [ 0, 232 1] n: [ 0, 231 1] U [231, 232 1]
y=
x, daca 0 x 31 1
2
232 | x |, daca 231 x < 0 (prin complementare)
- 231 x 231 1
0, daca x 0
Observaie: Primul bit =

1, daca x < 0
Exemplul 1: S se reprezinte numrul x = 27 n memorie:

2716 = 1B; 272 = 11011
00000000 00000000
0
0
0
0
00000000
0
0
00011011
1
B
Exemplul 2: S se reprezinte numrul x = 231 1 n memorie:

x = 231 1 = 7F.FF.FF.FF16
01111111
7
F
11111111
F
F
11111111
F
F
11111111
F
F
Exemplul 3: S se reprezinte numrul x = -231 n memorie:

y = 232 |x| = 232 231 = 231 * 2 231 = 231 ( prin complementare) = 8000000016
10000000 00000000
8
0
0
0
00000000
0
0
00000000
0
0
Capitolul 2
Principiile programrii structurate.

Metode de reprezentare a algoritmilor
Rezolvarea problemelor cu ajutorul calculatorului presupune existena unei

faze premergtoare n care se concepe algoritmul.
Un algoritm este o secven finit de operaii, ordonat i complet definit,
care, pornind de la date de intrare, furnizeaz date de ieire (rezultate).
Un algoritm trebuie s satisfac n general urmtoarele cerine:
claritate descrierea algoritmului se realizeaz ntr-un mod precis, fr
ambiguiti, coninnd toate etapele de calcul, toate posibilitile ce apar, pentru
a obine o soluie
generalitate un algoritm este util dac rezolv o clas ntreag de probleme
finitudine - algoritmul trebuie s furnizeze rezultate pentru orice set de date
de intrare, ntr-un numr finit de pai. O eroare care trebuie evitat const n
utilizarea de structuri repetitive infinite ( bucle infinite), care blocheaz
programele.
Operaiile elementare care apar ntr-un algoritm sunt:
- operaii de citire-scriere ( intrare-ieire) datele de intrare se citesc, iar
datele de ieire se scriu
- operaii de atribuire unei variabile i se atribuie valoarea unei expresii
- operaii de decizie se determin valoarea de adevr a unei expresii
logice i, n funcie de rezultatul obinut, se ramific execuia
algoritmului.
Algoritmii utilizeaz variabile pentru operaiile elementare. De exemplu,
variabilele de intrare se citesc, se prelucreaz, iar variabilele de ieire se afieaz
(se scriu).
Variabile
O noiune de baz n programare este cea de variabil. O variabil
reprezint un ansamblu de patru elemente:
- numele variabilei
- tipul ei
- valoarea ei
- adresa din memorie, unde se salveaz variabila.
Numele unei variabile este format din unul sau mai multe caractere: litere,
cifre, caracterul underscore (de subliniere), primul caracter fiind liter. Referirea
unei variabile se realizeaz prin intermediul numelui su. Exemple: a, b, S, min,
maxim, x1, etc.
Tipul variabilei indic mulimea de valori posibile ( ntreg, real, caracter,
boolean, etc.), operaiile ce pot fi aplicate acesteia, precum i modul de
reprezentare n memoria calculatorului. Fiecare limbaj de programare permite
folosirea unor tipuri elementare de date, specifice acestuia. Pentru fiecare
variabil folosit trebuie declarat n mod explicit tipul de date.
Valoarea unei variabile este valoarea efectiv memorat la un moment dat. O
variabil are n orice moment o singur valoare, care se poate modifica printr-o
instruciune de atribuie sau de citire.
Adresa de memorie a unei variabile este adresa fizic la care se afl valoarea
variabilei n memoria calculatorului.
2.1. Principiile programrii structurate

Odat cu dezvoltarea informaticii a aprut conceptul de programare
structurat. Ideea de baz const n elaborarea algoritmilor folosind structuri
elementare, avnd un singur set de date de intrare i un singur set de date de
ieire.
Un principiu de baz al programrii structurate este enunat de teorema de
structur a lui Bhm i Jacopini, conform creia orice algoritm se poate construi
folosind doar trei structuri de control: secvenial, alternativ ( decizional) i
repetitiv.
Structurile elementare utilizate n programarea structurat sunt prezentate
n figura 1.
- structura liniar ( secvenial) const n execuia necondiionat a
unei secvene de instruciuni
- structura alternativ (decizia) ramific execuia algoritmului n
funcie de valoarea de adevr a unei condiii evaluate
- structura repetitiv ( repetiia) const n execuia repetat de un
numr finit de ori a unei secvene de instruciuni. Exist
posibilitatea utilizrii de structuri repetitive cu test inial (se
evalueaz condiia la nceput i dac este ndeplinit, se execut
instruciunile) sau structuri repetitive cu test final ( se execut
instruciunile cel puin o dat i la final se evalueaz condiia).
Fig. 1. Structuri de control.

Un principiu de baz al programrii structurate este programarea
descendent, care presupune descompunerea unei probleme complexe n
subprobleme mai simple. Fiecrei subprobleme i corespunde un modul de
instruciuni, realizndu-se astfel o structurare modular a problemelor. Un
avantaj al programrii modulare const n extinderea i modificarea programelor
prin actualizarea sau adugarea unor module cu instruciuni.
2.2. Reprezentarea algoritmilor

Pentru descrierea algoritmilor se pot utiliza:
- schema logic
- pseudocodul
- limbajul de programare
Schema logic
Este o reprezentare grafic, ce permite vizualizarea nlnuirii i
subordonrii secvenelor de operaii. Folosete simboluri grafice numite blocuri
care prin forma lor, indic tipul operaiei.
Pseudocodul
Este o metod de reprezentare a algoritmilor ce tinde spre un limbaj de
programare, neavnd totui o sintax rigid, precum limbajele de programare.
Elementele componente ale limbajului pseudocod sunt:
instruciuni pentru scriere

write lista_variabile
Exemple: write x
write (suma este , s)
instruciuni pentru citire

read lista_variabile
Exemple: read n
instruciuni de atribuire
variabila expresie
Exemple: S 0
S=0
instruciuni decizionale
if condiie then instructiune_1
else instructiune_2
endif
Exemplu: if x >=0 then write ( numar pozitiv)

else write (negativ)
endif
instruciuni repetitive cu contor

for contor = valoare_initiala, valoare_finala
instructiune_1
instructiune_2
endor
sau:
for contor = valoare_initiala, valoare_finala
instructiune_1
instructiune_2
repeat
Exemplul 1) afiarea primelor 100 numere naturale

for i = 1 , 100
write i
repeat
Exemplul 2) Calculai suma primelor n numere naturale ( n este dat):

procedure suma
read n
s0
for i = 1 , n
ss+i
repeat
write (suma s =,s)
end
instruciuni repetitive cu test iniial

while conditie:
instructiune_1
instructiune_2
repeat

i=1
while i <= 100
write i
i i +1
repeat
Exemplul 2) Afiai primele n numere naturale, unde n este dat.
procedure afisare
read n
i=1
while i <= n
write i
i i+1
repeat
end
instruciuni repetitive cu test final

do
instructiune_1
instructiune_2
until conditie

i=0
do
i i +1
write i
until i >= 100
Exemplul 2) Afiai primele n numere naturale, unde n este dat.
procedure afisare
read n
i=1
do
write i
i i+1
until i >= n+1
end
instruciuni pentru apelul procedurilor

procedure nume [ ( lista de parametri formali )]
[ declaratii locale]
[ secven de instruciuni ]
[ return]
end
Observaii:
- apelarea unei proceduri se realizeaz prin instruciunea
call nume [ (lista de valori)]
- o apelare corect are loc dac ntre lista parametrilor i cea a
valorilor exist o bijecie ( coresponden de numr, tip i
ordine)
- o procedur poate apela o alt procedur
- terminarea execuiei unei proceduri se face la ntlnirea unei
instruciuni return sau end, care determin ntoarcerea n
programul apelant, la instruciunea imediat urmtoare
instruciunii call, care a apelat-o.
Exemplu: S se calculeze suma a 2 numere a i b reale
procedure suma
integer a, b, s
read a, b
sa+b
write ( suma = , s)
return
end
Apelul procedurii ntr-o aplicaie se realizeaz asfel:
call suma
instruciuni pentru apelul funciilor

function nume [ ( lista de parametri formali )]
[ declaratii locale]
[ secven de instruciuni ]
[ return]
end
Observaii:
- apelarea unei funcii se realizeaz prin instruciuni precum:
call nume [ (lista de valori)]
sau
expresie nume [ (lista de valori)]
sau alte tipuri de instruciuni de scriere sau repetitive, etc., n
funcie de aplicaie
Exemplu: S se calculeze valoarea funciei f definit astfel

3x 5, x < 5
f(x) = 10, 5 x 10
9 x + 1, x > 10
function f ( x )
if x < 5 then f = 3 * x 5
else if x <= 10 then f = 10
else f = 9 * x +1
endif
endif
end
Apelul functiei se poate realiza asfel:
write f(x)
sau
call f(x)
sau se pot utiliza alte variante de apel, n funcie de aplicaie.
instruciunea
GOTO etichet
unde eticheta indic o instruciune din aceeai procedur
Este indicat s evitm folosirea instruciunii goto deoarece ngreuneaz
nelegerea algoritmului
declaraia unui tablou

array A( n )
2.3. Aplicaii
Se dau 3 numere reale x, y, z. S se calculeze valoarea expresiei:

E=
x + y, z < 0
x * y, z = 0
0, z > 0
procedure expresie
integer x, y, z, e
read x, y, z
if z < 0 then e x + y
else if z = 0 then e x * y
else e 0
endif
endif
write (expresia E = , e)
return
end
S se citeasc n numere reale. Calculai i afiai suma celor n numere.
Metoda 1: folosnd o structur repetitiv for

procedure calcul
read n
s0
for i = 1 , n
read x
ss+x
repeat
write (suma s =, s)
end
Metoda 2: folosnd o structur repetitiv while
procedure calcul
read n
s0
i=1
while i <= n
read x
ss+x
i i+1
repeat
write (suma s =,s)
end
Metoda 3: folosnd o structur repetitiv do-until
procedure calcul
read n
s0
i=0
do
i i +1
read x
ss+x
until i >= n
write (suma s =,s)
end
S se citeasc n natural. Afiai divizorii unui numr n.
procedure divizori
read n
sw 0
for i = 2 , int ( n/2)
if n /i = int ( n/i)
write ( i, divizor)
sw 1
endif
repeat
if sw = 0 then write (nu exista divizori)
endif
end
Fie vectorul A = ( a[1], a[2], ..., a[n]), unde n este numr natural dat. Numrai
elementele pare.
procedure divizori
array a[n]
read n
sw 0
for i = 1 , n
read ( a[i])
if a[i] mod 2 = 0 { restul impartirii la 2 }
write ( a[i], numar par)
sw 1
endif
repeat
for i = 1 to n
write { a[i] )
repeat
if sw = 0 then write (nu exista numare pare)
endif
end
Ordonarea cresctoare a elementelor unui vector prin interschimbarea elementelor

procedure ordonare
array a[n]
read n
for i = 1 , n
read ( a[i])
repeat
write (vectorul initial:)
for i = 1 to n
write { a[i] )
repeat
for i = 1 to n 1
for j = i + 1 to n
if a[i] > a[j] then
aux a[i]
a[i] a[j]
a[j] aux
endif
repeat
repeat
write (vectorul ordonat crescator:)
for i = 1 to n
write { a[i] )
repeat
end
Fie o matrice ptratic de ordinul n, cu numere ntregi. S se calculeze suma

elementelor de pe diagonala secundar a matricei:
procedure diagonala
array a[n, n]
read n
for i = 1 , n
for j = 1 to n
read ( a[i, j])
repeat
repeat
write (matricea A:)
for i = 1 to n
for j = 1 to n
write ( a[i, j])
repeat
writeln
repeat
s0
for i = 1 to n
for j = 1 to n
if i + j = n + 1 then s s + a[i, j]
endif
repeat
repeat
write (s =, s)
end
Fie n un numr ntreg. S se verifice dac este prim.

procedure prim
read n
sw 0
for i = 2 , int ( n/2)
if n /i = int ( n/i)
sw 1
endif
repeat
if sw = 0 then write (n, este prim)
else write (n, nu este prim)
endif
end
Probleme propuse
1. Fie o matrice A(m, n), cu m linii i n coloane, cu elemente numere ntregi. S
se formeze un ir cu elementele pare, respectiv un ir cu elementele impare.
2. Se d o matrice ptratic A(n, n), cu n linii i n coloane, cu elemente numere
ntregi. S se ordoneze cresctor elementele de pe diagonala principal, prin
permutri de linii i coloane.
3. Fie un vector A( n), cu elemente numere reale. S se inverseze elementele
vectorului ( primul ultimul, al doilea penultimul, etc.). Exemplu: pentru
A = ( 1.5, 5.7, -2.3, 25.2), rezult A = ( 25.2, -2.3, 5.7, 1.5).
4. Pentru dou matrice A(m,n) i B(m, n), s se determine matricea sum C(m,n),
C = A + B.
5. Fie o matrice A ( m, n), cu elemente de tip char. S se ordoneze cresctor
elementele de pe fiecare linie a matricei.
6. Fie un vector A ( n), cu numere ntregi. S se transforme vectorul A n
mulimea B ( elementele unei mulimi sunt unice).
7. Fie un numr n ntreg dat. S se calculeze suma cifrelor sale.
8. Se citete n mod repetat un numr n natural pn la introducerea unui numr
n = 0. S se determine cifra maxim a fiecrui numr n.
De exemplu, n = 48 ( max = 8 )
n = 731 ( max = 7)
n=0
9. S se citeasc n mod repetat un numr pn la introducerea rspunsului N
sau n la ntrebarea Mai citii date? ( d/ n). Care este cel mai mare numr?
10. Se citesc n numere naturale. S se numere cte cifre are irul de numere.
Capitolul 3
Limbajul C++. Alfabet i vocabular
n anul 1970, Brian Kerninghan si Dennis Ritchie au definit i dezvoltat

limbajul C, un limbaj foarte flexibil care permite att programarea la nivel nalt,
ct i la nivel sczut, fiind un limbaj procedural. Principalul scop pentru care a
fost realizat acest limbaj a fost rescrierea sistemului de operare UNIX, pentru a-l
face portabil pe toate platformele existente.
n anul 1980, Bjarne Stroustrup a conceput limbajul "C with Classes", o
variant mbuntit a limbajului C, care permite lucrul cu clase. n 1983, Cwith-classes a fost dezvoltat i redefinit ca limbaj C++, ce ofer faciliti de
programare orientat pe obiecte.
Aplicaiile orientate pe obiecte sunt mai uor i mai rapid de scris, prin
crearea sau dezvoltarea de tipuri de obiecte aparinnd claselor predefinite sau
definite de utilizator.
Exist cteva limbaje dezvoltate ca extinderi ale limbajului C, printre care
se pot enumera Visual C++, C#, Java, Javascript. De exemplu, Visual C++ este o
versiune de compilator C++, produs de Microsoft, care permite crearea de
programe n mediul Windows.
Exemplele din aceast carte au fost realizate folosind mediul de dezvoltare
Borland C++, versiunea 3.1., care pune la dispoziie metoda de programare la
consol, sau programarea sub sistemul de operare DOS. Exist o opiune DOS
shell n meniul File care asigur lucrul exclusiv sub sistemul de operare MS-DOS.
3.1. Alfabetul limbajului C++

Alfabetul limbajului C este alctuit dintr-o mulime de simboluri afiabile
i neafiabile [ Marinoiu C, 2000].
Simbolurile afiabile ( care pot fi reprezentate grafic) sunt:
-
litere mici / mari ale alfabetului englez: a, ..., z, A, ..., Z
cifre zecimale 0, 1, 2, ... , 9
linia de subliniere _ (underscore)
semne de punctuaie i semne speciale (unele simboluri

constituie operatori n cadrul expresiilor)
;:,?.< > =! \&^*+-/%#~
Cteva exemple de simboluri i semnificaiile acestora sunt prezentate n

tabelul 1:
semn
semnificaie
diez
&
ampersand
slash
backslash
tilda
Tabelul 1. simboluri C++
Simbolurile neafiabile ( fr echivalent grafic)

reprezentate prin secvene escape ( de evitare) sau coduri backslash-caracter
sunt coduri ASCII care nu pot fi citite de la tastatur
Exemple de secvene escape sunt prezentate n tabelul 2:
secvene escape
semnificaie
\n
new line
\b
backspace ( recul cu o poziie)
\f
form feed ( salt la pagin nou)
\r
carriage return ( retur de car)
\t
horizontal tab
\v
vertical tab
\ddd
caracter ASCII n notaie octal ( baza 8)
\xdd
caracter ASCII n baza 16

Tabelul 2. secvene ESCAPE
3.2. Vocabularul limbajului C++

Vocabularul limbajului C++ este alctuit din atomi lexicali:
identificatori
cuvinte cheie
constante
semne de punctuaie
simboluri speciale
operatori
Identificatori reprezint secvene de litere, cifre, liniue de subliniere,
primul caracter fiind obligatoriu liter sau caracterul underscore ( _ ), fiind
folosite pentru numele variabilelor, funciilor, etc.
Ex: program_1, a0, S
Exemple de identificatori care nu sunt acceptai: x..a, a&b, &a
Cuvinte cheie cuvinte rezervate n limbajul C++. Ele nu pot fi folosite ca
identificatori. Limbajul standard ANSI C are 32 cuvinte cheie.
Ex: void, if, for, while, do, int, float, char, case, break, continue, else,
include, switch, return, main.
Constante
pot fi numere, caractere, iruri de caractere
- valoarea lor nu se modific n timpul execuiei programului
- n limbajul C, exist 4 tipuri de constante ( ntregi, reale, de tip
caracter, iruri de caractere)
- modul de declarare: este urmtorul:
const tip var = valoare;
Printr-o astfel de declaraie, se permite asignarea unei valori iniiale unei
variabile ce nu poate fi modificat ulterior n program.
Exemple:
i.constante ntregi: 179, -28
ii.constante octale ( n baza 8) ncep cu cifra 0 pentru identificare: 012,
074, 023
iii. constante hexazecimale ncep cu ox: oxA4, oxB7
iv.constante reale n format F (cu punct zecimal: 0.7, .8, 12.59) i n
format exponenial ( 1.4E+3, -2.8E-4 ): const float pi= 3.14;
1.4E+3 = 1.4 * 103
-2.8E-4 = -2.8 * 10-4
v.constante ir de caractere: program ordonare
Observaii:
limbajul C++ extinde definiia constantelor la clase i funcii
membru
o constant poate fi modificat indirect prin intermediul unui
pointer, ca n exemplul urmtor:
const x = 41;
*(int *)&x = 32;
Semne de punctuaie ( separatori)
# (pentru directiva include) este utilizat numai de preprocesor
: ( dou puncte)
[ ] paranteze drepte
( ) paranteze rotunde
{ } acolade pentru blocuri
spaiul, tab
; punct i virgul
Simboluri speciale
comentarii
// comentariu pe o linie
/*
comentariu pe linii
multiple
*/
sfrit de linie, de pagin
Operatori combinaii de semne speciale care arat modalitatea de
prelucrare sau atribuire a valorilor ( tabelul 3):
++
incrementare
||
sau logic
--
decrementare
not pe bit
adunare
sau pe bit
scdere
&
i pe bit
*, /
nmulire, mprire
sau exclusiv pe bit
==
egalitate
modulo
!=
diferit
<, >, mai mic, mai mare

<=, >=
!
&&
not logic
virgul ( operator de
secveniere)
&
adres
<<, >>
i logic
sizeof
deplasare pe bii la
stnga i dreapta
dimensiunea n octei
a unei variabile sau
tip de dat
Tabelul 3.operatori C++
Un operator poate avea mai multe semnificaii, n funcie de context. De

exemplu, operatorul ampersand (&) poate fi interpretat ca:
operator i pe bii (a & b), care este un operator binar
operator adres (&a), care este un operator unar
sinonim de variabil
int x=10, &y=x;
Clase de preceden
Operatorii definesc operaiile admise de operanzi. n limbajul C++, se pot
folosi urmtoarele tipuri de operanzi:
- variabile
- constante
- funcii
- expresii
O clasificare a operatorilor poate s ia n considerare criterii precum:
numrul de operanzi crora li se aplic ( operatori unari ++, - -,
binari +, -, ternari ?: etc.)
prioritatea avut n evaluarea expresiilor ( clase de preceden)
tipul operanzilor ( aritmetici, logici, relaionali, la nivel de bit)
Priorittile operatorilor impun ordinea de evaluare a expresiilor.
O clas de preceden conine operatori cu prioriti egale. Categoria 1 de
preceden are prioritatea cea mai mare, categoria 2 conine operatorii unari, care
au prioritate mai mic dect cei din prima clas, .a.m.d. Operatorul virgul are
cea mai mic prioritate.
Conform precedenei operatorilor n Borland C++, operatorii se mpart n
15 categorii ( tabelul 4):
Categoria
1. operatori cu cea
mai mare prioritate
Operator
()
apel de funcie
[]
indice n tablouri
selecie indirect de
componente ( n C++)
operatorul de rezoluie ( n
C++)
selecie direct de componente
( n C++)
NOT ( negaie logic)
NOT pe bii
plus unar
minus unar
::
.
2. operatori unari
3. operatori
multiplicativi
4. operatori aditivi
Descriere
++
incrementare
--
decrementare
&
adres
indirectare
sizeof
returneaz dimensiunea unui

operand n bytes
new
delete
alocare dinamic n C++

dezalocare dinamic n C++
*
/
nmulire
restul modulo
plus binar
mprire
minus binar
<<
shift stnga
>>
shift dreapta
<
<=
mai mic
mai mic sau egal
>
mai mare
>=
mai mare sau egal
7. operatori pentru
verificarea egalitii
==
egal
!=
diferit
8.
&
AND pe bii
9.
XOR (sau exclusiv) pe bii
10.
OR ( sau) pe bii
11.
&&
AND (i) logic
12.
||
OR (sau) logic
13. operator
condiional
?:
a ? x : y nseamn
14. operatori de
atribuire
atribuire
*=
atribuire cu nmulire
/=
atribuire cu mprire
%=
atribuire cu restul modulo
+=
atribuire cu adunare
-=
atribuire cu scdere
&=
atribuire cu i pe bii
5. operatori shift
6. operatori
relaionali
"if a then x, else y"
15. operatorul
virgul
^=
atribuire cu sau exclusiv pe bii
|=
atribuire cu sau pe bii
<<=
atribuire cu shft stnga
>>=
atribuire cu shft dreapta
operator de secveniere
Tabelul 4.operatori C++
Toi operatorii de mai sus pot fi suprancrcai, cu excepia urmtorilor:

. operatorul de selecie direct a componentelor n C++
.* operator C++
:: operatorul de rezoluie pentru accesul n C++
?: operatorul condiional
Reguli de asociere a operatorilor:
de la dreapta la stnga pentru operatorii unari i cel condiional ?:
de la stnga la dreapta pentru restul operatorilor.
Operatorii de atribuire
Sintaxa folosit pentru operaia de atribuire este urmtoarea:
expresie_unar operator_atribuire expresie_de_atribuire
unde expresiile pot avea tipuri de date diferite. n limbajul C++ se fac conversii
implicite de tip, existnd relaia:
sizeof ( int) <= sizeof ( float) <= sizeof ( double)
De exemplu, n expresia E1 = E2, E1 trebuie s fie o valoare-stng
modificabil. Valoarea lui E2 ( dup conversia de tip), este memorat n obiectul
E1. Pentru ambele tipuri de atribuire ( simpl i compus), operanzii E1 i E2
trebuie s respecte una dintre urmtoarele reguli:
1. E1 i E2 sunt de tip aritmetic
2. E1 i E2 sunt de tip structur sau uniune
3. E1 i E2 sunt de tip pointer
4. unul dintre E1 sau E2 este de tip pointer la un obiect, iar cellalt este
pointer de tip void
5. E1 este un pointer i E2 este un pointer null constant.
O valoare-stng este un identificator sau o expresie care desemneaz un
obiect care poate fi accesat sau modificat n memorie. Exemple de valori-stngi:
E1 = 1
E1 = E1 + E2
sau *p ( un pointer), ns expresia E1 + E2 nu este o valoare-stng
(exemplu: E1 + E2 =7).
Exemplu de atribuire cu conversie de tip:
int a, b;
float m, n;
a = m; // a [ m ]
// sau variabilei a i se atribuie o valoare aleatoare, dac se
//depesc posibilitile de memorare
n = b; // b va fi reprezentat n virgul mobil
Atribuirea multipl poate fi evideniat astfel:
a = b = c = d = 10;
Operatorul de atribuire compus are forma general operator=, unde
operator poate fi unul dintre operatorii de mai jos:
*
- << >>
&
^ |
Expresia E1 op= E2 are acelai efect ca i expresia E1 = E1 op E2 unde

valoarea-stng E1 este evaluat o singur dat. De exemplu,
E1 += E2 nseamn E1 = E1 + E2.
Operatorii de incrementare / decrementare
-
operatorul de incrementare ( prefix sau postfix)

sintaxa :
++ operand ( prefix)
sau
operand ++ ( postfix)
unde operandul trebuie s fie de tip scalar ( aritmetic sau pointer) i s fie o
valoare-stng modificabil
Pentru incrementare prefixat, valoarea operandului crete cu 1, iar
valoarea expresiei este valoarea obinut dup incrementare.
Pentru incrementare postfix, valoarea expresiei este valoarea dinainte de
aplicarea incrementrii. Dup incrementarea postfix, valoarea operandului crete
cu 1.
Exemplu :
int x = 10, y, z ;
y = x++ ; // y = x =10 i x =x + 1 =11
z = ++x ; // x =x + 1 = 11 + 1 = 12 i z = x = 12
-
operatorul de decrementare ( prefix sau postfix)
sintaxa :
- - operand ( prefix)
sau
operand - - ( postfix)
unde operandul trebuie s fie de tip scalar ( aritmetic sau pointer) i s fie o
valoare-stng modificabil.
Pentru decrementare prefixat, valoarea operandului scade cu 1, iar
valoarea expresiei este valoarea obinut dup decrementare.
Pentru decrementare postfix, valoarea expresiei este valoarea dinainte de
aplicarea decrementrii. Dup decrementarea postfix, valoarea operandului
scade cu 1.
Exemplu :
int x = 10, y, z ;
y = x - - ; // y = x =10 i x = x - 1 = 9
z = - -x ; // x =x - 1 = 9 - 1 = 8 i z = x = 8
Operatorul de secveniere ( virgula)
permite construirea de expresii, ca liste de alte expresii
sintaxa: expresie_1, expresie_2, . . . , expresie_n
expresiile se evalueaz de la stnga la dreapta
tipul i valoarea ntregii expresii sunt date de ultima expresie din list
pentru evitarea ambiguitii n utilizarea operatorului virgul ntr-o list cu
argumente ale unei funcii sau n liste de iniializri, se recomand folosirea
parantezelor.
Exemplu :
int x = 10, y, z ;
z = suma ( x, ( y = 3, y*2 + 1), z) ; // funcia suma este apelat cu 3
argumente : 10, 7, z.
Operatorii aritmetici
-
operatorii aditivi : + i Sintaxa operatorilor unari + i se poate exprima astfel:

+ operand respectiv operand
unde operandul trebuie s fie de tip arithmetic.

Exemplu :
int x = 10, y, z ;
z = +x ; // z =10
y = -x; //y = -10
Sintaxa operatorilor binari + i respect regula expresiilor combinate, cu
unul sau mai muli operatori:
operand_1 + operand_2 respectiv operand_1 - operand_2

unde operanzii trebuie s fie de tip aritmetic sau unul dintre operanzi poate s
fie pointer ctre un anumit tip de obiecte.
Exemplu :
int x = 10, y = 100, z ;
z = x + y ; // z = 110
z = x - y; //z = -90
-
operatorii multiplicativi: *, /, %
Sintaxa operatorilor multiplicativi:
operand1 * operand2 ( nmulirea a dou numere)
operand1 / operand2 ( mprirea a dou numere, al doilea fiind nenul)
operand1 % operand2 ( restul mpririi a dou numere, al doilea fiind nenul)
unde operanzii trebuie s fie de tip aritmetic, iar conversiile de tip sunt cele
uzuale. Operatorul / aplicat unor operanzi ntregi furnizeaz un rezultat ntreg
i aplicat unor operanzi reali produce un rezultat real.
Exemplu :
int x = 10, y = 7, z ;
z = x * y ; // z = 70
z = x / y ; //z =1
z = x % y ; // z = 3
Operatorii relaionali <, >, <=, >=, ==, !=
Sintaxa operatorilor relaionali :
operand1 < operand2 respectiv operand1 > operand2
operand1 <= operand2 respectiv operand1 >= operand2
n expresiile relaionale operanzii trebuie s ndeplineasc una dintre
urmtoarele condiii:
- ambii operanzi sunt aritmetici, caz n care se efectueaz conversiile uzuale, iar
rezultatul expresiei relaioanale este de tip int ( 1 adevrat i 0 fals)
- operanzii pot fi pointeri ctre obiecte de tip compatibil, caz n care rezultatul
depinde de adresele relative ale celor dou obiecte la care se refer pointerii
Operatorii de egalitate ==, != testeaz egalitatea sau inegalitatea ntre
valori aritmetice sau pointeri, utiliznd reguli similare cu ale celorlali operatori
relaionali. Operatorii de egalitate sunt ntr-o categorie de preceden inferioar
(prioritate mai mic) dect ceilali operatori relaionali.
Sintaxa operatorilor relaionali :
operand1 == operand2 ( egalitate) respectiv operand1 != operand2 ( diferit)
Dac ambii operanzi sunt aritmetici, rezultatul expresiei relaionale este 1

( true) sau 0 ( false).
Cnd operanzii sunt pointeri, atunci expresia operand1 == operand2 are
ca rezultat 1 ( true), dac ambii pointeri sunt NULL sau dac pointerii se refer la
acelai obiect.
Operatorii logici
- negaie logic ( ! operand) - expresia ( ! operand) este echivalent cu expresia
(operand ==0)
- i logic (operand1 && operand2)
- sau logic (operand1 || operand2)
Operanzii trebuie s fie de tip scalar. Sunt realizate conversiile aritmetice
uzuale pentru operanzi.
Operatorii && i || sunt evaluai de la stnga la dreapta astfel:
operand1 este evaluat primul: dac operand1 este 0, atunci operand1 &&
operand2 este implicit 0 i operand2 nu se mai evalueaz
operand1 este evaluat primul: dac operand1 este 1, atunci operand1 ||
operand2 este implicit 1 i operand2 nu se mai evalueaz.
Exemplu : fie dou variabile x i y de tip ntreg, atunci expresiile logice
construite cu ajutorul operatorilor !, &&, || sunt evaluate n tabelul 5 :
x
!x
x && y
x || y
Tabelul 5.operatori logici
Operatorii logici au prioritate mai mic dect operatorii relaionali :

x <= y && y >z este echivalent cu
( x <= y) && ( y >z )
Operatorii pe bii
operatorii pe bii sunt:
- negaie pe bii ( ~ operand)
- i pe bii (operand1 & operand2)
- sau pe bii (operand1 | operand2)
- sau exclusiv pe bii (operand1 ^ operand2)
se aplic operanzilor de tip int sau char, nu se aplic valorilor de tip float,
double, long double
Exemplu : fie dou variabile x i y de tip ntreg, atunci expresiile logice

construite cu ajutorul operatorilor !, &&, || sunt evaluate n tabelul 6 :
x
~x
x&y
x|y
x^y
Tabelul 6.operatori pe bii
Exemplu : Fie x = 6 i y =27. Operaiile pe bii efectuate cu x i y sunt

prezentate n tabelul 7:
x = 62 = 0000 0110 = 0*2o+1*21 + 1*22 = 2 + 4 = 6
y =272 = 0001 1011= 1*20+1*21 + 0*22 + 1* 23+ 1*24 = 1 + 2 + 8 + 16 = 27
x=6
y = 27
~x
x&y
x|y
x^y
0000 0110
0001 1011
1111 1001
0000 0010
0001 1111
0001 1101
Tabelul 7.operaii pe bii
Operatorii shift
operatorul shift stnga (variabil << numr) deplaseaz biii variabilei cu un
numr de poziii la stnga; la deplasarea spre stnga, biii liberi din dreapta
se completeaz cu 0 ( zero)
operatorul shift dreapta (variabil >> numr) deplaseaz biii variabilei cu
un numr de poziii la dreapta; la deplasarea spre dreapta, biii liberi din
stnga se completeaz cu:
- 0 ( zero), dac numrul este fr semn
- 1 ( unu), dac numrul este negativ
operaiile de deplasare pe bii la stnga i dreapta sunt echivalente cu
nmulirea, respectiv mprirea cu 2 la o putere egal cu numrul de bii
deplasai:
x << n este echivalent cu x * 2n
x >> n este echivalent cu x / 2n
exemplu: pentru x = 5, n =2
x << n = 5 << 2 = 0000 0101 << 2 = 0001 0100
0001 0100 = 0*20+ 0*21 + 1*22 + 0* 23+ 1*24 = 0 + 0 + 4 + 0 + 16 = 20
x * 2n = 5 * 22 = 20
Deci 5 << 2 = 0001 0100 = 20 = 5 * 22
un exemplu de deplasare shift pe bii pentru un numr negativ:

pentru x = -6, n = 3
Se complementeaz cu 1:
-6(2) = ~6(2) + 1 = ~0000 0110 + 1 = 1111 1001 + 1 = 1111 1010
-6(2) >> 3 = 1111 1010 >> 3 ( se pierd ultimii trei bii) = 1111 1111
Capitolul 14
Programare orientat pe obiecte

n limbajul C++
Limbajul de programare C++ ofer faciliti de programare orientat pe

obiecte, n care obiectele aparin unor tipuri abstracte, denumite clase. n limbajul
C++, clasele constituie tipuri de date structurate ce permit organizarea datelor
eterogene, complexe i reprezint colecii de variabile i funcii, grupate sub un
singur nume, pentru manipularea lor unitar.
Programarea orientat pe obiecte folosete concepte fundamentale
precum:
ncapsulare un obiect grupeaz att date, ct i funciile necesare prelucrrii
acestora; o clas este un tip abstract de date care realizeaz ncapsularea datelor
i funciilor;
motenire datele sau funciile pot fi transmise de la o clas de baz la clasele
derivate din aceasta;
derivare definirea unei clase noi pe baza unei clase existente;
polimorfism redefinirea funciilor i a operatorilor.
n acest capitol se vor prezenta noiunile de clas, constructor i
destructor, vor fi descrise conceptele fundamentale utilizate de programarea
orientat pe obiecte, precum motenirea i suprancrcarea. Se va exemplifica
modul de realizare a polimorfismului i se vor evidenia proprietile funciilor
virtuale i claselor abstracte.
14.1. Clase
Un obiect este o variabil, reprezentnd un ansamblu alctuit din:
- date membre;
- funcii membre, numite metode. Obiectele sunt variabile declarate de tip
class, un tip de date abstract, asemntor tipurilor de date structurate struct i
union.
Sintaxa utilizat pentru declararea tipurilor class, struct i union poate fi

exprimat astfel:
<cuvnt_cheie> [ <identificator>] [ : <lista_clase_baz>]
{
tip1 lista_membri_1;
tip2 lista_membri_2;
..................
} [ list_variabile];
unde <cuvnt_cheie> este unul dintre cuvintele cheie class, struct sau union;
<identificator> reprezint numele tipului de date definit ( class, struct sau
union);
<lista_clase_baz> - lista claselor de baz din care deriv aceast clas, fiind
opional;
lista_membri_1, lista_membri_2, . . . sunt liste de date i funcii membre;
tip1, tip2, . . . desemneaz tipurile de date ale elementelor membre.
Un exemplu de clas definit pentru reprezentarea numerelor raionale
poate fi urmtorul:
class rational
{
int p, q;
};
rational a, *b = &a;
Specificatorii de acces public, private, protected se pot declara, folosind
sintaxa [ Help, Borland C++ - 1990]:
public : <declaraii>
private : <declaraii>
protected : <declaraii>
-
atributul public permite accesarea membrilor din orice funcie; n limbajul

C++, elementele membre ale unei structuri / uniuni au atributul public (n
mod implicit);
atributul private un membru cu atributul private este accesibil n
funciile membre i friends ale clasei n care este declarat; membrii unei
clase au n mod implicit atributul private;
atributul protected ( accesat n interiorul ierarhiei claselor).
p
, unde p, q
q
Z ( clasa conine date private i metode publice pentru iniializarea i afiarea
numrtorului i numitorului unei fracii).
Exemplu: S se defineasc o clas pentru numere raionale
#include<stdio.h>
#include<conio.h>
class rational
{
int p, q;
public:
void fractie( int x, int y)
{
p = x;
q = y;
}
int numarator()
{
return p;
}
int numitor()
{
return q;
}
}a;
void main(void)
{
clrscr();
a.fractie(7,8);
printf("\n fractia: %d / %d ", a.numarator(), a.numitor());
getche();
}
Operatorul de rezoluie :: permite accesul la variabile globale ale
programului. Un exemplu de afiare difereniat a unei variabile declarate
global, respectiv local este programul urmtor:
#include<stdio.h>
#include<conio.h>
int i = 10;
void main()
{
int i = 15;
clrscr();
printf("\n variabila globala ( din exteriorul functiei main) i = %i",::i);
printf("\n variabila locala (din main) i = %i",i);
getch();
}
Operatorul de rezoluie se poate folosi pentru funcii declarate n
exteriorul unei clase, al cror prototip este definit n interiorul clasei. Un exemplu
este problema definirii unei clase pentru numere raionale, rezolvat astfel:
#include<stdio.h>
#include<conio.h>
class rational
{
int p, q;
public:
void fractie( int, int);
int numarator();
int numitor();
}a;
void main(void)
{
clrscr();
a.fractie(20,42);
printf("\n fractia: %d / %d ", a.numarator(), a.numitor());
getche();
}
void rational::fractie( int x, int y)
{ p = x;
q = y;
}
int rational::numarator()
{ return p;
}
int rational::numitor()
{ return q;
}
Funcii inline sunt funciile declarate i definite n interiorul unei clase.
La fiecare apel al funciei, aceasta este nlocuit cu codul ei, mrind viteza de
execuie a programului.
Constructori i destructori
Constructorul generat implicit este o metod special ataat n mod
implicit unei clase, pentru declararea obiectelor. Astfel, se aloc spaiul de
memorie necesar obiectelor declarate. O clas poate avea mai muli constructori,
cu restricia ca metodele constructor s difere prin numrul i tipul parametrilor
formali. Exist un tip special de constructor numit constructor de copiere care
atribuie datele unui obiect altui obiect.
Destructorul este o metod special ataat unei clase, ce realizeaz
operatia invers alocrii obiectelor, adic eliberarea memoriei. Numele
destructorului este acelai cu numele clasei, dar este precedat de caracterul ~. O
clas are un singur destructor. Destructorul nu are parametri formali, el fiind
apelat implicit atunci cnd existena unui obiect nceteaz.
Funciile prieten sunt funciile care nu aparin unei clase, dar pot accesa
datele private ale acesteia. Pentru a ataa unei clase o funcie prieten, se
introduce n interiorul definiiei clasei prototipul funciei prieten, precedat de
cuvntul cheie friend, iar definiia funciei se efectueaz n exteriorul clasei.
14.2. Motenire
Motenirea este o tehnic de baz n programarea orientat pe obiecte,
prin care se pot reutiliza i extinde clasele existente. Mecanismul motenirii este
urmtorul:
avnd o clas oarecare B, se poate defini o alt clas D care s preia toate
caracteristicile clasei B, la care s-i poat aduga alte proprieti proprii;
clasa B se numete clas de baz, iar clasa D se numete clas derivat;
mecanismul de derivare poate fi aplicat numai claselor definite prin
specificatorii class i struct;
se poate forma o ierarhie de clase.
Pentru derivarea claselor, se folosete sintaxa:
class | struct clasa_derivat : { specificator_acces_1} clas_baz_1
{, specificator_acces_2} clas_baz_2,
.................................
{
.........
}
Controlul accesului la membrii:
- specificatorul de acces poate lipsi; dac lipsete, se consider private
pentru class i public pentru struct.
Motenirea de tip privat este modul de motenire implicit pentru class.
Membrii protected i public prin motenire private devin private.
Motenirea de tip protected:
mostenire protected
- membrii private private
mostenire protected
- membrii protected i public protected
Motenirea de tip public:

mostenire public
- membrii private
private
mostenire public
- membrii protected
protected
mostenire public
public.
- membrii public
Motenirea multipl presupune crearea unor clase derivate din mai multe
clase de baz. n aceste cazuri, constructorii se apeleaz n ordinea in care sunt
scrise clasele n liste de motenire a clasei derivate.
Exemplu: S se defineasc o clas de baz pentru grafuri neorientate, care
s conin matricea de existen, matricea de adiacen, metode pentru citirea i
afiarea unei matrice i o metod pentru algoritmul Roy Warshall. S se
construiasc o clas derivat din prima, care s conin metode pentru:
- verificarea conexittii unui graf;
- tiprirea vrfurilor izolate;
- tiprirea vrfurilor de grad maxim.
Algoritmul Roy Warshall transform matricea de adiacen a muchiilor
unui graf neorientat in matrice de existen a lanurilor. Pentru determinarea
componentelor conexe ale unui graf neorientat, se folosete matricea de existent
a lanurilor.
#include<stdio.h>
#include<conio.h>
int i, j, n, m, x, y, k, sw;
class graf
{
public:
int a[10][10]; //matrice de adiacenta a muchiilor
int e[10][10]; // matrice de existenta a lanturilor
void citire();
void tiparire();
void Roy_Warshall();
};
class graf1 : public graf
{
public:
int conex();
int vf_izolate();
void vf_gr_max();
}a;
void graf::citire()
{
for(i = 1; i <= n; i++)
for(j = 1; j <= n; j++)
a[i][j] = e[i][j] = 0;
printf("\n Dati muchiile grafului: ");
for(i = 1; i <= m; i++)
{
printf("\n muchia %d \n",i);
scanf("%d %d",&x, &y);
e[x][y] = e[y][x] = 1;
a[x][y] = a[y][x] = 1;
}
}
void graf::tiparire()
{
printf("\n Matricea de adiacenta\n");
for(i = 1; i <= n; i++)
{
for(j = 1; j <= n; j++)
printf(" %d ",a[i][j]);
printf("\n");
}
printf("\n Matricea de existenta a lanturilor\n");
for(i = 1; i <= n; i++)
{
for(j = 1; j <= n; j++)
printf(" %d ", e[i][j]);
printf("\n");
}
}
void graf::Roy_Warshall()
{
for(i = 1; i <= n; i++)
for(j = 1; j <= n; j++)
if(e[i][j] == 1)
for(k = 1; k <= n; k++)
if(e[i][k] < e[j][k])
e[i][k] = e[k][i] = e[j][k];
// matrice simetrica fata de diagonala principala
}
int graf1::conex()
{
sw = 1;
for(i =1; i <=n; i++)
for(j=1; j <= n; j++)
if (e[i][j] == 0)
sw = 0;
return sw;
}
int graf1::vf_izolate()
{
for(i = 1; i<=n; i++)
{
sw = 1;
for(j = 1; j <= n; j++)
if (e[i][j] == 1)
sw = 0;
if (sw == 1)
{ printf("\n %d varf izolat", i);
return sw;
}
}
return 0;
}
void graf1::vf_gr_max()
{
int max, poz;
for(i = 1; i<=n; i++)
{
a[i][n+1] = 0;
for(j = 1; j <= n; j++)
if (a[i][j]) a[i][n+1]++;
}
max = a[1][n+1]; poz = 1;
for ( i = 2; i <= n; i++)
if(a[i][n+1] > max)
{ poz = i;
max = a[i][n+1];
}
printf("\n varful de grad maxim este %d si are gradul %d",poz, max);
}
void main(void)
{
clrscr();
printf("\n nr de varfuri n = "); scanf("%d", &n);

printf("\n numarul de muchii: "); scanf("%d",&m);
a.citire();
a.Roy_Warshall();
a.tiparire();
if (a.conex() == 0) printf ("\n graful nu este conex");
else printf("\n graf conex");
if (a.vf_izolate() == 0)
printf("\n nu exista varfuri izolate");
a.vf_gr_max();
getche();
}
Observaie: Pentru execuia programelor, se recomand efectuarea mai
multor teste. De exemplu:
Test 1:
Pentru graful din figura 8.1., se
pot introduce datele:
- numrul de vrfuri n = 5
- numrul de muchii m = 3
- muchia 1: 1 2
- muchia 2: 1 4
- muchia 3: 3 5
Fig. 8.1. Test 1
Rezultate: graful nu este conex

nu exista varfuri izolate
varful de grad maxim este 1 si are gradul 2
Test 2:
- muchia 1: 1 2
- muchia 2: 1 3
- muchia 3: 2 3
Fig. 8.2. Test 2
Rezultate: graf conex

Test 3:
- muchia 1: 1 2
- muchia 2: 1 3
- muchia 3: 1 4
- muchia 4: 2 4
Fig. 8.3. Test 3
Rezultate: graful nu este conex

5 varf izolat
Test 4:
- muchia 1: 1 2
- muchia 2: 1 4
- muchia 3: 2 5
- muchia 4: 3 5
- muchia 5: 3 6
- muchia 6: 5 6
Fig. 8.4. Test 4
Rezultate: graf conex

14.3. Suprancrcare
Suprancrcarea permite atribuirea mai multor semnificaii anumitor
operatori sau funcii. De exemplu, operatorii binari precum +, -, * sunt folosii,
de obicei, n construcia expresiilor aritmetice, ntre operanzi ntregi, reali sau de
diverse tipuri aritmetice combinate. ns, prin suprancrcarea acestor operatori,
se pot construi expresii cu operatori i operanzi definii de tip class.
Suprancrcarea operatorilor se poate realiza utiliznd urmtoarea
sintax:
operator <identificator>( <parametrii> )
{
<instruciuni>;
}
unde operator <identificator> definete o nou aciune asociat unui operator

prin suprancrcare.
Suprancrcarea operatorilor +, *, Exemplul 1): Suprancrcarea operatorilor + i * poate fi evideniat n
programul de calculare a sumei i produsului a dou matrice. Se vor folosi dou
clase:
o clas care memoreaz informaii despre elementele matricelor i metode
pentru operaiile de citire i scriere;
a doua clas derivat din prima clas, care s defineasc suprancrcarea
operatorilor + i *.
#include<stdio.h>
#include<conio.h>
class matrice1
{
public:
int inf[12][12];
void citire();
void tiparire();
};
class matrice2 : public matrice1
{
public:
matrice2 operator+(matrice2);
matrice2 operator*(matrice2);
}a, b, c;
int i, j, n, s, k;
void matrice1::citire()
{
for(i = 0; i < n; i++)
for(j = 0; j < n; j++)
{
printf("\n inf[%d][%d]= ",i,j);
scanf("%d", &inf[i][j]);
}
}
void matrice1::tiparire()
{
for(i = 0; i < n; i++)
{
for(j = 0; j < n; j++)
printf(" %d ",inf[i][j]);
printf("\n ");
}
}
matrice2 matrice2::operator+(matrice2 a)
{
for(i = 0; i < n; i++)
for(j = 0; j < n; j++)
c.inf[i][j] = inf[i][j] + a.inf[i][j];
return(c);
}
matrice2 matrice2::operator*( matrice2 a)
{
for(i = 0; i < n; i++)
for(j = 0; j < n; j++)
{
s = 0;
for(k = 0; k < n; k++)
s += inf[i][k] * a.inf[k][j];
c.inf[i][j] = s;
}
return(c);
}
void main(void)
{
clrscr();
printf("\n nr de linii/coloane n = "); scanf("%d", &n);
printf("\n dati matricea A:\n "); a.citire();
printf("\n dati matricea B:\n "); b.citire();
printf("\n matricea A este:\n "); a.tiparire();
printf("\n matricea B este:\n "); b.tiparire();
printf("\n matricea suma A + B:\n ");
c = a + b;
c.tiparire();
printf("\n matricea produs A * B:\n ");
c = a * b;
c.tiparire();
getche();
}
Observaie: La execuia programului, se pot folosi urmtoarele teste:
1 2
5 2
, B =
Test 1: n = 2, A =
3 4
7 1
Rezultatele compilrii programului:

6 4
, matricea produs A * B =
matricea suma A + B =
10
5
19 4
43
10
1 0 2
1 2 1
Test 2: n = 3, A = 3 4 1 , B = 7 0 3
5 1 2
4 1 5
Rezultatele compilrii programului:

2 2 3
matricea suma A + B = 10 4 4 ,
9 2 7
9 4 11
matricea produs A * B = 35 7 20 .
20 12 18
Exemplul 2): S se realizeze suprancrcarea operatorilor +, -, *, = la

mulimi, pentru operaiile de baz cu mulimi: reuniunea ( +), diferenta ( -),
intersecia ( *) i atribuirea ( =).
#include<iostream.h>
#include<conio.h>
char ch;
class multime
{
public:
int inf[10], n;
void citire();
void afisare();
};
class multime1 : public virtual multime
{
public:
multime1 operator*(multime1);
multime1 operator+(multime1);
multime1 operator-(multime1);
void operator=(multime1);
}a, b, c;
int i, j, n, x, sw;
void multime::afisare()
{
if(!n)
cout<<"multime vida";
for(i=1; i<=n;i++)
cout<<inf[i]<<" ";
}
void multime::citire()
{
if (n <= 0 )
return;
cout<<endl<<"elementele multimii: ";
cout<<"\n inf[1]= ";
cin>>inf[1];
i = 1;
while( i < n)
{
cout<<"\n inf["<<i+1<<"]= ";
cin>>x;
sw = 1;
for(j = 1; j <= i; j++)
if(inf[j] == x)
sw = 0;
if(sw)
{
i++;
inf[i] = x;
}
}
}
multime1 multime1::operator*(multime1 b)
{
sw = 0;
for(i = 1; i <= n;i++)
for(j = 1; j <= b.n;j++)
if(inf[i] == b.inf[j])
{
sw++;
c.inf[sw] = inf[i];
}
if(sw == 0)
cout<<"\n multime vida";
c.n = sw;
return(c);
}
void multime1::operator=(multime1 b)
{
for(i = 1; i <= b.n;i++)
inf[i] = b.inf[i];
n = b.n;
}
multime1 multime1::operator-(multime1 a)
{
x = 0;
for(i = 1; i <= n;i++)
{
sw = 0;
for(j = 1; j <= a.n;j++)
if(inf[i] == a.inf[j])
sw = 1;
if(!sw)
c.inf[++x] = inf[i];
}
c.n = x;
return(c);
}
multime1 multime1::operator+(multime1 a)
{
x = 0;
for(i = 1; i <= n;i++)
{
sw = 0;
for(j = 1; j <= a.n;j++)
if(inf[i] == a.inf[j])
sw = 1;
if(sw == 0) c.inf[++x] = inf[i];
}
for(i = 1; i <= a.n;i++)
c.inf[++x] = a.inf[i];
c.n = x;
return(c);
}
void main(void)
{
clrscr();
cout<<endl<<"dati numarul de elemente ale multimii A: ";
cin>>a.n;
a.citire();
cout<<endl<<"dati numarul de elemente ale multimii B: ";
cin>>b.n;
b.citire();
cout<<endl<<"\n multimea A: ";
a.afisare();
cout<<endl<<"\n multimea B: ";
b.afisare();
c = a;
cout<<endl<<"\n atribuire: C = A = ";
c.afisare();
c = a - b;
cout<<endl<<"\n diferenta: C = A - B = ";
c.afisare();
c = a * b;
cout<<endl<<"\n intersectia: A * B = ";
c.afisare();
c = a + b;
cout<<endl<<"\n reuniune: A + B = ";
c.afisare();
getche();
}
Suprancrcarea operatorilor [ ], ( ) i =
a) operatorul [ ] asigur accesul la datele unui obiect
De exemplu, prin suprancrcarea operatorului [ ], un element a[i] al unui
vector se poate scrie n mod echivalent astfel:
a[i] a.operator[ ] (i)
unde a este un obiect aparinnd unei clase, n care funcia operator[ ] este o
metod:
class vector
{
int nr[100];
public:
int& operator[](int);
} a;
n programul urmtor, se propune calcularea sumei elementelor unui
vector, folosind suprancrcarea operatorului [ ].
#include<stdio.h>
#include<conio.h>
int i, n, s, p;
class vector
{
int nr[100];
public:
void citire();
void tiparire();
};
int& vector::operator[](int i)
{ return nr[i];
}
void vector::citire()
{
for(i = 0; i < n; i++)
{
printf("\n nr[%d] = ",i);
scanf("%d",&nr[i]);
}
}
void vector::tiparire()
{
printf("\n Vectorul\n");
for(i = 0; i < n; i++)
printf("%d ",nr[i]);
}
void main(void)
{
vector a;
clrscr();
printf("\n ne elemente ale vectorului n = ");
scanf("%d", &n);
printf("\n dati vectorul: ");
a.citire();
a.tiparire();
s = 0;
for(i = 0; i < n; i++)
s+= a.operator[](i);
printf("\n suma elementelor = %d", s);
p = 1;
for(i = 0; i < n; i++)
p *= a.operator[](i);
printf("\n produsul elementelor (metoda 1) = %d", p);
p = 1;
for(i = 0; i < n; i++)
p *= a[i];
printf("\n produsul elementelor (metoda 2) = %d", p);
getche();
}
Observaii:
n program, s-au utilizat notaiile echivalente:
a.operator[ ] (i) a[i]
metoda operator[ ] declarat astfel:

returneaz valoarea membrului privat nr. Pentru tipul datelor returnate, se

folosete int& (lvalue required).
b) operatorul ( ) este folosit pentru apelul funciilor
De exemplu, prin suprancrcarea operatorului ( ), un element a[i][j] al
unei matrice se poate scrie n mod echivalent astfel:
a(i, j) a.operator( ) (i, j)
unde a este un obiect din clasa matrice, iar funcia operator( ) este o metod:
class matrice
{
int nr[20][20];
public:
int& operator( )(int, int);
} a;
n programul urmtor, se propune determinarea transpusei unei matrice,
folosind suprancrcarea operatorului ( ).
#include<stdio.h>
#include<conio.h>
int i, j, n;
class matrice
{
public:
int inf[10][10];
int& operator()(int, int);
void citire();
}a;
int& matrice::operator()(int i, int j)
{
return inf[i][j];
}
void matrice::citire()
{
for(i = 1; i <= n; i++)
for(j = 1; j <= n; j++)
{
printf("\n inf[%d][%d]= ",i,j);
scanf("%d",&inf[i][j]);
}
}
void main(void)
{
clrscr();
printf("\n nr de varfuri n = "); scanf("%d", &n);
a.citire();
printf("\n Matricea\n");
for(i = 1; i <= n; i++)
{
for(j = 1; j <= n; j++)
printf(" %d ",a.operator()(i,j));
printf("\n");
}
printf("\n Matricea transpusa\n");
for(i = 1; i <= n; i++)
{
for(j = 1; j <= n; j++)
printf(" %d ",a(j,i));
printf("\n");
}
getche();
}
Observaie: n program, se pot utiliza notaiile echivalente:
a.operator( ) (i, j) a(i, j) a.inf[i][j]
c) operatorul = poate fi folosit pentru verificarea egalitii a dou obiecte
De exemplu, suprancrcarea operatorului = permite ca verificarea
egalittii elementelor a dou matrice a i b s se scrie n mod echivalent astfel:
a = b a.operator= (b)
unde a i b sunt obiecte din clasa matrice, iar funcia operator= este o metod:
class matrice
{
int nr[10][10];
public:
int operator=(matrice);
} a, b;
n programul urmtor, se propune verificarea egalitii a dou matrice,
folosind suprancrcarea operatorului =.
#include<stdio.h>
#include<conio.h>
int i, j, n;
class vector
{
public:
int inf[10], n;
int operator=(vector);
void citire();
void afisare();
}a, b;
int vector::operator=(vector b)
{
int sw;
sw = 1;
if(b.n != n)
sw = 0;
for(i = 1; i <= n; i++)
for(j = 1; j <= n; j++)
if (inf[i] != b.inf[i])
sw = 0;
return sw;
}
{
for(i = 1; i <= n; i++)
{
printf("\n inf[%d]= ",i);
scanf("%d",&inf[i]);
}
}
void vector::afisare()
{
for(i = 1; i <= n; i++)
printf(" %d ",inf[i]);
}
void main(void)
{
clrscr();
printf("\n nr de elemente ale vectorului A: n = ");
scanf("%d", &a.n);
a.citire();
printf("\n nr de elemente ale vectorului B: n = ");
scanf("%d", &b.n);
b.citire();
printf("\n Vectorul A\n");
a.afisare();
printf("\n Vectorul B\n");
b.afisare();
if( a = b) printf("\n vectorii au elementele egale");
if(!a.operator=(b)) printf("\n nu exista egalitate");
getche();
}
Observaie: n program, s-au utilizat notaiile echivalente:
a.operator= (b) a = b
Suprancrcarea funciilor
Funciile pot fi suprancrcate, adic pot exista dou sau mai multe funcii
cu acelai nume n clase derivate. Exist o restricie, n sensul c funciile trebuie
s difere prin numrul i tipul parametrilor formali.
Suprancrcarea funciilor n clase derivate: se poate nzestra o clas
derivat cu o metod cu acelai nume i aceeai list de parametri formali, ca una
existent n clasa de baz. Exemplu: o funcie de afiare definit att n clasa de
baz, ct i n clasa derivat.
#include<stdio.h>
#include<conio.h>
class A
{
public:
int i;
void afisare()
{
printf("\n clasa de baza A: i = %d",i);
}
};
class B : public A
{
public:
int i;
void afisare()
{
printf("\n clasa derivata B: i = %d",i);
}
}y;
void main(void)
{
clrscr();
y.A::i = 99;
y.A::afisare();
y.i = 10;
y.afisare();
getche();
}
Suprancrcarea funciilor standard presupune redefinirea funciilor
standard n interiorul unei clase.
Exemplu: Calculai radicalul unui numr n n mod repetat pn la
introducerea caracterului n sau N, ca rspuns la ntrebarea mai dai un
numr? (d/n). S se foloseasc redefinirea funciei standard sqrt.
#include<math.h>
#include<conio.h>
class radical
{
public:
float sqrt(int);
}x;
float radical::sqrt(int a)
{
return(::sqrt(a));
}
int n;
char c;
void main(void)
{
clrscr();
do
{
do
{
cout<<endl<<"dati numarul n:";
cin>>n;
}
while(n<=0);
cout<<endl<<x.sqrt(n);
cout<<endl<<"mai dati un numar? (d/n)";
cin>>c;
}
while(c!='n' && c!='N');
}
14.4. Polimorfism
Polimorfismul se realizeaz prin redefinirea funciilor i a operatorilor.
Un aspect al polimorfismului este capacitatea utilizrii unei funcii n mai multe
obiecte diferite, ceea ce nseamn c o funcie poate avea mai multe definiii.
Compilatorul determin funcia care trebuie apelat n funcie de lista de
parametri [ M. Williams, 1997]. De exemplu, n programul urmtor sunt definite
dou versiuni diferite ale funciei de afiare:
#include<conio.h>
#include<stdio.h>
void afisare (int);
void afisare(char[]);
void main(void)
{
int nr;
char sir[20];
clrscr();
cout<<"\n dati un numar: ";
cin>>nr;
cout<<"\n dati un sir de caractere ";
gets(sir);
afisare(nr);
afisare(sir);
getche();
}
void afisare (int nr)
{
cout<<"\n Numarul este: "<<nr;
}
void afisare( char sir[])
{
puts("\n Sirul este: ");
puts(sir);
}
Legtura static
Dac decizia asupra versiunii care se execut la apelul unei funcii
suprancrcate este luat n momentul compilrii, atunci spunem c funcia
realizeaz o legtur static.
#include<conio.h>
class punct
{
public:
float aria()
{
return 0;
}
}ob1;
class patrat: public punct
{
float l;
public:
setare(float x)
{
if(x>=0)
l = x;
else l =x;
}
float aria()
{
return l * l;
}
}ob2;
void main(void)
{
punct *p;
patrat *q;
int nr;
clrscr();
cout<<"\n dati latura patratului: ";
cin>>nr;
ob2.setare(nr);
cout<<"\n obiectul 1: "<<ob1.aria();
cout<<"\n obiectul 2: "<<ob2.aria();
p = &ob1;
cout<<"\n pointerul p la ob1 (din clasa punct): "<<p->aria();
q = &ob2;
cout<<"\n pointerul q la ob2 (din clasa patrat): "<<q->aria() ;
getche();
}
Observaie: La redefinirea funciilor, n mod implicit se realizeaz legtura
static. Versiunea de funcie executat se stabilete n momentul compilrii, fiind
o metod ineficient n proiectarea unei ierarhii de clase, deoarece varianta
funciei din clasele derivate nu poate fi folosit.
Funcii virtuale. Funcii virtuale pure. Clase abstracte
Legtura dinamic realizeaz detectarea versiunii funciei executate n
momentul execuiei programului.
Funciile virtuale sunt metodele pentru care se efectueaz legtura
dinamic. Cteva proprietti ale funciilor virtuale ar fi:
funciile virtuale trebuie s aparin unei clase;
nu pot fi statice i nici inline;
redefinirea unei funcii virtuale este posibil la orice nivel al ierarhiei de clase.
n acest caz, funciile redefinite rmn virtuale, fr a mai fi necesar specificarea
cuvntului virtual.
constructorii nu pot fi funcii virtuale, ns destructorii pot fi funcii virtuale;
cnd se folosete o funcie virtual, compilatorul construiete tabelul de
functii virtuale pentru pstrarea evidenei functiilor ce trebuie apelate, pentru
fiecare obiect din clasa respectiv.
Apelul unei funcii virtuale presupune:
determinarea adresei funciei virtuale ale clasei din care face parte
obiectul;
citirea adresei funciei virtuale din tabelul de functii virtuale;
executarea funciei apelate.
Avantajele folosirii claselor virtuale

flexibilitate crescut n reutilizarea i dezvoltarea claselor existente;
funciile deja concepute pot fi adaptate unor clase noi, fr a fi necesar
modificarea lor.
Un dezavantaj al utilizrii funciilor virtuale const n creterea
consumului de memorie i a timpului de executie, prin utilizarea tabelului de
funcii virtuale.
Funcii virtuale pure. Clase abstracte
Funcia virtual pur realizeaz doar declararea prototipului unei funcii,
urmnd ca n clasele derivate s apar suprancrcarea ei. O funcie virtual pur
se declar folosind sintaxa urmtoare:
virtual <prototip> = 0
Clasa abstract este o clas care conine cel puin o funcie virtual pur.
Funciile virtuale pure sunt destinate crerii unor clase noi.
Exemplul 1): S se defineasc o clas de baz cu funcii virtuale pure
pentru calcularea ariei i perimetrului unui ptrat. S se construiasc o clas
derivat care s redefineasc funciile virtuale pure.
#include<stdio.h>
#include<conio.h>
class forme
{
public:
virtual float aria()=0;
virtual float perimetrul() = 0;
}*a;
class patrat : public forme
{
float l;
public:
patrat(float l);
float aria();
float perimetrul();
};
patrat::patrat(float x)
{
l = x;
}
float patrat::aria()
{
return l*l;
}
float patrat::perimetrul()
{
return(4*l);
}
void main(void)
{
float x;
clrscr();
do
{
printf("\n dati latura patratului: ");
scanf("%f",&x);
}
while(x<=0);
patrat p(x);
a = &p;
printf("\n aria = %.2f",a->aria());
printf("\n perimetrul = %.2f", a->perimetrul());
getche();
}
Exemplul 2): S se defineasc dou clase, prima clas de baz, iar a doua
clas, derivat din clasa de baz, care s redefineasc o funcie virtual pentru afiarea
unui mesaj. S se dfineasc pointeri ctre cele dou clase i s se evidenieze
legtura dinamic.
#include<conio.h>
class B
{
public:
virtual void afisare();
};
class D : public B
{
public:
virtual void afisare();
};
void B::afisare()
{
cout<<"\n apel functie din clasa de baza B";
}
void D::afisare()
{
cout<<"\n apel functie din clasa derivata D";
}
void main(void)
{
clrscr();
B *p = new B;
p->afisare();
delete p;
D *q = new D;
q->afisare();
delete q;
//legatura dinamica
B *p1;
D p2;
p1 = (B*) &p2;
cout<<"\n legatura dinamica";
p1->afisare();
getche();
}
Observaie: Instruciunea p1->afisare(); evideniaz legtura dinamic - se
apeleaz funcia afisare() din clasa derivat, deoarece funcia este declarat virtual.
Exemplul 3): S se defineasc o clas de baz tablou care s conin
funcii virtuale pure pentru citire, scriere i calculul sumei elementelor unui
tablou. S se declare o clas derivat pentru operaii cu vectori.
#include<conio.h>
int i, j, n, s, nr;
char ch;
class tablou
{
public:
virtual void citire() = 0;
virtual void scriere() = 0;
virtual int suma() = 0;
};
class vector: public tablou
{
int n, inf[12];
public:
vector(int);
void citire();
void scriere();
int suma();
};
vector::vector( int nr)
{
n = nr;
}
{
for(i=1;i<=n;i++)
{
cout<<"\n inf["<<i<<"]=";
cin>>inf[i];
}
}
void vector::scriere()
{
for(i=1; i<=n; i++)
cout<<inf[i]<<" ";
}
int vector::suma()
{
s = 0;
for(i=1; i<=n; i++)
s+=inf[i];
return s;
}
void main(void)
{
clrscr();
do
{
cout<<endl<<"numarul de elemente ale vectorului: ";
cin>>n;
}
while(n<=0);
vector v(n);
cout<<endl<<"dati elementele vectorului: ";
v.citire();
cout<<endl<<"vectorul: ";
v.scriere();
cout<<endl<<"suma elementelor vectorului: "<<v.suma();
getche();
}
Exemplul 4): S se defineasc o clas de baz tablou care s conin
funcii virtuale pure pentru citire, scriere i calculul sumei elementelor unui
tablou. S se declare o clas derivat pentru operaii cu liste simplu nlnuite
(citire, afiare elemente i concatenarea a dou liste).
#include<conio.h>
#include<ctype.h>
class lista
{
public:
int nr;
lista* urm;
}*p, *pr, *ul;
int s, nr;
char ch;
class tablou
{
public:
virtual void citire() = 0;
virtual void scriere() = 0;
virtual int suma() = 0;
};
class lista1: public tablou
{
lista *prim, *ultim;
public:
void citire();
void scriere();
int suma();
lista1 operator+(lista1);
}l1, l2, l3;
void lista1::citire()
{
ultim = prim = NULL;
do
{
if(ultim ==NULL)
{
ultim = new lista;
cout<<endl<<"Dati nr: ";
cin>>nr;
ultim->nr = nr;
ultim->urm = NULL;
prim = ultim;
}
else
{
p = new lista;
cout<<endl<<"Dati urmatorul element: ";
cin>>nr;
p->nr = nr;
p->urm = NULL;
ultim->urm = p;
ultim = p;
}
cout<<"mai introduceti elemente?(d/n)";
ch = getche();
}while(toupper(ch)!='N');
}
void lista1::scriere()
{
if(prim == NULL)
cout<<"\n lista vida";
else
for(p = prim; p; p = p->urm)
cout<<" "<<p->nr;
}
lista1 lista1::operator+(lista1 l2)
{
pr = prim;
ul = ultim;
ul->urm = l2.prim;
ul= l2.ultim;
l3.prim = pr;
l3.ultim = ul;
return(l3);
}
int lista1::suma()
{
s=0;
for(p=prim;p;p=p->urm)
s+=p->nr;
return s;
}
void main(void)
{
clrscr();
lista1 l1, l2;
cout<<endl<<" dati lista l1: ";
l1.citire();
cout<<"\n\n lista 1: ";
l1.scriere();
cout<<"\n\n suma elementelor listei l1 = "<<l1.suma();
cout<<"\n\ndati lista l2: ";
l2.citire();
cout<<"\n\n lista l2: ";
l2.scriere();
cout<<"\n\n l1 + l2 = ";
l3 = l1 + l2;
l3.scriere();
getche();
}
Probleme propuse
9. S se scrie un program C++ care s redefineasc operatorii de atribuire simpl
i compus, ca funcii membru pentru urmtoarele clase:
a. numere complexe
b. iruri de caractere
= ( atribuire)
+= ( concatenarea irurilor, cu pstrarea rezultatului n irul curent)
-= ( tergerea unui subir dintr-un ir)
c. liste dublu nlnuite
= atribuire simpl ( copierea unei liste n alt list)
+= atribuire compus ( adugarea unui element la o list i
concatenarea cu o alt list)
d. arbori binari
+= inserarea unui element
-+ tergerea unui element.
BIBLIOGRAFIE
1.
Boian, F. M., Sisteme de operare interactive, Editura Libris, Cluj-Napoca,

1994
2.
Garbacea I., Andonie R., http://www.cwu.edu/~andonie/Cartea de

algoritmi, Brasov, 1995
3.
Gonnet G. H., Handbook of Algorithms and Data Structures, Addison

Wesley, 1984
4.
Jamsa Dr. K., Klander L., Totul despre C i C++, Manualul fundamental
de programare n C i C++, Editura Teora, 1999-2006
5.
Kernighan B. W., Ritchie D. M., The C Programming Language, Prentice

Hall Software Series, Second Edition, 1978
6.
Knuth D., The Art of Computer Programming, vol. 3, Addison Wesley,

1973
7.
Kruse R. L., Data Structures and Program Design, Prentice Hall, 1984
8.
Litwin W., Linear Hashing: A new tool for file and table addressing, Proc.
6th Conference on Very Large Databases, 1980
9.
Livovschi L., Georgescu H., Sinteza i analiza algoritmilor, Editura

tiinific i Enciclopedic, Bucureti, 1986
10.
Marinoiu C., Programarea n limbajul C, Editura Universitii din Ploieti,

2000
11.
Perjeriu E., Vaduva I., ndrumar pentru lucrari de laborator la cursul de

Bazele Informaticii, anul I, Universitatea din Bucuresti, Facultatea de
Matematica, 1986
12.
Smeureanu I., Ivan I., Drdala M., Limbajul C/C++ prin exemple, Editura
Cison, Bucuresti, 1995
13.
Stoilescu D., Culegere de C/C++, Editura Radial, Galati, 1998
14.
Tudor N. L., Contribuii privind optimizarea tehnicilor de accesare a

obiectelor din baze de date relaionale tez de doctorat, Universitatea
POLITEHNICA Bucureti, 2009
15.
Tudor S., Bazele programrii n C++, Editura L&S INFOMAT, 1997
16.
Tudor S., Tehnici de programare, Editura Teora, 1996
17.
Williams M., Bazele Visual C++ 4, Editura Teora, 1997
18.
Wirth N., Systematic Programming: An Introduction, Prentice Hall, 1972
19.
*** Borland C++, versiunea 3.1, Help, 1990

Book Basics of Programming in C++ Tudor 2010

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Book Basics of Programming in C++ Tudor 2010

Uploaded by

Copyright:

Available Formats

See

Bazele programrii n limbajul C++

Available from: Nicoleta Liviana Tudor

Bazele programrii n limbajul C++

Editura MATRIX ROM

Bazele programrii n limbajul C++

Sisteme de calcul. Reprezentarea datelor n memoria calculatorului

Reprezentarea datelor n memoria calculatorului . . . . . . .

Principiile programrii structurate. Metode de reprezentare a

2.1. Principiile programrii structurate . . . . . . . . . . . . . . . . . . .

2.2. Reprezentarea algoritmilor . . . . . . . . . . . . . . . . . . . . . . . . . .

Limbajul C++. Alfabet i vocabular . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.1. Alfabetul limbajului C++ . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.2. Vocabularul limbajului C++ . . . . . . . . . . . . . . . . . . . . . . . . .

Tipuri de date. Operaii de intrare-ieire . . . . . . . . . . . . . . . . . . . . . . . .

4.1. Tipuri fundamentale de date . . . . . . . . . . . . . . . . . . . . . . . .

4.2. Structura programelor n limbajul C++ . . . . . . . . . . . . . . .

4.3. Funcii uzuale de intrare-ieire . . . . . . . . . . . . . . . . . . . . . .

4.4. Operaii cu consola ( header <iostream.h>) . . . . . . . . . . . .

Structuri decizionale: if, switch, operatorul ?: . . . . . . . . . . . . . . . . . . .

5.1. Instruciunea if i directiva #if . . . . . . . . . . . . . . . . . . . . . . .

5.2. Instruciunea switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Structuri iterative. Instruciuni pentru transferul execuiei . . . . . . . .

6.1. Instruciunea for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.2. Instruciunea while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.3. Instruciunea do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.4. Instruciuni pentru transferul execuiei . . . . . . . . . . . . . . .

Tablouri ( vectori, matrice, iruri de caractere) . . . . . . . . . . . . . . . . . . .

7.1. Tablouri unidimensionale ( vectori) . . . . . . . . . . . . . . . . . . .

7.1.1. Cutare n vectori . . . . . . . . . . . . . . . . . . . . . . . . . . .

7.1.2. Sortarea unui vector . . . . . . . . . . . . . . . . . . . . . . . . .

7.1.3. Interclasarea a doi vectori ordonai . . . . . . . . . . . .

7.2. Tablouri bidimensionale ( matrice) . . . . . . . . . . . . . . . . . . .

7.3. iruri de caractere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9.1. Prototipul, definiia i apelul unei funcii . . . . . . . . . . . . . .

9.2. Transferul parametrilor unei funcii . . . . . . . . . . . . . . . . . .

9.2.1. Transferul parametrilor prin valoare . . . . . . . . . .

9.2.2. Transferul parametrilor prin referin . . . . . . . . .

9.2.3. Transferul parametrilor de tip tablou . . . . . . . . .

9.2.4. Transferul parametrilor de tip structur . . . . . . .

9.3. Funcii cu un numr neprecizat de parametri . . . . . . . . . .

9.4. Pointeri la funcii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9.5. Funcii recursive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9.5.1. Funcii direct recursive . . . . . . . . . . . . . . . . . . . . . .

9.5.2. Recursivitatea i metoda relurii (backtracking)

Structuri de date alocate dinamic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

10.1. Operaii cu variabile de tip pointer . . . . . . . . . . . . . . . . . .

10.2. Pointeri ctre tablouri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

10.3. Structuri autoreferite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11.1. Liste, stive, cozi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11.2. Tabele de dispersie (Hash) . . . . . . . . . . . . . . . . . . . . . . . . .

11.3.1. Arbori binari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11.3. 2. Arbori oarecare . . . . . . . . . . . . . . . . . . . . . . . . . . .

Programare orientat pe obiecte n limbajul C++ . . . . . . . . . . . . . . . .

Sisteme de calcul. Reprezentarea datelor

Un sistem de calcul este un ansamblu de componente hardware

1.1. Componenta hardware

UC = CPU (unitate central de prelucrare ) + MI ( memorie intern )

Fig. 1. Schema unui sistem de calcul.

Un octet (byte) 1o = 1 B = 8 bii = cantitatea de informaie memorat ntr-o

1.2. Componenta software

operare). Acesta ncarc n RAM nucleul sistemului de operare i l lanseaz n

Componentele sistemului de operare sunt:

Nucleul ( Kernel) conine programele necesare pentru gestionarea

Reprezentarea numrului 27 n baza 2 este: 272 = 11011= 12o+121 + 0*22 +

Reprezentarea numrului 6 n baza 2: 62 = 110 = 02o+121 + 1*22 = 6

Scrierea numrului 27 n baza 16: 2716 = 1B = B160 + 1161 = 11 + 16 = 27