19.08.19/18:42

aceminin C++ köşesi

Başlatan data_grrr, 27.02.07/12:04

« önceki - sonraki »

0 Üye ve 1 Ziyaretçi konuyu incelemekte.

data_grrr

Döngüler Dönelim Dönelim

Dallanma ifadeleri ile programın kodunun bir yerinden bir başka yerine akışını kontrol etmeyi sağladık ama bu komplex programlar yazabilmek için yeterli değildir.

Düşünün ki bilgisayar ekranının sürekli olarak güncellenmesi gerekiyor. Bütün ekranın güncellenmesi için milyonlarca pikselin ekrana çizilmesi gerekiyor. Aynı kodu tekrar tekrar çalıştıramayan bir program ancak güncelleme işini yapan kodun tekrar tekrar binlerce kez yazılarak ekranın güncellenmesini sağlayabilir. Bu ise gereksiz bir zahmettir.

İşte bir komutu birden çok kere çalıştırmak için döngü ifadelerine ihtiyaç duyarız.

Bir durum doğru iken döngü yapmak:

Döngü ifadelerinin en basit formu while döngüsüdür. Aşağıdaki gibidir:

Alıntıwhile(durum)
{
    // ...durum doğruyken tekrar tekrar çalışan kod
}


Durum önce test edilir. Bu durum if degisken > 5 ya da if deg1 == deg2 ya da aklınıza gelen herhangi birşey olabilir. Eğer durum doğruysa { } işaretleri arasındaki kodlar çalıştırılır. kapanma } işaretine geldiğinde kod C++ kontrolü en başa döndürür ve işlem yeniden baştan başlar. Sonuçta C++ {} işaretleri arasındaki kodu durum doğru olduğu müddetçe tekrar tekrar çalıştırır. Bir köpek sahibi köpeği pislemeden nasıl parkta tekrar tekrar dönüyorsa aynı şeydir bu da.

Peki en başta durum 'doğru' ise durumu gelecekte 'yanlış' yapacak şey nedir? Aşağıdaki örnek bunu açıklar:

Alıntı// While Örneği
#include <iostream>
using namespace std;

int main()
{
    // döngü sayısını gir
    int donguSayisi;
    cout << "Dongu sayisini girin: ";
    cin >> donguSayisi;
   
    // şimdi girilen döngü sayısı kadar döngü yap
    while (donguSayisi > 0)
    {
          donguSayisi = donguSayisi - 1;
          cout << "Sadece " << donguSayisi << " dongu kaldi\n";
    }
   
    //bir tuşa basana kadar bekle
    system("PAUSE");
    return 0;
}


While örneği kullanıcıdan bir döngü sayısı isteyerek başlar. Bunu donguSayisi isimli değişken içinde saklar. Program daha sonra while döngüsünü çalıştırır. while önce donguSayisi > 0 durumunu test eder. Eğer donguSayisi 0'dan büyükse program döngünün içine girer ( { } arasına). Burada donguSayisi değişkeninin değerini 1 eksiltir ve donguSayisinin yeni değerini ekrana yazar. Program daha sonra döngünün başına döner ve donguSayisi'nin hala 0'dan büyük olup olmadığını test eder. Değilse döngünün dışına çıkar ve program biter.

Eğer kullanıcı negatif bir değer girmiş olsaydı program döngüyü en baştan atlardı. Çünki en başta kontrol edildiğinde değişkenin 0'dan büyük olduğu doğru olmadığı için döngüden hemen çıkardı.

Program çalışınca aşağıdaki gibi görünür:

AlıntıDongu sayisini girin: 4
Sadece 4 dongu kaldi
Sadece 3 dongu kaldi
Sadece 2 dongu kaldi
Sadece 1 dongu kaldi
Sadece 0 dongu kaldi
Press any key to continue  .  .  .


while döngüsünün biraz değişik bir formu da 'do' ile yapılır.
do .  .  . while döngüsünde do'dan sonra döngünün içindeki kod en az bir kere çalıştırılır ve sondaki while ifadesindeki durum test edilir, doğruysa döngü ikince kez tekrar çalıştırılır, doğru olduğu müddetçe devam eder bu.

do
{
     // ...döngünün içi
} while (durum);

data_grrr

Döngülerde 1 Ekleme / 1 Eksiltme Özelliği

++ ve -- olan 1 ekleme ve 1 eksiltme operatörleri programlarda bir şeyi sayan döngülerde sık sık kullanılır. Bir önceki while örneğinde bunun örneğini gördük. Aşağıda programın bu 1 eksiltme işini yapan kısmı bulunuyor. donguSayisi = donguSayisi - 1; ifadesi donguSayisi diyelim 5 ise önce bundan 1 çıkarıp onu 4 yapıyor sonra bu 4 değerini tekrar donguSayisi değişkenine atıyor. Yeni donguSayisi değeri bu durumda 4 oluyor. Bu işlem donguSayisi 0 değerine varıncaya kadar devam ediyor.

Alıntı// şimdi girilen döngü sayısı kadar döngü yap
    while (donguSayisi > 0)
    {
          donguSayisi = donguSayisi - 1;
          cout << "Sadece " << donguSayisi << " dongu kaldi\n";
    }


Daha kısa olarak yazılan başka bir versiyonu ise şöyledir.

Alıntı// şimdi girilen döngü sayısı kadar döngü yap
    while (donguSayisi > 0)
    {
          donguSayisi--;
          cout << "Sadece " << donguSayisi << " dongu kaldi\n";
    }


-- operatörünün burada yaptığı şey donguSayisi = donguSayisi - 1 ile aynıdır. Tek fark 'otomatik olarak' önüne geldiği değişkenin değerini 1 düşürmesidir. Sonuçta yaptıkları şey aynıdır. -- aynı zamanda düşürüp, değişkenin değerini tanımladığı için kodumuz daha da kısa olabilir. while (durum) içerisine doğrudan yazılabilir --.

Alıntı
    while (donguSayisi-- > 0)
    {
          cout << "Sadece " << donguSayisi << " dongu kaldi\n";
    }


Bu durumda en kısa yazılmış hali kullanmak her zaman daha avantajlıdır. Hem kolay okunur hem de kolay yazılır.

donguSayisi-- ile --donguSayisi ikisi de değişkenini düşürür. Sondaki ama değişkenin değerini düşürülmeden önce programa döndürür.

Bu programda ne gibi bir fark yaratır peki? while programı örneğinde '1' değerini girdiğimizi düşünelim. Eğer --donguSayisi kullansaydık --donguSayisi'nin değeri 0 olacaktı. while (--donguSayisi > 0) olduğu için yani değişken zaten 0'dan büyük olmadığı için kontrol asla döngüye girmeyecekti. Program baştan biterdi yani. Ama donguSayisi-- yapsaydık 0'dan büyük olup olmadığı karşılaştırılan değer 1 olduğu için, yani değişkenin değeri henüz düşürülmediği için kontrol döngüye girecekti.

For döngüleri

while da kullanılmakla beraber en çok kullanılan döngüler for döngüleridir. for döngüsünün while'a göre daha çok kullanılma nedeni okunmasının daha kolay olmasıdır.

Aşağıdaki formattadır.

Alıntıfor ( değişken; durum; yükseltme)
{
   // ...döngünün içi
}


for döngüsü parantezinin üç kısmı bulunur, değişken kısmında sayma işleminde kullanılacak olan değişken açıklanır. Değişken kısmı sadece for döngüsü ile programda ilk karşılaşıldığında çalıştırılır.

Program durum kısmından devam eder. while'daki durum bölümüyle aynısıdır bu. Durum doğru olduğu müddetçe döngüye girilir ve geri dönülür.

Döngüye bir kez girilip geri dönüldükten sonra kontrol 3. kısım olan yükseltmeye gelir. Yükseltmede -- ve ++ operatörleri kullanılarak değişkenin değeri yükseltilir veya eksiltilir. Sonra tekrar 2. kısıma gelinir ve değişkenin yeni değeri ile durum kontrol edilir, doğru ise tekrar döngüye girilir.

3 kısım da opsiyoneldir. Eğer değişken veya yükseltme kısmı yoksa C++ görmezden gelir ve döngüye girer. Eğer durum kısmı yoksa döngü sonsuza dek devam eder.

for örneği:

Alıntı// For örneği - döngü sayısını belirle.
//                 o sayı kadar döngüde kal.
#include <iostream>
using namespace std;

int main()

{
    // döngü sayısını gir
    int donguSayisi;
    cout << "Dongu sayisini gir: ";
    cin >> donguSayisi;
   
    // döngü sayısı 0'a gelene kadar say
    for (; donguSayisi > 0;)
    {
        donguSayisi = donguSayisi - 1;
        cout << "Sadece" << donguSayisi << " dongu kaldi\n";
    }
   
    // bir tuşa basılana kadar bekle
    system("PAUSE");
    return 0;
}




data_grrr

Yukarıdaki for örneğini inceleyelim. Program klavyeden bir girdi alarak bunu donguSayisi değişkenine atar. Ardından gelen for, donguSayisi değişkeni değerini sıfır ile karşılaştırır. Eğer donguSayisi sıfırdan daha büyükse kontrol for döngüsüne geçer. Kontrol for döngüsüne geçip döngünün içine girildiğinde program donguSayisi'nın değerini bir düşürür ve sonucu ekrana yazar. Bu olduktan sonra tekrar for döngüsünün başına döner program ve donguSayisinin bir eksiltilmiş yeni değerini sıfır ile tekrar karşılaştırır. Sıfırdan büyük olduğu müddetçe for döngüsü tekrarlanır.

Yalnız yukarıdaki for döngüsünün iki problemi vardır. Birincisi yok edicidir. Çünki bizim orijinal donguSayisi değişkeninin değeri ile oynar, bu değişkenin orjinal değeri bize lazım olabilir. İkincisi sayma işlemi geriye doğru büyük sayılardan küçüklere gider. Bu minik problemler sadece for döngüsü için kullanılacak ikinci bir değişken(sayaç) tanımlanarak aşılabilir. Aşağıdaki gibi:

Alıntı// For örneği 2 - sayaç kullanılarak
#include <iostream>
using namespace std;

int main()
{
    // donguSayisi değerini gir
    int loopCount;
    cout << "Dongu sayisinin degerini girin:  ";
    cin >> donguSayisi;
   
    // Döngü sayısı limitine kadar say
    for (int i = 1; i <= donguSayisi; i++)
    {
        cout <<  i << " dongu bitti\n";
    }
    // bir tuşa basılmasını bekle
    system("PAUSE");
    return 0;
}


Yukarıdaki örnek bir önceki while ve for örneği ile tamamen aynı işi yapar. Tek fark bizim orjinal donguSayisi değeri ile oynanmayıp sayma işinin sayaç değişkenine, yani örnekte 'i' olarak tanımlanan değişkene bırakılmasıdır.

donguSayisi değişkenine klavyeden bir değer atandıktan sonra kontrol for döngüsüne geçer. Burada for parantezi içinde ilk sayaç değişkeni yani 'i' tanımlanır ve 1 değeri içine atılır. Sonra 'i'nin donguSayisi'ndan küçük-eşit olup olmadığı kontrol edilir. 'i' donguSayisi'ndan küçük olduğu müddetçe döngüye girilir sonra başa dönülür ve 'i'nin değeri bir artırılır. Sonra yeniden donguSayisi'ndan küçük-eşit olup olmadığına bakılır. 'i', donguSayisi'ndan büyük olunca, yani durum yanlış olunca kontrol döngüden çıkar ve system("PAUSE"); dan devam eder program.

'i' değişkeni for döngüsünün parantez içindeki değişken kısmında tanımlandığı için bu indeks(sayaç) değişkeni sadece for döngüsünün içinde bilinir. Yani örnekte for döngüsünden çıkıldığında 'i' değişkeni örneğin return ifadesi ile beraber kullanılamaz, çünki bu ifade for döngüsü içinde değildir ya da 'i' for döngüsü dışında tanımlanmamıştır.

Yani 'i' nin faaliyet alanı for döngüsüdür sadece.