Kısım I · Makine · Bölüm 10

C ile Belleğe Dokunmak

Dizi, adres, pointer (Arrays, addresses, pointers)

1. Kat 6–10Gömülü yazılım, işletim sistemi, ağ, web, uygulamaBu bölümdeki bellek fikirleri hepsinin altında çalışır.
2. Kat 5Programlama dilleri ve derleyiciC, belleği doğrudan gösteren en yalın dildir. Bölüm 9–11.
3. Kat 4Makine dili ve assemblyAdresler burada komutların işlenenleridir. Bölüm 7.
4. Kat 3İşlemci ve bellek (CPU, RAM)Numaralı hücreler: adresler buradadır. Bölüm 5, 6, 8.
5. Kat 0–2Elektrik, kapılar, devrelerBölüm 2–5.

Bu bölümün sonunda bir değişkenin belleğe nasıl yerleştiğini, bir pointer'ın aslında yalnızca bir adres (bir sayı) olduğunu, malloc ile ayrılan bellekten kimin sorumlu olduğunu ve bunu yanlış yapınca neden "segmentation fault" gibi hatalar çıktığını anlatabileceksin. Sonra bakışı yukarı çevireceğiz: JavaScript'te bir nesneyi kopyalayıp orijinalinin değiştiğini gördüğünde, bunun aynı adres fikrinin görünmeyen halinden doğduğunu fark edeceksin. Her örnek bu makinede (Linux, x86-64, gcc 15.2.0) gerçekten çalıştırılmıştır.

10.1 Dizi: yan yana hücreler, sıfırdan başlayan indeks

Bölüm 9'da int dogru = 7; yazdığında derleyici belleğin 4 byte'ını ayırıp ona dogru adını vermişti. Peki üç quiz puanını saklamak için üç ayrı değişken mi yazacaksın: puan1, puan2, puan3? Soru bankasında 500 soru olsa ne olurdu? Bu sorunun cevabı dizidir (array): aynı tipten birden çok değeri, bellekte art arda, yan yana yerleştirilmiş hücrelerde saklayan yapı. CS50'nin anlatımıyla int scores[3], derleyiciye "bana art arda üç adet int büyüklüğünde yer ver" demektir.¹

int skor[3] = {80, 90, 100};
printf("%i\n", skor[0]);      // 80: ilk hücre
printf("%i\n", skor[2]);      // 100: üçüncü hücre

Köşeli parantez içindeki sayı indekstir (index): kaçıncı hücreye bakılacağı. İndeks sıfırdan başlar: ilk hücre skor[0], son hücre skor[2]. Bunun nedeni keyfî bir adetten çok mesafedir. Dizinin kendisi, ilk hücrenin adresiyle tanımlanır; skor[2], "ilk hücreden iki hücre ileri" demektir ve ilk hücreye uzaklık sıfırdır. Bu makinede üç hücrenin adreslerini yazdırdım (adreslerin kendisi her çalıştırmada değişir; farklarına bak):

&skor[0] = 0x7fffb4a048c0
&skor[1] = 0x7fffb4a048c4
&skor[2] = 0x7fffb4a048c8

Her adres bir öncekinden tam 4 fazla; çünkü bir int 4 byte yer kaplar (Bölüm 9.3). Dizinin toplam boyutu da sizeof skor ile sorulduğunda 12 çıktı (3 × 4). Yani skor[i] bilgisayarın içinde şu hesaptır: dizinin başlangıç adresi + i × (bir hücrenin boyutu). İşlemci bu toplamayı tek bir adım olarak yapabilir (Bölüm 4'teki toplayıcı ve Bölüm 7'deki "yükle" komutu), bu yüzden dizideki herhangi bir hücreye gitmek her zaman aynı hızdadır; hücre sayısı 3 de olsa 3 milyon da olsa. "Rastgele erişim" (random access) adındaki RAM'in (Bölüm 5.4) özelliğiyle dizi böyle bir araya gelir.

