Download - expresii - operatori

Transcript

Expresia este o succesiune de operatori și operanzi legați între ei după reguli specifice limbajului.

Operanzii pot fi: - nume de variabile de memorie sau de constante simbolice;- constante; - funcții care returnează un rezultat chiar prin numele lor.

Operatorii sunt simboluri care determina executarea anumitor operații.

Expresia poate să conțină numai un operand(exemplu: constantele literare, variabilele: 11, x, ”succes!”)

Operatorii pot fi: - unari – se aplică pe un singur operand- binari – se aplică pe doi operanzi- ternari – se aplică pe trei operanzi

Tipuri de operanzi:- operatori aritmetici (matematici)- operatori de incrementare și decrementare- operatori relaționali- operatori logici- operatori de atribuire- operatorul virgulă- operatorul condițional- operatorul de conversie explicită- operatorul dimensiune

Precedența operatorilor: există 16 niveluri de prioritate.

Asociativitatea operatorilor: există două tipuri de asociativitate – de la stânga la dreapta și de la dreapta la stânga.

Reguli: - operatorii care au același nivel de prioritate au aceeași asociativitate

- toți operatorii unari au același nivel de prioritate, prioritatea lor fiind mai mare decât a oricărui operator binar sau ternar, iar asociativitatea lor este de la stânga la dreapta.

În funcție de rezultatul obținut în urma evaluării expresilor acestea pot fi:

- expresii matematice (rezultatul este un număr întreg sau real)

- expresii logice (rezultatul este 0 sau 1)- expresii de tip text (rezultatul este un șir de

caractere)- expresii fara tip (contin apelul unor functii care

nu returneaza nici un rezultat)

Există instrucțiunea expresie care are sintaxa: expresie;

Operatorii aritmetici Operatori unari: operatorul minus (-),

operatorul plus (+)- folosiți pentru stabilirea semnului unui operand numeric.Operatori binari:

- de adunare: operatorul pentru adunare (+), operatorul pentru scădere (-)

- de înmulțire: operatorul pentru înmulțire (*), operatorul pentru împărțire (/), operatorul modulo – restul împărțirii (%)

- asociativitate – de la stânga la dreapta- precedența – operatorii unari au prioritate mai mare decât cei

binari, iar pentru cei binari precedența este cea aritmetică

Operatorii aritmeticiObservații:

1. Operatorul / se folosește și pentru împărțirea întreagă, dar și pentru împărțirea reală, rezultatul depinzând de tipul operanzilor, astfel: dacă ambii operanzi sunt de tip întreg, rezultatul va fi de tip întreg (împărțire întreagă); dacă cel puțin unul dintre operanzi este de tip real, rezultatul va fi de tip real (împărțire reală)

Operatorii aritmeticiExemplu:

#include<iostream.h>void main(){int a=10,c=3; float b=10; cout<<a/3; //3 cout<<b/3; //3.333333 cout<<a/c; //3 cout<<a/3.; //3.333333}

Operatorii aritmeticiObservații:

2. Operatorul % NU se poate aplica pe valori numerice reale (pe operanzi de tip float sau double)3. Operatorii / și % se pot folosi pentru a calcula câtul (c) și restul (r) împărțirii a două numere întregi a și b cu semn. c = |a| / |b| r = |a| % |b|

a b a / b a % b> 0 > 0 c r> 0 < 0 - c r< 0 > 0 - c - r< 0 < 0 c - r

Operatorii aritmeticiExemplu:

#include<iostream.h>void main(){int a=7,b=3; cout<<a/b<<‘ ’<<a%b<<endl; //2 1 cout<< a/-b<<‘ ’<<a%-b<<endl; //-2 1 cout<< -a/b<<‘ ’<<-a%b<<endl; //-2 -1 cout<< -a/-b<<‘ ’<<-a%-b<<endl; //2 -1}

Operatorii aritmetici4. Pentru a schimba ordinea implicită de executare a operatorilor matematici dată de prioritatea lor, se pot folosi parantezele rotunde () care au rol de separatori.

Exemplu: #include<iostream.h>void main(){int a=7,b=3; cout<<a+b*2<<‘ ’<<(a+b)*2<<endl;} //13 20

Operatorii aritmetici5. O expresie aritmetică poate conține operanzi numerici de mai multe tipuri.

