Ders 3 - C++ Operatörler

Operatörler tüm programlama dillerinde bulunan, büyüklük küçüklük karşılaştırmalarının, mantıksal karşılaştırmalarının ve aritmetik işlemlerin yapılmasını sağlayan karakterler topluluğudur.

1) Atama Operatörü

Aslında atama operatörünü önceki derslerden biliyoruz. Değişkene değer atamayı bu operatör ile yapıyoruz. Yani değişkenlere değer atarken kullandığımız operatördür. Örnek:

int sayi=15;
char harf='a';

2) Aritmetik Operatörler

Genellikle sayısal yani matematiksel işlemleri yaparken işimize yarayacak olan operatörlerdir. Başlıca aritmetik operatörler şu şekildedir:

1- Toplama ( + )

2- Çıkarma ( - )

3- Çarpma ( * )

4- Bölme ( / )

5- Mod Alma ( % )

a) 4 İşlem Operatörü

Zaten 4 işlemi bilmeyen yoktur. Hemen örnekle anlatalım: Örnekte 2 tane int(tamsayı) tipinde değişken tanımlanıyor ve bunlara başlangıç değeri veriliyor. Daha sonra bu 2 değişkene 4 işlem uygulanıyor ve ekrana yazdırılıyor.

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int sayi1 = 8, sayi2 = 4;

  cout << "iki sayinin toplami: " << sayi1 + sayi2 << endl;
  cout << "iki sayinin farki: " << sayi1 - sayi2 << endl;
  cout << "iki sayinin carpimi: " << sayi1 * sayi2 << endl;
  cout << "iki sayinin bolumu: " << sayi1 / sayi2 << endl;

  system("pause");

  return 0;
}

Bu örneği kendi derleyiciniz aracılığıyla deneyebilirsiniz. Programın çıktısı şu şekilde olmalıdır:

Art arda cout kodu yazmak yerine bu işlemi şu kodla da yapabilirdik:

cout << "iki sayinin toplami: " << sayi1 + sayi2 << endl << "iki sayinin farki: " << sayi1 - sayi2 << endl << "iki sayinin carpimi: " << sayi1 * sayi2 << endl << "iki sayinin bolumu: " << sayi1 / sayi2 << endl;

Sizlerinde fark edeceği gibi bu şekilde kodlar karmaşık duruyor. O nedenle ayrı ayrı yazılması tercih edilir.

Şimdi ise aynı örneği yapacağız ama bu sefer değişkenlere ilk değeri vermek yerine kullanıcıdan bu 2 sayıyı girmesini isteyeceğiz.

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int sayi1, sayi2;

  cout << "ilk sayiyi giriniz: ";

  cin >> sayi1;

  cout << "ikinci sayiyi giriniz: ";

  cin >> sayi2;

  cout << "iki sayinin toplami: " << sayi1 + sayi2 << endl;
  cout << "iki sayinin farki: " << sayi1 - sayi2 << endl;
  cout << "iki sayinin carpimi: " << sayi1 * sayi2 << endl;
  cout << "iki sayinin bolumu: " << sayi1 / sayi2 << endl;

  system("pause");

  return 0;
}

Eğer kullanıcının 2. girdiği değer 0 -sıfır- olursa tanımsızlık ortaya çıkacağı için program hata verecektir.

b) Mod Operatörü

Modun ne olduğu belki bileniniz vardır. Mod; 1. sayının 2. sayıya bölümünden kalandır. Hemen örnekle pekiştirelim:

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int a = 8, b = 4, c = 3;

  cout << "8 mod 4:  " << a % b << endl;
  cout << "8 mod 3:  " << a % c << endl;
  cout << "4 mod 3:  " << b % c << endl;

  system("pause");

  return 0;
}

Programın çıktısı şu şekilde:

3) Tip Dönüşümü

Programımızda değişkenler veya sabitler birbirinden farklı tiple olabilirler. Eğer böyle bir durum söz konusu ise tip dönüştürme ihtiyacı duyabiliriz. Matematiksel işlemlerimizde hesap sonucumuzun hangi tipte olacağı önemlidir. Bu nedenle bir hata ile karşılaşmamak için tip dönüşümü yapılmalıdır. Örnekle durumu daha iyi açıklayacağımı düşünüyorum:

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int sayi = 9;
  float a, b, c;

  a = sayi / 4;
  b = sayi / 4.0;
  c = (float)sayi / 4;

  cout << "a degeri: " << a << endl;
  cout << "b degeri: " << b << endl;
  cout << "c degeri: " << c << endl;

  system("pause");

  return 0;
}

Bu kodların çıktısı bu şekilde olacaktır:

Programda, 3 tane float yani ondalıklı tipte değişken tanımladık ve 1 tane de tamsayı tipinde ilk değeri 9 olan bir değişken tanımladık.

