İsimler, binding, lifetime ve scope (static vs dynamic)

Bu bölümün iki yüzü var. Kısa cevaplı kısım: binding time tablosu ve storage kategorileri, ezberle biter. Uzun kısım: static ve dynamic scope altında program çıktısı. Bu soru vizede neredeyse kesin çıkar ve tablo kurarak çözülür.

Altın kurallar:

1. Static scope = sayfaya bak. Değişken yerel değilse fonksiyonun yazıldığı yeri çevreleyen birimde aranır.
2. Dynamic scope = davete bak. Değişken yerel değilse çağıran fonksiyonda, sonra onu çağıranda aranır.
3. Nonlocal bir değişkene atama yapılıyorsa, bulduğun değişken değişir. Çağırana döndüğünde yeni değeri görürsün.
4. Scope ≠ lifetime. Görünürlük metinle, ömür çalışmayla ilgili.

Değişkenin altı niteliği

İki isim aynı adrese erişiyorsa bunlar alias’tır. Pointer’lar, reference’lar ve C’deki union’lar alias yaratır. Okuyan kişi bir değişkenin değerinin başka bir isimle değiştirildiğini fark etmeyebilir: reliability düşer.

Binding ve binding time

Binding, bir varlık ile bir nitelik arasındaki ilişki: değişken ile tipi, isim ile adresi, sembol ile işlemi. Binding time bu ilişkinin kurulduğu an.

Static binding çalışmadan önce olur ve çalışma boyunca değişmez. Dynamic binding çalışma sırasında olur ya da değişebilir.

Type binding

• Explicit declaration: int count;
• Implicit declaration: isim kuralına göre. Fortran’da I-N ile başlayan isim integer, diğerleri real. Perl’de $ ile başlayan skaler, @ dizi.
• Type inference: tip bağlamdan çıkarılır. C#‘ta var sum = 0;, ML ve Haskell’de neredeyse her şey.
• Dynamic type binding: tip atama anında bağlanır (Python, JavaScript, Ruby, PHP).

let t = 5;
t = "five";
console.log(typeof t);

string

Dynamic type binding esneklik verir (aynı kod farklı tiplerle çalışır) ama derleyici tip hatalarını yakalayamaz ve çalışma zamanında tip kontrolü yapmak pahalıdır; bu dillerin çoğu yorumlanır.

Lifetime ve storage kategorileri

Hücreyi almaya allocation, geri vermeye deallocation denir. Lifetime, ikisi arasındaki süre.

TUZAK · pointer ile gösterdiği farklı kategoride. int *p = malloc(sizeof(int)); satırında p’nin kendisi stack-dynamic (yerel değişken), gösterdiği hücre explicit heap-dynamic.

Scope ve lifetime aynı şey değil

void count() {
    static int calls = 0;
    calls++;
    printf("%d ", calls);
}
/* count(); count(); count(); */

1 2 3

calls’un scope’u sadece count’un gövdesi, ama lifetime’ı tüm program: değer çağrılar arasında korunuyor. Tersi de olur: f, g’yi çağırdığında f’nin yerel değişkenleri hâlâ yaşıyor ama (static scope’ta) g’nin içinden görünmüyor.

Scope

Bir değişken bir ifadede kullanılıyor ve o birimde bildirilmemişse nonlocal’dir. Nerede aranacağını scope kuralı belirler.

Static (lexical) scope

Program metnine bakılır. Önce yerel bildirimler, sonra fonksiyonun yazıldığı yeri çevreleyen birim (static parent), sonra onun ebeveyni (static ancestors). Derleme zamanında belirlenir. C, Java, Python, JavaScript, Ada.

İçteki bildirim dıştaki aynı isimli değişkeni gizler (hides). Bloklar { ... } kendi scope’unu açar:

{ var v = 1; { var v = 2; } console.log(v); }
{ let w = 1; { let w = 2; } console.log(w); }

2
1

JavaScript’te var blok scope’u tanımaz, let tanır. Java ve C#‘ta iç blok, aynı metottaki yerel değişkenin adını tekrar bildiremez (derleme hatası: variable x is already defined); C ve C++‘ta bildirebilir ve dıştakini gizler.

Dynamic scope

Çağrı zincirine bakılır. Önce yerel, sonra beni çağıran fonksiyon, sonra onu çağıran… Çalışma zamanında belirlenir. Erken LISP, APL, SNOBOL4 ve Perl’in local bildirimi.

Eleştirisi: bir fonksiyonun yerel değişkenleri çağırdığı her fonksiyona açıktır (reliability düşer), nonlocal referansın ne olduğu çağrı yoluna bağlıdır (readability düşer), statik tip kontrolü yapılamaz, erişim yavaştır. Tek avantajı: çağıranın değişkenleri parametre geçmeden kullanılabilir.

Çözümlü örnek: izleme tablosu

int n = 1;
void a() { n = n * 10; print(n); }
void b() { int n = 2; a(); }
void c() { int n = 3; b(); a(); print(n); }
main() { c(); print(n); }

a’daki n nonlocal. İki kuralı ayrı ayrı izle:

STATIC: a'nın static parent'ı global → a'daki n hep global n
olay          global n   c.n   b.n   çıktı
c → b → a     1 → 10     3     2     10
c → a         10 → 100   3           100
c: print(n)              3           3
main          100                    100

DYNAMIC: a'da n yok → çağırana bak
olay          aranan n bulunduğu yer   yeni değer   çıktı
c → b → a     b.n (2)                  20           20
c → a         c.n (3)                  30           30
c: print(n)   c'nin kendi n'i          30           30
main          global n (dokunulmadı)   1            1

Static: 10 100 3 100. Dynamic: 20 30 30 1. Bu iki çıktı Perl’de my yerine local kullanarak birebir üretilebilir.

TUZAK · dynamic’te tanım yerine bakmak. Dynamic scope’ta fonksiyonun nerede yazıldığı önemsiz; sadece “beni şu an kim çağırdı?” sorulur. Ve en yakın çağıran kazanır: zincir main → c → b → a ise b’nin n’i c’ninkinden önce bulunur.

Referencing environment

Bir ifadenin referencing environment’ı orada görünen tüm isimlerdir. Static scope’ta: yereller + gizlenmemiş static ata değişkenleri. Dynamic scope’ta: yereller + aktif tüm çağıranların gizlenmemiş değişkenleri.

function main() { var a, b, c;
  function sub1() { var b, d;
    function sub2() { var c, e; /* point 2 */ } }
  function sub3() { var a, d; /* point 3 */ } }

point 2: c, e (sub2) · b, d (sub1) · a (main)
point 3: a, d (sub3) · b, c (main)      sub1'in değişkenleri YOK

Sık yapılan hatalar

int x = 5;
void f() { print(x); }
void g() { int x = 7; f(); }
main() { g(); f(); }

int n = 1;
void a() { n = n * 10; print(n); }
void b() { int n = 2; a(); }
void c() { int n = 3; b(); a(); print(n); }
main() { c(); print(n); }

function main() {
  var a = 1, b = 10;
  function p() { a = a + b; print(a, b); }
  function q() { var b = 20; p(); r(); }
  function r() { var a = 100; p(); print(a); }
  q();
  print(a, b);
}

function main() {
  var a, b, c;
  function sub1() {
    var b, d;
    function sub2() {
      var c, e;
      /* point 2 */
    }
  }
  function sub3() {
    var a, d;
    /* point 3 */
  }
}

void count() {
    static int calls = 0;
    calls++;
    printf("%d ", calls);
}

public static void main(String[] args) {
    int x = 1;
    { int x = 2; System.out.println(x); }
}

{ var v = 1; { var v = 2; } console.log(v); }
{ let w = 1; { let w = 2; } console.log(w); }

let t = 5;
t = "five";
console.log(typeof t);