Operatori

Pentru că am introdus variabilele și constantele, putem începe să operăm cu ele folosind operatori.
Ceea ce urmează este o listă completă a operatorilor. În acest moment nu este necesar să îi cunoaștem pe
toți, dar i-am prezentat pe toți pentru a ne servi ca referință.

Operatorul de atribuire (=)

Operatorul de atribuire asignează unei variabile o valoare.

1 x = 5;

Această instrucțiune atribuie valoarea întreagă 5 variabilei x. Operația de atribuire are loc
întotdeauna de la dreapta la stânga, niciodată în sens invers:

1 x = y;

Această instrucțiune atribuie variabilei x valoarea conținută în variabila y. Valoarea lui x la

momentul execuției acestei instrucțiuni este pierdută și înlocuită cu valoarea lui y.

De asemenea, considerăm că doar atribuim lui x valoarea lui y, la momentul operației de atribuire.
De aceea, dacă y se schimbă mai târziu, aceasta nu va afecta valaorea luată de x.

De exemplu, să ne uităm puțin la codul următor - am inclus în comentarii evoluția conținutului

memorat în variabile:

// operatorul de atribuire
#include <iostream>
using namespace std;

int main ()
{
int a, b; // a:?, b:?
a = 10; // a:10, b:?
b = 4; // a:10, b:4
a = b; // a:4, b:4
b = 7; // a:4, b:7

cout << "a:";

cout << a;
cout << " b:";
cout << b;
}

Acest program afișează pe ecran valorile finale ale lui a și b (4, respectiv 7). Observați că a nu a fost
afectat de schimbarea finală a lui b, chiar dacă am avut a = b mai înainte.

Operațiile de atribuire sunt expresii care pot fi evaluare. Aceasta înseamnă că atribuirea însăși are o
valoare și, pentru tipurile fundamentale, este cea atribuită în operație. De exemplu:

1 y = 2 + (x = 5);

În această expresie, lui y i se atribuie rezultatul sumei dintre 2 și valoarea altei expresii de atribuire
(care are, la rândul ei, valoarea 5). Este echivalentă cu:
1 x = 5;
2 y = 2 + x;

cu rezultatul final 7 atribuit lui y.

Următoarea expresie este validă, de asemenea, C++:

1 x = y = z = 5;

Ea asignează valoarea 5 tuturor celor trei variabile: x, y și z; întotdeauna de la dreapta la stânga.

Operatori aritmetici ( +, -, *, /, % )
Cele cinci operații aritmetice suportate de C++ sunt:

OperatorDescriere
+ Adunare
- Scădere
* Înmulțire
/ Împărțire
% Modulo

Operațiile de adunare, scădere, înmulțire și împărțire corespund exact operatorilor matematici

cunoscuți. Ultimul, operatorul modulo, reprezentat de simbolul procent (%), determină restul împărțirii a
două valori. De exemplu:

1 x = 11 % 3;

are ca efect faptul că variabila x conține valoarea 2, deoarece împărțind pe 11 la 3 obținem câtul 3 și restul 2.

Atribuire compusă (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)
Operatorii pentru atribuire compusă modifică valoarea curentă a variabilei față de ea însăși. Sunt
echivalente cu atribuirea rezultatului unei operații chiar primului operand:

Expresie Echivalentă cu...

y += x; y = y + x;
x -= 5; x = x - 5;
x /= y; x = x / y;
pret *= cantitate + 1;pret = pret * (cantitate+1);

și la fel pentru toți operatorii de atrbuire compusă. De exemplu:

1 // atribuire compusa
2 #include <iostream>
3 using namespace std;
4
5 int main ()
6{
7 int a, b=3;
8 a = b;
9 a+=2; // echivalent cu a=a+2
10 cout << a;
11 }
Incrementare și decrementare (++, --)
Unele expresii pot fi prescurtate chiar mai mult: operatorul de incrementare (++) și
operatorul de decrementare (--) crește, respectiv descrește cu o unitate valoarea memorată în
variabilă. Ele sunt echivalente cu +=1, respectiv -=1. Deci:
1 ++x;
2
x+=1;
3
x=x+1;

