[MEU 50º LIVRO]: BANCOS DE DADOS E ACESS - CURSO COMPLETO - DO BÁSICO AO VBA - 1602 páginas

Páginas: 1602 | Autor: Júlio Battisti | 40% de Desconto e 70h de Vídeo Aulas de Bônus

Você está em: PrincipalArtigosASP.NET › Capítulo 04 : 02
Quer receber novidades e e-books gratuitos?
›››
  « Lição anterior Δ Página principal ¤ Capítulos Próxima lição »
ASP.NET - CURSO COMPLETO
Autor: Júlio Battisti


Promoção: Livro Windows Server 2012 R2 e Active Directory - Curso Completo, 2100 Páginas. Tudo para você se tornar um administrador de redes altamente qualificado para o mercado de trabalho e levar a sua carreira para o próximo nível!

Promoção: Livro Windows Server 2012 R2 e Active Directory

Curso Completo, 2100 páginas. Tudo para você se tornar um administrador de redes altamente qualificado para o mercado de trabalho e levar a sua carreira para o próximo nível!


Lição 033 - Capítulo 04 - Operadores e mais operadores

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:

Curso Completo de ASP.NET - Júlio Battisti
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.

Operador Descrição
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Retorna o resto da divisão

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.

Curso Completo de ASP.NET - Júlio Battisti
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.

Operador Exemplo Descrição
== x == y

Comparação. Retorna verdadeiro se x for igual a y.

!= x != y

Diferente. Retorna verdadeiro se x for diferente de b.

< x < y

Menor do que. Retorna verdadeiro se x for menor do que y.

> x > y

Maior do que. Retorna verdadeiro se x for maior do que y.

<= x <= y

Menor ou igual a.Retorna verdadeiro se x menor ou igual a y.

>= x >= y

Maior ou igual a. Retorna verdadeiro se x for maior ou igual a y.

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.

Operador Descrição
& Faz um AND bit a bit entre dois operandos.
| Faz um OR bit a bit entre dois operandos.
^ Faz um OR exclusivo (XOR) entre dois operandos.
&& Faz um AND lógico entre dois operandos.
|| Faz um OR lógico entre dois operandos.

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.

Operador Exemplo Equivale a
+= x += y x = x  + y
-= x -= y x = x  -  y
*= x *= y x = x  *  y
/= x /= y x = x  /   y
%= x %= y x = x  %  y

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.

Curso Completo de ASP.NET - Júlio Battisti
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.


Promoção: Livro Windows Server 2012 R2 e Active Directory - Curso Completo, 2100 Páginas. Tudo para você se tornar um administrador de redes altamente qualificado para o mercado de trabalho e levar a sua carreira para o próximo nível!

Promoção: Livro Windows Server 2012 R2 e Active Directory

Curso Completo, 2100 páginas. Tudo para você se tornar um administrador de redes altamente qualificado para o mercado de trabalho e levar a sua carreira para o próximo nível!


  « Lição anterior Δ Página principal ¤ Capítulos Próxima lição »

Best Sellers de Programação do Julio Battisti

Todos com Vídeo Aulas, E-books ou Exemplos de Brinde!

Aprenda com Júlio Battisti: SQL Server 2008 R2

 

Autor: Júlio Battisti | Páginas: 1164 | Editora: Instituto Alpha

 

Macros e Programação VBA no Excel 2010

 

Autor: Júlio Battisti | Páginas: 1124 | Editora: Instituto Alpha

 

Access 2010 Avançado, Macros e Programação VBA - Passo a Passo

 

Autor: Júlio Battisti | Páginas: 828 | Editora: Instituto Alpha

 

 

Todos os livros com dezenas de horas de vídeo aulas de bônus, preço especial (alguns com 50% de desconto). Aproveite. São poucas unidades de cada livro e por tempo limitado.

Dúvidas?

Utilize a área de comentários a seguir.

Me ajude a divulgar este conteúdo gratuito!

Use a área de comentários a seguir, diga o que achou desta lição, o que está achando do curso.
Compartilhe no Facebook, no Google+, Twitter e Pinterest.

Indique para seus amigos. Quanto mais comentários forem feitos, mais lições serão publicadas.

Quer receber novidades e e-books gratuitos?
›››

Novidades e E-books grátis

Fique por dentro das novidades, lançamento de livros, cursos, e-books e vídeo-aulas, e receba ofertas de e-books e vídeo-aulas gratuitas para download.



Institucional

  • Quem somos
  • Garantia de Entrega
  • Formas de Pagamento
  • Contato
  • O Autor
  • Endereço

  • Júlio Battisti Livros e Cursos Ltda
  • CNPJ: 08.916.484/0001-25
  • Rua Vereador Ivo Cláudio Weigel, 537 Universitário
  • Santa Cruz do Sul/RS
  • CEP 96816-208
  • Todos os direitos reservados, Júlio Battisti 2001-2017 ®

    [LIVRO]: MACROS E PROGRAMAÇÃO VBA NO EXCEL 2010 - PASSO-A-PASSO

    APRENDA COM JULIO BATTISTI - 1124 PÁGINAS: CLIQUE AQUI