Kategori: Programlama Dilleri

  • C Programlama Dili Diziler

    C Programlama Dili Diziler

    Bu güne kadar yaptığımız konu anlatımların da hep birkaç değişkenle örneklerimizi halletmemiz gerekiyordu ancak bazı durumlar olur ki, kullanıcıdan yüzlerce veya binlerce değer girmesini istemeniz gerekebilir. Bu gibi durumlarda girilecek her değer için tek tek değişkenler oluşturup süre ve boyut sıkıntısı yaşamamak için diziler en büyük yardımcılarımızdır. Örneğin 50 tane tane veri saklamamız gerekiyor, bunun için 50 tane değişken tanımlamak yerine bir tane dizi tanımlayıp 50 farklı değerin hepsini bu dizi üzerinde ki farklı noktalara kayıt edebiliriz. Tabi bu işlem için öncelikle dizimizin uzunluğunu belirlememiz ve diziyi tanımlamamız gerekiyor, örneğimiz de 50 tane dediğimiz için bu değeri kullanalım ve dizimizde ki verilerin integer tipinde olacağını varsayalım, bu durumda dizinin tanımlanması aşağıda ki gibi olacaktır.

    #include <stdio.h>
    int main(){
    	int dizi[50];
    	return 0;
    }

    Görebileceğiniz gibi dizinin tanımlanma şekli herhangi bir değişken tanımlamaya çok benziyor. Öncelikle dizinin içerisinde saklanacak veri türünü yazıyoruz (int, char, float vs…) daha sonra dizimizin adını yazıyoruz son olarak da dizinin adına bitişik olarak dizinin kaç değer saklayabilmesini istediğimizi yani uzunluğu köşeli parantezler içerisinde belirtiyoruz.

    Önemli: Bir dizinin içerisinde sadece tanımlama sırasında belirttiğiniz veri türünden değerleri kullanabilirsiniz.

    Önemli: Dizinin ilk elemanı her zaman dizi[0] adresinde bulunur, yani ilk elemana erişmek için dizi[1] yerine dizi[0] kullanmanız gerekecek. Dizinin 40. elemanına ulaşmak isterseniz dizi[39] adresini kullanmanız gerekecek.

    Dizilerin kullanımı genellikle döngüler -özellikle for döngüleri- ile olmaktadır, eğer döngüler hakkında yeterince bilgi sahibi değilseniz C programlama dili döngüler isimli konumuzu incelemenizi tavsiye ederiz.

    Diziye İlk Değer Atama

    Bazı durumlarda başlangıç için dizinin elemanlarını bizim belirlememiz gerekebilir, örneğin bir değişken tanımlarken “int sayi=20;” şeklinde bir başlangıç değeri atayabiliyorduk, aynı işlemi şimdi dizilerde yapacağız.

    Eğer bir dizinin tüm elemanlarına başlangıçta bir değer atamak istiyorsanız aşağıda ki yapıyı kullanmanız gerekiyor.

    int dizi[5]={10, 20, 30, 40, 50};

    Dizimizin boyutunu 5 olarak belirttik ve sırasıyla dizininin elemanlarını 10, 20, 30, 40, 50 olarak tanımladık ancak başlangıçta dizinin tüm elemanlarına değer atıyorsak boyutunu belirtmemiz gerekmez, örneğin;

    int dizi[]={10, 20, 30, 40, 50};

    Bu dizi de bir üstte ki dizi ile aynı çalışacaktır, başlangıç ta boyut belirtmediğimiz için dizinin boyutu otomatik olarak eklenen eleman sayısı olacaktır, bu örnek de ise otomatik olarak 5 olarak tanımlanacaktır.


    Bazı durumlar da dizide ki tüm elemanların hepsini belli bir sayıya eşitlemeniz gerekebilir, örneğin sıfıra. Normal bir şekilde dizi tanımlayıp hiçbir işlem yapmadan bu diziyi ekrana direkt ekrana yazdırırsanız muhtemelen aşağıda ki gibi anlamsız değerler karşınıza çıkabilir;

    1
    0
    4203625
    0
    3
    0
    36
    0
    0
    0

    Bunun nedeni, bir dizi kullanmak için dizi tanımladığımız da bilgisayarın hafızasında o diziye ayrılan bölümlerde daha önceden yapılmış işlemlere ait değerler kalmış olabilir, yukarıda ki örnekte görebileceğiniz 1, 4203625, 36 değerleri daha eski işlemlerden dolayı hafızanın o bölümünde kalmış değerler, bu yüzden bir dizi tanımladığımızda o dizinin tüm elemanlarını sıfıra eşitlemek bizim için daha kullanışlı ve sorunsuz olacaktır. Bunu yapmak içinse aşağıda ki yolu kullanıyoruz;

    int dizi[10]={0};

    Eğer bu şekilde bir diziyi süslü parantez içerisinde ki tek bir değere eşitlerseniz, süslü parantez içerisinde ki değer dizinin tüm elemanlarına atanır. Eğer sıfırdan farklı bir sayı atamak isteseydik, sıfır yerine atamak istediğimiz sayıyı yazmamız yeterli olacaktı.


    Yalnızca dizinin belirli bir elemanının değerini değiştirmek isterseniz de aşağıda ki kullanımı gerçekleştirmeniz gerekmekte.

    #include <stdio.h>
    int main(){
    	int i;
    	int dizi[10];
    	dizi[8]=123;
    	return 0;
    }

    Kodda 10 elemanlı bir dizi tanımladık ve dizinin indis değeri 8 olan yani 9. elemanın değerini 123’e eşitledik.

    Diziye Eleman Eklemek

    Artık dizilerin kullanımına geçebiliriz, örneğin bir öğrencinin 5 dersin sınavlarından aldığı notları bir dizi üzerine kayıt edelim.

    #include <stdio.h>
    int main(){
    	int i;
    	int notlar[5];
    	for (i=0;i<5;i++){
    		printf("%d. Dersin Notunu Giriniz: ",i+1);
    		scanf("%d",&notlar[i]);
    	}
    	return 0;
    }

    Şimdi de kodda ne yaptığımızı inceleyelim. Öncelikle elimizde 5 tane derse ait sonuçlar olacağı için, “notlar” adında bir dizi tanımlayıp uzunluğunu 5 olarak ayarlıyoruz daha sonra da bir for döngüsü oluşturarak “i” değişkeninin değerini 0’dan başlayıp 5’e gidecek şekilde ayarlıyoruz. Daha sonra döngünün içerisinde printf ile i+1’inci sırada ki -i sıfırdan başladığı için printf içinde i+1 şeklinde kullandık- dersin notunu isteyip, bu notu “notlar” isimli dizimizin “notlar[i]” adresinde sakladık. Örnek çalışma şekli şu şekilde olacaktır.

    1. Dersin Notunu Giriniz: 68
    2. Dersin Notunu Giriniz: 54
    3. Dersin Notunu Giriniz: 26
    4. Dersin Notunu Giriniz: 47
    5. Dersin Notunu Giriniz: 85

    Diziyi Ekrana Yazdırmak

    Diziyi ekrana yazdırırken de for döngülerinden yararlanıyoruz, örneğin elemanları daha önceden tanımlanmış 5 elemanlı diziyi ekrana yazdıralım.

    #include <stdio.h>
    int main(){
    	int i;
    	int dizi[5]={10, 20, 30, 40, 50};
    	for (i=0;i<5;i++){
    		printf("dizi[%d] = %d \n",i,dizi[i]);
    	}
    	return 0;
    }

    Programımızın kodları yukarıda ki gibidir, 5 elemanlı bir dizi tanımladık ve değerlerini sırasıyla 10, 20, 30, 40, 50 ye eşitledik ve daha sonra for döngüsü kullanarak sırasıyla hepsini ekrana yazdırdık. Programın çıktısı şu şekilde olacaktır;

    dizi[0] = 10
    dizi[1] = 20
    dizi[2] = 30
    dizi[3] = 40
    dizi[4] = 50

    Diziler programlama dillerinde oldukça çok kullanılan yapılardır bu yüzden mantığının anlanması oldukça önemlidir, diziler ile ilgili örneklere buradan ulaşabilirsiniz, özellikle de sıralama ve arama algoritmalarının dizilerde kullanımı oldukça önemlidir, örneklerde çeşitli sıralama ve arama algoritmaları anlatılmıştır. Önümüzde ki konuda C programlama dilinde ki matrislerden -iki boyutlu diziler- bahsedeceğiz.

  • C Programlama Dili İç İçe Döngüler

    C Programlama Dili İç İçe Döngüler

    Merhaba arkadaşlar, bir önceki yazımızda c programla dilinde döngülerderden bahsetmiştik, bu yazımızda ise bu döngülerin nasıl iç içe kullanılabileceğinden bahsedeceğiz. Öncelikle daha önceki döngüler yazımızı okumadıysanız öncelikli olarak o yazıyı okuyup daha sonra bu yazıya geçiş yapmanız konuyu anlamanız açısından daha verimli olacaktır.

    Programlama aşamalarında genellikle tek bir döngü kullanmak özellikle de gelişmiş bir şeyler yazmaya çalışırken bize yeterli olmaz ve bu durumlarda iç içe döngüler kullanmamız gerekebilir, örneğin bir for döngüsünün içerisinde başka bir for döngüsü veya bir while döngüsünün içerisinde başka bir while döngüsü bulunabileceği gibi bir for döngüsünün içerisinde bir while döngüsü veya bir while döngüsünün içerisinde de bir for döngüsü bulunabilir, iç içe istediğiniz kadar döngü kullanabilirsiniz. İç içe döngülerde unutmamanız gereken tek şey işlemler yapılırken öncelikli olarak içte ki döngü tamamlanır daha sonra dışta ki döngüye geçilir, olayın temel mantığı budur. Bunu daha iyi anlamanız için aşağıda ki örneği inceleyelim.

    #include <stdio.h>
    int main(){
    	int i,j;
    	for (i=0;i<3;i++){
    		for (j=0;j<3;j++){
    			printf("i degeri = %d - j degeri = %d \n",i,j);
    		}
    	}
            return 0;
    }

    İnceleyeceğimiz programa ait kaynak kod yukarıda ki gibidir, çıktısı ise aşağıda ki gibi olacaktır. Kodun mantığından bahsetmek gerekirse, öncelikli olarak görebileceğiniz gibi iç içe iki tane for döngüsü kullanılmış, bu durumda az önce yukarıda da bahsettiğimiz gibi içte ki for döngüsü tamamlanacak daha sonra dışta ki for döngüsü tamamlanacaktır.  Kodun çalışma şekli;

    1. Öncelikli olarak i=0 değeri için program dışta ki döngüye girdi ve içte ki döngü ile karşılaştı.
    2. Bu noktada j=0 değerini aldı ve i,j değerlerini ekrana yazdırdı, daha sonra içte ki döngünün indisi (j değeri) bir artarak 1 değerini aldı ve tekrar i,j değerleri ekrana yazdırıldı, son olarak da içte ki döngünün indisi 2 değerini aldı ve i,j değerleri ekrana yazdırıldıktan sonra içte ki for döngüsü tamamlandı ve dışta ki döngüye tekrar geçildi.
    3. Bu noktada ise i indisi bir artarak i=1 değerini aldı ve bu değer içinde içteki döngüye girerek yukarıda ki işlemleri gerçekleştirdi ve i,j değerlerini ekrana yazdırdı.
    4. Son olarak da dışta ki döngü de i=2 değerini aldı ve madde ikideki işlemleri tekrar gerçekleştirdi, bu sayede dışta ki döngü de tamamlanmış oldu ve program sona erdi.
    i degeri = 0 - j degeri = 0
    i degeri = 0 - j degeri = 1
    i degeri = 0 - j degeri = 2
    i degeri = 1 - j degeri = 0
    i degeri = 1 - j degeri = 1
    i degeri = 1 - j degeri = 2
    i degeri = 2 - j degeri = 0
    i degeri = 2 - j degeri = 1
    i degeri = 2 - j degeri = 2

    Şimdide satır ve sütun sayısı kullanıcı tarafından girilecek olan ve ekrana girilen değerlere göre c dilinde çarpım tablosu oluşturan örneğimizi inceleyelim.

    #include <stdio.h>
    int main(){
    	int i,j,satir,sutun;
    	printf("Satir Sayisi: ");
    	scanf("%d",&satir);
    	printf("Sutun Sayisi: ");
    	scanf("%d",&sutun);
    	for (i=1;i<=satir;i++){
    		for (j=1;j<=sutun;j++){
    			printf("%dx%d=%d	", i, j, i*j);
    		}
    		printf("\n");
    	}
            return 0;
    }

    Kullanıcının gireceği satır sayısının 10, sütun sayısının 5 olduğunu kabul edersek, oluşacak olan çıktı aşağıda ki gibi gözükecektir. Sonuçlardan da görebileceğiniz gibi, öncelikle dış tarafta ki for döngüsü i=1 (çarpım tablosu oluşturduğumuz için i vej değerlerini 0 yerine 1 den başlattık.) değerini alıyor ve daha sonra da program içte ki döngüye geçerek j değerinin sırasıyla 1,2,3,4,5 almasını sağlıyor ve her değerde ilgili çarpım değeri hesaplanıp ekrana yazdırılıyor, içteki döngü tamamlandıktan sonra ise i değeri 1 arttırılıyor ve oluşan yeni i değeri için içte ki döngü tekrar çalıştırılıyor, bu sayede de aşağıda ki çıktı da görebileceğiniz bir çarpım tablosu oluşturabiliyoruz.

    Satir Sayisi: 10
    Sutun Sayisi: 5
    1x1=1           1x2=2           1x3=3           1x4=4           1x5=5
    2x1=2           2x2=4           2x3=6           2x4=8           2x5=10
    3x1=3           3x2=6           3x3=9           3x4=12          3x5=15
    4x1=4           4x2=8           4x3=12          4x4=16          4x5=20
    5x1=5           5x2=10          5x3=15          5x4=20          5x5=25
    6x1=6           6x2=12          6x3=18          6x4=24          6x5=30
    7x1=7           7x2=14          7x3=21          7x4=28          7x5=35
    8x1=8           8x2=16          8x3=24          8x4=32          8x5=40
    9x1=9           9x2=18          9x3=27          9x4=36          9x5=45
    10x1=10         10x2=20         10x3=30         10x4=40         10x5=50

    Şimdi de iç içe iki farklı döngü çeşidinin kullanımına göz atalım, örneğin aşağıda ki gibi bir görüntüyü iç içe döngü kullanarak elde etmeye çalışalım.

    Satir Sayisi: 10
    
     *
     *  *
     *  *  *
     *  *  *  *
     *  *  *  *  *
     *  *  *  *  *  *
     *  *  *  *  *  *  *
     *  *  *  *  *  *  *  *
     *  *  *  *  *  *  *  *  *

    Öncelikle görebileceğiniz gibi 10 adet satırdan oluşan bir dik ikizkenar üçken elde ediliyor, ikizkenar dik üçgeni elde etmek için takip etmemiz gereken mantık şu şekilde olacaktır;

    • Her satırla beraber i değeri artıyor ancak her satırda sadece i değeri kadar * sembolü gösteriliyor, yani 1. satırda bir tane * sembolü, 2. satırda 2 tane * sembolü şeklinde bir algoritma geliştirmemiz lazım.
    • Öncelikle kullanacağımız döngülere karar vermemiz lazım, satır sayısı görebileceğiniz gibi kullanıcıdan alındığı yani sonu belli bir değer olduğu için satırları oluşturmak için for döngüsü kullanmalıyız, diğer yandan sütunlarda ise * sembolü sayısı satır sayısına bağlı olduğu için belli bir sabit son değere sahip değildir ve karşılaştırma işlemi gerektiği için while döngüsü kullanmamız uygun olacaktır.
    • Dış döngüde for yapısını, iç döngüde ise while yapısını kullanmaya karar verdikten sonra artık işlemlere geçebiliriz, dışta ki for  döngüsünün değerinin sırasıyla artarak kullanıcının girdiği değere kadar gideceğini biliyoruz, içte ise while döngüsünü çalıştırmak için yani * sembolünü ekrana bastırmak için bir şart kullanmamız gerekiyor, bu örnekte ise görebileceğiniz gibi içte ki döngünün indisi dıştaki döngünün indisinden küçük olduğu sürece ekrana * sembolünü basıyor, yani while döngüsünün şartı bu olmalı, eğer şart sağlanıyor ise döngüye girilmeli ve indis değeri şart sağlanmayana kadar birer birer arttırılmalıdır.
    • Oluşması gereken kod aşağıda ki gibi olacaktır.
    #include <stdio.h>
    int main(){
    	int i,j,satir;
    	printf("Satir Sayisi: ");
    	scanf("%d",&satir);
    	for (i=0;i<satir;i++){
    		j=0;
    		while (j<i){
    			printf(" * ");
    			j++;
    		}
    		printf("\n");
    	}
            return 0;
    }

    Böylelikle bu dersimizinde sonuna geldik, iç içe döngüler daha çok iki ders sonra göreceğimiz matris yapıları ile birlikte sıkça görülmektedir, eğer konu hakkında daha fazla örneğe ihtiyaç duyarsanız c dili örnek sorular kategorisinden daha fazla örneğe ulaşabilirsiniz, bir sonra ki dersimizde dizilerden bahsedeceğiz.

  • C Programlama Dili Döngüler

    C Programlama Dili Döngüler

    Döngüler programlama dillerinin temel yapılarından biridir, özellikle bu dersten itibaren devam edeceğimiz C programlama dili dersleri de döngülere bağlı olarak devam edecektir, o yüzden bu dersi dikkatli bir şekilde incelemenizi ve bol bol pratik yapmanızı tavsiye ederiz.

    Programlama dillerinde aynı işlem kümelerini birden fazla defa tekrar yaptırmak istiyorsak döngüler tam bu noktada yardımımıza yetişiyor. Örneğin ekrana alt alta 100 tane “merhaba dünya” yazdırmak istiyoruz diyelim, bu güne kadar öğrendiğimiz bilgilere göre mecburen alt alta 100 satır şeklinde “merhaba dünya” yazdırarak bu işi yapardık ancak bu işi daha kısa yoldan yapabiliriz, döngüler sayesinde sadece bir kere “merhaba dünya” yazarak bizim yerimize döngünün onu 100 kere tekrar ettirmesini sağlayabiliriz.

    Daha da teorik olarak ifade etmek gerekirse programın neyi, nasıl, ne zaman yapmasını belirleyebildiğimiz yapılara döngü deriz. C programlama dilinde temel olarak üç tane döngü yapısı vardır;

    1.  For Döngüsü
    2. While Döngüsü
    3. Do..While Döngüsü

    Döngü yapılarında temel olarak yapılması istenen işlemlerin kaç kere veya hangi şartlar altında yapılacağını belirlemek çok önemlidir, eğer uygun değerler kullanılmazsa bir döngü kullanıcının bilgisayarının kaynaklarını oldukça zorlayabilir. Bu yüzden doğru adım sayısını belirlemek oldukça kritiktir. Döngüler içerisinde bu adım sayılarını belirlerken karşılaştırma operatörlerinden de faydalanabiliyoruz, bu yüzden operatörler hakkında bilginiz yoksa öncelikle burada ki yazımızı okuyarak operatörler hakkında bilgi sahibi olabilirsiniz. Şimdi döngüleri daha detaylı olarak inceleyebiliriz.

    For Döngüsü

    Özellikle yapılacak işlem sayısının belli olduğu durumlarda for döngülerini kullanırız. Başlangıç değerimiz ve gideceğimiz hedef değer belli olduğu için döngünün adım sayısını da belirlemiş oluyoruz, döngünün temel yapısı şu şekildedir;

    for (degisken=baslangic_degeri;degisken<=hedef_deger;degisken++){
        islemler;
    }

    Parantez içinde ki bölüm fark ettiğiniz gibi “;” işaretleri ile üç ayrı bölüme ayrılmıştır, bu üç bölümün hepsi farklı durumları ifade ederler. İlk bölümde ismini bizim belirlediğimiz bir değişkeni başlangıç değerine eşitleriz; ikinci bölümde ise belirtilen karşılaştırmanın doğruluğu kontrol edilir, şart sağlandığı sürece döngü devam eder; son kısımda ise belirlediğimiz değişkenin değerinin döngünün her turunda bir artmasını veya azalmasını belirleriz. Bunun için ++ veya — operatörlerinden birisini kullanabilirsiniz.

    Şimdi 10’a kadar olan pozitif sayıların toplamını hesaplayan bir program yazarak for döngüsünün mantığını daha iyi anlamaya çalışalım.

    #include <stdio.h>
    int main(){
     int i,toplam;
     toplam=0;
     for(i=1;i<=10;i++){
      toplam+=i; // Her adımda "i" değeri toplam değişkenine ekleniyor.
     }
     printf("Toplam = %d",toplam);
     return 0;
    }
    Toplam = 55

    Kodlamayı açıklamak gerekirse, for döngüsüne girdiğimizde “i” değişkenine 1 değerini atıyoruz ve her adımda “i++” operatörü ile birer birer artmasını sağlayarak son değer olarak belirlediğimiz 10’a kadar gitmesini sağlıyoruz, “i” değeri 11 olduğu zaman “i<=10” koşulunu sağlamayacağı için döngüye devam etmeyecektir. Döngünün içerisinde ki işlemlerde ise her “i” değerini daha önce belirlediğimiz “toplam” isminde ki değişkenine ekliyor (burada toplam+=i; yerine toplam=toplam+i; de yazılabilirdi.) ve 10’a kadar olan sayıların toplamını hesaplamış oluyor.

    Şimdide 10’a kadar olan sayıların karelerini ekrana yazdıran programın koduna bir bakalım;

    #include <stdio.h>
    int main(){
     int i,kare;
     for(i=1;i<=10;i++){
      kare=i*i;
      printf("%d    ",kare);
     }
     return 0;
    }
    1    4     9     16     25     36     49     64     81    100

    Bu döngünün içerisinde de her “i” değerini kendi ile çarparak yani karesini alarak ekrana yazdırıyor, örneklerimizi bu şekilde çoğaltabiliriz…

    C programlama dilinde bu yazımızda anlatacağımız üç farklı döngü yapısı içerisinde en çok kullanılan yapı for döngüleridir. Özellikle de sonra ki konularda göreceğimiz diziler ve matrislerle beraber kullanımı oldukça yaygındır.

    While Döngüsü

    While döngüsü ise işleyişi ve anlaşılması çok kolay bir döngü yapısıdır. Belirlediğimiz bir koşul sağlandığı sürece belirlediğimiz işlemlerin gerçekleşmesini sağlayan döngüye while döngüsü denir. Kod işleme sırasında while döngüsüne gelen programımız öncelikle döngünün şartının sağlanıp sağlanmadığını kontrol eder, daha sonra da eğer şart sağlanıyor ise döngüye girip içeride ki işlemleri yapıp döngüden çıkar, daha sonra tekrar şartı kontrol eder ve şart hala sağlanıyorsa tekrar döngüye girer, bu işlem döngüsü while döngüsünün şartı sağlanmayana kadar devam eder. While döngüsünün şartı sağlanmadığı zaman döngü tamamen terk edilir ve sonra ki kod yapılarının çalıştırılmasına geçilir. While döngülerinin temel yapısı aşağıda ki gibidir;

    while(koşul){
        işlemler;
    }

    koşul kısmında daha önce öğrendiğimiz operatörlerden yararlanacağız, bu koşul bölümünde tek bir şartı kontrol edebileceğimiz gibi birden fazla şartı da kontrol etmemiz mümkündür, bu gibi durumlarda bu şartlar “ve” ile “veya” kontrolleri ile birbirlerine bağlanırlar. Şimdi while döngüsünün kullanımını örneklerle daha iyi bir şekilde anlayalım.

    Girilen bir sayıya kadar olan sayıların karelerinin toplamını ekrana yazdıran programı yazalım.

    #include <stdio.h>
    int main(){
     int i,sayi,toplam;
     printf("Sayi Giriniz: ");
     scanf("%d",&sayi);
     i=0;
     toplam=0;
     while (i<sayi){
      toplam+=i*i;
      i++;
     }
     printf("Toplam: %d",toplam);
     return 0;
    }

    Bu kod içerisinde sırayla şu işlemleri yapıyoruz.

    • Öncelikle kullanıcıdan “sayi” değişkeni için bir sayı değeri alıyoruz.
    • Daha sonra da önceden tanımlayacağımız “i” ve “toplam” değişkenlerine 0 değerini atıyoruz, bunu yapmamızın nedeni bu değişkenlerin tanımlandığı zaman memory üzerinde ki rastgele değerlerden birine sahip olma ihtimalleridir. Örneğin toplam değişkenini tanımladığımızda bilgisayar bu değişkeni memory üzerinde bir yere atayacak ve belki de ilk değeri 12412532523 gibi bir sayı olabilecektir, bu yüzden değişkenlerimizin değerlerini sıfırlıyoruz.
    • “i” değişkenini zaten sıfırladığımız için “i” değişkenin değeri kullanıcının gireceği “sayi” değişkeninin değerinden küçük olacaktır, yani koşul sağlanacaktır, bu sayede programımız döngüye girecek.
    • Döngüye girdikten sonra “i” değişkenin değerini kendisi ile çarpacak ve “toplam” değişkeninin değerinin üstüne ekleyecek, daha sonra da döngünün ilerlemesi için “i” değişkeninin değerini bir arttırıyoruz. Bunu yapmamızda ki amaç döngünün sonsuzluğa kapılmamasıdır, eğer döngü içerisinde “i” değişkeninin değerini değiştirmezsek şart sürekli sağlanacağı için döngü asla sona ermeyecektir ve program hata verecektir.
    • Belirli bir işlem sayısı sonrasında “i” değişkenin değeri “sayi” değişkeninin değerini geçeceği için, tekrar döngüye girilmeyecektir ve döngüden sonra ki işlemlere devam edilerek toplam değeri ekrana yazdırılacaktır.

    Do While Döngüsü

    Do While döngüsü ise while döngüsüne alternatif bir döngü yapısıdır. Aralarında ki fark ise programımız while döngüsüne girmeden önce döngünün koşulunun sağlanıp sağlanmadığını kontrol eder, eğer şart sağlanırsa döngüye girerdi. Do While döngü yapısında ise program direk olarak döngüye girer, döngü içerisinde ki işlemleri gerçekleştirir ve en son döngüden çıkarken şartın sağlanıp sağlanmadığını kontrol eder. Bu durumda do while döngü yapılarının şartlar sağlansa da sağlanmasa da en az bir kez döngünün içerisine girecektir, ancak while döngüsünde şartlar sağlanmıyorsa döngüye hiç girilmezdi.
    Genellikle kodlamalarda while döngüleri, do while döngülerine oranla daha çok tercih edilirler ancak bazı durumlar da şartlar ne olursa olsun en az bir defa döngüye girilmesini istiyorsak o zaman do while döngü yapısını tercih edebiliriz. Do While döngülerinin temel yapısı aşağıda ki gibidir;

    do{
        işlemler;
    } while(koşul);

    Şimdi yukarı da yaptığımız örneğin do while döngüsü ile yapılmış haline bir göz atalım.

    #include <stdio.h>
    int main(){
     int i,sayi,toplam;
     printf("Sayi Giriniz: ");
     scanf("%d",&sayi);
     i=0;
     toplam=0;
     do {
      toplam+=i*i;
      i++;
     }while(i<sayi);
     printf("Toplam: %d",toplam);
     return 0;
    }

    Döngülerin temel kullanımları bu şekildedir, ancak döngüler programlama dillerinin temelini oluşturduğu için konunun iyice kavranması oldukça önemlidir. Özellikle ileride göreceğimiz diziler ve matrisler konuları ile daha karmaşık ve iç içe döngüler kullanmaya başlayacağız, önümüzde ki derste iç içe döngülerin kullanımlarından bahsedeceğiz. Eğer bu konu hakkında sorunlar yaşıyorsanız yorum bölümünden sorularınızı sorabilir veya örnek sorular bölümünden diğer örnekleri inceleyebilirsiniz.

  • C Programlama Dili Switch Case Yapısı

    C Programlama Dili Switch Case Yapısı

    Switch Case yapıları daha önce ki dersimizde anlattığımız if-else yapılarının bazı durumlarda öylesine karmaşık hale geldiklerinde, if-else yapılarını daha temiz ve verimli şekilde ifade etmemizi yarayan yapılardır. Özellikle de programa ait bir menü yapmamız gereken durumlarda da Switch Case yapısı oldukça verimlidir.

    Switch Case yapısının temeli şu şekildedir; öncelikle bir tane değişken belirlenir, daha sonra da bu değişkenin değerine göre sonsuz sayıda farklı koşul gerçekleştirilebilir. Temel olarak Switch Case yapısı aşağıda ki gibidir;

    switch (degisken){
     case durum1:
      işlemler
      break;
     case durum2:
      işlemler
      break;
     .
     .
     .
     case durumN;
      işlemler
      break;
     default:
      işlemler
    }

    Bu kodun yapısını biraz detaylandırmak gerekirse, öncelikle kullanıcıdan “degisken” adında ki bir değişkene değer ataması istenilir, daha sonra da bu değişkenin değerinin caseler içerisinde ki “durum1”, “durum2”, …, “durumN” değerlerine eşit olup olmadığı kontrol edilir. Eğer değişkenin değeri bu caselerden birisine eşitse o zaman bu case altında ki işlemler yapılır. İşlemlerden sonra da break; komutu kullanılarak, programın Switch Case yapısından çıkması sağlanır. Eğer değişken değeri hiçbir case ile uyuşmuyor ise o zaman da default: değeri altında istenilen uyarılar yapılabilir.

    Konuyu daha iyi anlayabilmeniz için Switch Case yapısını kullanarak bir basit bir hesap makinesi yapmaya çalışalım.

    /**
     Switch Case İle Basit Hesap Makinesi Örneği
     www.temelprogramlama.com
    **/
    #include <stdio.h>
    int main(){
     int x,y,tercih;
     printf("___ MENU ___\n");
     printf("[1] Toplama\n");
     printf("[2] Cikarma\n");
     printf("[3] Carpma\n");
     printf("[4] Bolme\n");
     printf("Tercih Ettiginiz Islem Numarasi: ");
     scanf("%d",&tercih);
     switch (tercih){
      case 1:
       printf("Islem Yapilacak Sayilari Giriniz: ");
       scanf("%d %d",&x,&y);
       printf("Sonuc: %d",x+y);
       break;
      case 2:
       printf("Islem Yapilacak Sayilari Giriniz: ");
       scanf("%d %d",&x,&y);
       printf("Sonuc: %d",x-y);
       break;
      case 3:
       printf("Islem Yapilacak Sayilari Giriniz: ");
       scanf("%d %d",&x,&y);
       printf("Sonuc: %d",x*y);
       break;
      case 4:
       printf("Islem Yapilacak Sayilari Giriniz: ");
       scanf("%d %d",&x,&y);
       printf("Sonuc: %d",x/y);
       break;
      default:
       printf("Gecerli Bir Numara Girmediniz!");
     }
            return 0;
    }

    Kodu analiz edecek olursak sırasıyla aşağıda ki olaylar gerçekleşir;

    • Öncelikle kullanıcıdan karşısına çıkan menüde ki 1, 2, 3, 4 işlem numaralarından birini girmesi istenilir.
    • Daha sonra “tercih” değişkenine kayıt edilen bu değerin, herhangi bir case değeri ile aynı olup olmadığı kontrol edilir.
    • Eğer “tercih” değişkenin değeri herhangi bir case değeri ile aynıysa o case değerinin içerisinde ki işlemler yapılır.
    • Eğer “tercih” değişkenin değeri herhangi bir case değeri ile aynı değilse default içerisinde ki işlemler gerçekleştirilir.

    Şimdi de eğer bu örneği uzun yoldan yani if-else kullanarak yapmak isteseydik nasıl yapardık ona bakalım;

    /**
     If-Else Yapısı İle Basit Hesap Makinesi Örneği
     www.temelprogramlama.com
    **/
    #include <stdio.h>
    int main(){
     int x,y,tercih;
     printf("___ MENU ___\n");
     printf("[1] Toplama\n");
     printf("[2] Cikarma\n");
     printf("[3] Carpma\n");
     printf("[4] Bolme\n");
     printf("Tercih Ettiginiz Islem Numarasi: ");
     scanf("%d",&tercih);
     if (tercih==1){
      printf("Islem Yapilacak Sayilari Giriniz: ");
      scanf("%d %d",&x,&y);
      printf("Sonuc: %d",x+y);
     } else if (tercih==2){
      printf("Islem Yapilacak Sayilari Giriniz: ");
      scanf("%d %d",&x,&y);
      printf("Sonuc: %d",x-y);
     } else if (tercih==3){
      printf("Islem Yapilacak Sayilari Giriniz: ");
      scanf("%d %d",&x,&y);
      printf("Sonuc: %d",x*y);
     } else if (tercih==4){
      printf("Islem Yapilacak Sayilari Giriniz: ");
      scanf("%d %d",&x,&y);
      printf("Sonuc: %d",x/y);
     } else {
      printf("Gecerli Bir Numara Girmediniz!");
     }
     return 0;
    }

    Baktığınız zaman iki kodda aynı satır sayısında gibi gözükebilir ama Switch Case yapısının sağladığı verimlilik çok yüksektir, şöyle ki “tercih” değişkenin değerini girdikten sonra Switch Case yapısında o değere ait case altında ki işlemleri yapıyor veya o değere ait case yoksa default altında ki işlemleri yapıp, eğer işlem yapıldıysa kendinden sonra ki diğer caselerin içine girmeden yapıdan çıkıyordu ama if-else yapısı kullandığımız zaman işlemimizi yaptırsak bile tek tek tüm if kontrollerini kontrol etmesi gerekiyor ve bize oldukça büyük bir işlem yükü getiriyor. Switch Case kullanarak yapılacak kontrol sayılarını yani işlem yükün hafifleterek programımızın daha verimli çalışmasını sağlayabiliyoruz.

    Eğer konu hakkında daha fazla örnek incelemek isterseniz, sitemizde ki C programlama dili örnek çözümleri sayfasına göz atmanızı tavsiye ederiz, önümüzde ki derste döngüler konusuna giriş yapacağız.