Rust Ownership Kavramı: Başlangıç Rehberi (2025) | Memory Safety Nedir?

Kural 1: Her Değerin Bir Sahibi Var (Each Value Has an Owner)

let s = String::from("hello");
// 's' değişkeni "hello" String'inin sahibidir
// 's' variable is the owner of the "hello" String

Kural 2: Aynı Anda Sadece Bir Sahip Olabilir (Only One Owner at a Time)

let s1 = String::from("hello");
let s2 = s1;  // Sahiplik s1'den s2'ye taşındı (ownership moved)

println!("{}", s1);  // ❌ HATA! s1 artık geçersiz (s1 no longer valid)

Kural 3: Sahip Scope'tan Çıktığında, Değer Drop Edilir (When Owner Goes Out of Scope, Value is Dropped)

{
    let s = String::from("hello");
    // s burada kullanılabilir (s is usable here)
} // s scope dışına çıktı, memory otomatik temizlendi!
  // (s went out of scope, memory automatically cleaned!)

// s artık kullanılamaz (s cannot be used anymore)

Örnek 1: String Move

fn main() {
    let s1 = String::from("Alesta Web");
    let s2 = s1;  // s1'den s2'ye MOVE (MOVE from s1 to s2)

    println!("{}", s2);  // ✅ Çalışır: "Alesta Web"
    println!("{}", s1);  // ❌ COMPILE ERROR!
}

// Hata mesajı (Error message):
// error[E0382]: borrow of moved value: `s1`

Neden? Çünkü String heap'te (on the heap) tutulur ve iki pointer'ın aynı memory'yi göstermesi (two pointers pointing to same memory) double-free bug'ına yol açar. Rust bunu engellemek için (to prevent this) ownership'i taşır!

Örnek 2: Copy vs Move

fn main() {
    // Integer'lar Copy trait'ine sahip (have Copy trait)
    let x = 5;
    let y = x;

    println!("x: {}, y: {}", x, y);  // ✅ İkisi de çalışır! (Both work!)

    // String'ler Copy trait'ine sahip DEĞİL (DON'T have Copy trait)
    let s1 = String::from("hello");
    let s2 = s1;

    println!("{}", s1);  // ❌ HATA!
}

Basit tipler (simple types) stack'te tutulur ve kopyalanması ucuzdur (copying is cheap), o yüzden Copy yapılır. Karmaşık tipler (complex types) heap'te tutulur, Move yapılır.

Immutable Reference (&T)

fn main() {
    let s1 = String::from("Alesta Web");

    // s1'i ödünç al (borrow s1) ama sahipliği taşıma (but don't take ownership)
    let len = calculate_length(&s1);

    println!("'{}' uzunluğu: {}", s1, len);  // ✅ s1 hala kullanılabilir!
}

fn calculate_length(s: &String) -> usize {
    s.len()  // Sadece okuma yapıyoruz (just reading)
}  // s scope dışı, ama String drop edilmez (s goes out of scope, but String is NOT dropped)
   // çünkü sahip değiliz! (because we don't own it!)

&s1 syntax'ı bir "reference" (referans) oluşturur. Reference sahiplik almaz (reference doesn't take ownership), sadece değere erişim sağlar (just provides access to the value).

Borrowing Kuralları (Borrowing Rules)

fn main() {
    let s = String::from("hello");

    // Aynı anda birden fazla immutable reference OK! ✅
    let r1 = &s;
    let r2 = &s;
    let r3 = &s;

    println!("{}, {}, {}", r1, r2, r3);  // ✅ Hepsi çalışır!
}

İstediğiniz kadar immutable reference oluşturabilirsiniz (you can create as many immutable references as you want). Sadece okuma yaptıkları için (since they only read) sorun yok!

Mutable Reference (&mut T)

fn main() {
    let mut s = String::from("hello");

    change(&mut s);  // Mutable reference geçiyoruz (passing mutable reference)

    println!("{}", s);  // "hello, world!"
}

fn change(s: &mut String) {
    s.push_str(", world!");  // String'i değiştiriyoruz! (modifying String!)
}

Dikkat edin: s değişkeni mut olmalı (must be mut) ve &mut s ile mutable reference oluşturuyoruz.

Immutable ve Mutable Karıştırılamaz! (Cannot Mix Immutable and Mutable!)

fn main() {
    let mut s = String::from("hello");

    let r1 = &s;      // ✅ immutable borrow
    let r2 = &s;      // ✅ immutable borrow
    let r3 = &mut s;  // ❌ HATA! Immutable reference varken mutable olamaz
                       // (Cannot have mutable while immutable exists)

    println!("{}, {}, {}", r1, r2, r3);
}

Dangling Reference Sorunu (Dangling Reference Problem)

fn main() {
    let r;

    {
        let x = 5;
        r = &x;  // ❌ HATA! x scope dışına çıkacak
                 // (ERROR! x will go out of scope)
    }

    println!("{}", r);  // r artık geçersiz memory'yi gösterir!
                         // (r would point to invalid memory!)
}

// error[E0597]: `x` does not live long enough

Rust compile-time'da bunu engelliyor (prevents this at compile-time)! C++'ta bu segmentation fault olurdu (this would be a segfault in C++).

Lifetime Annotation Örneği (Lifetime Annotation Example)

// Hangi reference daha uzun yaşıyor? (Which reference lives longer?)
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let s1 = String::from("Alesta");
    let s2 = String::from("Web");

    let result = longest(&s1, &s2);
    println!("En uzun: {}", result);  // "Alesta"
}

'a lifetime parametresi (lifetime parameter), return edilen reference'ın x ve y'den en az biri kadar yaşayacağını (will live at least as long as one of x or y) garanti eder.

Örnek 1: Vector'de Değişiklik (Modifying a Vector)

fn main() {
    let mut numbers = vec![1, 2, 3, 4, 5];

    // Immutable borrow - sadece okuma (just reading)
    for num in &numbers {
        println!("{}", num);
    }

    // Mutable borrow - değiştirme (modifying)
    for num in &mut numbers {
        *num *= 2;  // Her elemanı 2 ile çarp (multiply each element by 2)
    }

    println!("{:?}", numbers);  // [2, 4, 6, 8, 10]
}

Örnek 2: Struct ile Ownership

struct User {
    name: String,
    email: String,
}

fn main() {
    let user1 = User {
        name: String::from("alestaweb"),
        email: String::from("info@alestaweb.com"),
    };

    // user1'i ödünç al (borrow user1)
    print_user(&user1);

    // user1 hala kullanılabilir! (user1 still usable!)
    println!("User: {}", user1.name);
}

fn print_user(user: &User) {
    println!("Name: {}, Email: {}", user.name, user.email);
}

Örnek 3: String Manipulation

fn main() {
    let mut text = String::from("Alesta");

    append_web(&mut text);

    println!("{}", text);  // "Alesta Web"
}

fn append_web(s: &mut String) {
    s.push_str(" Web");  // String'e ekleme (appending to String)
}

❌ Hata 1: Move Edilen Değeri Kullanma (Using Moved Value)

// YANLIŞ (WRONG):
let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1);  // HATA!

// DOĞRU (CORRECT):
let s1 = String::from("hello");
let s2 = s1.clone();  // Explicit clone
println!("{}, {}", s1, s2);  // ✅ İkisi de çalışır

clone() pahalı bir işlemdir (expensive operation). Mümkünse borrowing kullanın (use borrowing if possible)!

❌ Hata 2: Birden Fazla Mutable Reference (Multiple Mutable References)

// YANLIŞ (WRONG):
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;  // HATA!

// DOĞRU (CORRECT):
let mut s = String::from("hello");
{
    let r1 = &mut s;
    r1.push_str(" world");
}  // r1 scope dışı (r1 goes out of scope)
let r2 = &mut s;  // ✅ Artık OK!

❌ Hata 3: Return Dangling Reference

// YANLIŞ (WRONG):
fn dangle() -> &String {
    let s = String::from("hello");
    &s  // HATA! s drop edilecek (s will be dropped)
}

// DOĞRU (CORRECT):
fn no_dangle() -> String {
    let s = String::from("hello");
    s  // Sahipliği taşı (move ownership)
}