Art arda durmanın bir faydası daha var: bir hücreyi okuduğunda işlemci komşularını da önbelleğe getirir; bu da Bölüm 8.2'de gördüğün yerellik fikrinin bir sonucudur. Dizi üzerinde döngü kurmak bu yüzden hızlı olur. Dizinin bedeli ise esnemezliğidir: bellekte yan yana yer ayrıldığı için, boyutu sonradan büyütmek zordur (11. bölümde bağlı listeyle bunun çözümüne bakacağız).

10.2 Karakter dizisi ve sonlandırıcı \0

Bölüm 2.5'te "HI!" yazısının 72, 73, 33 sayıları olduğunu görmüştün. C'de yazı (karakter dizisi (string)), char'lardan oluşan bir dizidir. CS50 bunu şöyle gösterir: bir string, ilk karakterle başlayan ve NUL denilen özel bir karakterle biten karakter dizisidir; NUL, \0 olarak yazılır ve değeri 0'dır (tek L'li NUL ile iki L'li NULL farklı şeylerdir).² Bunu doğruladım: char s[] = "HI!" için sizeof s 4, strlen(s) 3 çıktı ve dört byte'ın değerleri 72 73 33 0 idi.

Sonlandırıcı neden var? Dizi, belleğin düz bir bölgesidir; hücrelerden birine "burada yazı bitti" yazmazsan, yazıyı okuyan fonksiyon nerede duracağını bilemez. strlen (string uzunluğunu veren kütüphane fonksiyonu) bu yüzden \0'a kadar saymak zorundadır ve onu saymaz.² Yani strlen("HI!") 3'tür ama dizi 4 byte kaplar. İleride yer ayırırken "uzunluk + 1" yazılmasının nedeni budur.

Bu mimarinin ince bir sonucu, Bölüm 2.5'teki UTF-8 bilginle birleşince ortaya çıkar. strlen karakter değil byte sayar: strlen("sik") 3, strlen("şık") 5 verdi (ş ve ı ikişer byte). Türkçe metinlerde "kaç karakter" sorusu C'de bir kütüphane fonksiyonuyla cevaplanamaz; kodlamanın (Bölüm 2.5) bilinmesi gerekir.

CS50 bir tuzağa da dikkat çeker: iki yazıyı karşılaştırmak için == kullanamazsın, çünkü == yazıların içeriğini değil bellekteki adreslerini karşılaştırır. İçerik için strcmp kullanılır ve aynıysa 0 döner.¹ Bu tuzak, adres kavramını anladığında şaşırtıcı olmaktan çıkar. Şimdi ona geçelim.

10.3 Adres ve işaretçi: & ve *

Bölüm 5'ten beri biliyorsun: RAM'deki her hücrenin bir adresi var. Bölüm 2.4'te onaltılık sayıların neden kullanıldığını da gördün; adresler genellikle 0x önekiyle onaltılık yazılır, çünkü 0x10 adresiyle 10 değerini ayırmak gerekir.³ C'de iki işleç, adresle değer arasında gidip gelmeni sağlar:

