C++ Operatörler

Değişkenlerin ve sabitlerin öğrenildiğini varsayarsak bu ifadeler ile mutlaka kullanılacak olan operatörleri de bilmemiz gerekecektir. Bu konuda operatörlere yer vereceğiz. Tüm operatörleri bilme zorunluluğundan bahsetmemiz doğru olmaz. Lakin birçoğu C++ programlama dilinde tercih edilen temel operatörlerdir.

Atama Operatörü (=) - Assignment Operator

Bir değişkene değer atamak için kullanılır. Atama işlemleri her zaman sağdan sola olacak şekilde gerçekleşir.

Basit bir örnek yapmak gerekirse;

int main() {
	int x = 10;
	int y = x;
	cout << y;
}

Örnekteki yapıya baktığımızda int x (tam sayı x) değişkenine 10 değerini atadık. Hemen sonraki satırında ise int y değişkenimize x değişkenimizin değerini atadık. Sonuç olarak ekranımızda 10 çıktısı gözükecektir.

Kod yapısı incelendiğinde y değişkenine atanan değerden sonra tekrar x değişkeninin değerini almak istersek herhangi bir problemle karşılaşmayız.

int main() {
	int x = 10;
	int y = x;
	y = y+5;
	cout << "x degiskeninin degeri: " << x << endl;
	cout << "y degiskeninin degeri: " << y << endl;
}

Örneğimize baktığımızda y değişkenine x değişkeninin değerini atadık, y değişkenine 5 ekledik ve x ile y değişkenini ekrana yazdırdık. Çıktıyı aşağıda görebiliriz;

x degiskeninin degeri: 10
y degiskeninin degeri: 15

Yani başlangıçta belirlediğimiz x değişkeninin değerinde herhangi bir değişiklik yapmadık.

C++ dilinde birden fazla değişkene aynı değeri aşağıdaki gibi atayabiliriz;

int main() {
	int x,y,z;
	x = y = z = 5;
	cout << "x = " << x << endl;
	cout << "y = " << y << endl;
	cout << "z = " << z << endl;
}

**Matematiksel Operatörler ( + , - , * , / , % )**

Hemen her dilde olduğu gibi matematik işlemleri için kullanılan operatörlerdir. Kabaca;

Operatör	Açıklaması
+	Toplama İşlemi
-	Çıkartma İşlemi
*	Çarpma İşlemi
/	Bölme İşlemi
%	Mod Alma İşlemi

**Bileşik Atama Operatörleri ( += , -= , *= , /= , %= )**

Standart atama işlemini gerçekleştirirken işlemleri daha kısa yapabilmek için kullanılır.

Operatör	Aynı Anlama Gelir;
x += 1;	x = x + 1;
x -= 1;	x = x - 1;
*x = 1;**	x = x * 1;
x /= 1;	x = x / 1;
x %= 1;	x = x % 1;

Arttırma ve Azaltma Operatörleri ( ++ , -- )

Bileşik atama operatörlerinde yaptığımız işlemleri daha da kısaltabiliriz.

x++

x += 1

x = x + 1

Tablodaki 3 değerde birbirine eşittir.

Arttırma ve Azaltma Operatörlerinde Dikkat!

Bu operatörler kullanılırken dikkat edilmesi gereken ufak bir detay vardır. ++ ve -- ifadeleri belirtilen değişkenden önce ve sonra kullanımına göre farklı sonuçlar elde edilir. Aşağıdaki örneği ve yorum satırlarını dikkatlice inceleyelim.

int main() {
	int x = 5; // x'e 5 değerini atadık.
	int y = ++x; // y değişkenini x+1'e eşitledik.
	cout << "y: " << y << "\t" << "x: " << x; // x:6        y:6
	
	cout << "\n";
	
	int a = 5; // a'ya 5 değerini atadık.
	int b = a++; // b değişkenini a'ya eşitledik, a'yı 1 arttırdır.
	cout << "a: " << a << "\t" << "b: " << b; // a:6        b:5
}

Çıktılarımızı bir de şöyle görelim;

x:6        y:6
a:6        b:5

Yani anladığımız üzere ++ ve -- ifadelerini önce kullanmak ile sonra kullanmak çok farklıdır. Mantığa bakmak gerekirse bilgisayar programı okurken sırasıyla gelir demiştik. Yani ++x ile x değişkenini arttırdı ve y değişkenine atadı. İkinci örneğimizde ise a değişkenini b değişkenine atadı ve a değişkenini 1 arttırdı.

Karşılaştırma Operatörleri ( == , != , > , < , >= , <= )

Bu operatörler yardımıyla karşılaştırma işlemleri yapılmaktadır. İki değer arasından hangisinin küçük, hangisinin büyük olduğu gibi işlemler gerçekleştirilebilir. Sonuçları doğru veya yanlıştır.

Operatör	Aynı Anlama Gelir;
==	Eşittir
!=	Eşit Değildir
>	Büyüktür
<	Küçüktür
>=	Eşit veya Büyüktür
<=	Eşit veya Küçüktür

Aşağıdaki yapıyı bu eşitlikler sayesinde kurabiliriz.

a = 5;
b = 6;
c = 7;
d = 8;

a == b // Yanlış
b >= c // Yanlış
c < d // Doğru
b <= d // Doğru

