Operatörleri işlevlerine göre sınıflandırmak gerekirse; matematiksel, karşılaştırma, mantıksal, atama, bitsel ve özel operatörlerden söz edilebilir. Bazen aynı anda birden fazla karşılaştırma yapılmak istenir. Bu gibi durumlarda mantıksal operatörler(ve, veya, değil) kullanılır. Operatörlerin öncelik sıraları matematikteki gibidir. Bu arada C#’ta karşılaştırma ve kontrol işlemlerinin parantezlerin içinde yapıldığını hatırlamak gerekir.
Operatör |
İşlevi |
Örnek |
= |
Atama |
Sayi = 10 |
== |
Eşittir |
if (a == b) |
!= |
Eşit değilldir |
if (a != b) |
< |
Küçüktür |
if (a < b) |
> |
Büyüktür |
if (a > b) |
<= |
Küçük eşittir |
if (a <= b) |
>= |
Büyük eşittir |
if (a >= b) |
Aynı işlem veya satırda birden fazla karşılaştırma yapılmak istendiğinde mantıksal operatörler kullanılanılır. Mantıksal operatörler aşağıda tablo halinde verildi.
Operatör |
İşlevi |
Örnek |
&& |
Ve |
if (a > b && c=10) |
|| |
Veya |
if (a <= b || C>100) |
! |
Değil |
if (a != b) |
Burada tablo halinde verilen karşılaştırma ve mantıksal operatörlerden başka matematiksel operatörler vardır. Bu operatörler günlük hayatta matematiksel işlemlerde kullanılan operatörler ile aynı işleve sahiptir.
Operatör |
İşlevi |
Örnek |
+ |
Toplama |
a = b + c; |
- |
Çıkarma |
A = b – c; |
* |
Çarpma |
sonuc = a * b; |
/ |
Bölme |
sonuc = 100 / 10; |
% |
Kalan bulma |
sonuc =40 % 6; //sonuc 4 olur |
Arttırma ve Eksiltme Operatörleri
C# ile program yazılırken arttırma ve eksiltme operatörleri sık kullanılmaktadır. Aşağıda verilen satırda 2 işlem yapılmaktadır. İlk işlemde “X” değişkenin mevcut içeriği 1 sayısı ile toplanmaktadır. 2. işlemde ise bulunan değer X değişkenine aktarılmaktadır.
X = X + 1;
Değişkenlerin içeriklerini 1 arttırırken arttırma operatörünü(++) kullanabilirsiniz. Aşağıda verilen satır ile X değişkenin içeriği yine 1 arttırılır.
X++;
Aynı teknikle değişkenlerin içeriğini 1 azaltabiliriz. Aşağıda verilen her 2 yazılış şekli de “X” değişkenin içeriğini 1 azaltır.
X = X – 1 veya X--
Arttırma ve eksiltme operatörlerinin içerikleri artırılacak veya azaltılacak değişkenlerin önüne veya arkasına yazılması operatörün farklı etkide bulunmasına neden olmaktadır.
X = 5;
Y= ++X + 5; // Y =11 ve X = 6 olur.
Bu kullanımda önce X’in içeriği 1 artırılır. Ardından X’e 5 eklenip “Y” değişkenine aktarılır. Artım operatörleri X’in önüne yazıldığı için önce X’in içeriği arttırılır ondan sonra toplama işlemi yapılır. Aşağıda verilen kullanımda ise önce X ile 5 toplanıp Y değişkenine aktarılır. Ardından X’in içeriği 1 arttırılır.
X = 5;
Y= X++ + 5; // Y =10 ve X = 6 olur.
Atama İşlemleri
C#’ta atama işlemi “=” operatörü ile yapılmaktadır. Ancak atama işlemi ile birlikte bazı ek işlemleri yapabilirsiniz. Örneğin aşağıda verilen 2. ve 3. satır aynı işleve sahiptir. Her 2 satırda da X değişkenin içeriği 5 arttırılmaktadır.
X= 10;
X = X + 5; // X 15 olur.
X +=5; // X 15 olur.
İlk satırın nasıl çalıştığını biliyorsunuz. 2. satırda X değişkenin mevcut içeriği 5 ile toplanıp tekrar X’e aktarılmaktadır. 3. satırda aynı işlem daha az kod ile yapılmaktadır. Benzer mantıkla aşağıda verilen 2 satır işlev açısından birbirinden farklı değildir. Bu satırlarda X’ten 5 çıkarılıp bulunan değer tekrar X’e aktarılmaktadır.
X=25;
X = X-5; // X 20 olur.
X-=5; // X 20 olur.
Yukarıda atama işlemi ile birlikte toplama ve çıkarma yaptık. Aynı şekilde değişkenlere sabit bilgi veya başka bir değişkenin içeriğini aktarırken çarpma ve toplama yapabilirsiniz.
X= 10;
X = X*5; // X 50 olur.
X*=5; // X 50 olur.
X = 50;
X = X/5; // X 10 olur.
X /=5; // X 10 olur.
Kaydırma Operatörleri
C# projelerinde sayıların kuvvetlerini almak istiyorsanız “>>” operatörünü kullanabilirsiniz. Aşağıda verilen metot işletildiğinde X değişkeni 16 değerine sahip olur.
int X=0;
X = 2 << 3; // X 16 olur.
Bu örnekte 2‘nin karesini almak veya 4 ile çarpmak istemiş olsaydık “X=2<<2” şeklinde yazardık. Atama işlemi sırasında sayının üssünü alabilirsiniz. Aşağıda atama işlemi sırasında ayrıca X’in üssü alınmaktadır.
int X=2;
X <<=3; // X 16 olur.
Atama işlemi sırasında kullandığımız “<<” operatörü sayıların istenen sayıda 2 ile çarpılmasını sağlamaktadır. Çarpma yerine bölme yapılacaksa bu kez “>>” operatörünü kullanmalısınız. Aşağıda verilen işletildiğinde X değişkeni 4 olur.
int X=16;
X >>=2; // X 4 olur.
Kaydırma işleminin anlaşılmasını sağlamak için 16 sayısının 2 tabanlı karşılığını aşağıda verilen kutulara yerleştirdik. int değişkenler bellekte 4 byte yer kaplasalar bile bu int değişkene aktardığımız sayı küçük olduğu için yalnızca en sağdaki 8 bitle ilgilendik.
Bu sırada bu sayı bitsel düzeyde bir kez sola kaydırılırsa yani 2 ile çarpılırsa söz konusu sayının 2 tabanlı karşılığı aşağıdaki gibi olur. 16 x 2= 32 olur.
Tam bu sırada sayı 2 kez sağ kaydırılırsa yani 2 kez 2’ye bölünürse 8 sayısı elde edilir ve 2 tabanlı karşılığı aşağıdaki gibi olur.
as ve is Operatörleri
Bu operatörler değişik türdeki veriler birbirine dönüştürülürken ve tip kontrolü yapılırken kullanılmaktadır. Tipler arası dönüştürme yaparken gerek duyacağınız as operatörünün nasıl kullanıldığını anlatmak için aşağıda verilen basit örneği hazırladık. Bu örnekte object tipindeki değişkenin içeriği bilinen yöntemle dönüştürülüp string değişkene aktarılmaktadır.
object Nesne = "Beşiktaş";
string Takim = (string)Nesne;
textBox1.Text = Takim;
Aşağıda verilen kodda ise sayısal bilgi içeren object değişkenin içeriği dönüştürülüp int tipindeki değişkene aktarılıyor. Bu dönüştürme Convert sınıfının metotları ile yapılabilinir.
Object Nesne = 2009;
int Yil = (int)Nesne;
textBox2.Text = Yil.ToString();
Tipler arası dönüştürme yapılırken as operatörü kullanılabilir. Bu operatörün nasıl kullanıldığını aşağıda görebilirsiniz. Aşağıda verilen örnekte as operatörü ile object değişkenin içeriği dönüştürülüp string değişkene aktarılmaktadır.
object Nesne = "Beşiktaş";
string Takim = Nesne as string;
as operatörü ile string tipe dönüştürülen Object değişkenin içerdiği bilgi string olmasaydı hata meydana gelmezdi ama as operatörü geriye null bilgisini gönderirdi. as operatörünün ürettiği bilgi referans türünde olduğu için aşağıdaki gibi kullanıldığında hata meydana gelir.
Object Nesne = 2006;
int Yil = Nesne as int;
Forma yerleştirilmiş olan nesneler hakkında bilgi edinilirken as operatörü kullanılabilir. Aşağıda verilen kodda TextBox tipinde bir değişken tanımlayıp as operatörü ile forma daha önce yerleştirdiğimiz TextBox’ın referansını bu değişkene aktardık.
TextBox Text1 = textBox1 as TextBox;
Text1.Text = "Fenerbahçe";
Bu kod işletildiğinde formdaki TextBox’ın içeriği değişir. Şimdi as operatöründen yararlanıp formdaki bütün TextBox’ların içeriklerini temizleyeceğiz. Bildiğiniz gibi forma yerleştirilen nesneler hakkında bilgi Controls koleksiyonundan alınmaktadır.
TextBox Text1;
int sayi = this.Controls.Count;
for (int i = 0; i < sayi; i++)
{
Text1 = this.Controls[i] as TextBox;
Text1.Text = "";
}
Formun üzerindeki nesnelerin hepsi TextBox ise bu kod hatasız çalışır. as operatörüne parametre olarak verilen nesne TextBox değilse yani dönüştürme işlemi başarılı değilse geriye null gönderilmektedir. Bu kod aşağıdaki gibi düzenlenirse hatasızca çalışır.
TextBox Text1;
int Sayi = this.Controls.Count;
for (int i = 0; i < Sayi; i++)
{
Text1 = this.Controls[i] as TextBox;
if(Text1 != null)
Text1.Text ="";
}
Yukarıda hakkında bilgi verilen as operatörü ile uygun referans türleri birbirine dönüştürülüyordu. Dönüştürme başarısız olduğunda geriye null gönderildiği için yukarıda yapıldığı gibi yalnızca belli tipteki nesneler üzerinde kolaylıkla işlem yapılabiliniyordu. is operatörü ise kendisine parametre olarak verilen 2 nesnenin aynı türden olup olmadığı konusunda geriye mantıksal sonuç göndermektedir. is operatörünün nasıl kullanıldığını aşağıda görebilirsiniz.
int Sayi;
bool sonuc;
sonuc = Sayi is int;
Bu kodda önce int ve bool tipinde 2 değişken tanımladık. is operatörünün soluna yazılan değişkenin tipi sağ tarafa yazılan tip ile aynı ise geriye true gönderilir. “Sayi” adı verilen değişken int tipinde olduğu “sonuc” değişkenine true aktarılır. is operatörü aşağıdaki gibi kullanıldığında ise geriye false gönderilir.
int Sayi;
bool sonuc = Sayi is string;
isoperatörünün işlevinin anlaşılması için forma yerleştirdiğimiz bütün TextBox’ların içeriklerini temizleyeceğiz. Bu amaçla yazdığımız kodu aşağıda görebilirsiniz. Bu kodda formdaki nesnelerin sayısını öğrendikten sonra sıra ile bütün TextBox’ların içeriklerini Clear() metodu ile temizledik. Formun üzerindeki ilgili nesnenin TextBox tipinde olup olmadığını öğrendikten sonra bu nesneyi dönüştürüp referansını TextBox tipindeki değişkene aktardık.
TextBox Edit;
int Sayi = this.Controls.Count;
for (int i = 0; i < Sayi; i++)
{
if (this.Controls[i] is TextBox)
{
Edit = this.Controls[i] as TextBox;
Edit.Clear();
}
}
Operatörlerin Öncelik Sıraları
Operatörlerin kullanıldığı karşılaştırmalarda ve matematiksel işlemlerde operatörlerin öncelikleri matematikte gibidir. Örneğin aşağıda verilen satırlar işletildiğinde TextBox’a 50 yazılır. Çünkü çarpma(*) operatörünün önceliği olduğundan “Sayi2” adlı değişkenin içeriği 3 ile çarpılır ve bulunan değere Sayi1’in içeriğine eklenir.
int Sayi1 = 20;
int Sayi2 = 10;
textBox1.Text = Convert.ToString(Sayi1 + Sayi2 * 3);
Bu örnekte Sayi1 ile Sayi2’yi toplayıp bulunan değeri 3 ile çarpmak istemiş olsaydık Sayi1 ile Sayi2’yi parantezin içine alıp işlemlerin öncelik sıralarına müdahale ederdik. Aşağıda verilen şekilde düzenlenen kod işletildiğinde TextBox’a 90 aktarılır.
textBox1.Text = Convert.ToString((Sayi1 + Sayi2) * 3);
Matematiksel operatörlerinin işlem önceliği karşılaştırma operatörlerden yüksek olduğu için parantez kullanılmadan yan yana kullanıldığında öncelik matematiksel operatörün olur. Aynı mantıkla karşılaştırma operatörleri mantıksal operatörleri karşısında işlem önceliğine sahiptir. Aşağıda operatörleri işlem önceliği yönünden sıraladık.
Aritmetik |
Karşılaştırma |
Mantıksal |
^ |
= |
Not |
*, / |
<> |
And |
Eksi işareti(-) |
< |
Or |
\ |
> |
Xor |
Mod |
<= |
Eqv |
+, - |
>= |
Imp |
& |
Like |
|
Bit Düzeyinde İşlem Yapan Mantıksal Operatörler
Yukarıdaki sayfalarda kısaca anlatıldığı gibi && ve || gibi operatörler ile kolay bir şekilde birden fazla karşılaştırma birbirleri ile ilişkilendirilebilmektedir. Ancak bit düzeyinde işlem yapılmak istenildiğinde “&”, “|” ve XOR operatörlerini kullanmak gerekmektedir. Başka bir anlatımla bit düzeyinde işlem yapan operatörler sayının kendisi yerine sayıyı oluşturan bitler üzerinde işlem yapmaktadır. Herkes tarafından bilinmekle birlikte bu operatörlerle ilgili olarak aşağıda verilen tabloyu hazırladık.
&(ve) |
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
0 |
1 |
1 |
1 | |
|(veya) |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
1 | |
^(XOr) |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
0 | |
Burada tabloda yer verdiğimiz 3 operatörden başka ayrıca ~(değil) operatörü bulunmaktadır. Tek parametreye sahip olan “~” operatörü ilgili bit üzerinde işlem yapmaktadır. Kendisine parametre olarak verilen sayının 1 olan bitlerini 0, 0 olanları ise 1 yapmaktadır. Bu konuda bilgi vermek için 10 tabanlı 32 sayısını aktardığımız byte tipindeki değişkeni bu operatöre parametre olarak vereceğiz. Öncelikle bu sayının 2 tabanlı halini vereceğiz.
32 sayısı |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
0 |
Buna göre byte tipindeki değişkene 10 tabanlı 32 sayısı aktarıldığında sayı bellekte bu şekilde durmaktadır. Bu sayı değil operatörüne parametre olarak verildiğinde 0’lar 1, birler ise 0 yapılır ve geriye aşağıdaki gibi bir sonuç gönderilir.
~32 sayısı |
1 |
1 |
0 |
1 |
1 |
1 |
1 |
1 |
2 tabanlı bu sayının 10 tabanlı karşılığı 223’tür. ~ operatörünün nasıl kullanılabildiğini aşağıda görebilirsiniz. Bu örnekte ~ operatörüne byte bir değişkeni parametre olarak verdik ve çıkan sonucu başka bir byte değişkene aktardık. byte yerine uint değişken kullanmış olsaydık sonuç farklı olurdu.
byte sayi = 32;
byte sonuc = (byte)~sayi; // sonuc 223 olur.
Bu operatörlere daha çok sayılar parametre olarak verilmekle birlikte bool bilgiler parametre olarak verilebilir. Bu konuda bilgi vermek için aşağıda verilen satırları hazırladık. Bitsel operatörler bu şekilde kullanıldığında mantıksal işlem yapılıp geriye bool bilgi gönderilir.
bool sonuc = false & false; // sonuc False olur
sonuc = false | false; // sonuc False olur
sonuc = true | false; // sonuc True olur
Bu operatörlerin nasıl kullanıldığına örnek olması için aşağıda verilen kodu hazırladık. Bu kod sayesinde TextBox’a girilen sayının çift mi tek mi olduğunu öğreneceğiz.
ushort Sayi = ushort.Parse(textBox1.Text);
if ((Sayi & 1) == 0)
textBox2.Text = "Bu sayı ÇİFT bir sayıdır";
else
textBox2.Text = "Bu sayı TEK bir sayıdır";
Bu kodda ilk olarak kullanıcının çalışma anında formdaki ilk TextBox’a girmiş olduğu sayıyı Parse() metodu ile ushort tipindeki değişkene aktardık. Ardından bu değişkenin ilk bitinin 0 olup olmadığını Ve(&) operatörü ile öğrendik. Bu bit 0 ise sayı çift, değilse tektir. Sayının tek sayı olup olmadığını öğrenmek istemiş olsaydık bu kodu aşağıdaki gibi değiştirip ilk bitin 1 olup olmadığını araştırırdık.
ushort Sayi = ushort.Parse(textBox1.Text);
if((Sayi & 1) == 1)
textBox2.Text = "Bu sayı TEK bir sayıdır";
else
textBox2.Text = "Bu sayı ÇİFT bir sayıdır";
Konunun anlaşılmasına katkı olması için forma 2 ListBox yerleştirip ilk ListBox’a tasarım anında çift sayılar aktardık. Kod yazıp ilk ListBox’taki çift sayıları tek sayıya dönüştürüp 2. ListBox’a aktaracağız. Burada yapılması gereken sayının ilk bitini sıfırlamaktır.
int sayi, cift_sayi;
for (int i = 0; i < listBox1.Items.Count; i++)
{
sayi = Convert.ToInt16(listBox1.Items[i]);
cift_sayi = (sayi & 0XFFFE);
listBox2.Items.Add(cift_sayi.ToString());
}
Doğrudan bitler üzerinde işlem yapan operatörlerin nasıl işlev gördüğü konusunu netleştirmek için aşağıda verilen kodu hazırladık. Bu kodda 10 ve 30 saylarını & operatörüne parametre olarak verdik.
int number1 = 10;
int number2 = 30;
int netice = number1 & number2; // netice 10;
Burada yapılan şudur: iki sayının 2 tabanlı halinin her bitinin Ve(&) operatörü ile karşılaştırılmasıdır. Bu kod işletildiğinde TextBox’a 10 yazılır. Bu sonucun nasıl bulunduğunu açıklamak için 10 ve 30 sayılarının 2 tabanlı hallerini aşağıda verildi.
10 sayısı |
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
30 sayısı |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
Bu 2 sayının bitleri karşılıklı olarak Ve(&) işlemine tabi tutulursa aşağıdaki gibi bir sonuç alınır. Örneğin her iki sayınında ilk bitleri 0. Bu nedenle 0&0 işleminin sonucu 0 olur. Aynı şekilde her 2 sayının 2. bitleri 1’dir ve 1&1 işleminin sonucu 1’dir.
10 sayısı |
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
30 sayısı |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
ve işlemi |
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
Yukarıda verilen örnekte &(ve) yerine |(veya) operatörünü kullansaydık farklı bir sonuç çıkardı. 30 ve 10 sayıları veya operatörüne parametre olarak verildiğinde 30 sayısı elde edilir.
10 sayısı |
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
30 sayısı |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
veya işlemi |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
Şimdiye kadar verilen bilgilere göre “&” ile “|” gibi operatörler kendilerine parametre olarak verilen sayının bütün bitlerini etkilemektedir. Şimdi örnek olması için 32 sayısının 0 olan ilk bitini 1 yapacağız. Bu amaçla ilk biti 1 olan 10 tabanlı 1 sayısından yararlanacağız. 32 sayısının 0 olan ilk biti 1 yapıldığında sayı 33 olur.
32 sayısı |
0 |
0 |
1 |
1 |
0 |
0 |
1 |
0 |
1 sayısı |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
veya işlemi |
0 |
0 |
1 |
1 |
0 |
0 |
1 |
1 |
Bu işlemi yapmak üzere hazırladığımız kod aşağıda verildi. Bu kodda Or(|) yerine ve(&) operatörünü kullansaydık sonuç farklı olurdu ve geriye 0 gönderilirdi.
byte Sayi1 = 32;
byte Sayi2 = 1;
int sonuc = (int)Sayi1 | Sayi2 ; // sonuc 33 olur.
Şimdi verilecek örnekte çalışma anında kullanıcının TextBox’a yazdığı Byte tipindeki sayının 1.,3. ve 5 bitlerinin mutlaka 1 olmasını sağlayacak kod yazılacaktır. Bu amaçla ilk olarak 1., 3. ve 5. bitleri 1, diğerleri 0 olan sayıyı öğrendik. Bu sayı 10 tabanlı 21’dir.
byte Sayi2 = 21;
byte sayi1 = Convert.ToByte(textBox1.Text);
int sonuc = sayi1 | Sayi2;
textBox2.Text = sonuc.ToString();