TEORIE INFORMATICA C/C++

TEMATICA ADMITERE UBB

Bulzan Sergiu

Cuprins
Algoritmi ............................................................................................................................................. 1
1.1

Notiunea de algoritm. Caracteristici ................................................................................... 1

1.2

Date, variabile, expresii, operatii ........................................................................................ 2

1.3

Structuri de baza. Liniara, alternativa si repetitiva ............................................................. 4

1.4

Descrierea algoritmilor (programe pseudocod) ................................................................. 6

Elementele de baza ale unui limbaj de programare ........................................................................... 8

2.1

Vocabularul limbajului ........................................................................................................ 8

2.2

Constante.Identificatori ...................................................................................................... 9

2.3

Notiunea de tip de data. Operatori aritmetici, logici, relationali ..................................... 10

2.4

Definirea tipurilor de date ................................................................................................ 11

2.5

Variabile. Declararea variabilelor...................................................................................... 11

2.6

Definirea constantelor ...................................................................................................... 12

2.7

Structura programelor. Comentarii .................................................................................. 12

2.8

Expresii. Instructiunea de atribuire ................................................................................... 13

2.9

Citirea/Scrierea datelor ..................................................................................................... 13

2.10

Structuri de control(instructiunea compusa, instructiuni alternative si repetitive) ......... 14

Subprograme predefinite.................................................................................................................. 16
3.1

Subprograme. Mecanisme de transfer prin intermediul parametrilor............................. 16

3.2

Funcii predefinite ............................................................................................................. 16

Tipuri structurate de date ................................................................................................................. 20

4.1

Tipul Tablou....................................................................................................................... 20

4.2

Tipul ir de caractere......................................................................................................... 21

4.3

Tipul nregistrare (struct) .................................................................................................. 22

Fiiere text......................................................................................................................................... 23
5.1

Fiiere text. Tipuri de acces ............................................................................................... 23

5.2

Proceduri i funcii predefinite pentru fiiere text ........................................................... 23

Algoritmi elementari ......................................................................................................................... 25

6.2

Divizibilitate. Numere prime. Algoritmul lui Euclid........................................................... 25

6.3

irul lui Fibonacci. Calculul unor sume cu termenul general dat. ..................................... 26

6.4

Metode de ordonare......................................................................................................... 27

6.5

Interclasare ....................................................................................................................... 29

Subprograme definite de utilizator ................................................................................................... 31

7.1

Subprograme n limbajul C/C++ ........................................................................................ 31

7.2

Definiia unei funcii.......................................................................................................... 31

7.3

Declararea funciilor ......................................................................................................... 32

7.4

Apelul funciilor................................................................................................................. 32

7.5

Transferul parametrilor prin referin .............................................................................. 33

7.6

Variabile globale i variabile locale ................................................................................... 35

Recursivitate ..................................................................................................................................... 36
8.1

Prezentare general .......................................................................................................... 36

Algoritmi
1.1 Notiunea de algoritm. Caracteristici
Algoritmul = metoda de solutionare a unui tip de probleme, constand
intr-o multime finita,bine definita si ordonata de operatii.
Un algoritm reprezint o metod de rezolvare a problemelor de un
anumit tip.
A rezolva o problem nseamn a obine, pentru anumite date de
intrare, rezultatul problemei (date de ieire):
Date de intrare

ALGORITM

Date de ieire

De exemplu, orice reet de buctrie poate fi considerat un

algoritm prin care, plecnd de la materiile prime, obinem printr-o
succesiune finit de operaii produsul finit.
Exemplu:
Presupunnd c dispunem de un aragaz, o tigaie, 2 ou, sare i 2oo
ml ulei, s pregtim ochiuri.
Date de intrare: ou, ulei, sare.
Date de ieire: ochiuri.
Pas 1: Se pune tigaia pe foc.
Pas 2: Se toarn uleiul n tigaie.
Pas 3: Ateptm pn cnd se ncinge uleiul.
Pas 4: Spargem cu ndemnare oule n tigaie.
Pas 5: Ateptm pn cnd oule se rumenesc.
Pas 6: Dac nu inem regim, adugm sare.
Observm c am descris o succesiune de pai, prin care, pentru
orice ,,date de intrare (ulei, sare, ou), obinem rezultatul dorit (ochiuri).
Fiecare pas const din operaii culinare specice, care se execut n
ordinea n care sunt specicate.

Proprietati:
1) Generalitate algoritmul rezolva o clasa de probleme nu o problema
particulara
Ex : Nu 3+2 ci a+b
2) Claritate algoritmul nu contine ambiguitati
3) Finitudine algoritmul se termina dupa un numar finit de pasi
Alte proprietati:
Completitudinea algoritmul tine cont de toate cazurile particulare
ale problemei generale.
Ex : calculul lui 2 la n. Caz particular : 2 la 0 care trebuie
tratat separat.
Eficienta algoritmul se va executa cu numar minim de pasi,
folosind un minim
de memorie
Rezolvabilitate Algoritmul sa aiba cel putin o solutie

1.2 Date, variabile, expresii, operatii

Definiie: O dat este orice entitate cu care poate opera calculatorul.
Orice algoritm lucreaz cu date: date de intrare (datele pe care
trebuie s le primeasc un algoritm din exterior), date de ieire (datele pe
care trebuie s le furnizeze algoritmul n exterior), precum i date de
manevr (date temporare, necesare algoritmului pentru a obine datele de
ieire pe baza datelor de intrare).
Datele cu care lucreaz algoritmii pot clasificate din mai multe puncte
de vedere. O prim clasicare a datelor, n funcie de posibilitatea de a-i
modica valoarea, este:
Constante - date care nu i modic valoarea; de exemplu: 10, 3 .14,
sir de caractere, A
de caractere, A, fals ( 0 ).
Variabile - date care i modic valoarea. O variabil poate referit
printr-un nume (o succesiune de litere, cifre i liniu de subliniere,
primul caracter ind obligatoriu liter sau liniu de subliniere) i are

asociat o valoare. Numele unei variabile nu se schimb pe parcursul

algoritmului, dar valoarea acesteia se poate modica.
Pentru a cunoate natura valorilor care pot fi asociate variabilelor
precum i a operaiilor permise cu acestea, variabilele trebuie
declarate nainte de a fi utilizate.
n funcie de valoarea lor, datele pot fi clasicate astfel:
1) Date numerice - au ca valori numere ( naturale, ntregi sau reale );
2) Date alfabetice - au ca valori caractere sau iruri de caractere;
3) Date logice - au valoarea adevrat sau fals (1 sau 0).

Expresii
In scopul efectuarii calculelor, algoritmii folosesc expresii. O expresie
este alcatuita din unul sau mai multi operanzi legati intre ei prin
operatori.

Operanzii pot fi constante sau variabile

Operatorii au rolul de a preciza operatiile care se efectueaza.
o
o
o

Pentru adunare folosim operatorul +

Pentru scadere folosim operatorul Pentru inmultire folosim operatorul *
Pentru impartire folosim operatorul /

o
In limbajul de programare C/C++ -

Operatorii sunt de diferite tipuri:

