Instalarea IDE-ului Code::Blocks pe calculatorul dumneavoastră este foarte ușoară.

Începeți prin a
deschide situl Code::Blocks, așa cum vedeți mai jos:

Apoi, alegeți opțiunea Downloads => Download the binary release

și, în funcție de sistemul dvs. de operare, alegeți să descărcați una din versiunile de mai jos. De exemplu,
dacă utilizați sistemul de operare Windows, versiunea cea mai potrivită este, probabil, cea de-a patra:
codeblocks-(nr.ver.)mingw-setup.exe, unde, în loc de (nr.ver.) scrieți numărul versiunii curente (în cazul de
față 17.12), sau al unei versiuni mai vechi. Dacă lucrați pe un Linux Debian (deci Linux Mint, Ubuntu
ș.a.m.d.), descărcați versiunea stabilă corespunzătoare numărului de biți ai sistemului dvs. Permiteți fișierului
descărcat să aducă modificări pe calculatorul dvs., apoi, de fiecare dată, alegeți opțiunea implicită (sau dați
Next), respectiv acceptați condițiile de licență, setați folderul în care să fie instalat programul (îl puteți lăsa
pe cel implicit) – dați Install, iar programul își va face treaba și va instala Code::Blocks-ul pe calculatorul
dvs. În final, acceptați (sau nu) ca programul să fie lansat și ieșiți din instalator – dați Finish.

Indiferent dacă ați lansat direct Code::Blocks-ul sau după ce ați finalizat instalarea, el va trebui să detecteze
(cel puțin) un compilator, și anume GNU GCC Compiler, pe care vă sfătuiesc să-l și selectați și declarați
implicit, apăsând pe butonul Set as default, în caz contrar fiind nevoit să-l selectați de fiecare dată când
rulați IDE-ul.

Apoi, în fereastra care se deschide alegeți Create a new project. Dintre toate tipurile de proiecte listate,
alegeți Console Application și dați Go. Vă apare o nouă casetă, în care e bine să bifați opțiunea Skip the
page next time.
Alegeți limbajul dorit – implicit acesta e C++ și e bine să păstrați această opțiune -, apoi setați un nume
proiectului dumneavoastră, precum și un folder unde acesta va fi creat. Eu am ales opțiunea Primul proiect,
pentru numele proiectului, și am creat un folder dedicat – ProgrameCPP – pentru toate programele și
proiectele pe care le voi crea de-acum încolo. Se deschide o fereastră, ale cărei opțiuni e bine să nu le
schimbați, și care conține și un buton Finish – apăsați acest buton.

Se deschide fereastra
de mai jos, în care se

disting mai multe panouri. În panoul din stânga, numit Management, se poate vedea o structură
arborescentă: Workspace (Spațiul de lucru) ↳ Primul proiect (Numele proiectului) ↳ Sources (Fișierele
sursă).
Dați dublu click pe Sources, care devin astfel vizibile, apoi alegeți singura sursă disponibilă, și anume
main.cpp. Ca urmare, în panoul principal apare listingul primului nostru program, creat de IDE.

Pentru a testa, depana și rula acest program, în partea superioară a ecranului avem câteva butoane, și
anume: - de la stânga la dreapta, Build, Run, Build and Run, Rebuild și Abort.
Pentru a verifica și rula acest program, veți apăsa succesiv pe butoanele Build și Run, sau doar pe Build and
Run. Se va deschide o nouă fereastră, în care veți putea vedea rezultatul rulării programului.
 Dacă ați obținut această fereastră, înseamnă că ați instalat corect Code::Blocks-ul și ați și creat și
rulat un prim program.
Atenție, alte IDE-uri și compilatoare rulează foarte repede programul și închid imediat fereastra în
care acesta a rulat, astfel încât utilizatorului îi este dificil să urmărească rezultatul execuției programului. Din
acest motiv, atunci când programul este destinat unui astfel de compilator, programatorii adaugă încă o linie
de cod, prin care forțează fereastra în care rulează programul să rămână deschisă până când utilizatorul apasă
o tastă. În cazul Code:Blocks-ului, acest lucru nu este necesar, dar închiderea ferestrei prin apăsarea
butonului corespunzător (și nu prin apăsarea oricărei taste 1) va produce o eroare.
Eu nu lucrez, în general, pe un sistem Windows, și, din acest motiv, ceea ce veți vedea pe ecranul
vostru ar putea fi ușor diferit de ceea ce apare pe ecranul meu. De asemenea, instalarea Code::Blocks-ului pe
un calculator non-Windows ar putea prezenta anumite particularități, pe care le vom discuta, dacă va fi cazul,
punctual. De exemplu, în cazul meu, pe un sistem Linux Mint cu interfață Gnome, a fost necesar să setez
manual fereastra de ieșire (cea în care rulează programele). Oricum, aceste aspecte sunt cu totul neimportante
în învățarea limbajului C++.
Analizăm liniile programului de mai sus una câte una. Trebuie precizat că numerele din fața liniilor
nu fac parte din program, ele fiind utilizate doar pentru a-l face mai ușor de înțeles. Atunci când scriem un
program C++, IDE-ul Code::Blocks le generează automat.