• &n: "n'in adresi" (CS50'nin çevirisiyle "the address of n").³
• *p: "p'nin gösterdiği adresteki değer" (adresten değere gitmek, dereference).³

Bir adresi saklayan değişkene işaretçi (pointer) denir. CS50'nin tanımıyla pointer, bir şeyin adresini saklayan değişkendir; en yalın hâliyle, bellekteki bir adrestir.³ Küçük bir program:

int n = 50;
int *p = &n;                 // p, n'in adresini saklar
printf("n=%d *p=%d\n", n, *p);   // ikisi de 50
printf("%zu\n", sizeof p);       // 8

Satır satır: int *p, "p, bir int'in adresini tutan değişkendir" der (* burada tanımda geçiyor). &n, n'in adresini verir ve p'ye atanır. *p ise gidip o adresteki değeri okur: 50. Aynı yıldız işareti iki işe yarar: tanımda "pointer" demektir, ifadede "şu adrese git" demektir. Bu yüzden başlangıçta kafa karıştırır. sizeof p 8 çıktı: CS50'nin dediği gibi pointer genellikle 8 byte'lık bir değerdir.³ Sebep, bu tür makinelerde adresin kendisinin de 64 bit (8 byte) olmasıdır: 64 bitle 2⁶⁴ farklı adres yazılabilir (Bölüm 2.2'deki 2ⁿ fikri; Bölüm 6'daki x86-64 adı da buradan gelir).

Dizi adı ve pointer aritmetiği

Bir dizinin adı, çoğu bağlamda, ilk hücresinin adresi gibi davranır. CS50'nin anlatımıyla bir string aslında char *'dır, yani ilk karakterin adresidir; cs50.h yalnızca bu pointer'ı string adıyla saklayan bir yardımcıdır.³ Bu yüzden s'ye 1 eklemek ikinci karaktere götürür.³ Bir int pointer'ına 1 eklemek ise 1 byte değil bir int boyu ilerlemek demektir. Bu makinede: int a[3] = {10, 20, 30}; int *p = a; için *p, *(p + 1) ve a[2] 10, 20, 30 verdi ve p + 1 ile p arasındaki fark 4 byte çıktı. Dolayısıyla a[i] ile *(a + i) aynı işin iki yazılışıdır; 10.1'deki "başlangıç + i × boy" hesabının C'deki yazılışı budur.

Neden gerekli: kopya yerine adres vermek

Bölüm 9.4'te "argümanlar kopyalanır" demiştik. Şimdi sonucu görelim: iki değeri takas eden bir fonksiyon. İlk sürüm değer alır, ikinci sürüm adres alır.

void swap(int a, int b)        { int t = a; a = b; b = t; }
void swap2(int *a, int *b)     { int t = *a; *a = *b; *b = t; }

int x = 1, y = 2;
swap(x, y);        // çıktı: 1 2  (hiçbir şey değişmedi)
swap2(&x, &y);    // çıktı: 2 1  (değişti)

Bu makinede ilk çağrıdan sonra x y yine 1 2 yazdı, ikinciden sonra 2 1. Nedeni CS50'nin açıklamasıdır: değerle verildiğinde fonksiyon kopyalarla çalışır; adresle verildiğinde fonksiyon asıl değişkenin nerede durduğunu bilir ve orada değişiklik yapabilir.³ Esas numarası benzetmesine dönersek: swap'a fotokopi verdin, swap2'ye numara. Fotokopiyle oynanan dosya aslını etkilemez.

10.4 Yığın ve öbek: malloc, free, bellek sızıntısı

Bir programın belleği tek bir düz alan değildir; kabaca üç yere ayrılır. Bunu, main'in, bir global değişkenin, malloc ile ayrılan bir bloğun ve bir yerel değişkenin adreslerini yazdıran bir programla görmek mümkündür. Bu makinede şu çıktı geldi:

kod (main)    = 0x6261809531a9
global        = 0x626180956010
öbek (heap)   = 0x6261a1d3d010
yığın (stack) = 0x7ffe5248c02c

Dört adres dört farklı bölgeden: kod ile global değişken birbirine yakın, öbek biraz ötede, yığın çok daha yüksek bir adreste. (Adresler her çalıştırmada değişir; ben ./u programını iki kez çalıştırınca farklı adresler gördüm. Önemli olan bölgelerin ayrı olması.) İki bölgeye yakından bakalım.

Yığın (stack): fonksiyon çağrılarının defteri

Yığın (stack), bir kâğıt yığını gibi çalışır: son konan ilk alınır. Bottom-Up CS kitabının anlatımıyla her fonksiyon çağrısı yığında yeni bir çerçeve (stack frame) alır; çerçevede en az, fonksiyon bitince dönülecek adres, girdi argümanları ve yerel değişkenler için yer vardır.⁴ Fonksiyon bitince çerçeve atılır. İşte Bölüm 9'daki "her fonksiyon kendi kopyasıyla çalışır" cümlesinin fiziksel nedeni: her çerçeve ayrı bir bellek bölgesidir. CS50 de aynı şeyi çizer: main ve swap'ın ayrı çerçeveleri vardır, bu yüzden değerler bir çerçeveden ötekine doğrudan değiştirilemez.³

Yığın otomatik yönetilir; sen hiçbir şey yapmadan ayrılır ve geri verilir. Bedeli, ömrünün fonksiyon süresiyle sınırlı olmasıdır: fonksiyon bitince yerel değişkenlerin ortadan kalkar. Ayrıca yığın sınırlıdır; CS50, çok fazla fonksiyon çağrısının yığını taşırdığını söyler (stack overflow).³

Öbek (heap) ve malloc

Peki program çalışırken, ne kadar yer gerekeceğini ancak o zaman öğreniyorsan? Kullanıcının kaç soruluk bir sınav oluşturacağını bilmeden dizi tanımlayamazsın. Çözüm öbektir (heap): istek üzerine bellek ayrılan, ömrünü senin belirlediğin bölge. İki fonksiyon kullanılır: malloc verdiğin kadar byte'lık bir blok ayırır ve onun adresini döndürür; free o bloğu geri verir.³ CS50'nin örneği, bir yazıyı kopyalamaktır:

char *s = "HI!";
char *t = malloc(strlen(s) + 1);   // uzunluk + 1: \0 için de yer
if (t == NULL) return 1;           // malloc başarısız olduysa NULL döner
strcpy(t, s);                      // s'nin içeriğini t'ye kopyala
t[0] = 'h';
printf("%s %s\n", s, t);           // HI! hI!
free(t);                           // işin bitince geri ver

Çıktı HI! hI!: t gerçek bir kopya; t[0]'ı değiştirmek s'yi etkilemedi. CS50'nin ilk denemesi ise string t = s; yazmaktı ve bu yalnızca adresi kopyalar: iki pointer aynı yazıyı gösterir.³ Satırlar: strlen(s) + 1, yazının \0'ı da dahil boyudur (10.2). NULL kontrolü önemlidir: CS50'nin notu, malloc bir sorun olursa NULL döndürdüğünü ve bunun kontrol edilmesi gerektiğini söyler.³ free, "bu bloğu artık kullanmıyorum" demektir.

Bağlı liste: öbeğin ilk gerçek ürünü

Öbek ve pointer birleşince yeni bir veri düzeni mümkün olur: her hücrenin bir değeri ve bir sonraki hücrenin adresi olsun. Bu düzen Bölüm 11'in konusu olduğundan yalnızca şunu söylüyorum: pointer'lar, belleğin farklı yerlerinde duran parçaları birbirine iplikle bağlamaya yarar. Üç düğümlü bir bağlı listeyi (1 2 3) kurup dolaştım ve AddressSanitizer açıkken hiçbir hata çıkmadı; sizeof ile bir düğümün 16 byte olduğunu da gördüm (4 byte sayı, 4 byte dolgu, 8 byte pointer). Derinine Bölüm 11.5'te gireceğiz.

10.5 Bellek güvenliği: taşma, segmentation fault, çöp toplayıcı, sahiplik

Şimdi bu bölümün asıl sorusuna geliyoruz. C sana belleğin doğrudan anahtarını verir, ama o belleğin hangi kısmının senin olduğunu denetlemez. Bu yüzden iki tür hata ortaya çıkar. CS50 bunlara arabellek taşması (buffer overflow) der: ayrılan bloğun ötesine yazmak. Öbekte olursa heap overflow, yığında fazla çerçeve açıp yığın sınırını aşarsa stack overflow.³ Bunun somut bir örneği:

int *x = malloc(3 * sizeof(int));   // 3 int: x[0], x[1], x[2]
x[3] = 33;                          // dördüncüsü: bize ait değil!

Bu program sorunsuz derlenir. Ben bunu sıradan biçimde (-Wall uyarısı bile çıkmadı) derleyip çalıştırdım: program bitti yazdı ve çıkış durumu 0 oldu; hata hiç görünmedi. CS50'nin Valgrind örneğinde de aynı hata (3 elemanlık diziye 33 değerini x[3]'e yazmak) program hata vermese de araç tarafından yakalanır.³ Ben aynı programı gcc'nin AddressSanitizer seçeneğiyle (-fsanitize=address) derleyip çalıştırdım ve şu çıktıyı aldım (ilgili satırlar):

