Kontrol yapıları: seçim, döngüler ve guarded commands

Kontrol yapıları (control structures), programın hangi ifadeyi ne zaman çalıştıracağını belirler. Teoride bunun için çok az şey gerekir: Böhm ve Jacopini (1966), sıralama (sequence), seçim (selection) ve ön-testli döngü (pretest logical loop) ile her algoritmanın yazılabileceğini gösterdi; goto gerekmez. Dillerin bundan fazlasını sunmasının nedeni writability ve readability. Sınavda en çok switch/döngü çıktısı ve dil tasarım farkları sorulur.

Altın kurallar:

1. switch’te break yoksa alttaki case’lere düşülür.
2. C/Java for döngüsünde koşul her turdan önce yeniden hesaplanır.
3. while 0 kez, do-while en az 1 kez çalışır.
4. continue turu atlar ama güncelleme (i++) yine çalışır.
5. Guarded command’da birden çok guard true ise seçim nondeterministic.

Seçim (selection)

İki yönlü seçim

Tasarım soruları: koşul ifadesinin tipi ne olabilir? then/else kısmı tek ifade mi, blok mu? İç içe seçimin anlamı nasıl belirlenir?

• C89 ve C++ koşul olarak aritmetik ifade kabul eder (0 false). Java ve C# boolean ister.
• Dangling else: if (a) if (b) s1; else s2; else hangi if’e ait? Java, C, C++, C#: en yakın eşleşmemiş if. Perl her dalda süslü parantez zorunlu tutar; Python girintiyle, Ruby ve Ada end / end if ile belirler.

int y = 7;
if (y > 5)
    if (y > 10) System.out.println("big");
    else System.out.println("medium");

medium

Çok yönlü seçim: switch

int t = 0;
for (int k = 0; k < 5; k++) {
    switch (k % 3) {
        case 0: t += 1;          // break yok: case 1'e düşer
        case 1: t += 10; break;
        default: t += 100;
    }
}
System.out.println(t);

142

k   k%3   çalışanlar          t
0   0     +1, +10 (düştü)     11
1   1     +10                 21
2   2     default +100        121
3   0     +1, +10             132
4   1     +10                 142

Boş case’leri art arda yazmak (case 1: case 2:) her dilde serbesttir. Çok yönlü seçim her zaman iç içe else if ile de yazılabilir; Python’da elif, Python 3.10’dan beri match.

Counter-controlled döngüler

Döngü değişkeni (loop variable) bir başlangıç, bitiş ve adım değeriyle (loop parameters) kontrol edilir. Tasarım soruları:

1. Döngü değişkeninin tipi ve scope’u ne?
2. Gövdede döngü değişkeni veya parametreleri değiştirilebilir mi, tur sayısını etkiler mi?
3. Parametreler bir kez mi, her turda mı hesaplanır?
4. Döngü bittikten sonra değişkenin değeri tanımlı mı?

int n = 10, iters = 0;
for (int i = 0; i < n; i++) { n--; iters++; }
System.out.println(iters + " " + n);

5 5

C/Java for’unu while’a çevirme tarifi (operational semantics’teki gibi):

e1;
while (e2) {
    body;
    e3;
}

Fark: for’un başında bildirilen değişkenin scope’u döngüyle sınırlıdır; while versiyonunda dışarıda kalır. Ayrıca gövdedeki continue for’da e3’e gider, bu çeviride e3’ü atlar.

Logically-controlled döngüler

int a = 10, w = 0, d = 0;
while (a < 10) { w++; a++; }          // pretest
a = 10;
do { d++; a++; } while (a < 10);      // posttest
System.out.println(w + " " + d);

0 1

Pretest (while) gövdeyi hiç çalıştırmayabilir; posttest (do-while) en az bir kez çalıştırır. Java’da posttest döngünün tersi yoktur; Pascal repeat ... until koşul true olunca durur.

Kullanıcı kontrollü çıkış: break ve continue

int count = 0;
outer:
for (int i = 1; i <= 4; i++) {
    for (int j = 1; j <= 4; j++) {
        if (j == 3) continue outer;
        if (i == 3) break outer;
        count++;
    }
}
System.out.println(count);

4

• break: en içteki döngüden (ya da switch’ten) çıkar.
• continue: o turun geri kalanını atlar, döngü sürer.
• Etiketli (labeled) break/continue: Java, C#, Perl (last/next). C’de yok.
• switch içindeki continue switch’e değil en yakın döngüye uygulanır.

Etiketli break, goto’nun “kontrollü” halidir: sadece döngüden dışarı, bilinen bir noktaya atlar.

Iterator tabanlı döngüler

Bir veri yapısının elemanları üzerinde, yapının kendi sırasıyla gezinir: Java for (int v : arr), C# foreach, Python for x in seq, JavaScript for (const x of arr).

int[] arr = {1, 2, 3};
for (int v : arr) { v *= 2; }
System.out.println(arr[0] + arr[1] + arr[2]);

6

v her turda elemanın kopyası. Diziyi değiştirmek için indisli döngü gerekir.

goto

En güçlü ve en tehlikeli kontrol ifadesi. Kısıtsız goto okunabilirliği öldürür: kodu okuyan, kontrolün nereden geldiğini bilemez. Dijkstra 1968’de “Go To Statement Considered Harmful” yazdı. Java, Python ve Ruby’de goto yok. C# goto’ya izin verir, en meşru kullanımı switch içinde goto case. Yapısal programlama ilkesi: her yapının tek girişi ve (mümkünse) tek çıkışı olsun.

Guarded commands (Dijkstra, 1975)

Amaç: geliştirme sırasında doğrulamayı (verification) kolaylaştırmak. İki yapı var.

Seçim:

if <guard1> -> <stmt1>
[] <guard2> -> <stmt2>
...
fi

Tüm guard’lar hesaplanır. Birden fazlası true ise biri nondeterministic seçilir. Hiçbiri true değilse çalışma zamanı hatası.

if x >= y -> max := x
[] y >= x -> max := y
fi

x = y iken iki guard da true, hangisi seçilirse seçilsin sonuç aynı. Programcı “eşitlikte hangisini seçeyim?” kararını vermek zorunda değil.

Döngü:

do q1 > q2 -> swap(q1, q2)
[] q2 > q3 -> swap(q2, q3)
[] q3 > q4 -> swap(q3, q4)
od

Her turda true olan guard’lardan biri seçilir; hiçbiri true kalmayınca biter. Bitişte q1 ≤ q2 ≤ q3 ≤ q4 olduğu kesin. Başlangıç 4, 3, 2, 1 için olası tüm seçim yollarını tek tek denesen bile hepsi 1, 2, 3, 4’te biter. Ayrıca en büyük ortak bölen:

do x > y -> x := x - y
[] y > x -> y := y - x
od                      x = 18, y = 12 → 6

Sık yapılan hatalar

int t = 0;
for (int k = 0; k < 5; k++) {
    switch (k % 3) {
        case 0: t += 1;
        case 1: t += 10; break;
        default: t += 100;
    }
}
System.out.println(t);

int count = 0;
outer:
for (int i = 1; i <= 4; i++) {
    for (int j = 1; j <= 4; j++) {
        if (j == 3) continue outer;
        if (i == 3) break outer;
        count++;
    }
}
System.out.println(count);

int sum = 0;
for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) continue;
    sum += i;
}
System.out.println(sum);

int a = 10, w = 0, d = 0;
while (a < 10) { w++; a++; }
a = 10;
do { d++; a++; } while (a < 10);
System.out.println(w + " " + d);

int n = 10, iters = 0;
for (int i = 0; i < n; i++) { n--; iters++; }
System.out.println(iters + " " + n);

int[] arr = {1, 2, 3};
for (int v : arr) { v *= 2; }
System.out.println(arr[0] + arr[1] + arr[2]);

String s = "b";
switch (s) {
    case "a": System.out.print("A");
    case "b": System.out.print("B");
    case "c": System.out.print("C"); break;
    default: System.out.print("D");
}

int y = 7;
if (y > 5)
    if (y > 10) System.out.println("big");
    else System.out.println("medium");

if x >= y -> max := x
[] y >= x -> max := y
fi

do q1 > q2 -> swap(q1, q2)
[] q2 > q3 -> swap(q2, q3)
[] q3 > q4 -> swap(q3, q4)
od

int z = 100, steps = 0;
while (true) {
    z /= 3;
    steps++;
    if (z < 5) break;
}
System.out.println(steps + " " + z);