C’de switch Deyimi

Daha önceki yazılarımızda C’de konrol yapılarını incelerken seçmeli yapılardan ve onun türlerinden bahsetmiştik. C’de bu yapıları implement etmek için if ve if…else gibi deyimler bulunuyordu. Sadece if deyimi tek seçimli deyim olarak adlandırılıyordu, yani içerisindeki deyim ya çalıştırılır ya da çalıştırılmaz gibi bir durum vardı. if…else deyimi ise çift seçimli deyim, yani içerisindeki kod çalıştırılmazsa bir başka bloğundaki kod çalıştırılır gibi bir mantık vardı. Yani ya if bloğu içerisindeki deyimler ya da else bloğu içerisindeki deyimler çalıştırılırdı.

Bunların dışında çok seçimli deyimlerden bahsettik. Aslında bu seçmeli yapılarda birden fazla yol oluşturmaya benzemektedir. Örneğin bir sayı 10 ile 20 arasında ise bir işlem, 20 ile 30 arasındaysa başka bir işlem, 30 ile 40 arasındaysa da başka bir işlem yaptırabiliriz. Bunu elbette aslında temelde bir if…else deyimi olan if…else if…else deyimi ile yapabiliyorduk. Örneğin:

if(sayi >= 10 && sayi < 20)
{...}
else if(sayi >= 20 && sayi < 30)
{...}
else if(sayi >= 30 && sayi < 40)
{...}
else
{...}

Bu şekilde çok seçimli yapılar da oluşturabiliyorduk. Ancak o yazıda size aynı işi yapan switch isimli bir deyimden bahsetmiştim. Bu deyim ile ilgili detayları da bu yazıda göreceğiz. switch deyimi temelde if…else if…else ile aynı işi yapar. Fakat bu deyimin bazı kısıtlamaları vardır. Bu deyim aslında tamsayı türünden bir değişkenin (char türü de dahil) aldığı değerler üzerine işlem yapar. Şu örneği inceleyelim:

int deger;
scanf("%d", &deger);

switch(deger)
{
    case 0:
        puts("Sifir");
    case 1:
        puts("Bir");
    case 2:
        puts("Iki");
    case 3:
        puts("Uc");
}

puts("switch'ten sonra");

Burada direk deger değişkenine 0 değeri atanırsa ekrana Sifir yazıp daha sonra da switch'ten sonra yazılacağını düşünebilirsiniz. Ancak switch mekanizması bu şekilde çalışmaz. switch deyiminde öncelikle parantez içerisine yazılan tamsayı türünden değişkenin değerine bakılır. Daha sonra yukarıdan aşağıya doğru case anahtar kelimelerinin yanında yer alan değerler ile karşılaştırma yapılır. Eğer eşleşen değer bulunursa program o case satırının altından çalışmaya devam eder. Buraya kadar her şey normaldir. Ancak yukarıdaki örneği çalıştırıp klavyeden 1 değerini girerseniz şöyle bir çıktı ile karşılaşırsınız:

Şimdi burada ne oldu? Yanlış giden ne var? Aslında switch açısından yanlış giden bir şey yok. switch deyimi bir case kısmına girdiğinde, eğer oradaki ifadeleri çalıştırdıktan sonra satırın en sonunda switch deyiminden çıkacağımızı belirten bir ifade yer almazsa, diğer case kısımlarındaki deyimleri de sırayla çalıştırıp o şekilde deyimden çıkar. Bunu engellemenin yolu switch deyiminin sonlandığını derleyiciye bildirmektir. Bunu yapmak için ise bir sonraki yazıda daha sık olarak kullanacağımız break anahtar kelimesini kullanırız.

break anahtar kelimesi basitçe derleyiciye switch gibi deyimlerden çıkış yapıp bir sonraki deyimden devam etmesini söyleyen bir C anahtar kelimesidir. Yani yukarıdaki kod parçasını şu şekilde yazmamız gerekir:

int deger;
scanf("%d", &deger);