ERROR: AddressSanitizer: heap-buffer-overflow on address 0x781feefe001c
WRITE of size 4 at 0x781feefe001c thread T0
0x781feefe001c is located 0 bytes after 12-byte region [0x781feefe0010,0x781feefe001c)

Okunuşu: "4 byte'lık bir yazma yaptın; yazdığın yer, 12 byte'lık bölgenin hemen bittiği yer." Araç olmadan program sessizce komşu belleğin üstüne yazar. Bu sessizlik tehlikelidir, çünkü hata ortaya çıktığında (başka bir yerde, başka bir zamanda bozuk bir değer olarak) sebebinden uzaktadır. CS50 aynı noktaya scanf ile yazı okurken de işaret eder: kullanıcının ne kadar uzun bir yazı gireceğini bilemediğin için önceden ayırdığın alan yetmeyebilir ve bu kod "güvensizdir".³ Dışarıdan gelen veriyle taşıma, güvenlik tartışmalarının (Bölüm 41) konusudur; burada yalnızca kaynağını bil: C belleğin sınırını kontrol etmez.

Segmentation fault ise, işletim sisteminin bu ihlalin en çok göze batan türünü yakalamasıdır: programın kendisine ait olmayan bir bölgeye dokunması. CS50 bunu "programın dokunmaması gereken bir belleğe dokunması" diye tanımlar.² Neden yalnızca bazen çıkar, neden bazen sessiz geçer? Çünkü işletim sistemi bellek bölgelerini kaba sınırlarla korur (Bölüm 13 ve 15); sınır içinde kalan bir taşma fark edilmez.

Sorunu çözmenin üç yolu

Modern diller bu yükü farklı yollarla kaldırır. Kerem'in karşılaşacağı üç yol:

• Çöp toplayıcı (garbage collector): Çalışma zamanı, artık kullanılmayan belleği kendisi bulup geri verir. MDN'nin anlatımıyla JavaScript, nesneler oluşturulurken belleği otomatik ayırır ve artık kullanılmadıklarında serbest bırakır; C gibi diller ise malloc() ve free() gibi elle bellek yönetimi araçlarına sahiptir.⁵ Bellek yaşam döngüsü her dilde aynıdır: ayır, kullan, serbest bırak; yüksek seviyeli dillerde birinci ve üçüncü adım örtüktür.⁵ Bunun bir tuzağı var: MDN, bu otomatikliğin geliştiricide "belleği düşünmeme" yanılgısı yaratabileceğini söyler.⁵ JavaScript motorlarının kullandığı ana yöntem "erişilebilirlik"tir: köklerden (global nesne) başlayıp erişilebilen nesneleri bulur, erişilemeyenleri toplar.⁵ Go'nun da tasarım gerekçelerinde çöp toplama vardır: Go SSS'si, çok çekirdekli işlemcilerin dile eşzamanlılık desteği gerektirdiğini ve büyük eşzamanlı programlarda kaynak yönetimini yönetilebilir kılmak için çöp toplamanın ya da en azından güvenli bir otomatik bellek yönetiminin gerektiğini söyler.⁶
• Sahiplik (ownership): Rust'ın yolu. Rust Kitabı'nın ifadesiyle bazı diller çöp toplama kullanır; bazılarında programcı belleği elle ayırıp serbest bırakır; Rust ise "üçüncü bir yaklaşım" izler: bellek, derleyicinin denetlediği sahiplik kurallarıyla yönetilir. Kurallar ihlal edilirse program derlenmez.⁷ Kurallar kısadır: her değerin bir sahibi vardır; aynı anda tek sahip olabilir; sahip kapsamın dışına çıkınca değer atılır.⁷ Bu yöntemin ayırt edici yanı, bedelin çalışma zamanında değil derleme zamanında ödenmesidir: Rust Kitabı, sahiplik özelliklerinin programı çalışırken yavaşlatmadığını söyler.⁷ Rust'ı Bölüm 21'de dil haritasında göreceğiz.
• Dilden pointer aritmetiğini çıkarmak: Go SSS'sinde "Neden pointer aritmetiği yok?" sorusunun cevabı tek kelime: güvenlik. Pointer aritmetiği olmayınca, yanlışlıkla geçerli sayılan hatalı bir adres türetmek imkânsızlaşır; ayrıca bu durum çöp toplayıcının gerçeklenmesini de kolaylaştırır.⁶ Yani 10.3'te gördüğün p + 1 işlemi Go'da yok; bu bilinçli bir kısıtlama.

Bunların hepsi aynı terimle özetlenir: bellek güvenliği (memory safety), bir programın yalnızca kendisine ayrılmış belleğe dokunmasının dil tarafından güvence altına alınması. Go SSS'sinin bir cümlesi bunu ters yönden doğrular: Go'yu C koduyla birleştirmek, Go'nun sağladığı bellek güvenliği ve yığın yönetimi özelliklerinden vazgeçmek anlamına gelir.⁶ Neden C hâlâ kullanılıyor? Çünkü bu denetim bir maliyettir ve işletim sistemi çekirdeği, sürücüler ve gömülü yazılım (Bölüm 12–13) gibi yerlerde programcı o maliyeti ödemek ya da denetimi bırakmak istemez. Bu bölümde sana düşen: bir dilin "bellek güvenli" olmasının ne anlama geldiğini ve neyi senin yerine yaptığını bilmek.

10.6 Değer ve referans: JavaScript'te nesne kopyalarken sürprizler

JavaScript'te pointer yoktur; ama aynı fikir görünmeden çalışır. MDN'nin tanımıyla ilkel değer (primitive), nesne olmayan ve metodu bulunmayan veridir; yedi türü vardır (string, number, bigint, boolean, undefined, symbol, null) ve hepsi değiştirilemezdir.⁸ Nesneler, diziler ve fonksiyonlar ise ilkel değildir ve değiştirilebilir. Fark, kopyalarken ortaya çıkar. Aşağıdaki kodu Node ile çalıştırdım:

let n = 5; let m = n; m = 6;
console.log(n, m);                 // 5 6    → ilkel değer kopyalandı

const a = { ad: "Kerem", puan: 10 };
const b = a;                       // b = a: nesnenin KENDİSİ değil, ona giden "yol" kopyalandı
b.puan = 99;
console.log(a.puan);               // 99     → a da değişti!

const c = { ...a };                // yeni bir nesne: "yüzeysel kopya"
c.puan = 5;
console.log(a.puan, c.puan);       // 99 5   → bu kez ayrı

const d = { ad: "K", rozetler: ["ilk"] };
const e = { ...d };                // yüzeysel kopya
e.rozetler.push("seri");
console.log(d.rozetler);           // [ 'ilk', 'seri' ] → iç içe dizi ORTAK!

const f = structuredClone(d);      // derin kopya
f.rozetler.push("x");
console.log(d.rozetler.length, f.rozetler.length);   // 2 3

Satır satır: İlk blokta sayı kopyalanır; değişken değerini taşır, m'yi değiştirmek n'i etkilemez. İkinci blokta b = a nesnenin kendisini değil ona giden başvuruyu (referans, reference) kopyalar; esas numarası benzetmesindeki gibi iki kişi aynı dosya numarasına sahip olur ve birinin yazdığı ötekinde görünür. Üçüncü blokta { ...a } yeni bir nesne yapar. Ama MDN'nin yüzeysel kopya (shallow copy) tanımıyla, bu kopyanın özellikleri kaynağın özellikleriyle aynı başvuruları paylaşır; kaynağı ya da kopyayı değiştirirsen ötekini de değiştirebilirsin, derin kopya (deep copy) ise tamamen bağımsızdır.⁹ Dördüncü blok bunu gösterir: rozetler dizisi iki nesne arasında ortaktır, birinde push ettiğin öbüründe görünür. Beşinci blokta structuredClone() derin kopya yapar; MDN, bu yöntemin değeri "structured clone algorithm" ile derin kopyaladığını söyler.¹⁰

Bu bölümde neler kuruldu

Dizi, aynı tipten değerlerin bellekte art arda tutulmasıdır; indeks sıfırdan başlar ve skor[i] "başlangıç + i × boy" hesabıdır. Karakter dizisi (string), char dizisidir ve \0 ile biter; bu yüzden strlen("HI!") 3 ama kapladığı yer 4 byte'tır. Adres, bir hücrenin numarasıdır; & adres verir, * adresten değere gider. Pointer, adres saklayan değişkendir ve 64 bitlik makinede 8 byte'tır. Argümanlar kopyalanır; adres vermek, çağrılan fonksiyonun asıl değişkeni değiştirmesine izin verir. Bellek yığın (fonksiyon çerçeveleri, otomatik) ve öbek (malloc/free, elle) olarak ayrılır; free unutulursa bellek sızıntısı olur. Ayrılan bloğun ötesine yazmak arabellek taşmasıdır ve bazen segmentation fault olarak görünür. Bellek güvenliği, çöp toplayıcı (JavaScript, Go) ya da sahiplik (Rust) gibi yollarla sağlanır; Go ayrıca pointer aritmetiğini dilden çıkarmıştır. JavaScript'te ilkel değerler kopyalanır, nesnelerde başvuru kopyalanır; { ...a } yüzeysel, structuredClone derin kopyadır.

Terimler sözlükte, Bölüm 10 başlığı altında.

Kaynaklar

1. CS50x 2026, Lecture 3 ders notları. Kaynak: CS50 Hafta 3 notları; diziler ve arama, strcmp ile karakter dizisi karşılaştırma, segmentation fault.
2. CS50x 2026, Lecture 2 ders notları. Kaynak: CS50 Hafta 2 notları ve transkripti; diziler, string ve NUL karakteri, strlen.
3. CS50x 2026, Lecture 4 ders notları. Kaynak: CS50 Hafta 4 notları ve transkripti; onaltılık sayı ve 0x, & ve *, pointer, string = char *, pointer aritmetiği, == ile adres karşılaştırma, malloc/free, NULL, Valgrind, çöp değerler, takas ve yığın çerçeveleri, taşma türleri, scanf.
4. Ian Wienand, Computer Science from the Bottom Up, Bölüm 5.2: Elements of a process: yığın ve yığın çerçevesi (dönüş adresi, argümanlar, yerel değişkenler).
5. MDN, Memory management: bellek yaşam döngüsü, otomatik ayırma ve çöp toplama, erişilebilirlik (mark-and-sweep).
6. The Go Authors, Go FAQ: tasarım gerekçesi ve çöp toplama, "Why is there no pointer arithmetic?", C ile bağlamanın bellek güvenliğinden vazgeçmek olması.
7. Steve Klabnik ve Carol Nichols, The Rust Programming Language, "What Is Ownership?": sahiplik kuralları ve çöp toplama/elle yönetim karşılaştırması.
8. MDN, Glossary: Primitive: JavaScript'in yedi ilkel türü ve değiştirilemezlik.
9. MDN, Glossary: Shallow copy: yüzeysel ve derin kopya.
10. MDN, structuredClone(): derin kopya yöntemi.

Bu bölümdeki programların çıktıları (adres farkları, sizeof, strlen, segmentation fault, AddressSanitizer raporu, takas ve JavaScript sonuçları) yazar tarafından Linux x86-64, gcc 15.2.0 ve Node ile gerçekten çalıştırılarak elde edilmiştir.