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 Funcții 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

Fișiere text ......................................................................................................................................... 23

5.1 Fișiere text. Tipuri de acces ............................................................................................... 23

5.2 Proceduri și funcții predefinite pentru fișiere 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 Definiția unei funcții .......................................................................................................... 31

7.3 Declararea funcțiilor ......................................................................................................... 32

7.4 Apelul funcțiilor ................................................................................................................. 32

7.5 Transferul parametrilor prin referință .............................................................................. 33

7.6 Variabile globale și variabile locale ................................................................................... 35

Recursivitate ..................................................................................................................................... 36

8.1 Prezentare generală .......................................................................................................... 36

1

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 obţine, pentru anumite date de intrare, rezultatul problemei (date de ieşire):

Date de intrare Date de ieşire

De exemplu, orice reţetă de bucătărie poate fi considerată un algoritm prin care, plecând de la materiile prime, obţinem printr-o succesiune finită de operaţii produsul finit.

Exemplu:

Presupunând că dispunem de un aragaz, o tigaie, 2 ouă, sare şi 2oo ml ulei, să pregătim ochiuri.

Date de intrare: ouă, ulei, sare. Date de ieşire: ochiuri. Pas 1: Se pune tigaia pe foc. Pas 2: Se toarnă uleiul în tigaie. Pas 3: Aşteptăm până când se încinge uleiul. Pas 4: Spargem cu îndemânare ouăle în tigaie. Pas 5: Aşteptăm până când ouăle se rumenesc. Pas 6: Dacă nu ţinem regim, adăugăm sare.

Observăm că am descris o succesiune de paşi, prin care, pentru orice ,,date” de intrare (ulei, sare, ouă), obţinem rezultatul dorit (ochiuri). Fiecare pas constă din operații culinare specifice, care se execută în ordinea în care sunt specificate.

ALGORITM

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

Definiţie: 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 ieşire (datele pe care trebuie să le furnizeze algoritmul în exterior), precum şi date de manevră (date temporare, necesare algoritmului pentru a obţine datele de ieşire pe baza datelor de intrare).

Datele cu care lucrează algoritmii pot fi clasificate din mai multe puncte

de vedere. O primă clasificare a datelor, în funcţie de posibilitatea de a-şi modifica valoarea, este:

Constante - date care nu îşi modifică valoarea; de exemplu: 10, 3 .14,

”sir de caractere”, ’A’ de caractere”, ‘A’, fals ( 0 ). Variabile - date care îşi modifică valoarea. O variabilă poate fi referită

printr-un nume (o succesiune de litere, cifre şi liniuţă de subliniere, primul caracter fiind 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 modifica.

Pentru a cunoaşte natura valorilor care pot fi asociate variabilelor

precum şi a operaţiilor permise cu acestea, variabilele trebuie declarate înainte de a fi utilizate.

În funcţie de valoarea lor, datele pot fi clasificate 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 adevărat 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 Pentru adunare folosim operatorul +

o Pentru scadere folosim operatorul -

o Pentru inmultire folosim operatorul *

o Pentru impartire folosim operatorul / • 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 instrucţiuni care se

execută necondiţionat, o singură dată. O astfel de structură poate să conţină

instrucţiuni pentru citirea şi scrierea datelor, calcule matematice (expresii) —

instrucţiuni 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 efectuării repetitive a unei secvenţe de instrucţiuni, cât timp

este îndeplinită o anumită condiţie sau pâna când se îndeplineşte o anumită

condiţie. Repetiţia secvenţei de instrucţiuni se numeşte „iteraţie”.

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 instrucţiunea cât timp…execută;

daca valoarea expresiei este adevărat, se execută instrucţiunea, apoi se revine la Pas 1.

2) Executa… Cat timp

Executa

Instructiune;

Cat timp expresie ;

Efect:

Pas 1: se execută instrucţiunea; Pas 2: se evaluează expresia; Pas 3:dacă valoarea expresiei este fals(0) se iese din instrucţiunea repetitivă; dacă valoarea

expresiei este adevărat(1), se revine la Pas 1.

3) Pentru

Pentru contor <- exp_i, exp_f, x executa

Instructiune;

Sf Pentru