Operatori aritmetici (cei amintiti mai sus)
Operatori relationali (>, >=, <=, =, !=)
Operatori logici (negatia ! , conjunctia logica SI, disjnctia logica
SAU)
Operatii
In linii mari, operatiile care se fac intr-un algoritm se impart in trei mari categorii:
operatii de intrare / iesire;
operatii de atribuire;
operatii de decizie.

1.3 Structuri de baza. Liniara, alternativa si repetitiva

1. Structura liniar (secventiala) este o secven de instruciuni care se
execut necondiionat, o singur dat. O astfel de structur poate s conin
instruciuni pentru citirea i scrierea datelor, calcule matematice (expresii)
instruciuni de atribuire.
Model structura liniara:
Start;
Pas 1;
Pas 2;
Pas 3;
......
Pas n;
Stop
Observatie: Daca n=1 atunci nu se pun indicatorii "start" si "stop".

2. Structura alternativa se defineste prin selectia intre doua sau mai multe
actiuni in functie de datele problemei.Poate fi de doua tipuri:
A.
STRUCTURA ALTERNATIVA SIMPLA: Intre doua posibilitati alternative(adevarat;fals)
si care are ca instructiuni de baza instructiunile urmatoare:

daca conditie
atunci
actiune1;
altfel
actiune2;
sfarsit_daca.

B.
STRUCTURA ALTERNATIVA GENERALIZATA: Este atunci cand vom alege intre mai
multe posibilitati (diferite de principiul adevarat si fals) in functie de o variabila de memorie
numita selector,variabila care contine elemente de acelasi tip;executarea actiunilor se va
face in functie de valoarea selectorului in ordinea in care ne sunt date elementele lui.

in cazul ca selector

cazul v1:actiune1;
cazul v2:actiune2;
...........................
cazul vi:actiune i;
...........................
cazul vn:actiune n;
altfel actiune n+1
sfarsit_in_caz_ca.

3. Structura repetitiva. O structur repetitiv se caracterizeaz prin

posibilitatea efecturii repetitive a unei secvene de instruciuni, ct timp
este ndeplinit o anumit condiie sau pna cnd se ndeplinete o anumit
condiie. Repetiia secvenei de instruciuni se numete iteraie.
Exista trei tipuri de structuri repetitive:
-

Structura cu un numar necunoscut de repetitii cu test initial (CAT

TIMP)
Structura cu numar necunoscut de repetitii cu test final (EXECUTA
CAT TIMP sau REPETA)
Structura cu numar cunoscut de repetitii (PENTRU)

Exemplu:
1)

Cat timp

Cat timp expresie executa

Instructiune;
Sfarsit Cat timp.

Efect:
Pas 1: se evalueaz expresia;
Pas 2: dac valoarea expresiei este fals(0), se iese din instruciunea ct timpexecut;
daca valoarea expresiei este adevrat, se execut instruciunea, apoi se revine la Pas 1.

2) Executa Cat timp

Executa
Instructiune;
Cat timp expresie ;

Efect:

Pas 1: se execut instruciunea;

Pas 2: se evalueaz expresia;
Pas 3:dac valoarea expresiei este fals(0) se iese din instruciunea repetitiv; dac valoarea
expresiei este adevrat(1), se revine la Pas 1.

3) Pentru
Pentru contor <- exp_i, exp_f, x executa
Instructiune;
Sf Pentru

Efect:
Pas 1: se execut instruciunea;
Pas 2: se evalueaz expresia;
Pas 3:dac valoarea expresiei este adevrat(1) se iese din instruciunea repetitiv; dac
valoarea expresiei este fals(0), se revine la Pas 1.

exp_i si exp_f sunt expresii ale caror valori sunt evaluate in cadrul repetitiilor
contor este o variabila ce va lua prima data valoarea expresiei initiale exp_i urmand
apoi sa se modifice pana la valoarea expresiei finale exp_f
x este o valoare numerica, in aces caz contorul va creste din x in x. in cazul in care
x=1, atunci acesta poate sa lipseasca.

1.4 Descrierea algoritmilor (programe pseudocod)

Un limbaj de tip pseudocod este un ansamblu de convenii, respectate n mod
sistematic, care denesc operaiile permise (denumite i instruciuni) pentru
reprezentarea algoritmilor.
Un Iimbaj pseudocod se prezint sub form de text i se bazeaz pe nite aanumite cuvinte cheie. Fiecare cuvnt cheie identic n mod unic un anumit tip de
aciune.
Aciunile algoritmului se reprezint n pseudocod prin ceea ce numim
instruciuni. Ansamblul cuvintelor cheie mpreun cu regulile care trebuie respectate
n folosirea lor, alctuiesc ceea ce numim sintaxa Iimbajului pseudocod.
Declararea datelor
Sintaxa: variabila tip;

Operaia de citire
Sintaxa: citete variabila1, variabila2, ..., variabilan;
Efect: Prin operaia de citire (denumit 1 operaie de intrare) se preiau succesiv valori
de la tastatur i se asociaz, n ordine, variabilelor specicate.
Operaia de scriere
Sintaxa: scrie expresie1, expresie2, ..., expresien;
Efect: Operaia de scriere (denumit i operaie de ieire) presupune evaluarea n
ordine a expresiilor specicate
Operaia de atribuire
Sintaxa: variabila expresie;
Efect: se evalueaz expresia, apoi se atribuie valoarea expresiei variabilei din membrul
stng.

Elementele de baza ale unui limbaj de

programare
2.1 Vocabularul limbajului
Limbajul de programare este mijlocul de comunicare ntre utilizator i calculator.
Pentru a defini limbajul de programare se au n vedere 3 aspecte:
1
2
3

Sintaxa
= reprezint totalitatea regulilor care trebuie respectate pentru
definirea elementelor limbajului;
Semantica = definete semnificaia construciilor sintactic corecte;
Pragmatica = definete modul de utilizare a elementelor limbajului.

Implementarea unui algoritm ntr-un limbaj de programare se numete program.

Vocabularul limbajului este alctuit din: setul de caractere, identificatori,

separatori i comentarii.
Setul de caractere
n C/C++ setul de caractere acceptat este cel al codului ASCII;
- codul ASCII standard (codific de la 0-127)
- codul ASCII extins (codific de la 128-255) caractere grafice i semigrafice
Exist 256 de coduri ASCII.
Exemple:
a=097
A=065
0=048
Identificatorii sunt ntlnii i sub denumirea de nume i au rolul de a desemna
nume de variabile, constante , funcii, etc.
Din punct de vedere sintactic identificatorii sunt o succesiune de litere, cifre i liniue
de subliniere dintre care prima trebuie s fie liter sau liniu de subliniere.

Exemplu:
nume corect de variabil: a, a3, _56, nr_cuv
nume greit de variabil: 3aq, nr cuv

