Lectia C++

Lectia 1 C++ | Structura unui program
Published: Monday, 01 February 2016 18:23
 Print
Un program scris în limbajul c (sau c++) este compus din unul sau mai multe
fişiere sursă.
Un fişier sursă este un fişier text care conţine codul sursă (în limbajul C) al unui
program.
Aceasta este structura unui program:

//acesta este un comentariu; el nu influenteaza programul
//declararea headerelor
#include <iostream> //aceasta este o biblioteca
#include <stdio.h> //aceasta este alta biblioteca
using namespace std;
//declararea variabilelelor
int a;
//programul principal
int main(){
// instructiunile programului
a=6;
cout<<a;
return 0;} //aici se incheie programul
↓
6
1

Sa explicam codurile de mai sus:
// = reprezinta inceperea unui comentariu pe un singur rand;

/* */ = reprezinta comentarii pe mai multe randuri;
Comentariile vor fi ignorate si nu vor influenta functionalitatea programului.
Comentariile sunt folosite in general pentru a adauga explicatii sau note
ajutatoare despre cum functioneaza programul si pentru o mai buna citire
ulterioara a codului.
EXEMPLU:
//Acesta este un comentariu pe un singur rand
/*Acesta este
un comentariu
pe mai multe
randuri*/
#include <iostream> = reprezinta o directiva preprocesor (indicata de simbolul

#)
Acest header permite realizarea afisarii pe monitor.
using namespace std = face apel catre libraria standard.

Daca preferi sa nu il scrii, v-a trebui sa scrii std::cout in loc de cout mereu.
int main = reprezinta functia principala a programului.

Cand rulezi un program, calculatorul va executa ce ai scris in main.
return 0 = reprezinta starea de iesire a procesului.
2
Lectia 2 C++ | Variabile
 Print
O variabila este o portiune de memorie care stocheaza o valoare data.
Fiecare variabila are nevoie de un identificator care o deosebeste de celelalte.

Un identificator reprezinta numele unor date care pot fi constante ori variabile,
sau numele unor functii date de utilizator.
Identificatorul este format din una sau mai multe litere, cifre sau caracterul
underscore "_".
Un identificator trebuie sa inceapa cu o litera sau in unele cazuri cu caracterul
underscore si nu poate coincide cu niciun cuvant cheie al limbajului C/C++.
O variabila poate fi globala sau locala.

Variabila globala este declarata in corpul principal al codului sursa.
Variabila locala este declarata in corpul unei functii.
EXEMPLU:
#include <iostream>
#include <stdio.h>
int x; //aceasta este o variabila globala deoarece este declarata in corpul

principal.
//x este un identificator.
int main(){
int y; //aceasta este o variabila locala deoarece este declarata in corpul

functiei "main".
//y este alt identificator.
y=2;
x=1;
printf("%d. Variabila x este globala!",x);
printf("\n%d. Variabila y este locala!",y);
return 0;}
↓
3
1. Variabila x este globala!
2. Variabila y este locala!

Declararea variabilelor:
Modul general de declarare a variabilelor este:
tip_variabile | lista_nume_variabile
Se specifica tipul variabilei(lor) si o lista formata din unul sau mai multi
identificatori ai variabilelor de tipul respectiv.
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
int x; //declararea variabilei

//int este un tip de date si inseamna ca vom lucra doar cu numere intregi
//x este numele variabilei
x=5; //i-am atribuit variabilei x o valoare
printf("%d",x); //acest %d este un specificator de format si inlocuieste

numele variabilei cu valoarea data
return 0;}
↓
5
#include <stdio.h> = fara aceasta biblioteca nu putem folosi functia printf.

Functia printf, afiseaza un mesaj.
%d va inlocui x-ul cu valoarea care i-am atribuit-o. In cazul nostru valoarea este
5. In timpul executarii programului, valoarea lui x se poate schimba.
EXEMPLU:
#include <iostream>
#include <stdio.h>
4
int main(){
int x;
x=5;
printf("%d\n",x); // Acest \n indica trecerea la un rand nou
x=8; //am schimbat valoarea lui x
printf("%d",x);
return 0;}
↓
5
8
Acum sa folosim numere cu virgula.

Pentru a afisa numerele cu virgula, vom folosim functia "float" si in loc de "%d"
vom folosi "%f".
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
float x=3.6; //am declarat variabila x de tip float
printf("%f\n",x); //%f inlocuieste x-ul cu valoarea variabilei

x=6.8;
printf("%.2f",x); //%.2f arata cate cifre sa apara dupa virgula
return 0;}
↓
3.600000
6.80
Siruri de caractere:
Variabilele pot stoca valori non.numerice, care sunt mai lungi de un singur
5
caracter.
Aceste variabile se numesc : "siruri de caractere".
EXEMPLU:
#include <iostream>
#include <stdio.h>
#include <string> //aceasta este libraria
int main(){
string z="Aceste este un sir de caractere!"; //valoarea se noteaza intre

ghilimele.
cout << z; //cout << este echivalentul lui printf

cin.get(); //cin.get() se foloseste pentru a oprii inchiderea imediata a unui
program mai scurt.
return 0;}
↓
Acesta este un sir de caractere!
Lectia 3 C++ | Tipuri de date

 Print
Orice variabila sau constanta este de un anumit tip de date.
Tipurile de date sunt:

- char
- int
- float
- bool
Acum, sa definim fiecare tip de date.
6
Incepem cu tipul de date "char":
Acest tip de date, lucreaza doar cu caractere.
Caracterele sunt: A, b, C, d, etc.
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
char a='T'; //valoarea lui a, este T
printf("%c",a); //se afiseaza valoarea lui A, care este T

return 0;}
↓
T

Urmeaza tipul de date "int":
Acest tip de date, lucreaza doar cu numere intregi.
In int putem pune numere de la -32766 pana la 32767.
Pentru numere mai mari, s-a creat un calificator "long".
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
int x=500;
long long int y=5000000000; //am folosit calificatorul long pentru numere
mai mari
cout << x; //se afiseaza valoarea lui x

printf("\n"); //rand nou
cout << y; //se afiseaza valoarea lui y
return 0;}
7
↓
500
5000000000
In final, urmeaza tipul de date "float":

Acest tip de date, lucreaza cu numere care contin virgula.
Virgula se noteaza cu punct (.).
Float poate sa contina maxim 7 cifre.
Pentru a marii numarul de cifre se foloseste "double" in loc de "float".
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
float x=1.234567891;
printf("%f\n",x); //vor aparea 7 cifre pe ecran, chiar daca noi avem 10
double y=1.23456789128;
printf("%.11f",y); //"%.11f" acest .11` indica aparitia a 11 numere dupa
virgula
//daca punem .15, vor aparea 15 numere
//se pune intre "%" si "f"
return 0;}
↓
1.234567891
1.23456789128
Lectia 4 C++ | Specificatori de format

8
 Print
Specificatorii de format sunt:

- %d | %i
- %f
- %c
Sa incepem cu specificatorul "%d" / "%i" :

Acesti specificatori se folosesc pentru tipul de date "int".
Tipul de date "int", foloseste doar numere intregi.
In concluzie si specificatorii "%d" si "%i", vor folosii doar numere intregi.
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
int a,b;
a=5;
b=9;
printf("%d",a); //specificatorul "%d", inlocuieste pe a cu valoarea data
printf("%i",b); //specificatorul "%i", inlocuieste pe b cu valoarea data
return 0;}
↓
5
9

Urmeaza specificatorul "%f" :
Acest specificator se foloseste pentru tipul de date "float".
Tipul de date "float", foloseste numere cu virgula.
In concluzie si specificatorul "%f", va folosii numere cu virgula.
EXEMPLU:
9
#include <iostream>
#include <stdio.h>
int main(){
float a,b;
a=5.8;
b=3.775;
printf("%f",a); //specificatorul "%f", inlocuieste pe a cu valoarea data
printf("%.3f",b); //specificatorul "%f", inlocuieste pe b cu valoarea data

//acest .3 din %.3f, arats cate numere sa apara dupa virgula
return 0;}
↓
5.800000
3.775
In final, urmeaza specificatorul "%c":

Acest specificator se foloseste pentru tipul de date "char".
Tipul de date "char", foloseste caractere.
In concluzie si specificatorul "%c", va folosi caractere.
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
char a;
a='T';
printf("%c",a); //specificatorul "%f", inlocuieste pe a cu valoarea data
return 0;}
↓
T
10
Lectia 5 C++ | Constante
 Print
Constantele sunt opusul variabilelor.

O constanta nu poate sa isi schimbe valoarea data pe parcursul programului.
Cand ii atribuim unei constante o valoare, aceasta valoare se poate schimba doar
schimband valoarea initiala.
Valoarea unei constante se atribuie in momentul declararii constantei
Declararea unei constante, se face punand "const" inaintea unui tip de date.
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
const int a=7; //am pus "const" in fata unui tip de date(int) si i-am atribuit
o valoare.
//valoarea se atribuie in momentul declararii constantei
//aceasta valoare nu se poate schimba pe parcursul programului
printf("%d",a);
return 0;}
↓
7
Lectia 6 C++ | Operatori

 Print
Operatorii sunt:"+","-","*","/","!","&&","||".
11
+ = plus.
- = minus.
* = inmultit.
/ = impartit.
! = negare (not)
&& = daca (and)
|| = sau (or)
Acum sa folosim fiecare operator.
Incepem cu operatorul "+":
#include <iostream>
#include <stdio.h>
int main(){
int a,b,suma;
a=7;
b=5;
suma=a+b; //operatorul "+", aduna variabila "a" cu variabila "b".

//in cazul nostru, "a=7" si "b=5".In concluzie variabila "suma" va fi egala
cu "12"
printf("%d",suma);
return 0;}
↓
12
Am declarat trei variabile: a, b, suma.

Variabilelor a si b, le-am atribuit cate o valoare: a=7 si b=5.
Variabila "suma", trebuie sa fie suma dintre variabila "a" si variabila "b".
Vom scrie "suma=a+b", adica suma=7+5.
In final vom afisa valoarea sumei: "printf("%d",suma)", %d inlocuieste "suma"
cu 12 de la 7+5.
Acum sa trecem la operatorul "-":
12
#include <iostream>
#include <stdio.h>
int main(){
int a,b,diferenta;
a=7;
b=5;
diferenta=a-b; //operatorul "-", scade variabila "a" din variabila "b".

//in cazul nostru, "a=7" si "b=5".In concluzie variabila "diferenta" va fi
egala cu "2"
printf("%d",diferenta);
return 0;}
↓
2
Urmeaza operatorul "*":
#include <iostream>
#include <stdio.h>
int main(){
int a,b,produsul;
a=7;
b=5;
produsul=a*b; //operatorul "*", inmulteste variabila "a" cu variabila "b".

//in cazul nostru, "a=7" si "b=5".In concluzie variabila "produsul" va fi
egala cu "35"
printf("%d",produsul);
return 0;}
↓
35
13

Urmeaza operatorul"/":
#include <iostream>
#include <stdio.h>
int main(){
int a,b,catul;
a=10;
b=5;
catul=a/b; //operatorul "/", imparte variabila "a" cu variabila "b".

//in cazul nostru, "a=10" si "b=5".In concluzie variabila "catul" va fi egala
cu "2"
printf("%d",catul);
return 0;}
↓
2
Haideti sa facem un program care sa calculeze: suma, diferenta, produsul si catul

a doua numere:
Acesta este codul cu explicatii:
#include <iostream> //biblioteca

