InfoAcademy-C++ Lectia01 PDF

InfoAcademy Adonis Butufei
CUPRINS
1 INTRODUCERE........................................................................................................................................3
1.1 Limbaje de programare: tipuri si caracteristici...................................................................................3
1.1.1 Ce este un limbaj de programare?...............................................................................................3
1.1.2 Generatiile limbajelor de programare..........................................................................................3
1.2 Ce este C++?.......................................................................................................................................5
1.2.1 Modelele de programare suportate de C++.................................................................................5
1.2.2 Documentatia online pentru limbajul C++..................................................................................6
1.3 Medii de dezvoltare integrata (IDE)....................................................................................................7
1.4 Scrierea primului program..................................................................................................................7
1.4.1 Crearea proiectului......................................................................................................................7
1.5 Sumar..................................................................................................................................................9
2 ELEMENTE DE BAZA C++...................................................................................................................10
2.1 Comentariile......................................................................................................................................10
2.1.1 Comentarii pe mai multe linii....................................................................................................10
2.1.2 Cel specific C++ care este este pe o singura linie.....................................................................10
2.1.3 Recomandari..............................................................................................................................10
2.2 Variabile si constante - introducere...................................................................................................11
2.2.1 Ce sunt variabilele.....................................................................................................................11
2.2.2 Tipul variabilelor.......................................................................................................................11
2.2.3 Declararea variabilelor...............................................................................................................11
2.2.4 Atribuirea valorilor....................................................................................................................12
2.2.5 Citirea valorilor de la tastatura..................................................................................................13
2.2.6 Constante...................................................................................................................................13
2.2.7 Declararea constantelor simbolice.............................................................................................14
2.2.8 Constante de tip enumerare.......................................................................................................14
2.2.9 Sugestii pentru denumirea constantelor.....................................................................................15
2.3 Instructiuni, operatori si expresii introducere...................................................................................16
2.3.1 Instructiuni.................................................................................................................................16
2.3.2 Instructiuni compuse sau blocuri...............................................................................................16
2.3.3 Operatori si expresii...................................................................................................................16
2.3.3.1 Operatorul =.......................................................................................................................16
2.3.3.2 Expresiile...........................................................................................................................16
2.3.3.3 Operatorii aritmetici...........................................................................................................17
2.3.3.4 Incrementarea / decrementarea variabilelor.......................................................................17
2.3.3.5 Operatorii de comparare....................................................................................................18
2.4 Elemente de control al executiei.......................................................................................................18
2.4.1 Secventele..................................................................................................................................18
2.4.2 Deciziile.....................................................................................................................................18
2.4.2.1 Instructiunile if, else, else if...............................................................................................19
2.4.2.2 Instructiunea switch...........................................................................................................21
2.4.3 Bucle..........................................................................................................................................23
2.4.3.1 Bucle while........................................................................................................................23
2.4.3.2 Bucle do / while.................................................................................................................24
2.4.3.3 Bucle for............................................................................................................................25
2.4.4 Instructiunea break....................................................................................................................26
2.4.5 Instructiunea continue................................................................................................................27
2.5 Functii................................................................................................................................................28
2.5.1 Definirea functiilor....................................................................................................................28
2.5.2 Declararea functiilor..................................................................................................................28
1
2.5.3 Apelul functiilor.........................................................................................................................29

2.5.4 Exemple de functii.....................................................................................................................29
2.5.5 Executia programelor................................................................................................................30
2.6 Elemente de depanarea programelor: breakpoint, watches...............................................................30
2.6.1 Setarea breakpointurilor............................................................................................................31
2.6.2 Rularea in mod debugger a programelor...................................................................................31
2.6.2.1 Rularea programului pas cu pas.........................................................................................31
2.6.2.2 Rularea programului pana la urmatorul breakpoint...........................................................32
2.6.2.3 Rularea progamului pana in dreptul cursorului.................................................................32
2.6.3 Adaugarea watches....................................................................................................................32
2.7 Exemplu practic.................................................................................................................................32
2.8 Anexa: cuvintele cheie standard pentru C++.....................................................................................33
2.9 Sumar................................................................................................................................................33
2.10 Intrebari si exercitii.........................................................................................................................35
2.11 Bibliografie:.....................................................................................................................................36
2
1 INTRODUCERE
1.1 Limbaje de programare: tipuri si caracteristici
1.1.1 Ce este un limbaj de programare?

Un limbaj de programare contine un set de reguli si expresii care permite scrierea programelor.
Programele descriu pasii pentru rezolvarea unor probleme. Fiecare pas este exprimat in comenzi care sunt
executate de calculator.
1.1.2 Generatiile limbajelor de programare

Prima generatie
Programele din aceasta generatie erau scrise la inceput in limbaj binar, care putea fi procesat direct de
calculatoare.
Pentru imbunatatirea productivitatii au fost create limbajele de asamblare. Aceste tipuri de limbaje
contineau un set de instructiuni specifice tipului de calculator. Pentru a transfera programul pe alt tip de
calculator era necesara rescrierea lui folosind un nou set de instructiuni.
A doua generatie
Aceasta generatie a aparut cu limbajul FORTRAN. El permitea scrierea programului folosind un set de
instructiuni care erau mai usor de scris si depanat si erau independente de platforma hardware pe care
lucrau.
Pentru a putea fi rulat pe o masina, codul scris de programator trebuia transformat in instructiuni binare
(cod obiect) si aceasta se realiza cu ajutorul unui program numit compilator.
Deoarece codul sursa putea avea mai multe fisiere, dupa compilare rezultau mai multe fisiere binare care
trebuiau grupate impreuna pentru a crea programul. Aceasta se realiza cu ajutorul unui program numit
linker. Pentru a putea fi transferat pe o alta platforma hardware programul trebuia recompilat cu un
compilator specific acelei platforme.
A treia generatie
Daca a doua generatie a imbunatatit structura logica a limbajelor, a treia generatie a devenit mult mai usor
accesibila dezvoltatorilor. Multe limbaje de uz general folosite astazi, BASIC, C, C++, Java, C# apartin
acestei generatii.
Brian Kernighan si Denis Richie au creat limbajul de programare C. Acest limbaj a fost folosit pentru
rescrierea sistemului de operare UNIX care a avut un succes deosebit. Multe platforme hardware au
adoptat variante ale acestui sistem de operare. Dupa raspandirea acestui sistem de operare, scrierea
programelor a devenit mult mai usoara pentru ca dezvoltatorii nu mai erau nevoiti sa interactioneze direct
3
cu particularitatile platformei hardware ci cu resursele oferite de sistemul de operare.

In aceasta generatie, pe langa compilatoare au aparut interpretoarele care executau programul
instructiune cu instructiune. Acest mod de lucru permitea obtinerea raspunsului imediat fara a mai fi
necesara compilarea.
Deoarece procesul de compilare pentru programele mari era consumator de timp, dezvoltatorii s-au gandit
oare nu putem sa facem ceva invers? In loc sa compilam codul in limbaj binar, sa dezvoltam un program
care sa fie capabil sa execute comenzi complexe si compilarea sa se execute in momentul executiei. Asa
au aparut masinile virtuale care erau capabile sa execute comenzi si compilatoarele Just in time folosite
de limbajele Small Talk, Java si C#. In acest mod era suficient sa se implementeze o masina virtuala
pentru fiecare platforma iar codul scris in acel limbaj putea, cel putin teoretic, sa fie rulat pe toate
platformele.
A patra generatie
Cu limbajele de uz general din a treia generatie puteau fi dezvoltate o multitudine de programe. Insa
pentru anumite domenii specifice cum ar fi interogarea bazelor de date, calcule statistice si altele nu era
eficienta folosirea acestor limbaje. Din acest motiv, limbajele din a patra generatie s-au concentrat pe
rezolvarea problemelor specifice unor domenii.
Scopul acestor limbaje este sa reduca eforturile si costurile de dezvoltare a programelor, oferind un nivel
inalt de abstractizare al domeniului respectiv.
Cateva exemple de limbaje: FoxPro, SQL, PL/SQL, LabView, S, R, Mathematica, ABAP.
A cincea generatie
Aceste limbaje sunt dezvoltate cu intentia de a lasa programul sa rezolve probleme fara interventia
programatorului si sunt folosite in cercetarile legate de inteligenta artificiala. Eforturile in acest domeniu
au ramas inca in faza cercetarilor. Cateva exemple de limbaje: Prolog, OPS5, Mercury.
4
1.2 Ce este C++?

Asa cum am vazut in paragraful anterior C++ este un limbaj care apartine generatiei a treia. A fost creat
de Bjarne Strostrup in anul 1980. Dupa cum o sugereaza si numele, este bazat pe limbajul C si ofera
imbunatatiri radicale acestui limbaj. In mai bine de trei decenii de existenta limbajele C si C++ s-au
influentat si completat reciproc.
De ce a fost ales C ca limbaj de baza pentru C++?

• Pentru ca este un limbaj eficient si permite dezvoltarea apropiata de nivelul masina.
• Pentru ca oferea solutia optima pentru cele mai multe activitati de programare.
• Pentru ca ruleaza pe orice platforma hardware.
1.2.1 Modelele de programare suportate de C++

Programare procedurala
Aceasta model imparte functionalitatea programului in proceduri (functii) si foloseste algoritmii optimi
pentru implementarea functiilor. Atentia principala este indreptata catre transmiterea si returnarea
rezultatelor.
Programare modulara
Pe masura ce dimensiunea si complexitatea programelor creste, apare necesitatea unei organizari la nivel
mai inalt. Functionalitatea este impartita in module. Aceste module contin datele si procedurile care
lucreaza cu aceste date.
Progamarea modulara este un aspect pentru toate programele mari de succes. Pe masura ce aceste
programe cauta sa rezolve probleme reale, exprimarea conceptelor este destul de dificila folosind doar
tipurile de date oferite de limbajul de programare. Pentru a rezolva acest aspect C++ asigura
dezvolatorilor posibilitatea definirii propriilor tipuri de date. Acestea se numesc tipuri abstracte de date
sau tipuri definite de utilizator.
Programare obiectuala
Abstractizarea datelor este un element esential al designului de calitate. Totusi, doar tipurile utilizator nu
rezolva o serie de aspecte importante ale programelor reale.
Primul aspect important al programarii obiectuale este incapsularea. Incapsularea presupune separarea
modului de folosire a functionalitatii de detaliile de implementare. Majoritatea obiectelor din jurul nostru,
televizoare, telefoane mobile, tablete etc. ofera o interfata simpla de folosire si ascund modul cum au fost
realizate.
5
Al doilea aspect important al programarii obiectuale este mostenirea. Mostenirea permite extinderea unei
clase si adaugarea de alte functionalitati. Acest mecanism, folosit corect, permite reutilizarea codului
intr-un grad mult mai mare decat era posibil folosind modelele anterioare.
De exemplu putem avea o clasa Angajat. Deoarece un manager este un angajat dar are atributii diferite de
ale angajatului putem deriva clasa Manager si adauga functionalitatea specifica, asa cum este schitat in
exemplul de mai jos. Clasa Angajat se numeste clasa de baza, sau parinte pentru clasa Manager. Clasa
Manager se numeste clasa derivata.
Al treilea aspect important al programarii obiectuale este polimorfismul. Acest mecanism permite
claselor derivate sa specializeze comportamentul claselor de baza. De exemplu toate mijoloacele de
transport în comun se deplaseaza intre statii. Tramvaiul si autobuzul specializeaza deplasarea intre statii
in mod diferit.
Programare generica
Aplicarea programarii obiectuale in productie a permis reducerea timpului de dezvoltare a proiectelor de
la luni la saptamani si de la ani la trimestre. De asemenea, a permis dezvoltarea mai eficienta a versiunilor
urmatoare ale programelor lansate pe piata.
Exista tipuri de prelucrari care sunt similare indiferent de tipul de date asupra carora se executa aceste
prelucrari. O stiva de caramizi si o stiva de farfurii folosesc acelasi tipar de organizare a elementelor.
Folosind programarea generica putem implementa tiparul, stiva, o singura data si apoi sa-l folosim pentru
diferite tipuri de date.
1.2.2 Documentatia online pentru limbajul C++

Acest curs prezinta elementele de baza ale limbajului. Pentru informatii detaliate despre limbaj,
aprofundarea cunostintelor si rezolvarea problemelor practice este necesara consultarea documentatiei
online. In aceasta sectiune sunt recomandate sursele de informare utile:
1. Documentatia standard C++ poate fi consultata la: http://www.cplusplus.com/. Acest site contine
informatii de referinta legate in C++.
2. O alta sursa importanta de informatii despre programarea C++ se gaseste la:
http://www.cprogramming.com/
3. Informatii introductive pot fi gasite la: http://www.cpp4u.com/
4. C++ FAQ1 pot fi gasite la: http://www.parashift.com/c++-faq-lite/
5. Danny Kalev are un blog cu informatii utile despre C++ care poate fi accesat la:
http://www.informit.com/guides/guide.aspx?g=cplusplus
1 Intrebari frecvente despre C++, este o versiune online a unei carti excelente C++ FAQ de Marshall Cline
6
1.3 Medii de dezvoltare integrata (IDE)

Mediile de dezvoltare integrata sunt programe care reduc eforturile de dezvoltare. Ele cuprind printre
altele functionalitati de editare a codului, gestionarea proiectelor si fisierelor, compilare, depanare si
trasarea executiei programelor. In acest curs vom folosi mediul codeblocks care este disponibila pentru
download din contul personal (varianta Windows).
1.4 Scrierea primului program
1.4.1 Crearea proiectului

In incheierea acestei lectii vom scrie
un program care afiseaza clasicul
Hello World! pe ecran.
Se porneste aplicatia si se selecteaza
meniul File / New / Project. Se Fig 1.1
alege console appplication si se
apasa butonul Go.
Fig 1.2
Se alege tipul de program c++ si se apasa next. Se alege directorul unde se salveaza fisierele proiectului si
se apasa next. Se pastreaza optiunile implicite si se apasa finish.
Fig 1.3 Fig 1.4
Dupa acest pas avem cel mai simplu proiect c++:

Pentru compilare si executie completa se foloseste meniul Build iar pentru trasarea executiei si depanare
se foloseste meniul Debug.
7
Fig 1.5
Fig 1.6
cpp obj
cpp obj
linkeditor exe
c++ runtime
biblioteci (lib)
Fig 1.7
Atunci cand se apasa build compilatorul transforma fiecare fisier sursa in fisier binar. Apoi linkeditorul
conecteaza aceste fisiere cu biblioteca runtime de c++ si cu alte biblioteci si genereaza fisierul executabil.
8
Extensia fisierului determina sintaxa folosita de compilator: *.c pentru limbajul C respectiv *.cpp pentru
limbajul C++.
1.5 Sumar
• Limbajele de progamare permit transmiterea instructiunilor catre calculator.
• Exista 5 generatii de limbaje de programare.
• Primele trei generatii au reprezentat evoulutia tehnologica pentru limbajele de programare de uz

general. A patra generatie de limbaje de programare a cuprins limbaje specializate pe anumite domenii
cum ar fi interogarea bazelor de date. A cincea generatie a ramas doar în domeniul cercetarii.
• Limbajul C++ a fost creat de Bjarne Strostrup în anul 1980 si are la baza limajul C. El suporta patru
modele de scriere a programare: procedurala, modulara, obiectuala si generica.
• Programarea procedurala imparte functionalitatea unui program în functii si date asupra carora se
exercita actiunea functiilor.
• Programarea modulara permite gruparea functiilor si datelor în module.
• Programarea obiectuala ofera 3 mecanisme pentru cresterea productivitatii: incapsularea, mostenirea si

polimorfismul.
• Programarea generica ajuta la implementarea unei functionalitati comune pentru tipuri diferite de date.
• Procesul dezvoltarii programelor are 4 etape de baza: designul, implementarea, testarea si depanarea.
Pentru realizarea programelor practice aceste etape se parcurg de mai multe ori.
• Dezvoltarea programelor de calitate necesita o metodologie care ajuta descompunerea problemelor
complexe în probleme mai simple care pot fi analizate, planificate si dezvoltate.
• Pentru cresterea productivitatii se folosesc mediile de dezvoltare integrata.
9
2 ELEMENTE DE BAZA C++

Dupa parcurgerea acestui capitol:
• Vom putea sa scriem programe simple care ne vor permite explorarea practica a conceptelor
invatate de acum inainte.
• Vom putea organiza codul in functii pentru o mai buna organizare logica.
• Vom putea folosi variabilele si constantele.
• Vom intelege folosirea operatorilor si expresiilor.
• Vom intelege elementele de control ale executiei unui program.
• Vom intelege elementele de baza ale depanarii programelor.
2.1 Comentariile
Comentariile sunt explicatii care ajuta programatorul sa inteleaga mai usor anumite aspecte ale codului.
Pentru a putea fi ignorate de compilator comentariile necesita folosirea unor caractere de idenficare.
Exista doua tipuri de comentarii: pe mai multe linii si pe o singura linie.
2.1.1 Comentarii pe mai multe linii

Cel preluat din C si care se poate extinde pe mai multe linii, cuprins intre /* si */. Exemplu:
/* Acesta este un exemplu de comentariu
pe mai multe linii si
este preluat din C. */
2.1.2 Cel specific C++ care este este pe o singura linie.

// Acest comentariu este specific C++.
2.1.3 Recomandari
Comentariile nu trebuie sa clarifice ce face codul ci de ce este aleasa o anumita abordare.
Atunci cand se schimba codul este important sa actualizam si comentariile aferente.
Trebuie sa fie concise pentru a reduce eforturile de mentenanta.
10
2.2 Variabile si constante - introducere
2.2.1 Ce sunt variabilele

In C++ variabilele sunt zone de memorie in care se stocheaza datele. Putem gandi un program ca avand
doua parti importante: partea de cod care contine instructiunile scrise de programator si partea de date -
partea asupra careia se exercita actiunile instructiunilor.
2.2.2 Tipul variabilelor

Tipul unei variabile specifica dimensiunea zonei de memorie rezervata pentru ea. In C++ este necesara
declararea tipului pentru fiecare variabila folosita. Aceasta ofera doua avantaje majore: eficienta si
identificarea posibilelor erori in timpul compilarii. Eficienta este realizata prin folosirea unei cantitati
optime de memorie pentru date.
In tabelul de mai jos sunt prezentate doar tipurile de variabile necesare pentru a scrie programele de
invatare iar in capitolul urmator vom prezenta toate tipurile de date fundamentale din C++ cu detaliile
aferente.
Tip de date folosit Cuvant cheie Detalii

Numere intregi int
Numere reale double
Valoare de adevar bool poate fi true sau false

O singura litera char
Siruri de caractere string Trebuie adaugat la inceputul fisierului daca nu exista:

#include <string>
using namespace std;
sirul de caractere trebuie delimitat de " (ghilimele)

string mesaj = "bun venit";
2.2.3 Declararea variabilelor

Pentru declararea variabilelor sunt necesare doua elemente: tipul variabilei si numele. Tipul este necesar
pentru a informa compilatorul cata memorie este necesara pentru acea variabila si numele este necesar
pentru a putea lucra cu acea zona de memorie.
In C++ este necesara sa declararea variabilelor inainte de a fi folosite. Declararea unei variabile
informeaza compilatorul sa rezerve un spatiu de memorie din zona de date si sa-i asocieze un nume.
Variabilele pot fi gandite precum scaunele dintr-o sala de spectacol. Atunci cand cumparam un set de
bilete rezervam un numar de locuri din acea sala. Prin aceasta actiune ne declaram intentia de a participa
la acel spectacol.
11
Pentru numele variabilelor este necesar sa respectam urmatoarele reguli si sugestii:

• Trebuie sa inceapa cu o litera sau caracterul (_)2, nu trebuie sa contina spatii trebuie sa fie unice.
• Trebuie sa nu fie un cuvant cheie pentru C++3. Este necesara consultarea documentatiei mediului
(IDE) folosit pentru a verifica daca nu au fost rezervate si alte cuvinte.
• Trebuie sa fie expresive pentru a putea intelege usor scopul lor.
• Trebuie respectata o conventie de stabilire a numelor in mod consecvent pentru o mai usoara
mentenanta a programului. Pe parcursul acestui curs numele variabilelor incepe cu litera mica.
• Fiecare variabila este util sa se foloseasca pentru un singur scop. Aceasta previne aparitia unor defecte.
• Declararea variabilelor trebuie sa fie cat mai apropiata de locul unde sunt folosite.
• Numele sunt case sensitive, aceasta inseamna ca totalCount si totalcount sunt procesate ca doua
variabile diferite.
In cazul in care primele doua reguli nu sunt respectate apar erori la compilare.
Important
Variabilele trebuie sa fie unice in contextul de executie al programului. Daca doua variabile cu acel nume
sunt declarate in acelasi context compilatorul genereaza mesaje de eroare.
Exemple de declarare:
int contor; // declararea unei singure variabile pe linie
double celsius, fahrenheit; // declararea a doua variabile pe linie
bool isFinished;
char terminator;
string nume;
2.2.4 Atribuirea valorilor

Atunci cand este declarata o variabila compilatorul aloca memoria necesara pentru acea variabila insa
valoarea acelei variabile este nedeterminata. Atribuirea permite setarea valorilor pentru variabile folosind
simbolul =.
Exemplu:
int contor;
contor = 0;
2 In limba engleza caracterul (_) se numeste underscore.

3 O lista a cuvintelor cheie standard C++ este prezentata la sfarsitul capitolului.
12
Important
Pentru a elimina potentialele erori se recomanda setarea unei valori in momentul declararii variabilelor.
Aceasta se numeste initializare.
Exemplu:
int contor = 0;
char start = 'A';
bool isFinished = false;
double temperaturaCelsius = 32.5;
string mesaj = "Buna ziua";
2.2.5 Citirea valorilor de la tastatura

Citirea valorilor se realizeaza cu cin care este complementarul lui cout.
Exemplu:
#include <iostream>
#include <string>
int main()
string nume;
cout << "Introduceti numele: \n";
cin >> nume; // variabila nume este initializata de la consola
string prenume;
cout << "Introduceti prenumele: \n";
cin >> prenume; // variabila prenume este initializata

// de la consola;
cout << "Numele complet este: " << nume << " ";
cout << prenume << "\n";
return 0;
In acest exemplu cand se executa instructiunea cin >> nume; programul se oprese si asteapta
introducerea literelor (caracterelor) numelui. Executia va continua dupa ce utilizatorul apasa tasta Enter.
2.2.6 Constante
Cunstantele sunt variabile a caror valoare nu se schimba pe parcursul rularii programului. Se intalnesc in
13
doua forme de constante: literale si simbolice.

O constanta este literala atunci cand este folosita direct valoarea ei. Exemplu:
int lungimea = 35; // In acest caz 35 este o constanta literala.
// valoarea ei nu se poate schimba.
Acest tip de constanta este folosita de regula la initializarea variabileor .
2.2.7 Declararea constantelor simbolice

Pentru declararea constantelor simbolice se foloseste cuvantul cheie const.
Exemplu de constanta declarata folosind cuvantul cheie const. Exemplu:

const double PI = 3.14;
Constantele trebuie initializate la declarare, omiterea acestui fapt genereaza erori de compilare.
Exemplu
const double FACTOR_CONVERSIE; // genereaza eroare de compilare
2.2.8 Constante de tip enumerare

C++ permite definirea unui tip de date care poate avea un set predefinit si restrans de valori. De exemplu
zilele saptamanii pot lua doar 7 valori, semaforul de circulatie are 3 culori etc. Pentru acest tip de date se
folosesc constantele enumerate.
Exemplu
enum CuloareSemafor {ROSU, GALBEN, VERDE};
Implicit compilatorul trateaza tipul enumerat ca un caz particular de intreg, initializand crescator fiecare
componenta, pornind de la valoarea 0.
Exemplu
#include <iostream>
enum CuloareSemafor { ROSU, GALBEN, VERDE };
int main()
cout << "ROSU= " << ROSU << "\n";
cout << "GALBEN= " << GALBEN << "\n";
cout << "VERDE= " << VERDE << "\n";
14
return 0;
La rularea acestui program obtinem urmatoarele mesaje in consola:

ROSU= 0
GALBEN= 1
VERDE= 2
Press any key to continue . . .
Daca dorim putem specifica valoarea numerica pentru fiecare element din set sau pentru o parte a setului.
In ultimul caz, compilatorul continua incrementarea cu 1 pornind de la ultima valoare specificata ca in
exemplul urmator.
#include <iostream>
enum CuloareSemafor { ROSU, GALBEN = 10, VERDE };
int main()
cout << "VERDE= " << VERDE << "\n";
return 0;
}
La rularea acestui program se obtine urmatorul mesaj:

VERDE= 11
Press any key to continue . . .
2.2.9 Sugestii pentru denumirea constantelor

Pentru a putea fi usor de identificat este recomandabila scrierea cu majuscule a numelor
constantelor. Celelalte recomandari de la variabile se aplica si aici.
15
2.3 Instructiuni, operatori si expresii introducere
2.3.1 Instructiuni
Instructiunile controleaza secventa de executie, evalueaza expresiile sau nu fac nimic (in cazul
instructiunii nule care contine doar carcterul ; Caracterul ; indica sfarsitul instructiunii.
Sa examinam putin urmatoarea instructiune:

a = b + c;
Aceasta poate fi citita in modul urmator: atribuie variabilei a valoarea sumei b + c.
2.3.2 Instructiuni compuse sau blocuri

Mai multe instructiuni pot fi grupate intr-un bloc. Acest bloc formeaza o Exemplu:
instructiune compusa. Un bloc de instructiuni incepe cu caracterul { si se {
termina cu caracterul }. La sfarsitul blocului nu se pune terminatorul ;. temp = x;
x = y;
y = temp;
2.3.3 Operatori si expresii

Operatorii sunt simboluri care determina compilatorul sa calculeze un rezultat. Operanzii sunt variabilele
asupra carora se exercita actiunea operatorilor. In C++ sunt mai multe categorii de operatori. In acest
capitol vom studia operatorul de atribuire, operatorii aritmetici si operatorii de comparare.
2.3.3.1 Operatorul =
Acest operator seteaza valoarea din partea dreapta variabilei care se afla in partea stanga a semnului egal.
2.3.3.2 Expresiile
In C++ o expresie este orice combinatie de operatori, constante, apeluri de functii care calculeaza o
valoare.
Exemplu:
4.5; // returneaza valoarea 4.5 Sa analizam ultima expresie, care este evaluata in ordinea
a = b + c; urmatoare:
d = a = b + c; 6. calculeaza suma b + c
7. atribuie rezulatul lui a
8. atribuie rezultatul lui a = b + c lui d
16
2.3.3.3 Operatorii aritmetici

In tabelul de mai jos sunt prezentati operatorii aritmetici
Operator Explicatie Exemplu

+ adunare result = 4 + 5; // result = 9
- scadere result = 20 – 15; // result = 5
* inmultire result = 8 * 4; // result = 32
/ impartire result = 36 / 9; // result = 4
% modulo (restul impartirii intregi) result = 10 % 4; // result = 2
Important
Rezultatul impartirii depinde de tipul operanzilor: daca ambii termeni sunt de tip intreg, compilatorul
efectueaza impartirea intreaga chiar daca in stanga egalului este o variabila de tip double. In cazul in care
cel putin unul din termenii impartirii este real atunci compilatorul efectueaza impartirea reala si rezultatul
este cel asteptat.
Exemplu
double impartireIntreaga = 3 / 4; // rezultatul evaluarii este 0
// deoarece ambii termeni sunt
// numere intregi.
double impartireReala = 3.0 / 4; // rezultatul evaluarii este 0.75
2.3.3.4 Incrementarea / decrementarea variabilelor

Incrementarea unei variabile presupune marirea valorii cu o unitate, decrementarea presupune micsorarea
valorii cu o unitate. Deoarece aceste operatii apar frecvent in practica au fost adaugati doi operatori
speciali ++ pentru incrementare respectiv -- pentru decrementare.
Exista doua tipuri de incrementare / decrementare: cu prefixare atunci cand operatorul apare inaintea
variabilei si cu postfixare atunci cand operatorul apare dupa variabila. In capitolul 4 vom discuta in
detaliu diferentele dintre acesti operatori.
Exemple:
int a = 0;
int b = 1;
++a; // operatorul cu prefixare ehivalent cu a = a + 1.
b++; // operatorul cu postfixare echivalent cu b = b + 1.
17
2.3.3.5 Operatorii de comparare

Acesti operatori compara doua numere pentru a determina relatia dintre ele si returneaza o valoare true
sau false.
Operator Exemplu Explicatii4

== x == y Se testeaza egalitatea valorilor lui x si y
!= x != y Se testeaza daca x si y au valori diferite
> x > y Se testeaza daca valoarea lui x este mai mare decat valoarea lui y
< x < y Se testeaza daca valoarea lui x este mai mica decat valoarea lui y
>= x >= y Se testeaza daca valoarea lui x este mai mare sau egala cu valoarea lui y
<= x <= y Se testeaza daca valoarea lui x este mai mica sau egala cu valoarea lui y
2.4 Elemente de control al executiei

Pentru obtinerea rezultatelor dorite este necesar controlul executiei programului. Daca analizam
activitatile personale zilnice vom observa ca anumite activitati le facem secvential, altele trebuiesc
repetate si de asemenea exista situatii in care evaluam mai multe alternative si o alegem pe cea optima.
In mod similar executia programelor se controleaza prin: secventa, decizii si bucle.
2.4.1 Secventele
In acest caz instructiunile programului se executa secvential in ordinea in care au transformare
fost scrise. date
Fig 2.1
2.4.2 Deciziile
Deciziile permit executarea conditionata a unor comenzi. Sunt similare cu intuneric?
intersectiile strazilor alegem una din alternative in functie de obiective. In Error: da nu
Reference source not found lumina este aprinsa doar daca este intuneric (conditia aprind lumina
intuneric? este evaluata ca true).
Fig 2.2
4 daca relatia dintre valorile variabilelor este indeplinita expresia este evaluata cu valoarea true.
18
2.4.2.1 Instructiunile if, else, else if

Prima forma este cea mai simpla decizie:
if(expresie)
// instructiuni executate doar daca expresie este evaluata ca true
Pe prima linie avem testarea conditiei cu instructiunea if(expresie). Aici este important de remarcat ca
am folosit o instructiune compusa. In acest mod se delimiteaza foarte clar instructiunile care se executa
atunci cand este indeplinita conditia de cele din ramura principala a programului. Codul din blocul if
trebuie indentat cu un tab la dreapta pentru a citirea si intelegerea logicii programului.
Exemplu:
1: if(ROSU5 == culoare)
2: {
3: cout << "stop\n";
4: }
Frecvent atunci cand se foloseste instructiunea if se uita scrierea celui de-al doilea egal al operatorului.
Atunci cand expresia se compara cu o constanta eroarea poate fi identificata la compilare daca se scrie
constanta in partea stanga ca in linia 1.
A doua forma de decizie foloseste ambele ramuri ale deciziei.

1: if(ROSU == culoare)
2: {
3: cout << "stop\n";
4: }
5: else
6: {
7: cout << "puteti trece\n"; // se executa daca avem alta culoare
8: }
Exista cazuri cand trebuie sa testam mai multe alternative. O solutie poate fi sa tratam in interiorul
blocului else variantele ramase.
if(ROSU == culoare)
5 In acest exemplu si urmatoarele se foloseste constanta enumerata CuloareSemafor definita in sectiunea 2.2.8.
19
cout << "stop\n";
else
if(VERDE == culoare)
cout << "puteti trece\n";
else
cout << "pregatire\n";
In cazul in care avem mai multe variante logica acestor conditii devine greu de urmarit si inteles. Din
aceste motive pot apare multe defecte in timpul mentenantei.
O solutie mai buna se poate obtine folosind a treia forma in care folosim si combinatia else if ca in
exemplul de mai jos.
if(ROSU == culoare)
cout << "stop\n";
else if(VERDE == culoare)
cout << "puteti trece\n";
else
Din punct de vedere logic implementarile sunt echivalente insa aceasta forma este mult mai clara si este
de preferat primeia.
20
De evitat:
Adaugarea terminatorului ; pe linia cu decizia Folosirea operatorului = in loc de ==
if(x = y)
if(conditie); {
//...
{
}
// aceste instructiuni se executa mereu!
Scrierea instructiunilor pe aceeasi linie cu decizia Evaluarea variabilelor ne initializare.

if( contor < MAX) contor++; int x;
if( 0 == x)
{
// …
2.4.2.2 Instructiunea switch

Atunci cand exista mai multe optiuni se poate folosi instructiunea switch daca evaluarea acelor optiuni
se poate face cu o expresie care returneaza o valoare de tip intreg, enum sau char. Folosirea se face ca in
exemplul de mai jos:
switch(culoare) // inceputul blocului switch, tipul variabilei care
{ // se evalueaza trebuie sa fie char, int sau enum.
case ROSU: // constante cu care se compara valoarea variabilei.
cout << "stop\n";
break; // transfera executia dupa blocul switch.
case VERDE:
cout << "puteti trece!\n";
break;
case GALBEN:
break;
default:
cout << "culoare invalida\n";
break;
Observam ca blocul incepe cu instructiunea switch care evalueaza expresia. In interiorul blocului avem
o succesiune de alternative reprezentate de cuvintele cheie case.
21
Valorile acestor alternative sunt constante. Dupa aceea pentru fiecare valoare avem una sau mai multe
instructiuni. In momentul cand am terminat de tratat acea alternativa se iese din bloc cu instructiunea
break.
Optional exista alternativa default care este aleasa daca nici una dintre celelalte nu a fost rezultatul
evaluarii expresiei.
Important
In absenta instructiunii break din alternativa curenta, se continua executarea secventei de instructiuni din
interiorul blocului switch pana la intalnirea primului break sau pana la sfarsitul blocului switch.
Acest aspect trebuie tratat cu atentie pentru ca exista cazuri cand acest comportament este necesar, dar si
cazuri in care s-a omis instructiunea break din greseala.
Exemplu de identificare a vocalelor si consoanelor (pentru simplitate am omis diacriticele).

#include <iostream>
int main()
cout << "introduceti un caracter\n";
char ch;
cin >> ch;
switch(ch)
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
cout << "caracterul este vocala\n"; // se executa pentru atunci cand ch
break; // are una din valorile specificate de
// case (a, e, i, o sau u)
default:
cout << "caracterul este consoana\n";

break;
22
return 0;
In exemplu vocalele sunt selectate fiecare in parte si se executa un cod comun pentru ele iar pentru
consoane se executa codul din sectiunea default.
2.4.3 Bucle
Permit executarea unei secvente de instructiuni atat timp cat este indeplinita o conditie. Conceptual exista
trei tipuri de bucle: while, do while si for.
2.4.3.1 Bucle while

Acest tip de bucla efectueaza testul inainte de executia secventei. Sintaxa pentru aceasta bucla este:
while(conditie)
{
// secventa de instructiuni
Un exemplu simplu de folosire este programul urmator care calculeaza factorialul unui numar.
1: #include <iostream>
2: using namespace std;
3:
4: int main()
5: {
6: cout << "Introduceti un numar intreg\n";
7:
8: int n;
9: cin >> n;
10:
11: int factorial = 1;
12: while(n > 1)
13: {
14: factorial = factorial * n;
15: n = n - 1;
16: }
17:
18: cout << "n! = " << factorial << "\n";
19: return 0;
23
20: }
In linia 6 se afiseaza mesajul pe ecran. Valoarea variabilei este citita de la tastatura in linia 9. In linia 11
valoarea factorialului este initializata cu 1. In linia 14 se calculeaza produsul intre valoarea anterioara si
n. In linia 15 valoarea lui n este decrementata. Procesul se continua pana cand n devine egal cu 1,
moment in care bucla se termina si se afiseaza rezultatul pe ecran.
2.4.3.2 Bucle do / while

Acesta este un tip de bucla in care testul se face dupa prima iteratie. Sintaxa pentru aceasta bucla este:
do
{
// secventa instructiuni
} while (conditie);
Urmatorul program calculeaza factorialul unui numar folosind bucla do while.

3:
4: int main()
5: {
7:
8: int n;
9: cin >> n;
10:
12: if (n > 0)
13: {
14: do
15: {
16: factorial = factorial * n;
17: n = n - 1;
18: }while(n > 1);
19: }
21: return 0;
22: }
24
Singura diferenta intre acest tip de bucla si precedentul este ca aici testul conditiei se face la final.
Secventa se executa prima data indiferent de valoarea conditiei.
2.4.3.3 Bucle for

Aceasta este o bucla cu incrementare. Sintaxa pentru aceasta bucla este:
for(initializare; conditie; incrementare / decrementare )
// secventa instructiuni.
Bucla for are 3 expresii separate cu (;):
• Expresia de initializare, uzual declara un contor folosit in blocul buclei si se executa o singura data.
• Evaluarea contitiei (a doua expresie) se executa inainte de fiecare iteratie.
• Expresia de incrementare / decrementare se executa dupa fiecare iteratie.
Urmatorul program calculeaza factorialul unui numar folosind bucla for.

3:
4: int main()
5: {
7:
8: int n;
9: cin >> n;
10:
12:
13: for(int i = n; i > 1; i = i - 1)
14: {
15: factorial = factorial * i;
16: }
17:
19: return 0;
25
20: }
Executia programului pana la linia 13 este similara cu exemplele anterioare. Executia buclei for se face in
modul urmator:
1. La prima iteratie se declara si se intializeaza variabila i cu valoarea lui n.
2. Se evalueaza conditia in cazul nostru i > 1.
3. In caz afirmativ porneste executia seventei din corpul buclei.
4. Altfel se merge la urmatoarea instructiune dupa bucla.
5. Se actualizeaza factorial cu valoarea factorial * i
6. Se decrementeaza i
7. Se repeta secventa de la punctul 2.
Dupa terminarea buclei se afiseaza rezultatul pe ecran.
Observatii
• Pentru intelegerea codului este recomandat ca expresiile de initilalizare, conditie si increment sa fie cat
mai simple.
• Oricare din aceste expresii poate lipsi. Daca a doua expresie, cea pentru conditie, compilatorul
considera conditia indeplinita.
2.4.4 Instructiunea break

Exista cazuri frecvente in care este necesara terminarea executiei buclei inainte de verificarea testului.
Pentru aceasta se foloseste instructiunea break. In exemplul urmator se testeaza daca numarul introdus
de la tastatura este numar prim.
3:
4: int main()
5: {
7: int n;
8: cin >> n;
9:
10: int i = 2;
11: for(;i < n; i = i + 1)
12: {
26
13: if(0 == n % i )
14: {
15: cout << "Numarul nu este prim\n";
16: break;
17: }
18: }
19:
20: if(i == n)
21: {
22: cout << "Numarul este prim\n";
23: }
24: return 0;
25: }
In acest exemplu am definit variabila contor in linia 10 in afara buclei deoarece este utilizata pentru
verificarea conditiei din linia 20. In cazul in care a fost gasit un divizor pentru numar, altul decat 1 sau n
numarul nu este prim si bucla se opreste in linia 16.
2.4.5 Instructiunea continue

Exista cazuri cand este necesara executia pentru iteratia urmatoare fara a executa toti pasii iteratiei
curente. Pentru aceasta se foloseste instructiunea continue. La intalnirea ei programul revine la inceputul
buclei sarind peste instructiunile care o urmeaza6.
In urmatorul exempul se afiseaza doar numerele impare in intervalul 0 – 10 pe ecran.
1: for(int i = 0; i < 10; i = i + 1)
2: {
3: if(0 == i % 2)
4: {
5: continue;
6: }
7: cout << i << "\n";
8: }
Atunci cand i este numar par conditia din linia 3 este indeplinita si executia se contiuna de la inceputul
buclei.
6 In cazul buclelor while si do / while trebuie acordata atentie deoarece uzual incrementarea / decrementarea
contorului se face la sfarsit.
27
2.5 Functii7
O functie reprezinta un nume asociat unui bloc de cod. Blocul de cod se executa prin apelul numelui.
Functiile permit descompunerea problemelor complexe intr-un set de probleme simple care pot fi usor de
implementat.
Functiile scrise corespunzator ascund detaliile de implementare. Sunt folosite pentru evitarea scrierii
repetate a aceluiasi cod intr-un program sau in programe diferite.
2.5.1 Definirea functiilor

Functiile au urmatoarea sintaxa de scriere:
1: tip Nume (tip parametru1, tip parametru2, ...)
2: {
3: // instructiuni
4: }
• tip de return– reprezinta tipul de date returnat dupa executia functiei. Functiile care nu returneaza
rezultate folosesc void ca tip de return.
• Nume – reprezinta numele functiei. Numele functiei nu poate contine spatii.
• Lista de parametri: (tip parametru1, tip parametru2, ...) – contine atati parametri
cati sunt necesari pentru executia secventei. Fiecare parametru este reprezentat de un tip si un nume
care poate fi gandit ca o variabila apartinand functiei. Parametrii permit transferul datelor catre functie.
• Corpul functiei – blocul de cod care contine instructiunile functiei (liniile 2 – 4).
Headerul functiilor
Prima linie din exemplul de mai sus se numeste headerul functiei.
1: tip Nume (parametru1, parametru2, ...)
2.5.2 Declararea functiilor

Declararea unei functii presupune scrierea prototipului.
Prototipul functiei furnizeaza informatii compilatorului pentru a determina daca functia este folosita
corect sau nu. El contine aceeasi informatie ca si headerul functiei plus terminatorul de instructiune (;)
tip Nume (parametru1, parametru2, ...);
Important:
• Ca si variabilele functiile trebuiesc declarate sau definite inainte de a fi folosite.
• Declararea functiilor presupune scrierea prototipului.
• Definirea functiilor presupune scrierea headerului si a corpului functiei.
7 In capitolul 8 vor fi prezentate functiile in detaliu.

28
• O functie poate fi declarata de mai multe ori insa trebuie sa fie definita o singura data.
• Nu se definesc functii in interiorul altor functii!
2.5.3 Apelul functiilor

Apelul functiilor reprezinta executarea codului functiei. Acesta se realizeaza in scriind numele functiei si
transmiterea valorilor parametrilor pentru care dorim executia functiei.
2.5.4 Exemple de functii

In linia 1 este declarata functia pentru a putea fi apelata din functia main in linia 4. Definitia functiei se
face dupa main.
In momentul cand executia ajunge pe linia 4 se copiaza valoarea 3 in variabila x si valoarea 5 in variabila
y apoi se executa functia Suma.
Dupa executia comenzii return (linia 11) rezultatul expresiei x + y este atribuit variabilei rezultat
din linia 4 si se incheie executia functiei Suma si programul continua cu linia urmatoare.
1: int Suma(int x, int y); // 1. declararea functiei
2: int main()
3: {
4: int rezultat = Suma(3, 5); // 3. definirea functiei
5: return 0;
6: }
7:
8: // 2. definirea functiei
9: int Suma(int x, int y)
10: {
11: return x + y;
12: }
In exemplul de mai jos este prezentata o functie care nu returneaza rezultate.

2: #include <string>
4:
5: void AfisareMesaj(string mesaj);
6:
7: int main()
29
8: {
9: AfisareMesaj("Hello");
10: return 0;
11: }
12:
13: void AfisareMesaj(string mesaj)
14: {
15: cout << mesaj << "\n";
16: }
De retinut:
pentru funcții avem 3 activități:
• declarare - asemanatoare cu o carte de vizita – ofera informatii pentru a putea fi apelate.
• definire - conține codul functiei
• apel – asemanator cu apelul telefonic cand folosim numarul din cartea de vizita pentru a discuta cu
persoana respectiva. Aici folosim numele functiei si parametrii pentru a executa codul functiei.
Recomandari
• Pentru usurinta depanarii si intelegerii programelor este recomandata scrierea unei singure instructiuni
pe linie.
• O functie trebuie sa faca un singur lucru (de exemplu sa citeasca variabile, sa calculeze, sa afiseze
rezultate etc).
• Numele functiei este recomandabil sa inceapa cu litera mare pentru a putea distinge functiile de
variabile.
• Numele functiei trebuie sa reprezinte prelucrarea realizata de functie.
• Este recomandabil ca o functie sa aiba cel mult 7 parametri.
2.5.5 Executia programelor

Atunci cand un program este lansat in executie sistemul de operare executa functia main. In practica
functionalitatea programului este distribuita mai multor functii. In acest mod codul este mai usor de
implementat, depanat si mentinut.
2.6 Elemente de depanarea programelor: breakpoint, watches

Depanarea programelor este o deprindere necesara unui programator. Programele reale rareori
30
functioneaza corect de la prima rulare. De multe ori defectele sunt introduse in perioada de mentenanta
sau de adaugare de noi functionalitati. Chiar daca programele ar functiona corect de la prima rulare tot
este necesara verificarea corectitudinii pentru a fi siguri de asta.
Programele pot contine erori de sintaxa si erori de logica. Erorile de sintaxa sunt detectate automat de
compilator care precizeaza fisierul, linia din fisier si tipul erorii. Acestea sunt cel mai usor de fixat si cele
mai sigure pentru ca nu putem compila programul fara rezolvarea lor.
Am putea crede ca dupa ce am reusit sa compilam cu succes programul, jobul nostru s-a terminat. In
realitate insa lucrurile nu stau deloc asa. Pentru a fi siguri ca programul functioneaza corect este necesara
executarea programului pas cu pas si verificarea comportamentului prin toate ramurile logice.
Multe din programele comerciale „crapa” atunci cand utilizatorul doreste sa faca o actiune normala
deoarece echipa de dezvolatare nu a reusit sa verifice executia prin acea ramura logica.
Pentru a verifica un program dezvoltatorul poate rula programul din mediul de dezvoltare in mod
debbugger. Debuggerul este o componenta a mediului de dezvoltare care ofera printre altele posibilitatea
executarii programului pas cu pas, setarea unor puncte de intrerupere (breakpoint) in care se opreste
executia, examinarea valorilor variabilelor (watches).
In acest paragraf vom invata urmatoarele elemente:

1. Setarea unui breakpoint
2. Executarea pas cu pas a programului

3. Setarea watch-urlilor pentru examinarea valorilor unei variabile.
2.6.1 Setarea breakpointurilor

Se realizeaza din meniul Debug/Toggle Breakpoint sau folosind tasta F9 atunci cand ne aflam cu cursorul
pe linia dorita. Setarea breakpointurilor se poate face inainte de lansarea in executie sau in timpul
executiei. Pentru a rula un program in mod debugger executia unui program, de regula, este necesar sa
avem cel putin un breakpoint in program.
2.6.2 Rularea in mod debugger a programelor

Pentru rularea programului avem urmatoarele modalitati: rularea pas cu pas, rularea pana la urmatorul
breakpoint sau rularea pana in dreptul cursorului.
2.6.2.1 Rularea programului pas cu pas.

Rularea pas cu pas trateaza in trei moduri diferite: step over, step into si step out.
• In modul step over, executia programului continua in fisierul curent la urmatoarea instructiune. Daca
se intalneste apelul unei functii debuggerul nu traseaza executia acestei functii ci se duce automat la
linia urmatoare apelului.
31
• In modul step into, cand se intalneste un apel de functie debuggerul traseaza executia acestei functii.
• In modul step out executia continua in fisierul de unde s-a apelat functia curenta.
Aceste moduri se pot alege din meniul Debug, butoanele dedicate din toolbarul Debug
2.6.2.2 Rularea programului pana la urmatorul breakpoint

Acesta metoda permite deplasarea rapida intre doua breakpointuri succesive folosind meniul
Debug/Continue, buttonul dedicat din toolbarul Debug sau tasta F8.
2.6.2.3 Rularea progamului pana in dreptul cursorului

Aceasta metoda permite executarea programului pana la locul unde se afla cursorul si oprirea executiei in
acest punct. Aceasta se poate realiza pozitionand cursorul in fisierul sursa in pozitia dorita, Meniu
Contextual/Run to cursor. Aceasta comanda poate porni debuggerul daca nu ruleaza deja.
Nota
Executia se va opri inainte de a ajunge la cursor in urmatoarele conditii:
1. Exista un breakpoint intre punctul curent de executie si pozitia cursorului,
2. Exista o zona de cod care solicita interactiunea cu utilizatorul intre punctul curent de executie si
pozitia cursorului.
2.6.3 Adaugarea watches

Adaugarea de watches pentru inspectarea valorilor variabilelor se face doar in timpul executiei
programului cu ajutorul debuggerului in modul urmator:
Selectam variabila de inspectat din fisierul sursa si din meniul contextual selectam Add Watch.
Nota
Pentru a putea examina valorile variabilelor este necesar ca programul sa fie compilat in configuratia
Debug. Acest tip de compilare adauga informatii aditionale in executabil care faciliteaza operatiile de
rulare in mod interactiv a executiei. Aceasta se realizeaza din meniul Build/Configuration Manager.
2.7 Exemplu practic

La sfarsitul acestui capitol vom implementa practic exemplul de calculare a factorialului cu bucla for si
vom trasa executia programului in debugger urmarind pasii de mai jos:
1. Codeblocks si cream un nou proiect asa cum am prezentat in capitolul precedent.
2. Adaugam un nou fisier cu numele factorial.cpp si scriem codul prezentat la bucla for.
3. Compilam pentru a verifica daca nu avem erori de sintaxa. Punem cursorul pe linia primei
32
instructiuni din functia main.

4. Adaugam un breakpoint folosind tasta F5.
5. Apoi executam programul cu ajutorul tastei F8.
6. In acest moment executia programului se opreste pe aceasta linie.
7. Adaugam watch pentru variabilele n, factorial si i.
8. In acest moment putem vedea informatiile despre cele trei variabile in fereastra watch a mediului.
9. Executam pas cu pas programul folosind tasta F7 si examinam valorile in fereastra watches.
2.8 Anexa: cuvintele cheie standard pentru C++

asm auto bool break case
catch char class const const_cast
continue default delete do double
dynamic_cast else enum explicit export
extern false float for friend
goto if inline int long
mutable namespace new operator private
protected public register reinterpret_cast return
short signed sizeof static static_cast
struct switch template this typedef
typeid typename union unsigned using
virtual void volatile wchar_t while
2.9 Sumar
• Comentariile ajuta programatorul sa inteleaga mai usor anumite aspecte ale programului. Ele nu
trebuie sa explice de ce s-a ales o anumita solutie.
• Variabilele sunt locatii de memorie in care se stocheaza date. Variabilele trebuiesc declarate inainte de
folosire. Declararea variabilelor are doua elemente tipul si numele.
• Atribuirea permite setarea unei valori intr-o variabila.
• Constantele sunt variabile ale caror valori nu se pot schimba in timpul executiei.
• Pentru transmiterea comenzilor se folosesc instructiunile.
• Folosind acoladele se pot grupa instructiunile intr-un bloc.
• Programele au trei categorii elemente de control a executiei: secventele de instructiuni, deciziile si
33
buclele.
• Pentru decizii se folosesc instructiunile if, if/else, if/else if/ else si switch.
• Sunt trei tipuri de bucle: while, do while si for.
• Functiile sunt folosite pentru evitarea scrierii repetate a aceluiasi cod.
• Pentru verificarea executiei programele se executa in mod debugger. Aceasta permite executia pas cu
pas, verificarea valorilor variabilelor.
34
2.10 Intrebari si exercitii

1. Care este diferenta dintre o variabila si o constanta?
2. Care este diferenta dintre tipurile de comentarii // si /* */?
3. Urmatorul program are erori. Care sunt acelea?
#include <iostream>
main ()
cout << Care sunt erorile?\n”;
return 0;
4. Corectati urmatorul program:

#include <iostream>
int main()
cout << Introduceti anul nasterii\n;
cin >> anNastere;
cout << Introduceti anul curent\n;
cin >> anCurent;
varsta = anCurent – anNastere;
return 0;
5. Rezultatul urmatoarei functii este incorect. Unde este greseala?
double Division(int a, int b)
return a /b;
}
35
6. Evaluati urmatoarele expresii:

a) 10 % 3
b) 8 * 9 + 2
c) 6 * 3 /4
d) 3/4 * 8
7. Rezultatul urmatoarei functii este incorect. Unde este greseala?

int Sum(int range)
int result;
for(int i =0; i < range; i = i + 1)
result = result + i;
return result;
8. Scrieti o functie care primeste numarul de ore si minute ca parametri si returneaza valoarea acelui
interval in minute. Exemplu: pentru 1 ora si 30 minute va returna 90 minute.
9. Scrieti o functie care primeste un interval in minute si tipareste pe ecran numarul de ore si minute.
Exemplu: pentru 90 minute va afisa o ora si 30 minute.
10. Scrieti un program care citeste varsta in ani si calculeaza numarul de luni corespunzatoare acestor ani.
2.11 Bibliografie:
• Sams Teach Yourself C++ in One Hour a Day, sixth edition, Sams, Jesse Liberty, Siddhartha Rao,
Bradley L. Jones; Cap 2 – 5, 7
• C++ Without Fear, second edition, Prentice Hall, Brian Overland; Cap 1, 2.
36

InfoAcademy-C++ Lectia01 PDF

Încărcat de

Informații document

Titlu original

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

InfoAcademy-C++ Lectia01 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

InfoAcademy Adonis Butufei

2.5.3 Apelul functiilor.........................................................................................................................29

1.1 Limbaje de programare: tipuri si caracteristici

1.1.1 Ce este un limbaj de programare?

1.1.2 Generatiile limbajelor de programare

cu particularitatile platformei hardware ci cu resursele oferite de sistemul de operare.

1.2 Ce este C++?

De ce a fost ales C ca limbaj de baza pentru C++?

• Pentru ca ruleaza pe orice platforma hardware.

1.2.1 Modelele de programare suportate de C++

1.2.2 Documentatia online pentru limbajul C++

1.3 Medii de dezvoltare integrata (IDE)

1.4 Scrierea primului program

1.4.1 Crearea proiectului

Fig 1.3 Fig 1.4

Dupa acest pas avem cel mai simplu proiect c++:

• Exista 5 generatii de limbaje de programare.

• Primele trei generatii au reprezentat evoulutia tehnologica pentru limbajele de programare de uz

• Programarea obiectuala ofera 3 mecanisme pentru cresterea productivitatii: incapsularea, mostenirea si

2 ELEMENTE DE BAZA C++

• Vom putea folosi variabilele si constantele.

• Vom intelege folosirea operatorilor si expresiilor.

• Vom intelege elementele de control ale executiei unui program.

• Vom intelege elementele de baza ale depanarii programelor.

2.1.1 Comentarii pe mai multe linii

pe mai multe linii si

este preluat din C. */

2.1.2 Cel specific C++ care este este pe o singura linie.

2.2 Variabile si constante - introducere

2.2.1 Ce sunt variabilele

2.2.2 Tipul variabilelor

Tip de date folosit Cuvant cheie Detalii

Numere reale double

Valoare de adevar bool poate fi true sau false

Siruri de caractere string Trebuie adaugat la inceputul fisierului daca nu exista:

sirul de caractere trebuie delimitat de " (ghilimele)

2.2.3 Declararea variabilelor

Pentru numele variabilelor este necesar sa respectam urmatoarele reguli si sugestii:

2.2.4 Atribuirea valorilor

2 In limba engleza caracterul (_) se numeste underscore.

2.2.5 Citirea valorilor de la tastatura

using namespace std;

cout << "Introduceti numele: \n";

cin >> nume; // variabila nume este initializata de la consola

cout << "Introduceti prenumele: \n";

cin >> prenume; // variabila prenume este initializata

cout << prenume << "\n";

doua forme de constante: literale si simbolice.

Acest tip de constanta este folosita de regula la initializarea variabileor .

2.2.7 Declararea constantelor simbolice

Exemplu de constanta declarata folosind cuvantul cheie const. Exemplu:

2.2.8 Constante de tip enumerare

using namespace std;

enum CuloareSemafor { ROSU, GALBEN, VERDE };

cout << "ROSU= " << ROSU << "\n";

cout << "GALBEN= " << GALBEN << "\n";

cout << "VERDE= " << VERDE << "\n";

La rularea acestui program obtinem urmatoarele mesaje in consola:

Press any key to continue . . .

using namespace std;

enum CuloareSemafor { ROSU, GALBEN = 10, VERDE };

cout << "VERDE= " << VERDE << "\n";

La rularea acestui program se obtine urmatorul mesaj: