Uma expressão é formada por operadores e operandos. Os operadores de um expressão indicam qual o tipo de operação deve ser aplicada entre os operandos. Os exemplos mais conhecidos de operadores são os operadores aritméticos: adição (+), subtração (-), multiplicação (*) e divisão (/).

Neste tópico vamos estudar os seguintes tipos de operadores:

• Built-in
• Aritméticos
• Relacionais e Lógicos
• Atribuição (Assignment)

Quanto ao número de operandos os operadores também podem ser classificados em:

• Operadores unários: Este tipo de operador atua sobre um único operando, como por exemplo o sinal de menos (-) para tornar um número negativo, como por exemplo: -5.
• Operadores binários: Atua sobre dois operandos. O exemplo típico são os operadores aritméticos, como por exemplo: 2+3, 5*12.
• Operador ternário: Atuo sobre três operandos. Temos um único operador ternário em C#, que é o ponto-de-interrogação: ? Na verdade é um ponto-de-interrogação metido a if, conforme veremos no exemplo a seguir.

A sintaxe para o operador ? é a seguinte:

(teste) ? valor_se_verdadeiro  : valor_se_falso

Considere o exemplo:

int y;

int x;

y=22;

x = (y<25) ? 12 : 18;

Neste exemplo x é igual a 12. O teste (y<25) é avaliado. Como o teste é verdadeiro (pois y=22) é retornado o valor antes dos dois-pontos. Se o teste fosse falso seria retornado o valor após os dois pontos. É ou não é um if disfarçado?

Built-in operators

Existem operadores chamados Built-in para os tipos de dados int, uint, long, ulong, float, double e decimal. Isso significa que operações aritméticas básicas entre operadores destes tipos não precisamos fazer nenhuma conversão explícita. Considere o exemplo a seguir:

int num1 = 23;

int num2 = 32;

int soma = num1 + num2;

Neste caso não precisamos fazer nenhum tipo de conversão explícita (ou cast como é chamada no C#), uma vez que existe o operador de adição interno do próprio C# (Built-in) para o tipo int.

Agora se tentássemos fazer a seguinte operação teríamos problemas:

short nums1 = 10;

short nums2 = 17;

short soma   =  nums1+nums2;

Se tentarmos compilar um programa que contém este trecho de código obteremos a mensagem de erro indicada na Figura 4.1:

Figura 4.1 Erro de complição.

Para que o nosso exemplo possa funcionar precisamos fazer uma conversão explícita, conforme indicado a seguir:

short nums1 = 10;

short nums2 = 17;

short soma   = (short)  (nums1+nums2);

Operadores Aritméticos

Temos os operadores básicos que toda linguagem tem,ou seja, os operadores para as quatro operações matemáticas, conforme descrito na Tabela 4.1.

Tabela 4.1 Os principais operadores aritméticos.

Também temos o operador unário +, o qual simplesmente indica que um número é positivo. Não altera o valor do número. Por exemplo, os dois comandos a seguir são exatamente iguais e válidos:

short nums1 = +10;

ou

short nums1 = +10;

Já o operador unário menos (-) inverte o sinal de um número. Considere o exemplo:

int x = -10;

int y = -x;

Console.WriteLine(y);

Neste caso o valor de y será igual a 10. Isso mesmo, pois o – inverte o sinal e, lembrando lá do primário, menos com menos dá mais.

Outra observação é que o operador binário + além da adição, também é utilizado para concatenar strings. Observe o exemplo da Listagem 4.1.

Listagem 4.1 – Concatenando strings – ex1cap4.cs

using System;

using System.Windows.Forms;

class ex1cap4

{

            // Exemplo1  - Capítulo 4.

            //  Concatenando Strings.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração das variáveis.

                        string  nome;

                        string  sobrenome;

                        string  nomecompleto;

                        //  O usuário informa o nome e o sobrenome.

                        Console.Write("Digite  o seu nome ->");

                        nome  = Console.ReadLine();

                        Console.Write("Digite  o seu sobrenome ->");

                        sobrenome  = Console.ReadLine();

                        //  Utilizando o operador + para concatenar

                        //  o nome e o sobrenome.

                        nomecompleto  = nome + " " + sobrenome;

                        //  Exibição dos resultados.

                        MessageBox.Show(nomecompleto);

            }

}

Digite o exemplo da listagem 4.1 e salve o mesmo em um arquivo chamado ex1cap4.cs, na pasta C:\ExCsharp\cap4. Compile e execute o exemplo da listagem 4.1. Para o nome digite José e pressione ENTER. Para o sobrenome digite da Silva e pressione ENTER.  Você obterá os resultados indicados na Figura 4.2. Dê um clique no botão OK para fechar a janela de mensagem.

Figura 4.2 Executando o programa ex1cap4.exe.

Temos uma novidade neste exemplo: A utilização do método Show, da classe MessageBox, do namespace System.Windows.Forms. Observe que no início do programa adicionamos uma referência ao namespace System.Windows.Forms. Para exibir o nome completo utilizamos MessageBox.Show.

Utilizamos o operador + para fazer a concatenação do nome, um espaço em branco (“ “) e do sobrenome.

Operador de incremento: ++

O operador de incremento aumento o valor de uma variável em 1.  O operador pode ser utilizado antes ou depois da variável. A melhor maneira de entendermos as diferenças entre o operador estar antes ou depois é através de um exemplo. Considere o seguinte trecho de código:

int x = 10;

int y = x++;

Quais os valores de x e y após a execução destes comandos?

x vale 11

y vale 10

isso acontece porque, na segunda linha, primeiro y é feito igual ao valor atual de x (10) e depois x é incrementado passando o seu valor para 11.

Agora vamos alterar um pouco o nosso exemplo:

int x = 10;

int y = ++x;

Quais os valores de x e y após a execução destes comandos?

x vale 11

y vale 11

isso acontece porque, na segunda linha, primeiro o x é incrementado, passando o seu valor para 11. Em seguida o novo valor de x  (11) é atribuído para y.

Operador de decremento --

O operador de decremento diminui o valor de uma variável em 1.  O operador pode ser utilizado antes ou depois da variável. A melhor maneira de entendermos as diferenças entre o operador estar antes ou depois é através de um exemplo. Considere o seguinte trecho de código:

int x = 10;

int y = x--;

Quais os valores de x e y após a execução destes comandos?

x vale 9

y vale 10

isso acontece porque, na segunda linha, primeiro y é feito igual ao valor atual de x (10) e depois x é decrementado passando o seu valor para 9.

Agora vamos alterar um pouco o nosso exemplo:

int x = 10;

int y = --x;

Quais os valores de x e y após a execução destes comandos?

x vale 9

y vale 9

isso acontece porque, na segunda linha, primeiro o x é decrementado, passando o seu valor para 9. Em seguida o novo valor de x  (9) é atribuído para y.

Operadores Relacionais e Lógicos.

Os operadores relacionais são utilizados, principalmente, em testes nas estruturas de controle do C#. Neste tipo de teste são comparados dois valores e é retornado True ou False. Já os operadores lógicos são utilizados para operações do tipo AND, OR, etc.

Na Tabela 4.2 temos os principais operadores relacionais.

TABELA= Tabela 4.2 Os principais operadores relacionais.

Os operadores lógicos podem ser utilizados para a elaboração de testes mais complexos, inclusive testes compostos, onde temos dois ou mais testes ligados por operadores lógicos. Os dois principais operadores lógicos são && (AND) e o || (OR).

Quando temos uma expressão com vários testes ligados por operadores AND, o resultado somente será verdadeiro se todos os testes forem verdadeiros. Basta que um único teste seja falso, para que todo a expressão seja avaliada como falsa – False.

Considere o trecho de código a seguir:

If (10<11) && (5>3) && (3==3)

{

     Console.WriteLine(“Este  comando será executado !”);

}

Neste exemplo, como todos os testes são verdadeiros, a expressão é verdadeira e o comando será executado. Agora considere o trecho de código a seguir:

If (10<11) && (5<3) && (3==3) &  (123<=114)

{

     Console.WriteLine(“Este  comando NUNCA será executado !”);

}

Neste exemplo como um dos testes é falso (5<3), toda a expressão é avaliada como False e o comando no interior do laço NUNCA será executado.

Quando temos uma expressão com vários testes ligados por operadores OR, o resultado somente será falso se todos os testes forem falsos. Basta que um único teste seja verdadeiro, para que todo a expressão seja avaliada como verdadeira – True.

Considere o trecho de código a seguir:

If (10>11) && (5<3) && (3==3)

{

    Console.WriteLine(“Este  comando será executado !”);

}

Neste exemplo, como um dos testes é verdadeiro (3==3), a expressão é verdadeira e o comando será executado. Agora considere o trecho de código a seguir:

If (10>11) && (5<3) && (3!=3) &  (123>=114)

{

    Console.WriteLine(“Este  comando NUNCA será executado !”);

}

Neste exemplo como todos os testes são falsos, toda a expressão é avaliada como False e o comando no interior do laço NUNCA será executado.

Na Tabela 4.3 temos os principais operadores lógicos.

TABELA= Tabela 4.3 Os principais operadores lógicos.

Operadores de Atribuição (Assignment)

Temos operadores de atribuição simples e compostos. Temos um único operador de atribuição simples que é a igualdade (=), utilizado para atribuir um valor a uma variável ou o valor de uma variável à outra variável, conforme exemplo a seguir:

int x;

int y;

x = 123;

y = x;

Os operadores de atribuição compostos, além de fazerem a atribuição realizam, ao mesmo tempo, uma determinada operação. Para entendermos os operadores compostos vamos a um exemplo simples com o operador +=. Considere o trecho de código a seguir:

int x;

int y;

y = 10;

x = 5;

x += y;

Neste caso valor de x será 15, pois o último comando – x += y é equivalente à: x = x + y.

Na Tabela 4.4 temos os principais operadores de atribuição compostos.

TABELA= Tabela 4.4 Os principais operadores de atribuição compostos.

Precedência de operadores

Em expressões complexas, onde podemos ter diversos operandos e operadores, deve existir uma maneira de decidir quais operações serão realizadas em primeiro lugar. A ordem em que as operações são realizadas é determinada pelas regras de precedência de operadores.

As regrinhas básicas são as mesmas das demais linguagens. Uma expressão é avaliada da esquerda para a direita. Os operadores de incremento e decremento após a variável tem maior prioridade (x++ ou x--). Em seguida são avaliados os operadores unários (+ , -, !) e os operadores de incremento e decremento antes da variável (++x e –x). Na seqüência vem os operadores de multiplicação (*), divisão (/) e resto da divisão (%). Por último os operadores de adição (+) e subtração(-).

Podemos alterar a ordem de precedência dos operadores utilizando parênteses. Considere a expressão a seguir:

x = (y+z)*k

Neste caso a adição (y+z) será executada em primeiro lugar, pois a mesma está dentro do parênteses. O resultado da adição é então multiplicado por k.

Para ilustrar a ordem de precedência vamos considerar o exemplo da Listagem 4.2

Listagem 4.2 – Precedência de operadores. – ex2cap4.cs

using System;

class ex1cap4

{

            // Exemplo  2 - Capítulo 4.

            //  Precedência de operadores.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração das variáveis.

                        int  i=5;

                        int  j=21;

                        int  k=10;

                        int  l=20;

                        int  m=4;

                        int  expr1;

                        int  expr2;

                        int  expr3;

                        //  Alguns cálculos

                        expr1  = i++*j+k-l*m++;

                        expr2  = (i++*j)+(k-l)*m++;

                        expr3  = (i++*j+k)-l*m++;

                        //  Exibição dos resultados.

                        Console.WriteLine("***********************************");

                        Console.WriteLine("Valor  de expr1: {0}",expr1);

                        Console.WriteLine("Valor  de expr2: {0}",expr2);

                        Console.WriteLine("Valor  de expr3: {0}",expr3);

                        Console.WriteLine("***********************************");

            }

}

Digite o exemplo da listagem 4.2 e salve o mesmo em um arquivo chamado ex2cap4.cs, na pasta C:\ExCsharp\cap4. Compile e execute o exemplo da listagem 4.2. Você obterá os resultados indicados na Figura 4.3.

Figura 4.3 Executando o programa ex2cap4.exe.

Observe que temos a mesma expressão, apenas utilizamos parênteses para mudar a ordem de execução dos elementos da expressão. Vamos analisar a primeira expressão, na qual resultou em expr1 = 35.

expr1 = i++*j+k-l*m++;

Aqui não temos nenhum parênteses. Neste caso vale a ordem de precedência dos operadores. Em primeiro, na ordem de precedência estão os operadores de incremento. Porém cabe lembrar que, para a expressão, como o operador de incremento está após a variável, é utilizado o valor original de cada variável e somente depois disso é que as variáveis são incrementadas. Então para a primeira expressão serão utilizados os seguintes valores:

 i=5

 j=21

 k=10

 l=20

 m=4

Com isso nossa expressão fica:

expr1 = 5*21+10-20*4

Primeiro resolvo as multiplicações:

expr1 = 105+10-80

no que obtemos:

expr1 = 35

e após o cálculo da expressão, os valores de i e m são incrementados, passando a valer:

i=6

j=21

k=10

l=20

m=5

Se o operador de incremento estivesse antes das variáveis, primeiro as mesmas seriam incrementadas e depois, já com o novo valor, a expressão seria calculada.