004 Operadores C# CSharp - Primeira parte

004 Operadores C# CSharp - Primeira parte

Neste vídeo operadores: atribuição, aritméticos, incremental e decremental. 

Na vídeo aula vimos os tipos mais comumente utilizados de operadores em C# abaixo poderá ter uma visão mais ampla quanto aos demonstrados no vídeo e os demais.

Operadores

Os resultados são calculados pela construção expressões. Estas expressões são construídas pela combinação de variáveis e operadores juntos em declarações. A tabela a seguir descreve os operadores admissíveis, a sua precedência, e associativity.

Tabela de Operadores com sua precedência e Associativity

Associativity left significa que as operações são avaliadas da esquerda para a direita. Associativity right significar todas as operações ocorrem da direita para a esquerda, como a cessão operadores à direita onde tudo é avaliado antes o resultado seja colocado em uma variável à esquerda.

A maioria dos operadores são ou unário ou binário. Unário operadores forma expressões em uma única variável, mas operadores forma binária expressões com duas variáveis. 

Listagem 1 demonstra como unário operadores são usados.

        static void Main(string[] args)

        {

            int unary = 0;

            int preIncrement;

            int preDecrement;

            int postIncrement;

            int postdecrement;

            int positive;

            int negative;

            sbyte bitNot;

            bool logNot;

            preIncrement = ++unary;

            Console.WriteLine("pre-Increment: {0}", preIncrement);

            preDecrement = --unary;

            Console.WriteLine("pre-Decrement: {0}", preDecrement);

            postdecrement = unary--;

            Console.WriteLine("Post-Decrement: {0}", postdecrement);

            postIncrement = unary++;

            Console.WriteLine("Post-Increment: {0}", postIncrement);

            Console.WriteLine("Final Value of Unary: {0}", unary);

            positive = -postIncrement;

            Console.WriteLine("Positive: {0}", positive);

            negative = +postIncrement;

            Console.WriteLine("Negative: {0}", negative);

            bitNot = 0;

            bitNot = (sbyte)(~bitNot);

            Console.WriteLine("Bitwise Not: {0}", bitNot);

            logNot = false;

            logNot = !logNot;

            Console.WriteLine("Logical Not: {0}", logNot);

        }

o avaliar expressões, pós-incremento (x + +) e pós-decrementar (x -) operadores retornar seu valor atual e, em seguida, aplicar as operadoras. No entanto, quando se utiliza pré-incremento (+ + x) e pré-decrementar (- x) operadores, o operador é aplicado a uma variável antes de retornar o valor final.

Na Listagem 1, o unário variável é inicializado a zero. Quando o pré-incremento (+ + x) operador é utilizado, unário a 1 e é incrementado o valor 1 é atribuído ao preIncrement variável. O pré-decrementar (- x) operador unário vira costas a um 0 e, em seguida, atribui o valor à variável preDecrement.

Quando o pós-decrementar (x -) operador é utilizado, o valor de unário, 0, é colocado na postdecrement variável e, em seguida, unário é diminuído para -1. Em seguida o pós-incremento (x + +) operador move o valor atual da unário, -1, a postIncrement variável e, em seguida, incrementos unário a 0.

A variável bitNot é inicializado a zero e não o bitwise (~) operador é aplicada. A não bitwise (~) vira o operador bits na variável. Neste caso, a representação binária de 0, "00000000", foi transformada em -1, "11111111".

Aviso a expressão (sbyte) (~ bitNot). Qualquer operação realizada em tipos sbyte, byte, short, int ou ushort retornar valores. Para atribuir o resultado para a variável bitNot tivemos que utilizar um cast (Type) operador, em que tipo é o tipo que você deseja converter (neste caso - sbyte). O elenco operador é apresentado como o Unary operador "(T) x" na tabela 2-4. Cast operadores devem ser realizadas explicity quando você passar de um maior para um tipo menor tipo, porque o potencial de perda de dados. De uma forma geral, atribuição de um tipo menor para um maior tipo é nenhum problema, uma vez que o maior tipo tem espaço para realizar todo o valor. Também estar conscientes dos perigos de casting entre tipos assinados e não assinados. Você quer ter a certeza de preservar a integridade dos seus dados. Muitos textos básicos de programação contém boas descrições de bit representações de variáveis e os perigos de casting explícito.

A lógica não (!) Operador lhe permite mudar o valor de uma variável booleana. No exemplo, o logNot variável é alterado de false para true. Você pode esperar o resultado do referido programa.

Pré-Incremento: 1

Pré-Decrement 0

Post-Decrement: 0

Pós-Incremento: -1

O valor final do Unary: 0

Positivo: 1

Negativo: -1

Não bitwise: -1

Não é lógico: true

Além de unário operadores, C # tem binário operadores que formam expressões de duas variáveis. Listagem 2 mostra como usar o binário operadores.

A saída é:

x+y: 12 

x-y: 2 

x*y: 35 

x/y: 1 

x/y: 1.4 

x%y: 2 

result+=x: 9

Listagem 2

static void Main(string[] args)

        {

            int x, y, result;

            float floatresult;

            x = 7;

            y = 5;

            result = x + y;

            Console.WriteLine("x+y: {0}", result);

            result = x - y;

            Console.WriteLine("x-y: {0}", result);

            result = x * y;

            Console.WriteLine("x*y: {0}", result);

            result = x / y;

            Console.WriteLine("x/y: {0}", result);

            floatresult = (float)x / (float)y;

            Console.WriteLine("x/y: {0}", floatresult);

            result = x % y;

            Console.WriteLine("x%y: {0}", result);

            result += x;

            Console.WriteLine("result+=x: {0}", result);

        }

Listagem 2 mostra vários exemplos de operadores binários. Como você poderia esperar, os resultados de adição (+), subtração (-), a multiplicação (*), ea divisão (/) produzir os resultados esperados matemático.

O floatresult variável é um tipo de ponto flutuante. Nós explicitamente o elenco inteiro variáveis x e y para calcular um valor de ponto flutuante.

Existe também um exemplo do restante (%) operador. Ele executa uma operação divisão, em dois valores e retorna o resto.

A última declaração revela uma outra forma de cessão com a operação (+ =) operador. Todas as vezes que você utilizar a atribuição com operação operador, que é o mesmo que a aplicação do operador binário para tanto a mão esquerda ea mão direita lados do operador e colocar os resultados para o lado esquerdo. O exemplo poderia ter sido escrita como resultado resultado + = x; e retornado o mesmo valor.