Linia 1: #include <iostream>

O linie care începe cu caracterul # (hash) este o directivă preprocesor. Directivele preprocesor au diferite
roluri speciale, asupra cărora vom reveni. În cazul nostru, se cere preprocesorului să includă în programul
nostru fișierul-antet iostream – al cărui nume vine de la InOutSTREAM (flux de intrare-ieșire), în care
sunt definite obiectele cin, respectiv cout, cu ajutorul cărora vom realiza intrările și ieșirile standard (de la
tastatură, respectiv către ecran).
N-ați înțeles nimic până cum? Nu vă faceți probleme, începeți, pur și simplu, orice program C++ cu această
linie.

Liniile 2 și 4 sunt linii goale. Ele nu au decât un rol estetic, contribuind la lizibilitatea programului.

Linia 3: using namespace std;

1 În alte situații, doar a tastei ENTER.

La început, limbajul C++ era mai suplu, dar oferea programatorilor un set mult mai redus de instrumente,
funcții și obiecte pe care aceștia să le poată utiliza în programele lor pentru a-și ușura munca. Cu timpul,
însă, programatorii de C++ au creat un mare număr astfel de instrumente, ale căror nume au intrat, inevitabil,
în coliziune și, din acest motiv, a fost nevoie să fie grupate în biblioteci (librării) sau spații de nume distincte.
Cele mai utile instrumente au rămas, totuși, cele pe care C++ le-a avut de la bun început, grupate în
biblioteca standard std. Ideea e, așadar, următoarea: dacă, într-un singur program folosesc obiecte și
instrumente din mai multe astfel de biblioteci, atunci e absolut necesar să arăt din ce bibliotecă face parte
fiecare dintre ele. Dacă, însă, toate obiectele se regăsesc în aceeași bibliotecă, atunci e necesar doar să
precizez care e aceea, ceea ce am și făcut în linia 3 a programului. Rețineți: pentru o bună bucată de vreme
de-acum încolo, veți crea doar aplicații consolă și veți utiliza doar instrumente din biblioteca STandarD,
așa că nu va trebui să vă bateți capul dacă să scrieți sau nu această linie, scrieți-o, pur și simplu, imediat după
linia/liniile care încep cu #.

Linia 5: int main()

Un program C++ e o colecție de funcții care se apelează reciproc. Sigur, dacă e vorba de un program ultra-
simplu, nu e nevoie de mai multe funcții, nu e nevoie de mai multe funcții, ci doar de una, aceasta fiind și
situația prezentă.
În principiu, o funcție e o asociere între două mulțimi numite domeniu de definiție, respectiv domeniu de
valori sau codomeniu, astfel încât oricărui element din domeniul de definiție să-i corespundă, în mod unic,
un element oarecare din codomeniu. De exemplu, la matematică putem defini o funcție f: N→N, f(x) =
2x+1, cu ajutorul căreia asociem fiecărui număr natural un număr tot natural. Sau, putem defini o funcție g:
NxN→N, g(x,y) = x+y, care asociază oricărei perechi de numere naturale un număr tot natural, și anume
suma lor. Prima este o funcție de o variabilă, cea de-a doua de două variabile. Pentru a defini corect o funcție
trebuie, așadar, să definim trei elemente: mulțimea de definiție, codomeniul și formula/metoda prin care
putem obține, pentru orice element din domeniul de definiție, elementul corespunzător din codomeniu.
Spuneam că orice program C++ este o colecție de funcții, una din ele, cea care este și punctul de intrare în
program, având antetul predefinit. Antetul cuprinde (de la stânga la dreapta): tipul rezultatului returnat (în
cazul nostru int, adică întreg), numele funcției (main – nume predefinit), și lista parametrilor și a tipurilor
lor, între paranteze rotunde (în cazul nostru, o listă vidă – nu există niciun parametru). De remarcat că
declararea acestei liste este obligatorie, chiar și în cazul în care este vidă.

Liniile 6 și 9: { și }
Marchează începutul și sfârșitul unui bloc de cod, în acest caz blocul prin care este definit conținutul funcției
main().

Linia 7: cout << "Hello world!" << endl;

Cuvântul cout (Console OUTput) desemnează dispozitivul standard de ieșre, adică ecranul (tot așa,
cin reprezintă dispozitivul standard de intrare, adică tastatura). Semnul << este un operator de inserție.
Adică: ceea ce urmează după el este trimis ecranului spre afișare. "Hello world!" este un șir de
caractere (string) care se afișează identic pe ecran. Dar, trebuie inclus între ghilimele. Dacă, în loc de
"Hello world!" scriem Hello world!, compilatorul ne va semnala eroare. În fine, endl (de la
END of Line) este un modificator de format, al cărui efect este acela de a poziționa cursorul pe următorul
rând.
Linia 7 este o instrucțiune, și toate instrucțiunile se termină cu semnul punct și virgulă (;).
Observație: Limbajul C++ este case-sensitive, ceea ce înseamnă că face deosebire între literele mici și cele
mari. Dacă, în loc de:
cout << "Hello world!" << endl;
scriem:
Cout << "Hello world!" << endl;
compilatorul va semnala o eroare de sintaxă. Dacă, însă, vom scrie:
 cout << "HELLO world!" << endl;
compilatorul nu va semnala nicio greșeală, dar pe ecran va fi afișat textul HELLO world! în loc de
Hello world!

Linia 8: return 0;
Fiecare funcție returnează ceva, în acest caz un număr întreg (să ne amintim că funcția main() este de tip
întreg), și anume 0. Fiecare funcție returnează un rezultat de tipul precizat funcției care a apelat-o, dar funcția
main() este o excepție, ea nefiind apelată de nicio altă funcție. În aceste condiții, rezultatul funcției
main() este preluat de sistemul de operare și interpretat ca un cod de eroare. Codul de eroare 0 indică
faptul că execuția funcției main() a decurs normal, orice altă valoare indicând o problemă. Codul de eroare
al funcției main() este generat automat, astfel că instrucțiunea return 0; este, în acest caz, și doar în
acesta, superfluă. Totuși, în cazul oricărei alte funcții, instrucțiunea return este obligatorie și, prin urmare,
pentru uniformitate, e bine să o scriem și în cazul lui main().

Să studiem acum următorul program:

1 #include <iostream>
2
3 int main()
4 {
5 std :: cout << "Hello world!" << std :: endl;
6 return 0;
7 }

Față de programul precedent, remarcăm dispariția liniei 3: using namespace std; Remarcăm, de
asemenea, că linia 7 din vechiul program, 5 în noul program, a fost modificată în std :: cout <<
"Hello world!" << std :: endl; ( din cout << "Hello world!" << endl;)
Adică: pentru fiecare din obiectele cout și endl a devenit necesară precizarea spațiului de nume
din care face parte; am făcut acest lucru prefixându-le cu numele spațiului respectiv, urmat de operatorul de
rezoluție ::, care constă din două semne două-puncte, scrise unul după altul, fără pauză.
Pentru a înțelege mai bine cum funcționează cout și endl, rulați următorul program:
1 #include <iostream>
2 using namespace std;
3
4 int main()
5 {
6 cout << "Hello world!" << endl << "E primul meu program"
<< "si sunt foarte fericit" << endl;
7 return 0;
8 }

Observație: Evitați diacriticele într-un program C++. Chiar și în stringuri!

Comentariile sunt texte ignorate de compilator, dar folosite de programatori pentru a asigura o mai
mare lizibilitate programelor și pentru a le documenta. În C++ se folosesc două tipuri de comentarii:
➢ comentarii uni-linie, introduse de semnul // (două linii slash consecutive) – tot ce urmează după
acest semn, pe o linie, este ignorat de compilator;
➢ comentarii multi-linie, care încep cu caracterele /* la începutul unei linii, și se încheie cu */, la
sfârșitul altei linii (sau pe aceeași linie).
1 /*Acest program a fost scris de
2 marele programator
3 IO INSUMI */
4
5 #include <iostream>
6 using namespace std; //un scurt comentariu
7
8 int main()
9 {
10 cout << "Flori si aplauze!" << endl;
11 return 0;
12 }

Observație: Indentările au și ele rostul lor, deocamdată doar estetic. Rețineți, de asemenea, că:
➢ putem scrie mai multe instrucțiuni pe o singură linie – putem scrie oricâte instrucțiuni pe o singură
linie;
➢ putem scrie o instrucțiune pe mai multe rânduri – regula fiind: unde e legal să apară un spațiu, e
legal să apară oricâte spații, taburi și chiar treceri pe rândul următor.

Să analizăm acum următorul program:

1 #include <iostream>
2 using namespace std;
3
4 int main()
5 {
6 int var1, var2, suma;
7 var1=2;
8 var2=5;
9 suma=var1+var2;
10 cout << var1 << '+' << var2 << '=' << suma;
11 return 0;
12 }

Mai jos se poate vedea și ieșirea/rezultatul acestui program (reamintesc, sub Windows, aspectul
ieșirii poate fi ușor diferit).

Vom analiza acest program linie cu linie, omițând, însă, liniile a căror semnificație e clară.

Linia 6: int var1, var2, suma;

O variabilă este o zonă de memorie, referită printr-un anumit nume. În C++, compilatorul calculează și
prealocă spațiul necesar fiecărei variabile înainte de execuția programului, și, din acest motiv, pentru a fi
putea fi utilizată, orice variabilă trebuie declarată, ceea ce presupune atât precizarea numelui, cât și a tipului,
deoarece diferitele tipuri de date (întreg, real etc.) necesită un spațiu și o codificare diferite.
Sintaxa generală a unei declarații de variabilă este:
tipul_variabilei numele_variabilei;
De exemplu, pentru a declara o variabilă var de tip întreg (int), folosim următoarea declarație:
int var;
Putem declara mai multe variabile de același tip cu ajutorul unei singure declarații, ca în exemplul de mai
jos:
int a, b, c;
Declararea unei variabile impune, așadar compilatorului, să aloce spațiul de memorie corespunzător tipului
acelei variabile, dar în acel spațiu nu se regăsește, momentan, nicio informație (sau, oricum, nu informația pe
care o dorim noi). Din acest motiv, variabilele trebuie inițializate, în alte cuvinte trebuie să li se atribuie o
valoare.

Linia 7: var1=2;
Linia 8: var2=5;
Linia 9: suma=var1+var2;
Toate aceste linii realizează același lucru, și anume, inițializarea unor variabile. Astfel, linia 7 realizează
inițializarea variabilei var1 cu valoarea 2, iar linia 8 inițializarea variabilei var2 cu valoarea 5.
Inițializarea unei variabile se face, așadar, cu ajutorul unei instrucțiuni specifice, numită instrucțiune de
atribuire, a cărei sintaxă poate fi:
nume_variabila=expresie;
unde nume_variabila este numele variabilei, iar expresie reprezintă o combinație legală de constante,
variabile deja inițializate, valori returnate de funcții și, respectiv operatori, combinație care se evaluează la o
valoare de tipul precizat al variabilei.
De exemplu, linia 8 realizează inițializarea variabilei suma cu evaluarea expresiei var1+var2. Cum var1
este definită și inițializată cu 2, iar var2 cu 5, rezultatul evaluării expresiei var1+var2 este 2+5=7, și,
prin urmare variabila suma se inițializează cu valoarea 7.

Linia 10: cout << var1 << '+' << var2 << '=' << suma;
Ne amintim cum funcționează obiectul cout, el afișează pe dispozitivul standard de ieșire (adică pe ecran,
dacă nu e setat alt dispozitiv) conținutul fluxului respectiv de ieșire, oricât de lung ar fi. În cazul nostru, acest
șir este format din:
var1- acesta este numele unei variabile: se înlocuiește numele ei cu conținutul, adică se afișează 2;
'+' - acesta este un caracter, iar, pentru a se deosebi de alte obiecte, caracterele (care pot fi litere,
cifre, alte semne etc.) se scriu între apostrofuri. Prin urmare, se realizează afișarea caracterului +.
var2 – se afișează conținutul variabilei var2, adică 5;
'=' - se afișează semnul =;
suma – se afișează conținutul variabilei suma, adică 7;
Ce s-ar fi întâmplat dacă, în loc de apostrofuri am fi folosit ghilimele, adică dacă linia 8 ar fi arătat astfel:
cout << var1 << "+" << var2 << "=" << suma;
Din punct de vedere al rezultatului produs de program, absolut nimic, ieșirea ar fi fost identică. Totuși, între
apostrofuri scriem caracterele, iar între ghilimele, șirurile de caractere, care pot fi formate dintr-un singur
caracter, din mai multe caractere, sau chiar din niciun caracter. Prin urmare, 'a' desemnează caracterul a,
iar "a" șirul de caractere compus dintr-un singur caracter, și anume a. Este corect să scriem "" (șirul de
caractere vid), care este diferit de " " (șirul de caractere care conține un singur caracter, și anume spațiul,
care e diferit de ' ' (caracterul spațiu), dar nu e corect să scriem '' (între apostrofuri trebuie să avem un
caracter și numai unul), și nici 'abc' (sunt trei caractere), ci numai "abc".
 Observație: Numai variabilele declarate pot fi inițializate, dar putem face acest lucru într-o singură
instrucțiune. De exemplu, în locul instrucțiunilor 6, 7, 8 și 9, putem scrie una singură, și anume:
int var1=2, var2=5, suma=var1+var2;
Am putea „traduce” această instrucțiune în „limbaj uman” astfel: declară variabilele întregi var1,
inițializată cu 2, var2, inițializată cu 5, și suma, inițializată cu rezultatul adunării variabilelor deja
inițializate var1 și var2.
Ce se întâmplă dacă, în locul instrucțiunii anterioare scriem:
int var1=2; var2=5; suma=var1+var2;
Ei bine, într-o astfel de situație, compilarea va eșua, deoarece compilatorul va interpreta linia de mai sus ca
fiind formată din trei instrucțiuni, și anume:
int var1=2;
var2=5;
suma=var1+var2;
deoarece semnul punct și virgulă (;) marchează sfârșitul unei instrucțiuni.
Din cele trei instrucțiuni, doar prima este scrisă corect, și ea cere compilatorului să declare variabila var1
de tip întreg și s-o inițializeze cu 2, în schimb a doua instrucțiune cere compilatorului să inițializeze variabila
var2 cu 5, în condițiile în care var2 nu este declarată!

Să presupunem că avem, așadar, instrucțiunea:

int var1=2, var2=5, suma=var1+var2;
al cărei efect l-am discutat mai sus. Ea poate fi înlocuită cu instrucțiunea:
int var2=5, var1=2, suma=var1+var2;
efectul fiind același. Dacă, însă, încercăm s-o înlocuim cu următoarea instrucțiune:
int suma=var1+var2, var1=2, var2=5;
vedem că programul nu va mai compila (de ce?).

Ce se întâmplă dacă „uităm” că am declarat o variabilă și o redeclarăm? Compilatorul de C++ nu ne

va permite să facem așa ceva (în alte limbaje, acest lucru este posibil și, de asemenea, și redeclararea tipului).

Putem, însă, să reinițializăm o variabilă? A inițializa, înseamnă, de fapt, a da o valoare unei variabile,
în condițiile în care se presupune că nu are niciuna. Deci, nu putem reinițializa o variabilă, pentru că, odată
ce a fost inițializată, ea are o valoare. Putem, însă, să-i modificăm valoarea, însuși numele ei spune asta.
Verificați ce face următorul program:

1 #include <iostream>
2 using namespace std;
3
4 int main()
5 {
6 int var=1;
7 cout<<"Valoarea curenta a variabilei este "<<var<<endl;
8 var=2;
9 cout<<"iar acum este "<<var;
10 return 0;
11 }

Ce fel de nume putem da unei variabile? În principiu, orice nume, cu condiția să conțină doar litere
(mari și mici), cifre și semnul liniuță de subliniere (_), și să nu înceapă cu o cifră. Orice șir de caractere
(nevid) care se supune acestor reguli se numește identificator.
Prin urmare, sunt identificatori:
 variabila
numar_de_rotatii_pe_minut
numarDeRotatiiPeMinut
agentul007
_ABC
_1
și nu sunt identificatori:
1abc (începe cu o cifră)
doua cuvinte (caracter nepermis)
www.edu.ro (caracter nepermis)
ionel@yahoo.com (caracter nepermis)

În instrucțiunea:
int var=1;
semnul egal (=) este un operator, și anume operatorul de atribuire. Un operator este un obiect care
acționează asupra unei variabile sau constante (operatorii unari), sau asupra a două variabile/constante
(operatorii binari), sau chiar asupra a trei variabile/constante (cei ternari), returnând un anumit rezultat.
Până acum, în afară de operatorul de atribuire, am mai întâlnit operatorul de adunare +.
Operatorul de atribuire evaluează operandul din dreapta (care este o variabilă sau o expresie) și returnează
acel rezultat, modificând, în același timp, operandul din stânga, atribuindu-i valoarea rezultată din evaluarea
operandului din dreapta.
Dacă a și b sunt două variabile întregi, e corect să scriem:
a=1;
nu și:
1=a;
deoarece 1 este o constantă și nu putem să-i atribuim nicio valoare. Putem, însă, să scriem:
b=a=1;
deși, poate mai clar ar fi:
b=(a=1);
(variabilei a i se atribuie valoarea 1, valoare care este și returnată de operatorul de atribuire = și care, în
continuare, este atribuită, variabilei b).
Desigur, se pot scrie și instrucțiuni mai „păsărești”, precum:
a=2+(b=1);
dar acest lucru nu este chiar uzual și nici recomandat.

Să studiem acum următorul program:

1 #include <iostream>
2 using namespace std;
3
4 int main()
5 {
6 int a, b, sum, dif, prod, cat, rest;
7 double cat_real;
8 cout << "Scrieti un numar intreg a="; cin >> a;
9 cout << "Scrieti un numar intreg b="; cin >> b;
10 sum = a + b;
11 cout << "suma este " << sum << endl;
12 dif = a-b;
13 cout << "diferenta este " << dif << endl;
14 prod = a * b;
15 cout << "produsul este " << prod << endl;
16 cat = a/b;
17 cout << "catul este " << cat << endl;
18 rest = a % b;
19 cout << "restul este " << rest << endl;
20 cat_real = a/b;
21 cout << "catul real este " << cat_real << endl;
22 cat_real = (double)a/b;
23 cout << "de fapt, catul real este " << cat_real;
24
25 return 0;
26 }

După cum observăm, în linia 6 sunt declarate variabilele de tip întreg a, b, sum, dif, prod, cat și
rest, iar în linia 7, variabila cat_real de tip double.
Spuneam ceva mai sus că e de preferat ca variabilele să aibă nume cât mai sugestive, ceea ce impune
ca numele lor să fie format din mai multe cuvinte. Însă, cum folosirea unor alte semne decât litere, cifre și
liniuță de subliniere nu este permisă, sunt folosite două convenții de scriere a numelor lungi de identificatori:
➢ folosind semnul liniuță de subliniere sau underscore, ca în exemplul: cat_real;
➢ capitalizând (scriind cu literă mare prima literă) fiecare cuvânt, începând cu al doilea, ca în
exemplul: catReal.
Majoritatea programatorilor folosesc a doua convenție. Voi puteți folosi oricare dintre cele două convenții,
dar fiți consecvenți, nu folosiți, într-un același program, ambele convenții.
Tipul double este un tip real. Există două tipuri reale principale: float și double, numerele
double fiind reprezentate pe un număr mai mare de octeți, deci având o precizie mai mare.
În C++, numerele reale sunt, de fapt, fracții zecimale finite, cu un anumit număr de zecimale.
Fracțiile zecimale infinite nu pot fi reprezentate în C++, indiferent dacă sunt sau nu periodice. Prin urmare,
de la o anumită zecimală încolo, C++ va opera o trunchiere sau o aproximare ce ar putea afecta rezultatul.
Dacă rulați programul, constatați că, la un moment dat, vă invită să introduceți o valoare întreagă.

În acel moment, programul se oprește și așteaptă să introduceți un număr întreg. Calculatorul va ști că sunteți
gata doar atunci când veți apăsa tasta ENTER, iar atunci va lua în considerare doar numărul maxim de
caractere care pot forma un număr întreg (deci, dacă veți scrie 345ent890s34, va lua în considerare doar
354 sau va semnala o eroare).
Dacă v-ați gândit că această citire a ceea ce introduceți dvs., calculatorul o face cu ajutorul obiectului cin,
v-ați gândit foarte bine. Ca și cout, cin folosește un operator specific, numit operator de
extragere, pentru a prelua informațiile de pe ecran și a le atribui unei variabile. Deosebirea constă în
faptul că, pentru a prelua conținutul a mai multe variabile, e nevoie să scriem mai multe instrucțiuni cin.
Să presupunem că am introdus numerele 19 și 5. Iată ce va afișa, în aceste condiții, programul:
 Ați observat, desigur, utilizarea semnelor +, -, *, / și %. Toate aceste semne reprezintă operatori
aritmetici, care, după cum vă reamintiți, acționează asupra unor variabile, returnând un rezultat. Operatorii
aritmetici din C++ se utilizează în mod foarte asemănător cu cei din matematică. Astfel:
+ este operatorul de adunare, el returnează un rezultat de același tip cu cel al operanzilor (variabilele
asupra cărora acționează), dacă aceia sunt de același tip (întreg-întreg sau real-real), respectiv, de tip
real, dacă un operand este real, iar celălalt întreg.
- este operatorul de scădere, și acționează asemănător cu cel de adunare.
* este operatorul de înmulțire, și acționează asemănător cu cele de mai înainte.
/ este operatorul de împărțire, și, spre deosebire de operatorii aritmetici anteriori, aplicat unor
operanzi întregi, produce un rezultat întreg, dar care, din punct de vedere matematic, nu este corect,
pentru că, de regulă, două numere întregi nu se împart „exact”. Din acest motiv, rezultatul unei
împărțiri a/b este 3 atunci când a și b au valorile întregi 19, respectiv 5. Nu rezolvăm nimic dacă
împărțim două numere întregi, iar rezultatul îl atribuim unei variabile reale, și, din acest motiv, linia
20 nu va calcula corect, din punct de vedere matematic, câtul împărțirii lui 19 la 5. Abia după ce
convertim temporar unul din operanzi la tipul real, obținem rezultatul corect, ceea ce am și făcut în
linia 22. Acolo (double)a semnifică: „tratează-l pe a aici, și numai aici, ca și când ar fi
double”. În această situație, a fiind considerat double, câtul este calculat și atribuit corect
variabilei cat_real. Este posibilă și sintaxa double(a) sau chiar (double)(a). Dacă scriem,
însă, (double)(a/b) în loc de (double) (a)/b, vom obține un rezultat eronat (de ce?).
% este un operator care ne returnează restul unei împărțiri întregi. Operanzii săi trebuie să fie, cu
necesitate, întregi, iar încercarea de a folosi operanzi reali conduce la o eroare de compilare.

Operatorii aritmetici din C++ au aceleași priorități ca operatorii matematici similari, și asociază la
fel. Pentru a modifica asocierea implicită folosim, ca și în matematică, parantezele. Atenție: în C++ nu se
folosesc, în acest scop, decât parantezele rotunde, și pentru că nu putem folosi fracții, ar putea fi necesar să
a+b
folosim mai multe paranteze. De exemplu, pentru a scrie expresia matematică va fi nevoie să scriem
c
b
în C++ (a+b)/c deoarece a+b/c va fi interpretat ca a+ .
c

Exerciții:
1) Scrieți un program care realizează conversia unei sume exprimate în lei, în euro, la cursul zilei
curente.
 2) Scrieți un program care calculează prețul unui produs după deducerea TVA-ului, cunoscând prețul cu
TVA și procentul de TVA.
3) Scrieți un program care, citind lungimea și lățimea unui dreptunghi, îi calculează aria și perimetrul.
4) Scrieți un program care transformă gradele Celsius în Fahrenheit, conform formulei: T(°F) = T(°C) ×
9/5 + 32
5) Scrieți un program care transformă un anumit număr de secunde în ore, minute și secunde.

Până acum am învățat să scriem programe care pot face anumite calcule aritmetice cu anumite valori
întregi sau reale. Este, desigur, important, dar este încă foarte puțin pentru posibilitățile aproape nelimitate
ale limbajului C++ și ale calculatoarelor moderne. Pentru moment, ne mai jucăm puțin cu câteva progrămele.
Cum ar fi cel care urmează:

1 #include <iostream>
2 using namespace std;

3 int main()
4 {
5 int a, b;
6 cout << "a = "; cin >> a;
7 cout << "b = "; cin >> b;
8 a = a + b;
9 b = a - b;
10 a = a - b;
11 cout << endl << "a este acum " << a << ", iar b este " << b <<
endl;
12 return 0;
13 }

Iată și ieșirea pentru un set oarecare de valori:

Dacă valorile introduse sunt a=18 și b= 7, după efectuarea liniei 8, a devine 18+7=25, noua
valoare fiind suprascrisă peste cea veche – din acest moment, programul „uită” că a a fost cândva 18 și
reține numai noua valoare – 25. Apoi, linia 9 modifică valoarea conținută în b, din 7 în 25-7=18, iar linia
10, pe a din 25, în 25-18=7, acestea fiind valorile afișate de linia 11.
Practic, acest program interschimbă valorile a două variabile, într-o manieră mai puțin uzitată. Cel
mai adesea, acest lucru se face utilizând o variabilă auxiliară, pe care o vom numi aici aux, de același tip ca
a și b, într-o secvență precum cea de mai jos:
aux = a;
 a = b;
