// Operatörler

   // dört işlem: +-*/

   // artırma azaltma: a++, ++a, a--, --a

   // karşılaştırma: > büyük, < küçük, >=, <=, == eşitmi, != eşit değil mi

   // mantıksal ve bit operatörleri:

   // "ve" yani & (shift + 6 tuşula çıkan ifade)

   // "veya" yani | (altgr + >< tuşlarıyla çıkan ifade)

   // değil yani ! ifadesi ile kullanılır.

   // dışlamalı veya ^ (shift+3+boşluk) (ikisinden biri doğru olmalı

   // ikisi doğru olamaz, ikisi yanlış olamaz)

// **************** Derste yazdıklarım buraya kadar *****************

// ******************************************************************

// *******Operatörler***********

// nokta (.) operatörü -> Nokta operatörü bir sınıfın, namespace'in

// elemanlarına erişmek için kullanılır.

// () Parantez -> Parantez operatörü işlem sırasını belirlemek için

// kullanılır. Tür dönüşümlerinde de kullanılır örnek;

            double s = 3282.2;

            int a;

            a = (int)s;

// double tipindenki x değişkenini int tipine çevirerek a değişkenine atar

// ++, -- : Arttırma, Azaltma

// Bu operatör değişkenle birlikte kullanılır. Değişkenin değerini 1

// arttırma veya 1 azaltma  işlemini yapar. Örneğin;

   Console.WriteLine("++ ve -- operatörleri hakkındaki örnek başlıyor...");

            int x, y, z, v;

            x = 10;

            y = 25;

            z = 150;

            v = 250;

            Console.WriteLine(x++);

            Console.WriteLine(++y);

            Console.WriteLine(z--);

            Console.WriteLine(--v);

            Console.ReadLine();

// Yukarıda x,y,z,v adlarında 4 tane integer tipte değişken tanımladık ve

// bunlara değerler atadık.çıkan sonuçlar 10,26,150,249 olacaktır. ++ veya // -- operatörü değişkenin başına gelirse önce değeri azaltır veya arttırır

// ondan sonra değişkenle toplar. Eğer operatör en sona gelirse önce değeri

// yazar sonra azaltma veya arttırma işlemini uygular.

// +, -, /, *, %    

// Matematiksel İşlem Operatörleri

// + operatörü toplama işleminin dışında başka görevlerde de kullanılır.

// 2 string değeri birleştirmek içinde + operatörü kullanılır.

Console.WriteLine("+ operatörü hakkındaki örnek başlıyor...");

            int topla1, topla2;

            topla1 = 10;

            topla2 = 25;

            Console.WriteLine(topla1 + topla2);

            Console.ReadLine();

// - operatörü çıkartma işlemini gerçekleştirir..

            Console.WriteLine("- operatörü hakkındaki örnek başlıyor...");

            int say1, say2,saysonuc;

            say1 = 5;

            say2 = 3;

            saysonuc = say1 - say2;

            Console.WriteLine(saysonuc);

            Console.ReadLine();

// yukarıdaki işlemlerin sonucunda 5-3'ten 2 sayısı ekrana yazdırılacaktır.

// = (eşittir) : Atama Operatörü

// bu operatörle eşittir'in sağ tarafına girilen işlemleri ya da değerleri

// sol taraftaki bir değişkene atayabilirsiniz. örnek;

“

            double xx;

            int ii;

            ii = 5; // int türünden int türüne atama

            xx = ii; // int türünden double türüne dönüşüm

// == : Eşitlik operatörü

// bu operatör solundaki ve sağındaki operandların yani değerlerin eşit

// olup olmadığını kontrol eder. Eğer her iki taraftaki değerler eşitse             // 'true' değerini döndürür değilse 'false' değeri döner. Yani şöyle bir

// örnek verecek olursak 'a==b' şeklindeki bir işlemin

// 2 farklı sonuç verme ihtimali vardır ya a' b'ye eşittir ya da değildir. // true veya false.

// != : Eşitsizlik Operatörü

// Çalışma yapısı olarak eşitlilik operatörüyle aynıdır.

// Bir karşılaştırma operatörüdür.

// Eğer operatörün sağ ve sol tarafları birbirine eşit değilse true,

// eşitse false döner.

// örnek;

            Console.WriteLine("!= operatörü hakkındaki örnek başlıyor...");

            int sss, aaa;

            sss = 3;

            aaa = 5;

            Console.WriteLine(sss != aaa);

            Console.ReadLine();

// yukarıdaki işlemlerin sonucunda ekrana 'true' yazdırılacaktır. çünkü 3, // 5'e eşit değildir. Biz sss!=aaa  yazarak programa aaa değişkeni

