C# Programlama Dilinde Operatörler: Kapsamlı Bir Bakış

C# programlama dilinde operatörler, değişkenler ve değerler üzerinde çeşitli işlemler gerçekleştirmek için kullanılan özel sembollerdir. Bu işlemler aritmetik hesaplamalardan, karşılaştırmalara, mantıksal değerlendirmelere ve bit düzeyinde manipülasyonlara kadar uzanabilir. Operatörler, C# kodunun temel yapı taşlarından biridir ve programların dinamik ve etkileşimli olmasını sağlar.

Aritmetik Operatörler

Aritmetik operatörler, matematiksel hesaplamalar yapmak için kullanılır. C# dilinde en sık kullanılan aritmetik operatörler şunlardır:

• + (Toplama): İki değeri toplar.
• – (Çıkarma): İki değeri çıkarır.
• * (Çarpma): İki değeri çarpar.
• / (Bölme): İki değeri böler.
• % (Mod Alma): Bir bölme işleminden kalanı bulur.
• ++ (Artırma): Bir değişkenin değerini 1 artırır.
• — (Azaltma): Bir değişkenin değerini 1 azaltır.

Aşağıdaki örnek, aritmetik operatörlerin kullanımını göstermektedir:

int a = 10;
int b = 5;

int toplam = a + b; // toplam = 15
int fark = a - b; // fark = 5
int carpim = a * b; // carpim = 50
int bolum = a / b; // bolum = 2
int kalan = a % b; // kalan = 0

a++; // a = 11
b--; // b = 4

Karşılaştırma Operatörleri

Karşılaştırma operatörleri, iki değeri karşılaştırmak ve bir bool (true veya false) sonuç döndürmek için kullanılır. C# dilinde yaygın olarak kullanılan karşılaştırma operatörleri şunlardır:

• == (Eşittir): İki değerin eşit olup olmadığını kontrol eder.
• != (Eşit Değildir): İki değerin eşit olup olmadığını kontrol eder.
• > (Büyüktür): Bir değerin diğerinden büyük olup olmadığını kontrol eder.
• < (Küçüktür): Bir değerin diğerinden küçük olup olmadığını kontrol eder.
• >= (Büyük Eşittir): Bir değerin diğerinden büyük veya eşit olup olmadığını kontrol eder.
• <= (Küçük Eşittir): Bir değerin diğerinden küçük veya eşit olup olmadığını kontrol eder.

Aşağıdaki örnek, karşılaştırma operatörlerinin kullanımını göstermektedir:

int a = 10;
int b = 5;

bool esitMi = (a == b); // esitMi = false
bool esitDegilMi = (a != b); // esitDegilMi = true
bool buyukMu = (a > b); // buyukMu = true
bool kucukMu = (a < b); // kucukMu = false
bool buyukEsitMi = (a >= b); // buyukEsitMi = true
bool kucukEsitMi = (a <= b); // kucukEsitMi = false

Mantıksal Operatörler

Mantıksal operatörler, birden fazla bool ifadeyi birleştirmek veya bir bool ifadenin değerini tersine çevirmek için kullanılır. C# dilinde kullanılan mantıksal operatörler şunlardır:

• && (VE): İki ifade de true ise true döndürür.
• || (VEYA): İki ifadeden en az biri true ise true döndürür.
• ! (DEĞİL): Bir ifadenin değerini tersine çevirir.

Aşağıdaki örnek, mantıksal operatörlerin kullanımını göstermektedir:

bool a = true;
bool b = false;

bool veSonucu = (a && b); // veSonucu = false
bool veyaSonucu = (a || b); // veyaSonucu = true
bool degilA = !a; // degilA = false

Bitwise (Bitsel) Operatörler

Bitsel operatörler, sayısal değerlerin bitleri üzerinde doğrudan işlem yapmak için kullanılır. Bu operatörler genellikle düşük seviyeli programlama veya performans kritik uygulamalarda kullanılır. C# dilinde bulunan bitsel operatörler şunlardır:

• & (Bitsel VE): İki değerin karşılık gelen bitleri 1 ise 1, aksi takdirde 0 döndürür.
• | (Bitsel VEYA): İki değerin karşılık gelen bitlerinden en az biri 1 ise 1, aksi takdirde 0 döndürür.
• ^ (Bitsel XOR): İki değerin karşılık gelen bitleri farklı ise 1, aynı ise 0 döndürür.
• ~ (Bitsel TÜMLEME): Bir değerin tüm bitlerini tersine çevirir (1’ler 0 olur, 0’lar 1 olur).
• << (Sola Kaydırma): Bir değerin bitlerini sola kaydırır.
• >> (Sağa Kaydırma): Bir değerin bitlerini sağa kaydırır.

Aşağıdaki örnek, bitsel operatörlerin kullanımını göstermektedir:

int a = 5; // 0101
int b = 3; // 0011

int bitselVe = a & b; // bitselVe = 1 (0001)
int bitselVeya = a | b; // bitselVeya = 7 (0111)
int bitselXor = a ^ b; // bitselXor = 6 (0110)
int bitselTumlemeA = ~a; // bitselTumlemeA = -6 (11111111111111111111111111111010 - 32-bit signed integer)
int solaKaydirma = a << 1; // solaKaydirma = 10 (1010)
int sagaKaydirma = a >> 1; // sagaKaydirma = 2 (0010)

Atama Operatörleri

Atama operatörleri, bir değişkene değer atamak için kullanılır. En temel atama operatörü =‘dir. C# ayrıca, aritmetik ve bitsel operatörlerle birleştirilmiş bileşik atama operatörlerini de destekler:

• = (Atama): Bir değişkene bir değer atar.
• += (Toplama ve Atama): Bir değişkene bir değer ekler ve sonucu değişkene atar.
• -= (Çıkarma ve Atama): Bir değişkenden bir değer çıkarır ve sonucu değişkene atar.
• *= (Çarpma ve Atama): Bir değişkeni bir değerle çarpar ve sonucu değişkene atar.
• /= (Bölme ve Atama): Bir değişkeni bir değere böler ve sonucu değişkene atar.
• %= (Mod Alma ve Atama): Bir değişkenin bir değere göre modunu alır ve sonucu değişkene atar.
• &= (Bitsel VE ve Atama): Bir değişkenle bir değerin bitsel VE işlemini yapar ve sonucu değişkene atar.
• |= (Bitsel VEYA ve Atama): Bir değişkenle bir değerin bitsel VEYA işlemini yapar ve sonucu değişkene atar.
• ^= (Bitsel XOR ve Atama): Bir değişkenle bir değerin bitsel XOR işlemini yapar ve sonucu değişkene atar.
• <<= (Sola Kaydırma ve Atama): Bir değişkenin bitlerini sola kaydırır ve sonucu değişkene atar.
• >>= (Sağa Kaydırma ve Atama): Bir değişkenin bitlerini sağa kaydırır ve sonucu değişkene atar.

Aşağıdaki örnek, atama operatörlerinin kullanımını göstermektedir:

int a = 10;

a += 5; // a = 15 (a = a + 5)
a -= 3; // a = 12 (a = a - 3)
a *= 2; // a = 24 (a = a * 2)
a /= 4; // a = 6 (a = a / 4)
a %= 5; // a = 1 (a = a % 5)

Diğer Operatörler

C# dilinde yukarıda bahsedilenlerin dışında da operatörler bulunmaktadır. Bunlardan bazıları şunlardır:

• ?? (Null-coalescing Operator): Bir ifadenin null olup olmadığını kontrol eder ve null ise varsayılan bir değer döndürür.
• . (Üye Erişim Operatörü): Bir nesnenin üyelerine (metot, özellik, alan vb.) erişmek için kullanılır.
• [] (Dizi Erişim Operatörü): Bir dizinin belirli bir elemanına erişmek için kullanılır.
• () (Metot Çağırma Operatörü): Bir metodu çağırmak için kullanılır.
• as (Tip Dönüşüm Operatörü): Bir nesneyi belirli bir türe dönüştürmeye çalışır. Dönüşüm başarısız olursa null döndürür.
• is (Tip Kontrol Operatörü): Bir nesnenin belirli bir türde olup olmadığını kontrol eder.
• ?: (Koşullu Operatör – Ternary Operator): Bir koşulu değerlendirir ve koşul doğruysa bir değer, yanlışsa başka bir değer döndürür.

Sonuç

C# programlama dilinde operatörler, programların temel yapı taşlarından biridir. Bu operatörler, değişkenler ve değerler üzerinde çeşitli işlemler gerçekleştirerek programların dinamik ve etkileşimli olmasını sağlar. Bu makalede, C# dilinde en sık kullanılan operatörler ayrıntılı olarak açıklanmıştır. Umarım bu bilgiler, C# programlama becerilerinizi geliştirmenize yardımcı olur.

5. Operatörler (Aritmetik, Karşılaştırma, Mantıksal, Bitwise, vb.) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.

Delphi Programlama Dilinde Operatörler (Aritmetik, Karşılaştırma, Mantıksal, Bitwise, vb.)

Delphi programlama dilinde operatörler, değişkenler ve değerler üzerinde çeşitli işlemler gerçekleştirmek için kullanılan sembollerdir. Bu operatörler, matematiksel hesaplamalar, karşılaştırmalar, mantıksal işlemler ve bit düzeyinde manipülasyonlar gibi birçok farklı görevi yerine getirebilir. Bu makalede, Delphi’deki temel operatör türlerini ve kullanımlarını ayrıntılı olarak inceleyeceğiz.

Aritmetik Operatörler

Aritmetik operatörler, matematiksel hesaplamalar yapmak için kullanılır. Delphi’de yaygın olarak kullanılan aritmetik operatörler şunlardır:

• + (Toplama): İki değeri toplar.
• – (Çıkarma): İki değeri çıkarır.
• * (Çarpma): İki değeri çarpar.
• / (Bölme): İki değeri böler (gerçek sayı sonucu verir).
• div (Tamsayı Bölme): İki değeri böler ve tamsayı kısmını döndürür.
• mod (Mod Alma): İki değerin bölümünden kalanı döndürür.

Örneğin:

var
  sayi1, sayi2, toplam, fark, carpim, bolum, tamsayiBolum, kalan: Integer;
begin
  sayi1 := 10;
  sayi2 := 3;

  toplam := sayi1 + sayi2; // toplam = 13
  fark := sayi1 - sayi2;   // fark = 7
  carpim := sayi1 * sayi2;  // carpim = 30
  bolum := sayi1 / sayi2;  // bolum = 3.333...
  tamsayiBolum := sayi1 div sayi2; // tamsayiBolum = 3
  kalan := sayi1 mod sayi2;  // kalan = 1
end;

Karşılaştırma Operatörleri

Karşılaştırma operatörleri, iki değeri karşılaştırmak ve bir Boolean (True veya False) sonuç döndürmek için kullanılır. Delphi’deki temel karşılaştırma operatörleri şunlardır:

• = (Eşittir): İki değerin eşit olup olmadığını kontrol eder.
• <> (Eşit Değildir): İki değerin eşit olmadığını kontrol eder.
• > (Büyüktür): Bir değerin diğerinden büyük olup olmadığını kontrol eder.
• < (Küçüktür): Bir değerin diğerinden küçük olup olmadığını kontrol eder.
• >= (Büyük Eşittir): Bir değerin diğerinden büyük veya eşit olup olmadığını kontrol eder.
• <= (Küçük Eşittir): Bir değerin diğerinden küçük veya eşit olup olmadığını kontrol eder.

Örneğin:

var
  sayi1, sayi2: Integer;
  sonuc: Boolean;
begin
  sayi1 := 10;
  sayi2 := 5;

  sonuc := sayi1 = sayi2; // sonuc = False
  sonuc := sayi1 <> sayi2; // sonuc = True
  sonuc := sayi1 > sayi2;  // sonuc = True
  sonuc := sayi1 < sayi2;  // sonuc = False
  sonuc := sayi1 >= sayi2; // sonuc = True
  sonuc := sayi1 <= sayi2; // sonuc = False
end;

Mantıksal Operatörler

Mantıksal operatörler, Boolean değerler üzerinde mantıksal işlemler yapmak için kullanılır. Delphi’deki temel mantıksal operatörler şunlardır:

• and (Ve): İki ifade de True ise True döndürür.
• or (Veya): İki ifadeden en az biri True ise True döndürür.
• not (Değil): Bir ifadenin değerini tersine çevirir.
• xor (Özel Veya): İki ifadenin değeri farklı ise True döndürür.

Örneğin:

var
  durum1, durum2, sonuc: Boolean;
begin
  durum1 := True;
  durum2 := False;

  sonuc := durum1 and durum2; // sonuc = False
  sonuc := durum1 or durum2;  // sonuc = True
  sonuc := not durum1;   // sonuc = False
  sonuc := durum1 xor durum2;  // sonuc = True
end;

Bitwise Operatörler

Bitwise operatörler, tamsayı değerlerinin bit düzeyinde manipülasyonunu sağlamak için kullanılır. Bu operatörler, özellikle düşük seviyeli programlama ve donanım etkileşimi gerektiren durumlarda faydalıdır. Delphi’deki temel bitwise operatörler şunlardır:

• and (Bitwise Ve): İki değerin karşılık gelen bitleri 1 ise sonuçta 1, aksi halde 0 olur.
• or (Bitwise Veya): İki değerin karşılık gelen bitlerinden en az biri 1 ise sonuçta 1, aksi halde 0 olur.
• xor (Bitwise Özel Veya): İki değerin karşılık gelen bitleri farklı ise sonuçta 1, aynı ise 0 olur.
• not (Bitwise Değil): Bir değerin tüm bitlerini tersine çevirir (1’ler 0’a, 0’lar 1’e).
• shl (Sola Kaydırma): Bir değerin bitlerini belirtilen sayıda sola kaydırır. Sağa boşalan bitler 0 ile doldurulur.
• shr (Sağa Kaydırma): Bir değerin bitlerini belirtilen sayıda sağa kaydırır. Sola boşalan bitler 0 ile doldurulur.

Örneğin:

var
  sayi1, sayi2, sonuc: Integer;
begin
  sayi1 := 5;   // Binary: 00000101
  sayi2 := 3;   // Binary: 00000011

  sonuc := sayi1 and sayi2; // sonuc = 1 (Binary: 00000001)
  sonuc := sayi1 or sayi2;  // sonuc = 7 (Binary: 00000111)
  sonuc := sayi1 xor sayi2; // sonuc = 6 (Binary: 00000110)
  sonuc := not sayi1;   // sonuc = -6 (Binary: 11111010 - İşaretli tamsayı gösterimi nedeniyle)
  sonuc := sayi1 shl 1;  // sonuc = 10 (Binary: 00001010) - Sola 1 bit kaydırma
  sonuc := sayi1 shr 1;  // sonuc = 2 (Binary: 00000010) - Sağa 1 bit kaydırma
end;

Önemli Not: Bitwise operatörler genellikle düşük seviyeli işlemlerde, örneğin bir donanım portuna erişirken veya bir veri yapısının bitlerini manipüle ederken kullanılır.

Operatör Önceliği

Delphi’de operatörlerin bir öncelik sırası vardır. Bir ifadede birden fazla operatör varsa, Delphi bu operatörleri öncelik sırasına göre değerlendirir. Operatör önceliği aşağıdaki gibidir (en yüksekten en düşüğe):

1. @, not
2. *, /, div, mod, and
3. +, -, or, xor
4. =, <>, <, >, <=, >=, in, is

Önceliği değiştirmek için parantezler kullanılabilir. Parantez içindeki ifadeler her zaman önce değerlendirilir.

Örneğin:

var
  sonuc: Integer;
begin
  sonuc := 2 + 3 * 4; // sonuc = 14 (Çarpma toplama işleminden önce gelir)
  sonuc := (2 + 3) * 4; // sonuc = 20 (Parantez içindeki işlem önce yapılır)
end;

Delphi’deki operatörler, programlarınızda çeşitli işlemler gerçekleştirmek için güçlü araçlardır. Bu operatörlerin doğru kullanımı, daha verimli ve okunabilir kod yazmanıza yardımcı olacaktır. Özellikle bitwise operatörler gibi daha karmaşık operatörlerin dikkatli bir şekilde kullanılması, hataların önlenmesi açısından önemlidir.

“Delphi’de operatörlerin doğru anlaşılması ve kullanılması, temiz ve etkili kod yazmanın temelidir.” – Delphi Uzmanı

4. Operatörler (Aritmetik, Karşılaştırma, Mantıksal, Bitwise, vb.) yazısı ilk önce Keşif Ruhu üzerinde ortaya çıktı.