1. Rumah
  2. C # Operator

Tutorial C # Operator Terbaik Pada tahun 2024, Dalam tutorial ini Anda dapat mempelajari operator aritmatika,Operator relasional,Operator logis,bitwise Operator,Operator penugasan,Operator Miscellaneous,Dalam C didahulukan # Operator,

C # Operator

Operator adalah simbol untuk memberitahu compiler untuk melakukan operasi matematika atau logis tertentu. C # memiliki kekayaan built-in operator, sebagai berikut:

  • operator aritmatika
  • Operator relasional
  • Operator logis
  • bitwise Operator
  • Operator penugasan
  • Operator Miscellaneous

Tutorial ini akan menjelaskan masing-masing operator aritmatika, operator relasional, operator logika, operator bitwise, operator penugasan dan operator lainnya.

operator aritmatika

Tabel berikut menunjukkan C # dukungan semua operator aritmatika.Sebuah nilai 10 diasumsikan variabel, variabel Badalah 20, maka:

运算符描述实例
+把两个操作数相加 A + B 将得到 30
-从第一个操作数中减去第二个操作数 A - B 将得到 -10
*把两个操作数相乘 A * B 将得到 200
/分子除以分母 B / A 将得到 2
%取模运算符，整除后的余数 B % A 将得到 0
++自增运算符，整数值增加 1 A++ 将得到 11
--自减运算符，整数值减少 1 A-- 将得到 9

contoh

Perhatikan contoh berikut untuk belajar C # semua operator aritmatika yang tersedia: 

menggunakan System;

OperatorsAppl namespace
{
    Program kelas
    {
        static void Main (string [] args)
        {
            int a = 21;
            int b = 10;
            int c;

            c = a + b;
            Console.WriteLine ( "1 Line - c adalah {0}", c);
            c = a - b;
            Console.WriteLine ( "2 Line - c adalah {0}", c);
            c = a * b;
            Console.WriteLine ( "3 Line - c adalah {0}", c);
            c = a / b;
            Console.WriteLine ( "4 Line - c adalah {0}", c);
            c = a% b;
            Console.WriteLine ( "Line 5 - c adalah {0}", c);

            // ++ Sebuah operasi increment pertama dilakukan oleh tugas c = ++ a;
            Console.WriteLine ( "6 Line - c adalah {0}", c);

            // Dalam hal ini nilai 22
            // -sebuah Pertama pengurangan diri dengan tugas c = -sebuah;
            Console.WriteLine ( "7 Line - c adalah {0}", c);
            Console.ReadLine ();
        }
    }
}

Ketika kode di atas dikompilasi dan dijalankan, menghasilkan hasil sebagai berikut: 

1 Line - nilai c adalah 31
2 Line - nilai c adalah 11
3 Line - adalah nilai c 210
4 Line - nilai c adalah 2
Baris 5 - nilai c adalah 1
6 Line - nilai c adalah 22
7 Line - nilai c adalah 21
  • c = a ++: tugas pertama yang c, dan kemudian pada operator diri increment.
  • c = ++ a: pertama operator diri increment, dan kemudian ditugaskan ke c.
  • c = a--: tugas pertama yang c, dan kemudian pada diri pengurangan.
  • c = -sebuah: pertama diri pengurangan, kemudian ditugaskan ke 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();
        }
    }
}

Menjalankan contoh »

Program di atas, output adalah: 

a = 2
b = 1
a = 2
b = 2
a = 0
b = 1
a = 0
b = 0

Operator relasional

Tabel berikut menunjukkan C # dukungan semua operator relasional.Sebuah nilai 10 diasumsikan variabel, variabel Badalah 20, maka:

运算符描述实例
==检查两个操作数的值是否相等，如果相等则条件为真。 (A == B) 不为真。
!=检查两个操作数的值是否相等，如果不相等则条件为真。 (A != B) 为真。
>检查左操作数的值是否大于右操作数的值，如果是则条件为真。 (A > B) 不为真。
<检查左操作数的值是否小于右操作数的值，如果是则条件为真。 (A < B) 为真。
>=检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 (A >= B) 不为真。
<=检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 (A <= B) 为真。

