Conventii lexicale:

In limbajul C++ exista 5 categorii lexicale (tokens) = entitati lingvistice

care au semnificatie sintatica pentru compilator:

1. Nume (name) / Identificatori (identifiers)

2. Cuvinte cheie (keywords)
3. Literale (literals)/ constante
4. Operatori (operators)
5. Semne de punctuatie (punctuators), incluzand: Separatori
(separators)
Conventii lexicale

Spatii albe (white spaces) → multimea caracterelor:

• spatiu (blank),
• tabulatori orizontali si verticali (tabs),
• linie noua (new line),
• caractere de formatare (formfeeds) si
• comentariile (def.: /* sir caractere */ sau // linie )

Spatii albe sunt ignorate si eliminate din codul sursa in etapa de

compilare, cu exceptia situatiei când folosesc pentru separarea a 2
entitati lexicale.

Un spatiu alb este necesar pentru separarea identificatorilor, a

cuvintelor-cheie si a constantelor.
Conventii lexicale

1. Nume (name) / Identificatori (identifiers) → secventa de lungime

oarecare de litere si cifre, primul caracter sa fie litera sau
underscore (’_’).

Obs.: C++ este limbaj “case sensitive”, literele mici sunt diferite de
literele mari corespunzatoare.
Ex.:
int diferit de Int diferit de INT

Toate caracterele unui identificator sunt semnificative.

Identificatorii care incep cu 2 caractere underscore (de ex.: _ _nume )

sunt utilizati de compilator, motiv pentru care se evita definirea
unui astfel de nume
Conventii lexicale

2. Cuvinte cheie (keywords) → nume rezervate limbajului, care

semnifica diferite comenzi, operatii, functii si nu pot fi folositi in
alt scop
asm auto bool break case catch
char class const continue default delete
do double else enum extern false
float for friend goto if inline
int long namespace new operator private
protected public register return short signed
sizeof static struct switch template this
throw true try typedef union unsigned
using virtual void volatile while
Conventii lexicale

3. Literale (literals) / constante → valori fixe, pe care programul /

compilatorul NU le poate modifica.

Ex.: int a = 3;
NU trebuie confundate cu
float b = 5.78;
char c = ‘v’;
! notiunea de variabila constanta

char *sir = ”sir de caractere”;

a = a + 5;
Conventii lexicale

A. Constante intregi →succesiune de cifre (fara punct zecimal)

- Modificarea bazei in care sunt scrise (interpretate) constantele

intregi, se face folosind prefixele: 0, 0x, 0X.
Astfel avem:
constanta zecimala (in baza 10), daca NU incepe cu 0
Ex.: 1245
constanta octala (in baza 8), daca incepe cu 0:
Ex.: 01245
constanta hexazecimala (in baza 16), daca incepe
cu 0x sau 0X:
Ex.: 0x1245 sau 0X1fab3

TEMA: Sa se transforme numerele din ex. dintr-o baza in cealalta

Conventii lexicale

A. Constante intregi →succesiune de cifre (fara punct zecimal)

- Modificarea tipului constantei intreaga corespunzator

domeniului de variatie se poate face folosind sufixurile:
- u sau U constantele devin unsigned (fara semn)
- l sau L sunt de tip long (dubla precizie)

Ex.: 123u, 32L, 432734l, 1234ul

Tipul implicit = constanta intrega cu semn, scris in baza 10,

corespunzand modul de scriere: fără prefix, (cu 0 sau 0x în faţă)
si fara sufix (u, U, l, L scris la sfarsit) al constantei.
Conventii lexicale

B. Constante reale (in virgula mobila) → alcatuite dintr-o parte

întreaga,punctul zecimal, o parte fractionara si optional, un
exponent întreg cu semn precedat de caracterul e sau E. Poate lipsi
partea întreaga sau partea fractionara, dar nu amândoua.

𝑒 𝑓 /𝐹
[±]ParteIntreaga.ParteFractionala ± 𝐸𝑥𝑝𝑜𝑛𝑒𝑛𝑡
𝐸 𝑙 /𝐿

Obs.: Implicit (fara specificator de tip) constantele reale sunt de tip double.

Specificatorii de tip:f/F pentru float

l/L pentru long double
Ex.: 1245.7
-34.9e-2f
Conventii lexicale

C. Constante caracter → unul sau mai multe caractere cuprinse între

ghilimele simple (apostrof).

Ex.: ‘a’ ‘\n’ ‘\27’

Obs.: constanta de un singur caracter este de tipul char

constanta multi-caracter este de tipul int

Caracterele simple sunt memorate prin intermediul codului ASCII,

reprezentand o valoare intreaga pe un octet
Ex.: '1' = 49
'a' = 97
'A' = 65
Conventii lexicale

C. Constante caracter
Constanta multi-caracter (caractere speciale, caractere de
control, secvente de escape):
- caractere speciale: ‘\n’ = new line
‘\t’ = tab
‘\a’ = sunet
‘\\’ = caracterul \
‘\’’ = caracterul ‘
‘\”’ = caracterul ”
- caractere de control, specificate prin cod ASCII:
‘\nn’ = caracter cu cod ASCII in format zecimal
‘\0nnn’= caracter cu cod ASCII in format octal
‘\xnn’= caracter cu cod ASCII in format hexazecimal

Ex.: pentru ESC ‘\27’ ‘\033’ ‘\x1b’

pentru CTRL/C ‘\03’
Conventii lexicale

D. Constante sir de caracter → secventa de caractere cuprinsa între

ghilimele (duble), este de tipul vector de caractere si la sfarsit are
adaugat caracterul terminator de sir ‘\0’

Are clasa de memorare static

Poate contine caractere speciale

Ex.: “Sir de caractere \n”

Obs.: Unui pointer catre un sir de caractere care se initializeaza cu o

constanta sir de caractere NU i se aloca memorie
char *nume;
- - - - - - - - - - -
nume=“Ionescu”;// Corect, fara alocare

E. Constante booleane → cuvintele cheie: true,false

Conventii lexicale
4. Operatori (operators) → simboluri care semnifica operatii
se vor studia mai tarziu
5. Semnele de punctuatie (punctuators) → caractere (tokens) a caror
semnificatie sintactica si semantica se stabileste in functie de
context (relativ la alte categorii lexicale ce le insotesc).
→ unele, singure sau in combinatie au semnificatie proprie
(formeaza operatori);
→ unele sunt folosite in sintaxa de preprocesare (Ex.: #)

! % ^ & * ( ) – + = { } | ~ [ ] \ ; ' : " < > ? , . / #

Obs.: Caracterele ( ),[ ],{ } trebuie se folosesc numai in pereche

Separatori (separators) → in C++ sunt 9 separatori, formand o

submultime a semnelor de punctuatie: ( )[ ]{ }, ; :
Variabila. Obiect

Variabila / Obiect → regiune (zona)de memorie in care este stocata o

informatie binara.
→ are asociat un tip de date, care stabileste:
- dimesiunea spatiului de memorie alocat.
- semnificatia informatiei stocate
→ are asociat un nume, prin care variabila este identificata in
spatiul aplicatiei:
→ are o durata de viata (lifetime) si un domeniu de existenta

Obiect → variabila care are ca tip de date o clasa.

Declaratii. Definitii.
Declaratie → instructiune prin care se anunta existenta unui nume. NU
stabileste alcatuirea entitatii numelui, motiv pentru care nu se
aloca spatiu de memorie.

Sintaxa declaratie variabila:

tip_data nume;
Obs.: Declaratia nu se refera numai la variabile, ci si la alte entitati
precum, tipuri de date, functii, etc.
Ex.: int a; // declaratie si defintie
int fct(int); // nu este necesara declararea numelui
parametrului
struct s; // declaratie tip date
class t; // declaratie tip date
s var1; // declaratie variabila cu numele var1 avand
tipul de date s
t var2; // declaratie variabila cu numele var1 avand
tipul de date s
Declaratii. Definitii.
Definitie → instructiune prin care se stabileste continutul (alcatuirea)
entitatii la care se refera un nume.
→ stabileste dimensiunea memoriei alocate numelui

Ex.: int fct(int a) // ESTE necesara declararea numelui parametrului

{ return a+1;
};
struct s // definitie tip date; stabileste alcatuirea lui
{ int s;
float a;
};

Obs.: - Sunt situatii in care o declaratie este si o definitie a numelui

Ex.: int a;

- Orice definitie este si o declaratie a numelui respectiv.

Declaratii. Definitii.

Intr-un program (in intregul proiect) trebuie sa existe o singura

definitie a unui obiect, insa pot exista oricate declaratii.

Ex.: struct s;
- - - - - - - - - - -
struct s; // corect, redeclarare
int a;
- - - - - - - - - - - -
int a; // incorect, eroare, variabila redefinita
Domeniu de definitie (scope)

→ zona din program in care un nume este cunoscut si poate fi folosit

• Domeniul local → numele este declarat intr-un bloc (secventa de
instructiuni cuprinsa intre {}). Numele poate fi folosit incepand cu
locul declararii pana la sfarsitul blocului
Ex.: ------------
{ --------- { int b=1;
int a=1; b++;
----- -
a++; int a=2;
--------- b=a+1;
------------
} --------- }
---------
• Domeniul functie → numele este declarat intr-o functie; echivalent cu
domeniul local al blocului functiei
Domeniu de definitie (scope)

→ zona din program in care un nume este cunoscut si poate fi folosit

• Domeniul local → numele este declarat intr-un bloc (secventa de
instructiuni cuprinsa intre {}). Numele poate fi folosit incepand cu
locul declararii pana la sfarsitul blocului
Ex.: ------------
{ --------- { int b=1;
int a=1; b++;
----- -
a++; int a=2;
--------- b=a+1;
Variabila a NU este definita,
------------
} NU poate fi folosita }
---------
---------
• Domeniul functie → numele este declarat intr-o functie; echivalent cu
domeniul local al blocului functiei
Domeniu de definitie (scope)

→ zona din program in care un nume este cunoscut si poate fi folosit

• Domeniul local → numele este declarat intr-un bloc (secventa de
instructiuni cuprinsa intre {}). Numele poate fi folosit incepand cu
locul declararii pana la sfarsitul blocului
Ex.: ------------
{ --------- { int b=1;
int a=1; b++;
----- - Domeniu de definitie pentru a
a++; int a=2;
--------- b=a+1;
Variabila a NU este definita,
------------
} NU poate fi folosita }
---------
---------
• Domeniul functie → numele este declarat intr-o functie; echivalent cu
domeniul local al blocului functiei
Domeniu de definitie

• Domeniul clasa → numele este asociat unui membru al clasei; se

foloseste in interiorul clasei.

• Domeniul fisier / global → numele este declarat in afara oricarui

bloc sau clasa;
→ are ca domeniu fisierul in care a fost declarat;
→ se poate folosi de la locul declaratiei pana la sfarsitul
fisierului;
→ NU se poate folosi in tot programul (restul fisierelor din
proiect). Pentru utilizare in alt fisier, trebuie declarat (in acel
fisier) ca extern

( Ex.: extern int a; )

Domeniu de vizibilitate

→ un nume este vizibil in intregul domeniu de definitie, cu exceptia

cazului in care numele este redefinit intr-un bloc inclus in
domeniul de definitie initial (domenii imbricate), caz in care
primul nume este partial ascuns.

Ex.: void fct()

{ int i=10;
{ int i=100;
cout << i << endl; // se afiseaza 100
}
cout << i << endl; // se afiseaza 10
}
Domeniu de vizibilitate
→ un nume cu domeniul de definitie fisier (global) poate fi accesat intr-
un domeniu local in care este ascuns prin redefinire folosind
operatorul de rezolutie ::

Ex.: int i=10;

void fct()
{ int i=100;

cout<<“val globala”<<::i<<endl; // se afiseaza 10

cout<<“val locala”<<i<<endl; // se afiseaza 100
}

→ redefinirea unui nume se poate face numai in domenii diferite, in caz

contrar se obtine eroare de redefinire
Durata de viata a variabilelor
(Domeniu de existenta)

O variabila este creata in momentul definirii si este distrusa cand se

paraseste domeniul de definitie.

O variabila globala se creaza in momentul definirii si exista pana la

terminarea programului

O variabila locala se creaza de fiecare data cand se executa intructiunea

de definire.

Obs.: Din acest motiv nu este indicat sa se defineasca variabile in

interiorul ciclurilor
Durata de viata a obiectelor
EXCEPTIE de la regulile anterioare (generale) o fac obiectele declarate
static:
→ ele isi incep existenta din momentul defintiei,
→ NU se distrug la terminarea blocului, exista pana la terminarea
programului.
→ Desi ele exista pana la terminarea aplicatiei, in intreg programul,
sunt vizibile numai in interiorul blocului in care au fost definite.
→ Se initializeaza automat (implicit) la definire cu 0
→ Instructiunea de definire (si initializare daca este explicita) se
executa numai o data, la prima parcurgere (cand se creaza obiectul).

Obs: In C++ si variabilele globale se impliciti cu 0

Durata de viata a obiectelor

Ex.: #include <iostream>

int a;

void fct()
{ int b=1;
static int c=2;

a++,b++,c++;

cout<<“a=”<<a<<“ b=”<<b<<“ c=”<<c<<endl;

}

int main() Interesant este ca in acest punct al

{ for(int i=0;i<5;i++) programului:
fct(); a exista, e vizibil, e def.
} b nu exista, nu e vizibil, nu e def.
c EXISTA, nu e vizibil, nu e def.

TEMA: ce afiseaza programul, cum se explica rezultatul?

Categorii de memorare

auto → obiecte locale care se creaza (aloca memoria) automat la

fiecare parcurgere a blocului. Este modul implicit de alocare a memoriei
unui obiect, nu se fol. in practica.
register → pentru obiectele (variabile) folosite des se aloca memoria
intr-unul din registrii procesorului, pentru a avea timp de acces mic.
Compilatoarele noi fac aceasta optimizare automat, nu se foloseste in
practica.
extern → pentru obiecte globale (care se definesc intr-un singur
fisier), pentru a le accesa din alte fisere trebuie declarate de tip extern.
static → obiect care exista permanent, de la definire pana la
terminarea programului, este vizibil numai in interiorul functiei, blocului
sau fisierului in care a fost definit
Categorii de memorare

Variabila globala definita static

- se poate folosi numai in fisierul in care a fost definita
- NU poate fi declarata extern in alt fisier.
- Se blocheaza accesul din alt fisier la acest obiect.

Obiectele statice sunt obiecte globale (permanente) carora li se

restrange domeniul de vizibilitate la nivelul blocului, functiei sau
fisierului in care au fost definite
Tipuri de date

O variabila (numele asociat ei) are un tip de date asociat, care

determina:
- dimensiunea memoriei alocate numelui,
- domeniul de variatie,
- “decodarea” informatiei binare stocate,
- operatiile care se pot aplica variabilei.
Denumirea unui tip de date se numeste nume de tip (in particular, cand
utilizatorul defineste un nou tip de date, ii asociaza un nume nou)

Operatiile care se pot aplica unui tip de date sunt:

sizeof
new
Tipuri de date

Tipuri de date fundamentale (de baza)

• Tipuri intregi: char 1 oct.
int 2 oct. (4 oct.)
• Tipuri reale (in virgula mobila):
float 4 oct.
double 8 oct.

Modificatori de tip, folositi pentru ajustarea dimensiunii spatiului de

memorare, domeniului de variatie, preciziei:
signed (implicit), numai pentru tipuri intregi
unsigned numai pentru tipuri intregi
short
long
Tipuri de date
Tipuri de date fundamentale (de baza)
char 1 oct. -128 … 127
short int 2 oct. -32768 … 32767
int 2 oct. (4 oct.)
long int 4 oct. -2147483648 … 2147483647
long long int 8 oct.
unsigned char 1 oct. 0 … 255
unsigned int 2 oct. 0 … 65535
unsigned long 4 oct. 0 … 4294967295
float 4 oct. +/-(3.4E-38 ... 3.4E38) prec. 7 cifre
double 8 oct. +/-(1.7E-308 ... 1.7E308) prec. 15 cifre
long double 10 oct. +/-(3.4E-4932 ... 1.1E4932) p. 19 cifre
Obs.: dimensiunea alocata fiecarui tip de date fundamental depinde de
compilator, sistem de operare, etc. Este bine sa se verifice dimensiunile
tipurilor inainte de folosirea lor: ex.: sizeof(int)
Tipuri de date

Tipuri de date fundamentale (de baza)

Obs.:
Tipul long float este corect (sintactic), insa este echivalent
cu double

La scrierea tipurile intregi modificate , se poate omite tipul de

baza
Ex.:
long este echivalent cu long int
long long este echivalent cu long long int

Reprezentarea numerelor intregi negative se fac in complement fata de 2

Tipuri de date

Tipuri de date fundamentale (de baza)

•Tipul void folosit pt. pointeri, valoare returnata de functii

•Tipul bool tip date logice, valori de adevar: true, false

Se pastreaza regula (din C) de evaluare a expresiilor (valorilor)

logice:
orice valoare diferita de zero este true
numai zero are valoare logica false
Tipuri de date

Tipuri de date fundamentale (de baza)

Atunci cand se intalnesc variabile cu tipuri de date diferite, compilatorul

realizeaza o operatie de conversie (cast) automata a tipului
In general, regula de baza este ca tipul de date mai simplu este promovat
catre cel mai complex:
Ex.: char → int int → long int
int → float float → double
Ex.: (explicatie mecanism de conversie)
int main() int main()
{ int a=5,b=2; { int a=5;
double c; double b=2.0, c;
c = a/b; c = a/b;
cout<<c<<endl; cout<<c<<endl;
} }
Tipuri de date
Tipuri de date fundamentale (de baza)
Constante
Cuvantul cheie const blocheaza posibilitatea de modificare a
unei variabile, aceasta devenind o variabila cu valoare constanta
Ex.: const int a2 = 54;

ATENTIE! Acest tip de constanta este o variabila, deci i se aloca

memorie, iar valoare este stocata in acea memorie.

Constanta simbolica
Se poate defini o constanta prin directiva de preprocesare:
#define nume valoare
Ex.: #define a2 54
! Fara ;

ATENTIE! Acest tip de constanta NU ocupa loc in memorie, in esenta

este o prelucrare la nivel de text, in etapa de precompilare
Tipuri de date

Constanta simbolica

Atentie ! Inlocuirea la nivel de text se face in tot textul codului sursa

Se pot obtin alterari la nivel de nume, cuvinte cheie, etc.

Ex.: #define a2 54
#define or 39
. . . . . . . . .
a2 = 10;
for(i=0;i<10;i++)
. . . . . . . . .
Operatori

Unul dintre scopurile realizarii programelor este de a face caclule =

operatii

(Instructiunea de tip) expresia = insiruire de operanzi si operatori

Operanzii = entităţile asupra cărora se execută operatiile, pot fi:

constante,
constante simbolice,
variabile,
nume de funcţii (apel de funcţie)
Operatorii = simboluri ce determină modul de prelucrare al operanzilor
Evaluarea expresiilor se face în conformitate cu ordinea de priorităţi,
modul de asociere şi a regulilor de evaluare.
Opertatori. Operatori de atribuire.

Operatori de atribuire
Operatorul simplu (standard) =

Sintaxa: nume_variabilă = expresie ;

• Operator binar: operand_stang = operand_drept

• Se evalueaza de la dreapta la stanga: se evalueaza mai intai
opernadul drept care apoi este transferat in operandul drept
• In urma efectuarii operatiei de atribuire se intoarce (return) ca
raspuns rezultatul transferat din drepta in stanga. Din acest motiv se
poate realiza operatie de atribuire multipla

var_1 = var_2 = . . . = var_n = expresie ;

Ex.: a = b = c = 5; echivalent cu: c=5; b=c; a=b;
a1 = cv3 = asd + 5*sd;
Opertatori. Operatori de atribuire.

Operatori de atribuire compusi op =

Sintaxa: nume_var op = expresie ;

Echivalent cu: nume_var = nume_var op expresie ;

în care op este unul dintre operatorii binari:

• multiplicativi: * , / , %
• aditivi: + , -
• de deplasare: >> , <<
• de modificare la nivel de bit: & , | , ^
Opertatori. Operatori de atribuire.

Operatori de atribuire compusi op =

Operator Exemplu Echivalent Rezultat

*= a*=5 a=a*5 250
/= a/=10 5
%= a%=3 2
+= a+=13 63
-= a-=7 43
>>= a>>=3 6
<<= a<<=1 100
&= a&=15 2
|= a|=12 62
^= a^=5 55
Opertatori. Operatori relationali

Operatori relationali

• Operatorii relaţionali sunt folosiţi pentru a determina relaţia de

ordonare între doua expresii.
• Rezultatul obţinut prin aplicarea acestor operatori este tip logic
(boolean): adevărat (true) sau fals (false), conform regulii:
– valoarea 0 (zero) reprezintă valoarea logică fals
– orice valoare diferită de zero corespunde valorii logice
adevărat.

Operatorii relaţionali: Sintaxa:

> mai mare expresie_1 > expresie_2
< mai mic expresie_1 < expresie_2
>= mai mare sau egal expresie_1 >= expresie_2
<= mai mic sau egal expresie_1 <= expresie_2
Opertatori. Operatori relationali

Operatorii relaţionali: Sintaxa:

> mai mare expresie_1 > expresie_2
< mai mic expresie_1 < expresie_2
>= mai mare sau egal expresie_1 >= expresie_2
<= mai mic sau egal expresie_1 <= expresie_2

Exemplu:
(x+3)<5 dacă x=1 valoarea întoarsă este adevărat (true)
dacă x=4 valoarea întoarsă este fals (false)

Tema:
Sa se evalueze: x + 3 < 5
Opertatori. Operatori de egalitate

Operatoratori de egalitate (logica)

• Sunt folosiţi pentru a determina daca doua expresii au rezultat egal s

• au diferit.
• Rezultatul obţinut prin aplicarea acestor operatori este tip logic
(boolean): adevărat (true) sau fals (false).
• Operatorii de egalitate: Sintaxa:
= = egalitate expresie_1 = = expresie_2
!= diferit expresie_1 != expresie_2

Ex.: (x%3)==2 dacă x=5 rezultatul este adevărat (true)

dacă x=1 rezultatul este fals (false)
Opertatori. Operatori logici

Operatoratori logici

• Operatori pentru prelucrarea valorilor (operanzi, expresii)

logice.
• Rezultatul obţinut este de tip logic (boolean): adevărat (true) sau
fals (false).

Operator unar: evaluare dreapta-stânga, adică se aplică operandului

din dreapta:

! negare (inversarea valorii logice) !expresie

Exemplu:
int a=5, b=7;
bool t = !(a<7);
Opertatori. Operatori logici

Operatori binari, evaluare stânga-dreapta

|| SAU expresie_1 || expresie_2

Exemplu: ((x+5)<3)||(x>3)
dacă x=3 răspunsul este fals (false)
dacă x=5 răspunsul este adevărat (true)
dacă x=-4 răspunsul este adevărat (true)

Tema:
int a=5,b=7;
boole t;
t = ((a+=7)&3)||(b==8);
cout << a << b << t << endl;
Opertatori. Operatori logici

Operatori binari, evaluare stânga-dreapta

&& SI expresie_1 && expresie_2

Exemplu: ((x+5)<3)&&(x<3)
dacă x=3 răspunsul este fals (false)
dacă x=-3 răspunsul este adevărat (true)
dacă x=-4 răspunsul este adevărat (true)
Tema:
int a=5,b=7;
boole t;
t = ((a^=7)&3)&&(!(b+8))||(a=9);
cout << a << b << t << endl;
Opertatori. Operatori logici

Operatori binari, evaluare stânga-dreapta

Operatorii logici binari: && şi ||, NU realizează evaluarea tuturor

expresiilor (operanzilor) asupra cărora acţionează,
ci evaluază operanzii în ordine apariţiei, de la stanga la dreapta, până
când se întâlneşte primul rezultat care determină rezultatul final,
expresiile care urmează NU mai sunt evaluate.

Mai exact:
• pentru && evaluarea se face până la prima expresie care are valoare
fals => răspunsul final fiind automat fals.
• pentru || evaluarea se face până la primul rezultat adevarat, =>
rezultatul final luând valoarea adevarat.
Opertatori. Operatori logici

Operatori binari, evaluare stânga-dreapta

Exemplu:

int a,b,c;
a=b=10;
c=(a=0)&&(b=1)&&(a=2);
cout<<a<<b<<c<<endl;
Opertatori. Operatori de incrementare/decrementare

Operatori de incrementare/decrementare

Operatori unari, pot fi prefixati si postfixati (sufixati)

++ incrementare a++ sau ++a rezultatul final a = a+1

-- decrementare a-- sau --a rezultatul final a = a-1

Opertatori. Operatori de incrementare/decrementare

Operatori de incrementare/decrementare

Mod de prelucrare
operaţie postfixata (sufixate):
• valoarea operandului este mai întâi folosită în prelucrare (cu
valoarea curenta),
• iar apoi este incrementată / decrementată.

Exemplu:
int a=10,x;
x=a++; /* echivalent cu:
x=a;
a=a+1; */
cout<<a<<x<<endl;
Opertatori. Operatori de incrementare/decrementare

Operatori de incrementare/decrementare

Mod de prelucrare
operaţie prefixata:
• valoarea operandului este mai întâi incrementată / decrementată,
• iar apoi este folosită în prelucrare (cu noua valoarea).

Exemplu:
int a=10,x;
x=--a; /* echivalent cu:
a=a-1;
x=a; */
cout<<a<<x<<endl;
Opertatori. Operatori de incrementare/decrementare

Operatori de incrementare/decrementare

Tema 1:
int a=10;
cout<<a++<<endl;
cout<<++a<<endl;

Tema 2:
int x,a=10;
x= ++a--;
cout<<a<<endl<<x<<end;
Opertatori. Operatorul conditional

Operatorul conditional ?:

Operator ternar, evaluare stanga-dreapta

Sintaxa:
expresie_condiţie ? expresie_1 : expresie_2;

Echivalent:
dacă expresie_condiţie este adevărată
atunci
execută expresia_1
altfel
execută expresia_2
Opertatori. Operatorul conditional

Operatorul conditional ?:

Exemplu:

float a=123.56, b=-12.6;

cout<<”Modulul numarului ”<<a<<” = ”<< a>0?a:-a;
cout<<”Modulul numarului ”<<b<<” = ”<< b>0?b:-b;
Opertatori. Operatorul virgula

Operatorul virgula ,

Se foloseste la concatenarea a doua (sau mai multe) instructiuni, in

general acolo unde sintaxa ne obliga sa folosim numai una singura.

Exemplu: Introducerea mai multor experesii in interiorul operatorului

conditional ?:

Sintaxa:
expresie_conditie ? expresie1[, expresie2]:expresie4[, expresie5]

int a=5, b;
b = a>0?a,a++:-a,a--;
Opertatori. Operatorul sizeof

Operatorul sizeof

Se foloseste pentru determinarea dimensiunii unei date sau tip de data

Sintaxa:
sizeof(nume_variabila)
sizeof(nume_tip_data)

Exemplu:
int a=5;
cout<<”Dim. var. a este:” << sizeof(a) << endl;
cout <<”Dim. float:” << sizeof(float) << endl;
Opertatori. Operatorul cast

Operatorul cast

Se foloseste pentru converisa fortata (explicita) a tipului de date

corespunzator unei variabile
Sintaxa:
(nume_tip_data)nume_variabila
Exemplu:
int a=5, b=2;
float c;
c = (float)a/b;

Tema: Ce afiseaza blocul de instuctiuni?

float a=5.5,b=2.0,c;
c = (int)a/b;
cout << c << endl;
Opertatori. Reguli de conversie implicita

Reguli de conversie implicita.

A. Conversia de tip in evaluarea expresiilor

Cand o expresie conţine operanzi de tipuri diferite, se realizeaza o

operatie de cast (morificare de tip) automata (implicita), care are
ca scop aducerea operanzilor la acelasi tip.

Regula generală de conversie a tipului în evaluarea expresiilor:

tipurile mai mici (simple) sunt promovate către cele mai largi
(complexe), care dictează şi tipul rezultatul operaţiei

Observatie: In general, tipul char este transformat automat la

evaluare în tipul int. Sunt compilatoare la care si datele de tip
float sunt convertite în double
Opertatori. Reguli de conversie implicita

Reguli de conversie implicita.

A. Conversia de tip in evaluarea expresiilor
Ordinea de conversie: long double

Dimensiune

Sensul de promovare
double
float
unsigned long long
long long
unsigned long
long
unsigned int
int

Tema: Ce afiseaza blocul de instructiuni?

unsigned int a=210;
int b=-120;
int c;
c=a+b;
cout<<c<<endl;
Opertatori. Reguli de conversie implicita

Reguli de conversie implicita.

A. Conversia de tip in operatii de atribuire

În operaţiile de atribuire în care tipul operandului stânga diferă de cel

obţinut prin evaluarea expresiei membru-dreapt se face o conversie
automată a tipului din dreapta în tipul variabilei din stânga.

Dacă tipul din stânga este mai larg decât cel din dreapta, atunci în
procesul de atribuire NU se obţin erori.
În caz contrar, se obţine o pierdere de informaţie (trunchiere).