Dacă a și b sunt operanzi numerici de două tipuri diferite (char și int, int și float), iar c este rezultatul, tipul rezultatului c se va obține prin conversie aritmetică implicită – se face ”promovarea” tipului inferior la tipul superior, rezultatul având tipul superior.

Regulile de conversie aritmetică implicită:a) dacă unul dintre operanzi este de tip long double, și celălalt este convertit în tipul long double, altfel se trece la pasul b);b) dacă unul dintre operanzi este de tip double, și celălalt este convertit în tipul double, altfel se trece la pasul c);c) dacă unul dintre operanzi este de tip float, și celălalt este convertit în tipul float, altfel se trece la pasul d);d) dacă unul dintre operanzi este de tip unsigned long, și celălalt este convertit în tipul unsigned long, altfel se trece la pasul e);e) dacă unul dintre operanzi este de tip long, și celălalt este convertit în tipul long, altfel se trece la pasal f);f) convertește tipurile char, unsigned char și short în tipul int.

Operatorii aritmeticiExemplu:

#include<iostream.h>void main(){float a=1; char b=‘a’; cout<<a+b<<endl; //98 const float PI=3.14; int raza = 2; cout<<“aria= ” <<PI*raza*raza<<endl;}

Operatorul de conversie explicităConversia de tip poate fi forțată să se execute în alt

mod decât cel implicit, folosind operatorul de conversie explicită.

Este un operator unar care precede operandul și are sintaxa:

(tip_dată)unde tip_dată este tipul datei în care se convertește operandul.

Operatorul de conversie explicită de tip nu modifică tipul variabilei de memorie pe care este aplicat. Conversia se face numai în cadrul operației de evaluare a expresiei.

Exemplu: operatorul (int) convertește operandul în tipul int, operandul (float) convertește operandul în tipul float.

Operatorul de conversie explicităExemplu:#include<iostream.h>