contoh

Perhatikan contoh berikut untuk belajar C # semua operator relasional yang tersedia: 

menggunakan System;

Program kelas
{
  static void Main (string [] args)
  {
      int a = 21;
      int b = 10;
      
      if (a == b)
      {
          Console.WriteLine ( "Line 1 - adalah sama dengan b");
      }
      lain
      {
          Console.WriteLine ( "Line 1 - tidak sama dengan b");
      }
      if (a <b)
      {
          Console.WriteLine ( "Line 2 - kurang dari b");
      }
      lain
      {
          Console.WriteLine ( "Line 2 - tidak kurang dari b");
      }
      jika (a> b)
      {
          Console.WriteLine ( "Jalur 3 - a lebih besar dari b");
      }
      lain
      {
          Console.WriteLine ( "Jalur 3 - tidak lebih besar dari b");
      }
      / * Ubah nilai a dan b * /
      a = 5;
      b = 20;
      if (a <= b)
      {
         Console.WriteLine ( "Line 4 - kurang dari atau sama dengan b");
      }
      jika (b> = a)
      {
         Console.WriteLine ( "Line 5 - b lebih besar dari atau sama dengan");
      }
  }
}

Ketika kode di atas dikompilasi dan dijalankan, menghasilkan hasil sebagai berikut: 

Baris 1 - tidak sama dengan b
Jalur 2 - tidak kurang dari b
Jalur 3 - a lebih besar dari b
Baris 4 - a kurang dari atau sama dengan b
Baris 5 - b lebih besar dari atau sama dengan

Operator logis

Tabel berikut menunjukkan C # dukungan semua operator logika. Misalkan variabel nilaiA Boolean benar, variabel Badalah nilai Boolean false, maka:

运算符描述实例
&&称为逻辑与运算符。如果两个操作数都非零，则条件为真。 (A && B) 为假。
||称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (A || B) 为真。
!称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 !(A && B) 为真。

contoh

Perhatikan contoh berikut untuk belajar C # semua operator logis yang tersedia: 

menggunakan System;

OperatorsAppl namespace
{
    Program kelas
    {
        static void Main (string [] args)
        {
            bool = true;
            bool b = true;
           
            jika (a && b)
            {
               Console.WriteLine ( "Line 1 - kondisi benar");
            }
            jika (a || b)
            {
                Console.WriteLine ( "Line 2 - kondisi benar");
            }
            / * Ubah nilai a dan b * /
            a = false;
            b = true;
            jika (a && b)
            {
                Console.WriteLine ( "Jalur 3 - kondisi benar");
            }
            lain
            {
                Console.WriteLine ( "Jalur 3 - kondisi ini tidak benar");
            }
            if (! (a && b))
            {
                Console.WriteLine ( "Line 4 - kondisi benar");
            }
            Console.ReadLine ();
        }
    }
}

Ketika kode di atas dikompilasi dan dijalankan, menghasilkan hasil sebagai berikut: 

Baris 1 - kondisi benar Jalur 2 - kondisi ini benar Jalur 3 - kondisi ini tidak benar Jalur 4 - kondisi benar

bitwise Operator

operator bitwise yang bekerja pada bit, dan bit dengan operasi bit. &, | Dan ^ tabel kebenaran adalah sebagai berikut:

pqp & qp | qp ^ q
00000
01011
11110
10011

Misalkan jika A = 60, dan B = 13, dan sekarang, dalam bentuk biner, adalah sebagai berikut:

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~ A = 1100 0011

Tabel berikut berisi daftar C # operator dukungan bitwise. Misalkan variabelA adalah 60, nilai variabel B13, maka:

运算符描述实例
&如果同时存在于两个操作数中，二进制 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

contoh