switch(deger)
{
    case 0:
        puts("Sifir");
        break;
    case 1:
        puts("Bir");
        break;
    case 2:
        puts("Iki");
        break;
    case 3:
        puts("Uc");
        break;
}

puts("switch'ten sonra");

Şimdi pograma 1 değerini girdiğinizde program size sadece Bir ve switch'ten sonra çıktılarını verecektir. Aslında son case bloğunda break anahtar kelimesini kullanma zorunluluğumuz yoktur. Çünkü switch içerisinde o bloktan sonra çalışacak başka bir blok yer almamaktadır. Burada case bloklarında süslü parantezleri kullanmadığımıza dikkat edin. Diğer yazılardan yola çıkarak burada sadece case satırından sonraki ilk satırın çalıştırılacağını düşünebilirsiniz. Ancak burada işler bu şekilde yürümez. Burada bir case bloğunu sonlandıran şey başka bir case bloğunun başlangıcı veya switch deyimini sonlandıran “}” parantezinin varlığıdır.

switch deyiminde eğer değişken ile ilgili bir case değeri bulunamazsa direk olarak deyimden çıkılır ve sonraki deyimden çalışmaya devam edilir. Ancak varsayılan olarak bir şeyler yapmak istiyorsanız, bu sefer default anahtar kelimesini switch deyiminin sonunda kullanmalısınız. Hemen şu örneğe bakalım:

int deger;
scanf("%d", &deger);

switch(deger)
{
    case 0:
        puts("Sifir");
        break;
    case 1:
        puts("Bir");
        break;
    case 2:
        puts("Iki");
        break;
    case 3:
        puts("Uc");
        break;
    default:
        puts("Sayi bulunamadi!");
}

puts("switch'ten sonra");

Gördüğünüz gibi default yanına herhangi bir değer almaz ve her case satırı sonundaki gibi “:” işareti yer alır. En sonda yer aldığı sürece yine break anahtar kelimesinin kullanımına gerek yoktur. Eğer programı çalıştırıp 5 değerini girersek, program bize şöyle bir çıktı verir:

Bu biraz else bloğuna benzemektedir. Böylelikle switch veya diğer adıyla switch…case deyiminin tam olarak iskeletini görmüş olduk. Bu iskeleti şöyle özetleyebiliriz:

switch(<kontrol ifadesi>) {
case <değer1>:
case <değer2>:
…
case <değerN>:
default:
}

Daha önce söylediğimiz gibi break anahtar kelimesini kullanmamıza gerek yokur. Fakat kullanmamamız durumunda ilginç ve hatalı sonuçlar ile karşılaşma olasılığımız yüksektir. Yine az önce söylediğimiz gibi case değerleri yukarıdan aşağıya doğru kontrol edilir. Yani girilen değişkenin daha yüksek ihtimalli değerlerini en yukarılara yazmak, programın gereksiz karşılaştırma yapmasının önüne geçer.

Bunun yanında “değer1“, “değer2” gibi isimerle ifade edilen değerler yerine tamsayı türünden bir sabit ifadesi gelmelidir. Örneğin bu kısma 4 + 5 gibi bir ifade gelebilirken x + 7 gibi bir ifade gelmesi söz konusu değildir. Ayrıca case ve default bloklarını herhangi bir sırada yazabiliriz. Ancak yukarıdan aşağıya bir kontrol söz konusu olduğundan default bloğu genellikle en sonda yer alır.

Yukarıdaki örneklerden farkedebileceğiniz gibi switch deyimi ile sadece eşitlik durumlarına bakılmaktadır. Yani “<“, “>“, “<=” ve “>=” gibi operatörler ile koşulları yazılmış olan if…else if…else deyimlerini doğrudan switch deyimine çevirmek mümkün olmayabilir. Ancak birden fazla case değeri için aynı sonucu yazdırmamız mümkündür. Bunu da şu şekilde yaparız:

switch(deger)
{
    case 0:
    case 1:
    case 2:
        puts("Ilk Uclu");
        break;
    case 3:
    case 4:
    case 5:
        puts("Ikinci Uclu");
        break;
    default:
        puts("Varsayilan");
}

Burada eğer deger değişkeninin değeri 0, 1 veya 2 olursa ekrana Ilk Uclu çıktısı verilir. Aynı şekilde 3, 4 veya 5 olursa ekrana Ikinci Uclu çıktısı verilir. Gördüğünüz gibi switch deyiminin özelliğinden yararlanarak birden fazla değer için aynı işlemleri yaptırabiliriz. Tabi buradaki küçük aralıklardan ziyade, arasında 20, 30 ve hatta 100 değer olan aralıklar için böyle bir kullanım can sıkıcı olur. Bu durumlarda if…else if…else deyimini tercih etmelisiniz.

switch deyiminin en iyi kullanım alanı oldukça sınırlı değerler alabilen karakter (char) türündeki değişkenlerin yer aldığı uygulamalrdır. Şimdi bununla ilgili bir örnek yapalım. Kullanıcıdan 10 adet karakter alıp bu karakterin kaçının “A“, kaçının “B“, kaçının “C” ve kaçının bu harflerin dışında bir harf olduğunu hesaplayan bir program yazalım. Kullanıcı bu harfleri küçük veyas büyük girebilsin. Programımız şu şekilde olacaktır:

// Code 4.3.1: Code4_3_1.c
// Girilen 10 karakterden A, B, C sayısını bulma

#include <stdio.h>

int main()
{
    int aSayisi = 0;
    int bSayisi = 0;
    int cSayisi = 0;
    int digerSayisi = 0;

    for(int i = 0; i < 10; i++)
    {
        char karakter;
        scanf(" %c", &karakter);

        switch(karakter)
        {
            case 'A':
            case 'a':
                aSayisi++;
                break;
            case 'B':
            case 'b':
                bSayisi++;
                break;
            case 'C':
            case 'c':
                cSayisi++;
                break;
            default:
                digerSayisi++;
        }
    }

    printf("A Sayisi: %d\n", aSayisi);
    printf("B Sayisi: %d\n", bSayisi);
    printf("C Sayisi: %d\n", cSayisi);
    printf("Diger Karakter Sayisi: %d\n", digerSayisi);

    return 0;
}

Girdiğimiz harflerden ve çıktıdan anlayabileceğiniz gibi program gayet düzgün bir şekilde çalışmaktadır. Çeşitli değişkenleri tanımladıktan sonra 13. satırda 10 kez dönecek bir for döngüsü oluşturuyoruz. Bu döngüde her adımda 16. satırda kullanıcıdan bir karakter alıyor ve onu karakter değişkeninde depoluyoruz. Daha sonra da switch deyimi ile bu karakterin “A“, “B“, “C” veya başka bir karakter olup olmadığını sorguluyor ve ilgili sonuca göre de ilgili değişkenin değerini 1 arttırıyoruz.

Hem büyük hem de küçük harfi algılamak için, case değerlerini harfin hem büyük hali hem de küçük hali için aynı kodu çalıştıracak biçimde ayarlıyoruz. Eğer bu 3 harften farklı bir harf girilirse, switch deyiminde default kısmına yazdığımız kod çalışıyor. Döngüden çıktığımızda ise arttırdığımız değişkenleri tek tek ekrana bastırıyoruz.

Bu bölümde switch deyiminden ve onun çeşitli özelliklerinden bahsettik. Bununla beraber artık C’de seçmeli yapıları implement etmek için kullanılan bütün deyimleri görmüş olduk. Son olarak bir sonraki yazıda son bir döngü deyimini de görüp döngüleri de tamamlayacağız. Ayrıca bu yazıda gördüğümüz break anahtar kelimesinin döngülerdeki kullanımına bakıp continue anahtar kelimesi ile ilgili çeşitli döngü kontrol mekanizmalarını öğreneceğiz.