Opérateurs C #
Opérateur est un symbole pour indiquer au compilateur d'effectuer des opérations mathématiques ou logiques spécifiques. C # a une richesse d'opérateurs intégrés, comme suit:
- Les opérateurs arithmétiques
- opérateurs relationnels
- opérateurs logiques
- opérateurs sur les bits
- Opérateurs d'affectation
- opérateurs Divers
Ce tutoriel vous expliquera chacun des opérateurs arithmétiques, des opérateurs relationnels, les opérateurs logiques, les opérateurs de bits, opérateur d'affectation et d'autres opérateurs.
Les opérateurs arithmétiques
Le tableau suivant montre le support C # tous les opérateurs arithmétiques.Une valeur de 10 est supposée variable, la variable Best de 20, alors:
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 把两个操作数相加 | A + B 将得到 30 |
| - | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
| * | 把两个操作数相乘 | A * B 将得到 200 |
| / | 分子除以分母 | B / A 将得到 2 |
| % | 取模运算符，整除后的余数 | B % A 将得到 0 |
| ++ | 自增运算符，整数值增加 1 | A++ 将得到 11 |
| -- | 自减运算符，整数值减少 1 | A-- 将得到 9 |
Exemples
Considérons les exemples suivants pour apprendre C # tous les opérateurs arithmétiques disponibles:
using System;
OperatorsAppl d'espace de noms
{
Programme de classe
{
static void Main (string [] args)
{
int a = 21;
int b = 10;
int c;
c = a + b;
Console.WriteLine ( "1 Line - c est {0}", c);
c = a - b;
Console.WriteLine ( "2 Line - c est {0}", c);
c = a * b;
Console.WriteLine ( "3 Line - c est {0}", c);
c = a / b;
Console.WriteLine ( "4 Line - c est {0}", c);
c = a% b;
Console.WriteLine ( "Ligne 5 - c est {0}", c);
// ++ Une première opération d'incrémentation effectuée par attribution ++ c = a;
Console.WriteLine ( "Line 6 - c est {0}", c);
// Dans ce cas, une valeur de 22
// --a Première auto soustraction par cession c = --a;
Console.WriteLine ( "7 Line - c est {0}", c);
Console.ReadLine ();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
1 Line - la valeur de c est 31 2 Line - la valeur de c est 11 3 Line - est la valeur de c 210 4 Line - la valeur de c est 2 Ligne 5 - la valeur de c est 1 6 Line - la valeur de c est 22 7 Line - la valeur de c est 21
- c = a ++: une première affectation à c, puis sur un opérateur auto-incrémentation.
- c = ++ a: d' abord un opérateur auto-incrémentation, puis affecté à un c.
- c = a--: une première affectation à c, puis sur une auto-soustraction.
- c = --a: d' abord une auto-soustraction, puis affecté à 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();
}
}
}
Le programme ci-dessus, le résultat est:
a = 2 b = 1 a = 2 b = 2 a = 0 b = 1 a = 0 b = 0
opérateurs relationnels
Le tableau suivant montre le support C # tous les opérateurs relationnels.Une valeur de 10 est supposée variable, la variable Best de 20, alors:
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果相等则条件为真。 | (A == B) 不为真。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 | (A > B) 不为真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 | (A < B) 为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (A >= B) 不为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (A <= B) 为真。 |
Exemples
Considérons les exemples suivants pour apprendre C # tous les opérateurs relationnels disponibles:
using System;
Programme de classe
{
static void Main (string [] args)
{
int a = 21;
int b = 10;
if (a == b)
{
Console.WriteLine ( "Ligne 1 - a est égal à b");
}
autre
{
Console.WriteLine ( "Ligne 1 - un pas égal à b");
}
si (a <b)
{
Console.WriteLine ( "Ligne 2 - un peu moins de b");
}
autre
{
Console.WriteLine ( "Ligne 2 - une au moins b");
}
si (a> b)
{
Console.WriteLine ( "Ligne 3 - a est supérieur à b");
}
autre
{
Console.WriteLine ( "Ligne 3 - un pas plus grand que b");
}
/ * Changer la valeur de a et b * /
a = 5;
b = 20;
si (a <= b)
{
Console.WriteLine ( "Ligne 4 - un inférieur ou égal à b");
}
si (b> = a)
{
Console.WriteLine ( "Ligne 5 - b est supérieur ou égal à un");
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
Ligne 1 - un pas égal à b Ligne 2 - un pas moins de b Ligne 3 - a est supérieur à b Ligne 4 - a est inférieur ou égal à b Ligne 5 - b est supérieur ou égal à un
opérateurs logiques
Le tableau suivant montre le support C # tous les opérateurs logiques. Supposons que la valeur booléenne variables vrai, la variableB est une valeur booléenne false, alors:
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 | (A && B) 为假。 |
| || | 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 | (A || B) 为真。 |
| ! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |
Exemples
Considérons les exemples suivants pour apprendre C # tous les opérateurs logiques disponibles:
using System;
OperatorsAppl d'espace de noms
{
Programme de classe
{
static void Main (string [] args)
{
bool a = true;
bool b = true;
si (a && b)
{
Console.WriteLine ( "Ligne 1 - condition est vraie");
}
si (a || b)
{
Console.WriteLine ( "Ligne 2 - condition est vraie");
}
/ * Changer la valeur de a et b * /
a = false;
b = true;
si (a && b)
{
Console.WriteLine ( "Ligne 3 - condition est vraie");
}
autre
{
Console.WriteLine ( "Ligne 3 - la condition est pas vrai");
}
if (! (a && b))
{
Console.WriteLine ( "Ligne 4 - condition est vraie");
}
Console.ReadLine ();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
Ligne 1 - la condition est vraie Ligne 2 - la condition est vraie Ligne 3 - la condition est pas vrai Ligne 4 - condition est vraie
opérateurs sur les bits
Opérateurs binaires agissant sur le bit et bit par opération binaire. &, | Et ^ table de vérité est la suivante:
| 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 |
Supposons que si A = 60 et B = 13, et maintenant, sous forme binaire, sont les suivants:
A = 0011 1100
B = 0000 1101
-----------------
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~ A = 1100 0011
Le tableau suivant dresse la liste des C # opérateurs soutien binaires. Supposons que la variableA est 60, la valeur de la variable B13, alors:
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 如果同时存在于两个操作数中，二进制 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 |
Exemples
Considérons les exemples suivants pour apprendre le C #, tous les opérateurs de bits disponibles:
using System;
OperatorsAppl d'espace de noms
{
Programme 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 est {0}", c);
c = a | b; / * 61 = 0011 1101 * /
Console.WriteLine ( "2 Line - c est {0}", c);
c = a ^ b; / * 49 = 0011 0001 * /
Console.WriteLine ( "3 Line - c est {0}", c);
c = ~ a / * - 61 = 1100 0011 * /
Console.WriteLine ( "4 Line - c est {0}", c);
c = a 2 << / * 240 = 1111 0000 * /
Console.WriteLine ( "Ligne 5 - c est {0}", c);
c = a >> 2; / * 15 = 0000 1111 * /
Console.WriteLine ( "Line 6 - c est {0}", c);
Console.ReadLine ();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
1 Line - la valeur de c est 12 2 Line - la valeur de c est 61 3 Line - la valeur de c est 49 4 Line - valeur c est -61 Ligne 5 - la valeur de c est 240 6 Line - la valeur de c est 15
Opérateurs d'affectation
Le tableau suivant dresse la liste des C # supportent l'opérateur d'affectation:
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，把右边操作数的值赋给左边操作数 | 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 |
Exemples
Considérons les exemples suivants pour apprendre le C # dans tous les opérateurs d'affectation disponibles:
using System;
OperatorsAppl d'espace de noms
{
Programme de classe
{
static void Main (string [] args)
{
int a = 21;
int c;
c = a;
Console.WriteLine ( "Ligne 1 - valeur = c = {0}", c);
c = a +;
Console.WriteLine ( "Ligne 2 - Valeur + = c = {0}", c);
c - = a;
Console.WriteLine ( "Ligne 3 - - = valeur de c = {0}", c);
c * = a;
Console.WriteLine ( "Ligne 4 - valeur * = c = {0}", c);
c / = a;
Console.WriteLine ( "Ligne 5 - valeur / = c = {0}", c);
c = 200;
C% = a;
Console.WriteLine ( "Line 6 - Valeur% = c = {0}", c);
c << = 2;
Console.WriteLine ( "Ligne 7 - << = valeur c = {0}", c);
c >> = 2;
Console.WriteLine ( "Ligne 8 - >> = valeur c = {0}", c);
c & = 2;
Console.WriteLine ( "Ligne 9 - & = valeur c = {0}", c);
c ^ = 2;
Console.WriteLine ( "Ligne 10 - valeur ^ = c = {0}", c);
c | = 2;
Console.WriteLine ( "Ligne 11 - | = valeur c = {0}", c);
Console.ReadLine ();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
Ligne 1 - = c = valeur 21 Ligne 2 - + = valeur de c = 42 3 Line - - = la valeur de c = 21 4 Line - * = valeur de c = 441 Ligne 5 - / = c = valeur 21 6 Line -% = la valeur de c = 11 7 Line - << = valeur de c = 44 8 Line - la valeur >> = c = 11 9 Line - & = valeur de c = 2 Ligne 10 - ^ = c = 0 valeur Ligne 11 - | = c 2 = valeur
opérateurs Divers
Le tableau suivant dresse la liste des C # soutenir d'autres opérateurs importants, y comprissizeof, typeofet?:.
StringReader r = obj comme StringReader;
Exemples
using System;
OperatorsAppl d'espace de noms
{
Programme de classe
{
static void Main (string [] args)
{
/ * Exemple de l'opérateur Sizeof * /
Console.WriteLine ( "int taille est {0}", sizeof (int));
Console.WriteLine ( "taille courte est {0}", sizeof (courte));
Console.WriteLine ( "doubler la taille de la {0}", sizeof (double));
/ * Opérateur ternaire casse instance * /
int a, b;
a = 10;
b = (a == 1) 20: 30 ;?
Console.WriteLine ( "valeurs de b sont {0}", b);
b = (a == 10) 20: 30 ;?
Console.WriteLine ( "valeurs de b sont {0}", b);
Console.ReadLine ();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
Taille Int est 4 taille courte est 2 taille double est 8 Les valeurs b sont 30 Les valeurs b sont 20
Dans # priorité des opérateurs de C
La priorité des opérateurs de déterminer une durée combinée d'une expression. Cela affecte la façon dont un calcul d'expression. Certains opérateurs ont une priorité plus élevée que les autres opérateurs, comme l'addition et la soustraction, la multiplication et opérateur de division que l'opérateur une plus grande priorité.
Par exemple, x = 7 + 3 * 2, où x est affecté à 13 au lieu de 20, parce que l'opérateur * a une priorité supérieure +, donc d'abord calculer la multiplication 3 * 2, puis ajouter 7.
Le tableau suivant sera répertorié dans l'ordre de priorité des opérateurs pour chaque opérateur, ayant les opérateurs prioritaires ci-dessus plus élevés apparaissent dans le tableau, avec les opérateurs de priorité inférieure suivants apparaissent dans le tableau. Dans l'expression, une plus grande priorité des opérateurs prioritaires est calculée.
| 类别 | 运算符 | 结合性 |
|---|---|---|
| 后缀 | () [] -> . ++ - - | 从左到右 |
| 一元 | + - ! ~ ++ - - (type)* & sizeof | 从右到左 |
| 乘除 | * / % | 从左到右 |
| 加减 | + - | 从左到右 |
| 移位 | << >> | 从左到右 |
| 关系 | < <= > >= | 从左到右 |
| 相等 | == != | 从左到右 |
| 位与 AND | & | 从左到右 |
| 位异或 XOR | ^ | 从左到右 |
| 位或 OR | | | 从左到右 |
| 逻辑与 AND | && | 从左到右 |
| 逻辑或 OR | || | 从左到右 |
| 条件 | ?: | 从右到左 |
| 赋值 | = += -= *= /= %=>>= <<= &= ^= |= | 从右到左 |
| 逗号 | , | 从左到右 |
Exemples
using System;
OperatorsAppl d'espace de noms
{
Programme de classe
{
static void Main (string [] args)
{
int a = 20;
int b = 10;
int c = 15;
int j = 5;
int e;
e = (a + b) * c / j // (30 * 15) / 5
Console.WriteLine ( "valeur (a + b) * c / d est {0}", e);
e = ((a + b) * c) / d; // (30 * 15) / 5
Console.WriteLine ( "valeur ((a + b) * c) / d est {0}", e);
e = (a + b) * (c / d); // (30) * (15/5)
Console.WriteLine ( "(a + b) * (c / d) valeurs sont {0}", e);
e = a + (b * c) / d; // 20 + (150/5)
Console.WriteLine ( "valeur d'un + (b * c) / d est {0}", e);
Console.ReadLine ();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:
Valeur (a + b) * c / d est de 90 La valeur ((a + b) * c) / d est égal à 90 (A + b) * (c / d) la valeur est de 90 La valeur de a + (b * c) / d est égal à 50