#include <stdio.h> //biblioteca
#include <conio.h> //biblioteca
#include <math.h> //biblioteca
using namespace std; //face apel catre biblioteca standard
int main(){
char z; //declaram un sir de caractere
float a,b,suma,diferenta,produsul,catul; //declaram variabilele de tip float
(cu virgula)
printf("Introduceti primul numar:"); //afisam un mesaj

scanf("%f",&a); //stocam valoarea introdusa in variabila (numarul) "a"
14
printf("Introduceti al doilea numar:"); //afisam un mesaj
scanf("%f",&b); //stocam valoarea introdusa in variabila (numarul) "a"
printf("\n\nCe operatie doriti sa faceti?\n"); //afisam un mesaj

printf("1.Adunare"); //afisam un mesaj
printf("\n2.Scadere"); //afisam un mesaj
printf("\n3.Inmultire"); //afisam un mesaj
printf("\n4.Impartire"); //afisam un mesaj
printf("\n\nTastati numarul corespunzator operatiei:"); //afisam un mesaj
z=getch(); //citeste un singur caracter de la tastatura

switch(z) { //aici incepe blocul switch
case '1' : suma=a+b; printf("\nSuma este egala cu:%.2f",suma);break;

//daca apasam tasta 1, va aparea cazul 1
case '2' : diferenta=a-b;printf("\nDiferenta este egal cu:
%.2f",diferenta);break; //daca apasam tasta 2, va aparea cazul 2
case '3' : produsul=a*b;printf("\nProdusul este egal cu:
%.2f",produsul);break; //daca apasam tasta 3, va aparea cazul 3
case '4' : catul=a/b;printf("\nCatul este egal cu:%.2f",catul);break; //daca
apasam tasta 4, va aparea cazul 4
} //aici se termina blocul switch
getch();
return 0;} //aici se termina programul
Urmeaza operatorul"!":
#include <iostream>
#include <stdio.h>
int main(){
int a=1;
if(!(a<0)){ //operatorul "!", neaga conditia "a<0" care devine "a>0".
//in concluzie aceasta conditie devine adevarata si se va afisa mesajul
urmator.
printf("Operatorul ! neaga o conditie."); //acesta este mesajul.

}
return 0;}
↓
Operatorul ! neaga o conditie.
15

Urmeaza operatorul "&&":
#include <iostream>
#include <stdio.h>
int main(){
int a=1,b=6;
if(a>0 && b>5){ //operatorul "&&", verifica daca toate conditile sunt
adevarate.
//daca o conditie nu este adevarata, nu se va afisa mesajul.
//conditile noastre sunt adevarate si se va afisa mesajul urmator.
printf("Operatorul && verifica toate conditile.");

}
return 0;}
↓
Operatorul && verifica toate conditile
Urmeaza operatorul "||":
#include <iostream>
#include <stdio.h>
int main(){
int a=1,b=6;
if(a<0 || b>5){ //operatorul "||", verifica daca o singura conditie este
adevarata.
//daca o conditie nu este adevarata dar alta este, se va afisa mesajul.
printf("Operatorul || verifica daca o conditie este adevarata.");

}
return 0;}
↓
16
Operatorul || verifica daca o conditie este adevarata.
Lectia 7 C++ | Citire si afisare

 Print
Pentru citire se foloseste : "scanf" sau "cin".

Pentru afisare se foloseste : "printf" sau "cout".
- scanf sau cin, citeste valoarea introdusa de la tastatura.

- printf sau cout, afiseaza un mesaj.
Sa incepem cu scanf si printf.
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
int a,b; //am declarat doua variabile
printf("Introduceti primul numar:"); //afiseaza un mesaj care ne pune sa

introducem un numar
scanf("%d",&a); //stocheaza in variabila "a" numarul pe care l-am introdus
//& indica unde sa se stocheze numarul pe care l-am introdus
printf("Introduceti al doilea numar:");

scanf("%d",&b);
printf("Primul numar a fost: %d si al doilea numar a fost: %d",a,b);

//afiseaza numerele pe care le-am introdus
//primul "%d", va fi inlocuit cu variabila "a" si al doilea "%d" va fi inlocuit
cu variabila "b"
return 0;}
17

Urmeaza "cin" si "cout".
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
cout<<"Intoduceti primul numar:"; //afiseaza un mesaj care ne pune sa

introducem un numar
cin>>a; //stocheaza in variabila "a", numarul pe care l-am introdus
cout<<"Introduceti al doilea numar:";

cin>>b;
cout<<"Primul numar a fost : "; //afiseaza un mesaj

cout<<a; //afiseaza in continuarea mesajului, valoarea variabilei "a"
cout<<" si al doilea numar a fost : "; //afiseaza mesajul in continuarea

valorii variabilei "a"
cout<<b; //afiseaza valoarea variabilei "b", in continuarea mesajului
return 0;}
"cin" si "cout" se pot combina cu "printf" si "scanf".
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
printf("Intoduceti primul numar:"); //afiseaza un mesaj care ne pune sa

introducem un numar
18
cin>>a; //stocheaza in variabila "a", numarul pe care l-am introdus
cout<<"Introduceti al doilea numar:";

scanf("%d",&b);
printf("Primul numar a fost : %d",a); //afiseaza un mesaj si valoarea

variabilei "a"
printf(" si al doilea numar a fost : "); //afiseaza mesajul in continuarea

valorii variabilei "a"
cout<<b; //afiseaza valoarea variabilei "b", in continuarea mesajului
return 0;}
Lectia 8 C++ | Instructiunea if

 Print
Instructiunea if se foloseste atunci cand vrem sa punem o conditie.

O conditie este foarte importanta in orice limbaj de programare.
Pentru a pune o conditie, trebuie sa avem o actiune care sa se verifice.

Aceasta este structura unei conditii:
if(conditie){corpul conditiei}
Conditia trebuie sa fie adevarata sau falsa.

Daca conditia este adevarata, se va afisa corpul functiei.
Daca conditia este falsa, corpul functiei nu va fi citit si nu se va afisa nimic.
Daca dorim sa se afiseze ceva cand conditia este falsa, vom folosi "else".
if(conditie){corpul conditiei}
else mesaj
EXEMPLU:

#include <iostream>
#include <stdio.h>
int main(){
int a,b;
a=5;
19
b=9;
if(a<b){ //conditia este adevarata si se va afisa corpul ei
printf("Conditia este adevarata"); //acesta este corpul conditiei
}
return 0;}
↓
Conditia este adevarata

Acum sa il folosim si pe "else" :
EXEMPLU:

#include <iostream>
#include <stdio.h>
int main(){
int a,b;
a=5;
b=9;
if(a<b){ //conditia este falsa si nu se va afisa corpul ei
printf("Conditia este adevarata"); //acesta este corpul conditiei
}
else //se va afisa else
printf("Conditia este falsa"); //acest mesaj se va afisa
return 0;}
↓
Conditia este falsa
Lectia 9 C++ | Instructiunea Switch

 Print
Instructiunea switch alege o variabila data de noi pe care o va atribui unui caz

care are aceeasi valoare cu variabila.
Instructiunea switch analizeaza o problema in functie de cazuri.
20
Daca nici un caz nu se potriveste cu variabila, atunci se va executa o instructiune
in (default).
Instructiunea switch are urmatoarea structura:

switch(conditie)
case 1:
instructiune...
break;
case 2:
instructiune...
break;
...
default:
instructiune...
break;
Putem introduce cate cazuri dorim. Daca nu exista un (default), se va trece la

urmatoarea instructiune.
Sa spunem ca avem 5 cazuri (case 1; case 2; case 3; case 4; case 5), pentru a fi
executat cazul 3 (case 3) va trebui sa introducem in consola numarul "3". Daca
vom introduce alte numere decat cele corespunzatoare cazurilor, se va executa
(default).
In locul conditiei de la switch "switch(conditie)", putem introduce o variabila

care sa stocheze valoarea introdusa in consola si sa verifice daca exista un caz
pentru valoarea respectiva.
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main()
{
int cazuri;
printf("Intr");
scanf("%d",&cazuri);
switch(cazuri){
case 1:
21
printf("Aici va fi cazul 1");
break;
case 2:
break;
case 3:
break;
default:
printf("Nu corespunde niciun caz!");
}
}
Lectia 10 C++ | While loop

 Print
While este asemanator cu instructiunea if, doar ca while se repeta de cate ori
dorim.
Structura este urmatoarea:
while(conditie){corpul while}
Trebuie sa specificam de cate ori se va repeta, altfel while se va repeta la

nesfarsit.
EXEMPLU:
#include <iostream>
#include <stdio.h>
int main(){
int a;
a=1;
while(a<=5){ //conditia este adevarata
printf("Conditia este adevarata\n"); //acesta este corpul while
a++; //incrementare. valoarea variabilei a, se va aduna cu 1
//daca nu incrementam pe a, while se va repeta la nesfarsit, deoarece 1 este
mereu mai mare ca 5
}
22
return 0;}
ˇ

Initial valoarea variabilei "a", a fost 1.
Punand "a++" spunem ca am incrementat variabila a si i s-a schimbat valoarea
dupa cum urmeaza:
a=1
a++
a=a+1=2 => a=2
a++
a=a+1=3 => a=3
a++
a=a+1=4 => a=4
a++
a=a+1=5 => a=5
a++
a=a+1=6 => a=6 | Aici am iesit din bucla "while" deoarece conditia a fost:
Cat timp a<=5, sa se afiseze mesajul.
Variabila "a" si-a schimbat valoarea devenind 6
6 nu este nici mai mic nici egal cu 5.
Ca urmare, am iesit din bucla "while".
Lectia 11 C++ | Functii

Published: Wednesday, 24 February 2016 13:59
 Print
Cand un program devine foarte complex, acesta trebuie divizat in mai multe
parti. In acest mod programul devine mult mai usor de gestionat.
Pentru a putea diviza un program, se vor folosi functiile. O functie contine
instructiuni clare despre o anumita sectiune dintr-un program.
23
Aceasta este sintaxa unei functii:
tipul_de_data numele_functiei(tipul_de_parametrii) {corpul_functiei}
Exemplu:
int functie(int x)("tip1 parametru1, tip2 parametru2, ..., tipN parametruN")
{corpul_functiei}
Functiile mai sunt numite si subprograme
Exista doua tipuri de functii/programe:

-program apelant;
-program apelat;
Programul apelant poate fi un subprogram sau programul principal.

Programul principal este definit prin functia main().
Programul apelat poate fi doar un subprogram.
In urmatoarele randuri o sa iti dau un exemplu care sa te va ajuta sa intelegi mai

bine cum sta treaba cu programul apelant si cel apelat:
Gandeste-te la o firma.
O firma este formata dintr-un sef care are in subordine mai multi angajati.
Seful intotdeauna ii va trage la raspundere pe angajatii acestuia. Angajatii
niciodata nu vor putea sa il traga la raspundere pe sef.
In acest caz, il putem numi pe sef "Programul principal" care poate doar sa
apeleze.
Seful poate sa angajeze si un subsef. Acest subsef poate la randul lui sa fie
apelat de catre sef, dar si sa apeleze angajatii pe care acesta ii are in subordine.
In acest caz il putem numi pe subsef "program sau subprogram" deoarece poate
atat sa apeleze cat si sa fie apelat.
O functie nu poate fi definita in interiorul unei alte functii. De regula, functiile

se definesc inaintea functiei main().
Toate functiile pot fi apelate sau apelante, dar functia main() va detine
intotdeauna controlul.
EXEMPLU:
#include <iostream>
int functie(int x){
24
cout<<x;
}
int main(){
int a=6;
functie(a);
return 0;}
↓
6

Acum, sa explicam fiecare rand:
-"int functie(int x)" | acesta este antetul functiei
-"int" inseamna ca functia lucreaza cu numere intregi.