Observaii:
- un identificator poate s aib orice lungime, semnificative sunt primele 31
caractere.
- C/C++ este case-sensitive (face distincie ntre literele mari i mici; adic un
identificator a difer de identificatorul A)
- identificatorii ar trebui s aib denumirea n conformitate cu scopul utilizrii lor.
O categorie special de identificatori este reprezentat de cuvintele rezervate
sau cuvinte cheie ale limbajului.
Din punct de vedere sintactic cuvintele cheie sunt identificatori utilizai numai n
scopul pentru care au fost creai.
Separatorii
Sunt utilizai pentru a separe unitile sintactice ntre ele;
Exist mai multe tipuri de separatori:
- separatori standard: spaiul ( ), tab(\t), enter (new line \n)
- delimitatori: operatorul virgul (,)
- separatori speciali: ;(este utilizat la finalul unei instruciuni), (apostroafe)
i (utilizai pentru constantele de tip caracter i ir de caractere)
Comentariile
Reprezint o succesiune de caractere pe care compilatorul (cel care transcrie
codul surs n limbaj main) nu le ia n considerare.
Exist n C/C++ dou tipuri de comentarii:
- pe mai multe linii cu marcajul /**/
- pe o singur linie (de la marcaj pn la sf. de linie) cu marcajul //
Sunt utilizate pentru a crete gradul de lizibilitate a programului i ajut
utilizatorii multiplii la nelegerea programului.

2.2 Constante.Identificatori
Constantele - sunt date ce nu pot fi modificate n cadrul programului.
n limbajul C, preprocesorul poate crea macrouri i poate substitui valori. Preprocesorul
realizeaz o simpl nlocuire de text i nu ofer posibiliti de verificri pentru tipuri de date.
Acest lucru poate introduce anumite efecte ascunse. Acest aspect poate fi rezolvat prin
folosirea valorilor const. nlocuirea tipic a valorilor prin nume se face ca n exemplul
urmtor:

#define DIMENSIUNE 1000

DIMENSIUNE este un nume care exist doar n faza de preprocesare, dup care nu va fi
stocat n memorie. Declaraia se poate plasa n fiiere header pentru a furniza o singur
valoare pentru toate fiierele surs care l vor utiliza.
Dac se dorete evitarea eventualelor probleme (bug-uri) provocate de aceast declaraie,
n special prin lipsa verificrii tipurilor de date utilizate, se poate folosi o variabil const care
poate fi plasat oriunde n program, astfel nct s poat fi folosit n faza compilrii:

const int DIMENSIUNE = 1000;

Utilizarea valorilor constante este important, de exemplu, n declararea tablourilor de date.
De exemplu, se poate face declaraia:

double vector[DIMENSIUNE];
Se poate folosi const pentru toate tipurile predefinite de date (char, int, float i double) i
pentru cele derivate din acestea.

2.3 Notiunea de tip de data. Operatori aritmetici, logici,

relationali
O dat este orice entitate cu care poate opera calculatorul.
Orice limbaj de programare dispune de un set de tipuri de date predefinite numite i tipuri
de date standard
Un tip de date este format din mulimea valorilor pe care le pot lua datele de tipul
respectiv, modul de reprezentare n memorie precum i operaiile care se pot aplica datelor
de tipul respectiv.
Operatorii aritmetici : +, -, *, /, %
Operatorul
+, *, /, %
+,-

Tipul operaiei
Semne (operatori unari)
De multiplicitate (operatori binari)
Aditivi (operatori binari)

Operatorii logici sunt de dou tipuri: logici globali i logici pe bii (sunt operatori binari toi n
afar de negaia logic i pe bii care sunt unari)
Operatori logici globali (&&, ||, !)
Operatori relaionali (<,>,<=,>=,!=) se aplic datelor de tip standard i returneaz un rezultat
de tip logic.

2.4 Definirea tipurilor de date

1) Tipul ntreg
Valorile datelor de tip int sunt numere intregi, cuprinse in intervalul [-32768, 32768],
reprezentate in memorie pe 2 octeti (bytes), in cod complementar. Tipul de date int suporta
modificatori de tip unsigned (datele sunt numere naturale) si long(modifica dimensiunea
reprezentarii). Se obtin astfel urmatoarele tipuri de date intregi:
Denumirea

Nr. octei

Valori

int

2 octei cu semn

[-32768, 32768]

unsigned int

2 octei fr semn

[0, 65535]

long int
unsigned long int

4 ocei cu semn
4 ocei fr semn

[-2147483648, 2147483647]
[0, 4294967295]

2) Tipul char
Tipul char este, de asementea, un tip intreg, care se reprezinta pe un octet, cu semn. Acest
tip suporta un singur modificator unsigned:

Denumirea
char
unsigned char

Nr. octei
1 octet cu semn
1 octet fr semn

Valori
[128, 127]
[0, 255]

3) Tipul real
Tipurile reale ale limbajului C/C++ sunt float si double. Tipul double accepta si modificatorul
long.

Denumirea Nr. octei - n

Valori
virgul
mobil
float
4 octei
[3.4*10-38,3.4*1038]U [-3.4*10+38,-3.4*10-38]
double
8 octei
[1.7*10-308,1.7*10308]U [-1.7*10+308,-1.7*10-308]
long double 10 octei
[3.4*10-4932,1.1*104932]U [-3.4*10+4932,-1.1*10-4932]

2.5 Variabile. Declararea variabilelor

O variabil este o dat care i poate modica valoarea pe parcursul execuiei programului.
n limbajul C/C++, nainte de a utiliza o variabil, trebuie s o declarm. La declarare, trebuie
s specicm numele variabilei, tipul acesteia i, eventual, o valoare iniial pe care dorim s
o atribuim variabilei.

Formatul general al unei declaraii de variabile este:

tip nume_var1

[=expresie1] [, nume_var2 [=expresie2]...];

ex:
int a, b=2, c=2+4;
char z;
float x=b*2.5, y;

2.6 Definirea constantelor

Pentru definirea constantelor simbolice se folosete (n zona de preprocesare) construcia:

#define nume valoare

sau folosind modificatorul const astfel:

const tip nume=valoare;

Exemplul:
#define PI 3.1415;
const float PI=3.1415

2.7 Structura programelor. Comentarii

Orice program C/C++ este alctuit dintr-o succesiune de module (numite funcii ),una dintre
acestea fiind funcia principal numit main().
Forma general a unei surse n C/C++ este:
int main()
{
..// corpul funciei n care se vor scrie declaraiile i
instruciunile care trebuie executate i care acum e vid
return 0;
}
Cnd execuia unui program se termin cu succes, n mod uzual, programul returneaz la ncheierea
execuiei valoarea 0.
Programul va conine i o serie de fiiere antet(headere) n cazul n care vrem s folosim funcii
standard din fiierele respective.
Zona de preprocesare apare n partea de sus a sursei i este introdus de caracterul #. n aceast
zon vor fi incluse fiiere antet (headere) din care vor fi folosite funcii standard (pentru
citire/scriere, prelucrri de date, funcii matematice, etc.)

Exemplu:
# include <iostream.h> // am inclus fiierul antet iostream.h care
conine funcii pentru citire/scriere
Observaie:
Dac realizm noi fiiere pe care vrem s le includem n antet acestea vor fi incluse ntre ghilimele ca
de exemplu: # include fisierul_meu.cpp
n zona de preprocesare se pot defini i constante simbolice de forma:
# define PI 3.1415

Comentariile
Reprezint o succesiune de caractere pe care compilatorul (cel care transcrie codul surs n
limbaj main) nu le ia n considerare.
Exist n C/C++ dou tipuri de comentarii:
- pe mai multe linii cu marcajul /**/
- pe o singur linie (de la marcaj pn la sf. de linie) cu marcajul //
Sunt utilizate pentru a crete gradul de lizibilitate a programului i ajut utilizatorii multiplii la
nelegerea programului.

2.8 Expresii. Instructiunea de atribuire

O expresie este constituita dintr-o succesiune de operanzi, conectati prin operatori. Un
operand poate fi o constanta, o variabila, un apel de functie sau o expresie incadrata intre
paranteze rotunde.
Instruciunea de atribuire are sintaxa:
identificator_variabil = valoare
Unde identificator_variabil este numele variabilei iar valoare (care poate fi constant,
variabil sau expresie ) trebuie s aib tipul compatibil cu cel al variabilei pentru a putea
efectua atribuirea.
Efect: Variabilei identificator_variabil i se va atribui valoarea valoare.

2.9 Citirea/Scrierea datelor

Exist citire i scriere cu i fr format. n continuare ne vom referi la citirea i scrierea
fr format (din C++).
Fluxul de intrare a datelor este cin-console input (de la tastatur) iar operatorul de
extragere care preia datele de intrare i le salveaz n variabile este >>.
Sintaxa: cin>>id_variabil;
Fluxul de ieire a datelor este cout-console output (pe monitor) iar operatorul de inserie
de date n fluxul se ieire este <<.

Sintaxa: cout<<expresie;
Citirea i scrierea de date este gestionat din fiierul antet iostream.h

2.10 Structuri de control(instructiunea compusa, instructiuni

alternative si repetitive)
1. Instructiunea expresie
| Expresie;
Se evalueaza expresia.
Exemple:
| i++;
| p*=2;
| clrscr();
2. Instructiunea compusa
{
declaratii
instructiune_1
instructiune_2

instructiune_n
}
Efect: Se executa in ordine instructiunile specificate.
3. Instructiunea IF
if(expresie)
instructiune_1
else
instructiune_2
Efect: Se evalueaza expresia. Daca valoarea expresiei este diferita de 0, se executa
instructiune_1, altfel se executa instructiune_2
4. Instructiunea WHILE
while(expresie)
instructiune
Efect:
Pas1: Se evalueaza expresia;
Pas2: daca valoarea expresiei este 0, se iese din instructiunea while. daca valoarea expresiei
este diferita de 0, se executa instructiunea, apoi se revine la pas1.

5. Instructiunea DO-WHILE
do
instructiune;
while(expresie);
Efect:
Pas1: se executa instructiunea;
Pas2: se evalueaza expresia;
Pas3: daca valoarea expresiei este 0, se iese din instructiunea repetitiva. daca valoarea
expresiei este diferita de 0, se revine la Pas1.
6. Instructiunea FOR
for(expresieinitializare ; expresiecontinuare ; expresiereinitializare)
instructiune;
Efect:
Pas1: se evalueaza expresia de initializare;
Pas2: se evalueaza expresia de continuare;
Pas3: daca valoarea expresiei de continuare este 0, se iese din instructiunea repetitiva for;
daca valoarea expresiei de continuare este diferite de 0:
- se executa instructiunea;
- se evalueaza expresia de reinitializare
- se revine la Pas 2.

Subprograme predefinite
3.1 Subprograme. Mecanisme de transfer prin intermediul
parametrilor
Un subprogram este un ansamblu ce poate conine tipuri de date, variabile i
instruciuni destinate unei anumite prelucrri (calcule, citiri, scrieri). Subprogramul poate fi
executat doar dac este apelat de ctre un program sau de ctre un alt subprogram.
n limbajul C si C++, subprogramele sunt denumite funcii.
Funciile reprezinta un element fundamental al limbajului C/C++. Aa cum tim, orice
program C/C++ este constituit dintr-o succesiune de funcii, dintre care una este funcia
principal main(). La lansarea execuiei a unui program C/C++ este apelata funcia main().
n concluzie, ntr-un program C/C++ toate prelucrrile sunt organizate ca o ierarhie
de apeluri de funcii, baza acestei ierarhii fiind funcia main().

3.2 Funcii predefinite