au toate același sens; fiecare dintre ele crește cu 1 valoarea lui x.

În primele compilatoare C, cele trei expresii de mai sus ar fi putut produce cod
executabil diferit. Acum, însă, acest tip de optimizare a codului este executat automat de
către compilator, deci cele trei expresii ar trebui să producă exact același cod executabil.

O particularitate a acestui operator este aceea că poate fi folosit atât ca prefix, cât și ca
sufix. Aceasta înseamnă că poate fi scris fie înaintea numelui variabile(++x) fie după el (x+
+). Cu toate că în expresii simple precum x++ sau ++x, au exact același înțeles, în alte
expresii în care rezultatul incrementării sau decrementării este evaluat, poate fi o mare
diferență între sensurile lor: în cazul prefixării operatorului de incrementare a valorii (++x),
expresia se evaluează cu valoarea finală a lui x, adică acea valoare care a fost deja majorată.
Pe de altă parte, în cazul postfixării (x++), valoarea este majorată,dar expresia se evaluează
cu valaorea pe care o avea x înainte de incrementare. Să observăm diferența:
Exemplul 1 Exemplul 2
x = 3; x = 3;
y = ++x; y = x++;
// x contine 4, y contine 4 // x contine 4, y contine 3

În Exemplul 1, valoarea asignată lui y este valoarea lui x după ce a fost majorată. În timp ce
în Exemplul 2, are valoarea lui x înainte ca ea să fi fost majorată.

Operatori de relație și egalitate ( ==, !=, >, <, >=, <= )

Două expresii pot fi comparate folosind operatori de relație și de egalitate: de exemplu, pentru a ști
dacă două valori sunt egale sau dacă una este mai mare decât cealaltă.

Rezultatul unei asemenea operații este una dintre valorile boolene true (adevărat) sau false (fals).

Operatorii relaționali C++ sunt:

OperatorDescriere
== Egal cu
!= Diferit de
< Mai mic decât
> Mai mare decât
<= Mai mic decât sau egal cu
>= Mai mare decât sau egal cu
Să vedem câteva exemple:

1 (7 == 5) // are valoarea false

2 (5 > 4) // are valoarea true
3 (3 != 2) // are valoarea true
4 (6 >= 6) // are valoarea true
5 (5 < 5) // are valoarea false

Evident că nu doar valori numerice constante pot fi comparate, ci oricare două valori, inclusiv variabile. Să
presupunem că a=2, b=3 și c=6; atunci:

1 (a == 5) // are valoarea false, deoarece a nu este egal cu 5

2 (a*b >= c) // are valoarea true, deoarece (2*3 >= 6) este true
3 (b+4 > a*c) // are valoarea false, deoarece (3+4 > 2*6) este false
4 ((b=2) == a) // are valoarea true

Atenție! Operatorul de atribuire (operatorul =, cu un simbol egal) nu este același cu

operatorul de egalitate folosit pentru comparație(operatorul ==, cu două semne egal); primul
(=) atribuie valoarea din partea dreaptă variabilei din stânga, în timp ce celălalt (==) compară
valorile din cele două părți ale operatorului de egalitate. De aceea, în ultima expresie
((b=2) == a), mai întâi atribuim valoarea 2 lui b și apoi o comparăm cu a (care conține tot
valoarea 2), deci avem true.

Operatori logici ( !, &&, || )

Operatorul ! este implementarea în C++ a operației boolene NOT. Are doar un operand, la dreapta sa,
și îl neagă producând false dacă operandul este true, respectiv true dacă operandul este false. În principiu, el
returnează valoarea booleană opusă valorii pe care o are operandul. De exemplu:

1 !(5 == 5) // are valoarea false deoarece expresia din dreapta (5 == 5) este true
2 !(6 <= 4) // are valoarea true deoarece (6 <= 4) este false
3 !true // are valoarea false
4 !false // are valoarea true

Operatorii logici && și || se folosesc la evaluarea a două expresii pentru a obține un singur rezultat
de relație. Operatorul && corespunde operației logice boolene AND, care va avea rezultatul true dacă ambii
operanzi au valoarea true și false în celelalte situații. Următorul tabel ne arată rezultatul
operatorului && după evaluarea expresiei a&&b:

