Adaptado de

cba
 count++

-x
a+b
0 if b == 0 else a / b

(a maioria das linguagens funcionais usa notação infixa)

inf a + b
x = ( a ( 10 2 *) + ) pre (+ a b)
pos (a b +)
• Em Visual Basic, Fortram, Ruby, Ada há operador de exponenciação. Este tem
precedência mais alta. No caso de subtração unária:

- A ** B
é equivalente
-(A**B)

a + (- b) *c
count++
++count
!x
 notação prefixa

(exige o uso de agrupamento por parênteses)

//erro
A ** B ** C
A×B+C
(da mesma forma como ocorre na matemática)

(A + B) * C
 Exemplo C:
Teste para evitar a divisão por zero
res = (b == 0) ? 0 : a / b;
x = 0 if (b == 0) else (a / b)
if (b==0){
res = 0;
} else {
res = a / b;
}
 (só depois é possível usar como operando)

x = 10 + f(a)
a = 5;
x = 10 + a + f(a);

f(a){
a = 30;
}
(no caso do C, poderia ser proibindo o
uso de variáveis globais em funções)
result1 = (fun(a) + b) / (fun(a) - c);
temp = fun(a);
result2 = (temp + b) / (temp - c);
• A mais importante é que sua semântica é muito mais fácil de entender do que
a dos não transparentes referencialmente.

• Ser transparente referencialmente torna uma função equivalente a uma

função matemática, em termos de facilidade de entendimento.
 e em algumas
linguagens para concatenação de cadeias

, duas operações totalmente diferentes

A instrução x = &y pode ser um erro para x = 67 & y, por exemplo

float x;
int y;

float res = x + y
 A : Integer;
B, C, D : Float;
...
C := B * A;

influenciando na confiabilidade

• A questão é se os programadores devem se preocupar com essa

categoria de erros ou se o compilador deve detectá-los.
 quando houver mudança significativa no valor

• Python: float(angle)
, resultando em um valor booleano
int x, y, z;
x = 3;
y = 2;
z = 1;
printf("%d", (x > y > z));
• Esse atalho é difícil de ser detectado em expressões aritméticas, então ele
nunca é tomado
 (a >= 0) && (b < 10)
caso seja FALSE && (c<10)
não é preciso analisar o restante

aqui é feito um
acesso fora da faixa

• Todos os operadores lógicos de Ruby, Perl e Python são

avaliados em curto-circuito.
if (x = 10){
...
}
 count = count + 1; e neste caso?
x = ++count x = count;
x = count++ - count ++
x = count;
count = count + 1;
- (count++)
 if (x = 10){
...
}
if (x ==10){
}

• Nesses casos, a precedência do operador de atribuição é menor do que dos

operadores relacionais, por isso é preciso usar parênteses. Caso não seja
delimitado com parênteses, o resultado da comparação seria guardado
em ch
• Pode haver efeito colateral: expressões difíceis de serem lidas e entendidas

a = b + (c = d / b) - 1 x = cont = 0;
• Perl
($first, $second, $third) = (20, 40, 60);

($first, $second) = ($second, $first);

 (ex: um valor int pode ser atribuído a uma
variável float, mas não o contrário)
• Não permitir metade das possíveis atribuições de modo misto é uma
maneira simples, mas efetiva, de aumentar a confiabilidade de Java e C#
em relação a C e C++
• Ada não permite atribuições de modo misto