-"functie" este numele functiei (puteti pune orice nume doriti).
-"(int x)" reprezinta tipul de parametrii formali pe care o sa ii introduceti. Este o
variabila care nu trebuie initializata.
Puteti introduce cati parametrii formali doriti separandu-i prin virgula.
{}
-intre aceste paranteze se afla corpul functiei.
printf("%d",x);
-"x" va fi inlocuit cu "x" din "int functie(int x)".
int a=6;
-am declarat o variabila
functie(a);
-am apelat functia "functie".
-"a" este un parametru actual si va inlocui "x" din "int functie(int x)" care la
randul lui va inlocui "x" din "printf("%d",x);".
In concluzie, se va afisa 6.
Acum sa dam exemplu de o functie care are mai multi parametrii.
25
#include <iostream>
#include <stdio.h>
void functie(int x,float y,char abc){

printf("%d\n",x);
printf("%f\n",y);
printf("%c",abc);
}
int main(){
int a=6;
float b=5.6;
char c='Z';
functie(a,b,c);
return 0;}
↓
6
5.600000
Z
Trebuie sa introduceti variabilele a, b, c, in ordinea tipului de date fata de

functie.
void functie(int x,float y,char abc)

Primul parametru formal este "int".
In concluzie, unde am apelat functia trebuie sa punem variabila de tip "int"
prima.
functie(a,b,c);
Test C++
Published: Wednesday, 24 February 2016 14:21
 Print
26
Stiu ca nu va plac testele, dar pentru aceasta lectie am pregatit un test care sper
sa va placa.
Pentru a putea finaliza acest test, trebuie sa aveti urmatoarele cunostinte ale
limbajului C/C++:
- variabile
- citire si afisare
- tipuri de date si specificatori de format
- instructiunea if
- instructiunea switch
Vom crea interfata unui bancomat!
Cerinte:
1.Puneti ca titlu: "Bancomat" asezat la mijloc.
2.Dupa titlu, sa se afiseze limbile bancomatului:

1.Romana
2.Spanish
3.Franch
4.English
Tastati:
Dintre aceste limbi, doar limba romana trebuie sa

mearga.Restul limbilor, cand le accesam, sa se afiseze un
mesaj "Aceasta limba nu este disponibila" si sa se inchida
programul.
La mesajul "Tastati", tastati numarul corespunzator limbilor,
pentru a le accesa.
3.Cand accesam "1.Romana", sa se afiseze un mesaj: "Bun

venit!" si sub acest mesaj, sa se afiseze meniul bancomatului:
1.Interogare sold
2.Extragere numerar
3.Iesire

27
Tastati
4.Cand accesam "1.Interogare sold", va aparea urmatorul

meniu:
Dispunet de 1500 RONI
Apasati 0 pentru a efectua o tranzactie, sau 1 pentru a iesi.

Tastati:
Daca apasam 0, va aparea urmatorul mesaj:
Introduceti suma:
Daca vom introduce o suma mai mica sau egala cu 1500 roni,
se va afisa urmatorul mesaj:

Ati extras: (aici se va afisa suma introdusa) RONI
La revedere.
Daca vom introduce o suma mai mare de 1500 roni, se va

afisa urmatorul mesaj:
Nu dispuneti de aceasta suma.

La revedere.
Daca apasam 1, se va afisa urmatorul mesaj si se va inchide

programul.
La revedere.
5.Cand accesam "2.Extragere numerar", se va afisa urmatorul

mesaj:
28
Introduceti suma:
Daca vom introduce o suma mai mica sau egala cu 1500 roni,
se va afisa urmatorul mesaj:
Ati extras:
(aici se va afisa suma introdusa) RONI
La revedere.
Daca vom introduce o suma mai mare de 1500 roni, se va

afisa urmatorul mesaj:
Nu dispuneti de aceasta suma.

La revedere.
Daca vom accesa "3.Iesire", se va afisa urmatorul mesaj si se

va inchide programul:
La revedere.
29
Aici a aveti codul sursa pentru a va putea
verifica.
Codul sursa
Bancomat
#include <stdio.h>
#include <conio.h>
int main()
{
int optiune ,optiune2, suma, tranzactie;
printf("\t\t\t\tBancomat\n\n\n");
printf("Alegeti limba:\n\n");
printf("1.Romana\n");
printf("2.Spanish\n");
printf("3.Franch\n");
printf("4.English\n\n");
printf("Tastati:");
scanf("%d",&optiune);
if(optiune==1){
printf("\nBun venit\n\n");
printf("1.Interogare sold");
printf("\n2.Extragere numerar");
printf("\n3.Iesire");
printf("\n\nTastati:");}
else{
printf("\n\nAceasta limba nu este disponibila.\n\n");
return 0;
}
scanf("%d",&optiune2);
30
switch(optiune2){
case 1:
printf("\nDspuneti de 1500 RONI");
printf("\n\nApasati 0 pentru a efectua o tranzactie, sau 1 pentru a
iesi.");
printf("\nTastati:");
scanf("%d",&tranzactie);
if(tranzactie==0){
printf("\nIntroduceti suma:");
scanf("%d",&suma);
if(suma<1500){
printf("\n\nAti extrs: %d RONI\n",suma);
printf("La revedere.\n\n");
return 0;
}
else{
printf("\nNu dispuneti de aceasta suma.\n");
return 0;
}}
if(tranzactie==1){
printf("\n\nLa revedere\n\n");
return 0;
}
else{
printf("Ati tastat gresit\n\n");
return 0;
}
case 2:
printf("Introduceti suma:");
scanf("%d",&suma);
if(suma<1500){
printf("\n\nAti extras:%d RONI",suma);
printf("\nLa revedere.\n\n");
return 0;
}
else{
printf("\n\nNu dispuneti de aceasta suma.\n");
return 0;
}
case 3:
return 0;
}
}
31
Lectia 12 C++ | Pointeri
Published: Saturday, 17 March 2018 13:50
 Print
Un pointer este o variabila care are ca valoare adresa de memorie a unei alte
zone.
Cu ajutorul adreselor lor, pointerii se folosesc pentru a face referire la date.
Aceasta este sintaxa unui pointer:

tip *nume_variabila;
Pentru a putea utiliza pointerii, se folosesc doi operatori unari:
-operatorul * | furnizeaza valoarea zonei de memorie indicate de pointer;

-operatorul & | extrage adresa unei variabile si o atribuie unei alte variabile;
Exemplu:
Un pointer este o variabilă care memorează o adresă de memorie.

Un pointer se declară în felul următor:
tip * nume;
Aici tip* reprezintă tipul de dată al variabilei (obiectului) pe care pointerul îl
referă.
Un pointer este un pointer deoarece el memorează o adresă şi ocupă acelaşi
spaţiu de memorie cu un pointer de alt tip*.
Totuşi, asta nu înseamnă că puteţi memora adresa unui double într-un pointer
int* sau să interschimbaţi adrese între pointeri de tipuri diferite.
Pe lângă memorarea adreselor, pointerii mai pot accesa şi conţinutul de la
respectivele adrese. Decodificarea conţinutului se face pe baza tipului
pointerului tip*.
Spaţiul de memorie pe care îl ocupă un pointer depinde de compilator şi
sistemul de operare.
Exemplu de pointeri:
int * p1; // Refera un int
32
char * p2; // Refera un char
Aveţi grijă să iniţializaţi un pointer înainte de a-l folosi, altfel puteţi accesa zone
de memorie pentru care programul vostru nu are acces, iar acest lucru poate
cauza erori în program.
Puteţi iniţializa un pointer fie cu o adresă de memorie, fie cu pointerul NULL
nullptr.
Acest keyword a fost introdus în noul standard C++11 şi diferă de NULL prin
faptul că nu este un întreg, pur şi simplu reprezintă un pointer NULL.
NULL în C/C++ este definit ca #define NULL 0 - practic NULL este constanta
zero.
Dacă compilatorul vă permite, folosiţi nullptr în loc de NULL.
Adresa unei variabile se obţine cu operatorul de referenţiere (&) (sau
operatorul adresă).
ptr = &var;
Conţinutul unei adrese de memorie (stocată într-un pointer) se obţine cu
operatorul de dereferenţiere (*) (sau operatorul de indirectare).
*ptr
Nu confundaţi acest operator cu steluţa (*) din declararea unui pointer! Ea face
parte din tipul pointerului.
Iată un exemplu mai concret:
#include <iostream>
int main()
{
int * p1; double * p2;
int d1 = 45; double d2 = 3.14;
p1 = &d1; // p1 refera variabila d1
p2 = &d2; // p2 refera variabila d2
// Afisez adresele de memorie stocate in cei doi pointeri
cout << p1 << ' ' << p2 << '\n';
// Afisez continutul stocat la adresele de memorie
// din cei doi pointeri
cout << *p1 << ' ' << *p2 << '\n';
cout << sizeof(p1) << ' ' << sizeof(p2);
return 0;
}
Output:
0x22fef4 0x22fee8
45 3.14
33
44
Prin convenţie numerele hexazecimale sunt reprezentate cu prefixul 0x.
Operatorul sizeof(ob), unde ob reprezintă un tip (int, char, float, etc.) sau un
obiect (variabilă), returnează mărimea, în bytes, a argumentului.
După cum vedeţi, pointerii ocupă 4 bytes de memorie (în sistemele de 32-biţi).
Puteţi scădea doi pointeri ca să obţineţi numărul de elemente de tipul respectiv

ce încap între ei.
#include <iostream>
int main()
{
double * p1, * p2;
double d1 = 1.1, d2 = 2.2;
p1 = &d1; p2 = &d2;
cout << p1 << ' ' << p2 << '\n';
cout << p1 - p2;
return 0;
}
Output:
0x22fef0 0x22fee8
1
Diferenţa dintre 0x22fef0 şi 0x22fee8 este 0x8, adică 8, iar 8 bytes este spaţiul
de memorie pe care îl ocupă 1 double, deci rezultatul afişat este 1.
Puteţi scădea numai pointeri ce referă acelaşi tip de dată.
Dacă p1 ar fi fost int*, codul de mai sus nu ar fi compilat.
Alocarea dinamică
Când declaraţi un vector trebuie să precizaţi numărul de elemente ce-l vor

alcătui.
34
Asta înseamnă că stabiliţi spaţiu de memorie ocupat de vector înainte de a ştii
exact numărul de elemente ce va fi memorat în vectorul respectiv.
Vectorii statici pot fi ineficienţi din punct de vedere al memoriei ocupate atunci
când nu se ştie exact câte elemente va memora vectorul.
De aceea C++ ne pune la dispoziţie operatorii new şi delete cu care putem
aloca / dealoca memorie dinamic în timpul execuţiei programului.
Cu new se alocă (rezervă) memorie. Operatorul returnează adresa de memorie a
spaţiului alocat.
tip* var = new tip;

Sau putem aloca un bloc de memorie (vector dinamic):
tip* var = new tip[nr_elem];
Nu există succes garantat când alocaţi memorie dinamic.
Operatorul new alocă memorie din zona liberă (heap).
Este posibil ca această zonă din memorie să fie ocupată de alte aplicaţii sau
starea sistemului să nu permită o astfel de alocare.
În această situaţie new lansează o excepţie. Puteţi folosi (nothrow) astfel încât
new să returneze pointerul NULL în caz de eşec.
tip* var = new (nothrow) tip;
Memoria alocată cu new - numai aceasta - poate fi dealocată (eliberată) cu
delete.
delete var;
delete[] var; // pentru vectori
După ce aţi folosit delete pe un pointer, acesta nu mai indică către o adresă
validă (respectiva adresă nu mai este rezervată pentru programul vostru), de
aceea este bine să-i atribuiţi valoarea nullptr (sau NULL).
ATENŢIE: delete nu distruge variabila pointer! El eliberează spaţiul de
memorie indicat de pointer prin adresa pe care o memorează.
35
Nu uitaţi să dealocaţi spaţiul de memorie atunci când nu mai aveţi nevoie de el!
Dacă nu dealocaţi memoria, aceasta rămâne rezervată, degeaba, pentru aplicaţia
voastră, când alte aplicaţii ar putea avea nevoie de ea sau chiar programul
vostru, care alocă fără să elibereze, poate rămâne fără spaţiu de lucru.
Fenomenul se numeşte memory leak.
Un exemplu de alocare dinamică:
#include <iostream>
int main()
{
int* x = new int;
*x = 98;
cout << *x << ' ' << x;
delete x;
return 0;
}
Output:
98 0x7c0f70
Un vector static este practic un pointer constant. El referă numai blocul de
memorie care îi este atribuit de compilator.
Numele vectorului este un pointer către primul element din vector. Exemplu:
#include <iostream>
int main()
{
int v[] = {1, 2, 3, 4, 5};
cout << *v; // Se va afisa 1
return 0;
}
Puteţi accesa elementele unui vector, static sau dinamic, în două moduri:
v[i]; // SAU
*(v+i);
// unde i este un intreg
Atunci când adunaţi sau scădeţi un intreg dintr-un pointer, deplasaţi pointerul
peste i blocuri de memorie de tipul referit de pointer.
De exemplu, dacă un pointer (int* ptr;) referă / indică adresa 0x22feec, atunci
ptr+1 va referi adresa 0x22fef0.
0x22feec + 4 = 0x22fef0 (4 este mărimea în bytes a tipului int). Vezi imaginea
36
de mai sus.
Aşadar, putem folosi operatorii ++ şi -- pentru a parcurge un vector:
#include <iostream>
int main()
{
int v[] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++)
cout << *(v+i) << ' '; // v[i]
return 0;
}
Din acest motiv vectorii se transmit prin referinţă.
Deoarece ei sunt nişte pointeri constanţi a căror adresă (stocată în ei) este
transmisă (prin valoare) parametrului funcţiei, care este un vector.
Acel vector accesează, şi eventual modifică, conţinutul de la adresa de memorie
primită.
Un exemplu cu vectori dinamici. Programul cere utilizatorului să introducă o
listă de numere, iar acesta calculează şi afişează suma lor:
#include <iostream>
int main()
{
int n, suma = 0;
cout << "Cate numere vrei sa adun? "; cin >> n;
int * nr = new int[n];
cout << "Scrie numerele despartite prin spatiu: ";
for (int i = 0; i < n; i++)
cin >> nr[i];
// Suma
for (int i = 0; i < n; i++)
suma += nr[i];
cout << "Suma lor este: " << suma;
delete[] nr;
return 0;
}
Pointerii constanţi sunt de două feluri:

- Pointeri care nu pot modifica datele referite (date constante), dar care pot fi
modificaţi (le puteţi atribui o altă adresă);
37
const tip* ptr;
- Pointeri care pot modifica datele referite (date neconstante), dar care nu pot fi
modificaţi (nu le puteţi atribui o altă adresă);
tip* const ptr;
- Pointeri care nu pot modifica datele referite şi nu pot fi modificaţi.
const tip* const ptr;
Exemplu:
#include <iostream>
int main()
{
const int sz = 10;
int money = 3000;
const int* pSz = &money;

int* const pMoney = &money;
const int* const ptr = &sz;
pSz = &sz; // OK!

// *pSz = 11; // Eroare! Nu pot modifica variabila referita
*pMoney = 4000; // OK!
// pMoney = &sz; // Eroare! Pointer constant
// ptr = &money; // Eroare!
// *ptr = 13; // Eroare
pSz = &money;
// Eroare! Chiar daca money nu este const

// Pointerul n-o poate modifica
// *pSz = 5000;
// Iar daca se incearca modificarea unei variabile const

// Cu un pointer neconstant, din nou eroare
// const int* este DIFERIT de int*
// &sz returneaza o adresa (pointer) de tip const int*
// int* pt = &sz;
// *pt = 17;
return 0;
}
38
Pointerii pot fi parametri ai unei funcţii.
Studiaţi cu atenţie exemplele următoare.
#include <iostream>
void vreauPointer(int* p)
{
cout << "In functie *p = " << *p << '\n';
*p = 90; // Modific continutul de la adresa memorata in p
cout << "Dupa modificare *p = " << *p << '\n';
int x = 12;
// Modificarea pointerului este vizibila doar aici
// Deoarece variabila pointer nu este
// transmisa prin referinta
p = &x;
cout << "In functie p refera " << p << '\n';
}
int main()
{
int q = 70;
int* ptr = &q;
cout << "In main q = " << q << '\n';
cout << "In main *ptr = " << *ptr << '\n';
cout << "In main ptr refera " << ptr << '\n';
vreauPointer(ptr);
cout << "Dupa apel q = " << q << '\n';
cout << "Dupa apel *ptr = " << *ptr << '\n';
cout << "Dupa apel ptr refera " << ptr << '\n';
return 0;
}
Output:
In main q = 70
In main *ptr = 70
In main ptr refera 0x22fef8
In funtie *p = 70
In functie p refera 0x22fef8
Dupa modificare *p = 90
Dupa modificare p refera 0x22fe6c
Dupa apel q = 90
Dupa apel *ptr = 90
Dupa apel ptr refera 0x22fef8
39
Pointerii pot fi transmişi prin referinţă.
#include <iostream>
void vreauPointer(int* &p) // Referinta!

{
cout << "In functie *p = " << *p << '\n';
*p = 90; // Modific continutul de la adresa memorata in p
cout << "In functie p refera " << p << '\n';
cout << "Dupa modificare *p = " << *p << '\n';
int x = 12; // Aceasta variabila va fi distrusa la sfarsitul functiei
// Modificarea pointerului este vizibila in afara
// Deoarece variabila pointer este
// transmisa prin referinta
p = &x;
cout << "Dupa modificare p refera " << p << '\n';
}
int main()
{
int q = 70;
int* ptr = &q;
cout << "In main q = " << q << '\n';
cout << "In main *ptr = " << *ptr << '\n';
cout << "In main ptr refera " << ptr << '\n';
vreauPointer(ptr);
cout << "Dupa apel q = " << q << '\n';
cout << "Dupa apel *ptr = " << *ptr << '\n';
cout << "Dupa apel ptr refera " << ptr << '\n';
return 0;
}
Output:
In main q = 70
In main *ptr = 70
In main ptr refera 0x22fefc
In funtie *p = 70
In functie p refera 0x22fefc
Dupa modificare *p = 90
Dupa modificare p refera 0x22fe6c
Dupa apel q = 90
Dupa apel *ptr = 4683872
Dupa apel ptr refera 0x22fe6c
40
Observaţi că *ptr referă o valoare ciudată. Acest lucru se întâmplă deoarece ptr
memorează adresa variabilei x din funcţia vreauPointer().
Când o funcţie îşi termină execuţia toate variabilele declarate în acea funcţie
(+parametrii) sunt distruse (memoria ocupată de ele este eliberată).
La respectiva adresă rămâne numai gunoi (junk), un şir de 1 şi 0 care nu are
niciun sens pentru programul vostru, dar acesta îşi face datoria şi afişează
interpretarea int, în acest caz, a biţilor.
Acelaşi lucru se întâmplă şi când folosiţi un pointer neiniţializat sau o variabilă
neiniţializată.
Referinţe
O referinţă este un alias pentru o variabilă.

Dacă variabila reprezintă o anumită zonă de memorie, şi referinţa va reprezenta
aceeaşi zonă de memorie.
Referinţele se declară cu (&).
#include <iostream>
int main()
{
int x = 6;
int& q = x; // q refera acelasi spatiu de memorie ca si x
q += 5; // Referintele se folosesc normal ca si variabilele
cout << x; // se va afisa 11
return 0;
}
Referinţele trebuie iniţializate!
Nu puteţi iniţializa o referinţă cu o constantă! Trebuie să fie un obiect /
variabilă.
Puteţi avea referinţe constante care referă variabile constante.
#include <iostream>
int main()
{
const int p = 5;
const int& x = p;
cout << x; // 5
return 0;
}
41
De îndată ce a fost iniţializată, referinţa nu mai poate fi schimbată. Nu mai aveţi
cum.
Referinţa se comportă ca o altă variabilă.
Funcţii (Subprograme)
Ce este o funcţie?
O funcţie (subprogram) este un grup de instrucţiuni apelabil (invocabil) din alte

părţi ale programului. De exemplu, main este o funcţie.
A apela o funcţie înseamnă a o executa.
Funcţiile ajută la modularizarea programului, la structurarea acestuia în unităţi
logice.
O funcţie se declară în felul următor:
tip nume(lista_param); // Prototipul functiei

Exemplu:
int suma(int a, int b);
lista_param - lista de parametri, despărţiţi prin virgulă, este opţională.
Parantezele sunt obligatorii. Ele deosebesc funcţiile de alte entităţi C++ (de
exemplu, variabile).
void nimic(); // functie fara parametri
Tipul void reprezintă absenţa tipului. Cu alte cuvinte, funcţiile care nu
returnează nicio valoare, au tipul void.
Funcţiile pot returna valori codului apelant (locul de unde a fost apelată funcţia)
prin intermediul instrucţiunii return.
După declarare, o funcţie trebuie definită undeva în program.
#include <iostream>
int suma(int, int); // Declarare
int main()
{
int x, y;
cout << "Da-mi doua numere intregi: ";
42
cin >> x >> y;
cout << "Suma lor este " << suma(x, y);
return 0;
}
int suma(int a, int b) // Definire

{
int rezultat = a + b;
// Puteam scrie direct
// return a + b;
return rezultat;
}
Când declaraţi o funcţie, puteţi omite numele parametrilor (aşa cum am făcut în
exemplu), dar trebuie să precizaţi tipul lor.
Parametrii sunt variabile locale funcţiei (vizibile numai în blocul funcţiei).
Instrucţiunea return întrerupe execuţia funcţiei şi returnează valoarea expresiei,
din dreapta, codului apelant.
Într-o funcţie puteţi avea mai multe instrucţiuni return.
Observaţi cum se apelează o funcţie: suma(x, y);. Dacă funcţia nu are parametri,
se apelează doar cu nume + paranteze: funcFaraParam();.
Când execuţia unei funcţii se termină, controlul programului revine în punctul
apelării şi programul îşi continuă execuţia normal.
Funcţiile void nu returnează valori, ele doar îndeplinesc o sarcină, deci nu pot
avea instrucţiunea return expr;.
Puteţi însă folosi return; ca să întrerupeţi execuţia unei funcţii void.
#include <iostream>
void afiseazaText() // Declarare + Definire

{
for (int i = 0; i < 5; i++)
cout << "Hello functions!";
}
int main()
{
// Se va afisa de 5 ori textul:
// Hello functions!
afiseazaText();
return 0;
}
43
Puteţi declara şi defini o funcţie în acelaşi loc, dar numai înainte de main, altfel
compilatorul nu va recunoaşte funcţia.
Funcţiile void nu pot fi folosite în expresii, deoarece expresiile au în
componenţa lor operatori care aşteaptă valori, ori o funcţie void nu returnează
nicio valoare.
O funcţie poate avea orice număr de parametri.
Variabilele declarate într-o funcţie sunt locale, adică sunt vizibile numai în
respectiva funcţie. Ele nu pot fi folosite în afara ei (valabil şi pentru parametri).
Argumentele funcţiei sunt datele (variabile, expresii, constante, etc.) transmise
funcţiei şi primite de parametrii acesteia.
De exemplu, în apelul suma(x, y); argumentele sunt variabilele x şi y.
Parametrii unei funcţii pot avea valori implicite (default). Parametrii default
trebuie poziţionaţi la sfârşitul listei de parametri.
După ce aţi declarat un parametru implicit, nu mai aveţi voie să declaraţi
parametri normali în continuare acestuia, ci doar parametri impliciţi.
#include <iostream>
double arieCerc(double raza, double PI = 3.14)

{
return 2 * PI * raza * raza;
}
int main()
{
cout << "Aria cercului de raza 2 este " << arieCerc(2.0) << '\n'; // PI == 3.14
cout << "Aria cercului de raza 2 este " << arieCerc(2.0, 3.141592);
return 0;
}
Se va afişa
Aria cercului de raza 2 este 25.12
Aria cercului de raza 2 este 25.1327
Când nu transmiteţi o valoare parametrului implicit, compilatorul va folosi
valoarea implicită, dată de voi.
Supraîncărcarea (Overloading) funcţiilor
Supraîncărcaţi o funcţie atunci când definiţi mai multe versiuni ale aceleiaşi
funcţii.
44
Funcţia trebuie să aibă acelaşi nume, dar lista de parametri trebuie să difere prin
numărul parametrilor sau prin tipul parametrilor (sau ambele).
Tipul funcţiei poate fi diferit, dar nu este necesar să fie aşa.
Versiunile diferă unele de altele numai prin lista de parametri!
#include <iostream>
// Aria patratului
double arie(double lungime)
{
return lungime * lungime;
}
// Aria dreptunghiului
double arie(double lungime, double latime)
{
return lungime * latime;
}
int main()
{
cout << "Aria patratului de L = 2 este " << arie(2.0) << '\n';
cout << "Aria dreptunghiului de L = 3 si l = 4 este " << arie(3.0, 4.0);
return 0;
}
Output:
Aria patratului de L = 2 este 4
Aria dreptunghiului de L = 3 si l = 4 este 12
Funcţia arie este supraîncărcată (overloaded). Am două versiuni care diferă prin
numărul de parametri.
Compilatorul se foloseşte de tipul şi numărul de argumente ca să invoce funcţia
corectă.
Transmiterea prin valoare şi prin referinţă
Atunci când transmiteţi argumente (şi sunt variabile) unei funcţii, transmiteţi de
fapt o copie a acelor variabile.
Aceasta este transmiterea prin valoare (pass by value).
Orice modificare a parametrilor unei funcţii este vizibilă numai în acea funcţie.
Variabilele - folosite ca argumente - rămân nemodificate.
45
#include <iostream>
void modifica(int a)
{
a = a + 5;
cout << "a are valoarea: " << a << '\n';
}
int main()
{
int x = 1;
cout << "x inainte de apel: " << x << '\n';
modifica(x);
cout << "x dupa apel: " << x;
return 0;
}
Output:
x inainte de apel: 1
a are valoarea: 6
x dupa apel: 1
O funcţie poate returna decât o singură valoare printr-un return, ca la
matematică.
Uneori vrem ca o funcţie să poată returna mai multe valori. Un mod prin care
putem obţine acest lucru este transmiterea prin referinţă (pass by reference).
Atunci când transmiteţi prin referinţă, parametrii funcţiei alterează direct
conţinutul variabilelor argumente (nu mai există nicio copie).
Ca să transmiteţi prin referinţă folosiţi ampersand (&) între tipul parametrului şi
numele acestuia.
Parametrii referinţă acceptă numai variabile. NU acceptă constante (deoarece nu
pot fi alterate)!
#include <iostream>
void modifica(int& a) // Nu uitati de ampersand !

{
a = a + 5;
cout << "a are valoarea: " << a << '\n';
}
int main()
46
{
int x = 1;
cout << "x inainte de apel: " << x << '\n';
modifica(x);
cout << "x dupa apel: " << x;
return 0;
}
Output:
x inainte de apel: 1
a are valoarea: 6
x dupa apel: 6
Vectorii se transmit prin referinţă!
#include <iostream>
void modifica(int v[], int l)

{
for (int i = 0; i < l; i++)
v[i] += 5; // v[i] = v[i] + 5;
}
int main()
{
int w[] = {1, 2, 3, 4}, k = 4;
modifica(w, k);
for (int i = 0; i < k; i++)

cout << w[i] << ' ';
return 0;
}
Output:
6789
Observaţi cum se transmite un vector ca parametru.
Numărul de elemente poate lipsi (valabil doar pentru prima dimensiune).
Dacă aş fi avut o matrice de 2 x 3, atunci aş fi scris:
void modifica(int v[][3], ...) ...
Veţi înţelege mai bine aceste lucruri după ce veţi învăţa ceva despre pointeri.
47
Funcţii recursive
O funcţie care se autoapelează se numeşte recursivă.

Aveţi grijă ca funcţia să aibă o condiţie de terminare, altfel puteţi crea o repetiţie
infinită.
Parametrii funcţiilor şi variabilele locale sunt încărcate, stocate, pe Stivă (o
regiune din memorie structurată pe principiul stivei, LIFO), iar în cazul unei
funcţii recursive infinite, Stiva se poate umple repede (stack overflow) cauzând
un crash al programului.
Factorialul unui număr poate fi calculat cu o funcţie recursivă (deşi se poate face
acelaşi lucru şi cu un loop).
#include <iostream>
int fact(int n)
{
if (n == 0) // Conditia de terminare
return 1;
else
return n * fact(n - 1);
}
int main()
{
cout << fact(0) << '\n';
cout << fact(3) << '\n';
cout << fact(8) << '\n';
return 0;
}
Output:
1
6
40320
Ca să înţelegeţi mai bine mecanismul recursivităţii vizionaţi acest clip de pe
Youtube:
Funcţii inline
Atunci când o funcţie este apelată, parametrii şi variabilele locale sunt încărcate
pe Stivă.
48
Acest proces consumă resurse şi timp de execuţie.
Pentru funcţiile ce efectuează puţine operaţii, apelarea poate costa mai mult timp
şi spaţiu de execuţie decât dacă aceste operaţii ar fi executate direct în cod.
Din acest motiv există keyword-ul inline.
Cu inline programatorii pot cere compilatorului să insereze blocul funcţiei în
punctul apelării, în loc să creeze instrucţiunile de apel.
O funcţie se declară inline în felul următor:
#include <iostream>
inline double myPI()

{
return 3.14159265359;
}
int main()
{
cout << myPI();
return 0;
}
Nu declaraţi inline funcţii recursive sau funcţii complexe!
Mărimea programului poate creşte considerabil.
Compilatoarele moderne de astăzi optimizează automat codul sursă.
Unele dintre ele vor refuza inline, chiar dacă programatorul le cere explicit (de
exemplu, compilatoarele care optimizează mărimea programului), altele vor face
automat inline anumite funcţii (compilatoarele optimizate pentru viteză), chiar
dacă programatorul nu cere acest lucru.
Vectori - Tablouri de memorie

Vectori
Un vector (array), sau tablou de memorie este o colecţie de date stocate în

locaţii succesive din memorie.
Toate elementele vectorului au acelaşi tip de dată. Un vector se declară în felul
următor:
tip nume[numar_elemente];
De exemplu, un vector cu 100 de întregi.
int yoyo[100];
49
Numărătoarea elementelor începe de la zero.
Putem accesa şi modifica un element de-al vectorului cu următoarea sintaxă:
nume[index];
De exemplu, pot atribui elementului al treilea valoarea 10.
yoyo[2] = 10;
ATENŢIE: Primul element este yoyo[0], iar ultimul este yoyo[99].
Aceşti vectori se zic statici (static arrays) deoarece numărul de elemente şi
spaţiul de memorie ocupat este constant în timpul compilării. (numar_elemente
trebuie să fie o constantă).
Vectorii declaraţi global, în afara oricărei funcţii, sunt iniţializaţi cu zero.
La declarare vectorii pot fi iniţializaţi, aşa cum sunt iniţializate variabilele, dar
cu o sintaxă diferită.
int vec[3] = {1, 2, 3};
Sau, doar în acest caz, puteţi omite numărul de elemente:
int vec[] = {1, 2, 3};
Deoarece lungimea va fi dedusă de compilator pe baza numărului de date dintre
acolade.
Parcurgerea unui vector se face cel mai simplu cu un loop, în general un for.
#include <iostream>
int main()
{
int cifrePare[] = { 0, 2, 4, 6, 8 };
for (int i = 0; i < 5; i++)
cout << cifrePare[i];
return 0;
}
ATENŢIE: Accesarea elementelor din afara vectorului - cum ar fi cifrePare[5] -
poate produce rezultate neaşteptate, ca instabilitatea programului sau, în cel mai
rău caz, un crash al programului.
Vectori multidimensionali
Vectorii multidimensionali sunt vectori ai vectorilor. Sintaxa generală de

declarare este:
tip nume[nr_elem1][nr_elem2]...[nr_elemN]
Aşa cum vedeţi, un vector poate avea oricâte dimensiuni vreţi. Totuşi, spaţiu de
memorie fiind limitat, nu veţi întâlni vectori cu mai mult de 3 dimensiuni.
50
Un vector bidimensional poate fi imaginat ca o matrice (un tabel cu linii şi
coloane).
De exemplu, matricea int mat[5][3]; are 5 linii şi 3 coloane.
În realitate, în memorie, elementele tot în ordine secvenţială sunt stocate.
Vectorul (matricea) de mai sus este echivalent cu int mat[15];.
Iniţializarea este similară cu cea a vectorilor unidimensionali:
int mat[2][3] = { {1, 2, 3}, {4, 5, 6} };
Parcurgerea se face tot cu un for:
#include <iostream>
int main()
{
int cifre[2][3] = { {1, 2, 3}, {4, 5, 6} };
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++)
cout << cifre[i][j] << ' ';
cout << '\n';
}
return 0;
}
Observaţi cum se accesează elementul de pe linia i şi coloana j.
cifre[i][j];
Programul va afişa:
123
456
Primul element al matricei este cifre[0][0], adică 1.
Dacă nu vă place numărătoarea de la zero, puteţi declara vectorul cu 1 +

nr_elemente, astfel încât să începeţi numărătoarea de la 1, dar să aveţi spaţiu
pentru nr_elemente. Exemplu:
#include <iostream>
int main()
{
int yoyo[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i = 1; i < 10; i++)
cout << yoyo[i] << i << ' ';
51
return 0;
}
Acum indicele i coincide cu yoyo[i].
Primul element al vectorului, yoyo[0], este ignorat, şi al doilea, yoyo[1], este
considerat noul prim.
Booleeni şi Structuri de Control

Tipul boolean
Tipul boolean sau tipul de dată logic este tipul ce are două valori: true şi false.
Acest tip este folosit în contextele booleene, acolo unde expresia este evaluată*
la true sau false. De exemplu, în condiţia de la if sau while.
O variabilă de tip bool se declară normal, ca orice variabilă:
bool x = true;
În contextele booleene din C/C++, valorile pozitive sunt evaluate la true, iar
ZERO este evaluat la false.
De exemplu:
if (1) cout << "TRUE";
Se va afişa mesajul TRUE deoarece 1 este interpretat ca fiind true.
Operatorii care returnează un rezultat booleean sunt operatorii relaţionali şi

operatorii logici.
Operatorii relaţionali sunt:
< // Mai mic

<= // Mai mic sau egal
== // Egal
!= // Diferit
> // Mai mare
>= // Mai mare sau eagl
În general sunt folosiţi cu numere (întregi, reali), dar veţi vedea că pot fi definiţi
şi pentru alte tipuri.
Opeatorii logici sunt:
&& // AND - SI LOGIC
|| // OR - SAU LOGIC
! // NOT - NEGATIE LOGICA
Operatorul AND returnează true dacă ambii operanzi sunt true.
Operatorul OR returnează true dacă cel puţin unul dintre operanzi este true.
52
Operatorul NOT inversează valoarea booleană a expresiei, variabilei, etc.
C++ foloseşte evaluarea scurtă.
Pentru AND: Dacă primul operand este false atunci întreaga expresie este false;
nu se mai evaluează operandul al doilea.
Pentru OR: Dacă primul operand este true atunci întreaga expresie este true; nu
se mai evaluează operandul al doilea.
Dintre aceşti operatori, NOT are prioritatea cea mai mare, urmat de operatorii
relaţionali, apoi (în această ordine) AND şi OR.
Tabelul cu precedenţa operatorilor.
Structuri decizionale
Instrucţiunea if permite execuţia unei porţiuni de cod* doar dacă o anumită

