1. Categorii de operatori:
- Aritmetici
- Binari
- Logici
- Relationali
- Operatori pentru situatii speciale: indexare masiv, acces la mebrii claselor, expresii lambda.
2. Operatorii aritmetici:
| + | adunare |
| - | scadere, minus unar |
| * | inmultire |
| / | impratire |
| % | impartirea modulo |
| -- | decrement |
| ++ | increment |
Operatorul % se poate folosi si la date de tip double. Ex.:
//-------------------------------------------------------------------------------------
using System;
namespace Exercitii
{
class Program
{
static void Main(string[] args)
{
int iresult, irem;
double dresult, drem;
iresult = 10 / 3;
irem = 10 % 3;
dresult = 10.0 / 3.0;
drem = 10.0 % 3.0;
Console.WriteLine("Rezultatul impartirii 10/3 = \n = " +
iresult + "\n restul: " + irem);
Console.WriteLine("Rezultat si restul impartirii 10.0/3.0 = \n = " +
dresult + "\n restul: " + drem);
Console.ReadKey(true);
}
}
}
3. Operatorii increment(++) si decrement (--):
- Incrementul mareste operandul cu 1, decrementul micsoreaza operandul cu 1.
- Ambii pot fi indicati in forma prefixata (++x) si postfixata(x++).
- Cind operatorii sunt prefixati rezultatul operatiei este valoarea operandului dupa incrementare/decrementare.
- Cind operatorii sunt postfixatii rezultatul operatiei este valoarea operandului inainte incrementare/decrementare.
Exemplu:
//------------------------------------------------------
using System;
namespace PrePostDemo
{
class Program
{
static void Main(string[] args)
{
int x, y;
int i;
x = 1;
y = 0;
Console.WriteLine("x initial = " + x + "\ny initial este = " + y);
Console.WriteLine("Sirul de numere obtinut" +
"prin intermediul expresiei y = y + x++;");
for (i = 0; i < 10; i++) {
y = y + x++; // forma postfixata al operatorului ++
Console.Write(y + " ");
}
Console.WriteLine();
x = 1;
y = 0;
Console.WriteLine("Sirul de numere obtinut " +
"prin intermediul expresiei y = y + ++x;");
for (i = 0; i < 10 ; i++) {
y = y + ++x; //forma prefixata al operatorului ++
Console.Write(y + " ");
}
Console.ReadKey(true);
}
}
}
4. Operatorii logici si relationali:
| == | egal cu |
| != | diferit de |
| > | mai mare |
| < | mai mic |
| >= | egal sau mai mare |
| <= | mai mic sau egal |
| & | SI |
| | | SAU |
| ^ | SAU exclusiv |
| && | SI logic |
| || | SAU logic |
| ! | negatie logica |
- Rezultatul executarii operatorilor relationali sau logici sunt valorile logice de tip bool.
| p | q | p & q | p | q | p ^ q | !p |
| false | false | false | false | false | true |
| true | false | false | true | true | false |
| false | true | false | true | true | true |
| true | true | true | true | false | false |
Exemplu:
//------------------------------------------------------
using System;
namespace RelLogops
{
class Program
{
static void Main(string[] args)
{
int i, j;
bool b1, b2;
i = 10;
j = 11;
if (i < j) Console.WriteLine("i < j");
if (i <= j) Console.WriteLine("i <= j");
if (i != j) Console.WriteLine("i != j");
if (i == j) Console.WriteLine("Nu se poate executa");
if (i >= j) Console.WriteLine("Nu se poate executa");
if (i > j) Console.WriteLine("Nu se poate executa");
b1 = true;
b2 = false;
if (b1 & b2) Console.WriteLine("Nu se poate executa");
if (!(b1 & b2)) Console.WriteLine("!(b1 & b2)");
if (b1 | b2) Console.WriteLine("b1 | b2 - true");
if (b1 ^ b2) Console.WriteLine("b1 ^ b2 - true");
Console.ReadKey(true);
}
}
}
4. Implicatia:
- Operatie binara, rezultatul careia este fals doar atunci cind operandul string are valoarea adevarat, iar cel drept - fals
| p | q | rezultat implicatie p si q |
| true | true | true |
| true | false | false |
| false | false | true |
| false | true | true |
- Implicatia se poate obtine prin combinarea operatorilor logici ! si | ( !p | q).
Exemplu:
//------------------------------------------------------
//Implicatia in C#
using System;
namespace Implication
{
class Program
{
static void Main(string[] args)
{
bool p = false, q = false;
int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
if (i == 0) p = true;
if (i == 1) p = false;
if (j == 0) q = true;
if (j == 1) q = false;
Console.WriteLine(" p este " + p + " q, este " + q);
if (!p | q)
Console.WriteLine(" Rezultatul implicatiei " + p +
" si " + q + " este " + true);
else
Console.WriteLine(" Rezultatul implicatiei " + p +
" si " + q + " este " + false);
Console.WriteLine();
}
}
Console.ReadKey(true);
}
}
}
5. Operatorii logici conditionali:
- Operatia SI se executa cu operatorul && (corespunde cu &)
- Operatia SAU se executa cu operatorul || (corespunde cu ||)
- Specificul operatorilor conditionali este ca al doilea operand se verifica doar daca este necesar.
Exemplu:
//------------------------------------------------------
//Operatorii logici conditionali
using System;
namespace SCops
{
class Program
{
static void Main(string[] args)
{
int n, d;
n = 10;
d = 2;
if (d != 0 && (n % d) == 0)
Console.WriteLine(n + " se imparte fara rest la " + d);
d = 0; //atribuie valoare 0 variabilei d
// d este agal cu zero, deaceia al doilea operand nu se verifica
// si nu se afiseaza numic
if(d != 0 && (n % d) == 0)
Console.WriteLine(n + " se imparte fara rest la " + d);
//daca vom face acelasi lucru fara operatorul conditional va aparea eroare din cauza impartiri la zero
// if(d != 0 & (n % d) == 0)
// Console.WriteLine(n + " se imparte fara rest la " + d);
Console.ReadKey(true);
}
}
}
- Cind trebuie sa se verifice ambii operanzi ne folosim de operatorii logici & si |
Exemplu:
//----------------------------------------------
// necesitatea efectelor secundare al operatorilor
// logici & si |
using System;
namespace SideEffects
{
class Program
{
static void Main(string[] args)
{
int i;
bool someCondition = false;
i = 0;
//valoarea variabilei i se incrementeaza
//chiar daca if nu se executa
if (someCondition & (++i < 100))
Console.WriteLine(" nu se afiseaza ");
Console.WriteLine("Operatorul if se executa: " + i); //se afiseaza 1
// in aceasta situatie valoarea variabilei i nu se incremenreaza
//deoarece incrementul in acest caz se omite
i = 0;
if(someCondition && (++i < 100))
Console.WriteLine(" nu se afiseaza ");
Console.WriteLine("Operatorul if nu se executa: " + i); //se afiseaza 0
Console.ReadKey(true);
}
}
}
Se observa ca in primul operator if expresiile din ambele parti se verifica indiferent de valoarea obtinuta, in al doilea if se verifica doar expresia din stinga (someCondition = false),si deaceia expresia din dreapta nu se mai verifica.
6. Operatorul de atribuire:
- nume_variabila = expresie
- Se poate de creat un lant de atribuiri
EX.:
int x, y, z;
x = y = z = 100; //se atribuie valoarea 100 la toate variabilele
7. Operatori de atribuire compusi:
x = x + 10; => x+= 10;
x = x - 100; => x -= 100;
| += | -= | *= | /= |
| %= | &= | |= | ^= |
8. Operatori pe biti
- Se folosesc daor la tipuri de date intregi
| & | SI pe biti |
| | | SAU pe biti |
| ^ | SAU EXCLUSIV pe biti |
| >> | deplasare la drepta |
| << | deplasare la stinga |
| ~ | operatorul unar NU (negatia) |
9. Operatori pe biti SI, SAU, excluziv SAU si NU
SI - &
SAU - |
excluziv SAU - ^
excluziv NU - ~
- Actoneaza la nivel de biti
| p | q | p & q | p | q | p ^ q | ~p |
| 0 | 0 | 0 | 0 | 0 | 1 |
| 1 | 0 | 0 | 1 | 1 | 0 |
| 0 | 1 | 0 | 1 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 | 0 |
Exemplu cu operatorul & (transformarea numerelor impare in numere pare)
//----------------------------------------------
//Operatorul & (SI), pentru a transforma numarul din impar in par
using System;
namespace MakeEven
{
class Program
{
static void Main(string[] args)
{
ushort num;
ushort i;
for (i = 1; i <= 10; i++) {
num = i;
Console.WriteLine(" num: " + num);
num = (ushort)(num & 0xFFFE); // 0xFFFE = 1111 1111 1111 1110 = 65534
Console.WriteLine(" num dupa prelucrarea bitului inferior: "
+ num + "\n");
}
Console.ReadKey(true);
}
}
}
Valoarea hexazecimala 0xFFFE folosita in operatorul pe biti & (SI), are urmatoarea forma binara: 1111 1111 1111 1110. In asa fel operatia & (SI) lasa neschimbati toti bitii variabilei num, in afara de bitul cel mai inferior, care se stabileste in 0 (zero). In rezultat numerele pare nu suporta modificari, iar cele impare se micsoreaza cu 1 devenid astfel pare.
- Operatorul & (SI) este comod de folosit pentru a determina starea (1 sau 0) unui bit luat individual:
Exemplu:
//----------------------------------------------
//Operatorul & (SI), pentru a stabili daca numarul este impar
using System;
namespace IsOdd
{
class Program
{
static void Main(string[] args)
{
ushort num;
num = 10;
if ((num & 1) == 1)
Console.WriteLine(" nu se afiseaza. ");
num = 11;
if ((num & 1) == 1)
Console.WriteLine(num + " - numar impar.");
Console.ReadKey(true);
}
}
}
In primul if se produce urmatoarea operatie:
1 0 1 0
0 0 0 1
&
-----------------
0 0 0 0
In al doilea if se produce urmatoarea operatie:
1 0 1 1
0 0 0 1
&
-----------------
0 0 0 1
- Cu proprietatea de a verifica bitii individual operatorul & (SI) se poate de folosit la scrierea de programe, in care bitii valorii de tip byte se afizeaza in forma binara
Exemplu:
//----------------------------------------------
//prezentare bitii, care compun byte-ul
using System;
namespace ShowBits
{
class Program
{
static void Main(string[] args)
{
int t;
byte val;
val = 123;
for (t = 128; t > 0; t = t / 2) {
if ((val & t) != 0) Console.Write("1 ");
if ((val & t) == 0) Console.Write("0 ");
}
Console.ReadKey(true);
}
}
}
- In ciclul for fiecare bit al variabilei val este verificat cu ajutorul operatorului & (SI), pentru a stabili daca este 1 sau 0, respectiv se afiseaza 1 sau 0.
- Operatorul | (SAU) este folosit pentru setarea bitilor individual. Daca oricare bit dintr-un operator avre valoare 1, atunci se va seta 1 si pe bitul corespunzator al altui operand
1101 0011
1010 1010
|
--------------
1111 1011
Exemplu: Numere impare in numere pare:
//----------------------------------------------
//Exemplu cu operatorul SAU, transforma numerel in impare
using System;
namespace MakeOdd
{
class Program
{
static void Main(string[] args)
{
ushort num;
ushort i;
for (i = 1; i <= 10; i++) {
num = i;
Console.WriteLine("num: " + num);
num = (ushort)(num | 1);
Console.WriteLine("num dupa setarea bitului inferior: " +
num + "\n");
}
Console.ReadKey(true);
}
}
}
- Operatorul ^ (SAU Excluziv) seteaza bitul cu valoarea 1 doar atunci cind bitii operanzilor sunt diferiti:
0111 1111
1011 1001
^
---------------
1100 0110
- Daca executam pentru inceput R1 = X^Y, apoi R2 = R1^Y, atunci R2 devine egal cu X. Aceasta proprietate se poate de folosit intro programa simpla de codificare, in care un intreg este folosit in calitate de cheie pentru codificare si decodificare a mesajelor.
Exemplu: operatorul ^:
//----------------------------------------------
//Exemplu cu operatorul SAU exclusiv
using System;
namespace Encode
{
class Program
{
static void Main(string[] args)
{
char ch1 = 'H';
char ch2 = 'i';
char ch3 = '!';
int key = 88;
Console.WriteLine("Mesajul initial :" + ch1 + ch2 + ch3);
//codificare mesaj
ch1 = (char) (ch1 ^ key);
ch2 = (char) (ch2 ^ key);
ch3 = (char) (ch3 ^ key);
Console.WriteLine("Mesajul codificat: " + ch1 + ch2 + ch3);
//decodificare mesaj
ch1 = (char)(ch1 ^ key);
ch2 = (char)(ch2 ^ key);
ch3 = (char)(ch3 ^ key);
Console.WriteLine("Mesajul decodificat: " + ch1 + ch2 + ch3);
Console.ReadKey(true);
}
}
}
- Operatorul ~ (NU) seteaza toti bitii cu valoarea inversa
Exemplu: operatorul ~:
//----------------------------------------------
//Exemplu cu operatorul NU
using System;
namespace NotDemo
{
class Program
{
static void Main(string[] args)
{
sbyte b = -34;
for (int t = 128; t > 0; t = t / 2) {
if ((b & t) != 0) Console.Write("1 ");
if ((b & t) == 0) Console.Write("0 ");
}
Console.WriteLine();
//inversare valori biti
b = (sbyte) ~b;
for (int t = 128; t > 0; t = t / 2)
{
if ((b & t) != 0) Console.Write("1 ");
if ((b & t) == 0) Console.Write("0 ");
}
Console.ReadKey(true);
}
}
}
10. Operatori de deplasare
- Deplasare biti ai intrgilor la stinga (<<) sau la dreapta (>>).
- La deplasare la stinga bitul inferior se seteaza pe zero
- La deplsarare la dreapta, daca intrgul este fara semn bitul superior se seteaza pe zero, daca este cu semn atunci bitul semnului se pastreaza.
- Deplsarea nu este ciclica: bitii respectivi se pierd.
Exemplu: << si >>:
//----------------------------------------------
using System;
namespace ShifttDemo
{
class Program
{
static void Main(string[] args)
{
int val = 1;
for (int i = 0; i < 8; i++) {
for (int t = 128; t > 0; t = t / 2) {
if ((val & t) != 0) Console.Write("1 ");
if ((val & t) == 0) Console.Write("0 ");
}
Console.WriteLine();
val = val << 1; // deplasare la stinga
}
Console.WriteLine();
val = 128;
for (int i = 0; i < 8; i++)
{
for (int t = 128; t > 0; t = t / 2)
{
if ((val & t) != 0) Console.Write("1 ");
if ((val & t) == 0) Console.Write("0 ");
}
Console.WriteLine();
val = val >> 1; // deplasare la dreapta
}
Console.ReadKey(true);
}
}
}
- La deplsarea la dreapta intrgul se dubleaza, iar la stinga se injumatateste. Acest lucru este valabil atita timp cit nu se perd bitii.
Exemplu:
//----------------------------------------------
using System;
namespace MultDiv
{
class Program
{
static void Main(string[] args)
{
int n = 10;
Console.WriteLine("Valoarea variabilei n: " + n);
//inmultit la 2
n = n << 1;
Console.WriteLine("Valoarea varabilei n dupa " +
"operatia n = n * 2: " + n);
//inmultit la 4
n = n << 2;
Console.WriteLine("Valoarea varabilei n dupa " +
"operatia n = n * 4: " + n);
//impartit la 2
n = n >> 1;
Console.WriteLine("Valoarea varabilei n dupa " +
"operatia n = n / 2: " + n);
//impartit la 4
n = n >> 2;
Console.WriteLine("Valoarea varabilei n dupa " +
"operatia n = n / 4: " + n);
//instalare varabila in starea initiala
n = 10;
Console.WriteLine("Valoarea variabilei n: " + n);
//inmultit la 2 de 30 ori
n = n << 30; //pierderi de biti
Console.WriteLine("Valoarea variabilei n dupa " +
"deplasarea cu 30 pozitii la stinga: " + n);
Console.ReadKey(true);
}
}
}
- La deplsarea la stinga cu 30 informatia se pierde pentru ca biti au depasit diapazonul tipului int
11. Operatori pe biti cu operatorul atribuire
- Toti operatorii pe biti pot fi folositi in comun cu operatorul de atribuire
x = x ^ 127;
x ^= 127;
12. Operatorul ternar ? :
- Este la fel ca constructioa if-then-else
- expr1 ? expr2 : expr3; -> daca expr1 este adevarata atunci se calculeaza expr2 si rezultatul expr2 este rezultatului intregii expresii ternare. Daca expr1 este falsa, atunci se calculeaza expr3 si rezultatul expr3 este rezultatului intregii expresii ternare.
- absval = val < 0 ? -val : val; // obtinere modul al variabilei val
Exemplu:
//----------------------------------------------
//Exemplu cu operatorul ternar
using System;
namespace NoZeroDiv
{
class Program
{
static void Main(string[] args)
{
int result;
for (int i = -5; i < 6; i++) {
result = i != 0 ? 100 / i : 0;
if (i != 0)
Console.WriteLine("100 / " + i + " = " + result);
}
Console.ReadKey(true);
}
}
}
- In linia result = i != 0 ? 100 / i : 0; variabilei result i se atribuie rezultatul impartirii 100 / i, Impartirea are loc doar daca i != 0, Daca i = 0 variabilei result i se atribuie valoarea zero.
//----------------------------------------------
//Exemplu cu operatorul ternar
using System;
namespace NoZeroDiv2
{
class Program
{
static void Main(string[] args)
{
for (int i = -5; i < 6; i++)
if (i != 0 ? ( i % 2 == 0) : false)
Console.WriteLine("100 / " + i + " = " + 100 / i);
Console.ReadKey(true);
}
}
}
|
100 / -4 = -25 100 / -2 = -50 100 / 2 = 50 100 / 4 = 25 |
- Daca i = 0; atunci if da rezultat false, daca i != 0, atunci if returneaza true cind i este par, si false cind i este impar
13. Spatiile si parantezele rotunde
- Se recomanda de folosit spatii si paranteze pentru marirea lizibilitatii.
x=10/y*(127+x);
x = 10 / y * (127 + x);