Efect: Pas 1: se execută instrucţiunea; Pas 2: se evaluează expresia; Pas 3:dacă valoarea expresiei este adevărat(1) se iese din instrucţiunea 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 convenţii, respectate în mod sistematic, care definesc operațiile permise (denumite şi instrucţiuni) pentru reprezentarea algoritmilor.

Un Iimbaj pseudocod se prezintă sub formă de text şi se bazează pe nişte aşa-numite cuvinte cheie. Fiecare cuvânt cheie identifică în mod unic un anumit tip de acţiune.

Acţiunile algoritmului se reprezintă în pseudocod prin ceea ce numim instrucţiuni. Ansamblul cuvintelor cheie împreună cu regulile care trebuie respectate în folosirea lor, alcătuiesc ceea ce numim sintaxa Iimbajului pseudocod.

Declararea datelor Sintaxa: variabila tip;

Operaţia de citire Sintaxa: citeşte variabila1, variabila2, ..., variabilan; Efect: Prin operaţia de citire (denumită ş1 operaţie de intrare) se preiau succesiv valori de la tastatură şi se asociază, în ordine, variabilelor specificate. Operaţia de scriere Sintaxa: scrie expresie1, expresie2, ..., expresien; Efect: Operaţia de scriere (denumită şi operație de ieșire) presupune evaluarea în

ordine a expresiilor specificate

Operaţia de atribuire Sintaxa: variabila ← expresie; Efect: se evaluează expresia, apoi se atribuie valoarea expresiei variabilei din membrul stâng.

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 Sintaxa = reprezintă totalitatea regulilor care trebuie respectate pentru

definirea elementelor limbajului; 2 Semantica = defineşte semnificaţia construcţiilor sintactic corecte; 3 Pragmatica = defineşte modul de utilizare a elementelor limbajului. Implementarea unui algoritm într-un limbaj de programare se numeşte program.

Vocabularul limbajului este alcătuit 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 întâlniţi şi sub denumirea de “nume” şi au rolul de a desemna

nume de variabile, constante , funcţii, etc. Din punct de vedere sintactic identificatorii sunt o succesiune de litere, cifre şi liniuţe de subliniere dintre care prima trebuie să fie literă sau liniuţă de subliniere. Exemplu: nume corect de variabilă: a, a3, _56, nr_cuv nume greşit de variabilă: 3aq, nr cuv

Observaţii:

- un identificator poate să aibă orice lungime, semnificative sunt primele 31 caractere.

- C/C++ este case-sensitive (face distincţie între literele mari şi mici; adică un identificator a diferă de identificatorul A)

- identificatorii ar trebui să aibă denumirea în conformitate cu scopul utilizării 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 utilizaţi numai în scopul pentru care au fost creaţi. Separatorii Sunt utilizaţi pentru a separe unităţile sintactice între ele; Există mai multe tipuri de separatori:

- separatori standard: spaţiul (‘ ’), tab(‘\t’), enter (new line ‘\n’)

- delimitatori: operatorul virgulă (‘,’)

- separatori speciali: ‘;’(este utilizat la finalul unei instrucţiuni), ‘’(apostroafe) şi “” (utilizaţi 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 maşină) 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 până la sf. de linie) cu marcajul // Sunt utilizate pentru a creşte gradul de lizibilitate a programului şi ajută

utilizatorii multiplii la înţelegerea 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ă posibilităţi de verificări 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

următor:

#define DIMENSIUNE 1000

DIMENSIUNE este un nume care există doar în faza de preprocesare, după care nu va fi

stocat în memorie. Declaraţia se poate plasa în fişiere header pentru a furniza o singură

valoare pentru toate fişierele sursă care îl vor utiliza.

Dacă se doreşte evitarea eventualelor probleme (bug-uri) provocate de această declaraţie,

în special prin lipsa verificării tipurilor de date utilizate, se poate folosi o variabilă const care

poate fi plasată oriunde în program, astfel încât să poată fi folosită în faza compilării:

const int DIMENSIUNE = 1000;

Utilizarea valorilor constante este importantă, de exemplu, în declararea tablourilor de date. De exemplu, se poate face declaraţia: 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 mulţimea valorilor pe care le pot lua datele de tipul

respectiv, modul de reprezentare în memorie precum şi operaţiile care se pot aplica datelor

de tipul respectiv.

Operatorii aritmetici : +, -, *, /, %

Operatorul Tipul operaţiei

+, - Semne (operatori unari)

