UF1 – PROGRAMACIÓ ESTRUCTURADA

CURS 2013-14

A01 2.-OPERADORS I EXPRESSIONS

Operadors aritmètics
Operador Ús Operació

B + A+B Suma
i - A–B Resta
n
a * A*B Multiplicació
r
i / A/B Divisió
s
% A%B Resta d’una divisió sencera (mòdul)
U ++ ++A Increment
n
a -- --A Decrement
r
+ +A Signe positiu
i
s - -A Signe negatiu
Exemples d’operadors aritmètics
int x = 14;
int y = 8;
int resultat1 = x + y; // resultat1 = 22
int resultat2 = x – y; // resultat2 = 6
int resultat3 = x * y; // resultat3 = 112
int resultat4 = x / y; // resultat4 = 1
int resultat5 = x % y; // resultat5 = 6
int resultat6 = -y + x; // resultat6 = 6
int resultat7 = --y; // resultat7 = 7, y = 7
int resultat8 = ++x; // resultat8 = 15, x = 15

double a = 8.5;
double b = 3.4;
double resultat9 = a + b; // resultat9 = 11.9
double resultat10 = a - b; // resultat10 = 5.1
double resultat11 = a * b; // resultat11 = 28.90
double resultat12 = a / b; // resultat12 = 2.5
double resultat13 = a % b; // resultat13 = 1.7
double resultat14 = -a + b; // resultat14 = -5.1
double resultat15 = --a; // resultat15 = 7.5
double resultat16 = ++b; // resultat16 = 4.4
Operadors relacionals

Operador Ús Operació
== A==B A igual a B
!= A!=B A diferent a B
> A>B A més gran que B
< A<B A més petit que B
>= A>=B A més gran o igual que B
<= A<=B A més petit o igual que B
Exemples d’operadors relacionals
descomptePercent == 2.3 // igual a un número
lletra == ‘y’ // igual a un char
esValid == false // igual al valor false (fals)

subtotal != 0 // no igual a un número

anys > 0 // més gran que un número

i < mesos // més petit que una variable

subtotal >= 500 // més gran o igual a un número

quantitat <= puntComanda // més petit o igual que una variable

esValid // esValid es igual a true (vertader)

!esValid // esValid es igual a false (fals)
Operadors lògics

Operador Ús Operació
&& A&&B A AND B

|| A||B A OR B

! !A Not A
Operadors lògics - Valors

A B A and B A B A or B
true true true true true true
true false false true false true
false true false false true true
false false false false false false

A A!
true false
false true
Exemples d’operadors booleans
int m = 2, n = 5; // Definició de les variables;
boolean res;

res = m > n && m >= n; // m > n => 2 és més gran que 5? No! => false
// m >= n => 2 és més gran o igual que 5? No! => false
// res = m > n && m >= n serà:
// res = false && false
// per tant...
// res = false

res = !(m > n && m >= n); // Sabem que (m > n && m >= n) és false, per tant l’operació
// de negació d’aquesta expressió amb l’operand ! serà true.

res = m < n || m != n; // m < n => 2 és més petit que 5? Si! => true
// m != n => 2 és diferent a 5? Si! => true
// res = m < n || m != n serà:
// res = true || true
// per tant...
// res = true

res = !(m < n || m != n); // Sabem que (m < n || m != n) és true, per tant l’operació
// de negació d’aquesta expressió amb l’operand ! serà false.
Operadors - Precedència

 Les normes de precedència i els parèntesis determinen l’ordre

de les operacions.

 Quan l’ordinador ha de decidir quina de les operacions ha

d’executar primer i l’ordre no està dictaminat per parèntesis,
començarà a executar l’operació amb la prioritat més alta i
després executarà la de prioritat més baixa.

 Alguns operadors tenen la mateixa precedència, així doncs

s’executarà primer segons apareguin en l’expressió.
Operadors binaris d’igual precedència s’executen d’esquerra
a dreta. Operadors unitaris de dreta a esquerra.
Operadors - Precedència

Prioritat més alta

Primer: els operadors unitaris +, -, !, ++, i –

Segon: els operadors aritmètics *, /, i %
Tercer: els operadors aritmètics + i –

Prioritat més baixa

Exemples de precedència
int resultat = 2 + 3 * 4 // resultat = 14

// Primer fa la multiplicació 3 * 4 = 12, i,

// després, a aquest resultat 12 li sumarà 2

int resultat = (2 + 3) * 4 // resultat = 20

// La suma entre parèntesis va primer, i, després

// el resultat d’aquesta suma, 5, serà multiplicat
// per 4.
int resultat = 2 * (3 + (4 * 5)) // resultat = 46

// Quan hi ha més d’un parèntesis, es començarà el

// càlcul des del parèntesis que hi ha més a
// l’interior de l’expressió. Per tant, primer,
// calcularà 4 * 5 que serà 20, i després li sumarà
// 3 que donarà com a resultat 23. Finalment,aquest
// valor serà multiplicat per 2.
int resultat = 25 / 8 * 3 // resultat = 9

// Primer 25 serà dividit entre 8. El resultat serà

// 3 perquè és de tipus int. Llavors 3 es multipli-
// carà per 3 donant com a resultat 9.