2.1.Limbajele de programare C şi C++. Elemente de bază.

2.1.1.Limbajele C şi C++

Limbajul C face parte din familia de limbaje concepute pe principiile programării

structurate, la care ideea centrală este ”structurează pentru a stăpâni o aplicaţie”.
Limbajul C++ este o variantă de limbaj C îmbunătăţit, mai riguroasă şi mai
puternică, completată cu construcţiile necesare aplicării principiilor programării orientate
pe obiecte (POO). Limbajul C++ păstrează toate elementele limbajului C, beneficiind de
eficienţa şi flexibilitatea acestuia.
Un program scris în limbajul C (sau C++) este compus din unul sau mai multe
fişiere sursă. Un fişier sursă este un fişier text care conţine codul sursă (în limbajul C) al
unui program. Fiecare fişier sursă conţine una sau mai multe funcţii şi eventual, referinţe
către unul sau mai multe fişiere header
Funcţia principală a unui program este numită main. Execuţia programului începe
cu execuţia acestei funcţii, care poate apela, la rândul ei, alte funcţii.

2.1.2.Elemente de bază.

VOCABULARUL

În scrierea programelor în limbajul C/C++ pot fi folosite doar anumite simboluri care
alcătuiesc alfabetul limbajului. Acesta cuprinde:
 Literele mari sau mici de la A la Z (a-z);

 Caracterul subliniere ( _ underscore), folosit, de obicei, ca element de legătura între

cuvintele compuse;
 Cifrele zecimale (0-9);

 Simboluri speciale:

 Caractere:
 operatori (Exemple: +, *, !=);
 delimitatori (Exemple: blank (spaţiu), tab \t, newline \n, cu rolul de a
separa cuvintele);
 Grupuri (perechi de caractere).

Grupurile de caractere, numire adesea separatori, pot fi:

 ( ) - Încadrează lista de argumente ale unei funcţii sau sunt folosite în expresii pentru
schimbarea ordinii de efectuare a operaţiilor (în ultimul caz, fiind operator);
 {} - Încadrează instrucţiunile compuse;
 // - Indică începutul unui comentariu care se poate întinde până la sfârşitul
liniei;
 /* */ - Indică începutul şi sfârşitul unui comentariu care poate cuprinde mai multe
linii;
 " " - Încadrează o constantă şir (un şir de caractere);
 ' ' - Încadrează o constantă caracter (un caracter imprimabil sau o secvenţă escape).

UNITĂŢILE LEXICALE

Unităţile lexicale (cuvintele) limbajului C/C++ reprezintă grupuri de caractere cu o

semnificaţie de sine stătătoare. Acestea sunt:
 Identificatori;

 Cuvinte cheie ale limbajului;

Identificatorii reprezintă numele unor date (constante sau variabile), sau ale unor
funcţii. Identificatorul este format dintr-un şir de litere, cifre sau caracterul de subliniere
(underscore), trebuie să înceapă cu o literă sau cu caracterul de subliniere şi să fie
sugestivi.

Exemple: viteză, greutate_netă, Viteza, Viteza1, GreutateNetă

Identificatorii pot conţine litere mici sau mari, dar limbajul C++ este senzitiv la
majuscule şi minuscule (case-sensitive). Astfel, identificatorii viteza şi Viteza sunt
diferiţi.
Nu pot fi folosiţi ca identificatori cuvintele cheie. Identificatorii pot fi standard (ca
de exemplu numele unor funcţii predefinite: scanf, clear, etc.) sau aleşi de utilizator.

Cuvintele cheie sunt cuvinte ale limbajului, împrumutate din limba engleză, cărora
programatorul nu le poate da o altă utilizare. Cuvintele cheie se scriu cu litere mici şi pot
reprezenta:
 Tipuri de date (Exemple: int, char, double);

 Clase de memorare (Exemple: extern, static, register);

 Instrucţiuni (Exemple: if, for, while);

 Operatori (Exemplu: sizeof).

Sensul cuvintelor cheie va fi explicat pe masură ce vor fi prezentate construcţiile în care

acestea apar.
2.2. Descrierea şi prelucrarea datelor (tipuri standard de date, constante, variabile,
expresii, operaţii de citire/scriere, funcţii uzuale).

2.2.1. DATE ÎN LIMBAJUL C/C++

Aşa cum s-a văzut în capitolul 1, un program realizează o prelucrare de informaţie.

Termenul de prelucrare trebuie să fie considerat într-un sens foarte general (de exemplu,
în programul prezentat în paragraful 2.2., prelucrarea se referea la un text şi consta în
afişarea lui). În program datele apar fie sub forma unor constante (valori cunoscute
anticipat, care nu se modifică), fie sub forma de variabile. Constantele şi variabilele sunt
obiectele informaţionale de bază manipulate într-un program.

Fiecare categorie de date este caracterizată de atributele:

 Nume;
 Valoare;
 Tip;
 Clasa de memorare.
De primele trei tipuri de atribute ne vom ocupa în continuare, urmând ca de atributul
clasă de memorare să ne ocupăm în paragraful 6.8.

Numele unei date

Numele unei date este un identificator şi, ca urmare, trebuie să respecte regulile
specifice identificatorilor. Deasemenea, numărul de caractere care intră în compunerea
unui identificator este nelimitat, însă, implicit, numai primele 32 de caractere sunt luate în
considerare. Aceasta înseamnă că doi identificatori care au primele 32 de caractere
identice, diferenţiindu-se prin caracterul 33, vor fi consideraţi identici.

2.2.2. TIPURI DE DATE

Tipul unei date constă într-o mulţime de valori pentru care s-a adoptat un anumit
mod de reprezentare în memoria calculatorului şi o mulţime de operatori care pot fi
aplicaţi acestor valori. Tipul unei date determină lungimea zonei de memorie ocupată de
acea dată. În general, lungimea zonei de memorare este dependentă de calculatorul pe
care s-a implementat compilatorul. Tabelul 2.1. prezintă lungimea zonei de memorie
ocupată de fiecare tip de dată pentru compilatoarele sub MS-DOS şi UNIX/LINUX.
Tipurile de bază sunt:
 char un singur octet (1 byte=8 biţi), capabil să conţină codul unui caracter din
setul
local de caractere;
 int număr întreg, reflectă în mod tipic mărimea naturală din calculatorul utilizat;
 float număr real, în virgulă mobilă, simplă precizie;
 double număr real, în virgulă mobilă, dublă precizie.

În completare există un număr de calificatori, care se pot aplica tipurilor de bază char,
int, float sau double: short, long, signed şi unsigned. Astfel, se obţin
tipurile derivate de date. Short şi long se referă la mărimea diferită a întregilor, iar
datele de tip unsigned int sunt întotdeauna pozitive. S-a intenţionat ca short şi
long să furnizeze diferite lungimi de întregi, int reflectând mărimea cea mai "naturală"
pentru un anumit calculator. Fiecare compilator este liber să interpreteze short şi long
în mod adecvat propriului hardware; în nici un caz, însă, short nu este mai lung decât
long. Toţi aceşti calificatori pot aplicaţi tipului int. Calificatorii signed (cel implicit)
şi unsigned se aplică tipului char. Calificatorul long se aplică tipului double.
Dacă într-o declaraţie se omite tipul de bază, implicit, acesta va fi int.

Tabelul 2.1.
Tip Lungimea zonei Descriere
de memorie
ocupate (în biţi)
MS- UNIX
DOS LINUX
char 8 8 Valoarea unui singur caracter; poate fi întâlnit în expresii cu
extensie de semn
unsigned char 8 8 Aceeaşi ca la char, fară extensie de semn
signed char 8 8 Aceeaşi ca la char, cu extensie de semn obligatorie
int 16 32 Valoare întreagă
long 32 64 Valoare întreagă cu precizie mare
(long int)
long long int 32 64 Valoare întreagă cu precizie mare
short int 16 32 Valoare întreagă cu precizie mică
unsigned int 16 32 Valoare întreagă, fără semn
unsigned long 32 64 Valoare întreagă, fără semn
int
float 32 32 Valoare numerică cu zecimale, simplă precizie (6 )
double 64 64 Valoare numerică cu zecimale, dublă precizie (10 )
long double 80 128 Valoare numerică cu zecimale, dublă precizie

2.2.3. CONSTANTE

O constantă este un literal (o formă externă de reprezentare) numeric, caracter sau

şir de caractere. Numele şi valoarea unei constante sunt identice. Valoarea unei constante
nu poate fi schimbată în timpul execuţiei programului în care a fost utilizată. Tipul şi
valoarea ei sunt determinate în mod automat, de către compilator, pe baza caracterelor
care compun literalul.

2.2.3.1.Constante întregi

Constantele întregi sunt literali numerici (compuşi din cifre), fără punct zecimal.
 Constante întregi în baza 10, 8 sau 16

 Constante întregi în baza 10

Exemple:
45
-78 // constante întregi decimale (în baza 10), tip int
 Constante întregi octale
Dacă în faţa numărului apare cifra zero (0), acest lucru indică faptul că acea
constantă este de tipul int, in baza opt (constantă octală).
Exemple:
056
077 // constante întregi octale, tip int
 Constante întregi hexagesimale
Dacă în faţa numărului apar caracterele zero (0) şi x (sau X), acest lucru indică
faptul că acea constantă este de tipul int, în baza 16 (constantă hexagesimală).
Amintim că în baza 16 cifrele sunt: 0-9, A (sau a) cu valoare 10, B (sau b) cu
valoare 11, C (sau c) cu valoare 12, D (sau d) cu valoare 13, E (sau e) cu valoare
14, F (sau f) cu valoare 15.
Exemple:
0x45
0x3A
0Xbc // constante întregi hexagesimale, tip int
 Constante întregi, de tipuri derivate

 Dacă secvenţa de cifre este urmată de L sau l, tipul constantei este long
int.
Exemple:
145677L
897655l // tip decimal long int
 Dacă secvenţa de cifre este urmată de U sau u, tipul constantei este
unsigned int.
Exemple:
65555u
 Dacă secvenţa de cifre este urmată de U (u) şi L (l), tipul constantei este
unsigned long int.
 Exemple: 7899UL //tip decimal unsigned long int

2.2.3.2.Constante numerice, reale

 Dacă o constantă numerică conţine punctul zecimal, ea este de tipul double.

Exemplu:
3.1459 //tip double
 Dacă numărul este urmat de F sau f, constante este de tip float.
 Dacă numărul este urmat de L sau l, este de tip long double.
Exemplu:
0.45f //tip float
9.788L //tip long double
 Constante reale în format ştiinţific
Numărul poate fi urmat de caracterul e sau E şi de un număr întreg, cu sau fără semn.
În acest caz, constanta este în notaţie ştiinţifică. În această formă externă de
reprezentare, numărul din faţa literei E reprezintă mantisa, iar numărul întreg care
urmează caracterului E reprezintă exponentul. In forma externă de reprezentare, baza
de numeraţie este 10, deci valoarea constantei va fi dată de mantisa × 10 exponent .

2.2.3.3. Constante caracter

Constantele caracter sunt încadrate între apostroafe.

Exemplu:
'a' //tip char
O constantă caracter are ca valoare codul ASCII al caracterului pe care îl reprezintă.
Acest set de caractere are următoarele proprietăţi:
 Fiecărui caracter îi corespunde o valoare întreagă distinctă (ordinală);

 Valorile ordinale ale literelor mari sunt ordonate şi consecutive ('A' are codul ASCII

65, 'B' - codul 66, 'C' - codul 67, etc.);

 Valorile ordinale ale literelor mici sunt ordonate şi consecutive ('a' are codul ASCII

97, 'b' - codul 98, 'c' - codul 99, etc.);

 Valorile ordinale ale cifrelor sunt ordonate şi consecutive ('0' are codul ASCII 48, '1' -

codul 49, '2' - codul 50, etc.).

 Constante caracter corespunzătoare caracterelor imprimabile

O constantă caracter corespunzătoare unui caracter imprimabil se reprezintă prin
caracterul respectiv inclus între apostroafe.
Exemplu:
Constantă caracter Valoare
 ‘A’ 65
‘a’ 97
‘0’ 48
‘*’ 42
2.2.3.4. Constante şir de caractere

Constanta şir este o succesiune de zero sau mai multe caractere, încadrate de ghilimele. În
componenţa unui şir de caractere, poate intra orice caracter, deci şi caracterele escape.
Lungimea unui şir este practic nelimitată. Dacă se doreşte continuarea unui şir pe rândul
următor, se foloseşte caracterul backslash.

Caracterele componente ale unui şir sunt memorate într-o zonă continuă de memorie (la
adrese succesive). Pentru fiecare caracter se memorează codul ASCII al acestuia. După
ultimul caracter al şirului, compilatorul plasează automat caracterul NULL (\0), caracter
care reprezintă marcatorul sfârşitului de şir. Numărul de octeţi pe care este memorat un
şir va fi, deci, mai mare cu 1 decât numărul de caractere din şir.

2.2.4. VARIABILE

Spre deosebire de constante, variabilele sunt date (obiecte informaţionale) ale căror
valori se pot modifica în timpul execuţiei programului. Şi variabilele sunt caracterizate de
atributele nume, tip, valoare şi clasă de memorare. Variabilele sunt nume simbolice
utilizate pentru memorarea valorilor introduse pentru datele de intrare sau a rezultatelor.
Dacă la o constantă ne puteam referi folosind caracterele componente, la o variabilă ne
vom referi prin numele ei. Numele unei variabile ne permite accesul la valoarea ei, sau
schimbarea valorii sale, dacă este necesar acest lucru. Numele unei variabile este un
identificator ales de programator. Ca urmare, trebuie respectate regulile enumerate în
secţiunea identificatori.

Dacă o dată nu are legături cu alte date (de exemplu, relaţia de ordine), vom spune
că este o dată izolată. O dată izolată este o variabilă simplă. Dacă datele se grupează într-
un anumit mod (în tablouri - vectori, matrici - sau structuri), variabilele sunt compuse
(structurate).

În cazul constantelor, în funcţie de componenţa literalului, compilatorul stabilea,

automat, tipul constantei. În cazul variabilelor este necesară specificarea tipului fiecăreia,
la declararea acesteia. Toate variabilele care vor fi folosite în program, trebuie declarate
înainte de utilizare.

2.2.4.1. Declararea variabilelor

Modul general de declarare a variabilelor este:

tip_variabile listă_nume_variabile;
Se specifică tipul variabilei(lor) şi o listă formată din unul sau mai mulţi identificatori ai
variabilelor de tipul respectiv. Într-un program în limbajul C++, declaraţiile de variabile
pot apare în orice loc în programul sursă. La declararea variabilelor, se rezervă în
memorie un număr de octeţi corespunzător tipului variabilei, urmând ca ulterior, în acea
zonă de memorie, să fie depusă (memorată, înregistrată) o anumită valoare.
Exemple:
int i, j;/*declararea var. simple i, j, de tip int. Se rezervă pentru i şi j câte 16 biţi
(2octeţi)*/
char c; /* declararea variabilei simple c, de tip char. Se rezervă un octet. */
float lungime; /* declararea variabilei simple lungime; se rezervă 4
octeţi */

2.2.4.2. Iniţializarea variabilelor în declaraţii

În momentul declarării unei variabile, acesteia i se poate da (asigna, atribui) o