void main(){int a=7, b=2; float x=-1.5; cout<<a/b<<” ”<<(float)a/b<<endl; //3 3.5 cout<<x<<‘ ’<<(int)x<<endl; //-1.5 -1 int n=97, m=1; char c=‘a’; float y=-3.5, z=97.5; cout<<m<<“ ”<<(float)m<<endl; //1 1 cout<<(float)n<<“ ”<<(char)n<<endl; //97 a cout<<(int)c<<“ ”<<c<<endl; //97 a cout<<(int)y<<“ ”<<y<<“ ”<<(char)z<<endl; //-3 -3.5 a cout<<1/2+1/3<<‘ ’<< 1/2.+1./3<<‘ ’<< (float)1/2+1/(float)3;}

Operatorii de incrementare și decrementareSunt operatori unari care se aplică pe un operand numeric:

- operatorul de incrementare ++ adună 1 la valoarea operandului (a++ aa+1)

- operatorul de decrementare -- scade 1 la valoarea operandului (a-- aa-1)

Acești operatori pot fi:- prefixați – se aplică înaintea operandului (++a sau

--a) – incrementarea, respectiv decrementarea operandului, se face înaninte ca valoarea operandului să intre în calcul (înainte să fie evaluată expresia)

- postfixați - se aplică după operand (a++ sau a--) – incrementarea, respectiv decrementarea operandului, se face după ce valoarea operandului a intrat în calcul (după ce a fost evaluată expresia)

Operatorii de incrementare și decrementareExemplu:

#include<iostream.h>void main(){int a=1,b=2; cout<<a+++b++<<‘ ’;cout<<a<<‘ ’<<b<<endl; //3 2 3 cout<<++a+(++b)<<‘ ’;cout<<a<<‘ ’<<b<<endl; //7 3 4 cout<<a+b++<<‘ ’;cout<<a<<‘ ’<<b<<endl; //7 3 5 cout<<a+++b--<<‘ ’;cout<<a<<‘ ’<<b<<endl; //8 4 4 cout<<a+++--b<<‘ ’;cout<<a<<‘ ’<<b<<endl; //7 5 3 float x=1.5, y=-2.5; char c=‘a’; cout<<x+++y++<<’ ’;cout<<x<<’ ’<<y<<endl; //-1 2.5 -

1.5 cout<<x--+y--<<‘ ’;cout<<x<<‘ ’<<y<<endl; //1 1.5 -2.5 cout<<++(++c)<<endl; //c}

Operatorii relaționaliSunt operatori binari, iar rezultatul produs este de tip numeric: 0 pentru fals și 1 pentru adevărat.Ei se impart in doua grupe: - operatori relaționali pentru inegalități:

< > <= >=- operatori relaționali petru egalitate:

== (egal) != (diferit)

Operatorii relaționali de inegalitate au prioritate mai mare decât cei de egalitate, iar toți operatorii relaționali au prioritate mai mică decât operatorii aritmetici.Asociativitatea operatorilor relaționali este de la stânga la dreapta.

Operatorii relaționaliExemplu:

#include<iostream.h>void main(){int a=2,b=3; cout<<(a>b)<<‘ ’<<(a<=b)<<endl; //0 1 cout<<(a==b)<<‘ ’<<(a!=b)<<endl;} //0 1

Observație: expresiile relaționale se scriu între paranteze atunci când trebuie afișate deoarece operatorul de ieșire are prioritate mai mare decât operatorii relaționali.

Operatorii logiciExistă trei operatori logici:- operatorul unar pentru negație logică: !- operatorul binar pentru și logic: &&- operatorul binar pentru sau logic: ||

Operatorii logici se aplică pe orice variabilă sau constantă de tip numeric (0 = fals, orice valoare diferită de zero = adevărat) și produc un rezultat numeric: 0 pentru fals și 1 pentru adevărat.Operatorul && are prioritate mai mare decât operatorul ||, iar operatorul de negare !, fiind operator unar, are prioritate mai mare decât operatorii && și ||.Asociativitatea operatorilor logici binari cu același nivel de prioritate este de la stânga la dreapta.

. Operatorii logici au prioritate mai mică decât operatorii relaționali.

Operatorii logiciExemplu:

#include<iostream.h>void main(){float x=2.5; int a=0,b=2,c=3; cout<<(x>0)<<‘ ’<<(!x)<<‘ ’<<(b&&c)<<endl; //1 0 1 cout<<(a&&c)<<(a||c)<<(x&&c)<<endl; //011 cout<<(a&&x)<<(a||x)<<endl;} //01

Operatorii logiciObservații:

- în cazul operatorilor logici binari, al doilea operand nu mai este evaluat dacă primul operand decide valoarea rezultatului:

- operatorul &&: dacă primul operand are valoarea 0, rezultatul este 0 oricare ar fi valoarea celui de-al doilea operand, iar dacă valoarea primului operand este 1, rezultatul depinde de valoarea celui de-al doilea operand (nu se mai evaluează al doilea operand doar atunci când primul are valoarea 0);

- operatorul ||: dacă primul operand are valoarea 1, rezultatul este 1 oricare ar fi valoarea celui de-al doilea operand, iar dacă valoarea primului operand este 0, rezultatul depinde de valoarea celui de-al doilea operand (nu se mai evaluează al doilea operand doar atunci când primul are valoarea 1).

Operatorii logiciExemplu:

#include<iostream.h>void main(){int a=0,b=1; cout<<(a&&b++)<<endl; //0 cout<<b<<endl; //1 cout<<(b||a++)<<endl; //1 cout<<a<<endl;} //0

Operatorii de atribuireOperatorul de atribuire = este un operator binar (a=b) care

atribuie primului operand (a) valoarea celui de-al doilea operand (b).

Construcția a=b este o expresie, rezultatul evaluării ei fiind valoarea primului operand (a).

Operatorul de atribuire are prioritatea mai mică decât toți operatorii prezentați.

Și în cazul operatorului de atribuire acționează conversia implicită de tip, tipul expresiei a=b este dat de tipul primului operand (a).

Există trei moduri în care poate fi folosit operatorul de atribuire:- atribuirea simplă- atribuirea multiplă- atribuirea cu operator

Atribuirea simplă.Primul operand este un nume de variabilă de memorie,

iar al doilea operand este o expresie.

nume_variabilă=expresie;

Mod de execuție:- se evaluează expresia- valoarea obținută se atribuie variabilei de memorie, făcându-se, dacă este cazul, conversia de tip.

Instrucțiunea prin care unei variabile i se atribuie valoarea unei expresii se numește instrucțiune de atribuire.

Atribuirea simplă.Exemplu:

#include<iostream.h>void main(){unsigned x=5,y=2; float a,b,c,d; cout<<(a=5*x/y)<<endl; //12 b=5*(x/y); c=5.*x/y; d=5.*(x/y); cout<<a<<‘ ’<<b<<‘ ’<<c<<‘ ’<<d<<endl;

//12 10 12.5 10a=5*(float)x/y; b=5*((float)x/y); cout<<a<<‘ ’<<b<<endl;} //12.5 12.5

Atribuirea simplă.Tipul expresiei a=b este dat de tipul primului operand (a). Dacă

tipul primului operand este inferior tipului celui de al doilea operand, pot să apară pierderi de date (conversia implicită de tip).

Exemplu: #include<iostream.h>void main(){unsigned a=2000; char c=‘a’; a=c; cout<<a<<endl; //97 a=20; c=a; cout<<(unsigned)c<<endl; //20 a=2000; c=a; a=c; cout<<(unsigned int)c<<‘ ’<<a<<endl;} //65488 65488

Atribuirea simplă.Dacă unei variabile de tip întreg i se atribuie valoarea unei variabile reale, valoarea acesteia este trunchiată.

Exemplu: #include<iostream.h>void main(){int a; float b=1.8, c=-2.7; a=b; cout<<a<<endl; //1 a=c; cout<<a<<endl;} //-2

Atribuirea simplă.Ce afișează următoarele programe:Program1:

#include<iostream.h>void main(){float x; cout<<“x=”;cin>>x; //se citește 0.123 x=x*10; x=(x-(int)x)*10; x=(int)x/10.; cout<<x<<endl;}

Program2: #include<iostream.h>

void main(){int a,b,x; cout<<“a=”;cin>>a; cout<<“b=”; cin>>b; x=a; a=b; b=x; cout<<a<<‘ ’<<b<<endl;}

Atribuirea multiplă.

Deoarece operația de atribuire simplă este o expresie, rezultatul ei poate fi atribuit unei alte variabile de memorie, rezultând o nouă expresie, al cărei rezultat poate fi atribuit unei alte variabile de memorie ș.a.m.d., rezultând o atribuire multiplă, prin care aceeași valoare furnizată de o expresie se atribuie mai multor variabile de memorie identificate prin nume1, nume2, ... numen.

Atribuirea multiplă.nume1=nume2=...=numen-1=numen=expresie;

Mod de execuție:- se evaluează expresia;- valoarea obținută se atribuie variabilei de memorie numen, făcându-se, dacă este cazul, conversia de tip;- conținutul variabiblei numen se atribuie variabilei de memorie identificate cu numen-1, făcându-se, dacă este cazul, conversia de tip;- ș.a.m.d. Până când conținutul variabilei de memorie nume2

se atribuie variabilei de memorie identificate cu nume1, făcându-se, dacă este cazul, conversia de tip.

Atribuirea multiplă.Asociativitatea operatorilor de atribuire este de la dreapta la stânga. Din această cauză, o expresie care foloseste atribuirea multiplă, de genul:

nume1=nume2=...=numen-1=numen=expresie1 =expresie2;este greșită, deoarece rezultatrul unei expresii nu poate fi atribuit

altei expresii.

Exemplu: #include<iostream.h>void main(){unsigned int x,y; float a; a=x=y=5/2; cout<<a<<x<<y<<endl; //2 2 2 a=x=y=5./2; cout<<a<<x<<y<<endl; //2 2 2 x=y=a=5./2; cout<<a<<x<<y<<endl;} //2.5 2 2

Atribuirea cu operatorEste de forma:

nume_variabilă operator=expresie;

unde operator poate fi: +=, -=, *=, /=.Modul de execuție:

- se evaluează expresia;- se aplică operatorul astfel: primul operand este numele variabilei de memorie, iar al doilea operand este valoarea expresiei, dacă este cazul se face conversia de tip (v+=e; v=v+e;);- valoarea obținută se atribuie variabilei de memorie, făcându-se dacă este cazul conversia de tip.

Atribuirea cu operator

Exemplu: #include<iostream.h>void main(){int a=10, b=20, c=30; a+=b+c; cout<<a<<endl; //60 a=10; b=20; c=10; a+=b+=c; cout<<a<<b<<endl;} //40 30

Observație:- se pot folosi atribuiri multiple cu operatori aritmetici

Operatorul condițional (?:)Este singurul operator ternar și are sintaxa:

expresie1 ? expresie2 : expresie3Mod de execuție:

- se evaluează epresie1; - dacă valoarea obținută este diferită de 0

(adevărat), atunci se evaluează expresie2, iar expresie3 va fi ignorată, valoarea furnizată de operator va fi valoarea expresiei expresie2;

- dacă valoarea obținută este de 0 (fals), atunci se evaluează expresie3, iar expresie2 va fi ignorată, valoarea furnizată de operator va fi valoarea expresiei expresie3.

Operatorul condițional (?:)Exemple:1. #include<iostream.h>

void main(){int x; cout<<“x=”; cin>>x; cout<<“modulul: ”<<(x>=0?x:-x)<<endl;}

Operatorul condițional (?:)Observație: Tipul rezultatului va fi determinat prin conversie implicită. Dacă tipul expresiei expresie3 este superior tipului expresiei expresie2, tipul rezultatului este dat de expresie3, chiar dacă se evaluează expresie22. #include<iostream.h>

void main(){int a=3; float b=2; cout<<(a>0?a:b)/2;} //1.5

Operatorul condițional (?:)3. #include<iostream.h>

void main(){int x; cout<<“x=”; cin>>x; cout<<(x%2==0?”par”:”impar”)<<endl;}

4. #include<iostream.h>void main(){float x; cout<<“x=”; cin>>x; cout<<(int(x)==x?”intreg\n”:”nu e intreg\n”);}

Operatorul condițional (?:)5. #include<iostream.h>

void main(){int a,b,c,max; cout<<“a=”; cin>>a; cout<<“b=”; cin>>b;

cout<<“c=”; cin>>c; max=a; max=max<b?b:max; max=max<c?c:max; cout<<“maxim = ”<<max<<endl;}

Operatorul condițional (?:)Observație: Expresia care se evaluează în operatorul condițional poate fi tot un operator condițional, obținându-se structuri alternative simple imbricate.În exemplul următor se citește un caracter, iar dacă este literă mică se transformă în literă mare și invers, dacă nu este literă, rămâne neschimbat.

6. #include<iostream.h> void main(){char c;

cout<<“Dati caracterul: ”; cin>>c; cout<<(c>=’a’&&c<=‘z’?(char)(c-32):

(c>=‘A’&&c<=‘Z’?(char)(c+32):c));}

