Bit düzeyinde and Shift işleçleri (C# Başvurusu)

Aşağıdaki işleçler integral sayısal türlerin veya char türünün işlenenleri ile bit düzeyinde veya SHIFT işlemleri gerçekleştirir:

• Birli ~ (bit düzeyinde tamamlama) işleci
• İkili << (sol SHIFT) ve >> (sağ SHIFT) kaydırma işleçleri
• İkili & (mantıksal ve), | (mantıksal or)ve ^ (mantıksal dışlamalı veya) işleçler

Bu işleçler,,, int uint long ve türleri için tanımlanır ulong . Her iki işlenen de diğer integral türlerinde ( sbyte , byte ,, short ushort veya char ) olduğunda, değerleri int bir işlemin sonuç türü olan türüne dönüştürülür. İşlenenler farklı integral türlerindiğinde, değerleri, en yakın integral türüne dönüştürülür. Daha fazla bilgi için C# dil belirtiminin sayısal yükseltmeler bölümüne bakın.

&, | Ve ^ işleçleri tür işlenenleri için de tanımlanmıştır bool . Daha fazla bilgi için bkz. Boolean mantıksal işleçler.

Bit düzeyinde ve kaydırma işlemleri hiçbir şekilde taşmaya neden olmaz ve denetlenen ve işaretlenmeyen bağlamlarda aynı sonuçları üretir.

Bit düzeyinde tamamlama işleci ~

~İşleci her bir biti ters çevirerek işleneni bir bit düzeyinde tamamlayıcı üretir:

uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Console.WriteLine(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011

~Sonlandırıcıları bildirmek için sembolünü de kullanabilirsiniz. Daha fazla bilgi için bkz. sonlandırıcılar.

Sola kaydırma işleci <<

<<İşleci sol taraftaki işlenenini sağ işleneni tarafından tanımlanan bit sayısınagöre sola kaydırır.

Aşağıdaki örnekte gösterildiği gibi, sol SHIFT işlemi, sonuç türü aralığının dışındaki yüksek sıralı bitleri atar ve düşük sıralı boş bit konumlarını sıfıra ayarlar:

uint x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Console.WriteLine($"Before: {Convert.ToString(x, toBase: 2)}");

uint y = x << 4;
Console.WriteLine($"After:  {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After:  10010000000000000000000100010000

SHIFT işleçleri yalnızca,, ve türleri için tanımlandığından int , uint long ulong bir işlemin sonucu her zaman en az 32 bit içerir. Sol işlenen başka bir integral türü ( sbyte , byte ,, short ushort , veya char ) ise, int Aşağıdaki örnekte gösterildiği gibi, değeri türüne dönüştürülür:

byte a = 0b_1111_0001;

var b = a << 8;
Console.WriteLine(b.GetType());
Console.WriteLine($"Shifted byte: {Convert.ToString(b, toBase: 2)}");
// Output:
// System.Int32
// Shifted byte: 1111000100000000

İşlecin sağ işleneninin kaydırma sayısını tanımladığı hakkında daha fazla bilgi için << SHIFT Operators bölümünün kaydırma sayısını inceleyin.

Sağa kaydırma işleci >>

>>İşleci, sol işlenenin sağ işleneni tarafından tanımlanan bit sayısınagöre sağa kayar.

Aşağıdaki örnekte gösterildiği gibi, doğru kaydırma işlemi düşük sıralı bitleri atar:

uint x = 0b_1001;
Console.WriteLine($"Before: {Convert.ToString(x, toBase: 2), 4}");

uint y = x >> 2;
Console.WriteLine($"After:  {Convert.ToString(y, toBase: 2), 4}");
// Output:
// Before: 1001
// After:    10

Yüksek sıralı boş bit konumları, sol taraftaki işlenenin türüne göre aşağıdaki gibi ayarlanır:

• Sol işlenen türü int veya ise long , sağ SHIFT işleci bir Aritmetik kaydırma gerçekleştirir: sol işlenenin en önemli bit (işaret biti) değeri, yüksek sıralı boş bit konumlarına yayılır. Diğer bir deyişle, sol işlenen negatif olmayan ve negatifse bir tane olarak ayarlandıysa, yüksek sıralı boş bit konumları sıfır olarak ayarlanır.

  int a = int.MinValue;
  Console.WriteLine($"Before: {Convert.ToString(a, toBase: 2)}");
  
  int b = a >> 3;
  Console.WriteLine($"After:  {Convert.ToString(b, toBase: 2)}");
  // Output:
  // Before: 10000000000000000000000000000000
  // After:  11110000000000000000000000000000
  

• Sol işlenen veya türünde ise uint ulong , sağ SHIFT işleci bir mantıksal kaydırma gerçekleştirir: yüksek sıralı boş bit konumları her zaman sıfır olarak ayarlanır.

  uint c = 0b_1000_0000_0000_0000_0000_0000_0000_0000;
  Console.WriteLine($"Before: {Convert.ToString(c, toBase: 2), 32}");
  
  uint d = c >> 3;
  Console.WriteLine($"After:  {Convert.ToString(d, toBase: 2), 32}");
  // Output:
  // Before: 10000000000000000000000000000000
  // After:     10000000000000000000000000000
  

İşlecin sağ işleneninin kaydırma sayısını tanımladığı hakkında daha fazla bilgi için >> SHIFT Operators bölümünün kaydırma sayısını inceleyin.

Mantıksal AND işleci &

&İşleci, tam sayı işlenenlerinin bit düzeyinde MANTıKSAL ve işlecini hesaplar:

uint a = 0b_1111_1000;
uint b = 0b_1001_1101;
uint c = a & b;
Console.WriteLine(Convert.ToString(c, toBase: 2));
// Output:
// 10011000

boolİşlenenler için işleç, & işlenenlerinin mantıksal ve işlecini hesaplar. Birli & işleç Adres işleçtir.

Mantıksal dışlamalı OR işleci ^

^İşleci, tam bit düzeyinde mantıksal dışlamalı veya tam sayı işlenenlerinin bit düzeyinde MANTıKSAL XOR olarak da bilinen değerini hesaplar:

uint a = 0b_1111_1000;
uint b = 0b_0001_1100;
uint c = a ^ b;
Console.WriteLine(Convert.ToString(c, toBase: 2));
// Output:
// 11100100

boolİşlenenler için işleç, ^ işlenenlerinin MANTıKSAL dışlamalı veya ' ı hesaplar.

Mantıksal OR işleci |

|İşleci, tamsayı işlenenlerinin bit düzeyinde MANTıKSAL veya bir değerini hesaplar:

uint a = 0b_1010_0000;
uint b = 0b_1001_0001;
uint c = a | b;
Console.WriteLine(Convert.ToString(c, toBase: 2));
// Output:
// 10110001

boolİşlenenler için işleç, | işlenenlerinin mantıksal veya işlecini hesaplar.

Bileşik atama

Bir ikili işleci için op , formun bileşik atama ifadesi

x op= y

eşdeğerdir

x = x op y

hariç x yalnızca bir kez değerlendirilir.

Aşağıdaki örnek, bileşik atamanın bit düzeyinde ve kaydırma işleçleriyle kullanımını gösterir:

uint INITIAL_VALUE = 0b_1111_1000;

uint a = INITIAL_VALUE;
a &= 0b_1001_1101; 
Display(a);  // output: 10011000

a = INITIAL_VALUE;
a |= 0b_0011_0001; 
Display(a);  // output: 11111001

a = INITIAL_VALUE;
a ^= 0b_1000_0000;
Display(a);  // output: 1111000

a = INITIAL_VALUE;
a <<= 2;
Display(a);  // output: 1111100000

a = INITIAL_VALUE;
a >>= 4;
Display(a);  // output: 1111

void Display(uint x) => Console.WriteLine($"{Convert.ToString(x, toBase: 2), 8}");

Sayısal yükseltmelernedeniyle, op işlemin sonucu örtük olarak türüne dönüştürülebilir olmayabilir T x . Böyle bir durumda, op önceden tanımlanmış bir işleçse ve işlemin sonucu türüne açıkça dönüştürülebilir ise, T x formun bileşik atama ifadesi x op= y öğesine eşdeğerdir x = (T)(x op y) , ancak x yalnızca bir kez değerlendirilir. Aşağıdaki örnekte bu davranış gösterilmektedir:

byte x = 0b_1111_0001;

int b = x << 8;
Console.WriteLine($"{Convert.ToString(b, toBase: 2)}");  // output: 1111000100000000

x <<= 8;
Console.WriteLine(x);  // output: 0

İşleç önceliği

Aşağıdaki liste, en yüksek öncelikten en düşüğe başlayarak bit düzeyinde ve kaydırma işleçlerini sıralar:

• Bit düzeyinde tamamlama işleci ~
• SHIFT işleçleri << ve >>
• Mantıksal AND işleci &
• Mantıksal dışlamalı OR işleci ^
• Mantıksal OR işleci |

()İşleç önceliğine göre uygulanan değerlendirmenin sırasını değiştirmek için parantezleri kullanın:

uint a = 0b_1101;
uint b = 0b_1001;
uint c = 0b_1010;

uint d1 = a | b & c;
Display(d1);  // output: 1101

uint d2 = (a | b) & c;
Display(d2);  // output: 1000

void Display(uint x) => Console.WriteLine($"{Convert.ToString(x, toBase: 2), 4}");

Öncelik düzeyine göre sıralanan C# işleçlerinin tüm listesi için c# işleçleri makalesinin operatör önceliği bölümüne bakın.

Kaydırma işleçlerinin kaydırma sayısı

SHIFT işleçleri ve için << >> sağ işlenen türü int veya önceden tanımlanmış örtük sayısal dönüştürmeye sahip bir tür olmalıdır int .

x << countVe ifadeleri için x >> count , gerçek kaydırma sayısı x aşağıdaki şekilde türüne bağlıdır:

• Türü x int veya ise uint , kaydırma sayısı sağ işlenenin düşük sıralı beş biti tarafından tanımlanır. Diğer bir deyişle, kaydırma sayısı count & 0x1F (veya) öğesinden hesaplanır count & 0b_1_1111 .

• Türü x long veya ise ulong , kaydırma sayısı sağ işlenenin alt-sırası altı bitsiyle tanımlanır. Diğer bir deyişle, kaydırma sayısı count & 0x3F (veya) öğesinden hesaplanır count & 0b_11_1111 .

Aşağıdaki örnekte bu davranış gösterilmektedir:

int count1 = 0b_0000_0001;
int count2 = 0b_1110_0001;

int a = 0b_0001;
Console.WriteLine($"{a} << {count1} is {a << count1}; {a} << {count2} is {a << count2}");
// Output:
// 1 << 1 is 2; 1 << 225 is 2

int b = 0b_0100;
Console.WriteLine($"{b} >> {count1} is {b >> count1}; {b} >> {count2} is {b >> count2}");
// Output:
// 4 >> 1 is 2; 4 >> 225 is 2

Sabit listesi mantıksal işleçleri

~,, & | Ve ^ işleçleri her bir numaralandırma türü tarafından da desteklenir. Aynı numaralandırma türünün işlenenleri için, temel alınan integral türünün karşılık gelen değerlerinde bir mantıksal işlem gerçekleştirilir. Örneğin, x y temel alınan bir tür ve bir numaralandırma türü için T ifade, U x & y ifadesiyle aynı sonucu üretir (T)((U)x & (U)y) .

Genellikle, Flags özniteliğiyle tanımlanan bir numaralandırma türü ile bit düzeyinde mantıksal işleçler kullanırsınız. Daha fazla bilgi için Listeleme türleri makalesinin numaralandırma türleri bit bayrakları bölümüne bakın.

Operatör overloadability

Kullanıcı tanımlı bir tür,, ,, ~ , << >> & | ve ^ işleçlerini aşırı yükleyebilir. İkili işleç aşırı yüklendiğinde, karşılık gelen bileşik atama işleci de örtük olarak aşırı yüklenmiştir. Kullanıcı tanımlı bir tür, bileşik atama işlecini açıkça aşırı yükleyemez.

Kullanıcı tanımlı bir tür T << veya işlecini aşırı >> yükletir, sol taraftaki işlenenin türü olmalıdır T ve sağ işlenen türü olmalıdır int .

C# dili belirtimi

Daha fazla bilgi için C# dil belirtimininaşağıdaki bölümlerine bakın:

• Bit düzeyinde tamamlama işleci
• Kaydırma işleçleri
• Mantıksal işleçler
• Bileşik atama
• Sayısal yükseltmeler

Ayrıca bkz.

• C# başvurusu
• C# işleçleri ve ifadeleri
• Boole mantıksal işleçleri