*, /, % De multiplicitate (operatori binari)

+,- Aditivi (operatori binari)

Operatorii logici sunt de două tipuri: logici globali şi logici pe biţi (sunt operatori binari toţi în afară de negaţia logică şi pe biţi care sunt unari) Operatori logici globali (&&, ||, !)

Operatori relaționali (<,>,<=,>=,!=) 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:

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:

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

Denumirea Nr. octeţi - în virgulă mobilă

Valori

float 4 octeţi [3.4*10-38,3.4*1038]U [-3.4*10+38,-3.4*10-38]

double 8 octeţi [1.7*10-308,1.7*10308]U [-1.7*10+308,-1.7*10-308]

long double 10 octeţi [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 modifica valoarea pe parcursul execuţiei programului. În limbajul C/C++, înainte de a utiliza o variabilă, trebuie să o declarăm. La declarare, trebuie să specificăm numele variabilei, tipul acesteia şi, eventual, o valoare iniţială pe care dorim să o atribuim variabilei.

Denumirea Nr. octeţi Valori

int 2 octeţi cu semn [-32768, 32768]

unsigned int 2 octeţi fără semn [0, 65535]

long int 4 ocţeţi cu semn [-2147483648, 2147483647]

unsigned long int 4 ocţeţi fără semn [0, 4294967295]

Denumirea Nr. octeţi Valori

char 1 octet cu semn [128, 127]

unsigned char 1 octet fără semn [0, 255]

Formatul general al unei declaraţii 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 foloseşte (ȋn zona de preprocesare) construcția: #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 alcătuit dintr-o succesiune de module (numite funcții ),una dintre acestea fiind funcția principală numită main(). Forma generală a unei surse ȋn C/C++ este:

int main()

{

…..// corpul funcţiei ȋn care se vor scrie declaraţiile şi

instrucţiunile care trebuie executate şi care acum e vid

return 0;

}

Când execuția unui program se termină cu succes, ȋn mod uzual, programul returnează la încheierea

execuției valoarea 0.

Programul va conține şi o serie de fișiere antet(headere) în cazul în care vrem să folosim funcţii

standard din fișierele respective.

Zona de preprocesare apare în partea de sus a sursei şi este introdusă de caracterul ‘#’. În această

zonă vor fi incluse fișiere antet (headere) din care vor fi folosite funcţii standard (pentru

citire/scriere, prelucrări de date, funcţii matematice, etc.)

Exemplu:

# include <iostream.h> // am inclus fișierul antet iostream.h care

conține funcții pentru citire/scriere

Observație:

Dacă realizăm noi fișiere 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 mașină) 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 până la sf. de linie) cu marcajul // Sunt utilizate pentru a crește gradul de lizibilitate a programului şi ajută utilizatorii multiplii la înțelegerea 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. Instrucţiunea 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 fără format. În continuare ne vom referi la citirea şi scrierea fără 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 ieşire a datelor este “cout”-console output (pe monitor) iar operatorul de inserţie de date în fluxul se ieşire este “<<”.

Sintaxa: cout<<expresie; Citirea şi scrierea de date este gestionată din fişierul 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 conține tipuri de date, variabile și instrucțiuni destinate unei anumite prelucrări (calcule, citiri, scrieri). Subprogramul poate fi executat doar dacă este apelat de către un program sau de către un alt subprogram.

În limbajul C si C++, subprogramele sunt denumite funcții. Funcțiile reprezinta un element fundamental al limbajului C/C++. Așa cum știm, orice

program C/C++ este constituit dintr-o succesiune de funcții, dintre care una este funcția principală main(). La lansarea execuției a unui program C/C++ este apelata funcția main(). În concluzie, într-un program C/C++ toate prelucrările sunt organizate ca o ierarhie de apeluri de funcții, baza acestei ierarhii fiind funcția main().

3.2 Funcții predefinite

Funcţii 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 număr, fără zecimale, mai mic sau egal

cu x (rotunjire prin lipsă).

double ceil(double x);

Returnează un real care reprezintă cel mai apropiat număr, fără 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. Numărul real returnat se află în

intervalul [-1, 1].

double cos(double x);

Returnează valoarea lui cos(x), unde x este dat în radiani. Numărul 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]. Numărul 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]. Numărul real returnat

se află în intervalul [0, pi].

double atan(double x);