Operatorul && (și)

a b a && b
true true true
true false false
false true false
false false false

Operatorul || corespunde operației logice boolene OR, care are valaorea true dacă oricare dintre
operanzii săi are valoarea true, deci va fi falsă numai când ambii operanzi sunt falși. Iată posibilele rezultate
ale lui a||b:
Operatorul || (sau)
a b a || b
true true true
true false true
false true true
false false false

De exemplu:
1 ( (5 == 5) && (3 > 6) ) // are valoarea false ( true && false )
2 ( (5 == 5) || (3 > 6) ) // are valoarea true ( true || false )

Când folosim operatorii logici, C++ evaluează numai cât este necesar de la stânga spre dreapta
pentru a afla rezultatul operației, ignorând restul. De aceea, în ultimul exemplu ((5==5)||(3>6)), C++
evaluează mai întâi dacă egalitatea 5==5 este true și , în caz afirmativ, nu va mai verifica dacă și
inegalitatea 3>6 este true sau nu. Acest mecanism este cunoscut ca evaluare scurt-circuit și lucrează, pentru
acești operatori ca mai jos:

OperatorScurt-circuit
dacă expresia din partea stângă este false, rezultatul combinat este false (expresia din partea
&&
dreaptă nu va mai fi evaluată).
dacă expresia din partea stângă este true, rezultatul expresiei combinate este true (expresia din
||
partea dreaptă nu va mai fi evaluată).

Cel mai important este când expresia din partea dreaptă ar putea avea efecte, ca de exemplu să altereze
valorile:

1 if ( (i<10) && (++i<n) ) { /*...*/ } // atentie la expresia care il incrementeaza pe i

Aici, expresia condițională combinată l-ar putea crește pe i cu o unitate, dar numai în cazul în care
condiția din stânga semnului && are valaorea true, deoarece altfel condiția din partea dreaptă (++i<n) nu va
fi evaluată (deci incrementarea nu are loc).

Operatorul condițional ternar ( ? )

Operatorul condițional evaluează o expresie, returnând o valoare dacă expresia are valoarea true,
respectiv o altă valoare atunci când expresia are valoarea de adevăr false. Sintaxa ei este:

conditie ? rezultat_1 : rezultat_2

În cazul în care conditie are valoarea true, întreaga expresie se evaluează cu rezultat_1, iar altfel se
evaluează cu rezultat_2.

1 7==5 ? 4 : 3 // are valoarea 3, deoarece 7 nu este egal cu 5.

2 7==5+2 ? 4 : 3 // are valoarea 4, deoarece 7 este egal cu 5+2.
3 5>3 ? a : b // are valoarea lui a, deoarece 5 este mai mare decat 3.
4 a>b ? a : b // are acea valoare care este mai mare, a sau b.

De exemplu:

1 // operatorul conditional 7
2 #include <iostream>
3 using namespace std;
4
5 int main ()
 6{
7 int a,b,c;
8
9 a=2;
10 b=7;
11 c = (a>b) ? a : b;
12
13 cout << c << '\n';
14 }

În acest exemplu, a este 2, b este 7, așa încât expresia care trebuie evaluată (a>b) nu are
valoarea true, deci prima valoare precizată după semnul de întrebare este ignorată în favoarea celei de-a
doua valori (cea de după două puncte) adică b (care este 7).

Operatorul virgulă ( , )
Operatorul virgulă (,) este folosit pentru a separa două sau mai multe expresii succesive. Când setul de
expresii trebuie evaluat la o valoare, numai expresia cea mai din dreapta se va lua în considerare.

De exemplu, codul următor:

1 a = (b=3, b+2);

asignează mai întâi valoarea 3 lui b, apoi asignează b+2 variabilei a. Așa încât, la sfârșit, variabila a ar putea
conține valoarea 5 în timp ce variabila b ar conține valoarea 3.

Operatori pe biți ( &, |, ^, ~, <<, >> )

Operatorii pe biți modifică variabilele considerând șablonul de biți al valorilor pe care le conțin variabilele.

OperatorEchivalent asmDescriere
& AND AND pe biți
| OR OR inclusiv pe biți
^ XOR OR exclusiv pe biți
~ NOT Complement unar (complementarea pe biți)
<< SHL Shiftare spre stânga pe biți
>> SHR Shiftare spre dreapta (pe biți)

Operatorul de conversie explicită

Operatorii de conversie de tip permit conversia unei valori dintr-un anumit tip de dată la un al tip.
Sunt câteva modalități de a face aceasta în C++. Cea mai simplă, care a fost moștenită din limbajul C, este
cea prin care expresia de convertit este precedată de noul tip cuprins între paranteze (()):

1 int i;
2 float f = 3.14;
3 i = (int) f;

Codul anterior convertește numărul real zecimal 3.14 la o valoare întreagă (3); restul se pierde. Aici,
operatorul de conversie este (int). Altă modalitate de a face exact același lucru în C++ este folosirea notației
funcționale: după cuvântul cheie corespunzător noului tip, urmează expresia de convertit cuprinsă între
paranteze:

1 i = int (f);
Ambele modalități de conversie de tip sunt valide în C++.
sizeof
Acest operator acceptă un parametru, care poate fi un tip de dată sau o variabilă, și returnează
dimensiunea în bytes a acelui tip sau obiect:

1 x = sizeof (char);

Aici, lui x i se asignează valoarea 1, deoarece tipul de dată char are dimensiunea de un byte.

Valoarea returnată de sizeof este determinată în timpul compilării, deci ea este determinată
întotdeauna înainte de execuția programului.

Alți operatori
Mai târziu, în acest tutorial vom vedea mai mulți operatori, precum cei referitori la pointeri sau cei specifici
programării orientate pe obiecte.

Precedența operatorilor
O singură expresie poate conține mai mulți operatori. De exemplu:

1 x = 5 + 7 % 2;

În C++, expresia de mai sus atribuie valoarea 6 lui x, deoarece operatorul % are o precedență mai
mare față de operatorul + și este evaluat întotdeauna înainte. Uneori părți ale unor expresii pot fi cuprinse
între paranteze pentru a modifica ordinea dată de precedență sau pentru a face mai explicit efectul dorit. Să
observăm diferența:

1 x = 5 + (7 % 2); // x = 6 (la fel si fara paranteze)

2 x = (5 + 7) % 2; // x = 0

De la prioritatea cea mai mare la cea mai mică, operatorii C++ sunt evaluați în ordinea următoare:
Gradgrup de precedență Operator Descriere Grupare
De la stânga la
1 Domeniu :: Calificator de domeniu
dreapta
Incrementare / decrementare
++ --
postfixată
De la stânga la
2 Postfixat (unar) () Forme funcționale
dreapta
[] subscript
. -> Accesare membru
Incrementare / decrementare
++ --
prefixată
~! NOT pe biți / NOT logic
+- Unar prefixat De la dreapta la
3 Prefixat (unar)
&* Referențiere / Dereferențiere stânga
new delete Alocare / Dealocare
sizeof
(type) Conversie de tip în stilul C
De la stânga la
4 Pointer la membru .* ->* Pointer de acces
dreapta
De la stânga la
5 Aritmetic: scaling */% înmulțire, împărțire, modulo
dreapta
De la stânga la
6 Aritmetic: adunare +- adunare, scădere
dreapta
 De la stânga la
7 Deplasare pe biți << >> deplasare stânga, deplasare dreapta
dreapta
De la stânga la
8 Relațional < > <= >= Operatori de comparație
dreapta
De la stânga la
9 Egalitate == != egalitate / inegalitate
dreapta
De la stânga la
10 Și & AND pe biți
dreapta
De la stânga la
11 OR exclusiv ^ XOR pe biți
dreapta
De la stânga la
12 OR inclusiv | OR pe biți
dreapta
De la stânga la
13 Conjuncție && AND logic
dreapta
De la stânga la
14 Disjuncție || OR logic
dreapta
= *= /= %= += -=
Expresii la nivel de >>= <<= &= ^= | Atribuire / Atribuire compusă De la dreapta la
15
atribuire = stânga
?: Operator condițional
De la stânga la
16 Secvență , Separator virgulă
dreapta

