Veri tipleri II: record, union, pointer ve tip eşdeğerliği

Önceki sayfa tek tek değerleri tutan tiplerle ilgiliydi. Bu sayfa değerleri bir araya getiren tipler (record, union), başka değerleri gösteren tipler (pointer, reference) ve tiplerin birbiriyle uyumunu (type checking, type equivalence) kapsar. Sınavda en çok sorulanlar: dangling pointer ile memory leak farkı, free ve discriminated union, name ve structure equivalence.

Altın kurallar:

1. Dangling pointer: silinmiş hücreyi gösteren pointer. Leak: kimsenin göstermediği hücre.
2. Free union kontrol edilmez, discriminated union bir tag taşır.
3. Name equivalence = aynı ad, structure equivalence = aynı yapı.
4. Reference counting döngüleri toplayamaz.

Record

Record, heterojen elemanların (field) adlarıyla erişildiği topluluktur. Dizinin aksine elemanlar farklı tiplerde olabilir; erişim indisle değil adla olur: emp.name. COBOL ve C struct, Java’da sınıflar ve record.

record P(int x, int y) {}
P p = new P(1, 2), q = new P(1, 2);
System.out.println(p.equals(q) + " " + (p == q));
System.out.println(p);

true false
P[x=1, y=2]

Alan erişimi derleme zamanında sabit bir ofsete çevrilir, bu yüzden hızlıdır. Tuple record’a benzer ama alanların adı yoktur (Python (3, "a"), ML); erişim konumla olur.

Union

Union, bir değişkenin çalışma boyunca farklı zamanlarda farklı tiplerde değer tutabildiği tiptir. Tüm alanlar aynı belleği paylaşır.

• Free union (C, C++): hangi alanın geçerli olduğunu takip eden bir şey yok. Tip kontrolü yapılmaz.
• Discriminated union (Ada, ML, Haskell): bir tag (discriminant) alanı hangi tipin geçerli olduğunu söyler; yanlış alan okunursa hata.

union { int i; float f; } u;
u.i = 1;
printf("%g", u.f);   /* int'in bitleri float olarak okunur */

Aynı bitlerin float yorumu Java ile gösterilebilir:

System.out.println(Float.intBitsToFloat(1));
System.out.println(Float.intBitsToFloat(1065353216));
System.out.println(Float.floatToIntBits(1.0f));

1.4E-45
1.0
1065353216

1 tam sayısı float olarak 1.4E-45’tir; 1.0f’nin bitleri ise int olarak 1065353216’dır. Free union bu karışıklığı sessizce yapar. Java ve C# union’ı hiç almamıştır; reliability için kalıtım (inheritance) kullanılır.

Pointer ve reference

Pointer bir bellek adresi ya da özel değer nil (null) tutar. İki kullanımı var: dolaylı adresleme ve heap’te dinamik bellek yönetimi.

int a[5] = {10, 20, 30, 40, 50};
int *p = a;     /* p = &a[0] */
p += 2;         /* p = &a[2] */
/* *p + 1 = 31,  *(p + 1) = 40,  p - a = 2 */

Reference tipi (C++ int&, Java ve C# sınıf değişkenleri) bir nesneyi gösterir ama aritmetik yapılmaz. Java’da reference’lar hiçbir zaman serbest bırakılmış belleği göstermez, çünkü serbest bırakma garbage collector’ın işidir. Bu yüzden Java’da dangling reference yoktur.

Pointer problemleri

Dangling pointer

Serbest bırakılmış (deallocate edilmiş) bir heap hücresinin adresini hâlâ tutan pointer.

int *p = new int(5);
int *q = p;
delete p;      // p ve q artık serbest bırakılmış hücreyi gösteriyor

p’yi nullptr yapabilirsin, ama q’yu unutursun. O hücre daha sonra başka bir değişkene verilirse, q üzerinden yazmak başka bir verinin üzerine yazar.

Lost heap-dynamic variable (memory leak)

Ayrılmış ama artık hiçbir pointer’ın erişemediği heap hücresi. Bunlara garbage denir.

int *p = new int;   // hücre 1
p = new int;        // hücre 2; hücre 1 KAYBOLDU
int *q = p;         // q hücre 2'yi gösteriyor
p = new int;        // hücre 3; hücre 2 q sayesinde kurtuldu

Kayıp hücre sayısı 1. Sınavda her new’ü numaralandır, sonda her hücreyi hangi pointer’ın gösterdiğini yaz. Kimse göstermiyorsa leak, gösteren var ama hücre silinmişse dangling.

Dangling pointer çözümleri

• Tombstone: her heap nesnesi için ek bir hücre; pointer’lar bu hücreyi gösterir. Nesne silinince tombstone nil olur. Bedel: zaman ve bellek.
• Locks-and-keys: pointer bir (key, adres) çifti; heap hücresi bir lock taşır. Erişimde key == lock kontrol edilir; silinen hücrenin lock’u değişir.
• En iyisi: programcıya silme yetkisi vermemek (Java, C#, LISP: garbage collection).

Heap yönetimi: garbage collection

A.next = B;  B.next = A;  root = A;  root = null;
reference count: A = 1 (B'den), B = 1 (A'dan)  → hiçbiri 0 değil, toplanmaz
mark-sweep: kökten A'ya yol yok → ikisi de işaretsiz → toplanır

Type checking ve strong typing

Type checking, bir operatörün operandlarının uyumlu tiplerde olduğunun kontrolüdür. Uyumlu tip: ya doğrudan geçerli ya da dilin kurallarına göre otomatik dönüştürülebilir (coercion). Uygunsuz tipte operand kullanmak type error’dür.

Tip bağlamaları statikse kontrol neredeyse tamamen derleme zamanında yapılabilir; dinamik tip bağlamada (JavaScript, Python) kontrol çalışma zamanında yapılmak zorundadır. Hatayı ne kadar erken yakalarsan düzeltmesi o kadar ucuz.

Strongly typed dil: tip hataları her zaman yakalanır. ML ve F# strongly typed. Java ve C# neredeyse (açık cast hata üretebilir ama çalışmada yakalanır). C ve C++ değil: free union’lar ve pointer dönüşümleri kontrol dışı. Fazla coercion strong typing’in faydasını azaltır.

Type equivalence

İki tip ne zaman “aynı” sayılır?

type Celsius = float;
type Fahrenheit = float;
c: Celsius;  f: Fahrenheit;
f := c;       name equivalence: HATA     structure equivalence: geçerli

TUZAK · Ada anonim tipleri. A, B : array (1..10) of Integer; satırında A ve B eşdeğer değil: anonim tip ifadesi her değişken için ayrı bir tip üretir. Eşdeğer olmaları için tipe önce bir ad verilmeli.

Sık yapılan hatalar

class Point { int x, y; Point(int x, int y) { this.x = x; this.y = y; } }
Point a = new Point(1, 2);
Point b = a;
b.x = 5;
System.out.println(a.x);

record P(int x, int y) {}
P p = new P(1, 2), q = new P(1, 2);
System.out.println(p.equals(q) + " " + (p == q));

int *p = new int(5);
int *q = p;
delete p;

int *p = new int;
p = new int;
int *q = p;
p = new int;

type Celsius = float;
type Fahrenheit = float;

A.next = B;  B.next = A;
root = A;
root = null;