b = aux;

Să presupunem că scriem un program în cadrul căruia reținem vârsta unui prieten în variabila
varsta, cât de logic este ca, după trecerea unui an, să modificăm numele variabilei, deoarece s-a modificat
vârsta? Acest lucru nu este logic deloc, nu numele variabilei ar trebui schimbat, ci conținutul său, printr-o
instrucțiune de forma:
varsta = varsta + 1;
Când vom dobândi o oarecare experiență în programare, vom constata că instrucțiuni de tipul celei de mai
sus, care modifică „pe (același) loc” conținutul unei variabile, sunt foarte frecvente. E vorba de instrucțiuni
precum cele de mai jos:
x = x + a;
x = x – a;
x = x * a;
x = x / a;
x = x % a;
Din „lene” (comoditate) programatorii C++ au „inventat” niște operatori „prescurtați”, și anume +=, -=, *=,
/= și %=, cu ajutorul cărora scriu mai puțin cod, ca în exemplul de mai jos:
x +=a; // echivalent cu x = x + a;
Mai mult decât atât, au inventat și așa numiții operatori de incrementare (++) și decrementare (--), care
măresc, respectiv micșorează cu o unitate operandul asupra căruia sunt aplicați. Prin urmare, putem înlocui
fără nicio problemă instrucțiunea:
x = x + 1;
cu:
x++;
sau cu:
++x;
Cum trebuie să scriem, așadar, operatorul de incrementare sau decrementare, înaintea sau după operand?
Într-o situație precum cea de mai sus, e indiferent, dar situațiile de mai jos sunt diferite, explicațiile fiind date
în comentarii:

x = 3; // x primește valoarea 3
y = x++; // valoarea lui x, adică 3, este întâi atribuită lui y,
// apoi x este incrementat, devenind 4. După instrucțiune, x este 4, iar y este 3

x = 3; // x primește valoarea 3
y = ++x; // valoarea lui x, adică 3, este întâi incrementată, apoi atribuită lui y.
// După instrucțiune, x este 4, iar y este tot 4.

sau:

a = b = 0;
c = a++ + b++; // c este 0

a = b = 0;
c = ++a + b++; // c este 1
a = b = 0;
c = a++ + ++b; // c este 1

a = b = 0;
 c = ++a + ++b; // c este 2

Următorul program conține multe elemente noi și interesante:

1 #include <iostream>
2 #include <string>
3 using namespace std;
4
5 int main ()
6 {
7 string r;
8 int varsta;
9 cout << "Cum vă numiți? ";
10 getline (cin, r);
11 cout << r <<", bine ați venit!\nCâți ani aveți? ";
12 cin >> varsta;
13 if (varsta < 18)
14 cout << "Ne pare rău, nu avem nicio ofertă pentru
dumneavoastră.\nReveniți peste " << 18-varsta << "
ani.";
15 return 0;
16 }

Iată și două exemple de utilizare, pentru două seturi de date diferite:

Ieșirea voastră arată ușor diferit? Sau ușor mai mult? Dacă da, nu uitați că v-am sugerat să nu folosiți
diacriticele nici măcar în stringuri.
 Dar, hai să examinăm mai îndeaproape liniile programului:

Linia 2: #include <string>

După cum, probabil, vă mai amintiți, liniile începând cu semnul # sunt directive preprocesor. Astfel, linia 1
#include <iostream>
ne permitea să utilizăm obiectele definite în fișierul-antet iostream, care conține obiectele cu ajutorul
cărora gestionăm intrările și ieșirile de la și spre dispozitivul standard de intrare, respectiv de ieșire. În mod
asemănător, fișierul-antet string conține obiectele cu ajutorul cărora gestionăm operațiunile legate de
stringuri (șiruri de caractere).

Linia 7: string r;
Este o declarație de variabilă de tip string. Tipul string nu este nativ, așa cum sunt int sau double,
dar declararea obiectelor de tip string se face asemănător cu a celor de tipul int sau double.

Linia 10: getline (cin, r);

Cu ajutorul acestei linii realizăm inițializarea variabilei r, de tip string. Practic, apelăm funcția getline,
precizându-i doi parametri: dispozitivul din care preluăm informația – în cazul nostru cin -, și numele
stringului în care o depunem – în cazul nostru r. Stringul r poate conține un caracter sau mai multe, litere,
cifre, anumite caractere speciale, cum ar fi spațiile, dar nu orice caracter special.

Linia 11: cout << r <<", bine ați venit!\nCâți ani aveți? ";
Această instrucțiune trimite un flux de informații către dispozitivul de ieșire standard, cout, iar acesta
afișează conținutul acestor informații pe dispozitivul standard de ieșire, respectiv monitor. Elementul de
noutate este reprezentat de prezența unui caracter special, neimprimabil, și anume \n. Acest caracter face
parte dintr-un grup de caractere speciale, numite și secvențe de escape, fiindcă, fizic, sunt formate din
caracterul \ (escape sau backslash) și alt(e) caracter(e). Mai specific, o secvență de escape poate avea una
din următoarele forme:
➢ \c, unde c este unul din următoarele caractere: b, t, n, f, r, ", ', sau \, cu semnificațiile:
\b – backspace – deplasarea cursorului cu o poziție la stânga;
\t – tab;
\n – line feed (linie nouă);
\f - form feed (salt la pagină nouă);
\r - carriage return (întoarcerea carului);
\" - double quote (ghilimele);
\' - single quote (apostrof);
\\ - backslash.
Alături de \n, mai frecvent folosite sunt \", \' și \\.
➢ \ooo, unde ooo sunt trei cifre octale (de la 0 la 7), pentru desemnarea unor caractere conform
codului ASCII2.
➢ \uhhhh, unde hhhh sunt patru cifre hexazecimale (adică 0-9 și a-f), pentru desemnarea unor
caractere conform codului Unicode, în care caracterele sunt reprezentate pe doi octeți 3. Atenție: deoarece
reprezentarea internă e pe doi octeți, caracterele Unicode sunt considerate multicaractere, adică stringuri. De
exemplu, programul:
1 #include <iostream>
2 using namespace std;

2 În memoria internă a calculatorului, absolut orice informație este reprezentată sub forma unui șir de 0 și 1, deci
numeric. Codul ASCII este un mod de codificare a literelor alfabetului englez și a altor caractere pe un singur octet
de memorie (de fapt, pe doar 7 biți, în varianta standard, și doar în varianta extinsă pe 8). Prin urmare, folosind
codul ASCII, putem reprezenta maximum 28 = 256 de caractere. Despre codul ASCII puteți citi mai multe aici.
3 Pentru a vedea caracterele codului Unicode, click aici.
3
4 int main()
5 {
6 cout << "\u4108";
7 return 0;
8 }

afișează ideograma chinezească 䄈, care s-ar putea traduce prin: sacrificiul pe care trebuie să-l facem pentru
a obține fericirea.

Codurile Unicode ale caracterelor românești sunt următoarele 4: Â – 00C2, Î – 00CE, â – 00E2, î – 00EE, Ă-
0102, ă – 0103, Ș – 0218, ș – 0219, Ț – 021A, ț – 021B.
Puteți spune ce afișează programul următor, fără a-l rula?
1 #include <iostream>
2 using namespace std;
3 int main()
4 {
5 cout << "\u00cenc\u0103 mai \u00eenv\u0103\u021b, de\u0219i
\u0219tiu.";
6 return 0;
7 }

Linia 12: cin >> varsta;

După cum probabil ați intuit, obiectul cin este omologul lui cout: dacă acesta din urmă se folosea pentru
afișarea datelor pe terminalul standard de ieșire, respectiv monitorul, cin se folosește pentru preluarea
datelor de la terminalul standard de intrare - tastatura. Și cin, și cout sunt obiecte de tip stream (flux), al
căror rol este acela de a „transporta” informații.
În cazul de față, cin așteaptă introducerea celui mai lung șir de caractere care poate fi interpretat ca o dată de
tipul precizat (int), apoi interpretând corespunzător acel șir, îl depune în variabila varsta.
Mai multe despre cin și cout aici.

Liniile 13 și 14 reprezintă, de fapt, o singură instrucțiune:

if (varsta < 18) cout << "Ne pare rău, nu avem nicio ofertă pentru
dumneavoastră.\nReveniți peste " << 18-varsta << " ani.";

Instrucțiunea if este deosebit de importantă, deoarece, cu ajutorul ei putem implementa structura

alternativă sau de decizie. Despre ce este vorba? Până acum am vorbit de programe foarte simple, care
execută anumite instrucțiuni, mereu aceleași, la fiecare rulare, indiferent de valorile variabilelor. Aceasta este
structura liniară:
instrucțiune 1;
instrucțiune 2;

4 Pentru a reprezenta cifrele hexazecimale a-f putem folosi atât litere mici, cât și mari.
 ...
instrucțiune n;

Rareori se întâmplă, însă, ca problemele pe care dorim să le rezolvăm cu ajutorul programelor de calculator
să fie atât de simple încât să poată fi rezolvate cu ajutorul unui set de instrucțiuni executate liniar.