Operadores C #
Operador é um símbolo para dizer ao compilador para executar operações matemáticas ou lógicas específicas. C # tem uma riqueza de operadores internos, como segue:
- operadores aritméticos
- Operadores relacionais
- Operadores lógicos
- Operadores bit a bit
- Operadores de atribuição
- Operadores diversos
Este tutorial irá explicar cada um dos operadores aritméticos, operadores relacionais, operadores lógicos, operadores bit a bit, operador de atribuição e outros operadores.
operadores aritméticos
A tabela a seguir mostra o # suporte C todos os operadores aritméticos.Um valor de 10 é assumida variável, a variável Bé de 20, em seguida:
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 把两个操作数相加 | A + B 将得到 30 |
| - | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
| * | 把两个操作数相乘 | A * B 将得到 200 |
| / | 分子除以分母 | B / A 将得到 2 |
| % | 取模运算符，整除后的余数 | B % A 将得到 0 |
| ++ | 自增运算符，整数值增加 1 | A++ 将得到 11 |
| -- | 自减运算符，整数值减少 1 | A-- 将得到 9 |
Exemplos
Considere os seguintes exemplos para aprender C # todos os operadores aritméticos disponíveis:
using System;
OperatorsAppl namespace
{
Programa de classe
{
static void Main (string [] args)
{
int a = 21;
int b = 10;
int C;
C = a + b;
Console.WriteLine ( "1 Line - c é {0}", c);
c = a - b;
Console.WriteLine ( "2 Line - c é {0}", c);
C = a * b;
Console.WriteLine ( "3 Line - c é {0}", c);
C = a / b;
Console.WriteLine ( "4 Line - c é {0}", c);
c = a% b;
Console.WriteLine ( "Linha 5 - c é {0}", c);
// ++ A primeira operação de incremento realizado pela atribuição c = ++ a;
Console.WriteLine ( "6 Line - c é {0}", c);
// Neste caso, um valor de 22
// --a Primeira auto subtração pela atribuição c = --a;
Console.WriteLine ( "7 Line - c é {0}", c);
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
1 Line - o valor de c é 31 2 Line - o valor de c é 11 3 Line - é o valor de c 210 4 Line - o valor de c é 2 Linha 5 - o valor de c é 1 6 Line - o valor de c é 22 7 Line - o valor de c é 21
- c = a ++: a primeira atribuição para c, e, em seguida, um operador de auto-incremento.
- c = ++ um: primeiro um operador de auto-incremento, em seguida, atribuído a um c.
- c = um--: a primeira atribuição para c, e, em seguida, em uma auto-subtração.
- c = --a: primeiro um auto-subtração, então atribuído a um c.
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 1;
int b;
// a++ 先赋值再进行自增运算
b = a++;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();
// ++a 先进行自增运算再赋值
a = 1; // 重新初始化 a
b = ++a;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();
// a-- 先赋值再进行自减运算
a = 1; // 重新初始化 a
b= a--;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();
// --a 先进行自减运算再赋值
a = 1; // 重新初始化 a
b= --a;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();
}
}
}
O programa acima, a saída é:
a = 2 b = 1 a = 2 b = 2 a = 0 b = 1 a = 0 b = 0
Operadores relacionais
A tabela a seguir mostra o # suporte C todos os operadores relacionais.Um valor de 10 é assumida variável, a variável Bé de 20, em seguida:
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果相等则条件为真。 | (A == B) 不为真。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 | (A > B) 不为真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 | (A < B) 为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (A >= B) 不为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (A <= B) 为真。 |
Exemplos
Considere os seguintes exemplos para aprender C # todos os operadores relacionais disponíveis:
using System;
Programa de classe
{
static void Main (string [] args)
{
int a = 21;
int b = 10;
if (a == b)
{
Console.WriteLine ( "Linha 1 - a é igual a B");
}
mais
{
Console.WriteLine ( "Linha 1 - um não igual a B");
}
if (a <b)
{
Console.WriteLine ( "Linha 2 - a menos de b");
}
mais
{
Console.WriteLine ( "Linha 2 - a não menos de b");
}
if (a> b)
{
Console.WriteLine ( "Linha 3 - a é maior que b");
}
mais
{
Console.WriteLine ( "Linha 3 - a não superior a b");
}
/ * Altere o valor de um e b * /
a = 5;
b = 20;
if (a <= b)
{
Console.WriteLine ( "Linha 4 - um inferior ou igual a b");
}
Se (b> = a)
{
Console.WriteLine ( "Linha 5 - b é maior do que ou igual a um");
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
Linha 1 - um não igual ab Linha 2 - uma não menos do que b Linha 3 - a é maior do que b Linha 4 - a é menor do que ou igual a b Linha 5 - b é maior do que ou igual a um
Operadores lógicos
A tabela a seguir mostra o # suporte C todos os operadores lógicos. Suponha que o valorbooleano variável verdade, a variável Bé um valor booleano falso, então:
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 | (A && B) 为假。 |
| || | 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 | (A || B) 为真。 |
| ! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |
Exemplos
Considere os seguintes exemplos para aprender C # todos os operadores lógicos disponíveis:
using System;
OperatorsAppl namespace
{
Programa de classe
{
static void Main (string [] args)
{
bool a = true;
bool b = true;
if (a && b)
{
Console.WriteLine ( "Linha 1 - condição é verdadeira");
}
se (a || b)
{
Console.WriteLine ( "Linha 2 - condição é verdadeira");
}
/ * Altere o valor de um e b * /
a = false;
b = true;
if (a && b)
{
Console.WriteLine ( "Linha 3 - condição é verdadeira");
}
mais
{
Console.WriteLine ( "Linha 3 - a condição não é verdadeira");
}
if (! (a && b))
{
Console.WriteLine ( "Linha 4 - condição é verdadeira");
}
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
Linha 1 - a condição é verdadeira Linha 2 - a condição é verdadeira Linha 3 - a condição não é verdade Linha 4 - condição for verdadeira
Operadores bit a bit
Operadores bit a bit que actuam sobre o pouco e pouco a operação bits. &, | E ^ tabela verdade é a seguinte:
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Suponhamos que se A = 60, e B = 13, e agora, em forma binária, são como se segue:
A = 0011 1100
B = 0000 1101
-----------------
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~ A = 1100 0011
A tabela a seguir lista os operadores C # suporte bit a bit. Suponhamos que a variávelA é 60, o valor da variável B13, em seguida:
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 | (A & B) 将得到 12，即为 0000 1100 |
| | | 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 | (A | B) 将得到 61，即为 0011 1101 |
| ^ | 如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。 | (A ^ B) 将得到 49，即为 0011 0001 |
| ~ | 二进制补码运算符是一元运算符，具有"翻转"位效果。 | (~A ) 将得到 -61，即为 1100 0011，2 的补码形式，带符号的二进制数。 |
| << | 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 | A << 2 将得到 240，即为 1111 0000 |
| >> | 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 | A >> 2 将得到 15，即为 0000 1111 |
Exemplos
Considere os seguintes exemplos para aprender C #, todos os operadores bits disponíveis:
using System;
OperatorsAppl namespace
{
Programa de classe
{
static void Main (string [] args)
{
int a = 60; / * 60 = 0011 1100 * /
int b = 13; / * 13 = 0000 1101 * /
int C = 0;
c = a & b; / * 12 = 0000 1100 * /
Console.WriteLine ( "1 Line - c é {0}", c);
c = a | b; / * 61 = 0011 1101 * /
Console.WriteLine ( "2 Line - c é {0}", c);
c = a ^ b / * 49 = 0011 0001 * /
Console.WriteLine ( "3 Line - c é {0}", c);
c = ~ a; / * - 61 = 1100 0011 * /
Console.WriteLine ( "4 Line - c é {0}", c);
c = a << 2; / * 240 = 1111 0000 * /
Console.WriteLine ( "Linha 5 - c é {0}", c);
c = a >> 2; / * 15 = 0000 1111 * /
Console.WriteLine ( "6 Line - c é {0}", c);
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
1 Line - o valor de c é 12 2 Line - o valor de c é de 61 3 Line - o valor de c é de 49 4 Line - valor c está -61 Linha 5 - o valor de c é de 240 6 Line - o valor de c é 15
Operadores de atribuição
A tabela a seguir lista os C # suporta o operador de atribuição:
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，把右边操作数的值赋给左边操作数 | C = A + B 将把 A + B 的值赋给 C |
| += | 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 | C += A 相当于 C = C + A |
| -= | 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 | C -= A 相当于 C = C - A |
| *= | 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 | C *= A 相当于 C = C * A |
| /= | 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 | C /= A 相当于 C = C / A |
| %= | 求模且赋值运算符，求两个操作数的模赋值给左边操作数 | C %= A 相当于 C = C % A |
| <<= | 左移且赋值运算符 | C <<= 2 等同于 C = C << 2 |
| >>= | 右移且赋值运算符 | C >>= 2 等同于 C = C >> 2 |
| &= | 按位与且赋值运算符 | C &= 2 等同于 C = C & 2 |
| ^= | 按位异或且赋值运算符 | C ^= 2 等同于 C = C ^ 2 |
| |= | 按位或且赋值运算符 | C |= 2 等同于 C = C | 2 |
Exemplos
Considere os seguintes exemplos para aprender C #, em todos os operadores de atribuição disponíveis:
using System;
OperatorsAppl namespace
{
Programa de classe
{
static void Main (string [] args)
{
int a = 21;
int C;
C = um;
Console.WriteLine ( "Linha 1 - value = C = {0}", c);
C + = a;
Console.WriteLine ( "Linha 2 - Valor + = c = {0}", c);
c - = a;
Console.WriteLine ( "Linha 3 - - value = C = {0}", c);
c * = A;
Console.WriteLine ( "Linha 4 - Valor * = C = {0}", c);
C / = A;
Console.WriteLine ( "Linha 5 - valor / = C = {0}", c);
C = 200;
C% = A;
Console.WriteLine ( "Linha 6 - valor% = C = {0}", c);
c << = 2;
Console.WriteLine ( "Linha 7 - << = valor c = {0}", c);
c >> = 2;
Console.WriteLine ( "Linha 8 - >> = valor c = {0}", c);
c & = 2;
Console.WriteLine ( "Linha 9 - & = valor c = {0}", c);
c ^ = 2;
Console.WriteLine ( "Linha 10 - valor ^ = C = {0}", c);
c | = 2;
Console.WriteLine ( "Linha 11 - | = valor c = {0}", c);
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
Linha 1 - = c = valor 21 Linha 2 - + = valor de c = 42 3 Line - - = valor de c = 21 4 Line - * = valor de c = 441 Linha 5 - / = c = valor 21 6 Line -% = o valor de c = 11 7 Line - << = valor de c = 44 8 Line - o valor >> = c = 11 9 Line - & = valor de c = 2 Linha 10 - ^ = c = 0 valor Linha 11 - | = c 2 = valor
Operadores diversos
A tabela a seguir lista os C # Suporte alguns outros operadores importantes, incluindosizeof, typeofe?:.
StringReader R = obj como StringReader;
Exemplos
using System;
OperatorsAppl namespace
{
Programa de classe
{
static void Main (string [] args)
{
/ * Exemplo operador sizeof * /
Console.WriteLine ( "size int é {0}", sizeof (int));
Console.WriteLine ( "short tamanho é {0}", sizeof (short));
Console.WriteLine ( "dobrar o tamanho da {0}", sizeof (double));
/ * Operador ternário quebra instância * /
int a, b;
a = 10;
b = (A == 1) 20: 30 ;?
Console.WriteLine ( "valores B são {0}", b);
b = (A == 10) 20: 30 ;?
Console.WriteLine ( "valores B são {0}", b);
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
tamanho int é de 4 short tamanho é 2 o dobro do tamanho é de 8 valores B são 30 valores B são 20
Em C # precedência do operador
A precedência de operadores determinar um termo combinado de uma expressão. Isto afeta como um cálculo de expressão. Alguns operadores têm uma prioridade maior do que outros operadores, como adição e subtração, multiplicação e operador de divisão do que o operador de uma prioridade mais elevada.
Por exemplo, X = 7 + 3 * 2, em que, X é atribuído a 13 em vez de 20, porque o operador tem precedência * superior a +, de modo que em primeiro lugar calcular a multiplicação 3 * 2, em seguida, adicionar 7.
A tabela a seguir serão listados em ordem de precedência do operador para cada operador, tendo os operadores prioritárias acima mais elevados aparecem na tabela, com os seguintes operadores de menor prioridade aparecem na tabela. Na expressão, maior prioridade operadores prioritários é calculado.
| 类别 | 运算符 | 结合性 |
|---|---|---|
| 后缀 | () [] -> . ++ - - | 从左到右 |
| 一元 | + - ! ~ ++ - - (type)* & sizeof | 从右到左 |
| 乘除 | * / % | 从左到右 |
| 加减 | + - | 从左到右 |
| 移位 | << >> | 从左到右 |
| 关系 | < <= > >= | 从左到右 |
| 相等 | == != | 从左到右 |
| 位与 AND | & | 从左到右 |
| 位异或 XOR | ^ | 从左到右 |
| 位或 OR | | | 从左到右 |
| 逻辑与 AND | && | 从左到右 |
| 逻辑或 OR | || | 从左到右 |
| 条件 | ?: | 从右到左 |
| 赋值 | = += -= *= /= %=>>= <<= &= ^= |= | 从右到左 |
| 逗号 | , | 从左到右 |
Exemplos
using System;
OperatorsAppl namespace
{
Programa de classe
{
static void Main (string [] args)
{
int a = 20;
int b = 10;
int c = 15;
int d = 5;
int E;
E = (a + b) * c / d; // (30 * 15) / 5
Console.WriteLine ( "valor (a + b) * c / d {0}", e);
E = ((a + b) * c) / d; // (30 * 15) / 5
Console.WriteLine ( "valor ((a + b) * c) / d {0}", e);
E = (a + b) * (c / d); // (30) * (15/5)
Console.WriteLine ( "(a + b) * (C / D) são os valores {0}", e);
E = a + (b * C) / d; // + 20 (150/5)
Console.WriteLine ( "valor de um + (b * c) / d {0}", e);
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
Valor de (a + b) * c / d é 90 Valor ((a + b) * c) / d é de 90 (A + b) * (d / c) valor é 90 O valor de a + (b * C) / d é de 50