Daha sonra “sayi” ismindeki tamsayı değişkenini 4’e böldük(9/4) ve “a” isimli float tipindeki değişkene atadık. Fakat float ondalıklı sayı göstermesi gerekirsen sonuç yuvarlanarak 2 olarak yazdırıldı. Çünkü işleme soktuğumuz değişkenlerin ikisi de tamsayı tipindeydi. Dolayısıyla sonuçta tamsayı olarak aktarıldı.

2. işlemde ise aynı bölme işlemi olan “sayi” ismindeki değişkeni 4’e bölmek oldu. Yani,  9/4 işlemini yaptık. Fakat 4 sayısını 4.0 şeklinde yani ondalıklı şekilde yazdık. Dolayısıyla sonucu atadığımız değişkende ondalıklı olduğu için ekrana tam olarak 2.25 yazdırıldı.

3. işlemde ise aynı bölme işlemini yaptık. Hatta bu sefer 4.0 bile yazmadık ama sonuç yine 2.25 şeklinde aktarıldı. Çünkü float ifadesi ile programa bunun sonucunu float cinsinden döndürmesini istedik. Dolayısıyla program bizi kırmadı ve sonuç c ismindeki float tipindeki değişkene ondalıklı olarak aktarıldı.

4) Arttırma (++) ve Azaltma (–) Operatörleri

C++ dilinde arttırma ve azaltma operatörleri önemli bir yer tutar. Arttırma (++) operatörü, yanındaki değişkenin değerini 1 arttırır. Azaltma operatörü ise 1 tane eksiltir. Aşağıdaki örnekle konuyu daha iyi anlayabilirsiniz.

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int a = 6, b = 8;

  ++a;
  b++;

  cout << "a'nin yeni degeri: " << a << endl;
  cout << "b'nin yeni degeri: " << b << endl;

  system("pause");

  return 0;
}

Programın çıktısından da görebileceğiniz gibi başlangıç değerleri 6 ve 8 olan 2 tane değişkenin ++ operatörü ile arttırdık ve yeni değerleri 7 ve 9 oldu.

Aynı şekilde ++ operatörü yerine – operatörünü kullansaydık. Değerleri 1 tane azaltmış olacaktık dolayısıyla yeni değişken değerleri 5 ve 7 olacaktı. Buraya kadar her şey tamam. Şimdi gelelim önemli bir noktaya. Dikkat ederseniz üstteki örnekte operatörü değişkenden önce (++a) veya değişkenden sonra (b++) kullanmamız bir şey değiştirmedi. İkisi de aynı görevi gördü. Peki bunların farkı var mı? Elbette var. Bu fark değişkene atama yaparken ortaya çıkıyor. Şimdi size bunu örnekle açıklayayım.

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int sayi1 = 5, sayi2 = 10, yeniSayi1 = 0, yeniSayi2 = 0;

  yeniSayi1 = sayi1++; /*Burada öncelikle sayi1'in değerini yeniSayi1 değişkenine atadı ve daha sonra sayi1'in değerini 1 tane arttırdı. */
  yeniSayi2 = ++sayi2; /*Burada ise öncelikle sayi2'nin değerini 1 tane arttırdı ve sonra sayi2'nin değerini yeniSayi2 değişkenine atadı. */

  /* Şimdi bu değişkenlerin değerini ekrana yazdıralım. */

  cout << "sayi1 degeri: " << sayi1 << endl;
  cout << "yeniSayi1 degeri: " << yeniSayi1 << endl << endl;/*2 satır boşluk bırakmamın sebebi sonucu daha net görebilmeniz.*/
  cout << "sayi2 degeri: " << sayi2 << endl;
  cout << "yeniSayi2 degeri: " << yeniSayi2 << endl;

  system("pause");

  return 0;
}

Aşağıdaki programın çıktısında gerekli açıklamayı yaptım ama  yine burada belirteyim. Atama yaptığımız esnada; ++ veya – operatörünü değişkenden önce koyarsanız ilk yapacağı iş değişkenin değerini arttırmak/azaltmak daha sonra atama işlemini yapmak olacaktır. Zıttı olarak da eğer bu operatörleri değişkenden sonra koyarsanız önce atamayı yapar daha sonra yanındaki değişkenin değerini arttırır/azaltır.

Daha iyi anlamanız için tablo olarak özetleyelim:

5) Aritmetik Atama Operatörleri

C++ dilinde 5 tane aritmetik atama operatörü vardır. Bunlar kod yazarken bizlere kolaylık sağlar ve daha az kod yazmamızı sağlar.

Topla ve Ata ( += )

a=a+b ifadesinin kısa şekli a+=b şeklindedir.

Çıkar ve Ata (-=)

a=a-b ifadesinin kısa şekli a-=b şeklindedir.

Çarp ve Ata ( *= )

a=a*b ifadesinin kısa şekli a*=b şeklindedir.

Böl ve Ata ( /= )