Când o expresie are doi operatori cu același grad de precedență, gruparea determină care
dintre ei este evaluat primul: fie de la stânga la dreapta fie de la dreapta la stânga.

Includerea tuturor subexpresiilor în paranteze (chiar și acolo unde nu este necesar datorită
precedenței) poate îmbunătăți claritatea sursei.

Structura unui program

Cel mai bun mod de a învăța un limbaj de programare este scrierea de programe. De
obicei, primul program scris de începători este programul numit "Hello World", care pur și
simplu printeaza "Hello World" pentru ecranul computerului. Deși este foarte simplu, el
conține toate componentele fundamentale ale programelor C ++:
// primul meu program in C++
#include <iostream>

int main()
{
std::cout << "Salutare, lume!";
}

Să examinăm acest program linie cu linie:

Linia 1: // primul meu program in C++
Doua semne slash indică faptul că restul liniei este un comentariu introdus de către
programator, dar care nu are nici un efect asupra comportamentului programului.
Programatorii le folosesc pentru a include explicații scurte sau observații cu privire la cod
sau program. În acest caz, este vorba de o scurtă descriere introductivă a programului.

Linia 2: #include <iostream>

Liniile care încep cu un diez (#) sunt directivele de citit și interpretat de ceea ce este
cunoscut sub numele de preprocesor. Acestea sunt linii speciale interpretate înainte de
începerea programului în sine. În acest caz, directiva #include <iostream>, instruiește
preprocesorul să includă o secțiune de cod C ++, cunoscuta ca antet-ul iostream care permite
efectuarea de operațiuni de intrare și de ieșire standard, cum ar fi scrierea pe ecran a
mesajului (Salutare lume).

Linia 3: O linie goală.

Liniile goale nu au niciun efect asupra unui program. Ele îmbunătățesc pur și simplu lizibilitatea codului.

Linia 4: int main ()

Această linie inițiază declararea unei funcții. În esență, o funcție este un grup de
instructiuni de cod caruia ii este dat un nume: în acest caz, avem numele de "main" pentru
gruparea de instructiuni care urmează. Funcțiile vor fi discutate în detaliu într-un capitol
ulterior, dar, în esență, definirea acestora este introdusa ca o succesiune de tip (int), un
nume(main) și o pereche de paranteze (()), care opțional poate include si parametri.

Funcția numita main este o funcție specială în toate programele C ++; aceasta este
funcția apelata atunci când programul este rulat. Executarea tuturor programelor C ++ începe
cu funcția main, indiferent de locul în care funcția este de fapt localizata în cod.

Liniile 5 si 7: { si }
Acolada deschisa ({) la linia 5, indică începutul definiției funcției main, iar acolada de
închidere (}) de la linia 7, indică sfârșitul ei. Tot ce este între aceste acolade formeaza corpul
functiei care definește ceea ce se întâmplă atunci când se apeleaza functia principala main.
Toate funcțiile folosesc acolade pentru a indica începutul și sfârșitul definițiilor lor.

Linia 6: std::cout << "Salutare, lume!";

Această linie este o instrucțiune C ++. O instrucțiune este o expresie care poate
produce un efect. Este partea esențială a unui program, precizând comportamentul efectiv al
acestuia. Instrucțiunile sunt executate în aceeași ordine în care apar în corpul unei funcții.

Această instrucțiune are trei părți: în primul rând, std::cout, care identifică
dispozitivul standard de afișare (iesire = output) a caracterelor (de obicei, acest lucru este
ecranul calculatorului). În al doilea rând, operatorul de inserare (<<), care indică faptul că
ceea ce urmează este introdus în std::cout. În cele din urmă, o propoziție între ghilimele
("Salutare, lume!"), este ceea ce se trimite la ieșirea standard.

Observați că declarația se termină cu punct și virgulă (;). Acest caracter marchează sfârșitul
instrucțiunii, la fel cum punctul încheie o propoziție în limba engleză. Toate instrucțiunile C ++ trebuie să se
termine cu un caracter punct și virgulă. Una dintre cele mai comune erori de sintaxă în C ++ este cand se
uita terminarea unei instrucțiuni cu punct și virgulă.

Poate că ați observat că nu toate liniile acestui program efectuează acțiuni atunci când se execută
codul. Există o linie care conține un comentariu (începând cu //). Există o linie cu o directivă pentru
preprocesor (începând cu #). Există o linie care definește o funcție (în acest caz, funcția principală main). Și,
în cele din urmă, o linie cu instructiuni se termină cu punct și virgulă (folosirea lui cout), care a fost în
cadrul blocului delimitat de acolade ({ }) din funcția main.

Programul a fost structurat pe diferite linii și indentate în mod corespunzător, în scopul de a-l face
mai ușor de înțeles pentru oamenii care il citesc. Dar C ++ nu are reguli stricte cu privire la indentare sau cu
privire la modul de împărțire a instrucțiunilor în linii diferite. De exemplu, în loc de
1 #include<iostream>
2
3
4 int main ()
5
6 {
std::cout << " Salutare, lume!";
}

am fi putut scrie:
1 #include<iostream>
2
3
int main () { std::cout << "Salutare, lume!"; }

toate într-o singură linie, iar acest lucru ar fi avut exact același înțeles (pentru compilator) ca și codul
precedent.

În C ++, separarea dintre instrucțiuni se marcheaza cu ajutorul simbolului punct și virgulă (;) care se
pune la sfarsit de instructiune, iar separarea pe diferite linii nu are nici o importanta în acest sens. Mai multe
instrucțiuni pot fi scrise pe o singură linie, sau fiecare instrucțiune poate fi scrisa pe propria linie. Impartirea
codului pe linii diferite servește doar pentru a-l face mai lizibil și pentru a-l schematiza pentru oamenii care
il pot citi, dar nu are nici un efect asupra comportamentului real al programului.

Acum, haideți să adăugăm o instrucțiune suplimentară pentru primul nostru program:

// al doilea program al meu in C++
#include <iostream>
 int main ()
{
std::cout << "Salutare, lume! ";
std::cout << "Eu sunt un program C++.";
}

În acest caz, programul efectuează două inserții în std::cout în două instrucțiuni diferite. Încă o dată,
separarea pe diferite linii de cod, pur și simplu dă o mai mare vizibilitate la program, deoarece main ar fi
putut fi perfect valabil definită si în acest fel:
1 #include<iostream>
2
int main () { std::cout << " Salutare, lume! "; std::cout << " Eu sunt un program C++. "; }

Codul sursă ar fi putut fi, de asemenea, împărțit în mai multe linii de cod:

1 #include<iostream>
2
3 int main ()
4 {
5
6 std::cout <<
7 "Salutare, lume!";
8
std::cout
<< "Eu sunt un program C++.";
}

iar rezultatul ar fi fost din nou exact la fel ca în exemplele precedente.

Directivele preproces (cele care încep cu #) fac exceptie de la această regulă generală, deoarece
acestea nu sunt instructiuni. Acestea sunt linii citite și prelucrate de către preprocesor inainte de a incepe
compilarea corespunzătoare. Directivele preprocesorului trebuie să fie specificate în linia lor și, pentru că ele
nu sunt instructiuni, nu trebuie să se termine cu punct și virgulă (;).

Using namespace std

Dacă ați mai văzut cod C ++ inainte, este posibil să fi văzut cout folosit în loc
de std::cout. Ambele numesc același obiect: prima folosește nume necalificat (cout), în timp
ce al doilea il califică direct în spațiul de nume std (astfel, std::cout).

cout este parte din biblioteca standard, iar toate elementele din biblioteca standard C ++ sunt
declarate în ceea ce se numește un namespace (spatiu de nume): namespace std.

În scopul de a se referi la elementele din spațiul de nume std un program fie califică
fiecare utilizare a elementelor bibliotecii (așa cum am făcut prin prefixarea cout cu std::), fie
dă vizibilitate componentelor sale. Modul cel mai tipic de a da vizibilitate acestor
componente se face prin utilizarea instrucțiunii using declaratii:
1 using namespace std;

Instrucțiunea de mai sus permite tuturor elementelor din spațiul de nume std să fie accesate în
manieră necalificată (fără prefixul std::).

Cu aceasta în minte, ultimul exemplu poate fi rescris pentru utiliza cout necalificat astfel:
// al doilea program al meu in C++
#include <iostream>
using namespace std;

int main ()
{
cout << "Salutare, lume! ";
cout << "Eu sunt un program C++.";
}

Ambele modalități de accesare a elementelor spațiului de nume std namespace

(calificarea explicită și folosirea instrucțiunii using) sunt valabile în C ++ și produc exact
același comportament. Pentru simplitate, și pentru a îmbunătăți lizibilitatea, exemplele din
acest tutorial vor folosi mai des această din urmă abordare (cu instructiunea using,
deși calificarea explicită este singura modalitate care garantează că nu se produc coliziuni de
nume.

Variabile
Utilitatea programului "Hello World", prezentat în capitolul anterior este discutabilă. Am avut de
scris mai multe linii de cod, de compilat, iar apoi de executat programul rezultat, doar pentru a obține
afișarea unei propoziții simple în scris pe ecran. Cu siguranță ar fi fost mult mai rapid să introducem
propoziția noi înșine.

Cu toate acestea, programarea nu se limitează numai la imprimarea de texte simple pe ecran. În

scopul de a merge un pic mai departe cât și pentru a deveni capabili să scriem programe pentru sarcini utile,
care într-adevăr ne salvează, avem nevoie să introducem conceptul de variablă.

Să ne imaginăm că: vă rog să vă amintiți numărul 5, apoi să vă cer să memorați și numărul 2, în

același timp. Tocmai ați salvat două valori diferite în memorie (5 și 2). Acum, dacă vă rog să adăugați 1 la
primul număr spus, ar trebui să fie reținute în memorie numerele 6 (obținut din 5 + 1) și 2. Apoi, am putea,
de exemplu, să scădem aceste valori și să obținem rezultatul 4.

Întregul proces descris mai sus este un exemplu relativ la ceea ce poate face un
calculator cu două variabile. Același proces poate fi exprimat în C ++ cu următorul set de
instrucțiuni:
1 a = 5;
2
3 b = 2;
4 a = a + 1;
rezultat = a - b;

Desigur, acesta este un exemplu foarte simplu, deoarece am folosit doar două valori întregi mici, dar
să ținem cont că un calculator poate stoca simultan milioane de numere precum acestea și poate efectua
operațiuni matematice sofisticate cu ele.

Putem defini acum o variabilă ca o zonă din memorie în care stocăm o valoare.

Fiecare variabilă are nevoie de un nume care o identifică și o distinge de celelalte. De exemplu, în
codul anterior numele de variabile au fost a, b și rezultat, dar am fi putut numi variabilele cu orice nume
doream, atâta timp cât acestea ar fi fost identificatori valizi in limbajul C ++.
Foarte important: limbajul C ++ este un limbaj de tip "sensitive case". Asta înseamnă că un
identificator scris cu litere mari nu este echivalent cu un altul cu același nume, dar scris cu litere mici.
Astfel, de exemplu, variabila REZULTAT nu este aceeași cu variabila rezultat sau cu variabila Rezultat.
Acestia sunt trei identificatori diferiți identificand trei variabile diferite.
Declarații de variabile
C++ este un limbaj de tip ”strongly-typed” și necesită ca fiecare variabilă să fie declarată cu tipul de
dată corespunzător, înainte de prima sa utilizare. Declarația informează compilatorul cu privire la
dimensiunea pe care să o rezerve în memorie pentru acea variabilă și îi spune cum să interpreteze valorile
sale. Sintaxa pentru declararea unei noi variabile în C++ este extrme de simplă: doar scriem tipul de dată
urmat de numele variabilei (adică de identificatorul său). De exemplu:
1 int a;
2
float numar;

Acestea sunt două declarații valide de variabile. Prima declară o variabilă de tip int al cărei
identificator este a. A doua declară o variabilă de tip float al cărei identificator este numar. Odată declarate,
variabilele a și numar pot fi folosite în interiorul domeniului lor din program. Dacă avem mai multe variabile
de același tip, ele pot fi toate declarate într-o singură instrucțiune separaându-le identificatorii cu ajutorul
virgulei. De exemplu:
1 int a, b, c;

Aceasta declară trei variabile (a, b și c), toate fiind de tip int și având exact același sens ca și:
1 int a;
2
3 int b;
int c;

Pentru a înțelege cum se comportă într-un program, să ne uităm puțin la întregul cod C++ al exemplului cu
exercițiul de memorie mintal propus la începutul acestui capitol:
1 // lucrul cu variabile
2
3 #include <iostream>
4 using namespace std;
5
6
7 int main ()
8 {
9
10 // declararea variabilelor:
11 int a, b;
12
13 int rezultat;
14 // calcul:
15
16 a = 5;
17
b = 2;
18
19 a = a + 1;
20
21 rezultat = a - b;
22 // afisarea rezultatului:
23
cout << rezultat;
// terminarea programului:
return 0;
}

Inițializări de variabile
Când am declarat variabilele din exemplul de mai sus, ele aveau valori nedeterminate până în
momentul în care li s-au atribuit valori pentru prima oară. Dar se poate să atribuim o anumită valoare unei
variabile chiar în momentul declarării. Aceasta se numește inițializarea variabilei. În C++, există trei
modalități de inițializare a variabilelor. Toate sunt echivalente și au rămas datorită evoluției în timp a
limbajului:
Prima dintre ele, cunoscută ca inițializare în stilul c (deoarece a fost moștenită din limbajul C), constă în
adăugarea unui simbol egal urmat de valoarea care se atribuie la inițializare:

tip identificator = valoare_initiala;

De exemplu, pentru a declara o variabilă de tip int, numită x, și pentru a o inițializa cu valoarea zero chiar în
momentul declarării, putem scrie:
1 int x = 0;
A doua metodă, cunoscută ca inițializare prin constructor (introdusă de limbajul C++), cuprinde valoarea
inițială între paranteze (()):

tip identificator (valoare_initiala);

De exemplu:
1 int x (0);
În fine, a treima metodă, cunoscută care inițializare uniformă, asemănătoare celei de mai sus, dar care
folosește acolade ({}) în loc de paranteze (aceasta a fost introdusă de revizuirea standardului C++, în 2011):

tip identificator {valaore_initiala};

De exemplu:
1 int x {0};

Toate cele trei modalități de inițializare a variabilelor sunt valide și echivalente în C++.
1 // initializari de variabile
2
3 #include <iostream>
4 using namespace std;
5
6 int main ()
7 {
8
9 int a=5; // valoare initiala: 5
10
int b(3); // valoare initiala: 3
11
12 int c{2}; // valoare initiala: 2
13
14 int rezultat; // valoare initiala nedeterminata
15 a = a + b;
16
17 rezultat = a - c;
18 cout << rezultat;
return 0;
}

Deducție de tip: auto și decltype

Când o nouă variabilă este inițializată, compilatorul identifică automat tipul de dată al variabilei, conform cu
inițializarea. De aceea, este suficient să folosim auto ca specificator de tip pentru acea variabilă:
1 int foo = 0;
2
auto bar = foo; // la fel ca: int bar = foo;

Aici, bar este declarată ca având un tip auto; de aceea, tipul său bar este tipul valorii folosite pentru
inițializare: în acest caz se folosește tipul lui foo, care este int.

1 int foo = 0;
2
decltype(foo) bar; // la fel ca: int bar;

Aici, bar este declarată ca având același tip cu foo.

auto și decltype sunt caracteristici puternice ale limbajului recent adăugate. Dar deducția de
tip merită să fie folosită numai când nu se poate obține prin alte mijloace sau când folosirea
ei îmbunătățește claritatea programului. Niciunul dintre exemplele de mai sus nu se
încadrează în aceste situații. Din contră, ele chiar înrăutățesc claritatea, căci atunci când citim
sursa ar trebui să căutăm după tipul lui foo pentru a realiza care este de fapt tipul lui bar.