condiţie este îndeplinită. Condiţia este dată de programator.
#include <iostream>
int main()
{
int a = 4;
if (a >= 4) {
cout << "Hi!";
} else {
cout << "Bye!";
}
return 0;
}
Se va afişa if deoarece variabila a memorează 4, iar 4 este mai mare sau egal cu
4.
Ramura else este executată atunci când condiţia de la if nu este îndeplinită. Dacă
if se execută atunci programul ignoră ramura else.
În cazul unei singure instrucţiuni (valabil pentru toate structurile de control)
acoladele pot lipsi.
După else poate urma un alt if, şi un altul, până când cascada de if else se
termină în else sau nu se termină în nimic, deoarece else este opţional.
#include <iostream>
int main()
{
double nr;
53
cin >> nr;
if (nr >= 2) {
cout << "Ai introdus un numar mai mare sau egal cu 2.";
} else if (nr < 0) {
cout << "Ai introdus un numar negativ";
} else {
cout << "Ai introdus un numar din intervalul [0, 2)";
}
return 0;
}
Aici, ultimul else este executat numai dacă ramurile superioare nu sunt
executate.
Condiţia de la if (ca şi la celelalte structuri) poate fi orice: constantă, variabile,
expresie, orice se poate evalua la true sau false.
Mod de funcţionare if:
1. Se evaluează condiţia. Dacă este true se trece la pasul următor; dacă este
false se trece la pasul 3.
2. Se execută codul din blocul if (dintre acolade) şi se trece la pasul 4.
3. Se execută ramura else şi se trece la pasul 4.
4. Se iese din if şi se continuă execuţia programului.
Instrucţiunea switch este, într-un fel, similară cu if. Permite execuţia anumitor
instrucţiuni în funcţie de rezultatul unei expresii, variabile, etc.
#include <iostream>
int main()
{
int nr;
cin >> nr;
switch(nr)
{
case 1: cout << "Ai introdus 1"; break;
case 2: cout << "Ai introdus 2"; break;
default: cout << "Ai introdus un numar diferit de 1 si 2"; break;
}
return 0;
}
Instrucţiunea switch compară rezultatul expresiei dintre paranteze (aici este
variabila nr) cu fiecare caz şi-l execută atunci când găseşte o potrivire.
Expresiile de la case trebuie să fie constante.
54
Fără break, switch ar evalua în continuare celelalte cazuri chiar dacă l-ar găsi pe
cel potrivit.
Omiterea instrucţiunii break nu generează o eroare, deoarece este opţional.
Ultimul caz, default (implicit), se execută atunci când nu există potriviri cu
celelalte cazuri.
Un exemplu care arată cum puteţi valorifica lipsa break-ului:
#include <iostream>
int main()
{
int nr;
cin >> nr;
switch(nr)
{
case 1: case 2: case 3: case 4: case 5: case 6: case 7:
cout << "Ai introdus ziua a " << nr << "-a"; break;
default:
cout << "Te rog sa introduci numarul valid al unei zile";
}
return 0;
}
Să zicem că nr este 2. Se execută cazul 2, apoi, deoarece nu există break, se
trece la 3, apoi la 4, ... până la 7 unde există break şi se iese din switch.
Structuri iterative - Bucle - Loop-uri
Instrucţiunea while repetă o porţiune de cod până când condiţia devine falsă.
Dacă condiţia nu devine falsă la un moment dat, while va continua să ruleze
(până când programul este oprit forţat de programator / user).
#include <iostream>
int main()
{
int nr;
cout << "Ca sa inchizi programul scrie 0.\n";
cin >> nr;
while (nr != 0) { // Cat timp nr nu este 0
cout << nr * 2 << '\n';
cin >> nr;
}
55
return 0;
}
Condiţia de la while, în acest exemplu, este nr != 0.
Atunci când folosim loopuri trebuie să ne asigurăm că aceste condiţii vor deveni
false în cele din urmă, ca să evităm repetiţiile infinite.
În exemplul meu, decizia de a opri programul (care în fond înseamnă oprirea
iteraţiei) îi aparţine utilizatorului, prin acel cin >> nr; din while.
Mod de funcţionare while:
1. Se evaluează condiţia. Dacă este true se trece la pasul următor. Dacă este
2. Se execută codul din blocul while (dintre acolade).
3. Se trece la pasul 1.
4. Se iese din while şi se continuă execuţia programului.
O variaţie a structurii while este do { } while(conditie); Spre deosebire de while,

codul în do while este executat cel puţin o dată indiferent de condiţie.
#include <iostream>
int main()
{
bool conditie = false;
do {
cout << "In while :)";
} while (conditie);
return 0;
}
Se va afişa In while :) deoarece evaluarea se face la final.
Observaţi ; după while. Este obligatoriu.
Instrucţiunea for repetă de un anumit număr de ori o porţiune de cod.
#include <iostream>
int main()
{
for (int i = 1; i <= 10; i++) {
cout << i << ' ';
}
return 0;
56
}
Se va afişa: 1 2 3 4 5 6 7 8 9 10.
for (initializare; conditie; incrementare)
Instrucţiunea for are trei părţi:
 La iniţializare se declară (şi se iniţializează) variabila (sau variabilele)

contor (folosită la numărat).
 La conditie avem o expresie de terminare a iteraţiei.
 La incrementare (sau decrementare) variabila contor este modificată astfel
încât condiţia să poată deveni la un moment dat falsă.
Toate cele trei părţi sunt opţionale. Nu este obligatoriu să declaraţi variabila
contor în for, deşi dacă o declaraţi acolo, ea va fi vizibilă numai în blocul for.
#include <iostream>
int main()
{
for (int i = 10; i > 0; i-=2) {
cout << i << ' ';
}
return 0;
}
Se va afişa: 10 8 6 4 2. Mod de funcţionare:
1. Se iniţializează variabilele (Această parte se execută o singură dată).

2. Se evaluează condiţia. Dacă este true se trece pasul următor. Dacă este
3. Se execută codul din blocul for.
4. Se execută instrucţiunea de la incrementare.
5. Se iese din for şi se continuă execuţia programului.
Prin cod se înţelege o instrucţiune sau grup de instrucţiuni.

A evalua este echivalent cu a executa.
57
Input / Output cu CIN şi COUT
Output cu COUT
Am văzut că pentru a putea folosi obiectele cout (console output) şi cin avem
nevoie de biblioteca (library) iostream. Ca să putem folosi această bibliotecă
trebuie să includem următoarele linii la începutul programului:
#include <iostream>
Afişarea numerelor sau stringurilor pe ecran (consolă) se face cu obiectul cout şi
operatorul de inserţie <<. De exemplu:
cout << "Quick wafting zephyrs vex bold Jim\n"
<< "The five boxing wizards jump quickly.\n";
cout afişează datele aşa cum le daţi. cout nu formatează nimic, nu adaugă spaţii
între cuvinte, nu adaugă new line, etc. Exemplu:
cout << "Quick" << "wafting" << "zephyrs";
Se va afişa:
Quickwaftingzephyrs
Dacă vrem spaţii între cuvinte atunci adăugăm şi spaţii:
cout << "Quick" << " " << "wafting" << " " << "zephyrs";
Lanţul cout poate fi oricât de lung vreţi. Nu e obligatoriu să-l aveţi pe un singur
rând (vezi primul exemplu). Trebuie să se termine cu punct şi virgulă.
Puteţi, de asemenea, să aveţi expresii într-o instrucţiune cout:
cout << "Aria cercului este:" << (PI * raza * raza);
Practic orice obiect care are o reprezentare string poate fi afişat pe ecran cu cout.
Aţi văzut că un rând nou se inserează cu secvenţa escape '\n'. Ei bine, mai este o
metodă cu endl. De exemplu:
cout << "Quick wafting zephyrs vex bold Jim" << endl << "The five boxing
wizards jump quickly.\n";
Atunci când vreţi să afişaţi numere double s-ar putea să nu obţineţi ceea ce vreţi.
double phi = 4.893654;
cout << phi;
Se va afişa 4.893654. Dar poate vreţi să afişaţi doar primele două zecimale. Cum
faceţi asta? Cu următoarele instrucţiuni:
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
58
cout.precision(2);
Prima instrucţiune ne permite să folosim funcţia precision doar pentru partea
fracţionară (de după punct); altfel ar fi luat în considerare tot numărul.
A doua instrucţiune afişează punctul zecimal de fiecare dată - chiar şi pentru
numere întregi.
A treia instrucţiune setează precizia numărului la 2 zecimale. Se fac rotunjiri!
Argumentul funcţiei trebuie să fie pozitiv şi număr întreg sau o expresie evaluată
la int.
După aceste instrucţiuni puteţi folosi cout normal ca să afişaţi numerele reale în
noul format:
cout << phi; // 4.89
Puteţi folosi opţiunea ios::scientific ca să afişaţi în notaţie ştiinţifică:
double phi = 0.0000123;
cout.setf(ios::scientific);
cout.setf(ios::showpoint);
cout.precision(2);
cout << phi; // 1.23e-005
Input cu CIN
Similar putem folosi cin (console input) pentru operaţii de input, adică de
obţinere a datelor de la tastatură (de la user). Se foloseşte cu operatorul de
extracţie >>.
int a, b;
cout << "Introduceti doua numere: ";
cin >> a >> b;
cout << "Suma lor este: " << (a + b);
Atunci când întâlneşte instrucţiunea cin, programul aşteaptă inputul de la user.
Atribuie prima valoare primei variabile, a doua valoare variabilei a doua, etc.
Programul nu citeşte datele de intrare decât după ce utilizatorul apasă ENTER la
tastatură. În acest fel userul se poate corecta folosind backspace.
Obiectul cin foloseşte spaţiile albe (space, enter, tab, etc.) ca delimitatoare. Asta
înseamnă că datele de intrare trebuie despărţite prin câte un spaţiu sau rând nou
(new line).
cin ignoră - şi elimină din fluxul (stream) de intrare - toate spaţiile albe până
întâlneşte un input valid.
Deoarece ignoră spaţiile albe, nu puteţi citi propoziţii de cuvinte cu cin. Trebuie
să folosiţi funcţia getline (care citeşte până când întâlneşte un caracter new line
pe care îl extrage din stream şi-l ignoră). Se foloseşte cu tipul string:
string fullname;
getline(cin, fullname);
59
cout << "\nNumele tau este: \n"
<< fullname << endl;
Primul parametru trebuie să fie cin pentru că citiţi de la tastatură.
Al doilea parametru este o variabilă string în care va fi salvat şirul.
Streamul (fluxul) de intrare (input stream) reprezintă şirul datelor de intrare.
Imaginaţi-vă un flux de informaţii care curge către calculator. Aceste date vin
nu numai de la tastatură, ci şi de la alte dispozitive de intrare: mouse, scanner,
mircofon, etc.
cin se ocupă numai de tastatură.
Similar, cout scrie în streamul de ieşire (output stream) care este afişat pe ecran.
Exemplu: Se citesc de la tastatură trei numere naturale. Să se afişeze suma lor.
Pentru datele de intrare: 14 89 99 se va afişa 202.
#include <iostream>
int main()
{
int a, b, c;
cin >> a >> b >> c;
cout << a + b + c; // parantezele pot lipsi
system("PAUSE");
return 0;
}
Cu cin puteţi citi numere întregi şi reale, stringuri şi caractere, etc.
60
Constante - Operatori Aritmetici - Atribuire compusă - Type Casting
Constante
O constantă, sau constantă literală, este o reprezentare a unei valori fixe în