// sss değişkenine eşit değilmidir dedik o da cevap olarak 'true'

// yani evet aaa değişkeni sss değişkenine eşit değildir dedi.

// (*) ve (/) operatörleri :

// bu operatörler çarpma ve bölme işlemi yapmaya yarar

// örnekler;

            Console.WriteLine("* operatörü hakkındaki örnek başlıyor...");

            int carp1, carp2;

            carp1 = 5;

            carp2 = 12;

            Console.WriteLine("Carpma işlemi sonucu:" + (carp1 * carp2));

            Console.ReadLine();

// Önce Yukarıda integer(sayısal) tipte carp1 ve carp2 adlarında 2 değişken

// tanımladık Sonra bu değişkenlere 5 ve 12 değerlerini verdik, sonraki

// satırda da ekrana sonucu Yazdırdık ve çarpı operatörünü öğrenmiş olduk.

// Şimdi bölme (/) işlemine bakalım.

            int bol1, bol2;

            string sonucuyaz;

            Console.WriteLine("/ operatörü hakkındaki örnek başlıyor...");

            bol1 = 40;

            bol2 = 5;

            sonucuyaz = "Bölme işlemi sonucu:";

            Console.WriteLine(sonucuyaz + (bol1 / bol2));

            Console.ReadLine();

// Yukarıda bol1,bol2 ve sonucuyaz adlarında değişkenler tanımladık.            // Bu değişkenlerden bol1 ve bol2 integer(sayısal) tipte, sonucuyaz            // değişkenlere değerler girip programdan bol1'i bol2'ye bölmesini istedik.

// değişkeni ise string (yazı) tiptedir Yanlız burda dikkat edilmesi

// gereken bir husus var,burada bol1 ve bol2 integer tipte.

// Dolayısıyla bol1, bol2'ye tam olarak bölünmeli ki sonuç tam çıksın.

// Tamam tamam dur şimdi, şöyle bir örnek daha vereyim iyice pekişsin.

            double bolme1, bolme2;

            bolme1 = 23;

            bolme2 = 13;

            string aciklama1, aciklama2;

            aciklama1 = "Hehh bak şimdi oldu, bölme sonucu küsüratlıda olsa sonuç doğru hatta sonuç tamda ";

            aciklama2 = " çıkması lazım, dorğu mu bilmiyom bi hesap makinesiyle bak istersen";

            Console.WriteLine(aciklama1 + (bolme1 / bolme2) + aciklama2);

            Console.ReadLine();

// işte anladık ki bölme işlemlerinde değişkenlerimizi integer değilde

// double tipte  atamak daha doğru olacak, tabi bu her zaman için geçerli

// değil, yazdığınız  programa bağlı olarak integer olarak atamakta doğru // olur ancak bence riske girmeye gerek yok şimdilik bölme işlemlerinde

// değişkenleri double olarak atamayı alışkanlık

// haline getirin, hata yapma şansınız azalır.

// ?: -> Kontrol Operatörü

// Kullanımı->   koşul? ilk ifade : ikinci ifade;

// Bu operatörü örneklerle anlamak daha kolay olur o yüzden

// fazla uzatmadan direk örneğe geçelim.

            int kontrol1, kontrol2;

            kontrol1 = 5;

            kontrol2 = 20;

            Console.WriteLine( kontrol1 > kontrol2 ? kontrol1 : kontrol2 );

            Console.ReadLine();

// şimdi yukarıdaki örneği inceleyelim, integer tipte iki değişken atadım

// sonra bu değişkenlere değerler verdim. Dananın kuyruğunun koptuğu yere

// gelelim. 'kontrol1 > kontrol2 ? kontrol1 : kontrol2' şeklinde bir

// kodla kontrol operatörüne örnek verdik. Bu kod ne anlama geliyor

// Soru işareti(?)'nden önceki kısım koşul kısmıdır yani burda bir

// şart konur ve bu şartın sonucuna göre program devam eder.

// biz burda demişiz ki;

// "'kontrol1' değişkeni 'kontrol2' değişkeninden büyükse"

// sonra devam etmişiz; "Şart doğruysa ekrana 'kontrol1' yaz".

// ve yine iki nokta (:) işaretiyle yanlışsa yapılacak olan

// işlemi yani "küçükse ekrana kontrol2 yaz" kısmını yazmışız

// sonuç olarak bu operatörün kullanılışı şu şekilde akılda kalsın;

// burası doğruysa ? bu kısmı ekrana yaz : değilse bu kısmı ekrana yaz