D Programlama Dili - for Döngüsü

`for` Döngüsü

while döngüsü ile aynı işe yarar. Yararı, döngü ile ilgili bütün tanımların tek satırda yapılmasıdır.

for döngüsü foreach döngüsünden çok daha az kullanılır. Buna rağmen, for döngüsünün nasıl işlediği de iyi bilinmelidir. foreach döngüsünü daha sonraki bir bölümde göreceğiz.

`while`'ın bölümleri

Hatırlarsak, while döngüsü tek bir koşul denetler ve o koşul doğru olduğu sürece döngüye devam eder. Örneğin 1'den 10'a kadar olan bütün tamsayıları yazdıran bir döngü "sayı 11'den küçük olduğu sürece" şeklinde kodlanabilir:

    while (sayı < 11)

O döngünün ilerletilmesi, sayı'nın döngü içinde bir arttırılması ile sağlanabilir:

        ++sayı;

Kodun derlenebilmesi için sayı'nın while'dan önce tanımlanmış olması gerekir:

    int sayı = 1;

Döngünün asıl işlemlerini de sayarsak, bütün bölümlerine değinmiş oluruz:

        writeln(sayı);

Bu dört işlemi döngünün hazırlığı, devam etme koşulunun denetimi, asıl işlemleri, ve ilerletilmesi olarak açıklayabiliriz:

    int sayı = 1;           // ← hazırlık

    while (sayı < 11) {     // ← devam koşulu
        writeln(sayı);      // ← asıl işlemler
        ++sayı;             // ← döngünün ilerletilmesi
    }

while döngüsü sırasında bu bölümler şu sırada işletilirler:

hazırlık

koşul denetimi
asıl işlemler
ilerletilmesi

koşul denetimi
asıl işlemler
ilerletilmesi

...

Hatırlayacağınız gibi, bir break deyimi veya atılmış olan bir hata da döngünün sonlanmasını sağlayabilir.

`for`'un bölümleri

for döngüsü bu dört işlemden üçünü tek bir tanıma indirgeyen deyimdir. Bu işlemlerin üçü de for deyiminin parantezi içinde, ve aralarında noktalı virgül olacak şekilde yazılırlar. Asıl işlemler ise kapsam içindedir:

for (/* hazırlık */; /* devam koşulu */; /* ilerletilmesi */) {
    /* asıl işlemler */
}

Yukarıdaki while döngüsü for ile yazıldığında çok daha düzenli bir hale gelir:

    for (int sayı = 1; sayı < 11; ++sayı) {
        writeln(sayı);
    }

Bu, özellikle döngü kapsamının kalabalık olduğu durumlarda çok yararlıdır: döngüyü ilerleten işlem, kapsam içindeki diğer ifadeler arasında kaybolmak yerine, for ile aynı satırda durur ve kolayca görülür.

for döngüsünün bölümleri de while'ın bölümleriyle aynı sırada işletilirler.

break ve continue deyimleri for döngüsünde de aynı şekilde çalışırlar.

while ve for döngüleri arasındaki tek fark, for'un hazırlık bölümünde tanımlanmış olan değişkenin isim alanıdır. Bunu aşağıda açıklıyorum.

Çok sık olarak döngüyü ilerletmek için bir tamsayı kullanılır, ama öyle olması gerekmez. Ayrıca, döngü değişkeni arttırılmak yerine başka bir biçimde de değiştirilebilir. Örneğin belirli bir değer aralığındaki kesirli sayıların sürekli olarak yarılarını gösteren bir döngü şöyle yazılabilir:

    for (double sayı = 1; sayı > 0.001; sayı /= 2) {
        writeln(sayı);
    }

Birden fazla döngü değişkeni gerektiğinde küme parantezleri içinde tanımlanırlar. Örneğin, aşağıdaki döngü, türleri farklı olan iki değişken tanımlamaktadır:

    for ({ int i = 0; double d = 0.5; } i < 10; ++i) {
        writeln("i: ", i, ", d: ", d);
        d /= 2;
    }

Hazırlık bölümü, işaretlenmiş olan küme parantezlerinin arasındaki bölgedir. Dikkat ederseniz, hazırlık bölümüyle koşulun arasında noktalı virgül bulunmaz.

Döngünün üç bölümü de boş bırakılabilir

Gereken durumlarda isteğe bağlı olarak, bu bölümler boş bırakılabilir:

Bazen hazırlık için bir değişken tanımlamak gerekmez çünkü zaten tanımlanmış olan bir değişken kullanılacaktır
Bazen döngüyü sonlandırmak için döngü koşulu yerine döngü içindeki break satırlarından yararlanılır
Bazen döngüyü ilerletme adımı belirli koşullara bağlı olarak döngü içinde yapılabilir

Bütün bölümler boş bırakıldığında, for döngüsü sonsuza kadar anlamına gelir:

    for ( ; ; ) {
        // ...
    }

Öyle bir döngü, örneğin ya hiç çıkılmayacak şekilde, veya belirli bir koşul gerçekleştiğinde break ile çıkılacak şekilde tasarlanmış olabilir.

Döngü değişkeninin geçerli olduğu kapsam

for ile while'ın tek farkı, döngü hazırlığı sırasında tanımlanan ismin geçerlilik alanıdır: for döngüsünün hazırlık bölgesinde tanımlanan isim, yalnızca döngü içindeki kapsamda geçerlidir (ve onun içindekilerde), dışarıdaki kapsamda değil:

    for (int i = 0; i < 5; ++i) {
        // ...
    }

    writeln(i);   // ← derleme HATASI
                  //   i burada geçerli değildir

while döngüsünde ise, isim while'ın da içinde bulunduğu kapsamda tanımlanmış olduğu için, while'dan çıkıldığında da geçerliliğini korur:

    int i = 0;

    while (i < 5) {
        // ...
        ++i;
    }

    writeln(i);   // ← 'i' burada hâlâ geçerlidir

for döngüsünün bu ismin geçerlilik alanını küçük tutuyor olması, bir önceki bölümün sonunda anlatılanlara benzer şekilde, programcılık hatası risklerini de azaltır.

Problemler

İç içe iki for döngüsü kullanarak, ekrana satır ve sütun numaralarını gösteren 9'a 9'luk bir tablo yazdırın:

0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 
1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 1,8 
2,0 2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8 
3,0 3,1 3,2 3,3 3,4 3,5 3,6 3,7 3,8 
4,0 4,1 4,2 4,3 4,4 4,5 4,6 4,7 4,8 
5,0 5,1 5,2 5,3 5,4 5,5 5,6 5,7 5,8 
6,0 6,1 6,2 6,3 6,4 6,5 6,6 6,7 6,8 
7,0 7,1 7,2 7,3 7,4 7,5 7,6 7,7 7,8 
8,0 8,1 8,2 8,3 8,4 8,5 8,6 8,7 8,8

Bir veya daha fazla for döngüsü kullanarak ve * karakterini gereken sayıda yazdırarak geometrik şekiller çizdirin:
```
*
**
***
****
*****
```
```
********
 ********
  ********
   ********
    ********
```
vs.

... çözümler

[ ↢ Geri ] [ İleri ↣ ]

for Döngüsü