Perhatikan contoh berikut untuk belajar C #, semua operator bit yang tersedia: 

menggunakan System;
OperatorsAppl namespace
{
    Program kelas
    {
        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 adalah {0}", c);

             c = a | b; / * 61 = 0011 1101 * /
             Console.WriteLine ( "2 Line - c adalah {0}", c);

             c = a ^ b; / * 49 = 0011 0001 * /
             Console.WriteLine ( "3 Line - c adalah {0}", c);

             c = ~ a; / * - 61 = 1100 0011 * /
             Console.WriteLine ( "4 Line - c adalah {0}", c);

             c = a << 2; / * 240 = 1111 0000 * /
             Console.WriteLine ( "Line 5 - c adalah {0}", c);

             c = a >> 2; / * 15 = 0000 1111 * /
             Console.WriteLine ( "6 Line - c adalah {0}", c);
            Console.ReadLine ();
        }
    }
}

Ketika kode di atas dikompilasi dan dijalankan, menghasilkan hasil sebagai berikut: 

1 Line - nilai c adalah 12
2 Line - nilai c adalah 61
3 Line - nilai c adalah 49
4 Line - nilai c adalah -61
Baris 5 - nilai c adalah 240
6 Line - nilai c adalah 15

Operator penugasan

Tabel berikut berisi daftar C # mendukung operator penugasan:

运算符描述实例
=简单的赋值运算符，把右边操作数的值赋给左边操作数 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

contoh

Perhatikan contoh berikut untuk belajar C # di semua operator penugasan yang tersedia: 

menggunakan System;

OperatorsAppl namespace
{
    Program kelas
    {
        static void Main (string [] args)
        {
            int a = 21;
            int c;

            c = a;
            Console.WriteLine ( "Line 1 - value = c = {0}", c);

            c + = a;
            Console.WriteLine ( "Line 2 - nilai + = c = {0}", c);

            c - = a;
            Console.WriteLine ( "Jalur 3 - - value = c = {0}", c);

            c * = a;
            Console.WriteLine ( "Line 4 - nilai * = c = {0}", c);

            c / = a;
            Console.WriteLine ( "Line 5 - nilai / = c = {0}", c);

            c = 200;
            c% = a;
            Console.WriteLine ( "Line 6 - nilai% = c = {0}", c);

            c << = 2;
            Console.WriteLine ( "Line 7 - << = c value = {0}", c);

            c >> = 2;
            Console.WriteLine ( "Line 8 - >> = nilai c = {0}", c);

            c & = 2;
            Console.WriteLine ( "Line 9 - & = c value = {0}", c);

            c ^ = 2;
            Console.WriteLine ( "Line 10 - nilai ^ = c = {0}", c);

            c | = 2;
            Console.WriteLine ( "Line 11 - | = c value = {0}", c);
            Console.ReadLine ();
        }
    }
}

Ketika kode di atas dikompilasi dan dijalankan, menghasilkan hasil sebagai berikut: 

Baris 1 - = c = nilai 21
Jalur 2 - + = nilai c = 42
3 Line - - = nilai c = 21
4 Line - * = nilai c = 441
Baris 5 - / = c = nilai 21
6 Line -% = nilai c = 11
7 Line - << = nilai c = 44
8 Line - nilai >> = c = 11
9 Line - & = nilai c = 2
Baris 10 - ^ = c = 0 nilai
Line 11 - | = c 2 = nilai

Operator Miscellaneous

Tabel berikut berisi daftar C # mendukung beberapa operator penting lainnya, termasuksizeof, typeofdan?:.

