Neste segundo artigo iremos falar sobre operadores e veremos alguns exemplos de utilização no desenvolvimento de software.

Operadores aritméticos:

Os operadores aritméticos abaixo são usados para efetuar cálculos.
“+” = Adição
“-“ = Subtração
“*” = Multiplicação
“/” = Divisão
“%” = Módulo (resto da divisão)

Exemplo, na declaração de variáveis:
int a = 5;
int b = 15;
int c = 24;
int d = 30;
  
Exemplo das formas de cálculo:
Console.WriteLine (a + b);
Console.WriteLine (d – c);
Console.WriteLine (c * a);
Console.WriteLine (d / b);
Console.WriteLine (c % a);
    
Os resultados dos cálculos acima após a compilação resultarão respectivamente em:
20
6
120
2
4 (Na utilização do módulo o resultado final será o resto da divisão de 24 por 5)

Operadores aritméticos de atribuição reduzida:
+= = Mais igual
-= = Menos igual
*= = Vezes igual
/= = Divisão igual
%= = Módulo igual

int a = 5;

a += 10;

Quanto se executa a expressão acima o Visual Studio interpreta da seguinte forma:
a = a + 10;
a = 15;
    
Podendo ser usado todos os operadores de atribuição acima interpretados da mesma forma.

Operadores incrementais e decrementais:
Estes operadores tem a função de aumentar ou diminuir o valor exato "1" em uma variável.

Incremental (++)

1. Pré-incremental:
Colocado o sinal antes da variável, será somado o valor "1" antes do restante da expressão.
Exemplo:
int x = 10;

Console.WriteLine (“Número inicial” +x);
Console.WriteLine (++x +5); (A ordem será: 10 + 1 = 11 e depois 11 + 5 = 16)
    
Após compilado os resultados serão respectivamente:
Número inicial: 10
16

2. Pós-incremental:
Colocado o sinal depois da variável, será feito o cálculo da expressão e depois a soma do valor "1".

Exemplo:
int x = 10;

Console.WriteLine (“Número inicial” +x);
Console.WriteLine (x++ +5); (A ordem será: 10 + 5 = 15)

Após compilado os resultados serão respectivamente:
Número inicial: 10
15

Decremental (--)

1. Pré-decremental:

Colocado o sinal antes da variável, será subtraído o valor "1" antes do restante da expressão.
Exemplo:
int x = 10;

Console.WriteLine (“Número inicial” +x);
Console.WriteLine (--x +5); (A ordem será: 10 - 1 = 9 e depois 9 + 5 = 14)
    
Após compilado os resultados serão respectivamente:
Número inicial: 10
14

2. Pós-decremental:
Colocado o sinal depois da variável, será feito o cálculo da expressão e depois a subtração do valor "1".
Exemplo:
int x = 10;

Console.WriteLine (“Número inicial” +x);
Console.WriteLine (x++ +5); (A ordem será: 10 + 5)

Após compilado os resultados serão respectivamente:
Número inicial: 10
15

Os operadores citados acima tem maior usabilidade em laços de repetição, que veremos nos próximos artigos publicados.

Operadores relacionais:

== = igual a
!= = Diferente de
> = Maior do que
< = Menor do que
>= = Maior ou igual a
<= = Menor ou igual a

Exemplo:
int a = 5;
int b = 9;
int c = 14;
int d = 9;

Console.WriteLine(b == d);
Console.WriteLine(c != d);
Console.WriteLine(c > d);
Console.WriteLine(d < c);
Console.WriteLine(b <= d);
Console.WriteLine(c >= a);
    
Após compilado os resultados mostrados serão de “True”, pois conforme os operadores acima usados e os valores das variáveis os indicadores são verdadeiros. Estes operadores tem maior usabilidade em condições que veremos nos próximos artigos publicados. (Experimente efetuar a compilação trocando os valores das variáveis e verão que os resultados podem alternar entre “True” ou “False”).

Operadores lógicos:

Os operadores lógicos tem o resultado booleano (true ou false), usados somente em expressões lógicas e são eles:

Exemplo:
&& - AND = Será usado quando todas as expressões tiverem que ser avaliadas como verdadeiras
int a = 10;
int b = 30;
int c = 10;
int d = 25;

Console.WriteLine (a < d) && (b != c);
    
Após compilado o resultado será:
TRUE

|| - OR = Será usado quando somente umas das expressões tiver que ser avaliada como verdadeira.

int a = 10;
int b = 30;
int c = 10;
int d = 25;

Console.WriteLine (a > d) || (b != c);
    
Após compilado o resultado também será:
TRUE - Mesmo a primeira expressão sendo falsa.
! - NOT = Será usado para inverter a lógica de uma expressão.

Console.WriteLine(! (a >= b);
    
Após compilado o resultado será:
TRUE - A expressão (a >= b) teria o resultado de “False”, mas utilizando o operador (! ) o resultado é invertido.

Terminamos por aqui o segundo artigo sobre “operadores” que utilizaremos em nosso próximo artigo sobre condições e laços de repetição.

Conclusão

Este é o segundo de uma série de artigos para iniciantes da linguagem C# deixando aberto a idéias e dúvidas através do e-mail: carlos.andrade@fcamara.com.br.
No próximo artigo iremos aprender sobre condicionais e laços de repetição.

Carlos Eduardo de Andrade, MCTS Web Applications e sócio-coordenador da F|Camara, estuda além da evolução técnica, também a evolução humana.Já trabalhou em muitos projetos e hoje atua como consultor e gerente de projetos.