Returnează valoarea lui arctg(x), unde x este dat în radiani. Numărul 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 ridicării bazei la exponent ().

double sqrt(double x);

Returnează rădăcina pătrată a argumentului.

Funcţii 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); Funcţia 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); Funcţia 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.

Funcţii de conversie din şir în număr(de citire a unui număr dintr-un şir) (prototip în <stdlib.h>) long int atol(const char *npr); Funcţia converteşte şirul transmis ca argument (spre care pointează npr) într-un număr cu semn, care este returnat ca o valoare de tipul long int. Şirul poate conţine caracterele '+' sau '-'. Se consideră că numărul este în baza 10 şi funcţia nu semnalizează eventualele erori de depăşire care pot apare la conversia din şir în număr. int atoi(const char *sir); Converteste şirul spre care pointeaza sir într-un număr întreg. double atof(const char *sir); Funcţia converteste şirul transmis ca argument într-un număr real cu semn (returnează valoare de tipul double). În secvenţa de cifre din şir poate apare litera 'e' sau 'E' (exponentul), urmată de caracterul '+' sau '-' şi o altă secvenţă de cifre. Funcţia nu semnalează eventualele erori de depăşire 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); – adauga dest primele nr caractere

din sirul sursa. Sirul sursa ramane nemodificat. Exemplu: 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 colecție) de date organizate după

anumite reguli, reguli care depind de tipul de structură.

4.1 Tipul Tablou

Un tablou reprezintă o colecţie de date de acelaşi 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ă numărul

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 poziţia sa în tablou, prin numărul său de ordine (numerotarea începând de la 0). Dacă

dorim să numerotăm de la 1 poziţiile 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ă numărul de ordine al

elementului în tablou, cuprins între 0…nr_max_elem-1 sau 1 - nr_max_elem). Parantezele pătrate

[ ] constituie operatorul de indexare. Operatorul de indexare are prioritate maximă.

OBSERBAȚII

1. La întâlnirea unei declaraţii de variabilă tablou, compilatorul verifică dacă dimensiunea

zonei de memorie necesară pentru memorarea tabloului nu depăşeşte memoria disponibilă.

Dimensiunea zonei de memorie necesară unui tablou se calculează înmulţind numărul de

elemente cu numărul de octeţi necesari pentru memorarea unui element, adică

nr_max_elem*sizeof (tip).

2. Ca în cazul oricărei declaraţii de variabile, putem iniţializa 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

poziţia unui element este specificată utilizând un singur indice, se numeşte „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ă specificăm două dimensiuni, iar poziţia unui element este specificată utilizând doi indici, se numeşte „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] ;

Observaţie:

Putem iniţializa 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 octeţi (câte unul pentru fiecare

dintre cele 12 caractere din şir) + 1 octet suplimentar pentru marcajul de sfârşit de şir, deci

în total 13 octeţi. Pentru s2, lungimea a fost specificată (50 de octeţi), primii 8 octeţi fiind

iniţializaţi cu cele 8 caractere ale şirului "Gigel nu", iar cel de-al nouălea octet fiind iniţializat

cu marcajul de sfârşit 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

funcţiilor existente în bibliotecile limbajului).

Observaţie

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 conţine codul ASCII al caracterului.

Constanta "a" este stocată pe doi octeţi (primul conţine codul ASCII al caracterului, iar al

doilea, marcajul de sfârşit de şir - NULL).

4.3 Tipul înregistrare (struct)

În C++ există un tip de date numit struct, care permite mai multe câmpuri de tipuri diferite

numite înregistrări.

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 câmp:

| //nume_variabila.nume_camp //se ajunge la câmp prin separatorul “.”

Fișiere text 5.1 Fișiere text. Tipuri de acces

Un fișier este o colecție de date de același tip, memorate pe suport extern(hard-disk,

discheta, cd, etc).

Avantajele utilizării fişierelor sunt o consecinţă a proprietăţilor memoriilor externe. Fişierele

permit memorarea unui volum mare de date persistente (care nu se "pierd" la încheierea

execuţiei programului sau la închiderea calculatorului).

Declararea fișierelor

Operaţiile de intrare/ieşire în limbajul C++ au utilizat până acum stream-urile cin şi cout,

care erau automat asociate tastaturii, respectiv ecranului. Pentru ca un program să poată

citi informaţii dintr-un fişier, respectiv să scrie informaţii într-un fişier, trebuie să asociem

fişierul respectiv unui stream de intrare/ieşire.

În fişierul antet <fstream> sunt declarate clasele ifstream, ofstream şi fstream. Pentru a

utiliza într-un program operaţii de intrare/ieşire folosind fişiere trebuie să declarăm variabile

de tipurile ifstream, ofstream sau fstream. Mai exact:

ifstream - declarare stream de intrare (numai pentru operaţii de citire);

ofstream - declarare stream de ieşire (numai pentru operaţii de scriere);

fstream - declarare stream de intrare/ieşire (în care se pot realiza atât operaţii de

citire, cât şi operaţii de scriere, în funcţie de modul specificat la deschidere).

5.2 Proceduri și funcții predefinite pentru fișiere text

Deschiderea unui fișier:

|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 fișier:

După deschiderea fișierului ca fișier de intrare se pot realiza operații de citire. în

acest scop se poate utiliza operatorul de citire >>, sau pot fi utilizate funcții-membru

specifice.

Una dintre particularitățile citirii cu operatorul “>>“ este faptul că ignoră caracterele

albe. Prin urmare, dacă intenționăm să citim toate caracterele din fișier(inclusiv

spațiu,tab,enter), acest mod de citire este inadecvat. Se va folosi pt acest scop funcția get().

|ifstream f1(“text.in”);

|char c[10];

|f.get(c,10);

Scrierea datelor într-un fișier:

După deschiderea fișierului ca fișier de ieșire, se pot realiza operații de scriere

utilizâbd operatorul de scriere “<<”.

|ofstream fout(“date.out”);

|fout<<”Salut”;

Detectarea sfârșitului de fișier:

Pentru a testa dacă pointerul de fișier a ajuns la sfârșitul fișierului putem utiliza

funcția membră eof(). Funcția eof() returnează valoarea 0 dacă nu am ajuns la sfârșitul

fișierului, respectiv o valoare diferită de 0 daca s-a ajuns la sfârșit.

ifstream f(“file.in”);

int v[10], i=0;

while(!f.eof())

f>>v[++i];

Închiderea unui fișier:

După realizarea tuturor operațiilor cu un fișier acesta trebuie închis. Închiderea unui

fișier se realizează prin apelarea funcției 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.

Afișare 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, comparând fiecare două elemente vecine

și daca este cazul interschimbându-le. Cum într-o singură trecere nu se pot realiza sortareea

vectorului, acest procedeu se repeta până când 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 rău caz n*n operații

2. Sortare prin inserție

Metoda de sortare prin inserție este, de asemenea, o metodă simplă, pe care o utilizăm

adesea când ordonăm cărțile la jocurile de cărți: de fiecare dată când tragem o carte, o

plasăm pe poziția sa corectă, astfel încât în mână cărțile să fie ordonate

Algoritmul de sortare prin inserţie construieşte pas cu pas lista de elemente sortate, adăugând la ea câte un element la un moment dat. La fiecare pas un element este extras din din lista iniţială şi este introdus în lista de elemente sortate. Elementul este inserat în poziţia corectă în lista sortată, astfel încât ea să rămână sortată în continuare.

Utilizând această idee, sortăm vectorul astfel: parcurgem vectorul, element cu element. La fiecare pas i, căutăm poziția corectă a elementului curent a[i], astfel încât secvența 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 rău caz n*n operații => O(n*n)

3. Sortare prin selecție

Sortarea prin selecție are două variante : sortarea prin selecția elementului maxim și

sortarea prin selecția elementului minim. În ambele variante, ideea de bază este aceași: se

selectează cel mai mare element din vector(sau cel mai mic) și se plasează pe ultima

poziție în vector(respectiv pe prima poziție). Apoi se calculează cel mai mare dintre

elementele rămase și se plasează pe penultima poziție î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 selecție directa

Considerăm un vector de elemente comparabile între ele şi dorim să le ordonăm crescător.

Pentru aceasta comparăm primul element cu toate elementele care urmează după el. Dacă

găsim un element mai mic decât primul atunci le interschimbăm pe cele două. Apoi

continuăm cu al doilea element al şirului, pe care, de asemenea îl comparăm cu toate

elementele care urmează după el şi în caz de inversiune interschimbăm cele două elemente.