a=a/b ifadesinin kısa şekli a/=b şeklindedir.

Mod Al ve Ata ( %= )

a=a%b ifadesinin kısa şekli a%=b şeklindedir.

6) Karşılaştırma Operatörleri

C++ dilinde 6 tane karşılaştırma operatörü vardır. Bu operatörler ile iki karakteri veya sayıyı kendi aralarında karşılaştırabiliriz. Bu operatörler genellikle if gibi koşul yapılarında kullanıldığı için şimdilik sadece ne anlama geldiklerine değineceğiz. Yapılara gelince bunları fazlasıyla kullanacağız.

1. Küçüktür Operatörü ( < )
2. Büyüktür Operatörü ( > )
3. Küçük Eşittir Operatörü ( <= )
4. Büyük Eşittir Operatörü ( >= )
5. Eşit mi Operatörü ( == )  Bunu atama operatörü ile karıştırmayın. Bunda 2 tane = kullanıyoruz
6. Farklı mı(eşit değil) Operatörü ( != )

Bool veri tipimizi kullanarak bir örnek çözelim.

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  bool a = (6 < 3);
  bool b = (5 > 8);
  bool c = (10 <= 10);
  bool d = (12 >= 15);
  bool e = (1 == 1);
  bool f = (0 != 0);

  cout << "a degeri:  " << a << endl;
  cout << "b degeri:  " << b << endl;
  cout << "c degeri:  " << c << endl;
  cout << "d degeri:  " << d << endl;
  cout << "e degeri:  " << e << endl;
  cout << "f degeri:  " << f << endl;

  system("pause");

  return 0;
}

Üstte tanımladığımız bool tipindeki değişkenlere bazı koşullar ekledik. Eğer bu koşullar sağlanıyorsa yani doğruysa bool tipindeki değişkene True(1) değilse False(0) değeri atanıyor. Programın çıktısı bu şekildedir:

7) Mantıksal Operatörler

İki veya daha fazla koşul karşılaştırılırken mantıksal operatörlerden yararlanılır.

1. ‘Ve’ operatörü (&&) = Verilen ifadenin tümünün koşulu sağlaması gerekir.
2. ‘Veya’ operatörü (||) = Verilen ifadelerin en az bir tanesinin koşulu sağlaması gerekir.
3. ‘Değil’ operatörü (!) = Kendisinden sonra gelen ifadenin değilini yani tersini(zıttını) alır.

Şimdi örnekle olaya açıklık getirelim:

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  bool kosul_1 = 1 > 2 && 5 < 7; // Koşulların ikisi sağlanmadığı için 0(False) değerini döndürür.
  bool kosul_2 = 20 > 10 && 2 == 2; // koşulların ikisi sağlandığı için 1(True) değerini döndürür.

  bool kosul_3 = 12 < 6 || 4 > 2; // 12 sayısı 6'dan küçük ama 4 sayısı 2'den büyük. 1 koşul sağlandığı için 1(True) değerini döndürür.
  bool kosul_4 = 2 > 5 || 12 < 24; // her iki koşulda sağlanmayacağı için 0(False) değerini döndürür.

  cout << "Kosul 1:  " << kosul_1 << endl;
  cout << "Kosul 2:  " << kosul_2 << endl;
  cout << "Kosul 3:  " << kosul_3 << endl;
  cout << "Kosul 4:  " << kosul_4 << endl;

  system("pause");

  return 0;
}

Sizlerinde tahmin ettiği gibi sonuç bu şekilde olacaktır:

Gördüğünüz gibi koşullara göre sırasıyla; 0, 1, 1, 0 yani false, true, true, false değerleri alındı ve ekrana yazdırıldı. Sizlerde bu örnekleri deneyerek kavrayabilirsiniz.

8) Özel Amaçlı Ternary Operatörü ( ?: )

Bu dersten sonra göreceğimiz ‘if’ yapısının yaptığı görevi yapmaktadır. Kullanımı ise şu şekildedir:

koşul ? doğru_ise : yanlış_ise

Aşağıdaki örnekle konuyu biraz daha somutlaştıralım:

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
  int a = 10, b = 5, c = 25, d = 15, e, f;

  e = a > b ? a : c;
  f = c < d ? 9 : 13;

  cout << "e degeri:  " << e << endl;
  cout << "f degeri:  " << f << endl;

  system("pause");

  return 0;
}

Kodun çıktısı şu şekilde olacaktır:

Gördüğünüz gibi atama yaparken belirtiğimiz şartı sağlayıp sağlamamasına göre istediğimiz değerleri atayabiliyoruz.  Eğer koşul sağlanırsa : işaretinden önceki değeri, sağlamıyorsa : işaretinden sonraki değeri atıyor.

9) Operatörler ve Öncelikleri

Aşağıdaki tabloda operatörler ve öncelikleri gösterilmiştir: