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.