Operatorul virgulă (,)Operatorul virgulă poate fi folosit pentru construirea unei expresii compuse din mai multe expresii:

expresie1, expresie2, expresie3, .... , expresien

Modul de execuție: - se evaluează expresie1

- se evaluează expresie2

- ș.a.m.d. se evaluează expresien

Rezultatul și tipul rezultatului este dat de valoarea ultimei expresii.Asociativitatea operatorului virgulă este de la stânga la dreapta.Este operatorul cu cea mai mică prioritate.Folosirea acestuia este utilă acolo unde sintaxa nu permite decât o singură expresie și trebuie evaluate mai multe expresii – expresiile sunt legate prin operatorul virgulă, formând o singură expresie.

Operatorul virgulă (,)

Exemplu:1. #include<iostream.h>

void main(){int a=5,b=10; float d,c; c=a=++b, ++a, d=(float)a/b--, ++b; cout<<a<<b<<c<<d<<endl; //12 11 11 1.090909 a=5, b=10; cout<<(c=a=++b, ++a, d=(float)a/b--, ++b)/2;} //5

Operatorul dimensiuneOperatorul dimensiune sizeof este un operator unar. Operandul poate fi o expresie sau un tip de dată.

sizeof(expresie)sizeof(tip_dată)

Rezultatul returnat de acesta reprezintă numărul de octeți utilizați pentru a memora valoarea expresiei sau tipul de dată precizat.Aplicarea operatorului dimensiune pe o expresie nu are ca efect și evaluarea acesteia.

Operatorul dimensiuneExemplu:1. #include<iostream.h>

void main(){int a=5,b=10; float c; cout<<sizeof(int)<<‘ ’<<sizeof(float)<<endl; cout<<sizeof(c*a++)<<sizeof(a/b--)<<endl; cout<<a<<‘ ’<<b<<endl;} //5 10

Operatorii logici pe biţiAcţionează asupra operanzilor de tip întreg şi

execută operaţii logice la nivel de biţi. Operatorii logici pe biţi sunt:

- operatorul unar: ~ operatorul negare pe biţi;- operatori binari: de deplasare >> operatorul pentru deplasarea la dreapta << operatorul pentru deplasarea la stânga

& operatorul pentru ŞI pe biţi ^ operatorul pentru SAU exclusive

pe biţi | operatorul pentru SAU pe biţi

Precedenţa operatorilor logici pe biţi este:

Operatorul unar are prioritate mai mare decât operatorii binari;

Operatorii de deplasare au prioritate mai mare decât ceilalţi operatori binari logici pe biţi ;

Operatorul ŞI (&) pe biţi are prioritate mai mare decât operatorul SAU exclusiv pe biţi (^) care are prioritate mai mare decât operatorul SAU pe biţi (!).

Asociativitatea operatorilor logici pe biţi binari cu acelaşi nivel de prioritate este de la stânga la dreapta.

Operatorii de deplasare au prioritate mai mică decât operatorii aritmetici, dar mai mare decât operatorii relaţionali. Ceilalţi operatori binari logici pe biţi au prioritate mai mică decât operatorii relaţionali, dar mai mare decât operatorii logici.

Operatorii de deplasare

Operatorul de deplasare la stânga a<<n deplasează toţi biţii operandului a cu n poziţii la stânga. Primii n biţi se pierd, iar cele n poziţii rămase libere în dreapta sunt completate cu 0.

Operatorul de deplasare la dreapta a>>n

deplasează toţi biţii operandului a cu n poziţii la dreapta. Ultimii n biţi se pierd, iar cele n poziţii rămase libere în stânga sunt completate cu 0.

Observaţii :

1. Deplasarea a n biţi la dreapta în operandul a este echivalent cu câtul împărţirii operandului a la 2n.

2. Deplasarea a n biţi la stânga în operandul a este echivalentă cu înmulţirea operandului a cu 2n.

3. Pentru a afişa rezultatul operaţiei de deplasare la stânga a<<n, trebuie să încadraţi expresia între paranteze rotunde : corect este cout<<(a<<n) ; şi nu cout<<a<<n ; La fel se procedează pentru afişarea rezultatului operaţiei de deplasare la dreapta a>>n.

Exemplu :

#include<iostream.h>void main(){ int a=60,n=3; cout<<(a>>n)<<endl; // se afişează 7}

a înainte de deplasare a după deplasare 0…0111100 a>>>n 0…0000111

#include<iostream.h>void main(){ int a=15,n=3; cout<<(a<<n)<<endl; // se afişează 120}

a înainte de deplasare a după deplasare 0…0001111 a<<n 0…1111000

Operatorul pentru negare pe biţiOperatorul pentru negare pe biţi ~a neagă fiecare

bit al operandului a, astfel : ~1=0 şi ~0=1Exemplu

#include<iostream.h>void main(){ unsigned int a=0xF2F, b=0x5; cout<<(~a)<<” “<<(~b); // se afişează 61648 65530}

b înainte de negarea pe biţi b după negarea pe biţi 0…0000101 ~b 1…1111010

Operatorul ŞI pe biţi Operatorul ŞI pe biţi a&b aplică operatorul logic ŞI pe perechile de biţi de pe aceiaşi poziţie din cei doi operanzi a şi b: dacă ambii biţi sunt 1, rezultatul este 1, altfel este 0.

Exemplu

#include<iostream.h>void main(){ unsigned int a=0xF2F, b=0x5; cout<<(a&b); // se afişează 5}

a 0…000111100101111b 0…000000000000101a&b 0…000000000000101

Operatorul SAU exclusiv pe biţi

Operatorul SAU exclusiv pe biţi a^b aplică operatorul logic SAU exclusiv pe perechile de biţi de pe aceiaşi poziţie din cei doi operanzi a şi b : dacă ambii biţi au aceiaşi valoare, rezultatul este 0, altefel este 1.

Exemplu

#include<iostream.h>void main(){ unsigned int a=0xF2F, b=0x5; cout<<(a^b); // se afişează 3882}

a 0…000111100101111b 0…000000000000101a^b 0…000111100101010

Operatorul SAU pe biţi

Operatorul SAU pe biţi a|b aplică operatorul logic SAU pe perechile de biţi de pe aceiaşi poziţie din cei doi operanzi a şi b : dacă ambii biţi au vaoarea 0, rezultatul este 0, altefel este 1.

Exemplu

#include<iostream.h>void main(){ unsigned int a=0xF2F, b=0x5; cout<<(a|b); // se afişează 3887}

a 0…000111100101111b 0…000000000000101a|b 0…000111100101111