Apoi procedăm la fel cu al treilea element al şirului iar procesul continuă astfel pâna 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 numărarea aparițiilor

Î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 dintr-

un astfel de interval). Prin dimensiune redusă înțelegem că se poate declara un vector v cu

Max componente întregi.

În acest caz particular, cea mai bună metodă este sortarea prin numărarea aparițiilor: se

numără pentru fiecare valoare din intervalul [0,Max) de câte 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 operații.

6.5 Interclasare

Fie a un vector cu n elemente si b un vector cu m elemente, sortați în ordine crescătoare.

Pentru a construi un al treilea vector, c, sortat crescător, se parcurg cei doi vectori,

comparând 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, avansând doar în vectorul din care am

copiat. Când am epuizat elementele din unul din cei doi vectori, copiem elementele rămase

în celălalt, 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 funcții.

Funcțiile reprezintă un element fundamental al limbajului C/C++. Orice program C/C++ este

constituit dintr-o succesiune de funcții, dintre care una este funcția principală, denumită

main(). La lansarea în execuție a unui program C/C++ se apeleaza funcția main(). Funcțiile

apelate pot sa fie predefinite sau definite de utilizator.

În concluzie, într-un program C/C++ toate prelucrările sunt organizate ca o ierarhie de

apeluri de funcții, baza acestei ierarhii fiind funcția main().

Pentru a dezvolta și utiliza funcții proprii este necesar să cunoaștem cum se definesc, cum se

declară, și cum se apelează funcțiile.

7.2 Definiția unei funcții

Definiția unei funcții este constituită dintr-un antet, care conține numele funcției, tipul

rezultatului returnat de funcție și lista parametrilor funcției și bloc de instrucțiuni, care

descrie prelucrările efectuate de funcție.

Formatul general al definiției unei funcții este:

tip nume(lista_parametri_formali)

{

declaratii_variabile_locale;

instructiuni

}

unde:

O declarație de parametru formal specifică tipul și numele parametrului, sub forma: tip nume.

Parametrii unei funcții constituie o interfată prin intermediul căreia funcția

comunică cu exteriorul. Parametrii desemnează date primite de funcție din exterior, date de

care depind prelucrările efectuate de funcție.

tip – reprezintă tipul rezultatului returnat de funcție

nume – reprezintă numele funcției

lista_parametri_formali – este constituită din una sau mai multe declarațiide parametri formali,

separate prin virgulă, sau poate lipsi.

Parametrii formali sunt denumiți astfel deoarece cu ajutorul lor se descriu în mod

formal operațiile 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 funcție nu este specificat, implicit acesta este

considerat int. Dacă funcția nu trebuie să întoarcă nicio valoare, se specifică tip al

rezultatului void.

7.3 Declararea funcțiilor

Definiția funcției informează compilatorul despre formatul unei funcții (nume, parametri,

tip rezultat) și descrie prelucrările efectuate de funcție.

Declararea unei funcții informează compilatorul despre existența funcției și formatul

acesteia. Mai exact, o declarație de funcție specifică numele funcției, tipul rezultatului

returnat de funcție și parametrii acesteia.

tip nume(lista_parametri);

Se observă că o declarație de funcție este constituită din antetul funcției , urmat de “;” , nu

de blocul de instrucțiuni al funcției. Spre deosebire de definiție, în declarație lista

parametrilor nu conține în mod obligatoriu și numele parametrilor, ci este permisă doar

specificarea tipurilor parametrilor.

Declarația unei funcții se mai numește și prototip.

7.4 Apelul funcțiilor

Apelul funcției se poate realiza în două moduri – printr-o instrucțiune de apel sau ca

operand într-o expresie.

Instrucțiunea de apel al unei funcții are următorul format general:

nume(lista_parametri_actuali);

,unde nume reprezintă numele funcției. Lista parametrilor actuali este formată dintr-o

succesiune de expresii, separate prin virgulă.

Utilizăm instrucțiuni de apel atunci când funcția nu returnează nicio valoare sau

atunci când nu dorim să utilizăm valoarea returnată de funcție, ci ne interesează doar

efectuarea prelucrărilor desrise de funcție.

În cazul în care dorim să utilizăm valoarea returnată de funcție ca operand într-o

expresie, vom apela funcția în cadrul expresiei astfel:

nume(lista_parametri_actuali)

