- 31 Mar 2023
- 79
- 38
C# Operatorler
C# dilinde çeşitli işlemleri yapmak için kullanılan sembollere operatörler denir.
Aritmetik Operatörler
Matematiksel işlemleri yapmak için kullanılan operatörlere aritmetik operatörler denir.
Kod:
+-----------+--------------------+
| OPERATÖR | İŞLEVİ |
+-----------+--------------------+
| + | Toplama |
| - | Çıkarma |
| / | Bölme |
| * | Çarpma |
| % | Mod |
+-----------+--------------------+
Örnek soru : Kullanıcı tarafından klavyeden girilen iki sayının çarpımı, toplamı, farkı, bölümü ve modu hesaplanarak ekrana yazdırınız.
C#:
double sayi1, sayi2;
Console.WriteLine("klavyeden 2 sayi giriniz:");
sayi1 = Convert.ToDouble(Console.ReadLine());
sayi2 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Toplam = {0}", sayi1 + sayi2);
Console.WriteLine("Fark = {0}", sayi1 - sayi2);
Console.WriteLine("Çarpım = {0}", sayi1 * sayi2);
Console.WriteLine("Bölüm = {0}", sayi1 / sayi2);
Console.WriteLine("modu = {0}", sayi2 % sayi2)
Çıktı:
Kod:
klavyeden 2 sayi giriniz:
2
3
Toplam = 5
Fark = -1
Çarpım = 6
Bölüm = 0,66666666666667
modu = 0
Örnek soru : Kullanıcıdan alınan yarıçap değerine göre bir dairenin alanını hesaplayan programı yazınız.
C#:
int pi = 3;
double r, alan;
Console.WriteLine("Dairenin yarı çapını giriniz.");
r = double.Parse(Console.ReadLine());
alan = pi * Math.Pow(r, 2);
Console.WriteLine("Dairenin alanı = {0}", alan);
Console.ReadKey();
Çıktı:
Kod:
Dairenin yarı çapını giriniz.
2
Dairenin alanı = 12
Farklı veri tiplerindeki değişkenler arasında aritmetik işlem yapılırsa, sonuç daha büyük olan veri tipine dönüştürülecektir.
Örnek:
C#:
int a = 3;
double b = 1.2;
var c = a + b;
Console.WriteLine(c.GetType());
Çıktı:
Kod:
System.Double
Yukarıdaki ekran görüntüsünde gösterildiği gibi, farklı veri tiplerindeki değişkenler arasında aritmetik işlem yapılırken, işlem öncesi veri tipleri uyumlu hale getirilir ve daha küçük veri tipi, büyük veri tipine otomatik olarak dönüştürülür. Dönüşüm işlemi tamamlandıktan sonra aritmetik işlem gerçekleştirilir.
Bu duruma istisna olarak Byte veri tipleri arasında yapılan aritmetik işlemler istisna olarak ele alınır ve bu işlemlerin sonucunda daima int veri tipi döndürülür.
Atama Operatörü
Atama işlemi, = operatörü kullanılarak gerçekleştirilir. Bu operatörün sağındaki değişkenin değeri, solundaki değişkene atılır.
C#:
int x = 3;
int y = 12;
x = y;
Burada y değişkeni, x değişkenine atandı. Bu işlem sonucunda x değişkeninin değeri 12 olarak güncellendi.
Kod:
+-----------+--------------------------------------------------------+
| OPERATÖR | Yaptığı iş |
+-----------+--------------------------------------------------------+
| | Soldaki değişkeni sağdaki değişkenle toplayıp sonucu |
| += | soldaki değişkene atar. |
+-----------+--------------------------------------------------------+
| | Soldaki değişkeni sağdaki değişken ile çıkararak sonucu|
| -= | soldaki değişkene atar. |
+-----------+--------------------------------------------------------+
| | Soldaki değişkeni sağdaki değişken ile çarparak sonucu |
| *= | soldaki değişkene atar. |
+-----------+--------------------------------------------------------+
| | Soldaki değişkeni sağdaki değişken ile bölerek sonucu |
| /= | soldaki değişkene atar. |
+-----------+--------------------------------------------------------+
| | Solundaki değişkeni sağındaki değişkene bölerek kalanı |
| %= | solundaki değişkene atar. |
+-----------+--------------------------------------------------------+
C#:
int x = 3;
int y = 12;
x *= y;
Yukarıdaki kod çalıştırıldığında, x değişkeninin değeri 36 olarak güncellenir.
Mantıksal Operatörler
Mantıksal operatörler, sadece doğru (true) veya yanlış (false) olmak üzere iki farklı değer döndürürler.Ve (&&) Operatörü
Bu işlem, çarpma işlemine benzetilebilir. Yani, her iki taraf da doğru (true) olmadığı sürece sonuç doğru (true) olmaz.
Kod:
true && true = true
true && false = false
false && true = false
false && false = false
Veya (||) Operatörü
Bu işlem, toplama işlemine benzetilebilir. Yani, en az bir taraftaki değer doğru (true) ise sonuç da doğru (true) olacaktır.
Kod:
true || true = true
true || false = true
false || true = true
false || false = false
^ Özel veya Operatörü
Bu işlem, değişkenlerin birbirinden farklı olup olmadığını kontrol eder ve sonuç olarak doğru (true) veya yanlış (false) değerlerinden birini döndürür.
Kod:
true ^ false = true
true ^ true = false
false ^ false = false
false ^ true = true
! (değil) operatörü
Bu işlem, değişkenin mevcut değerini tersine çevirir. Yani, true (doğru) değeri false (yanlış) değerine, false değeri ise true değerine dönüştürülür.
Kod:
! true = false
! false = true
Null coalescing(??) Operatörü
Null coalescing operatörü, birinci değerin null (boş) olup olmadığını kontrol eder. Eğer null ise, ikinci değer işleme alınır. Eğer birinci değer null değilse, ikinci değer işleme alınmaz. Bu operatörde her iki taraf da aynı türden olmalıdır.
C#:
string soy_isim = null;
string soy_isim_ne = soy_isim ?? "Soy isim boş"
Console.WriteLine(soy_isim_ne);
Kod:
"Soy isim boş"
Null değer, sadece referans türü değişkenlerine atanabilen bir değerdir. Yukarıdaki örnekte soy_isim değişkeninin değeri null olduğundan soy_isim_ne değişkenine “Soy isim boş” değeri atandı.
Kod:
x is null
yada
x is not null
Şeklinde de bir değişkenin null olup olmadığını sorgulayabiliriz.
Null coalescing operatörü
Null-coalescing operatörü, bir değişkenin null değer olması durumunda başka bir değer atamak için kullanılan bir operatördür.Örnek:
C#:
string a = null;
a ??= "hehe";
Console.WriteLine(a);
Kod:
hehe
Koşul Ternary (?) Operatörü
Üçlü koşullu operatör (ternary operator) olarak da bilinen ? operatörü, if-else yapısının kısaltılmış halidir ve x ? y : z şeklinde kullanılır. Eğer x doğru ise y işlemi yapılır, aksi takdirde z işlemi yapılır. Y ve z işlemlerinin türleri aynı olmalıdır, örneğin y’de int türünden bir değer döndürülüyorsa z’de de int türünden bir değer döndürülmelidir. Bu operatör, if-else bloklarını daha okunaklı ve kısa hale getirmek için kullanılabilir.Örnek:
C#:
var number1 = 11;
Console.WriteLine(number1 == 10 ? "number1 is equals 10" : "number1 is not equals 10");
Console.ReadLine();
Çıktı:
Kod:
number1 is not equals 10
Örnek:
C#:
int a = 10;
a = a == 10 ? a - 5 : a + 1;
Console.WriteLine(a);
Çıktı:
Kod:
5
Örnek:
C#:
int not = 50;
string durum = not < 30 ? "Kaldı." : (not > 30 ? "Geçti" : "Araftasın");
Console.WriteLine(durum);
İç içe kullanılan ? operatörü, bir koşulun doğruluğuna göre farklı sonuçların döndürülmesini sağlar. Burada not değişkeninin değeri farklı koşullara göre inceleniyor ve bu koşullara göre “Kaldı”, “Geçti” veya “Araftasın” string değerleri durum değişkenine atanıyor.
Bitsel operatörler
Doğru, bitsel operatörlerin işlem yaptığı sayılar ikili sayı sistemiyle ifade edilirler. Bitsel ve operatörü (&), her iki sayının da aynı pozisyondaki bitleri 1 ise sonucun o pozisyondaki biti de 1 olur, diğer durumlarda 0 olur. Bitsel veya operatörü (|) ise en az bir sayının aynı pozisyondaki biti 1 ise sonucun o pozisyondaki biti de 1 olur, diğer durumlarda 0 olur. Bitsel özel veya operatörü (^), sadece bir sayının aynı pozisyondaki biti 1 ise sonucun o pozisyondaki biti de 1 olur, diğer durumlarda 0 olur. Bitsel değil operatörü (~) ise sayının her bir bitini 0 ise 1, 1 ise 0 yapar.Bitsel operatörler sayıları ikili sayı sistemine dönüştürüp öyle işlem yaparlar. 0001 1001 & 0010 0000 = 0000 0000 Yukarıda da gördüşünüz gibi bitsel operatörler satır satır işlem yaparlar yani 1 satır ile 1 satır, 2. satır ile 2 satır ve böyle devam eder.
Yani 25 & 32 işleminin sonucu 0 dır.
Kod:
true & true = true
true & false = false
false & true = false
false & false = false
Örnek:
C#:
int a = 0b_0000_1111_0000_1111_0000_1111_0000_1100; ;
int b = 0b_0100_1011_0101_0101_1010_0101_0110_0110; ;
Console.WriteLine(Convert.ToString(~b, toBase: 2));
Console.WriteLine(Convert.ToString(a & b, toBase: 2));
Console.WriteLine(Convert.ToString(a | b, toBase: 2));
Console.WriteLine(Convert.ToString(a ^ b, toBase: 2));
Console.ReadKey();
Çıktı:
Kod:
10110100101010100101101010011001
1011000001010000010100000100
1001111010111111010111101101110
1000100010110101010101001101010
Örnek soru: Klavyeden alınan iki sayıyı ikili sayı sistemi şeklinde ele alarak bitsel operatörler kullanarak AND, OR ve XOR işlemlerini yapan programi yaziniz.
C#:
int a, b;
Console.WriteLine("ilk sayıyı giriniz :");
a = Convert.ToInt32(Console.ReadLine());
Console.Clear();
Console.WriteLine("İkinci sayıyı giriniz :");
b = Convert.ToInt32(Console.ReadLine());
Console.Clear();
Console.WriteLine("AND : " + (a & b));
Console.WriteLine("OR : " + (a | b));
Console.WriteLine("XOR :" + (a ^ b));
Console.ReadKey();
Çıktı:
Kod:
ilk sayıyı giriniz :
5
İkinci sayıyı giriniz :
4
AND : 4
OR : 5
XOR :1
Bitsel kaydırma operatörleri(<< >>)
Bitsel kaydırma operatörleri sayıları bitsel olarak sağa ve sola kaydırmamızı sağlar. << sayıları sola, >> ise sayıları sağa kaydırır.Örnek:
C#:
int b = 0b_0100_1011_0101_0101_1010_0101_0110_0110; ;
b = b << 2;
Console.WriteLine(Convert.ToString(b, toBase: 2));
Console.ReadKey();
Çıktı:
Kod:
101101010101101001010110011000
Yukarıda gördüğünüz gibi 2 birim sola kaydı.
Karşılaştırma operatörleri
Kod:
+-----------+-------------------------+
| OPERATÖR | Yaptığı iş |
+-----------+-------------------------+
| == | Erşittir |
+-----------+-------------------------+
| ! | Değil |
+-----------+-------------------------+
| > | Büyüktür |
+-----------+-------------------------+
| < | Küçüktür |
+-----------+-------------------------+
| >= | Büyük yada eşittir |
+-----------+-------------------------+
| <= | Küçük yada eşittir |
+-----------+-------------------------+
| != | Eşit değildir |
+-----------+-------------------------+
| --> | Uzaklaşma operatörü |
+-----------+-------------------------+
| <-- | Yakınlaştırma operatörü |
+-----------+-------------------------+
“Karşılaştırma operatörleri” genellikle iki değeri karşılaştırmak için kullanılır ve boolean (true veya false) değerini döndürür.
Örnek:
C#:
int a, b;
Console.WriteLine("a sayısını giriniz :");
a = Convert.ToInt32(Console.ReadLine()); // a sayısını kullanıcıdan aldık.
Console.Clear(); // konsol ekranını temizledik
Console.WriteLine("b sayısını giriniz :");
b = Convert.ToInt32(Console.ReadLine()); // b sayısını kullanıcıdan aldık.
Console.Clear(); // konsol ekranını temizledik.
if (a == b) // a sayısı b sayısına eşit ise işlem yapılır.
Console.WriteLine("a sayısı b sayısına eşittir");
if (a < b) // a sayısı b sayısından küçük ise işlem yapılır.
Console.WriteLine("a sayısı b sayısından küçüktür");
if (a > b) // a sayısı b sayısından büyük ise işlem yapılır.
Console.WriteLine("a sayısı b sayısından büyüktür");
Console.ReadKey();
Örnek:
C#:
int a = 5;
int b = 5;
while (a-- > 0)
{
Console.WriteLine(a);
}
Console.WriteLine("-------------");
while (0 < --b)
{
Console.WriteLine(b);
}
Console.ReadKey();
Çıktı:
Kod:
4
3
2
1
0
-------------
4
3
2
1
“(a → 0)” işlemi 4'ten 0'a kadar geri saydırırken, “(0 ← b)” işlemi 4'ten 1'e kadar geri saydırdı.
Artırma ve Azaltma Operatörü
Değişken değerlerinin artırılması veya azaltılması için kullanılır. Uyguladığı değeri bir artırır veya bir azaltır ve değiştirdiği değeri tutar. Önce ve sonra kullanılmasına göre farklı anlamlar taşır. A bir değişken olsun, ++A, A++, — A veya A — şeklinde kullanılır.Örnek:
C#:
int a = 5;
Console.WriteLine("a = " + a);
int b = a++; // a'yı 1 artırdık ama atama işleminden sonra artırma gerçekleşir.
Console.WriteLine("b = " + b);
int c = --b; // ilk olarak b'yi 1 azalttık ve atama işlemini gerçekleştirdik.
Console.WriteLine("c = " + c);
Console.WriteLine("--------------------");
Console.WriteLine("a = " + a);
Console.WriteLine("b = " + b);
Console.WriteLine("c = " + c);
Console.ReadKey();
Çıktı:
Kod:
a = 5
b = 5
c = 4
--------------------
a = 6
b = 4
c = 4
Operatörlerde işlem önceliği
C# programlama dilinde operatörlerle işlem yaparken işlem önceliğine dikkat etmek gerekir. İşlem önceliği, yukarıdan aşağıya doğru şu şekildedir:Operatörler:
Kod:
()
! + - ++ --
* / %
+ -
< <= > >= is as
== !=
&
^
|
&&
||
?:
= *= /= %= += -= &= ^= |=
İs operatörü
Boxing’e uğramış bir değerin hangi türe ait olduğunu bulmamızı sağlayan bir operatördür. Kod yazarken değişken tiplerinin uygunluğunu anlamak için kullanabiliriz.Örnek:
C#:
object x = 1.7;
if (x is double)
{
Console.WriteLine("Değişken double");
}
else
{
Console.WriteLine("Değişken double değil");
}
Console.ReadKey();
Çıktı:
Kod:
Değişken double
Yukarıda, double türündeki bir değerin object türüne atanması sonucu oluşan değerin türünü sorgulayan bir program yazdık.
As operatörü
Cast operatörü, unboxing işlemi yerine kullanılan bir alternatif operatördür.Örnek:
C#:
object x = "osman";
string a = x as string;
as operatörü, unboxing işlemi yaparken karşılayacağı tür belirtilmezse null değerini döndürür. Null değeri sadece referans türü değişkenler alabileceğinden as operatörü, sadece referans türü değişkenlerinin unboxing işlemini yapabilir.
? Nullable operatörü
Normalde bir değer türü değişkenine null değeri atayamayız. Eğer null değerini atamak istiyorsak, Nullable operatörünü kullanmalıyız.Örnek:
C#:
int? a = null
int türündeki ‘a’ değişkenini nullable yaptık ve null değerini atadık. Artık ‘a’ değişkeni ile ‘as’ ve ‘is’ gibi operatörleri kullanabiliriz.
Örnek:
C#:
object x = 8;
double? a = x as double?;
. (member access — üye erişim operatörü)
Bir türün altındaki elemanlara (sınıflara, metotlara, özelliklere, alanlara) erişmemizi sağlayan bir operatördür.sizeof operatörü
Parantez içinde verdiğimiz türün bellekte kaç byte yer kapladığı bilgisini döndüren bir yöntemdir.
C#:
Console.WriteLine(sizeof(double));
Çıktı:
Kod:
8