Bu alanda en çok dikkat edilmesi gereken ve her yazılımcının hayatında bir kez olsun yaptığı hata = ve == ifadeleridir.
= : Sağdaki değişkeni veya değeri soldaki değişkene atar.
== : Sağ tarafın değeri ile sol tarafın değerinin eşit olup olmadığını karşılaştırır.

Mantıksal Operatörler ( ! , && , || )

Mantıksal operatörler aslında matematikte mantık konusunu oluşturur. Bu 3 operatörü tek tek inceleyelim;

1. Değildir Operatörü ( ! )

Bu operatör gerçekleşen işlemin sonucunu zıt olarak değiştirir. Örneğin;

x = 1;
y = 2;

x == y // Yanlış
!(x == y) // Doğru

2. Ve Operatörü ( && )

Bu operatör için aşağıdaki tabloyu inceleyelim;

a	b	a && b
1	1	1
1	0	0
0	1	0
0	0	0

Tablomuzdaki 1'leri doğru, 0'ları yanlış olarak kabul edebiliriz. Sonuçları ele aldığımızda a ve b değerlerinden herhangi biri sıfır olduğu anda sonucumuzunda sıfıra eşit olduğunu görüyoruz. Ancak her iki değer için de 1 yani doğru geçerli ise sonucumuz 1 oluyor.

Bunu bir örnek üzerinden anlatalım: Elimizde bir kullanıcı adı ve bir de şifre değişkenleri var. Bu iki değerinde bizim için 1 yani doğru sonucunu döndürmesi gerekir ki kullanıcı giriş yapabilsin. O halde bunun kontrolünü şöyle yapabiliriz;

(kullaniciAdi == 1) && (sifre == 1)

Bunu bir sayı vererekte anlatabiliriz;

(5 < 6) && (1 == 1) // Doğru && Doğru
(6 < 5) && (1 == 1) // Yanlış && Doğru

Programımızda karşılaştırma yaparken kullandığımız ve operatörü ile karşılaştırmalarımıza seçenek katmış oluruz. Genelde verdiğim üyelik sistemleri bu mantıkta çalışır.

3. Veya Operatörü ( || )

Bu operatör için aşağıdaki tabloyu inceleyelim;

a	b	a \|\| b
1	1	1
1	0	1
0	1	1
0	0	0

Tablomuzdaki 1'leri doğru, 0'ları yanlış olarak kabul edebiliriz. Sonuçları ele aldığımızda sonucun yanlış yani 0 dönmesi için her iki değişkeninde 0'a eşit olması gerekiyor. Yani iki değişkenin de yanlış olması durumunda sonuç yanlış kabul ediliyor. Fakat belirtilen koşullardan biri sağlandığında doğru sonucunu alıyoruz.

Bunu bir örnek üzerinden anlatalım: Bir kafeye gittiniz ve garsona çay veya kahve olup olmadığını sordunuz. İhtimalleri düşünelim;

Çay var, Kahve Var : Seçim bize kalıyor ve bu durumda kafede oturmaya devam ediyoruz. ( DOĞRU : 1 )
Çay var, Kahve Yok: Çay içiyoruz ve bu durumda kafede oturmaya devam ediyoruz. ( DOĞRU : 1 )
Çay yok, Kahve Var: Kahve içiyoruz ve bu durumda kafede oturmaya devam ediyoruz. ( DOĞRU : 1 )
Çay yok, Kahve Yok: Başka bir kafeye geçiyoruz. ( YANLIŞ : 0 )

Aslında bu 4 satır yukarıdaki tablomuzla aynı sonuca ulaştırıyor bizi. Şimdi bunu kodda görelim;

cay = 1;
kahve = 1;

(cay == 1) || (kahve == 1) // DOĞRU
(cay == 1) || (kahve == 0) // DOĞRU
(cay == 0) || (kahve == 1) // DOĞRU
(cay == 0) || (kahve == 0) // YANLIŞ

Koşul Operatörü ( ? )

Eğer (if) yapısını öğrendiğinizde bu yapıyı tekrar kullanmak istemeyebilirsiniz. If yapısının daha basite indirilmiş halidir fakat kişisel olarak kullanım yapısını karmaşık bulmaktayım.

koşul ? doğruysa : yanlışsa

Bunu C++ dilinde bir örnekle açıklamak gerekirse;

#include <iostream>
#include <string>
using namespace std;

int main() {
	int x = 5;
	int y = 6;
	string c;
	
	c = x == y ? "5 esittir 6" : "5 esit degildir 6";

	cout << c;
}

Elbette çıktı olarak;

5 esit degildir 6

gözükecektir.

Ayırma Operatörü ( , )

Aynı yerde bulunan birden fazla değeri veya değişkeni ayırmak için kullanılır.

int main() {
	int x,y;
	
	y = (x=5, x+1);
	cout << "x = " << x << endl;
	cout << "y = " << y;
}

Örneğimize baktığımızda yaptığımız işlemleri adım adım inceleyelim;

x ve y adında iki tane integer değişken oluşturduk.
y değişkenine atamak için bir yapı oluşturduk. Bu yapımızda ilk olarak x değişkenimize 5 değerini atadık. Ardından y değişkenimize x+1 değerini atadık. Yani 5+1 = 6 değeri y değişkenine atanmış oldu.

Ekrana çıktı olarak