Ders 07: Bellek Yönetimi

🎁 Sahiplik Nedir?What is Ownership?

Her oyuncağın bir sahibi var. Bir arkadaşına verirsen, artık senin değil! Ama ödünç verirsen geri alırsın. 🧸

📝 Örnek 1: Oyuncak DeğişimiExample 1: Toy Trading

🧸 oyuncak.berk

// Sahiplik - Bir oyuncağın tek sahibi var!
fonksiyon ana() {
    // Ahmet'in bir robot oyuncağı var
    değişken robot = "🤖 Süper Robot";
    yazdir("Ahmet'in oyuncağı: {}", robot);
    
    // Ahmet robotu Ayşe'ye VERDİ (sahiplik geçti)
    değişken aysenin_robotu = robot;
    yazdir("Ayşe'nin yeni oyuncağı: {}", aysenin_robotu);
    
    // ❌ HATA! robot artık Ahmet'te değil!
    // yazdir("Ahmet'in oyuncağı: {}", robot);  // Bu çalışmaz!
    
    yazdir("\n📌 Ders: Bir şeyi verirsen artık senin değil!");
}

📝 Örnek 2: Ödünç VermeExample 2: Borrowing

📚 odunc.berk

// Ödünç verme - & işareti kullan!
fonksiyon kitabi_oku(kitap: &metin) {
    yazdir("📖 Okunan kitap: {}", kitap);
    // Sadece okuyoruz, değiştirmiyoruz
}

fonksiyon kitabi_yazdir(kitap: &metin) {
    yazdir("📕 Kitap adı: {}", kitap);
}

fonksiyon ana() {
    değişken benim_kitabim = "Harry Potter";
    
    // Kitabı ödünç ver (& ile)
    kitabi_oku(&benim_kitabim);    // Arkadaş okudu
    kitabi_yazdir(&benim_kitabim); // Başka arkadaş da baktı
    
    // ✅ Kitap hâlâ bizde!
    yazdir("\n✅ Kitap hâlâ bende: {}", benim_kitabim);
    yazdir("📌 Ders: & ile ödünç verirsen geri alırsın!");
}

🎯 Hatırla!Remember!

Vermek = Sahipliği devretmek (geri almak yok)
Ödünç vermek (&) = Geçici olarak paylaşmakLend (&) = Temporarily share

📖 Stack vs HeapStack vs Heap

BERK

// Stack: Sabit boyutlu, hızlı
değişken x: tamsayı = 42;        // Stack'te
değişken y: ondalık = 3.14;      // Stack'te

// Heap: Dinamik boyutlu, referans gerekir
değişken metin = "Merhaba";      // Data heap'te, pointer stack'te
değişken liste = [1, 2, 3, 4];   // Array heap'te

📝 Örnek 1: Ownership KurallarıExample 1: Ownership Rules

📋 ownership.berk

fonksiyon sahiplik_al(s: Metin) {
    yazdir("Fonksiyon sahip: {}", s);
}  // s burada drop edilir (bellek serbest)

fonksiyon odunc_al(s: &Metin) {
    yazdir("Ödünç aldım: {}", s);
}  // Sadece referans biter, asıl veri yaşar

fonksiyon ana() {
    değişken s1 = Metin::yeni("Merhaba");
    
    // Move - sahiplik geçer
    sahiplik_al(s1);
    // yazdir("{}", s1);  // ❌ HATA: s1 artık geçersiz
    
    değişken s2 = Metin::yeni("Dünya");
    
    // Borrow - sadece referans
    odunc_al(&s2);
    yazdir("Hâlâ sahibim: {}", s2);  // ✅ Çalışır
    
    // Clone - derin kopya
    değişken s3 = s2.klon();
    yazdir("Orijinal: {}, Kopya: {}", s2, s3);
}

📝 Örnek 2: Mutable ReferencesExample 2: Mutable References

✏️ mutable.berk

function add_suffix(s: &mut String, suffix: &str) {
    s.push_str(suffix);
}

function main() {
    let mut name = String::from("Ali");
    
    // İmmutable borrow - sadece okuma (birden fazla olabilir)
    let r1 = &name;
    let r2 = &name;
    print("Okunan: {} ve {}", r1, r2);
    
    // Mutable borrow - değiştirme (sadece 1 tane!)
    let r3 = &mut name;
    r3.push_str(" Veli");
    print("Değiştirilen: {}", r3);
    
    // Fonksiyona mutable ref geç
    add_suffix(&mut name, " Deli");
    print("Sonuç: {}", name);
}

🎯 Lifetime ve Borrow CheckerLifetime and Borrow Checker

Lifetime annotations ('a)
Lifetime elision rules
Static lifetime ('static)
Non-lexical lifetimes (NLL)

📝 Örnek 1: Lifetime AnnotationsExample 1: Lifetime Annotations

BERK (Lifetimes)

// Explicit lifetime annotation
function longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// Struct with lifetime
struct TextParser<'a> {
    content: &'a str,
    position: usize,
}

impl<'a> TextParser<'a> {
    function new(content: &'a str) -> Self {
        TextParser { content, position: 0 }
    }
    
    function remaining(&self) -> &'a str {
        &self.content[self.position..]
    }
    
    function advance(&mut self, n: usize) {
        self.position = (self.position + n).min(self.content.len());
    }
}

// Multiple lifetimes
struct Context<'a, 'b> {
    text: &'a str,
    config: &'b Config,
}

function main() {
    let s1 = String::from("Merhaba");
    let s2 = String::from("Dünya!");
    
    let result = longest(&s1, &s2);
    print("Longer: {}", result);
    
    // Parser example
    let text = "Hello, World!";
    let mut parser = TextParser::new(text);
    print("Full: {}", parser.remaining());
    parser.advance(7);
    print("After advance: {}", parser.remaining());
}

📝 Örnek 2: Smart PointersExample 2: Smart Pointers

BERK (Smart Pointers)

use std::rc::Rc;
use std::cell::RefCell;

// Box: Heap allocation with single ownership
function box_example() {
    let boxed = Box::new(42);
    print("Boxed value: {}", boxed);
    
    // Recursive type requires Box
    enum List {
        Cons(i32, Box),
        Nil,
    }
    
    let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
}

// Rc: Reference counting (single-threaded)
function rc_example() {
    let data = Rc::new(vec![1, 2, 3]);
    
    let ref1 = Rc::clone(&data);  // Increment count
    let ref2 = Rc::clone(&data);
    
    print!("Reference count: {}", Rc::strong_count(&data));  // 3
}

// RefCell: Interior mutability
function refcell_example() {
    let data = RefCell::new(5);
    
    // Borrow mutably at runtime
    *data.borrow_mut() += 1;
    
    // Multiple immutable borrows OK
    let r1 = data.borrow();
    let r2 = data.borrow();
    print("Values: {}, {}", r1, r2);
}

// Combined: Rc> for shared mutable state
struct SharedCounter {
    value: Rc>,
}

impl SharedCounter {
    function new() -> Self {
        SharedCounter { value: Rc::new(RefCell::new(0)) }
    }
    
    function increment(&self) {
        *self.value.borrow_mut() += 1;
    }
    
    function get(&self) -> i32 {
        *self.value.borrow()
    }
}

function main() {
    box_example();
    rc_example();
    refcell_example();
    
    let counter = SharedCounter::new();
    counter.increment();
    counter.increment();
    print("Counter: {}", counter.get());
}

📌 ÖzetSummary

Her değerin tek bir sahibi (owner) vardırEvery value has a single owner
& ile immutable borrow, &mut ile mutable borrow
References her zaman geçerli olmalı (no dangling)