Funcii matematice ( #include<cmath> )
int abs(int x);
Returneaz un ntreg care reprezint valoarea absolut a argumentului.
double floor(double x);
Returneaz un real care reprezint cel mai apropiat numr, fr zecimale, mai mic sau egal
cu x (rotunjire prin lips).
double ceil(double x);
Returneaz un real care reprezint cel mai apropiat numr, fr zecimale, mai mare sau egal
cu x (rotunjire prin adaos).

double sin(double x);

Returneaz valoarea lui sin(x), unde x este dat n radiani. Numrul real returnat se afl n
intervalul [-1, 1].
double cos(double x);
Returneaz valoarea lui cos(x), unde x este dat n radiani. Numrul real returnat se afl n
intervalul [-1, 1].
double tan(double x);
Returneaz valoarea lui tg(x), unde x este dat n radiani.

double asin(double x);

Returneaz valoarea lui arcsin(x), unde x se afl n intervalul [-1, 1]. Numrul real returnat
(n radiani) se afl n intervalul [-pi/2, pi/2].
double acos(double x);
Returneaz valoarea lui arccos(x), unde x se afl n intervalul [-1, 1]. Numrul real returnat
se afl n intervalul [0, pi].
double atan(double x);
Returneaz valoarea lui arctg(x), unde x este dat n radiani. Numrul real returnat se afl n
intervalul [0, pi].
double log(double x);
Returneaz logaritmul natural al argumentului ( ln(x) ).
double log10(double x);
Returneaz logaritmul zecimal al argumentului (lg (x) ).
double pow(double baza, double exponent);
Returneaz un real care reprezint rezultatul ridicrii bazei la exponent ().
double sqrt(double x);
Returneaz rdcina ptrat a argumentului.

Funcii caractere ( #include<ctype> )

int isalpha(int c);
Testeaz dac argumentul este liter mare sau mic. Echivalent cu isupper(c)|| islower(c).
int isdigit(int c);
Testeaz dac argumentul este cifr.
int islower(int c);
Testeaz dac argumentul este liter mic.
int isupper(int c);
Testeaz dac argumentul este liter mare.
int tolower(int c);
Funcia schimb caracterul primit ca argument din liter mare, n liter mic i returneaz
codul ASCII al literei mici. Dac argumentul nu este liter mare, codul returnat este chiar
codul argumentului.
int toupper(int c);
Funcia schimb caracterul primit ca argument din liter mic, n liter mare i returneaz
codul acesteia. Dac argumentul nu este liter mic, codul returnat este chiar codul
argumentului.

Funcii de conversie din ir n numr(de citire a unui numr dintr-un ir)

(prototip n <stdlib.h>)
long int atol(const char *npr);
Funcia convertete irul transmis ca argument (spre care pointeaz npr) ntr-un numr cu
semn, care este returnat ca o valoare de tipul long int. irul poate conine
caracterele '+' sau '-'. Se consider c numrul este n baza 10 i funcia nu semnalizeaz
eventualele erori de depire care pot apare la conversia din ir n numr.
int atoi(const char *sir);
Converteste irul spre care pointeaza sir ntr-un numr ntreg.
double atof(const char *sir);
Funcia converteste irul transmis ca argument ntr-un numr real cu semn (returneaz
valoare de tipul double). n secvena de cifre din ir poate apare
litera 'e' sau 'E' (exponentul), urmat de caracterul '+' sau '-' i o alt secven de cifre.
Funcia nu semnaleaz eventualele erori de depire care pot apare.
Siruri de caractere
Functia strlen
int strlen(nume_sir); returneaza lungimea efectiva a unui sir (fara a numara terminatorul

de sir).
Exemplu:
char a[50]=ora de informatica; strlen(a) = 18

Functia strcpy
strcpy(sir_destinatie,sir_sursa); copiaza sirul sir_ sursa in sir_destinatie (se

simuleaza atribuirea a=b).

Functia strcat
strcat(dest,sursa); adauga sirului dest sirul sursa. Sirul sursa ramane nemodificat.

Operatia se numeste concatenare si nu este comutativa.

Exemplu:
char *a=vine ,*b=vacanta?;
strcat(a,b); a = vine vacanta?;

Functia strncat
strncat(dest,sursa,nr);

din sirul sursa. Sirul sursa

Exemplu:

adauga dest primele nr caractere

ramane nemodificat.

char *a=vine ,*b=vacanta?;

strncat(a,b,4); a = vine vaca;

Functia strchr
strchr(sir,c); are rolul de a cauta caracterul c in sirul sir. Cautarea se face de la stanga la

dreapta, iar functia intoarce adresa subsirului care incepe cu prima aparitie a caracterului c. Daca nu
este gasit caracterul, functia returneaza 0. Diferenta dintre adresa sirului initial si cea a subsirului
returnat reprezinta chiar pozitia caracterului cautat in sirul dat.
Exemplu:
char *a=acesta este un sir,b=t,c=x,d;
cout<<strchr(a,b); se tipareste ta este un sir;

cout<<strchr(a,c); nu se tipareste nimic (se tipareste 0 daca se face o conversie

la int a lui strchr(a,c) ;
d= strchr(a,b);
cout<<Caracterul apare prima data la pozitia <<d-a;

Functia strcmp
int strcmp(sir1,sir2); are rolul de a compara doua siruri de caractere. Valoarea returnata
este <0 (daca sir1<sir2), =0 (daca sir1=sir2) si >0 (daca sir1>sir2). Functia strcmpface

distinctie intre literele mari si cele mici ale alfabetului.

Obs: Functia strcmp returneaza diferenta dintre codurile ASCII ale primelor caractere care nu coincid
Functia strstr
strstr(sir1,sir2); are rolul de a identifica daca sirul sir2 este subsir al sirului sir1. Daca
este, functia returneaza adresa de inceput a subsirului sir2 in sirul sir1, altfel returneaza adresa 0.
In cazul in care sir2 apare de mai multe ori in sir1, se returneaza adresa de inceput a primei

aparitii. Cautarea se face de la stanga la dreapta

Functia strtok
strtok(sir1,sir2); are rolul de a separa sirul sir1 in mai multe siruri (cuvinte) separate
intre ele prin unul sau mai multe caractere cu rol de separator. Sirul sir2 este alcatuit din unul sau
mai multe caractere cu rol de separator.
Functia strtok actioneaza in felul urmator:
o
Primul apel trebuie sa fie de forma strtok(sir1,sir2); Functia intoarce adresa primului
caracter al primei entitati. Dupa prima entitate, separatorul este inlocuit automat prin caracterul
nul.
o
Urmatoarele apeluri sunt de forma strtok(NULL,sir2); De fiecare data, functia intoarce
adresa de inceput a urmatoarei entitati, adaugand automat dupa ea caracterul nul.
o
Cand sirul nu mai contine entitati, functia returneaza adresa nula.

Exemplu:
//Sa se separe cuvintele dintr-un text.
#include <iostream.h>
#include <conio.h>
#include <string.h>
void main()
{char text[100],cuv[10][10],*p,*r,separator[]=",. !?";int i=0,nr=0;
clrscr();
cout<<"Dati sirul:";cin.get(text,100);
strcpy(p,text);
p=strtok(p,separator);
while (p)
{strcpy(cuv[++nr],p);
p=strtok(NULL,separator);}
cout<<"Sunt "<<nr<<" cuvinte:"<<endl;
for (i=1;i<=nr;i++) cout<<cuv[i]<<endl;
getch();}

Tipuri structurate de date

O structur de date reprezint un ansamblu (o colecie) de date organizate dup
anumite reguli, reguli care depind de tipul de structur.

4.1 Tipul Tablou

Un tablou reprezint o colecie de date de acelai tip, memorate ntr-o zon de memorie
contigu, reunite sub un nume comun (numele tabloului).
Declararea unei variabile de tip tablou :
tip nume[nr_max_elem];
Am declarat un tablou format din nr_max_elem elemente de tipul tip. Nr_max_elem indic numrul
maxim de elemente din tablou i trebuie obligatoriu s fie o expresie constant.

nume[0]

nume[1]

nume[2]

nume[nr_max_elem-2] nume[nr_max_elem -1]

Deoarece elementele unui tablou sunt memorate n ordine, unul dup altul ntr-o zon contigu,
pentru a ne referi la un element al unui tablou putem specifica numele tabloului din care face parte
elementul i poziia sa n tablou, prin numrul su de ordine (numerotarea ncepnd de la 0). Dac
dorim s numerotm de la 1 poziiile din tablou atunci tabloul trebuie declarat cu nr_max_elem+1
elemente.
Referirea la un element al tabloului se face astfel:
nume[indice] ;
Am specificat elementul indice al tabloului nume (indice reprezint numrul de ordine al
elementului n tablou, cuprins ntre 0nr_max_elem-1 sau 1 - nr_max_elem). Parantezele ptrate
[ ] constituie operatorul de indexare. Operatorul de indexare are prioritate maxim.

OBSERBAII
1. La ntlnirea unei declaraii de variabil tablou, compilatorul verific dac dimensiunea
zonei de memorie necesar pentru memorarea tabloului nu depete memoria disponibil.
Dimensiunea zonei de memorie necesar unui tablou se calculeaz nmulind numrul de
elemente cu numrul de octei necesari pentru memorarea unui element, adic
nr_max_elem*sizeof (tip).

2. Ca n cazul oricrei declaraii de variabile, putem iniializa elementele unei variabile

tablou, chiar de la declarare.
tip nume [nr_max_elem]={ val0, val1,...,valk};
3. Un astfel de tablou, pentru care la declarare este specificat o singur dimensiune, iar
poziia unui element este specificat utiliznd un singur indice, se numete tablou
unidimensional sau vector.
4. Elementele unui tablou pot fi de orice tip al limbajului. Prin urmare elementele unui
tablou pot fi de tip tablou! Declarare:
tip nume[Nr1][Nr2];
Am declarat un tablou cu maxim Nr2 elemente, fiecare element fiind un tablou cu Nr1
elemente de tipul specificat. Un astfel de tablou, pentru care la declarare trebuie s
specificm dou dimensiuni, iar poziia unui element este specificat utiliznd doi indici, se
numete tablou bidimensional sau matrice.

4.2 Tipul ir de caractere

Un ir de caractere este o succesiune de caractere terminat cu caracterul NULL. Caracterul
NULL este caracterul care are codul ASCII 0. n limbajul C/C++ nu exist un tip special pentru
irurile de caractere, acestea pot fi implementate ca vectori de caractere. Prin urmare,
declararea unei variabile ir de caractere cu numele identificator_sir, ce reprezint un ir de
lungime maxim lungime_max caractere, se poate realiza astfel:
| char identificator_sir[lungime_max] ;
Observaie:
Putem iniializa o variabil ir de caractere chiar de la declarare, cu o constant ir (n acest
caz, lungimea maxim a irului poate lipsi, fiind determinat automat).
Exemplu
char s1[]="Ana are mere", s2[50]="Gigel nu";
Pentru irul s1, lungimea a fost determinat automat: 12 octei (cte unul pentru fiecare
dintre cele 12 caractere din ir) + 1 octet suplimentar pentru marcajul de sfrit de ir, deci
n total 13 octei. Pentru s2, lungimea a fost specificat (50 de octei), primii 8 octei fiind
iniializai cu cele 8 caractere ale irului "Gigel nu", iar cel de-al noulea octet fiind iniializat
cu marcajul de sfrit al irului.
irurile de caractere pot fi prelucrate la nivel de caracter (pot fi parcurse caracter cu
caracter, ca un vector de caractere) sau pot fi prelucrate la nivel de structur (cu ajutorul
funciilor existente n bibliotecile limbajului).

Observaie
Din modul de reprezentare a unui ir de caractere deducem c o constant caracter (de
exemplu, 'a') nu este echivalent cu o constant ir de caractere (de exemplu cu "a").
Constanta 'a' este stocat pe un singur octet care conine codul ASCII al caracterului.
Constanta "a" este stocat pe doi octei (primul conine codul ASCII al caracterului, iar al
doilea, marcajul de sfrit de ir - NULL).

4.3 Tipul nregistrare (struct)

n C++ exist un tip de date numit struct, care permite mai multe cmpuri de tipuri diferite
numite nregistrri.
Forma general este:
struct [nume structura]
{
<tip> <nume_variabila>,<nume_variabila2>,;
<tip> <nume_variabila>,<nume_variabila2>,;

}[nume_variabila de tip struct];

Accesul la o valoare a unui cmp:
| //nume_variabila.nume_camp //se ajunge la cmp prin
separatorul .

Fiiere text
5.1 Fiiere text. Tipuri de acces
Un fiier este o colecie de date de acelai tip, memorate pe suport extern(hard-disk,
discheta, cd, etc).
Avantajele utilizrii fiierelor sunt o consecin a proprietilor memoriilor externe. Fiierele
permit memorarea unui volum mare de date persistente (care nu se "pierd" la ncheierea
execuiei programului sau la nchiderea calculatorului).
Declararea fiierelor
Operaiile de intrare/ieire n limbajul C++ au utilizat pn acum stream-urile cin i cout,
care erau automat asociate tastaturii, respectiv ecranului. Pentru ca un program s poat
citi informaii dintr-un fiier, respectiv s scrie informaii ntr-un fiier, trebuie s asociem
fiierul respectiv unui stream de intrare/ieire.
n fiierul antet <fstream> sunt declarate clasele ifstream, ofstream i fstream. Pentru a
utiliza ntr-un program operaii de intrare/ieire folosind fiiere trebuie s declarm variabile
de tipurile ifstream, ofstream sau fstream. Mai exact:
ifstream - declarare stream de intrare (numai pentru operaii de citire);
ofstream - declarare stream de ieire (numai pentru operaii de scriere);
fstream - declarare stream de intrare/ieire (n care se pot realiza att operaii de
citire, ct i operaii de scriere, n funcie de modul specificat la deschidere).

5.2 Proceduri i funcii predefinite pentru fiiere text

Deschiderea unui fiier:
|ifstream f1;
|f1.open(date.in);
sau:
|ifstream f1(date.in);
sau:
|ofstream f1(c:\\users\user\desktop\file.in);
obs: se va folosi using namespace std;
Citirea datelor dintr-un fiier:
Dup deschiderea fiierului ca fiier de intrare se pot realiza operaii de citire. n
acest scop se poate utiliza operatorul de citire >>, sau pot fi utilizate funcii-membru
specifice.

Una dintre particularitile citirii cu operatorul >> este faptul c ignor caracterele
albe. Prin urmare, dac intenionm s citim toate caracterele din fiier(inclusiv
spaiu,tab,enter), acest mod de citire este inadecvat. Se va folosi pt acest scop funcia get().
|ifstream f1(text.in);
|char c[10];
|f.get(c,10);
Scrierea datelor ntr-un fiier:
Dup deschiderea fiierului ca fiier de ieire, se pot realiza operaii de scriere
utilizbd operatorul de scriere <<.
|ofstream fout(date.out);
|fout<<Salut;
Detectarea sfritului de fiier:
Pentru a testa dac pointerul de fiier a ajuns la sfritul fiierului putem utiliza
funcia membr eof(). Funcia eof() returneaz valoarea 0 dac nu am ajuns la sfritul
fiierului, respectiv o valoare diferit de 0 daca s-a ajuns la sfrit.
ifstream f(file.in);
int v[10], i=0;
while(!f.eof())
f>>v[++i];
nchiderea unui fiier:
Dup realizarea tuturor operaiilor cu un fiier acesta trebuie nchis. nchiderea unui
fiier se realizeaz prin apelarea funciei membre close().
|f1.close();

Algoritmi elementari
6.2 Divizibilitate. Numere prime. Algoritmul lui Euclid
Divizibilitate
void nr_divizori(int n)
{
int d,nr;
nr=0;
for(d=1;d<=n;d++)
if(n%d==0)
nr++;
return nr;
}
Numere prime
bool prim(int n)
{
ind d=3;
if(x==2)
return true;
if(x%2==0 || x==1)
return false;
while(d*d<=x)
if(x%d==0)
return false;
else
d=d+2;
return true;
}
Algoritmul lui Euclid
int euclid(int a, int b)
{
int rest;
while(b)
{
rest=a%b;
//calculez restul
a=b;
//impartitorul devine deimpartit
b=rest;
//restul devine impartitor
}
return a;
//ultimul rest diferit de 0
}

6.3 irul lui Fibonacci. Calculul unor sume cu termenul

general dat.

Afiare numere irul lui Fibonacci.

int main()
{
int a1=0, a2=1, a3, n;
cin>>n;
cout<<a1<<a2;
for(i=1;i<=n-2;i++)
{
a3=a1+a2;
cout<<a3;
a1=a2;
a2=a3;
}
return 0;
}
Descompunere in factori primi

int main()
{
int n,d=2,p;
cin>>n; // numarul de descompus
while(n>1)
{
p=0;
while(n%d==0)
{
p++;
n=n/d;
}
if(p)
cout<<d<<la puterea<<p<<endl;
d++;
}
return 0;
}

6.4 Metode de ordonare

1. Metoda bulelor
O metod de sortare este de a parcurge vectorul, comparnd fiecare dou elemente vecine
i daca este cazul interschimbndu-le. Cum ntr-o singur trecere nu se pot realiza sortareea
vectorului, acest procedeu se repeta pn cnd vectorul devine sortat(la ultima trecere nu
se mai efectueaza nicio schimbare)
do
{
ok=0; //initial nu am facut nicio schimbare
for(i=1;i<=n-1;i++)
if(a[i]>a[i+1])
{
//nu sunt in ordine, le interschimb
aux=a[i];
a[i]=a[i+1];
a[i+1]=aux;
ok=1; //retin ca am facut schimbari
}
}while(ok!=0); //procesul se repeta cat timp se executa schimbari
Se execut n cel mai ru caz n*n operaii
2. Sortare prin inserie
Metoda de sortare prin inserie este, de asemenea, o metod simpl, pe care o utilizm
adesea cnd ordonm crile la jocurile de cri: de fiecare dat cnd tragem o carte, o
plasm pe poziia sa corect, astfel nct n mn crile s fie ordonate
Algoritmul de sortare prin inserie construiete pas cu pas lista de elemente sortate,
adugnd la ea cte un element la un moment dat. La fiecare pas un element este extras din
din lista iniial i este introdus n lista de elemente sortate. Elementul este inserat n poziia
corect n lista sortat, astfel nct ea s rmn sortat n continuare.
Utiliznd aceast idee, sortm vectorul astfel: parcurgem vectorul, element cu element. La
fiecare pas i, cutm poziia corect a elementului curent a[i], astfel nct secvena
a[0],a[1],,a[i] s fie ordonat.
for(i=1;i<=n;i++)
{
v=a[i]; // caut pozitia lui v
for(poz=i; poz>1 && a[poz-1]>v; poz--)
a[poz]=a[poz-1]; //mut la dreapta elementele >v
a[poz]=v; //poz este pozitia curenta pentru v
}
Se execut n cel mai ru caz n*n operaii => O(n*n)

3. Sortare prin selecie

Sortarea prin selecie are dou variante : sortarea prin selecia elementului maxim i
sortarea prin selecia elementului minim. n ambele variante, ideea de baz este aceai: se
selecteaz cel mai mare element din vector(sau cel mai mic) i se plaseaz pe ultima
poziie n vector(respectiv pe prima poziie). Apoi se calculeaz cel mai mare dintre
elementele rmase i se plaseaz pe penultima poziie n vector .a.m.d. Acest procedeu
se repet de n-1 ori.

for(dr=n; dr>1; dr--) //calculez maximul de la 1 la dr

{
for(max=a[1],pozmax=1,i=2; i<=dr; i++)
if(a[i]>max)
{
max=a[i];
pozmax=i;
}
a[pozmax]=a[dr]; //plasez maximul pe pozitia dr
a[dr]=max;
}
O(n*n)
Sortare prin selecie directa
Considerm un vector de elemente comparabile ntre ele i dorim s le ordonm cresctor.
Pentru aceasta comparm primul element cu toate elementele care urmeaz dup el. Dac
gsim un element mai mic dect primul atunci le interschimbm pe cele dou. Apoi
continum cu al doilea element al irului, pe care, de asemenea l comparm cu toate
elementele care urmeaz dup el i n caz de inversiune interschimbm cele dou elemente.
Apoi procedm la fel cu al treilea element al irului iar procesul continu astfel pna la
penultimul element al irului care va fi comparat cu ultimul element din ir.

for(i=1;i<n;i++)
for(j=i+1;j<=n;j++)
if(a[j]<a[i])
{
aux=a[i];
a[i]=a[j];
a[j]=aux;
}
O(n*n)

Sortare prin numrarea apariiilor

n anumite probleme, elementele vectorului au ca valori numere naturale dintr-un interval
[0,Max) de dimensiune redus (sau au valori care pot fi asociate numerelor naturale dintrun astfel de interval). Prin dimensiune redus nelegem c se poate declara un vector v cu
Max componente ntregi.
n acest caz particular, cea mai bun metod este sortarea prin numrarea apariiilor: se
numr pentru fiecare valoare din intervalul [0,Max) de cte ori apare n vector.
#include<iostream>
#define Max 1000
#define NrMax 10000
int n, v[Max], a[NrMax];
int main()
{
int x,i,j,nr;
cin>>n;
for(i=1;i<=n;i++)
{
cin>>x; // se citeste o noua valoare
v[x]++; // marim numarul de aparitii a valorii x
}
//plasam in ordine elementele in vectorul a
for(nr=i=1; i<=Max; i++)
for(j=1;j<=v[i];j++)
a[nr++]=i;
for(i=1;i<=n;i++)
cout<<a[i]<< ;
return 0;
}
Se efectueaz n+Max operaii.

6.5 Interclasare
Fie a un vector cu n elemente si b un vector cu m elemente, sortai n ordine cresctoare.
Pentru a construi un al treilea vector, c, sortat cresctor, se parcurg cei doi vectori,
comparnd la fiecare pas elementul curent din a cu elementul curent din b. Cel mai mic
dintre cele dou elemente va fi copiat n vectorul c, avansnd doar n vectorul din care am
copiat. Cnd am epuizat elementele din unul din cei doi vectori, copiem elementele rmase
n cellalt, deoarece nu mai avem cu ce le compara.

i=j=1;
k=0;
while(i<=n && j<=m)
if(a[i]<b[j])
c[++k] = a[i++];
else
c[++k] = b[j++];
while(i<=n)
c[++k]=a[i++];
while(j<=m)
c[++k]=b[j++];

Subprograme definite de utilizator

7.1 Subprograme n limbajul C/C++
n limbajele C/C++ subprogramele sunt denumite funcii.
Funciile reprezint un element fundamental al limbajului C/C++. Orice program C/C++ este
constituit dintr-o succesiune de funcii, dintre care una este funcia principal, denumit
main(). La lansarea n execuie a unui program C/C++ se apeleaza funcia main(). Funciile
apelate pot sa fie predefinite sau definite de utilizator.
n concluzie, ntr-un program C/C++ toate prelucrrile sunt organizate ca o ierarhie de
apeluri de funcii, baza acestei ierarhii fiind funcia main().
Pentru a dezvolta i utiliza funcii proprii este necesar s cunoatem cum se definesc, cum se
declar, i cum se apeleaz funciile.

7.2 Definiia unei funcii

Definiia unei funcii este constituit dintr-un antet, care conine numele funciei, tipul
rezultatului returnat de funcie i lista parametrilor funciei i bloc de instruciuni, care
descrie prelucrrile efectuate de funcie.
Formatul general al definiiei unei funcii este:
tip nume(lista_parametri_formali)
{
declaratii_variabile_locale;
instructiuni
}
unde:
tip reprezint tipul rezultatului returnat de funcie
nume reprezint numele funciei
lista_parametri_formali este constituit din una sau mai multe declaraiide parametri formali,
separate prin virgul, sau poate lipsi.
O declaraie de parametru formal specific tipul i numele parametrului, sub forma: tip
nume.

Parametrii unei funcii constituie o interfat prin intermediul creia funcia

comunic cu exteriorul. Parametrii desemneaz date primite de funcie din exterior, date de
care depind prelucrrile efectuate de funcie.

Parametrii formali sunt denumii astfel deoarece cu ajutorul lor se descriu n mod
formal operaiile la care vor fi supuse datele ce vor fi transmise de programul apelant spre
program.
Lista de parametrii formali poate s fie vid, ns i n acest caz parantezele trebuie
s apar.
Dac tipul rezultatului returnat de funcie nu este specificat, implicit acesta este
considerat int. Dac funcia nu trebuie s ntoarc nicio valoare, se specific tip al
rezultatului void.

7.3 Declararea funciilor

Definiia funciei informeaz compilatorul despre formatul unei funcii (nume, parametri,
tip rezultat) i descrie prelucrrile efectuate de funcie.
Declararea unei funcii informeaz compilatorul despre existena funciei i formatul
acesteia. Mai exact, o declaraie de funcie specific numele funciei, tipul rezultatului
returnat de funcie i parametrii acesteia.
tip nume(lista_parametri);
Se observ c o declaraie de funcie este constituit din antetul funciei , urmat de ; , nu
de blocul de instruciuni al funciei. Spre deosebire de definiie, n declaraie lista
parametrilor nu conine n mod obligatoriu i numele parametrilor, ci este permis doar
specificarea tipurilor parametrilor.
Declaraia unei funcii se mai numete i prototip.

7.4 Apelul funciilor

Apelul funciei se poate realiza n dou moduri printr-o instruciune de apel sau ca
operand ntr-o expresie.
Instruciunea de apel al unei funcii are urmtorul format general:
nume(lista_parametri_actuali);
,unde nume reprezint numele funciei. Lista parametrilor actuali este format dintr-o
succesiune de expresii, separate prin virgul.
Utilizm instruciuni de apel atunci cnd funcia nu returneaz nicio valoare sau
atunci cnd nu dorim s utilizm valoarea returnat de funcie, ci ne intereseaz doar
efectuarea prelucrrilor desrise de funcie.

n cazul n care dorim s utilizm valoarea returnat de funcie ca operand ntr-o

expresie, vom apela funcia n cadrul expresiei astfel:
nume(lista_parametri_actuali)
Se poate observa c n acest caz lipseste caracterul ; care marcheaz sfritul
instruciunii de apel.
La apelul unei funcii, valorile parametrilor actuali sunt atribuite, n ordine,
parametrilor formali corespunztori.
Regul fundamental: Parametrii actuali trebuie s corespund cu parametrii
formali ca numr, ordine i tip
Unde sunt memorate valorile parametrilor actuali?
La apelarea unei funcii, se aloc spaiu de memorie pe stiv pentru valorile
parametrilor actuali (transfer prin valoare). La ncheierea execuiei funciei, zona de
memorie alocat pe stiv pentru apel este eliberat.
Ca urmare a acestui mod de funcionare, chiar dac n blocul funciei sunt modificate
valorile parametrilor, la ieirea din funcie, deoarece memoria alocat pentru parametri se
elibereaz, valorile modificate se pierd.
Prin urmare, daca valorile parametrilor sunt modificate n blocul funciei, la ieirea
din funcie valorile variabilelor care au fost folosite ca parametri actuali rmn
nemodificate.
Pentru a se pstra valorile modificate la ieirea din funcie, acestea nu se vor
transmite ca parametri expresii ale cror valori s fie copiate pe stiv, ci se vor stransmite
adresele variabilelor ale cror valori dorim s le modificm.

7.5 Transferul parametrilor prin referin

Apare frecvent necesitatea de a modifica valorile parametrilor funciei i de a utiliza n afara
funciei valorile modificate. n acest caz, este necesar s transmitem funciei adrese (transfer prin
referin)
Tipul referin este o facilitate suplimentar a limbajului C++, introdus pentru a acoperi o
lacun important a limbajului C, i anume transmiterea parametrilor prin referin.
O variabil de tip referin conine adresa unei alte variabile (asemntor unui pointer), dar
nu este interpretat ca pointer, ci ca un alt nume asociat variabilei (un alis, un sinonom).
Declararea unei referine:
tip &variabila_referinta = variabila_referita;

Declaraia de mai sus creeaz un alt nume (variabila_referinta) pentru

variabila variabila_referita avand tipul tip.

Exemplu:
int x=10;
int &rx=x;
cout<<x;
cout<<rx;
Cout<<x si cout<<rx vor avea acelai efect!
Observaii:
1. Valoarea atribuit unei referine NU poate fi schimbat, ea rmne valabil pe toat
durata execuiei blocului de program n care este declarat.
2. Dei referina seamn cu o variabil, ea nu este nsi o variabil, ci doar o referire
la variabila respectiv (o adres).
Referinele nu sunt utile dect n utilizarea acestora drept parametrii ai unei funcii.
void interschimba(int &a, int &b)
{
int aux;
aux=x; x=y; y=aux;
}
n acest caz, n urma executrii funciei valorile variabilelor din parametri actuali ii vor
pstra valoarea cu care au rmas n urma executrii blocului de instruciuni din funcie.
n concluzie, n cazul utilizrii referinelor drept parametri, beneficiem de toate
avantajele pointerilor(posibilitatea de a modifica valorile parametrilor), fr complicaii de
sintax.
Observaii:
1. Numele unui tablou este un pointer ctre primul element al tabloului! Prin urmare,
cnd se utilizeaz vectori ca parametrii, la definirea/declararea funciei se pot utiliza
pentru declararea parametrului una din construciile: tip [], sau tip[Max].
2. La apelarea unei funcii care are un parametru de tip tablou, trebuie transmis doar
numele tabloului (acesta este el nsui o adres)
Exemplu:
Declarare: void functie(int a[], int n);
Apel: functie(a,n);

7.6 Variabile globale i variabile locale

Vom diferenia cele dou categorii de variabile analiznd urmtoarele caracteristici:
- poziia declaraiei variabilei;
- clasa de memorare (precizeaz zona de memorie n care este alocat variabila n
segmentul de date al programului, pe stiv, etc. );
- durata de via (precizeaz timpul n care variabila are alocat zon de memorie);
- domeniul de vizibilitate (precizeaz zonele din program n care variabila respectiv
este vizibil, deci poate fi utilizat ).

Variabilele globale

- poziie: sunt declarate n exteriorul oricrei funcii;

- clasa de memorare : li se aloc memorie n segmentul de date al programului,
-

memoria alocat fiind automat iniializat cu 0;

durata de via: memoria rmne alocat pn la sfritul execuiei programului;
domeniu de vizibilitate: sunt vizibile din momentul declarrii pn la sfritul
programului, n toate modulele acestuia, chiar i n alte fiiere surs, cu excepia
cazurilor de omonimie.

Variabilele locale

- poziie: sunt declarate n blocul unei funcii;

- clasa de memorare : li se aloc memorie pe stiv, memoria alocat nefiind
-

iniializat automat;
durata de via: memoria rmne alocat pn la sfritul execuiei blocului n care
este declarat variabila;
domeniu de vizibilitate: sunt vizibile numai n blocul n care sunt declarate.

Regula de omonimie
Deoarece variabilele globale au alt clas de memorare dect variabilele locale, este permis
s declarm o variabil local care s aib acelai nume cu cel al unei variabile gloable. O
astfel de situaie este denumit omonimie.
Regula de omonimie: n interiorul blocului n care sunt declarate, variabilele locale au
prioritate fa da variabilele globale omonime.

Recursivitate
8.1 Prezentare general
n informatic i n matematic, recursivitatea este un concept fundamental.
Spunem c o noiune este definit recursiv dac n cadrul definiiei intervine insi
noiunea care se definete.
Reguli fundamentale pentru ca recursivitatea s fie definit corect sunt:
1. trebuie s existe cazuri elementare, care se pot rezolva direct ;
2. pentru cazurile care nu se rezolv direct, recursivitatea trebuie s progreseze ctre
un caz elementar.
Recursivitatea se realizeaz prin intermediul funciilor.
O funcie se numete recursiv dac se autoapealeaz .