Alt programlar I: parametre geçirme yöntemleri

Bu hafta parametre geçirme yöntemleri: sınavın en “mekanik” ve en çok puan getiren konularından biri. Soru şablonu hep aynı: küçük bir prosedür, bir çağrı, “her yöntemde değişkenler ne olur?” Tarif: her yöntem için formal parametrenin ne aldığını (değer mi, adres mi, ifade mi) ve ne zaman geri yazdığını yaz, sonra satır satır izle.

Altın kurallar:

1. Value: kopya. Reference: adres. Biri dışarıyı değiştirmez, diğeri anında değiştirir.
2. Value-result dışarıyı sadece dönüşte değiştirir, ve sonuç kopya sırasına bağlı olabilir.
3. Name: her kullanımda ifadeyi yeniden hesapla. İndis değişkeni değişirse başka elemana gidersin.
4. Aynı değişken iki parametreye ya da parametre + global olarak geçerse alias var. En çok soru buradan çıkar.
5. Java’da her şey pass-by-value, referanslar dahil.

Temel kavramlar

Alt program (subprogram) tanımı bir header (ad, parametreler) ve gövdeden oluşur. Tanımdaki parametreler formal parameter, çağrıdaki ifadeler actual parameter.

• Positional: actual’lar sırayla eşleşir. Kısa, ama uzun listelerde hata yaptırır.
• Keyword: area(width = 3, height = 5) (Python, Ada). Sıra serbest, ama formal adları bilinmeli.
• Default: actual verilmezse kullanılan değer.

function f(a, b = a * 2) { return a + b; }
console.log(f(3), f(3, 1));

9 4

Alt programlar ikiye ayrılır: değer döndüren function ve döndürmeyen procedure. Yerel değişkenler genelde stack-dynamic’tir (özyineleme mümkün); C’de static ile static yapılabilir (geçmişi hatırlar).

Anlamsal modeller: in, out, inout

Uygulama iki yolla yapılır: değeri fiziksel olarak kopyalamak (value, result, value-result) ya da bir erişim yolu (adres) aktarmak (reference).

Beş yöntem

Pass-by-value

Actual’ın değeri formal’ı başlatır, formal yerel bir değişken gibi davranır. Dışarıya hiçbir etki yok. Maliyet: büyük nesneler kopyalanır.

Pass-by-result

Giriş değeri aktarılmaz. Formal çağrılanda başlatılır, dönüşte değeri actual’a kopyalanır. Sorunlar: g(a, a) gibi çağrılarda hangi kopyanın kazanacağı (actual parameter collision) ve actual’ın adresinin çağrıda mı dönüşte mi hesaplanacağı.

void g(out int x, out int y) { x = 5; y = 7; }
g(a, a);          soldan sağa kopya: a = 5, sonra a = 7  → 7

Pass-by-value-result

Value + result: girişte kopya içeri, dönüşte kopya dışarı. Reference’a benzer ama alias etkileri dönüşe kadar görünmez.

Pass-by-reference

Actual’ın adresi aktarılır, formal onun takma adı (alias) olur. Kopya yok, hızlı. Ama alias’lar okunabilirliği ve güvenilirliği düşürür; her erişimde bir dolaylı adresleme (indirection) gerekir.

Pass-by-name

Formal’ın her kullanımı, actual’ın metniyle değiştirilmiş gibi davranır ve o anda çağıranın ortamında hesaplanır. ALGOL 60’ta var, bugün pek kullanılmaz. Uygulaması: her parametre için bir thunk (çağrıldığında adres ya da değer hesaplayan küçük fonksiyon). Basit bir değişken geçince reference ile aynı davranır; fark dizi elemanı ya da ifade geçince çıkar.

Çözümlü örnek 1: aynı değişken iki kez

void f(int x, int y) { x = x + 1; y = y * x; }
a = 2;  f(a, a);

Çözümlü örnek 2: global ile alias

int g = 3;
void fun(int x) { x = x * 2; g = g + 1; }
fun(g);

value:         x = 3 → 6 (yerel)       g = 3 + 1          → 4
reference:     x ≡ g: g = 6            g = 6 + 1          → 7
value-result:  x = 3 → 6 (yerel)       g = 4; dönüşte g = x → 6
name:          x ≡ g (basit değişken)                     → 7

Çözümlü örnek 3: dizi elemanı ve değişen indis

int i = 0;  int A[3] = {1, 2, 3};
void h(int x) { i = i + 1; x = x + 10; }
h(A[i]);

value:      dizi değişmez                         {1, 2, 3}
reference:  adres çağrıda: x ≡ A[0]               {11, 2, 3}
            i değişmesi önemsiz
name:       x her kullanımda A[i]; i artık 1      {1, 12, 3}
            x = x + 10  →  A[1] = A[1] + 10

Value-result’ta da {11, 2, 3} çıkar, çünkü dönüş adresi çağrı anında hesaplanır. Bazı tanımlarda adres dönüşte hesaplanır; o zaman {1, 11, 3} olur. Sınavda soruda belirtilmemişse çağrı anını varsay ve yaz.

Çözümlü örnek 4: klasik swap(i, A[i])

void swap(int x, int y) { int t = x; x = y; y = t; }
i = 1;  A = {5, 0, 7};
swap(i, A[i]);

reference (adresler çağrıda: x ≡ i, y ≡ A[1]):
  t = i = 1;  i = A[1] = 0;  A[1] = t = 1      → i = 0, A = {5, 1, 7}   doğru takas

name (her kullanımda yeniden hesapla):
  t = i            → 1
  i = A[i]         → i = A[1] = 0
  A[i] = t         → A[0] = 1      ← i artık 0
                                    → i = 0, A = {1, 0, 7}   takas BOZUK

Pass-by-name ile doğru çalışan genel bir swap yazılamaz. Bu yöntemin terk edilme nedenlerinden biri.

TUZAK · name ile reference aynı sanmak. Basit bir değişken (a) geçince ikisi aynı sonucu verir. Dizi elemanı geçerken indis gövdede değişiyorsa ayrılırlar: reference eski elemana, name yeni elemana yazar.

Dillerde durum

static void swap(int a, int b) { int t = a; a = b; b = t; }
static void change(int[] arr) { arr[0] = 99; arr = new int[]{7, 7}; arr[1] = 55; }
static void grow(StringBuilder sb) { sb.append("!"); sb = new StringBuilder("new"); sb.append("?"); }

int x = 1, y = 2; swap(x, y);
System.out.println(x + " " + y);
int[] a = {1, 2}; change(a);
System.out.println(a[0] + " " + a[1]);
StringBuilder s = new StringBuilder("hi"); grow(s);
System.out.println(s);

1 2
99 2
hi!

Kural: metot nesnenin içini değiştirebilir (çünkü aynı nesneyi gösteriyor), ama çağıranın değişkenini başka nesneye yöneltemez.

Closure ve diğer konular

Closure, bir alt program ile tanımlandığı referencing environment’ın birleşimidir. Fonksiyon bir değer olarak döndürülüp başka yerde çağrılabiliyorsa, yakaladığı değişkenlerin ömrü uzamalıdır (unlimited extent).

function makeCounter() { let c = 0; return () => ++c; }
const c1 = makeCounter(), c2 = makeCounter();
console.log(c1(), c1(), c2(), c1());
const fs = []; for (var i = 0; i < 3; i++) fs.push(() => i);
console.log(fs.map((g) => g()).join(","));
const gs = []; for (let j = 0; j < 3; j++) gs.push(() => j);
console.log(gs.map((g) => g()).join(","));

1 2 1 3
3,3,3
0,1,2

• Overloaded subprogram: aynı ad, farklı parametre profili (Java, C++). Hangisinin çağrılacağı derlemede belirlenir.
• Generic subprogram: farklı tiplerle çalışan tek tanım (Java generics, C++ template). Parametrik polimorfizm.
• Değişken sayıda parametre: Java int... xs, C printf.

Sık yapılan hatalar

void f(int x, int y) {
    x = x + 1;
    y = y * x;
}

void swap(int x, int y) {
    int t = x;
    x = y;
    y = t;
}

t = i          t = 1
i = A[i]       i = A[1] = 0
A[i] = t       A[0] = 1     (i artık 0!)

void h(int x) {
    i = i + 1;
    x = x + 10;
}

void fun(int x) {
    x = x * 2;
    g = g + 1;
}

static void swap(int a, int b) { int t = a; a = b; b = t; }
// in main:
int x = 1, y = 2;
swap(x, y);
System.out.println(x + " " + y);

static void change(int[] arr) {
    arr[0] = 99;
    arr = new int[]{7, 7};
    arr[1] = 55;
}
// in main:
int[] a = {1, 2};
change(a);
System.out.println(a[0] + " " + a[1]);

function makeCounter() { let c = 0; return () => ++c; }
const c1 = makeCounter(), c2 = makeCounter();
console.log(c1(), c1(), c2(), c1());

function f(a, b = a * 2) { return a + b; }
console.log(f(3), f(3, 1));

const fs = [];
for (var i = 0; i < 3; i++) fs.push(() => i);
console.log(fs.map(g => g()).join(","));