anumită valoare. În acest caz, în memorie se rezervă numărul de locaţii corespunzător
tipului variabilei respective, iar valoarea va fi depusă (memorată) în acele locaţii.
Forma unei declaraţii de variabile cu atribuire este:
tip_variabilă nume_variabilă=expresie;
Se evaluează expresia, iar rezultatul acesteia este asignat variabilei specificate.
Exemple:
int a=7*9+2; /* declararea variabilei simple a, de tip int şi iniţializarea ei cu
valoarea 65*/
float radiani, pi=3.14;/*declararea variabilei radiani;declararea şi
iniţializarea var. pi*/
short int z=3; //declararea şi iniţializarea variabilei simple
z
char d=’\011’;
char LinieNoua=’\n’;
double x=9.8, y=0;
Compilatorul C++ furnizează mecanisme care permit programatorului să influenţeze
codul generat la compilare, prin aşa-numiţii calificatori.
Aceştia sunt:
 const;
 volatile.

Calificatorul const asociat unei variabile, nu va permite modificarea ulterioară a valorii

acesteia, prin program (printr-o atribuire). Calificatorul volatile (cel implicit) are efect
invers calificatorului const. Dacă după calificator nu este specificat tipul datei, acesta este
considerat tipul implicit, adică int.
Exemple:
const float b=8.8;
volatile char terminator;terminator=’@’;terminator=’*’;
//permis
b=4/5; //nepermisa modificarea valorii variabilei b
const w; volatile g; //w, g de tip int, implicit

2.2.5.Operaţii de intrare/ieşire

Limbajele C/C++ nu posedă instrucţiuni de intrare/ieşire, deci de citire/scriere (ca

limbajul PASCAL, de exemplu). În limbajul C aceste operaţii se realizează cu ajutorul
unor funcţii (de exemplu, printf şi scanf), iar în limbajul C++ prin supraîncărcarea
operatorilor (definirea unor noi proprietăţi ale unor operatori existenţi, fără ca
proprietăţile anterioare să dispară), mai precis a operatorilor >> şi << . Vom folosi în
continuare abordarea limbajului C++, fiind, în momentul de faţă, mai simplă. În limbajul
C++ sunt predefinite următoarele dispozitive logice de intrare/ieşire:
cin - console input - dispozitivul de intrare (tastatura);
cout - console output - dispozitivul de ieşire (monitorul).
Aşa cum se va vedea în capitolul 9, cin şi cout sunt, de fapt, obiecte (predefinite).
Transferul informaţiei se realizează cu operatorul >> pentru intrare şi operatorul <<
pentru ieşire. Utilizarea dispozitivelor de intrare/ieşire cu operatorii corespunzători
determină deschiderea unui canal de comunicaţie a datelor către dispozitivul respectiv.
După operator se specifică informaţiile care vor fi citite sau afişate.
Exemple:
cout << var; /* afişează valoarea variabilei var pe monitor*/
cin >> var; /* citeşte valoarea variabilei var de la tasatatură */

Sunt posibile operarţii multiple, de tipul:

Exemple:
cout << var1 << var2 << var3;
cin >> var1 >> var2 >> var3;
În acest caz, se efectuează succesiv, de la stânga la dreapta, scrierea, respectiv citirea
valorilor variabilelor var1, var2 şi var3.

Operatorul >> se numeşte operator extractor (extrage valori din fluxul datelor de intrare,
conform tipului acestora), iar operatorul << se numeşte operator insertor (inserează
valori în fluxul datelor de ieşire, conform tipului acestora). Tipurile de date citite de la
tastatură pot fi toate tipurile numerice, caracter sau şir de caractere. Tipurile de date
transferate către ieşire pot fi: toate tipurile numerice, caracter sau şir de caractere.
Operanzii operatorului extractor (>>) pot fi doar nume de variabile. Operanzii
operatorului insertor (<<) pot fi nume de variabile (caz în care se afişează valoarea
variabilei), constante sau expresii. Utilizarea dispozitivelor şi operatorilor de intrare/ieşire
în C++ impune includerea fişierului iostream.h.
Exemple:
char c;
cout<<"Astept un caracter:"; //afişarea constantei şir de caractere,
deci a mesajului
cin>>c; //citirea valorii variabilei c, de tip caracter
int a, b, e; double d;
cin>>a>>b>>e>>d; //citirea valorilor variabilelor a, b, e, d de tip int,
int, int, double
cout<<"a="<<a<<"Valoarea expresiei a+b
este:"<<a+b<<'\n';

2.2.6. OPERATORI ŞI EXPRESII

Datele (constante sau variabile) legate prin operatori, formează expresii (figura 2.4).
Operatorii care pot fi aplicaţi datelor (operanzilor) depind de tipul operanzilor, datorită
faptului că tipul unei date constă într-o mulţime de valori pentru care s-a adoptat un
anumit mod de reprezentare în memoria calculatorului şi o mulţime de operatori care pot
fi aplicaţi acestor valori.

Operatorii pot fi:

 unari (necesită un singur operand);

 binari (necesită doi operanzi);

 ternari (trei operanzi).

O expresie este o combinaţie corectă din punct de vedere sintactic, formată din operanzi
şi operatori. Expresiile, ca şi operanzii, au tip şi valoare.

2.2.6.1. OPERATORI

 Operatorul unar adresă &, aplicat identificatorului unei variabile, furnizează adresa la
care este memorată aceasta. Poate fi aplicat oricărui tip de date şi se mai numeşte
operator de referenţiere.
Exemplu:
int a;
cout<<"Adresa la care este memorata variabila a
este:"<<&a;

 Operatorul de atribuire (de asignare) este un operator binar care se aplică tuturor
tipurilor de variabile. Este folosit sub formele următoare:
nume_variabilă=expresie;
sau: expresie1=expresie2;
Se evaluează expresia din membrul drept, iar valoarea acesteia este atribuită variabilei
din membrul stâng. Dacă tipurile membrilor stâng şi drept diferă, se pot realiza anumite
conversii, prezentate în paragraful 2.7.
Exemplu:
float x; int a,b; x=9.18;
a=b=10;
int s; s=a+20*5; //rezultat: s=110
s=x+2; //rezultat s=11, deoarece s este int.

Aşa cum se observă în linia a 2-a din exemplul precedent, operatorul de atribuire poate fi
utilizat de mai multe ori în aceeaşi expresie. Asociativitatea operatorului are loc de la
dreapta la stânga. Astfel, mai întâi b=10, apoi a=b.

 Operatori aritmetici unari:

Operator Semnificaţie Exemple
- Minus unar -a
++ Operator de incrementare a++ sau
(adună 1 la valoarea operandului) ++a
-- Operator de decrementare a-- sau
(scade 1 din valoarea operandului) --a

 Operatorul - unar schimbă semnul operandului.

 Exemplu:
int a,b; cout<<”a=”<<-a<<’\n’; b=-a;
cout<<”b=”<<b<<’\n’;
Operatorul - unar poate fi aplicat datelor întregi, reale, caracter.

 Operatorii de incrementare şi decrementare pot fi aplicaţi datelor

numerice sau caracter.
Ambii operatori pot fi folosiţi în formă prefixată, înaintea operandului, (++a,
respectiv --a) sau postfixată, după operand (a++, respectiv a--).
Operatorul de decrementare -- care poate fi folosit în formă prefixată (--a) sau
postfixată (a--).

Utilizarea acestor operatori în expresii, în formă prefixată sau postfixată, determină

evaluarea acestora în moduri diferite, astfel:

y=++x este echivalent cu: x=x+1;

y=x;
y=x++ este echivalent cu: y=x;
x=x+1;
y=--x este echivalent cu: x=x-1;
y=x;
y=x-- este echivalent cu: y=x;
x=x-1;

 Operatori aritmetici binari:

Operator Semnificaţie Exemple
+ Adunarea celor doi operanzi a+b
- Scăderea celor doi operanzi a-b
* Înmulţirea celor doi operanzi a*b
/ Împărţirea celor doi operanzi a/b
% Operatorul modulo (operatorul rest) a%b
(furnizează restul împărţirii operatorului stâng la operatorul drept).

 Operatori aritmetici binari compuşi

Operator Semnificaţie Exemple
+= a=a+b a+=b
-= a=a+b a-=b
*= a=a*b a*=b
 /= a=a/b a/=b
%= a=a%b a%=b
Aceşti operatori se obţin prin combinarea operatorilor aritmetici binari cu operatorul de
atribuire şi sunt folosiţi sub forma următoare:
expresie1 operator= expresie2;
Rezultatul obţinut este acelaşi cu rezultatul obţinut prin:
expresie1 = expresie1 operator expresie2;
Toţi aceşti operatorii modifică valoarea operandului stâng prin adunarea, scăderea,
înmulţirea sau împărţirea acestuia prin valoarea operandului drept.
Construcţia x+=1 generează acelaşi rezultat ca expresia x=x+1.
Observaţiile referitoare la operatorii aritmetici binari sunt valabile şi pentru operatorii
aritmetici binari compuşi. Operatorii aritmetici binari compuşi au aceeaşi prioritate şi
asociativitate ca şi operatorul de atribuire.

 Operatori relaţionali binari

Operator Semnificaţie Exemple
== Egal cu a==b
!= Diferit de a!=b
< Mai mic decât a<b
<= Mai mic sau egal a<=b
> Mai mare decât a>b
>= Mai mare sau egal a>=b
Primii doi operatori mai sunt numiţi operatori de egalitate. Operatorii relaţionali servesc
la compararea valorilor celor doi operanzi şi nu modifică valorile operanzilor. Rezultatul
unei expresii în care apare unul din operatorii relaţionali binari este întreg şi are valoarea
zero (0) dacă relaţia este falsă, sau valoarea unu (1) (sau diferită de 0 în cazul
compilatoarelor sub UNIX), dacă relaţia este adevărată. Aceşti operatorii pot fi aplicaţi
datelor de tip întreg, real sau char.
Regulile de precedenţă şi asociativitate ale acestor operatori sunt prezentate în tabelul 2.4.

 Operatori logici pe cuvânt

Operator Semnificaţie Exemple
! Not (negaţie logică) !(a==b)
&& And (conjuncţie, şi logic) (a>b) && (b>c)
|| Or (disjuncţie, sau logic) (a>b) || (b>c)
Aceşti operatori pot fi aplicaţi datelor de tip întreg, real sau caracter.

 Operatori logici pe bit

 Operator Semnificaţie Exemple
~ Negaţie (cod complementar faţă de unu) ~a
& AND (Conjuncţie, şi logic pe bit a & 0377
| OR (Disjuncţie, sau logic pe bit) a | 0377
^ XOR (Sau exclusiv logic pe bit) a^b
<< Deplasare stânga 0377 << 2
>> Deplasare dreapta 0377 >> 2

Aceşti operatori nu se aplică numerelor reale, ci numai datelor de tip întreg sau caracter.
Primul operator este unar, ceilalţi binari.

Operatorul ~ are aceeaşi prioritate ca şi ceilalţi operatori unari. El furnizează

complementul faţă de unu al unui întreg, adică va schimba fiecare bit de pe 1 în zero şi
invers. Operatorii de deplasare pe bit (<< şi >>) efectuează deplasarea la stânga sau la
dreapta a operandului stâng, cu numărul de biţi indicaţi de operandul drept. Astfel, x<<2
deplasează biţii din x la stânga, cu două poziţii, introducând zero pe poziţiile rămase
vacante.
Operatorul binar ^ îşi găseşte o utilizare tipică în expresii ca: x&^077, care
maschează ultimii 6 biţi ai lui x pe zero.
Operatorul & este adesea utilizat în expresii ca x&0177, unde setează toţi biţii
pe zero, cu excepţia celor de ordin inferior din x.
Operatorul | este utilizat în expresii ca: x&MASK , unde setează pe unu biţii
care în x şi masca MASK sunt setaţi pe unu.
Operatorii logici pe bit & şi | sunt diferiţi de operatorii logici && şi || (pe
cuvânt).
Deplasarea la stânga a unei date cu n poziţii este echivalentă cu înmulţirea
valorii acesteia cu 2 n . Deplasarea la dreapta a unei date fără semn cu n poziţii
este echivalentă cu împărţirea valorii acesteia cu 2 n .
Combinând operatorii logici pe bit cu operatorul de atribuire, se obţin
operatorii:
&=, ^=, |=, <<=, >>=.

 Operatorul condiţional
Este un operator ternar (necesită 3 operanzi), utilizat în construcţii de forma:
expresie1?expresie2:expresie3
Se evaluează expresia1. Dacă aceasta are o valoare diferită de zero, atunci
tipul şi valoarea întregii expresii vor fi aceleaşi cu tipul şi valoarea expresiei2.
Altfel (dacă expresie1 are valoarea zero), tipul şi valoarea întregii expresii vor
fi aceleaşi cu tipul şi valoarea expresiei3. Deci operatorul condiţional este
folosit pentru a atribui întregii expresii tipul şi valoarea expresiei2 sau a
expresiei3, în funcţie de o anumită condiţie. Acest lucru este echivalent cu:
Dacă expresie1 diferită de zero
Atunci evaluează expresie2
Altfel evaluează expresie3
Exemplu:
int semn=(x<0)?-1:1
Dacă x<0, atunci semn=-1, altfel semn=1.

 Operatorul virgulă
Este utilizat în construcţii de forma:
expresie1 , expresie2
Operatorul virgulă forţează evaluarea unei expresii de la stânga la dreapta. Tipul şi
valoarea întregii expresii este dată de tipul şi valoarea expresiei2. Operatorul virgulă este
folosit în instrucţiunea for. Operatorul virgulă are cea mai mică prioritate.
Exemplu:
int x, c, y;
cout<<”Astept val. ptr. y:”; cin>>y;
x=(c=y, c<=5); /* c va primi valoarea lui y (citită); se verifică dacă c este
mai mic sau
egal cu 5. Daca nu, x=0; daca da, x=1 sau x=valoare diferită de zero)*/
x++, y--; //întâi este incrementat x, apoi este decrementat y
 Operatorul sizeof()

Este un operator unar, care are ca rezultat numărul de octeţi pe care este memorată
o dată de un anumit tip. Operandul este un tip sau o dată (constantă sau variabilă)
de un anumit tip.
Exemple:
cout<<sizeof(int); // afişează numărul de octeţi pe care este memorat
un întreg (2)
cout<<sizeof(”ab6*”);// afişează 5, nr. de octeţi pe care este memorată
constanta şir ”ab6*”

 Operatorul (tip)
 Este un operator unar care apare în construcţii numite ”cast” şi converteşte tipul
operandului său la tipul specificat între paranteze.
Exemple:
int a; (float) a;// converteşte operandul a (care era de tip întreg) în float

În afara operatorilor prezentaţi, există şi alţii, pe care îi vom enumera în continuare.

Despre aceşti operatori vom discuta în capitolele viitoare, când cunoştinţele acumulate
vor permite acest lucru.

 Operatorul unar *
Este operator unar, numit şi operator de deferenţiere. Se aplică unei expresii de tip
pointer şi este folosit pentru a accesa conţinutul unei zone de memorie spre care
pointează operatorul. Operatorii & (adresă) şi * sunt complementari.
Exemplu: Expresia *a este înlocuită cu valoarea de la adresa conţinută în variabila
pointer a.

 Operatorii paranteză
Parantezele rotunde ( ) se utilizează în expresii, pentru schimbarea ordinii de
efectuare a operaţiilor, sau la apelul funcţiilor. La apelul funcţiilor, parantezele
rotunde încadrează lista parametrilor efectivi. Din acest motiv, parantezele rotunde
sunt numite şi operatori de apel de funcţie.

 Operatorii de indexare
Operatorii de indexare sunt parantezele pătrate []. Acestea includ expresii întregi
care reprezintă indici ai unui tablou.

 Operatori de acces la membri structurilor

Operatorii ::, ., ->, .* şi ->* permit accesul la componentele unei structuri. Ei
vor fi studiaţi în capitolul 7.

2.2.7.EXPRESII

Prin combinarea operanzilor şi a operatorilor se obţin expresii. Tipul unei expresii este
dat de tipul rezultatului obţinut în urma evaluării acesteia. La evaluarea unei expresii se
aplică regulile de prioritate şi asociativitate a operatorilor din expresie. Ordinea de
aplicare a operatorilor poate fi schimbată prin folosirea parantezelor. La alcătuirea
expresiilor, este indicată evitarea expresiilor în care un operand apare de mai multe ori.

2.6.3. CONVERSII DE TIP

La evaluarea expresiilor, se realizează conversii ale tipului operanzilor. Conversiile sunt:
  Automate;
 Cerute de evaluarea expresiilor;
 Cerute de programator (prin construcţiile cast), explicite.

Conversiile automate sunt realizate de către compilator:

char, short int -> int
Ele sunt realizate de fiecare dată când într-o expresie apar operanzi de tipul char sau short
int.
Conversiile cerute de evaluarea expresiilor sunt efectuate în cazurile în care în expresii
apar operanzi de tipuri diferite. Înaintea aplicării operatorilor, se realizează conversia
unuia sau a ambilor operanzi:
 Dacă un operand este de tip long int, celălalt este convertit la acelaşi tip; tipul

expresiei este long int.

 Dacă un operand este de tipul double, celălalt este convertit la acelaşi tip; tipul

expresiei este double.

 Dacă un operand este de tipul float, celălalt este convertit la acelaşi tip; tipul

expresiei este float.

Conversiile explicite (cerute de programator) se realizează cu ajutorul construcţiilor
cast.
Exemplu:
int x=3; float y; y=(float)x/2;
Înainte de a se efectua împărţirea celor 2 operanzi, operandul x (întreg) este convertit în
număr real simplă precizie. După atribuire, valoarea lui y va fi 1.5. Dacă nu ar fi fost
folosit operatorul de conversie în expresia y=x / 2, operanzii x şi 2 fiind întregi, rezultatul
împărţirii este întreg, deci y ar fi avut valoarea 1.

2.3. Tipuri structurate de date (tablouri unidimensionale, bidimensionale)

Algoritmul proiectat pentru rezolvarea unei anumite probleme trebuie implementat

într-un limbaj de programare; prelucrarea datelor se realizează cu ajutorul
instrucţiunilor. Instrucţiunea descrie un proces de prelucrare pe care un calculator îl
poate executa. O instrucţiune este o construcţie validă (care respectă sintaxa limbajului)
urmată de ; . Ordinea în care se execută instrucţiunile unui program defineşte aşa-numita
structură de control a programului.
Limbajele moderne sunt alcătuite pe principiile programării structurate. Conform lui C.
Bohm şi G. Jacobini, orice algoritm poate fi realizat prin combinarea a trei structuri
fundamentale:
 structura secvenţială;

 structura alternativă (de decizie, de selecţie);

 structura repetitivă (ciclică).

IMPLEMENTAREA STRUCTURII SECVENŢIALE

Structura secvenţială este o înşiruire de secvenţe de prelucrare (instrucţiuni), plasate una

după alta, în ordinea în care se doreşte execuţia acestora.
Reprezentarea structurii secvenţiale cu
ajutorul schemei logice ( figura 3.1.): Reprezentarea structurii secvenţiale cu
ajutorul pseudocodului:
S1 instr1;
instr2;
. . . . .
S2

Sn

Figura 3.1. Schema logică pentru structura

secvenţială

Implementarea structurii secvenţiale se realizează cu ajutorul instrucţiunilor:

 Instrucţiunea vidă

Sintaxa: ;
Instrucţiunea vidă nu are nici un efect. Se utilizează în construcţii în care se cere prezenţa
unei instrucţiuni, dar nu se execută nimic (de obicei, în instrucţiunile repetitive).

IMPLEMENTAREA STRUCTURII DE DECIZIE (ALTERNATIVE, DE SELECŢIE)

Reprezentarea prin schemă logică şi prin pseudocod a structurilor de decizie şi repetitive

sunt descrise în capitolul 1. Se vor prezenta în continure doar instrucţiunile care le
implementează.
 Instrucţiunea if:
Sintaxa:
if (expresie)
instrucţiune1;
[ else
instrucţiune2; ]

Ramura else este opţională.

La întâlnirea instrucţiunii if, se evaluează expresie (care reprezintă o condiţie) din
paranteze. Dacă valoarea expresiei este 1 (condiţia este îndeplinită) se execută
instrucţiune1; dacă valoarea expresiei este 0 (condiţia nu este îndeplinită), se
execută instrucţiune2. Deci, la un moment dat, se execută doar una dintre cele două
instrucţiuni: fie instrucţiune1, fie instrucţiune2. După execuţia instrucţiunii if se trece la
execuţia instrucţiunii care urmează acesteia.

 Instrucţiunea switch
În unele cazuri este necesară o decizie multiplă specială. Instrucţiunea switch permite
acest lucru. Reprezentare prin pseudocod:
Reprezentare prin schema logică (figura 3.2):

test_expresie Dacă expresie=expr_const_1

instrucţiune1;
[ieşire;]
Altfel dacă
instrucţiune1 expresie=expr_const_2
break
instrucţiune2;
[ieşire;]
instrucţiune2
break
Altfel dacă
expresie=expr_const_n-1
instrucţiune_n instrucţiune_n-1;
[ieşire;]
Altfel instrucţiune_n;
Figura 3.2. Decizia multiplă
Se testează dacă valoarea pentru expresie este una dintre constantele specificate
(expr_const_1, expr_const_2, etc.) şi se execută instrucţiunea de pe ramura
corespunzătoare. În schema logică test_expresie este una din condiţiile:
expresie=expr_const_1, expresie=expr_const_2, etc.
Sintaxa:
switch (expresie)
{
case expresie_const_1: instructiune_1;
[break;]
case expresie_const_2: instructiune_2;
[break;]
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . .
case expresie_const_n-1: instructiune_n-1;
[break;]
[ default: instructiune_n; ]
}
Este evaluată expresie (expresie aritmetică), iar valoarea ei este comparată cu
valoarea expresiilor constante 1, 2, etc. (expresii constante=expresii care nu conţin
variabile). În situaţia în care valoarea expresie este egală cu valoarea
expr_const_k, se execută instrucţiunea corespunzătoare acelei ramuri
(instrucţiune_k). Dacă se întâlneşte instrucţiunea break, parcurgerea este
întreruptă, deci se va trece la execuţia primei instrucţiuni de după switch. Dacă nu este
întâlnită instrucţiunea break, parcurgerea continuă. Break-ul cauzează deci, ieşirea
imediată din switch.
În cazul în care valoarea expresiei nu este găsită printre valorile expresiilor constante, se
execută cazul marcat cu eticheta default (când acesta există). Expresiile expresie,
expresie_const_1, expresie_const_2,etc., trebuie să fie întregi. În
exemplul următor, ele sunt de tip char, dar o dată de tip char este convertită automat
în tipul int.
IMPLEMENTAREA STRUCTURILOR REPETITIVE (CICLICE)

Există două categorii de instrucţiuni ciclice: cu test iniţial şi cu test final.

Implementarea structurilor ciclice cu test iniţial

Structura ciclică cu test iniţial este implementată prin instrucţiunile while şi for.
 Instrucţiunea while

Sintaxa:
 while (expresie)
instructiune;

La întâlnirea acestei instrucţiuni, se evaluează expresie. Dacă aceasta are valoarea 1 -

sau diferită de 0 - (condiţie îndeplinită), se execută instrucţiune. Se revine apoi în
punctul în care se evaluează din nou valoarea expresiei. Dacă ea este tot 1, se repetă
instrucţiune, ş.a.m.d. Astfel, instrucţiunea (corpul ciclului) se repetă atât timp cât
expresie are valoarea 1. În momentul în care expresie ia valoarea 0 (condiţie
neîndeplinită), se iese din ciclu şi se trece la următoarea instrucţiune de după while.

Observaţii:
1. În cazul în care la prima evaluare a expresiei, aceasta are valoarea zero, corpul
instrucţiunii while nu va fi executat niciodată.
2. Instrucţiune din corpul ciclului while poate fi compusă (un bloc), sau o altă
instrucţiune ciclică.
3. Este de dorit ca instrucţiunea din corpul ciclului while să modifice valoarea
expresiei. Dacă nu se realizează acest lucru, corpul instrucţiunii while se repetă de un
număr infinit de ori.
Exemplu:
int a=7;
while (a==7)
cout<<”Buna ziua!\n”; // ciclu infinit; se repetă la infinit afişarea
mesajului

 Instrucţiunea for
În majoritatea limbajelor de programare de nivel înalt, instrucţiunea for implementează
structura ciclică cu număr cunoscut de paşi (vezi reprezentarea prin schema logică şi
pseudocod din capitolul 1). În limbajul C instrucţiunea for poate fi utilizată într-un mod
mult mai flexibil.
Reprezentare în pseudocod:
Reprezentare prin schema logică (figura 3.3.):

evaluare expresie1 (particular iniţializare contor) evaluare expresie1

CÂT TIMP expresie2
REPETĂ
0
expresie2 ÎNCEPUT
instrucţiune
1 evaluare
instrucţiune expresie3
SFÂRŞIT
evaluare expresie3 (particular
incrementare contor)

Figura 3.3. Structura ciclică cu test iniţial

Sintaxa:
for (expresie1; expresie2; expresie3)
instructiune;

Nu este obligatorie prezenţa expresiilor, ci doar a instrucţiunilor vide.

Implementarea structurilor ciclice cu test final

 Instrucţiunea do-while
Sintaxa:
do instructiune;
while(expresie);

Se execută instrucţiune. Se evaluează apoi expresie. Dacă aceasta are valoarea

1, se execută instrucţiune. Se testează din nou valoarea expresiei. Se repetă
instrucţiune cât timp valoarea expresiei este 1 (condiţia este îndeplinită). În cazul
instrucţiunii do-while, corpul ciclului se execută cel puţin o dată.

Tablouri unidimensionale şi bidimensionale

DECLARAREA TABOURILOR

Numim tablou o colecţie (grup, mulţime ordonată) de date, de acelaşi tip, situate într-o zonă de memorie continuă
(elementele tabloului se află la adrese succesive). Tablourile sunt variabile compuse (structurate), deoarece
grupează mai multe elemente. Variabilele tablou au nume, iar tipul tabloului este dat de tipul elementelor sale.
Elementele tabloului pot fi referite prin numele tabloului şi indicii (numere întregi) care reprezintă poziţia
elementului în cadrul tabloului.

În funcţie de numărul indicilor utilizaţi pentru a referi elementele tabloului, putem întâlni tablouri
unidimensionale (vectorii) sau multidimensionale (matricile sunt tablouri bidimensionale).

Ca şi variabilele simple, variabilele tablou trebuie declarate înainte de utilizare.

Modul de declarare:
tip nume_tablou[dim_1][dim_2]…[dim_n];
unde:tip reprezintă tipul elementelor tabloului; dim_1,dim_2,...,dim_n sunt numere întregi sau
expresii constante întregi (a căror valoare este evaluată la compilare) care reprezintă limitele superioare ale
indicilor tabloului.
Exemple:
//1
int vect[20]; // declararea tabloului vect, de maximum 20 de elemente, de tipul int.
// Se rezervă 20*sizeof(int)=20 * 2 = 40 octeţi
//2
double p,q,tab[10];
// declararea variabilelor simple p, q şi a vectorului tab, de maximum 10 elemente, tip double
//3
#define MAX 10
char tabc[MAX]; /*declararea tabloului tabc, de maximum MAX (10) elemente de tip
char*/
//4
double matrice[2][3]; // declararea tabloului matrice (bidimensional),
// maximum 2 linii şi maximum 3 coloane, tip double

TABLOURI UNIDIMENSIONALE

Tablourile unidimensionale sunt tablouri cu un singur indice (vectori). Dacă tabloul

conţine dim_1 elemente, indicii elementelor au valori întregi din intervalul [0,
dim_1-1].
La întâlnirea declaraţiei unei variabile tablou, compilatorul alocă o zonă de memorie
continuă (dată de produsul dintre dimensiunea maximă şi numărul de octeţi
corespunzător tipului tabloului) pentru păstrarea valorilor elementelor sale. Numele
tabloului poate fi utilizat în diferite expresii şi valoarea lui este chiar adresa de început a
zonei de memorie care i-a fost alocată. Un element al unui tablou poate fi utilizat ca orice
altă variabilă (în exemplul următor, atribuirea de valori elementelor tabloului vector).
Se pot efectua operaţii asupra fiecărui element al tabloului, nu asupra întregului tablou.

Exemplu:
// Declararea tabloului vector
vector
int vector[6];
100 vector[0]
// Iniţializarea elementelor tabloului 101
vector[0]=100; vector[1]
102 vector[2]
vector[1]=101;
vector[2]=102; 103
vector[3]
vector[3]=103; 104 vector[4]
vector[4]=104; 105 vector[5]
vector[5]=105;
Figura 4.1.
La declararea unui vector cu iniţializarea elementelor sale, numărul maxim de elemente
ale tabloului poate fi omis, caz în care compilatorul determină automat mărimea
tabloului, în funcţie de numărul elementelor iniţializate.
Exemplu:
char tab[]={ ’A’, ’C’, ’D’, ’C’};
tab ’B’ ’C’ ’D’
’A’
1
[0] [3]

float data[5]={ 1.2, 2.3, 3.4 };

data 1.2 2.3 3.4 ? ?

[0] [4]
Adresa elementului de indice i dintr-un tablou unidimensional poate fi calculată astfel:
adresa_elementului_i = adresa_de_bază + i∗
lungime_element

Exerciţii:
//1 Citirea elementelor unui vector:
double a[5];
int i;
for (i=0; i<5; i++)
{ cout<<”a["<<i<<”]=”; //afişarea unui mesaj prealabil citirii fiecărui
element
cin>>a[i]; //citirea valorii elementului de indice i
}
//Sau:
double a[20]; int i, n;
cout<<”Dim. Max. =”; cin>>n;
for (i=0; i<n; i++)
{ cout<<”a[“<<i<<”]=”;
cin>>a[i];
}
//2 Afişarea elementelor unui vector:
cout<<”Vectorul introdus este:\n”;
for (i=0; i<n i++)
cout<<a[i]<<’ ’;
//3 Afişarea elementelor unui vector în ordine inversă:
cout<<”Elementele vectorului în ordine inversă:\n”;
 for (i=n-1; i>=0 i++)
cout<<a[i]<<’ ’;
//3 Vectorul sumă (c) a vectorilor a şi b, cu acelaşi număr de elemente:
for (i=0; i<n i++)
c[i]=a[i]+b[i];
//4 Vectorul diferenţă (c) a vectorilor a şi b, cu acelaşi număr de elemente:
for (i=0; i<n i++)
c[i]=a[i] - b[i];
//5 Produsul scalar (p) a vectorilor a şi b, cu acelaşi număr de elemente:
n −1

p= ∑ai ∗bi double p=0;

i =0

for (i=0; i<n i++)

p += a[i] ∗ b[i];

TABLOURI BIDIMENSIONALE

Din punct de vedere conceptual, elementele unui tablou bidimensional sunt plasate în
spaţiu pe două direcţii. Matricea reprezintă o aplicaţie naturală a tablourilor
bidimensionale.
În matematică:
q 11 q 12 q 13 . . . q 1n
q 21 q 22 q 23 . . . q 2 n
Q= . . . . . . . . . . . . . . . . . . . . . . . . . . Q m×n
q m1 q m2 q m3 . . . q mn

În limbajele C/C++ (indicii de linie şi de coloană pornesc de la 0):

q 00 q 01 q 02 . . . q 0 ,n −1
q 10 q 11 q 12 . . . q 1,n −1 Q m×n
Q= . . . . . . . . . . . . . . . . . . . . . . . . . . . .
q m−1, 0 q m−1,1 q m−1,2 . . . q m−1,n −1

Exemplu:
double q[3][2]; // declararea matricii q, cu maxim3 linii şi 2 coloane, tip
double

În memorie, elementele unei matrici sunt memorate pe linii:

q 00 q 01 q 10 q 11 q 20 q 21 . . .
Dacă notăm cu k poziţia în memorie a unui element, valoarea lui k = i ∗ m + j (unde m
este numărul maxim de linii, i este indicele de linie, j este indicele de coloană).
. . . . . . q[0][n-1] q[1][0]
q[0][0] q[0][1] q[0][2] . . . . . .q[m-1][0] . . . q[m-1][n-1]
.
Dacă se doreşte iniţializarea elementelor unei matrici în momentul declarării acesteia, se
poate proceda astfel:
int mat[4][3] = {
{10, -50, 3},
{32, 20, 1},
{-1, 1, -2},
{7, -8, 19} };
Prin această construcţie, elementele matricii mat se iniţializează în modul următor:
mat[0][0]=10, mat[0][1]=-50, mat[0][2]=3
mat[1][0]=32, mat[1][1]=20, mat[1][2]=1
mat[2][0]=-1, mat[2][1]=1, mat[2][2]=-2
mat[3][0]=7, mat[3][1]=-8, mat[3][2]=19

La declararea unei matrici şi iniţializarea elementelor sale, se poate omite numărul

maxim de linii, în schimb, datorită modului de memorare, trebuie specificat numărul
maxim de coloane:
int mat[][3] = {
{10, -5, 3},
{32, 20, 1},
{-1, 1, -2},
{7, -8, 9} };
Construcţia are acelaşi efect ca precedenta.
int mat[][3] = {
{1, 1},
{ -1},
{3, 2, 1}};
mat reprezintă o matrice 3 ∗ 3, ale cărei elemente se iniţializează astfel:
mat[0][0]=1, mat[0][1]=1, mat[1][0]=-1, mat[2][0]=3, mat[2][1]=2, mat[2][2]=1
Elementele mat[0][2], mat[1][1], mat[1][2] nu sunt initalizate. Ele au valoarea zero dacă
tabloul este global şi valori iniţiale nedefinite dacă tabloul este automatic.

Construcţiile utilizate la iniţializarea tablourilor bidimensionale se extind pentru tablouri

multidimensionale, cu mai mult de doi indici.
Exemplu:
int a[2][2][3]={
{ {10, 20}, {1, -1}, {3, 4}},
{ {20, 30}, {50, -40}, {11, 12}}
};
Exerciţiu: Să se citească de la tastatură elementele unei matrici de maxim 10 linii şi 10
coloane. Să se afişeze matricea citită.
#include <iostream.h>
void main(void)
{int A[10][10]; int nr_lin, nr_col; cout<<"Nr. linii:";
cin>>nr_lin;
cout<<"Nr. coloane:"; cin>>nr_col;int i, j;
//citirea elementelor unei matrici
for (i=0; i<nr_lin; i++)
for (j=0; j<nr_col; j++) {
cout<<"A["<<i<<","<<j<<"]="; //afişarea unui mesaj
prealabil citirii
cin>>A[i][j];
}
//afişarea elementelor matricii
for (i=0; i<nr_lin; i++) {
for (j=0; j<nr_col; j++)
cout<<A[i][j]<<'\t';
cout<<'\n'; // după afişarea elementelor unei linii, se trece pe linia
următoare
}
}
ŞIRURI DE CARACTERE

Şirurile de caractere sunt tablouri de caractere, care au ca ultim element un terminator de

şir, caracterul null (zero ASCII), ’\0’.
Exemplu:
char tc[5] = {’a’, ’b’, ’c’, ’d’, ’e’}; // tablou de
caractere
char sc[5] = {’a’, ’b’, ’c’, ’d’, ’\0’}; // şirul de caractere
cu elementele abcd
Limbajul C/C++ permite iniţializarea unui tablou de caractere printr-o constantă şir (şir
între ghilimele), care include automat caracterul null. Deci ultima iniţializare este
echivalentă cu:
char sc[5] = ”abcd”; //sau cu
char sc[] = ”abcd”;

FUNCŢII PENTRU OPERAŢII CU ŞIRURI DE CARACTERE

Funcţiile pentru operaţii cu şiruri se găsesc în header-ul <string.h>.

 strlen (nume_şir)
Returnează un număr întreg ce reprezintă lungimea unui şir de caractere, fără a număra
terminatorul de şir.

strcmp (şir_1, şir_2)

Funcţia compară cele două şiruri date ca argument şi returnează o valoare întreagă egală
diferenţa dintre codurile ASCII ale primelor caractere care nu coincid.

strcpy (şir_destinaţie, şir_sursă)

Funcţia copie şirul sursă în şirul destinaţie. Pentru a fi posibilă copierea, lungimea şirului
destinaţie trebuie să fie mai mare sau egală cu cea a şirului sursă, altfel pot apare erori
grave.

strcat (şir_destinaţie, şir_sursă)

Funcţia concatenează cele două şiruri: şirul sursă este adăugat la sfârşitul şirului
destinaţie. Tabloul care conţine şirul destinaţie trebuie să aibă suficiente elemente.

2.4. Implementarea funcţiilor în C/C++.

STRUCTURA UNEI FUNCŢII

Un program scris în limbajul C/C++ este un ansamblu de funcţii, fiecare dintre acestea
efectuând o activitate bine definită. Din punct de vedere conceptual, funcţia reprezintă o
aplicaţie definită pe o mulţime D (D=mulţimea, domeniul de definiţie), cu valori în
mulţimea C (C=mulţimea de valori, codomeniul), care îndeplineşte condiţia că oricărui
element din D îi corespunde un unic element din C.

Funcţiile comunică prin argumennte: ele primesc ca parametri (argumente) datele de

intrare, efectuează prelucrările descrise în corpul funcţiei asupra acestora şi pot returna o
valoare (rezultatul, datele de ieşire). Execuţia programului începe cu funcţia principală,
numită main. Funcţiile pot fi descrise în cadrul aceluiaşi fişier, sau în fişiere diferite,
care sunt testate şi compilate separat, asamblarea lor realizându-se cu ajutorul
linkeditorului de legături.
O funcţie este formata din antet si corp:
antet_funcţie
{
corpul_funcţiei
}
Sau:
tip_val_return nume_func (lista_declaraţiilor_param_
formali)
{
declaraţii_variabile_locale
instrucţiuni
return valoare
}
Prima linie reprezintă antetul funcţiei, în care se indică: tipul funcţiei, numele acesteia şi
lista declaraţiilor parametrilor formali. La fel ca un operand sau o expresie, o funcţie are
un tip, care este dat de tipul valorii returnate de funcţie în funcţia apelantă. Dacă funcţia
nu întoarce nici o valoare, în locul tip_vali_return se specifică void. Dacă
tip_val_return lipseşte, se consideră, implicit, că acesta este int. Nume_funcţie este un
identificator.
Lista_declaraţiilor_param_formali (încadrată între paranteze rotunde) constă într-o listă
(enumerare) care conţine tipul şi identificatorul fiecărui parametru de intrare, despărţite
prin virgulă. Tipul unui parametru poate fi oricare, chiar şi tipul pointer. Dacă lista
parametrilor formali este vidă, în antet, după numele funcţiei, apar doar parantezele ( ),
sau (void).

Corpul funcţiei este un bloc, care implementează algoritmul de calcul folosit de către
funcţie. În corpul funcţiei apar (în orice ordine) declaraţii pentru variabilele locale şi
instrucţiuni. Dacă funcţia întoarce o valoare, se foloseşte instrucţiunea return
valoare. La execuţie, la întâlnirea acestei instrucţiuni, se revine în funcţia apelantă.
În limbajul C/C++ se utilizează declaraţii şi definiţii de funcţii.
Declaraţia conţine antetul funcţiei şi informează compilatorul asupra tipului, numelui
funcţiei şi a listei parametrilor formali (în care se poate indica doar tipul parametrilor
formali, nu şi numele acestora). Declaraţiile de funcţii se numesc prototipuri, şi sunt
constituite din antetul funcţiei, din care pot lipsi numele parametrilor formali.
Definiţia conţine antetul funcţiei şi corpul acesteia. Nu este admisă definirea unei funcţii
în corpul altei funcţii.

O formă învechită a antetului unei funcţii este aceea de a specifica în lista parametrilor
formali doar numele acestora, nu şi tipul. Această libertate în omiterea tipului
parametrilor constituie o sursă de erori.
tipul_valorii_returnate nume_funcţie (lista_parametrilor_
formali)
declararea_parametrilor_formali
{
declaraţii_variabile_locale
instrucţiuni
return valoare
}

APELUL ŞI PROTOTIPUL FUNCŢIILOR

O funcţie poate fi apelată printr-o construcţie urmată de punct şi virgulă, numită

instrucţiune de apel, de forma:
nume_funcţie (lista_parametrilor_efectivi);
Parametrii efectivi trebuie să corespundă cu cei formali ca ordine şi tip. La apel, se
atribuie parametrilor formali valorile parametrilor efectivi, după care se execută
instrucţiunile din corpul funcţiei. La revenirea din funcţie, controlul este redat funcţiei
apelante, şi execuţia continuă cu instrucţiunea următoare instrucţiunii de apel, din funcţia
apelantă. O altă posibilitate de a apela o funcţie este aceea în care apelul funcţiei
constituie operandul unei expresii. Acest lucru este posibil doar în cazul în care funcţia
returnează o valoare, folosită în calculul expresiei.

Parametrii declaraţi în antetul unei funcţii sunt numiţi formali, pentru a sublinia faptul că
ei nu reprezintă valori concrete, ci numai ţin locul acestora pentru a putea exprima
procesul de calcul realizat prin funcţie. Ei se concretizează la execuţie prin apelurile
funcţiei.
Parametrii folosiţi la apelul unei funcţii sunt parametri reali, efectivi, concreţi, iar
valorile lor vor fi atribuite parametrilor formali, la execuţie. Utilizarea parametrilor
formali la implementarea funcţiilor şi atribuirea de valori concrete pentru ei, la execuţie,
reprezintă un prim nivel de abstractizare în programare. Acest mod de programare se
numeşte programare procedurală şi realizează un proces de abstractizare prin
parametri.

Variabilele declarate în interiorul unei funcţii, cât şi parametrii formali ai acesteia nu pot
fi accesaţi decât în interiorul acesteia. Aceste variabile sunt numite variabile locale şi nu
pot fi accesate din alte funcţii. Domeniul de vizibilitate a unei variabile este porţiunea de
cod la a cărei execuţie variabila respectivă este accesibilă. Deci, domeniul de vizibilitate
a unei variabile locale este funcţia în care ea a fost definită (vezi şi paragraful 6.8.).
Exemplu:
 int f1(void)
{ double a,b; int c;
. . .
return c; // a, b, c - variabile locale, vizibile doar în corpul funcţiei
}
void main()
{ . . . . . . // variabile a şi b nu sunt accesibile în main()
}
Dacă în interiorul unei funcţii există instrucţiuni compuse (blocuri) care conţin declaraţii
de variabile, aceste variabile nu sunt vizibile în afara blocului.
Exemplu:
void main()
{ int a=1, b=2;
cout << "a=”<<a<<” b=”<<b<<” c=”<<c’\n’; // a=1 b=2, c
nedeclarat
. . . . . . . .
{ int a=5; b=6; int c=9;
cout << "a=”<<a<<” b=”<<b<<’\n’; // a=5 b=6 c=9
. . . . . . . .
}
cout << "a=”<<a<<” b=”<<b<<” c=”<<c’\n’; // a=1 b=6, c
nedeclarat
. . . . . . . . . . . .
}

TRANSFERUL PARAMETRILOR UNEI FUNCŢII

Funcţiile comunică între ele prin argumente (parametrii).

Există următoarele moduri de transfer (transmitere) a parametrilor către funcţiile apelate:

 Transfer prin valoare;
 Transfer prin pointeri;
 Transfer prin referinţă.

TRANFERUL PARAMETRILOR PRIN VALOARE

În exemplele anterioare, parametrii de la funcţia apelantă la funcţia apelată au fost

transmişi prin valoare. De la programul apelant către funcţia apelată, prin apel, se
transmit valorile partametrilor efectivi, reali. Aceste valori vor fi atribuite, la apel,
parametrilor formali. Deci procedeul de transmitere a parametrilor prin valoare constă în
încărcarea valorii parametrilor efectivi în zona de memorie a parametrilor formali (în
stivă). La apelul unei funcţii, parametrii reali trebuie să corespundă - ca ordine şi tip - cu
cei formali.

Exerciţiu: Să se scrie următorul program (care ilustrează legătura dintre pointeri şi

vectori) şi să se urmărească rezultatele execuţiei acestuia.
void f1(float intr,int nr)// intr, nr - parametri formali
{
for (int i=0; i<nr;i++) intr *= 2.0;
cout<<”Val. Param. intr=”<<intr<<’\n’;// intr=12
}
void main()
{
float data=1.5; f1(data,3);
// apelul funcţiei f1; data, 3 sunt parametri efectivi
cout<<”data=”<<data<<’\n’;
// data=1.5 (nemodificat)
}

Fiecare argument efectiv utilizat la apelul funcţiei este evaluat, iar valoarea este atribuită
parametrului formal corespunzător. În interiorul funcţiei, o copie locală a acestei valori va
fi memorată în parametrul formal. O modificare a valorii parametrului formal în
interiorul funcţiei (printr-o operaţie din corpul funcţiei), nu va modifica valoarea
parametrului efectiv, ci doar valoarea parametrului formal, deci a copiei locale a
parametrului efectiv (figura 6.1.). Faptul că variabila din programul apelant (parametrul
efectiv) şi parametrul formal sunt obiecte distincte, poate constitui un mijloc util de
protecţie. Astfel, în funcţia f1, valoarea parametrului formal intr este modificată
(alterată) prin instrucţiunea ciclică for. În schimb, valoarea parametrului efectiv (data) din
funcţia apelantă, rămâne nemodificată.
În cazul transmiterii parametrilor prin valoare, parametrii efectivi pot fi chiar expresii.
Acestea sunt evaluate, iar valoarea lor va iniţializa, la apel, parametrii formali.
Exemplu:
double psi(int a, double b)
{
if (a > 0) return a*b*2;
else return -a+3*b; }
void main()
{ int x=4; double y=12.6, z; z=psi ( 3*x+9, y-5) + 28;
cout<<”z=”<<z<<’\n’; }
Transferul valorii este însoţit de eventuale conversii de tip. Aceste conversii sunt realizate
automat de compilator, în urma verificării apelului de funcţie, pe baza informaţiilor
despre funcţie, sau sunt conversii explicite, specificate de programator, prin operatorul
”cast”.
Exemplu:
float f1(double, int);
void main()
{
int a, b; float g=f1(a, b); // conversie automată: int a -> double a
float h=f1( (double) a, b); // conversie explicită
}

Limbajul C este numit limbajul apelului prin valoare, deoarece, de fiecare dată când o
funcţie transmite argumente unei funcţii apelate, este transmisă, de fapt, o copie a
parametrilor efectivi. În acest mod, dacă valoarea parametrilor formali (iniţializaţi cu
valorile parametrilor efectivi) se modifică în interiorul funcţiei apelate, valorile
parametrilor efectivi din funcţia apelantă nu vor fi afectate.

TRANSFERUL PARAMETRILOR PRIN POINTERI

În unele cazuri, parametrii transmişi unei funcţii pot fi pointeri (variabile care conţin
adrese). În aceste cazuri, parametrii formali ai funcţiei apelate vor fi iniţializaţi cu
valorile parametrilor efectivi, deci cu valorile unor adrese. Astfel, funcţia apelată poate
modifica conţinutul locaţiilor spre care pointează argumentele (pointerii).

Funcţii care returnează pointeri

Valoarea returnată de o funcţie poate fi pointer, aşa cum se observă în exemplul următor:
Exemplu:
#include <iostream.h>
double *f (double *w, int k)
{ // w conţine adr. de început a vectorului a
cout<<"w="<<w<<" *w="<<*w<<'\n'; // w= adr. lui a ;*w = a[0]=10
return w+=k;
/*incrementeaza pointerului w cu 2(val. lui k); deci w pointează către elementul de
indice 2 din vectorul a*/
}
void main()
{double a[10]={10,1,2,3,4,5,6,7,8,9}; int i=2;
cout<<"Adr. lui a este:"<<a;
 double *pa=a; // double *pa; pa=a;
cout<<"pa="<<pa<<'\n' // pointerul pa conţine adresa de început a tabloului
a
// a[i] = * (a + i)
// &a[i] = a + i
pa=f(a,i); cout<<"pa="<<pa<<" *pa="<<*pa<<'\n';
// pa conţine adr. lui a[2], adica adr. a + 2 * sizeof(double);
*pa=2;
}

TRANSFERUL PARAMETRILOR PRIN REFERINŢĂ

În acest mod de transmitere a parametrilor, unui parametru formal i se poate asocia

(atribui) chiar obiectul parametrului efectiv. Astfel, parametrul efectiv poate fi modificat
direct prin operaţiile din corpul funcţiei apelate.

În exemplul următor definim variabila br, variabilă referinţă către variabila b.

Variabilele b şi br se găsesc, în memorie, la aceeaşi adresă şi sunt variabile sinonime.

Exemplu:
b, br 7 12
#include <stdio.h>
#include <iostream.h>
void main() c 12
{
int b,c; Figura 6.4. Variabilele referinţă b, br
int &br=b; //br referinţă la altă variabilă (b)
br=7;
cout<<"b="<<b<<'\n'; //b=7
cout<<"br="<<br<<'\n'; //br=7
cout<<"Adr. br este:"<<&br; //Adr. br este:0xfff4
printf("Adr. b este:"<<&b<<'\n'; //Adr. b este:0xfff4
b=12; cout<<"br="<<br<<'\n'; //br=12
cout<<"b="<<b<<'\n'; //b=12
c=br; cout<<"c="<<c<<'\n'; //c=12
}

Comparând cele trei moduri de transmitere a parametrilor către o funcţie, se poate

observa:
1. La apelul prin valoare transferul datelor este unidirecţional, adică valorile se transferă
numai de la funcţia apelantă către cea apelată. La apelul prin referinţă transferul
datelor este bidirecţional, deoarece o modificare a parametrilor formali determină
modificarea parametrilor efectivi, care sunt sinonime (au nume diferite, dar referă
aceleaşi locaţii de memorie).
2. La transmiterea parametrilor prin valoare, ca parametrii efectivi pot apare expresii sau
nume de variabile. La transmiterea parametrilor prin referinţă, ca parametri efectivi nu
pot apare expresii, ci doar nume de variabile. La transmiterea parametrilor prin
pointeri, ca parametri efectivi pot apare expresii de pointeri.
3. Transmiterea parametrilor unei funcţii prin referinţă este specifică limbajului C++.
4. Limbajul C este numit limbajul apelului prin valoare. Apelul poate deveni, însă, apel
prin referinţă în cazul variabilelor simple, folosind pointeri, sau aşa cum vom vedea în
paragraful 6.4., în cazul în care parametru efectiv este un tablou.
5. În limbajul C++ se poate alege, pentru fiecare parametru, tipul de apel: prin valoare
sau prin referinţă, aşa cum ilustrează exemplele următoare:

2.5. Liste, stive şi cozi (reprezentarea grafică, operaţii specifice).

Liste liniare, Stive, Cozi, Arbori, Arbori binari
LISTE LINIARE
O lista liniara este o colectie de n noduri unde n>=0, ce poate fi si vida.
Listele se pot aloca dinamic sau secvential.
struct nod
{ int info:
nod *adr_urm;
} *v, *sf;

STIVE
O stiva este o structura liniara deschisa ale carei extremitati se numesc baza si varf si in
care accesul se face la un singur capat, si anume la varful stivei.
Stiva functioneaza pe principiul LIFO (Last In First Out).
Alocarea dinamica a stivei necesita cunoasterea in orice moment a pointerului pentru
varful stivei. Daca stiva este vida varful coincide cu baza si vor avea aceeasi adresa, si
anume constanta Null.
struct nod
{ int info;
nod *adr_inapoi;
} nod *v;

COADA
O coada este o lista liniara deschisa la care operatiile au loc la ambele capete.
Coada functioneaza pe principiul FIFO (First In First Out)
struct nod
{ int info;
nod *adr_urm;
} *v, *sf;

Cozi şi stive
1. Noţiuni generale

Cozile şi stivele sunt structuri de date logice (implementarea este făcută

utilizând alte structuri de date) şi omogene (toate elementele sunt de acelaşi tip).
Ambele structuri au două operaţii de bază: adăugarea şi extragerea unui element. În
afara acestor operaţii se pot implementa şi alte operaţii utile: test de structură vidă,
obţinerea primului element fără extragerea acestuia, … Diferenţa fundamentală între
cele două structuri este disciplina de acces. Stiva foloseşte o disciplină de acces de tip
LIFO (Last In First Out), iar coada o disciplină de tip FIFO (First In First Out).
2. Moduri de implementare
Stivele şi cozile pot fi implementate în mai multe moduri. Cele mai utilizate
implementări sunt cele folosind masive şi liste. Ambele abordări au avantaje şi
dezavantaje:
Avantaje Dezavantaje
Masive • implementare simplă
• consum redus de memorie
• viteză mare pentru operaţii
• numărul de elemente este
limitat
• risipă de memorie în cazul în
care dimensiunea alocată
este mult mai mare decât
numărul efectiv de elemente
Liste • număr oarecare de elemente • consum mare de memorie
pentru memorarea legăturilor
Pentru implementarea unei stive folosind masive avem nevoie de un masiv V
de dimensiune n pentru memorarea elementelor. Ultimul element al masivului va fi
utilizat pentru memorarea numărului de elemente ale stivei.
În cazul în care stiva este vidă, atunci elementul Vn-1 va avea valoarea 0.
Folosind această reprezentare, operaţiile de bază se pot implementa în timp constant
(O(1)). Algoritmii pentru implementarea operaţiilor de bază (în pseudocod) sunt:
adaugare(elem, V, n)
if v[n-1] = n-1 //verificam dacă stiva nu e plină
return "stiva plina"
v[v[n-1]] = elem //adaugăm elementul în masiv
v[n-1] = v[n-1] + 1 //incrementăm numărul de elemente
return "succes"
stergere(V, n)
if v[n-1] = 0 //verificam dacă stiva nu e goală
return "stiva goala"
elem = v[v[n-1] - 1] //extragem elementul din masiv
v[n-1] = v[n-1] + 1 //decrementăm numărul de elemente
return elem
Coada se poate implementa folosind un vector circular de dimensiune n (după
elementul n-4 urmează elementul 0). Ultimele două elemente conţin indicii de start şi
sfârşit ai cozii, iar antepenultimul element este un marcaj folosit pentru a putea
diferenţia cazurile de coadă goală şi coadă plină.
Algoritmii care implementează operaţiile de bază pentru o coadă memorată in
forma prezentată sunt:
adaugare(elem, V, n)
v[n-2] = (v[n-2] + 1) mod (n-2) //deplasăm capul cozii
if v[n-1] = v[n-2] //verificare coada plină
return "coada plina"
V[V[n-1]] = elem //adăugăm elementul
return "succes"
stergere(V,n)
if v[n-1] = v[n-2] //verificare coadă goală
return "coada goala"
v[n-1] = (v[n-1] + 1) mod (n-2) //deplasăm indicele de sfârşit
return V[V[n-1]] //întoarcem elementul
Cea de-a doua modalitate de implementare a stivelor şi cozilor este cea
folosind liste alocate dinamic.
În cazul stivei, vom folosi o listă simplu înlănţuită organizată ca în figura
următoare: Fiecare nod este format din informaţiile utile şi o legătură către elementul
următor. Tipul informaţiilor stocate în stivă este indicat de utilizator prin definirea
tipului TipStiva. Stiva vidă este reprezentată printr-un pointer nul. Elementele sunt
adăugate înaintea primului element (cu deplasarea varfului stivei). Extragerea se face
tot din vărful stivei.

2.6. Grafuri (orientate şi neorientare). Definire, parcurgere, operaţii.

Grafurile
Graf orientat
Un graf orientat reprezinta o pereche ordonata de multimi G=(X,U), unde X este
o multime finita si nevida, numita multimea nodurilor, si U este o multime formata
din perechi ordonate de elemente ale lui X, numita multimea arcelor.

Exemplu

In graful din fig. 1 multimea nodurilor este X={1, 2, 3, 4, 5, 6, 7} si multimea

arcelor este U={u1, u2, u3, u4, u5, u6, u7, u8, u9, u10}={(1,2), (2,3), (3,4), (4,1), (3,5),
(5,3), (5,6), (6,7), (7,6), (7,5)}.
Conexitate in grafuri orientate

Un graf G este conex, daca oricare ar fi doua varfuri ale sale, exista un lant care
le leaga.
Un lant intr-un graf orientat este un sir de arce {u1, u 2, u3 , …, un} cu proprietatea ca
oricare doua arce consecutive au o extremitate comuna. Altfel spus, un lant este
un traseu care uneste prin arce doua noduri numite extremitatile lantului, fara a
tine cont de orientarea arcelor componente.

Exemplu

Graful este conex pentru ca oricum am lua doua noduri putem ajunge de la unul
la celalalt pe un traseu de tip lant. De exemplu, de la nodul 4 la nodul 2 putem
ajunge pe traseul de noduri (4,3,2) stabilind astfel lantul {u5, u3}, dar si pe traseul
de noduri (4,1,2) stabilind lantul {u6, u2}
 Acest graf nu este conex.
Luand submultimea de noduri {1,2,3}, putem spune ca intre oricare doua noduri
din aceasta submultime exista cel putin un lant., de exemplu lantul {u1, u2} sau
{u3, u1}. La fel stau lucrurile cu submultimea de noduri {4,5,6}. Dar nu ptuem gasi
un lant intre un nod din prima submultime si un nod din a doua submultime.
Plecand dintr-un nod al primei submultimi si deplasandu-ne pe arce, nu avem
cum sa trecem in a doua submultime pentru ca nu exista nici un arc direct care
sa lege cele doua submultimi. De exemplu plecand din nodul 1 putem ajunge in
nodul 2 pe traseul {u3, u2}, dar de aici nu putem ajunge mai departe in nodul 4,
deci nu exista lant de la 2 la 4.
Componenta conexa
Componenta conexa a unui graf G=(X, U), reprezinta un subgraf G1=(X1, U1)
conex, a lui G, cu proprietatea ca nu exista nici un lant care sa lege un nod din X
1 cu un nod din X-X 1 (pentru orice nod, nu exista un lant intre acel nod si nodurile
care nu fac parte din subgraf).

De exemplu graful din fig. 3 nu este conex , insa in el distingem doua

componente conexe: G1 =(X1, U1), unde X1={1,2,3} si U1={u1, u2, u3}; si G2=(X2,
U2), unde X2={4,5,6} si U2={u4, u5}.

Graf tare conex

Graful tare conex este un graf orientat G=(X, U), daca pentru oricare doua noduri
x si y apartin lui X, exista un drum de la x la y precum si un drum de la y la x.

Exemplu

Graful cu n=3 din fig. 4 este tare conex.

Pentru a demonstra acest lucru, formam toate perechile posibile de noduri
distincte (x, y) cu x, y apartin multimii {1,2,3}, si pentru fiecare astfel de pereche
cautam un drum de la x la y si un drum de la y la x.
 x=1, y=2
De la 1 la 2 – drumul [1,3,2], pe arcele (1,3) si (3,2);
De la 2 la 1 – drumul [2,3,1], pe arcele (2,3) si (3,1).
x=1, y=3
De la 1 la 3 – drumul [1,2,3], pe arcele (1,2) si (2,3);
De la 3 la 1 – drumul [3,2,1], pe arcele (3,2) si (2,1).
x=2, y=3
De la 2 la 3 – drumul [2,1,3], pe arcele (2,1) si (1,3);
De la 3 la 2 – drumul [3,1,2], pe arcele (3,1) si (1,2).

Componenta tare conexa

Un subgraf se obtine dintr-un graf G= (X, U) eliminand niste varfuri si pastrand
doar acele muchii care au ambele extremitati in multimea varfurilor ramase.
Fie un subgraf tare conex G1=(X1, U1) al grafului G=(X, U). Adaugam la subgraf
un nod x care nu face parte din multimea nodurilor sale (x apartine X-X1).
Obtinem astfel multimea de varfuri X1 reunit cu {x}. Subgraful indus pe multimea
X1 reunit cu {x} se obtine luand si arcele care trec prin nodul x.

Daca acest subgrafnu mai este tare conex, atunci el se numeste componenta
tare conexa.

Exemplu
Acesta este graful G=(X,U) tare conex.
Din el eliminam nodul 4.

Am obtinut astfel subgraful tare conex G1=(X1, U1).

Acestui graf ii adaugam un nod x care nu face parte din multimea nodurilor
subgrafului G1.
Graful obtinut este componenta tare conexa.
Problema
Stabiliti daca graful de mai jos este sau nu conex.
X= {1, 2, 3, 4, 5};
U= {u1, u2, u3, u4, u5, u6, u7, u8, u9, u10, u11, u12, u13, u14, u15, u16}={(1,2), (2,1), (3,2),
(2,3), (4,3), (3,4), (1,4), (4,1), (2,5), (5,2), (3,5), (5,3), (4,5), (5,4), (1,5), (5,1)}.

De la 1 la 2 – pe drumul [1,5,2] sau [1,5,4,3,2], etc.

De la 1 la 3 – pe drumul [1,5,3] sau [1,5,2,3], etc.
De la 1 la 4 – pe drumul [1,5,4] sau [1,5,2,3,4], etc.
De la 1 la 5 – pe drumul [1,2,5] sau [1,4,5], etc.

De la 2 la 3 – pe drumul [2,5,3] sau [2,1,5,3],etc.

De la 2 la 4 – pe drumul [2,5,4] sau [2,3,5,4], etc.
De la 2 la 5 – pe drumul [2,1,5] sau [2,3,5], etc.

De la 3 la 4 – pe drumul [ 3,5,4] sau [3,2,5,4], etc.

De la 3 la 5 – pe drumul [3,2,5] sau [3,4,5], etc.
De la 4 la 5 – pe drumul [4,1,5] sau [4,3,5], etc.

Grafuri neorientate
Graf = orice mulţime finită V prevăzută cu o relaţie binară internă E.
Notăm graful cu G=(V, E).

Graf neorientat = un graf G=(V, E) în care relaţia binară este

simetrică: (v,w)∈E atunci (w,v) ∈E.

Nod = element al mulţimii V, unde G=(V, E) este un graf neorientat.

Muchie = element al mulţimii E ce descrie o relaţie existentă între

două vârfuri din V, unde G=(V, E) este un graf neorientat;

1 6
In figura alaturata:
V={1,2,3,4,5,6} sunt noduri
5 E={[1,2], [1,4], [2,3],[3,4],[3,5]} sunt muchii
2
G=(V, E)=({1,2,3,4,5,6}, {[1,2], [1,4], [2,3],[3,4],[3,5]})
3 4

Adiacenta: Într-un graf neorientat existenţa muchiei (v,w) presupune

că w este adiacent cu v şi v adiacent cu w.
În exemplul din figura de mai sus vârful 1 este adiacent cu 4 dar 1 şi 3
nu reprezintă o pereche de vârfuri adiacente.

Incidenţă = o muchie este incidentă cu un nod dacă îl are pe acesta

ca extremitate. Muchia (v,w) este incidentă în nodul v respectiv w.

Grad = Gradul unui nod v, dintr-un graf neorientat, este un număr

natural ce reprezintă numărul de noduri adiacente cu acesta (sau
numarul de muchii incidente cu nodul respectiv)

Nod izolat = Un nod cu gradul 0.

Nod terminal= un nod cu gradul 1

1 6 Nodul 5 este terminal (gradul

1).
5
2
Nodul 6 este izolat (gradul 0)
3 4
 Nodurile 1, 2, 4 au gradele
egale cu 2.
Lanţ = este o secvenţă de noduri ale unui graf neorientat G=(V,E), cu
proprietatea că oricare două noduri consecutive din lant sunt
adiacente:
L=[w1, w2, w3,. . ,wn] cu proprietatea că (wi, wi+1)∈E pentru
1≤ i<n.

Lungimea unui lanţ = numărul de muchii din care este format.

Lanţ simplu = lanţul care conţine numai muchii distincte

Lanţ compus= lanţul care nu este format numai din muchii distincte

Lanţ elementar = lanţul care conţine numai noduri distincte

Ciclu = Un lanţ în care primul nod coincide cu ultimul.

Ciclul este elementar dacă este format doar din noduri distincte,
excepţie făcând primul şi ultimul. Lungimea unui ciclu nu poate fi 2.
Succesiunea de vârfuri 2, 3,
1 6 5, 6 reprezintă un lanţ simplu
şi elementar de lungime 3.
5
2 Lanţul 5 3 4 5 6 este simplu
3 4 dar nu este elementar.
Lanţul 5 3 4 5 3 2 este
compus şi nu este elementar.
Lanţul 3 4 5 3 reprezintă un
ciclu elementar

Graf partial = Dacă dintr-un graf G=(V,E) se suprimă cel puţin o

muchie atunci noul graf G’=(V,E’), E’⊂ E se numeşte graf parţial al
lui G.

1 6 1 6

5 5
2 2

3 4 3 4
 G G1 este graf partial al lui
G

Subgraf = Dacă dintr-un graf G=(V,E) se suprimă cel puţin un nod

împreună cu muchiile incidente lui, atunci noul graf G’=(V’,E’), E’⊂
E si V’⊂ V se numeşte subgraf al lui G.
1 6 6

5 5
2 2

3 4 3

G G1 este graf
partial al lui G

Graf regulat = graf neorientat în care toate nodurile au acelaşi grad;

1 6

5
2

3 4

Graf complet = graf neorientat G=(V,E) în care există muchie între

oricare două noduri.
Numărul de muchii ale unui graf complet este: nr*(nr-1)/2.Unde nr
este numarul de noduri
1

3 4
graf complet. Nr de noduri: 4x(4-1)/2 = 6
Graf conex = graf neorientat G=(V,E) în care pentru orice pereche de
noduri (v,w) există un lanţ care le uneşte.
1 6 1 6

5 5
2 2

3 4 3 4
graf conex nu este graf conex
Componentă conexă = subgraf al grafului de referinţă, maximal în
raport cu proprietatea de conexitate (între oricare două vârfuri există
lanţ);

1 6

5
2

3 4
graful nu este conex. Are 2 componente conexe:
1, 2 si 3, 4, 5, 6
Lanţ hamiltonian = un lanţ elementar care conţine toate nodurile
unui graf

1 6

5
2

3 4
L=[2 ,1, 6, 5, 4, 3] este lant hamiltonian
Ciclu hamiltonian = un ciclu elementar care conţine toate nodurile
grafului

1 6

5
2

3 4
C=[1,2,3,4,5,6,1] este ciclu hamiltonian

Graf hamiltonian = un graf G care conţine un ciclu hamiltonian

Graful anterior este graf Hamiltonian.

Lanţ eulerian = un lanţ simplu care conţine toate muchiile unui graf
 1 6

5
2

3 4

Lantul: L=[1.2.3.4.5.3.6.2.5.6] este lant eulerian

Ciclu eulerian = un ciclu simplu care conţine toate muchiile grafului

Ciclul: C=[1.2.3.4.5.3.6.2.5.6.1] este ciclu eulerian

Graf eulerian = un graf care conţine un ciclu eulerian.

Condiţie necesară şi suficientă: Un graf este eulerian dacă şi numai

dacă oricare vârf al său are gradul par.

Reprezentarea grafurilor neorientate

Fie G=(V, E) un graf neorientat.
Exista mai multe modalitati de reprezentare pentru un graf neorientat, folosind
diverse tipuri de structuri de date. Reprezentarile vor fi utilizate in diversi algoritmi si in
programele care implementeaza pe calculator acesti algoritmi.

Matricea de adiacentã matricea booleanã

Matricea de adiacentã asociatã unui graf neorientat cu n noduri se

defineste astfel: A = (ai j) n x n cu

1, daca [i,j]∈E
a[i,j]=
0, altfel

Observatii:

- - Matricea de adiacenta asociatã unui graf neorientat este o

matrice simetricã
- - Suma elementelor de pe linia k reprezintã gradul nodului k
 - - Suma elementelor de pe coloana k reprezintã gradul nodului
k

Fie graful din figura urmatoare:

0 1 0 1 0 0 nodul 1 are gradul 2

1 6 1 0 1 0 0 0 nodul 2 are gradul 2
A = 0 1 0 1 1 0 nodul 3 are gradul 3
5
2 1 0 1 0 0 0 nodul 4 are gradul 2
3 4 0 0 1 0 0 0 nodul 5 are gradul 1
0 0 0 0 0 0 nodul 6 are gradul 0
Numarul de noduri este 6 si numarul de muchii este 4
Matricea este simetrica si patratica avand 6 linii si 6 coloane
Diagonala principala contine numai valori nule

Pentru a prelucra graful se citesc:

6- reprezentand n, numarul de noduri
4- reprezentand m, numarul de muchii
4 perechi x-y reprezentand extremitatile celor 4 muchii:
1-2 => a[1,2]=a[2,1]=1
1-4 => a[1,4]=a[4,1]=1
2-3 => a[2,3]=a[3,2]=1
3-4=> a[3,4]=a[4,3]=1
3-5 => a[3,5]=a[5,3]=1

Listele de adiacenta a nodurilor

Reprezentarea in calculator a unui graf se poate face utilizand listele de adiacenta a
varfurilor, adica pentru fiecare varf se alcatuieste lista varfurilor adiacente cu el.

Fie graful din figura urmatoare:

 1 6

5
2

3 4

Lista vecinilor nodului 3: 2, 4, 5 (noduri adiacente)

1 6

5
2

3 4

Nodul 6 nu are vecini (este izolat)

Pentru intreg graful vom avea mai multe liste :
Nodul 1 : 2 4

Nodul 2 : 1 3

Nodul 3 : 2 4 5

1 3
Nodul 4 :
3
Nodul 5 :

Ordinea nodurilor in cadrul unei liste nu este importanta

Pentru a genera o astfel de lista vom defini tipul nod :

struct nod {int nd;

nod *next;};

Toate listele se vor memora utilizand un vector de liste :

nod *L[20];

Datele de intrare : numarul de noduri si muchiile se vor citi din fisier :

O solutie de implementare este urmatoarea :

#include<conio.h>
#include<fstream.h>
struct nod
{int nd;
nod *next;};

nod *L[20];

void afisare(int nr_nod) //afiseaza lista vecinilor nodului nr_nod

{nod *p=L[nr_nod];
if(p==0)
cout<<nr_nod<<" este izolat "<<endl;
else
{cout<<"lista vecinilor lui "<<nr_nod<<endl;
nod *c=p;
while(c)
{cout<<c->nd<<" ";
c=c->next;}
cout<<endl;}
}

void main()
{fstream f;int i,j,n;
nod *p,*q;

f.open("graf.txt",ios::in); //citirea datelor din fisier

clrscr();
f>>n;
while(f>>i>>j)
{p=new nod; //se adauga j in lista vecinilor lui i
p->nd=j;
p->next=L[i];
L[i]=p;
q=new nod; //se adauga i in lista vecinilor lui j
q->nd=i;
q->next=L[j];
L[j]=q;
}
f.close();

cout<<endl<<"listele de adiacente ";

for(i=1;i<=n;i++)
afisare(i);
 getch();
}

Observatie : In exemplul anterior adaugarea unui nou element in lista se face inainte
celorlalte din lista corespunzatoare.

Aceste doua moduri de reprezentare (prin matrice de adiacenta si prin liste de vecini) se
folosesc dupa natura problemei. Adica, daca in problema se doreste un acces frecvent la
muchii, atunci se va folosi matricea de adiacenta; daca numarul de muchii care se
reprezinta este mult mai mic dect nxn, este de preferat sa se folosesca listele de adiacenta,
pentru a se face economie de memorie.

Probleme propuse :

1. 1. Sa se memoreze un graf neorientat utilizand liste de adiacente. Parcurgand

listele de adiacenta rezolvati urmatoarele cerinte :

a. a. Sa se determine daca graful contine noduri izolate

b. b. Sa se determine fradul unui nod citit de la tastatura
c. c. Sa se determine nodul cu cel mai mare grad
d. d. Sa se determine daca nodurile x si y sunt adiacente
e. e. Sa se verifice daca graful este regulat
f. f. Sa se determine daca graful este complet

Componente conexe
Fie G=(V, E) un graf neorientat, unde V are n elemente (n noduri) si E are m elemente
(m muchii).
Definitie: G1=(V1, E1)este o componenta conexa daca:
- - pentru orice pereche x,y de noduri din V1 exista
un lant de la x la y (implicit si de la y la x)
- - nu exista alt subgraf al lui G, G2=(V2, E2) care
sa indeplineasca prima conditie si care sa-l contina
pe G1
 1
6 7
Graful alaturat are doua
componente conexe:
2
5
- - subgraful care
contine nodurile:
3 4
12345
- - subgraful care
contine nodurile:
67

Observatie: subgraful 1, 2, 3, 4 nu este componenta conexa pentru ( chiar daca pentru

orice pereche x,y de noduri exista un lant de la x la y) deoarece exista subgraful 1, 2, 3,
4, 5 care il contine si indeplineste aceeasi conditie.

Definitie: Un graf G=(V, E)este conex daca pentru orice pereche x,y de noduri din V
exista un lant de la x la y (implicit si de la y la x).

Observatii:
- - Un graf este conex daca admite o singura componenta conexa.
- - Graful anterior nu este conex pentru ca admite doua componente conexe
Graful urmator este conex:
1
6 7

5
2

3 4

2.7. Arbori. Definire, modele de reprezentare, operaţii.

ARBORI
Un arbore este un graf conex fara nici un ciclu (n varfuri si n-1 arce).
Legaturile existente intr-un arbore sunt de tip parinte-fiu.
Nodul in care nu intra nici un arc se numeste radacina.
Un nod in care intra un arc se numeste succesor sau fiu, iar cel din care iese un arc sau
mai multe se numeste predecesor sau parinte.
Nodurile sunt organizate pe nivele, iar cele de pe ultimul nivel se numesc frunze sau
noduri terminale.
Nodurile pot contine informatii utile ce poarta denumirea de chei ale arborelui.
ARBORI BINARI
Definitie

Un arbore binar este o multime de n >= 0 noduri, care daca nu este vida, contine un nod
numit radacina, restul nodurilor formând doi arbori disjuncti numiti subarborele
stâng si subarborele drept.

Aceasta structura de date e importanta pentru ca e usor de reprezentat si prelucrat, orice

arbore putând fi transformat în arbore binar .

Tehnica transformarii unui arbore generalizat în arbore binar

Un arbore generalizat poate fi transformat intr-un arbore binar, astfel incât secventele de
noduri pentru parcurgerea inpreordine sa fie identice in cazul ambilor arbori.

Un arbore generalizat A cu radacina A1 si subarborii A1,1, A1,2, ...,A1,k se transforma în

arbore binar având radacina A1, A1,1 fiul sau stâng, iar A1,i devin fiii drepti ai lui A1,i-
1 pentru 2<=i<=k.

Secventele de noduri în parcurgerea în preordine a arborelui generalizat si a celui binar

obtinut prin transformare, sunt identice.

Exemplu: Se considera arborele generalizat de mai sus. Aplicând regula descrisa, se

obtine arborele binar reprezentat.

Implementarea arborilor binari

Un arbore binar poate fi descris cu ajutorul urmatoarei structuri de date dinamice:

typedef int TCheie;

class TNodAB {
public:
TCheie cheie;
TNodAB *stg,*dr;
TNodAB(TCheie k) {
cheie=k;
stg=dr=NULL;
}
};

Operatorii arborelui binar

INITIALIZEAZA(A) - face vid arborele A;

INSEREAZA(X,A) - insereaza cheia X în arborele A;
CAUTA(X,A) - cauta cheia X, returnând true la gasire;
SUPRIMA(X,A) - suprima cheia X, daca exista;
TRAVERSEAZA(A) - parcurge toate cheile arborelui A

Traversarea arborilor binari

Pentru un arbore binar, notând cu R radacina si cu A si cu B subarborele sau stâng,

respectiv drept, cele 3 posibilitati de traversare sunt:

o preordine - lista R, A, B
o inordine - lista A, R, B
o postordine- lista A, B, R.

Cele trei metode de traversare se concretizeaza în trei functii recursive în care Prelucrare
este operatia ce trebuie facuta asupra fiecarui nod.

Arbori binari ordonati. Arbori binari de înaltime minima

Arborele binar ordonat e arborele binar cu proprietatea ca parcurgând nodurile

în inordine, secventa cheilor este monoton crescatoare.

Are proprietatea ca daca un nod oarecare al arborelui are cheia c, toate nodurile din
subarborele stâng al nodului au cheile mai mici decât valoarea c, respectiv toate cheile
din subarborele drept au cheile mai mari sau egale cu c. De aici rezulta procedeul de
cautare foarte simplu, prin trecerea la fiul stâng sau drept de la nodul curent, functie de
relatia dintre cheia cautata si cea a nodului curent.
Cum înaltimea minima a unui arbore binar ordonat cu n noduri este

hmin=[log2 (n+1)],
rezulta ca o cautare într-un arbore binar ordonat necesita aproximativ log2n comparatii de
chei, fata de n/2 comparatii într-o lista liniara.

Tehnica de creare a arborilor binari ordonati

Procesul de creare consta în insertia câte unui nod într-un arbore binar ordonat, care
initial este vid, astfel încât dupa insertie el sa ramâna ordonat.

Pentru aceasta se traverseaza arborele începând cu radacina si se selecteaza fiul stâng sau
drept, dupa cum cheia de inserat e mai mica sau mai mare decât a nodului parcurs. Se
repeta pâna când se ajunge la un pointer nil care se inlocuieste cu pointerul spre noul nod
creat. Pentru ca sortarea sa fie stabila, se trece la fiul drept chiar daca valoarea cheii e
egala.

2.8. Algoritmi fundamentali pentru prelucrarea datelor (algoritmi de sortare,

algoritmi de căutare, algoritmi de interclasare)

Sortarea reprezinta una dintre cei mai utilizate metode de programare. Are
utilizari de la domenii precum matematica( statistica matematica ), pana la limbi(
realizarea unor dictionare ).De aceea se impune sa gasim cei mai convenabili
algoritmi
si sa prezentam avantajele si dezavantajele acestora. Ne vom rezuma la cei mai
importanti ( in cartea lui Donald Knuth –“ Algoritmi de sortare” sunt prezentati
peste
30 asemenea metode de programare).
Metodele de sortare se clasifica in metode directe si metode avansate. Metodele
directe se bazeaza„ pe algoritmi de dificultate redusa, usor de gasit si de inteles.
Metodele
directe pe care le vom lua in considerare sunt sortarea prin selectie ( SelectSort ),
sortarea prin insertie ( InsertSort ) si sortarea cu bule ( BubbleSort ).
Metodele avansate se bazeaza pe algoritmi putin mai complicati, dar care nu
necesita unostinte avansate de algoritmica. Cateva din cele mai cunoscute sunt
sortarea
rapida (QuickSort), sortarea prin interclasare (MergeSort) si sortarea cu
micsorarea incrementului( Shell Sort ).
La fiecare metoda voi descrie algoritmul, il voi exemplifica in Pseudocod si C++( la
unele metode si parametrizat), voi analiza complexitatea algoritmilor si voi propune
un
set de probleme.
Analizând complexitatea algoritmilor factorul cel mai important este timpul de
executie exprimat în "O-mare". Trebuie sã folosim mai multe criterii pentru
evaluarea
timpului de executie al algoritmului de sortare cum ar fi, numãrul de pasi(de
atribuiri) ai
algoritmului si numãrul de comparatii dintre elemente necesare pentru a sorta N
elemente
Al doilea factor important este cantitatea (volumul) de memorie suplimentarã
folositã de un algoritm de sortare. Metodele se împart în trei tipuri: cei care
sorteazã pe
loc, nu folosesc memorie suplimentarã, cu exceptie poate o micã tabelã sau stivã; cei
care
au o reprezentare de listã înlãntuitã deci folosesc N cuvinte de memorie în plus
pentru
pointerii listei; cei care au nevoie de memorie suplimentarã pentru o copie a tabelei
initiale.
Recomand ca lucrarea sa fie parcursa pas cu pas, intrucat nu exista un algoritm
perfect. In unele cazuri metodele directe sunt mai economicoase( mai putine
elemente de
comparat ), in altele cele avansate sunt mai bune. De asemenea recomand
incepatorilor ca
sa utilizeze fiecare metoda. 1. Metode directe
1.1 BubbleSort
Acesta metoda se rezuma la a compara fiecare element cu celelalte, facandu-se
interschimbarea daca elementul mai mare are indexul mai mic. Este cea mai simpla
metode de sortare si nu necesita cunoasterea detaliata a limbajului de programare.
Poate
fi folosita cu succes de catre incepatori.
Algoritmul este urmatorul:

simple-sort (a[Nmax+ 1])

pentru iÅ 1 pana la n
pentru j Å i+1 pana la n
daca a[i]>a[j]
interschimba(a[i], a[j])
Algoritmul in C++ (neparamatrizat) este :
void BubbleSort(Tip a[Nmax+1],int Size)
 }
for(int i=0;i<Size;i++)
for(int j=i+1;j<=Size;j++)
if(a[i]>a[j])
}
Tip aux=v[i];
a[i]=a[j];
a[j]=aux;
{
{
Bubble sort este o metodã de sortare simplã, eficientã pentru un numãr mic de
elemente (mai putin de 15), dar nu pentru tabele mari. Nu necesitã foate multã
memorie,
dar este de douã ori mai lentã decât InsertionSort în aproape orice situatie.
Timpul de executie depinde de input, adicã de ordinea initialã al elementelor. Dacã
tabela
este deja sortatã e nevoie de un singur pas, adicã N-1 comparãri. În cazul cel mai
nefavorabil sunt necesare N ×(N-1)/2 comparãri si N × (N-1)/2 interschimbãri.
Performanta algoritmului în caz general este mai greu de analizat dar este
asemãnãtor
cazului nefavorabil. Complexitatea timpului al Bubble sortului este O(N
2
.(
Algoritmul in C++ (parametrizat) este :
Void Bubblesort_para(Tip a[Nmax+1],int size)
}
int ok=0,i;
do{
for( i=1;i<size;i++)
if (a[i]>a[i+1]) {interschimba(a[i],a[i+1]);ok=1;}
}while (ok==1);
{In acest caz in cazul cel mai defavorabil numarul de comparatii este tot NC=n(n-
1)/2 dar spre deosebire de celalalt algoritm este mai rapid in cazurile medii. (daca
nu mai
gaseste doua elemente de interschimbat algoritmul se opreste.)
BubbleSort nu foloseste alte structuri de date si din aceasta cauza este recomandabil
in cazurile cu putine elemente de sortat si in cazul in care memoria este limitata.
Exemplu de sortare (sirul initial este {6, 5, 4, 3, 2, 1}):
Nr
interschinbari
6 5 4 3 2 1
1 5 6 4 3 2 1
2 5 4 6 3 2 1
3 5 4 3 6 2 1
4 5 4 3 2 6 1
5 5 4 3 2 1 6
6 4 5 3 2 1 6
7 4 3 5 2 1 6
8 4 3 2 5 1 6
9 4 3 2 1 5 6
10 3 4 2 1 5 6
11 3 2 4 1 5 6
12 3 2 1 4 5 6
13 2 3 1 4 5 6
14 2 1 3 4 5 6
15 1 2 2 3 4 5

1.3 InsertionSort
Insertia directã apartine familiei de tehnici de sortare care se bazeazã pe metoda
"jucãtorului de bridge". Este un algoritm aproape la fel de simplu ca Selection sort,
dar
poate mai flexibil. Considerãm elementele A[1]...A[i-1] fiind sortate, inserãm
elementul
A[i] în locul ce îi revine.
Fiind dat o tabelã A cu N elemente nesortate, parcurgem tabela si le inserãm
fiecare element în locul propriu între celelalte elemente considerate sortate. Pentru
fiecare
i = 2..N , elementele A[1]…A[i] sunt sortate prin inserarea lui A[i] între lista
elementelor
sortate: A[1]…A[i-1]. Elementele aflate în stânga indexului sunt în ordine sortatã
dar nu
sunt în pozitia lor finalã. Tabela este sortatã complect când indexul ajunge la
capãtul
drept al tabelei.
Algoritmul este :
Insertion(a[nmax+1])
Pentru iÅ2 pana la n
JÅi
pana cand (a[j-1]>a[i])
a[j]Åa[j-1] jÅ j-1
 a[j]Åa[i]Algoritmul in C++ este :
Insertion ( type A[ ], int size )
}
int i, j;
type v;
For ( i = 2; i <= size; i++ )
}
v = A[i]; j = i;
While ( A[j-1] > v )// mut elementele cu o pozitie in
fata
{ A[j] = A[j-1]; j --; }
A[j] = v;// pun elem in poz lui
{
{
Insertion sort este un algoritm de sortare simplu, liniar: O(N) pentru tabele care
contin N elemente aproape sortate. Timpul de executie al algoritmului depinde de
numãrul inversãrilor, deci de ordinea initialã al elementelor.

2.1 QuickSort
În practicã algoritmul de sortare cel mai rapid este Quicksort numitã sortare
rapidã, care foloseste partitionarea ca idee de bazã. Este mai rapidã decât orice
metodã
de sortare simplã, se executã bine pentru fisiere sau tabele mari, dar ineficient
pentru cele
mici.Strategia de bazã folositã este "divide et impera", pentru cã este mai usor de
sortat
douã tabele mici, decât una mare. Algoritmul este usor de implementat, lucreazã
destul de
bine în diferite situatii si consumã mai putine resurse decât orice altã metodã de
sortare în
multe situatii. Necesitã numai în jur de NlogN operati în cazul general pentru a
sorta N
elemente.
Metoda QuickSort presupune gasirea pozitiei finale pe care o ocupa elemenetul de
pe prima pozitie comparandu-l cu elementele din cealalta partitie a tabelului, acest
algoritm realizandu-se pana cand partitia are 1 element.

2.2 MergeSort
Algoritmul de sortare prin interclasare se bazeazã pe urmãtoarea idee: pentru a
sorta o tabelã cu N elemente îl împãrtim în douã tabele pe care le sortez separat si
le
intrclasãm. Este o metodã de sortare care foloseste strategia de bazã "divide et
impera",
conform cãreia problema se descompune în alte douã subprobleme de acelasi tip si
dupã
rezolvarea lor rezultatele se combinã. Algoritmul sorteazã elementele în ordine
crescãtoare.
Tabelul se imparte in n/2, dupa aceea tabelele se impart in jumatate, tot asa pana
cand tabelele formate au mai putin sau cel mult de k elemente(in cazul nostru k=2-
este
cel mai usor sa compari 2 elemente).
Algoritmul presupune :
1. Afla mijlocul tabelului
2. Sorteaza prima jumatate a tabelului
3. Sorteaza a doua jumatate a tabelului
4. Imbina cele 2 jumatati Algoritmul in Pseudocod este:

2.3 ShellSort
Sortarea cu micsorarea incrementului (shellsort) este o extensie simplã al
Insertion sortului care câstigã vitezã permitând schimbarea elementelor aflate
departe.
Ideea de bazã o constituie rearanjarea elementelor din tabela A în asa fel încât,
luând
fiecare a h-a element (începând de oriunde), sã obtinem o tabelã sortatã. Astfel
spunem cã
tabela este h-sortatã. O tabelã , h-sortatã este formatã din h subtabele sortate
independent,
intercalate. Folosind astfel o procedurã pentru fiecare secventã a valorii lui h care se
terminã în 1, va produce o tabelã sortatã.
Algoritmul este :
shell-sort (a)
h←1
pana cand h<n/9
h ← 3*h+1
pana cand h>0
pentru i ← h+1 pana la n
t ← a[i]
j←i
pana cand (j>h si a[j-h] > t)
interschimba(a[j], a[j-h])
j ← j-h
h ← h/3
Algoritmul in C++ este :
Shellsort(int A[], int n)
}
int i, j, h, v;
for (h = 1; h <= n/9; h = 3*h+1);
for ( ; h > 0; h /= 3 )
for (i = h+1; i <= n; i += 1)
}
v = A[i]; j = i;
while ( j>h && A[j-h]>v )
}
A[j] = A[j-h];
j - = h;
{
A[j] = v;
{
{
Exemplu : sirul initial este {1 11 8 10 12 4 7 3 1 13 1 6 9 5 2 }

2.9. Abordarea obiectuală a structurilor de date în aplicaţii complexe (definirea de clase şi

obiecte în C++, constructori, destructori, moşteniri).

Termenul "OOP" ("Object Oriented Programming") desemnează disciplina programării

obiectuale (orientate-obiect). Această disciplină care are la bază ideea unificării datelor
cu modalităţile de prelucrare a acestora şi manevrează entităţi reprezentate sub formă de
obiecte (obiect=date+cod de tratare a acestor date).

Aşa cum s-a subliniat în capitolul 1.3., rezolvarea unei probleme se poate face pe 3
direcţii:
 Rezolvarea orientată pe algoritm (pe acţiune), în care organizarea datelor este

neesenţială;
 Rezolvarea orientată pe date, acţiunile fiind determinate doar de organizarea datelor;

 Rezolvarea orientată obiect, care combină tendinţele primelor două abordări.

Programarea obiectuală oferă posibilităţi de modelare a obiectelor, a proprietăţilor şi a
relaţiilor dintre ele, dar şi posibilitatea de a descompune o problemă în componentele
sale (soft mai mentenabil, adaptabil, reciclabil). Câteva exemple de limbaje de
programare orientată obiect: SIMULA(1965), SIMULA-2(1967), Smalltalk, C++, Java
(în plus, Java poate fi considerat un limbaj de programare orientată eveniment).

Facilităţile oferite de
programarea orientată obiect (conform lui Pascou) sunt:
1. abstractizarea datelor;
2. moştenirea;
3. încapsularea (ascunderea) informaţiei;
4. legarea dinamică (“târzie”).

ABSTRACTIZAREA DATELOR

Obiectele sunt componente software care modelează fenomene din lumea reală. În
general, un fenomen implică tipuri diferite de obiecte. Obiectele care reprezintă aceeaşi
idee sau concept sunt de acelaşi tip şi pot fi grupate în clase (concrete sau abstracte).
Clasele implementează tipuri de date (aşa cum s-a subliniat în capitolul 2, un tip de date
înseamnă o mulţime de valori pentru care s-a adoptatat un anumit mod de reprezentare şi
o muţime de operatori care pot fi aplicaţi acestor valori), deci şi operatorii destinaţi
manipulării acestora: Clasă = Date + Operaţii.
De exemplu, programatorul îşi poate defini tipul (clasa) matrice şi operatorii care pot
fi aplicaţi matricilor (* pentru înmulţirea a două matrici, + pentru adunarea a două
matrici, - pentru scăderea a două matrici, etc). Astfel, el poate folosi tipul matrice în mod
similar unui tip predefinit:
matrice A, B;
matrice C=A+B;
Tipul unui obiect (şablon al obiectului) este o clasă. O clasă se caracterizează prin:
numele clasei, atribute, funcţii şi relaţii cu alte clase.
Instanţa este un obiect dintr-o clasă (A, B, C sunt obiecte, instanţe ale clasei matrice)
şi are proprietăţile definite de clasă. Pentru o clasă definită, se pot crea mai multe instanţe
ale acesteia. Toate obiectele au o stare şi un comportament. Starea unui obiect se referă
la elementele de date conţinute în obiect şi la valorile asociate acestora (datele membre).
Comportamentul unui obiect este determinat de care acţiunile pe care obiectul poate să le
execute (metodele).
Atributele specificate în definiţia unei clase descriu valoric proprietăţile obiectelor din
clasă, sub diferite aspecte. Cele mai multe limbaje orientate obiect fac următoarea
distincţie între atribute:
 atribute ale clasei (au aceeaşi valoare pentru toate instanţele clasei);
  atribute ale instanţei (variază de la o instanţă la alta, fiecare instanţă având
propria copie a atributului).
În limbajul C++ atributele se numesc date membre. Toate datele membre sunt atribute
instanţă. Atributele de clasă se pot obţine în cazul datelor membre statice (aceeaşi adresă
de memorare pentru orice instanţă a clasei).

Metode (funcţii membre). La definirea unei clase se definesc şi metodele acesteia

(numite şi funcţii membre). Fiecare obiect are acces la un set de funcţii care descriu
operaţiile care pot fi executate asupra lui. Metodele pot fi folosite de instanţele clasei
respective, dar şi de instanţele altor clase (prin mecanismul moştenirii).
Clasa conţine atât structurile de date necesare descrierii unui obiect, cât şi metodele care
pot fi aplicate obiectului. Astfel, gradul de abstractizare este, mult mai ridicat, iar
programele devin mult mai uşor de înţeles, depanat sau întreţinut.

La crearea unui obiect, alocarea memoriei se poate fi face static sau dinamic (cu ajutorul
unor funcţii membre speciale, numite constructori). Eliberarea memoriei se realizează cu
ajutorul unor funcţii membre speciale, numite destructori, în momentul încheierii
existenţei obiectului respectiv.
DEFINIŢIA CLASELOR ŞI ACCESUL LA MEMBRII

LEGĂTURA CLASĂ-STRUCTURĂ-UNIUNE

Aşa cum s-a subliniat în capitolul 9, o clasă reprezintă un tip abstract de date, care
încapsulează atât elementele de date (datele membre) pentru care s-a adoptat un anumit
mod de reprezentare, cât şi operaţiile asupra datelor (funcţiile membre, metode). În
limbajul C++, structurile şi uniunile reprezintă cazuri particulare ale claselor, putând avea
nu numai date membre, câmpuri de date (vezi capitolul 8), dar şi funcţii membre. Singura
diferenţă între structuri şi uniuni constă în faptul că la uniuni, pentru memorarea valorilor
datelor membre se foloseşte aceeaşi zonă de memorie. Deosebirea esenţială între structuri
şi uniuni - pe de o parte - şi clase - pe cealată parte - constă în modul de acces la
membrii: la structuri şi uniuni membrii (datele şi metodele) sunt implicit publici, iar la
clase - implicit privaţi (membrii sunt încapsulaţi). Lipsa unor modalităţi de protecţie a
datelor, face ca tipurile de date introduse prin structuri sau uniuni să nu poată fi strict
controlate în ceea ce priveşte operaţiile executate asupra lor. În cazul claselor, modul de
acces la membrii tipului de date (în scopul protejării acestora) poate fi schimbat prin
utilizarea modificatorilor de control ai accesului: public, private, protected.

. DECLARAREA CLASELOR
Modul de declarare a unei clase este similar celui de declarare a structurilor şi a
uniunilor:
class nume_tip{
modificator_control_acces:
lista_membrilor;
} lista_variabile;

Clasa reprezintă un tip de date (definit de utilizator).

Membrii unei clase sunt:
 Datele membre - datele declarate în cadrul clasei;

 Metodele - funcţiile membre, funcţiile declarate sau definite în cadrul clasei. Se

admite că în cadrul declaraţiei de clasă să se specifice doar prototipurile funcţiilor

membre, definiţiile putând fi făcute oriunde în fişier, sau în alt fişier.
Pentru membrii care apar în lista_membrilor se poate preciza un anumit mod de
acces.
Modificator_control_acces poate fi public, private sau protected
(eventual friend, vezi paragraful 10.4.). Dacă nu se specifică, este considerat cel
implicit (private). Modificatorul de acces public se utilizează pentru membrii care
dorim să fie neprotejaţi, ultimii doi modificatori asigurând protecţia membrilor din
domeniul de acţiune a lor. Membrii cu acces private pot fi accesaţi numai prin
metodele clasei (sau prin funcţiile prietene, capitolul 10.4.). Cei cu acces protected
posedă caracteristicile celor privaţi, în plus, putând fi accesaţi şi din clasele derivate.
Specificatorii modului de acces pot apare în declararea clasei de mai multe ori, în orice
ordine.
Domeniul unui modificator de acces ţine din punctul în care apare modificatorul
respectiv, până la sfârşitul declaraţiei clasei sau al întâlnirii altui modificator de acces
(exemplele 1,2).
Observaţiile legate de prezenţa nume_tip sau lista_variabile (din capitolul 8)
sunt valabile şi în cazul claselor.
Variabilele din lista_variabile sunt de tipul nume_tip şi se numesc instanţe
(obiecte) ale clasei.
Observaţie: În cazul tipurilor de date definite cu ajutorul structurilor, se pot aplica
modificatorii de acces. În cazul tipurilor definite cu ajutorul uniunilor, accesul implicit
(public) nu poate fi modificat.

Exemplu:
class masina{
char *culoare; // dată membru la care accesul este, implicit, private
int capacit_cil; // dată membru la care accesul este, implicit, private
public:
void citire_date();
//metodă cu acces public, care permite introducerea datelor despre o instanţă a
clasei
int ret_capacit(); //metodă cu acces public
};
Membrii culoare şi capacitate_cil (accesul private) pot fi accesaţi doar prin
intermediul metodelor clasei.
Exemplu:
class persoana{
char *nume; //dată membru privată
public:
void citire_inf_pers(); //metodă publică
private:
int varsta; //dată membru privată
};
OBIECTE

Un obiect este o dată de tip definit printr-o clasă. În exerciţiul anterior, punctul c, în
funcţia main, se declară obiectul (variabila) a de tip dreptunghi. Spunem că obiectul
a este o instanţă a clasei dreptunghi. Se pot declara oricâte obiecte (instanţe) ale
clasei. Aşa cum se observă din exemplu, declararea obiectelor de un anumit tip are o
formă asemănătoare celei pentru datele de tip predefinit:
nume_clasa lista_obiecte;
Exemple:
dreptunghi a;
dreptunghi b, c, d;

MEMBRII UNEI CLASE

Datele membru se alocă distinct pentru fiecare instanţă (atribute ale instanţei) a clasei
(pentru declararea obiectelor a, b, c, d de tip dreprunghi, vezi figura 10.1.). Excepţia de
la această regulă o constituie datele membru statice, care există într-un singur exemplar,
comun, pentru toate instanţele
a.Lun clasei. b.Lun c.Lun
Lung Lung Lung g
g g
a.la b.la lat c.la
lat lat t
a t b t c

d.Lun
Lung g
lat d.la
d t

Figura 10.1. Alocarea memoriei pentru datele membre nestatice

Metodele figurează într-un singur exemplar, oricâte instanţe ale clasei ar exista.

În exemplul anterior, metoda seteaza_dimen este doar declarată în interiorul clasei,

fiind abia apoi definită. La definirea funcţiei (void
dreptunghi::seteaza_dimen(double L, double l)) s-a folosit
operatorul :: (scope resolution operator) care specifică relaţia de apartenenţă a metodei
la tipul dreptunghi. Operatorul cuplează nume_clasa::nume_functie_membru
şi defineşte domeniul (scopul) în care acea funcţie va fi recunoscută. Prezenţa numelui
clasei în faţa funcţiei membru este obligatorie, deoarece, altfel nu s-ar putea face
distincţia între metode cu nume identice, care aparţin unor clase diferite.
O funcţie membru se apelează totdeauna în strânsă dependenţă cu un obiect din clasa
respectivă. Legătura dintre obiect şi funcţia membră se face prin operatorul . sau
operatorul ->, după cum obiectul este desemnat prin nume sau prin pointer (vezi
exemplu). În plus, metodele statice pot fi apelate independent de un obiect al clasei,
folosind operatorul de rezoluţie (::).
Accesul la o metodă presupune o activitate de adresare, transparentă utilizatorului. De
fapt, în interiorul obiectului creat se află doar punctatori la clasa din care provin. În
interiorul definiţiei clasei se alocă o singură copie a fiecărei funcţie membră şi punctatorii
respectiv, prin care obiectul va avea acces la metoda respectivă. Excepţia de la această
regulă o constituie metodele virtuale (capitolul 12).
Exemplu: Fie clasa dreptunghi din exerciţiul anterior.
class dreptunghi{
double Lung, lat;
public:
void seteaza_dimen(double, double );
double arata_Lung();
double arata_Lat();
double calcul_arie();
 };
//……………………………………………………………………………..
void main()
{ dreptunghi a;
//……………………………………………………………………
cout<<"Aria
dreptunghiului:"<<a.calcul_arie()<<'\n';
dreptunghi *pa;
pa=&a;
double arie=pa->calcul_arie();
}

Vizibilitate

Domeniul de vizibilitate a unei variabile (obiect) este determinat de clasa de memorare a

variabilei (obiectului), aşa cum prezintă tabelul 6.1. (capitolul 6). De obicei, domeniul de
vizibilitate al unui nume coincide cu domeniul numelui.

MOŞTENIREA

Moştenirea este o caracteristică a limbajelor de programare orientate obiect, care permite

refolosirea codului şi extinderea funcţionalităţii claselor existente. Între două clase pot
exista multe diferenţe, dar şi multe asemănări. Este bine ca informaţia comună unor clase
să fie specificată o singură dată (conceptul de clasă/subclasă, superclasă/clasă în OOP).
Mecanismul moştenirii permite crearea unei ierarhii de clase şi trecerea de la clasele
generale la cele particulare. Procesul implică la început definirea clasei de bază care
stabileşte calităţile comune ale tuturor obiectelor ce vor deriva din bază (ierarhic
superioară)(figura 9.1.). Prin moştenire, un obiect poate prelua proprietăţile obiectelor din
clasa de bază.
Clasa A reprezintă clasa de bază (este o generalizare) şi conţine informaţiile
comune (disponibile prin moştenire şi subclaselor acesteia). A
Clasa B reprezintă clasa derivată (este o particularizare, o specializare a clasei A)
care extinde funcţionalitatea clasei de bază şi conţine informaţiile specifice.
Să presupunem că A reprezintă clasa mamiferelor (cu proprietăţile caracteristice:
nasc pui vii, au sânge cald, îşi alăptează puii, etc), iar B reprezintă clasa
animalelor domestice. În momentul definirii clasei derivate B, aceasta moşteneşte B
toate caracteristicile clasei A, rămânând de specificat doar trăsăturile distinctive.
În acest caz, A este clasă de bază, iar B clasă derivată (subclasă a clasei A). Figura 9.1. Relaţia
Sau: B este clasă, iar A este o superclasă a clasei B. clasă de bază-clasă
Moştenirea poate fi: unică sau multiplă. derivată
. MOŞTENIREA UNICĂ

În cazul moştenirii unice, fiecare clasă are doar o superclasă. Există două modalităţi de
specializare a unei clase de bază:
 introducerea de extra-atribute şi extra-metode în clasa derivată (particulare doar clasei

derivate);
 redefinirea membrilor în clase derivate (polimorfism).

MOŞTENIREA MULTIPLĂ

În situaţia moştenirii multiple, o clasă are mai multe superclase. Astfel, moştenirea clasei
va fi multiplă (rezultând o structură de reţea).
A A

B C D B C D

E F G H E F

Figura 9.2. Moştenirea simplă (unică) Figura 9.3. Moştenirea multiplă

Moştenirea multiplă este utilă, dar poate crea ambiguităţi (când pentru acelaşi atribut se
moştenesc valori diferite). Există mai multe strategii de rezolvare a conflictului
(părintele cel mai apropiat, cel mai depărtat, etc.). Deasemenea, este posibilă o moştenire
repetată, în care o clasă ajunge să moştenească de la aceeaşi clasă, pe drumuri diferite în
reţea (vezi figura 9.3., în care clasa E moşteneşte de la aceeaşi clasă A, pe drumurile A-
B-E, A-C-E) . Aşa cum vedea în capitolele următoare, în aceste situaţii, limbajul C++
oferă programatorului două strategii: 1) clasa E poate avea două copii ale lui A, una
pentru fiecare drum; 2) clasa E are o singură copie, iar A este clasă virtuală de bază şi
pentru C şi pentru B. Ideea moştenirii multiple poate duce la utilizarea unor clase pentru
care nu există instanţe, care să ajute doar la organizarea structurii (reţelei) de moştenire.
În plus, limbajul C++ permite un control puternic asupra atributelor şi metodelor care vor
fi moştenite.

ÎNCAPSULAREA (ASCUNDEREA) INFORMAŢIEI

Încapsularea (ascunderea) informaţiei reflectă faptul că atributele instanţă şi metodele

unui obiect îl definesc doar pe acesta. Vom spune că metodele şi atributele unui obiect
sunt “private”, încapsulate în obiect. Interfaţa cu obiectul relevă foarte puţin din ceea ce
se petrece în interiorul lui. Obiectul deţine controlul asupra atributelor instanţă, care nu
pot fi alterate de către alte obiecte. Excepţia de la această observaţie o reprezintă doar
atributele de clasă care nu sunt încapsulate, fiind partajate între toate instanţele clasei.
Această tehnică de "plasare" a valorilor în datele membre private ale obiectului,
reprezintă un mecanism de ascundere a datelor.

În limbajul C++ încapsularea poate fi forţată prin controlul accesului, deoarece toate
datele şi funcţiile membre sunt caracterizate printr-un nivel de acces (rezultând astfel o
mare flexibilitate). Nivelul de acces la membrii unei clase poate fi (figura 9.4.):
public
Clasa A
 private: membrii (date şi metode) la care protected
accesul este private pot fi accesaţi doar prin private
metodele clasei (nivel acces implicit);
 protected: aceşti membri pot fi accesaţi
prin funcţiile membre ale clasei şi funcţiile
membre ale clasei derivate;
 public: membrii la care accesul este
public pot fi accesaţi din orice punct al
domeniului de existenţă a clasei respective;
clasă
 friend: aceşti membri pot fi accesaţi prin Clasa B
derivată
funcţiile membre ale funcţiei prietene
specificate.
Figura 9.4. Accesul la membrii unei clase

În limbajul C++, nivelul de acces poate preciza şi tipul de moştenire (capitolul 12).
 Publică, unde în clasa derivată nivelul de acces al membrilor este acelaşi ca în clasa de

bază;
 Privată, unde membrii protected şi public din clasa bază devin private în clasa

derivată.