operator deskripsi contoh sizeof () Kembali ukuran tipe data. sizeof (int), akan kembali 4. typeof () Mengembalikan jenis kelas. typeof (StreamReader); & Kembali variabel alamat. & A, Anda akan mendapatkan alamat yang sebenarnya dari variabel. * variabel pointer. * A; akan menunjuk ke variabel. ?: ekspresi kondisional ? Jika kondisi benar, atau X: Y dinyatakan adalah Menentukan apakah sebuah objek dari jenis tertentu. Jika (Ford adalah mobil) // memeriksa apakah sebuah objek kelas Ford Mobil. sebagai Cast, bahkan jika konversi gagal tidak akan melemparkan sebuah pengecualian. Object obj = new StringReader ( "Hello");
StringReader r = obj sebagai StringReader;

contoh 

menggunakan System;

OperatorsAppl namespace
{
    
   Program kelas
   {
      static void Main (string [] args)
      {
         
         / * Sizeof Operator contoh * /
         Console.WriteLine ( "ukuran int adalah {0}", sizeof (int));
         Console.WriteLine ( "ukuran pendek {0}", sizeof (pendek));
         Console.WriteLine ( "dua kali lipat ukuran {0}", sizeof (double));
         
         / * Operator Ternary istirahat contoh * /
         int a, b;
         a = 10;
         b = (a == 1) 20: 30 ;?
         Console.WriteLine ( "b nilai-nilai {0}", b);

         b = (a == 10) 20: 30 ;?
         Console.WriteLine ( "b nilai-nilai {0}", b);
         Console.ReadLine ();
      }
   }
}

Ketika kode di atas dikompilasi dan dijalankan, menghasilkan hasil sebagai berikut: 

int size adalah 4
ukuran pendek 2
Ukuran ganda adalah 8
nilai b adalah 30
nilai b adalah 20

Dalam C didahulukan # Operator

operator didahulukan menentukan jangka gabungan ekspresi. Hal ini mempengaruhi bagaimana perhitungan ekspresi. Beberapa operator memiliki prioritas yang lebih tinggi daripada operator lain, seperti penambahan dan pengurangan, perkalian dan divisi operator dari operator prioritas yang lebih tinggi.

Misalnya, x = 7 + 3 * 2, di mana, x ditugaskan untuk 13 bukan 20, karena operator * memiliki hak lebih tinggi dari +, jadi pertama menghitung perkalian 3 * 2, kemudian tambahkan 7.

Tabel berikut akan terdaftar dalam urutan prioritas operator untuk setiap operator, memiliki operator prioritas yang lebih tinggi di atas muncul dalam tabel, dengan operator prioritas berikut rendah muncul di tabel. Dalam ekspresi, prioritas operator prioritas yang lebih tinggi dihitung.

类别  运算符 结合性 
后缀 () [] -> . ++ - -   从左到右 
一元  + - ! ~ ++ - - (type)* & sizeof  从右到左 
乘除  * / % 从左到右 
加减 + -  从左到右 
移位  << >>  从左到右 
关系 < <= > >=  从左到右 
相等  == !=  从左到右 
位与 AND &  从左到右 
位异或 XOR  ^  从左到右 
位或 OR  |  从左到右 
逻辑与 AND &&  从左到右 
逻辑或 OR  ||  从左到右 
条件 ?:  从右到左 
赋值  = += -= *= /= %=>>= <<= &= ^= |= 从右到左 
逗号  ,  从左到右 

contoh 

menggunakan System;

OperatorsAppl namespace
{
    
   Program kelas
   {
      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 adalah {0}", e);

         e = (a + b) * (c / d); // (30) * (15/5)
         Console.WriteLine ( "(a + b) * (c / d) nilai-nilai {0}", e);

         e = a + (b * c) / d; // 20 + (150/5)
         Console.WriteLine ( "nilai a + (b * c) / d adalah {0}", e);
         Console.ReadLine ();
      }
   }
}

Ketika kode di atas dikompilasi dan dijalankan, menghasilkan hasil sebagai berikut: 

Nilai (a + b) * c / d 90
Nilai ((a + b) * c) / d 90
(A + b) * (c / d) nilai adalah 90
Nilai a + (b * c) / d 50

Tutorial Panas

Hubungi kami

C # Operator
10/30