Se poate observa că în acest caz lipseste caracterul “;” care marchează sfârșitul

instrucțiunii de apel.

La apelul unei funcții, valorile parametrilor actuali sunt atribuite, în ordine,

parametrilor formali corespunzători.

Regulă fundamentală: Parametrii actuali trebuie să corespundă cu parametrii

formali ca număr, ordine și tip

Unde sunt memorate valorile parametrilor actuali?

La apelarea unei funcții, se alocă spațiu de memorie pe stivă pentru valorile

parametrilor actuali (transfer prin valoare). La încheierea execuției funcției, zona de

memorie alocată pe stivă pentru apel este eliberată.

Ca urmare a acestui mod de funcționare, chiar dacă în blocul funcției sunt modificate

valorile parametrilor, la ieșirea din funcție, deoarece memoria alocată pentru parametri se

eliberează, valorile modificate se pierd.

Prin urmare, daca valorile parametrilor sunt modificate în blocul funcției, la ieșirea

din funcție valorile variabilelor care au fost folosite ca parametri actuali rămân

nemodificate.

Pentru a se păstra valorile modificate la ieșirea din funcție, acestea nu se vor

transmite ca parametri expresii ale căror valori să fie copiate pe stivă, ci se vor stransmite

adresele variabilelor ale căror valori dorim să le modificăm.

7.5 Transferul parametrilor prin referință

Apare frecvent necesitatea de a modifica valorile parametrilor funcției și de a utiliza în afara

funcției valorile modificate. În acest caz, este necesar să transmitem funcției 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ță conține adresa unei alte variabile (asemănător unui pointer), dar

nu este interpretată ca pointer, ci ca un alt nume asociat variabilei (un alis, un sinonom).

Declararea unei referințe:

tip &variabila_referinta = variabila_referita;

Declarația 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 același efect!

Observații:

1. Valoarea atribuită unei referințe NU poate fi schimbată, ea rămâne valabilă pe toată

durata execuției blocului de program în care este declarată.

2. Deși referința seamănă cu o variabilă, ea nu este însăși o variabilă, ci doar o referire

la variabila respectivă (o adresă).

Referințele nu sunt utile decât în utilizarea acestora drept parametrii ai unei funcții.

void interschimba(int &a, int &b)

{

int aux;

aux=x; x=y; y=aux;

}

În acest caz, în urma executării funcției valorile variabilelor din parametri actuali iși vor

păstra valoarea cu care au rămas în urma executării blocului de instrucțiuni din funcție.

În concluzie, în cazul utilizării referințelor drept parametri, beneficiem de toate

avantajele pointerilor(posibilitatea de a modifica valorile parametrilor), fără complicații de

sintaxă.

Observații:

1. Numele unui tablou este un pointer către primul element al tabloului! Prin urmare,

când se utilizează vectori ca parametrii, la definirea/declararea funcției se pot utiliza

pentru declararea parametrului una din construcțiile: tip [], sau tip[Max].

2. La apelarea unei funcții care are un parametru de tip tablou, trebuie transmis doar

numele tabloului (acesta este el însuși o adresă)

Exemplu:

Declarare: void functie(int a[], int n);

Apel: functie(a,n);

7.6 Variabile globale și variabile locale

Vom diferenția cele două categorii de variabile analizând următoarele caracteristici:

- poziția declarației 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

- poziție: sunt declarate în exteriorul oricărei funcții;

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

memoria alocată fiind automat inițializată cu 0;

- durata de viață: memoria rămâne alocată până la sfârșitul execuției programului;

- domeniu de vizibilitate: sunt vizibile din momentul declarării până la sfârșitul

programului, în toate modulele acestuia, chiar și în alte fișiere sursă, cu excepția

cazurilor de omonimie.

Variabilele locale

- poziție: sunt declarate în blocul unei funcții;

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

inițializată automat;

- durata de viață: memoria rămâne alocată până la sfârșitul execuției 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 decât variabilele locale, este permis

să declarăm o variabilă locală care să aibă același nume cu cel al unei variabile gloable. O

astfel de situație 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 noțiune este definită recursiv dacă în cadrul definiției intervine insăși

noțiunea care se definește.

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 către

un caz elementar.

Recursivitatea se realizează prin intermediul funcțiilor.

O funcție se numește recursivă dacă se autoapealează .