C # Operatori
Operatore è un simbolo per dire al compilatore di eseguire specifiche operazioni matematiche o logiche. C # ha una ricchezza di operatori built-in, come segue:
- Gli operatori aritmetici
- Operatori relazionali
- Operatori logici
- operatori bit per bit
- Operatori di assegnazione
- Operatori Varie
Questo tutorial vi spiegherà ciascuno degli operatori aritmetici, operatori relazionali, operatori logici, operatori bit a bit, operatore di assegnazione e di altri operatori.
Gli operatori aritmetici
La seguente tabella mostra il # supporto C tutti gli operatori aritmetici.Un valore di 10 si assume variabile, la variabile Bè 20, allora:
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 把两个操作数相加 | A + B 将得到 30 |
| - | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
| * | 把两个操作数相乘 | A * B 将得到 200 |
| / | 分子除以分母 | B / A 将得到 2 |
| % | 取模运算符，整除后的余数 | B % A 将得到 0 |
| ++ | 自增运算符，整数值增加 1 | A++ 将得到 11 |
| -- | 自减运算符，整数值减少 1 | A-- 将得到 9 |
Esempi
Considerate i seguenti esempi per imparare il C # tutti gli operatori aritmetici disponibili:
using System;
OperatorsAppl namespace
{
Programma di classe
{
static void Main (string [] args)
{
int a = 21;
int b = 10;
int c;
c = a + b;
Console.WriteLine ( "1 Linea - 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 ( "Linea 5 - c è {0}", c);
// ++ Una prima operazione di incremento effettuata mediante cessione c = ++ a;
Console.WriteLine ( "6 Line - c è {0}", c);
// In questo caso un valore di 22
// --Una Prima sottrazione di sé mediante cessione c = --a;
Console.WriteLine ( "7 Line - c è {0}", c);
Console.ReadLine ();
}
}
}
Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:
1 Line - il valore di c è 31 2 Line - il valore di c è 11 3 Line - è il valore di c 210 4 Line - il valore di c è 2 Linea 5 - il valore di c è 1 6 Line - il valore di c è 22 7 Line - il valore di c è 21
- c = a ++: una prima assegnazione c, e quindi su un operatore di auto-incremento.
- c = ++ una: prima un operatore di auto-incremento, e poi assegnato a un c.
- c = un--: una prima assegnazione c, e quindi su un auto-sottrazione.
- c = --Una: prima un auto-sottrazione, poi assegnato a un 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();
}
}
}
Il programma precedente, l'uscita è:
a = 2 b = 1 a = 2 b = 2 a = 0 b = 1 a = 0 b = 0
Operatori relazionali
La seguente tabella mostra il # supporto C tutti gli operatori relazionali.Un valore di 10 si assume variabile, la variabile Bè 20, allora:
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果相等则条件为真。 | (A == B) 不为真。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 | (A > B) 不为真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 | (A < B) 为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (A >= B) 不为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (A <= B) 为真。 |
Esempi
Considerate i seguenti esempi per imparare il C # tutti gli operatori relazionali disponibili:
using System;
Programma di classe
{
static void Main (string [] args)
{
int a = 21;
int b = 10;
if (a == b)
{
Console.WriteLine ( "Linea 1 - a è uguale a b");
}
altro
{
Console.WriteLine ( "Linea 1 - non uguale a B");
}
se (a <b)
{
Console.WriteLine ( "Linea 2 - una inferiore a B");
}
altro
{
Console.WriteLine ( "Linea 2 - un non inferiore a B");
}
if (a> b)
{
Console.WriteLine ( "Linea 3 - a è maggiore di b");
}
altro
{
Console.WriteLine ( "Linea 3 - un non superiore b");
}
/ * Modificare il valore di a e b * /
a = 5;
b = 20;
se (a <= b)
{
Console.WriteLine ( "Linea 4 - un minore o uguale ab");
}
if (b> = a)
{
Console.WriteLine ( "Linea 5 - b è maggiore o uguale a un");
}
}
}
Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:
Linea 1 - non uguale a b Linea 2 - un non inferiore b Linea 3 - a è maggiore di b Linea 4 - a è minore o uguale ab Linea 5 - b è maggiore o uguale a un
Operatori logici
La seguente tabella mostra il # supporto C tutti gli operatori logici. Supponiamo che il valorebooleano variabile vero, la variabile Bè un valore booleano falso, allora:
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 | (A && B) 为假。 |
| || | 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 | (A || B) 为真。 |
| ! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |
Esempi
Considerate i seguenti esempi per imparare il C # tutti gli operatori logici disponibili:
using System;
OperatorsAppl namespace
{
Programma di classe
{
static void Main (string [] args)
{
bool un = true;
bool b = true;
se (a && b)
{
Console.WriteLine ( "Linea 1 - condizione è vera");
}
se (a || b)
{
Console.WriteLine ( "Linea 2 - condizione è vera");
}
/ * Modificare il valore di a e b * /
a = false;
b = true;
se (a && b)
{
Console.WriteLine ( "Linea 3 - condizione è vera");
}
altro
{
Console.WriteLine ( "Linea 3 - la condizione non è vera");
}
if (! (a && b))
{
Console.WriteLine ( "Linea 4 - condizione è vera");
}
Console.ReadLine ();
}
}
}
Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:
Linea 1 - la condizione è vera linea 2 - la condizione è vera Linea 3 - la condizione non è vera linea 4 - condizione è vera
operatori bit per bit
operatori bit a bit che agiscono sul bit, e poco a funzionamento bit. &, | E ^ tabella della verità è la seguente:
| 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 |
Supponiamo che se A = 60 e B = 13, e ora, in forma binaria, sono i seguenti:
A = 0011 1100
B = 0000 1101
-----------------
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~ A = 1100 0011
Nella tabella seguente sono elencati gli operatori C # sostegno bit a bit. Supponiamo che la variabileA è 60, il valore della variabile B13, quindi:
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 如果同时存在于两个操作数中，二进制 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 |
Esempi
Considerate i seguenti esempi per imparare il C #, tutti gli operatori bit disponibili:
using System;
OperatorsAppl namespace
{
Programma di 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 Linea - 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 ( "Linea 5 - c è {0}", c);
c = a >> 2; / * 15 = 0000 1111 * /
Console.WriteLine ( "6 Line - c è {0}", c);
Console.ReadLine ();
}
}
}
Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:
1 Line - il valore di c è 12 2 Line - il valore di c è 61 3 Line - il valore di c è 49 4 Line - valore di c è -61 Linea 5 - il valore di c è 240 6 Line - il valore di c è 15
Operatori di assegnazione
Nella tabella seguente sono elencati i C # supportano l'operatore di assegnazione:
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，把右边操作数的值赋给左边操作数 | 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 |
Esempi
Considerate i seguenti esempi per imparare il C # a tutti gli operatori di assegnazione disponibili:
using System;
OperatorsAppl namespace
{
Programma di classe
{
static void Main (string [] args)
{
int a = 21;
int c;
c = a;
Console.WriteLine ( "Linea 1 - value = c = {0}", c);
c + = a;
Console.WriteLine ( "Linea 2 - valore + = c = {0}", c);
c - = a;
Console.WriteLine ( "Linea 3 - - value = c = {0}", c);
c * = a;
Console.WriteLine ( "Linea 4 - Valore * = C = {0}", c);
c / = a;
Console.WriteLine ( "Linea 5 - Valore / = c = {0}", c);
c = 200;
c% = a;
Console.WriteLine ( "Linea 6 - Valore% = c = {0}", c);
c << = 2;
Console.WriteLine ( "Linea 7 - << = valore c = {0}", c);
c >> = 2;
Console.WriteLine ( "Linea 8 - >> = valore c = {0}", c);
c & = 2;
Console.WriteLine ( "Linea 9 - e = valore c = {0}", c);
c ^ = 2;
Console.WriteLine ( "Linea 10 - valore ^ = c = {0}", c);
c | = 2;
Console.WriteLine ( "Linea 11 - | = valore c = {0}", c);
Console.ReadLine ();
}
}
}
Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:
Linea 1 - = c = valore 21 Linea 2 - + = valore di c = 42 3 Linea - - = il valore di C = 21 4 Line - * = valore di c = 441 Linea 5 - / = c = valore 21 6 Line -% = il valore di C = 11 7 Line - << = valore di c = 44 8 Line - il valore >> = c = 11 9 Line - & = valore di c = 2 Linea 10 - ^ = c = 0 valore Linea 11 - | = c 2 = valore
Operatori Varie
Nella tabella seguente sono elencati i C # Supporto alcuni altri operatori importanti, tra cuisizeof, typeofe?:.
StringReader r = obj come StringReader;
Esempi
using System;
OperatorsAppl namespace
{
Programma di classe
{
static void Main (string [] args)
{
/ * Sizeof esempio operatore * /
Console.WriteLine ( "int size è {0}", sizeof (int));
Console.WriteLine ( "short size è {0}", sizeof (short));
Console.WriteLine ( "raddoppiare le dimensioni della {0}", sizeof (doppio));
/ * Operatore ternario rompe esempio * /
int a, b;
a = 10;
b = (a == 1) 20: 30 ;?
Console.WriteLine ( "valori di b sono {0}", b);
b = (a == 10) 20: 30 ;?
Console.WriteLine ( "valori di b sono {0}", b);
Console.ReadLine ();
}
}
}
Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:
int size è 4 breve dimensione è 2 doppia dimensione è 8 valori di b sono 30 valori di b sono 20
In C # precedenza degli operatori
Precedenza degli operatori di determinare un termine combinato di un'espressione. Questo influisce su come un calcolo espressione. Alcuni operatori hanno una priorità più alta rispetto agli altri operatori, come l'addizione e sottrazione, moltiplicazione e divisione dell'operatore rispetto all'operatore una priorità più alta.
Per esempio, x = 7 + 3 * 2, dove x è assegnato a 13 invece di 20, perché l'operatore * ha precedenza maggiore rispetto +, quindi prima di calcolare la moltiplicazione 3 * 2, quindi aggiungere 7.
La tabella seguente saranno elencati in ordine di precedenza degli operatori per ciascun operatore, avendo gli operatori di priorità sopra superiori appaiono nella tabella, con i seguenti operatori priorità inferiore appariranno nella tabella. Nell'espressione, maggiore priorità agli operatori di priorità viene calcolato.
| 类别 | 运算符 | 结合性 |
|---|---|---|
| 后缀 | () [] -> . ++ - - | 从左到右 |
| 一元 | + - ! ~ ++ - - (type)* & sizeof | 从右到左 |
| 乘除 | * / % | 从左到右 |
| 加减 | + - | 从左到右 |
| 移位 | << >> | 从左到右 |
| 关系 | < <= > >= | 从左到右 |
| 相等 | == != | 从左到右 |
| 位与 AND | & | 从左到右 |
| 位异或 XOR | ^ | 从左到右 |
| 位或 OR | | | 从左到右 |
| 逻辑与 AND | && | 从左到右 |
| 逻辑或 OR | || | 从左到右 |
| 条件 | ?: | 从右到左 |
| 赋值 | = += -= *= /= %=>>= <<= &= ^= |= | 从右到左 |
| 逗号 | , | 从左到右 |
Esempi
using System;
OperatorsAppl namespace
{
Programma di 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 ( "value (a + b) * c / d è {0}", e);
e = ((a + b) * c) / d; // (30 * 15) / 5
Console.WriteLine ( "value ((a + b) * c) / d è {0}", e);
e = (a + b) * (c / d); // (30) * (15/5)
Console.WriteLine ( "(a + b) * (c / d) i valori sono {0}", e);
e = a + (b * c) / d; // 20 + (150/5)
Console.WriteLine ( "valore di un + (b * c) / d è {0}", e);
Console.ReadLine ();
}
}
}
Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati:
Valore (a + b) * c / d è 90 Valore ((a + b) * c) / d è 90 (A + B) * (d c /) il valore è di 90 Il valore di a + (b * c) / d è 50