program. O parte din constante le-aţi folosit în tutorialul anterior la iniţializarea
variabilelor.
Constantele de tip int sunt numere întregi: 45, -123, 0, 8965 etc.
Constantele de tip double (floating-point - virgulă mobilă) sunt numere reale:
3.14, 1.6867, 0.0001, 7.0 etc. Numerele reale mai pot fi exprimate şi prin notaţia
ştiinţifică.
De exemplu, numărul 1.5 * 104 poate fi reprezentat în C++ prin constanta 1.5e4,
unde e înseamnă 10 la puterea.
Numărul de după e reprezintă exponentul şi, deci, nu poate conţine punct
zecimal. Poate fi negativ.
Atenţie! În C++ numerele fracţionare nu pot conţine virgulă, ci doar punct
zecimal.
Constantele de tip caracter (char) sunt de forma: 'caracter', unde caracter
reprezintă un singur caracter ASCII.
De exemplu, 'a', 'x', 'G', 'P'. Caracterele se pun întotdeauna între două
apostrofuri.
Stringurile, şirurile de caractere, se pun între ghilimele. Exemplu: "Sunt un
string.".
Atenţie! Simbolul "B" este un string, nu un caracter de tip char. Următoarea
atribuire este ilegală: char s = "F"; // Gresit.
Secvenţele formate din backslash \ şi un singur caracter se numesc secvenţe
escape. Sunt folosite pentru a exprima caracterele imposibil de reprezentat
printr-un singur simbol. Acestea sunt cele mai folosite şi utile secvenţe escape:
Secvenţă escape Semnificaţie

\n Rând nou - new line
\t Tab orizontal
\\ Backslash
\' Apostrof
\" Ghilimele
\a Alertă (Sunet)
61
Secvenţele escape sunt tratate ca un singur caracter (deşi au două), deci se pun
între apostrofuri. Pot fi incluse în stringuri.
De exemplu, următoarea secvenţă de cod afişează textul pe două rânduri:
cout << "Acesta este\n" << "un exemplu.";
Stringurile sunt memorate fie în vectori de caractere, fie în obiecte de tip string
(aceste tipuri vor fi prezentate în tutorialele viitoare).
Constantele booleane sunt true şi false. Reprezintă cele două valori pentru tipul
bool.
C++ ne permite să declarăm variabile constante (constante declarate) cu ajutorul
modificatorului const. Exemplu:
const int MAX_PLAYERS = 500;
const double PI = 3.14159;
După ce au fost definite, aceste constante declarate nu pot fi modificate de nimic
în timpul execuţiei programului, nici măcar de o atribuire ulterioară (acest lucru
va genera o eroare de compilare).
Acest mod de a defini constante în program este foarte util. Dacă folosiţi o
valoare de mai multe ori în program este bine să-i daţi un nume şi să folosiţi
numele în loc de valoarea fixă propriu-zisă. Astfel veţi putea modifica mai uşor
valoarea constantei în program.
Modificatorul const poate fi folosit cu orice tip. Se numeşte modificator
deoarece modifică (restricţionează) variabila declarată.
Deşi C++ nu impune acest lucru, prin convenţie constantele declarate se scriu cu
litere mari şi cuvintele ce le alcătuiesc se despart prin underscore (_).
#include <iostream>
#include <string> // Necesar pentru tipul string
int main()
{
const double PI = 3.14159;
double raza;
string mesaj = "Introduceti raza cercului: ";
// cin este folosit pentru a obtine date de la user

cout << mesaj << '\n'; cin >> raza;
double aria = PI * raza * raza;
cout << "Aria cercului este: " << aria;

cout << '\n';
62
system("PAUSE"); // PAUZA
return 0;
}
Executaţi acest program.
Operatorii aritmetici
O expresie este formată din variabile, constante, operatori şi apeluri de funcţii.

Operatorii aritmetici definiţi în C++ sunt: + (adunare), - (scădere), * (înmuţire), /
(împărţire) şi % (modulo).
Modulo este operaţia prin care se obţine restul împărţirii unui număr la alt
număr. Exemplu: 5 % 2 returnează 1.
Ambii operanzi pentru operatorul % trebuie să fie de tip întreg.
Tipul rezultatului returnat de operatorii aritmetici depinde de tipul operanzilor.
Dacă ambii operanzi sunt de tip int atunci şi rezultatul va fi tot de tip int.
int result = 8 / 5; // 1
Dar dacă unul dintre operanzi este de tip double atunci rezultatul va fi de tip
double.
8.0 / 5 // 1.6
Regulile de evaluare sunt ca la matematică. Operatorii de înmulţire şi împărţire
au prioritate.
Puteţi altera ordinea evaluării folosind paranteze.
Operanzii nu trebuie să fie neapărat numere, pot fi de asemenea subexpresii:
double res = (3 + 2) / 2.0 * 3; // 7.5
Dacă nu sunteţi siguri de ordinea în care vor fi evaluate expresiile, vă recomand
să folosiţi parantezele. Nu strică şi nu scad performanţa programului.
Operatorul ++ creşte valoarea variabilei cu 1, iar operatorul -- scade valoarea
variabilei cu 1.
Când sunt folosiţi ca prefix, operatorii returnează noua valoare a variabilei, iar
când sunt folosiţi ca sufix operatorii returnează valoarea curentă a variabilei. În
ambele cazuri variabila este modificată, diferenţa constă în valoarea returnată.
Exemplu:
int a = 2, b = 2;
int x = a++; // sufix: se returneaza 2
int y = ++b; // prefix: se returneaza 3
cout << x << ' ' << y << '\n'; // 2 3

cout << a << ' ' << b; // 3 3
63
Aceşti operatori vor fi folosiţi cel mai des în structurile iterative (for, while etc.).
Au prioritatea mai mare ca înmulţirea şi împărţirea!
Tabelul cu prioritatea operatorilor.
Atribuire compusă | Type casting
Atunci când vrem să actualizăm valoarea unei variabile vom folosi probabil
această expresie a = a + b, unde a creşte cu valoarea lui b.
Există totuşi o notaţie prescurtată pentru acest tip de atribuire:
variabila operator= expresie;

De exemplu:
int a = 4, b = 2;
a += b + 1; // echivalent cu: a = a + (b + 1);
a *= b - 2; // echivalent cu: a = a * (b - 2);
a %= (b - 1) + 5; // echivalent cu: a = a % ((b - 1) + 5);
Type casting sau conversia de tip este metoda prin care puteţi converti o valoare
de un tip într-un alt tip. Se realizează cu operatorul static_cast. De exemplu,
dacă avem un int şi vrem să-l convertim în double, folosim:
int a = 7; double x;
x = static_cast<double>(a);
Sintaxa generală:
static_cast<tip>(expresie);
Acest operator nu modifică valoarea variabilei convertite, ci o returnează ca o
valoare nouă convertită în tipul specificat. Folosind conversia puteţi afla
valoarea ASCII a unui char:
int val; char p = 'A';
val = static_cast<int>(p); // 65
Metoda învechită, aproximativ echivalentă cu cea de sus, este următoarea:
int val; char p = 'A';
val = (int)p;
// sau
val = int(p);
Atunci când convertiţi din double (sau float) într-un tip întreg (int, short, long
etc.) veţi pierde partea fracţionară (de după punctul zecimal). Nu se fac rotunjiri!
Exemplu:
double epsilon = 4.9565;
int alpha = static_cast<int>(epsilon); // 4
64
Sfat: Oriunde puteţi avea o constantă literală în program, puteţi avea şi o
expresie, deoarece expresia, în cele din urmă, va fi evaluată la o singură valoare.
Identificatori - Variabile - Atribuire
Identificatori
Identificatorii reprezintă numele dat entităţilor dintr-un program C++.

Identificatorii pot începe cu literă sau underscore (_) şi pot continua numai cu
litere, cifre sau underscore. Exemplu:
Apple, _mCount, startDownload1

Exemplu de identificatori nevalizi:
1apple, _mCount.20, 123
Aceştia vor fi respinşi de compilator. Nu sunt identificatori valizi deoarece:
primul începe cu o cifră, al doilea conţine un caracter nepermis (punct), iar
ultimul este un număr.
C++ este case-sensitive, deci Home este diferit de HoMe.
Nu folosiţi ca identificatori cuvintele rezervate - reserved keywords - şi
identificatorii predefiniţi (de exemplu cout).
Deşi este posibil să redefiniţi aceşti identificatori, nu recomand asta deoarece fac
parte din bibliotecile standard C++, şi cu siguranţă veţi avea nevoie de acestea.
De cele mai multe ori, IDE-urile colorează cuvintele rezervate în albastru, deci
nu trebuie să le învăţaţi.
Nu există limită pentru numărul de caractere pe care-l poate avea un
identificator. Unele compilatoare vor lua în considerare doar un anumit număr
de caractere. Este un număr mare deci nu vă faceţi griji.
O convenţie populară (care a devenit universală în OOP) de numire este
camelCase. În notaţia camelCase, literele mari sunt folosite pentru a delimita
cuvintele dintr-un identificator. De exemplu:
bigApple, getName, setCount, estePrim
Prima literă poate fi mare, dar asta de obicei când numiţi clase (tipuri definite de
programator).
Variabile
De cele mai multe ori programele lucrează cu informaţii. Aceste informaţii

trebuie salvate undeva. Acest undeva este memoria.
Pentru a putea manipula informaţia în program, folosim variabile. Variabilele
trebuie declarate înainte de a putea fi folosite. A declara o variabilă înseamnă:
65
 Să specifici ce fel de valori vei memora în respectiva variabilă
 Să-i dai un nume
Tipul de dată specifică ce valori poate memora o variabilă şi cât spaţiu va

ocupa în memorie.
Calculatorul trebuie să cunoască tipul de dată al variabilei deoarece pe baza
acestuia stabileşte cât spaţiu rezervă variabilei respective şi stabileşte algoritmii
de codificare şi decodificare ai informaţiei.
De exemplu, caracterul 'a' în memorie este 1100001, dar acest şir de 1 şi 0 este
de fapt numărul 97 scris în binar. Deoarece calculatorul ştie (datorită tipului de
date) că lucrează cu un caracter, acesta va afişa (atunci când îi cerem) pe ecran
caracterul a în loc de numărul 97.
Calculatorul ştie permanent adresa de memorie a fiecărei variabile. Astfel poate
să actualizeze informaţia stocată în respectiva locaţie.
Puteţi afla adresa de memorie a variabilei folosind operatorul & (voi discuta mai
multe despre asta în tutorialul despre pointeri).
int numar;
double pi, epsilon;
Prima linie declară o variabilă de tip int care poate memora numai numere
întregi (integer).
A doua linie declară două variabile de tip double care pot memora numere reale
(floating-point).
Observaţi că puteţi declara mai multe variabile de acelaşi tip pe aceeaşi linie
despărţite prin virgulă. De asemenea, instrucţiunea de declarare se termină cu
punct şi virgulă.
Pe lângă int şi double mai există tipurile char, float, bool, short, long. Toate
acestea se numesc tipuri fundamentale (tipuri primitive).
Tabelul cu tipurile fundamentale îl găsiţi aici. NU trebuie să-l memoraţi!
Trebuie doar să ştiţi că int ocupă de obicei 4 bytes şi este folosit pentru numere
întregi, double ocupă 8 bytes şi este folosit pentru numere reale, iar char ocupă 1
byte şi este folosit pentru caractere ASCII.
Tipurile întregi sunt: short (2 bytes), int, long (8 bytes). Puteţi trata char ca pe un
tip întreg - deoarece fiecărui caracter ASCII îi corespunde un număr întreg - dar
nu recomand acest lucru.
Tipurile reale sunt: float (4 bytes) şi double.
Tipul bool ocupă 1 byte şi memorează doar două valori: true şi false.
// Sintaxa de declarare
tip_data variabila1, variabila2, variabila3, ..., variabilaN;
// Exemple
int x, y, z;
char litera; bool ok;
double alfa, theta;
66
Fiecare din tipurile întregi pot fi unsigned, însemnând că reprezintă doar numere
întregi pozitive. Evident că mulţimea de valori va fi mai mare.
De exemplu, dacă int ia valori din intervalul [-2,147,483,647 până la
2,147,483,647] atunci unsigned int va lua valori din intervalul [0 la
4,294,967,295]. Dacă vreţi să ştiţi cum sunt reprezentate numerele negative într-
un calculator, intraţi aici.
Atribuirea
Atribuirea (asignarea) în C++ se face cu operatorul = (operatorul de atribuire).

Atribuirea este operaţia prin care puteţi schimba valoarea unei variabile în mod
direct.
int a = 40;
Mai sus am atribuit variabilei a valoarea 40. Observaţi că am făcut acest lucru
imediat după ce am declarat variabila. Se citeşte a ia valoarea 40. (NU vă
gândiţi la noţiunea de egalitate din matematică. Pentru asta avem operatorul ==).
Atunci când sunt declarate, variabilele nu au o valoare bine definită. De aceea
este important să iniţializaţi o variabilă înainte de a o folosi.
Variabilele declarate global (în afara oricărei funcţii şi clase) sunt iniţializate
automat cu valoarea implicită. Pentru tipurile întregi aceasta este 0, pentru bool
este false, iar pentru char este '\0'.
Se zice că o variabilă este iniţializată atunci când îi atribuiţi o valoare pentru
prima dată.
Mecanismul de asignare funcţionează în felul următor:
Partea din dreapta operatorului = (rvalue), care poate fi o variabilă, o constantă,
sau o expresie, este evaluată, şi rezultatul evaluării este memorat în partea din
stânga operatorului = (lvalue), care trebuie să fie o variabilă.
int x;
x = 45 + 32;
Variabila x are valoarea 77.
Deoarece operatorul = returnează valoarea atribuită variabilei, este posibil să-l
folosim în felul următor:
int a, b;
a = b = 5;
Atenţie! Operaţia de atribuire este evaluată de la dreapta la stânga!!
În exemplu, b ia valoarea 5, iar apoi a ia valoarea returnată de operatorul = din
subexpresia b = 5, adică a ia valoarea 5.
Fie următorul exemplu:
int a = 4, b;
b = a = 3;
Atât a cât şi b vor fi 3.
Atunci când daţi valori variabilelor încercaţi să nu amestecaţi tipurile. De
67
exemplu unei variabile de tip int nu-i daţi valoarea 5.678 (double). Bineînţeles
că în variabila int va fi memorat doar 5 (partea întreagă a lui 5.678), deoarece
compilatorul face conversia automat. Dar aceste conversii automate, chiar dacă
nu generează erori, pot duce la buguri în program.
Rulaţi următorul program:
#include <iostream>
int main()
{
int a, b = 10;
double x, z, pi = 3.14;
a = b = 30;
x = pi; // x este initializat
z = x * pi; // * - inmultire
b = (a + b) - 2 * b;
// cout afiseaza pe ecran

cout << a << ' ' << b << ' ' << x << ' ' << z;
system("PAUSE"); // PAUZA
return 0;
}
Structura unui program C++

#include <iostream>
int main()
{
// Afiseaza pe ecran Hello World
cout << "Hello World";
return 0;
}
Directivele preprocesor
#include <iostream>
68
Această linie se numeşte directivă preprocesor sau simplu directivă. Se
deosebeşte de celelalte linii de cod prin faptul că începe cu #.
Rolul acestor linii este multiplu. Aici, directiva #include are rolul de a preciza
compilatorului faptul că vom folosi în program entităţile (funcţii, clase,
constante, etc.) din fişierul iostream (cout este un obiect definit în namespace-ul
std din iostream).
În acest mod putem scrie programe pornind de la altele existente, fără a rescrie
conţinutul lor în noul program. E un mod de a salva timp, spaţiu şi bani.
Fişierul iostream face parte din standardul C++ (compilatorul ştie unde se află,
de aceea nu trebuie să precizăm întreg path-ul).
Directivele nu se termină cu punct şi virgulă (Reţineţi asta!).
Următoarea linie using namespace std; spune că vom folosi toate numele
(denumirile entităţilor) din secţiunea (această secţiune se numeşte de fapt
namespace; veţi afla mai târziu ce este acesta) std din iostream.
Majoritatea programelor C++ vor începe cu aceste două linii. Fără ele nu veţi
putea afişa pe ecran şi nu veţi putea citi date de la user.
Funcţia main
Un program C++ constă practic doar din funcţia main. Atunci când rulaţi
programul, sistemul de operare invocă automat funcţia numită main.
Funcţiile - alte denumiri pentru conceptul de funcţie sunt: procedură,
subprogram, metodă (în OOP) - sunt entităţi ce grupează sub un singur nume o
porţiune de cod din program.
Funcţiile pot fi apelate (invocate) precizând numele acestora. Atunci când o
funcţie este invocată, codul funcţiei - se află între acolade - va fi executat.
Observaţi că o funcţie permite executarea aceluiaşi cod de mai multe ori fără a
scrie respectivul cod de mai multe ori în program.
Main este entry-pointul (punctul de intrare) programului. Aproape toate
limbajele de programare necesită definirea unei funcţii main. Fiecare program
trebuie să aibă un punct de start, iar acest punct este funcţia main.
Linia int main() se numeşte antetul sau header-ul funcţiei. În antet apar: tipul
valorii returnate de funcţie (aici int), numele funcţiei (aici main), parametrii între
paranteze (dacă există).
Corpul funcţiei (function body) constă din cele două acolade şi codul definit
între ele.
Instrucţiunea return 0; returnează valoarea 0 şi totodată opreşte execuţia funcţiei.
Deoarece sistemul de operare a apelat funcţia, tot el este acela care va primi
valoarea returnată de main. Codul 0 semnifică faptul că programul a rulat fără
probleme.
69
Instrucţiuni şi comentarii
Instrucţiunile (statements) reprezintă comenzi către calculator; sarcinile pe care

acesta trebuie să le îndeplinească.
Toate instrucţiunile trebuie să se termine cu punct şi virgulă ; (Reţineţi asta!).
Puteţi avea mai multe instrucţiuni pe aceeaşi linie atâta timp cât le separaţi prin
punct şi virgulă.
În programul de mai sus, instrucţiuni sunt:

cout << "Hello World";
return 0;
Directivele sunt instrucţiuni - speciale - pentru preprocesor. Preprocesorul este
executat de compilator înainte ca procesul de compilare să aibă loc.
Linia // Afiseaza pe ecran Hello World reprezintă un comentariu (comment).
Comentariile nu fac nimic (nu sunt instrucţiuni). Sunt de 2 feluri:
- comentariile întinse pe un rând (încep cu //);
- comentariile întinse pe mai multe rânduri (încep cu /* şi se termină cu */).
Exemplu:
/* Grumpy wizards make toxic brew
for the evil Queen and Jack. */
Comentariile sunt ignorate de compilator. Comentariile sunt folosite, în general,
pentru a explica anumite părţi ale programului.
Instrucţiunea cout << "Hello World"; afişează pe ecran textul Hello World.
Instrucţiunile din program sunt executate secvenţial (una după alta) de la început
până la sfârşit. După ce toate instrucţiunile au fost executate, programul îşi
încetează execuţia.
Şi compilatorul scanează secvenţial codul sursă atunci când îl translatează în cod
maşină.
Motivul pentru care browserul - pe care-l folosiţi acum - nu se opreşte este că
acesta aşteaptă comenzi de la user. Dacă userul apasă pe X, atunci browserul se
va opri, deoarece comanda de terminare va fi ultima de îndeplinit.
Este posibil să alterăm execuţia secvenţială a programului folosind structurile de
control (for, if, while, etc.). Acestea modifică flow-ul execuţiei programului în
funcţie de anumite condiţii. Voi discuta despre aceste lucruri mai târziu.
70

Lectia C++

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Lectia C++

Încărcat de

Drepturi de autor:

Formate disponibile

Lectia 1 C++ | Structura unui program

Published: Monday, 01 February 2016 18:23

Aceasta este structura unui program:

// = reprezinta inceperea unui comentariu pe un singur rand;

//Acesta este un comentariu pe un singur rand

#include <iostream> = reprezinta o directiva preprocesor (indicata de simbolul

Acest header permite realizarea afisarii pe monitor.

using namespace std = face apel catre libraria standard.

int main = reprezinta functia principala a programului.

return 0 = reprezinta starea de iesire a procesului.

O variabila este o portiune de memorie care stocheaza o valoare data.

Fiecare variabila are nevoie de un identificator care o deosebeste de celelalte.

O variabila poate fi globala sau locala.

int x; //aceasta este o variabila globala deoarece este declarata in corpul

int y; //aceasta este o variabila locala deoarece este declarata in corpul

printf("\n%d. Variabila y este locala!",y);

int x; //declararea variabilei

printf("%d",x); //acest %d este un specificator de format si inlocuieste

#include <stdio.h> = fara aceasta biblioteca nu putem folosi functia printf.

Acum sa folosim numere cu virgula.

float x=3.6; //am declarat variabila x de tip float

printf("%f\n",x); //%f inlocuieste x-ul cu valoarea variabilei

string z="Aceste este un sir de caractere!"; //valoarea se noteaza intre

cout << z; //cout << este echivalentul lui printf

Lectia 3 C++ | Tipuri de date

Orice variabila sau constanta este de un anumit tip de date.

Tipurile de date sunt:

Acum, sa definim fiecare tip de date.

char a='T'; //valoarea lui a, este T

printf("%c",a); //se afiseaza valoarea lui A, care este T

cout << x; //se afiseaza valoarea lui x

In final, urmeaza tipul de date "float":

Lectia 4 C++ | Specificatori de format

Specificatorii de format sunt:

Sa incepem cu specificatorul "%d" / "%i" :

printf("%d",a); //specificatorul "%d", inlocuieste pe a cu valoarea data

printf("\n"); //rand nou

printf("%i",b); //specificatorul "%i", inlocuieste pe b cu valoarea data

printf("\n"); //rand nou

printf("%.3f",b); //specificatorul "%f", inlocuieste pe b cu valoarea data

In final, urmeaza specificatorul "%c":

Constantele sunt opusul variabilelor.

Lectia 6 C++ | Operatori

Acum sa folosim fiecare operator.

Incepem cu operatorul "+":

suma=a+b; //operatorul "+", aduna variabila "a" cu variabila "b".

Am declarat trei variabile: a, b, suma.

Acum sa trecem la operatorul "-":

diferenta=a-b; //operatorul "-", scade variabila "a" din variabila "b".

Urmeaza operatorul "*":

produsul=a*b; //operatorul "*", inmulteste variabila "a" cu variabila "b".

catul=a/b; //operatorul "/", imparte variabila "a" cu variabila "b".

Haideti sa facem un program care sa calculeze: suma, diferenta, produsul si catul

Acesta este codul cu explicatii:

#include <iostream> //biblioteca

using namespace std; //face apel catre biblioteca standard

printf("Introduceti primul numar:"); //afisam un mesaj

printf("\n\nCe operatie doriti sa faceti?\n"); //afisam un mesaj

z=getch(); //citeste un singur caracter de la tastatura

case '1' : suma=a+b; printf("\nSuma este egala cu:%.2f",suma);break;

printf("Operatorul ! neaga o conditie."); //acesta este mesajul.

Urmeaza operatorul "&&":

printf("Operatorul && verifica toate conditile.");

Urmeaza operatorul "||":

produsul=ab; //operatorul "", inmulteste variabila "a" cu variabila "b".