Rust Rust: Güvenli ve Hızlı Programlama

Rust Ownership (Sahiplik) Nedir? Örneklerle Sahiplik Kuralları

Rust ownership, her değerin tek bir sahibi olmasını ve kapsam bitince otomatik temizlenmesini sağlayan derleme zamanı modelidir. Bu derste üç kuralı, move semantiğini, clone ve Copy farkını ve E0382 hatasını çalışır örneklerle işliyoruz.

Serhat ALPASLAN12 dk okuma

İçindekiler

Rust ownership (sahiplik), bir değerin bellekteki sahibini ve ne zaman serbest bırakılacağını derleme zamanında belirleyen modeldir. Bu ders Rust 1.91 için yazılmıştır ve Rust: Güvenli ve Hızlı Programlama serisinin 6. dersidir. Sahiplik kurallarını, move semantiğini, clone ve Copy farkını ve derleyicinin E0382 hatasını çalışır örneklerle inceliyoruz; Rust borrow checker bu kuralları derleme zamanında denetler.

Bu derste öğreneceklerin

  • Sahipliğin üç kuralını açıklayabilmek
  • Move ile kopyalama arasındaki farkı ayırt edebilmek
  • E0382 hatasını okuyup düzeltebilmek
  • Değerleri fonksiyonlara güvenle geçirmek ve geri almak
  • Drop trait’inin kapsam sonunda ne yaptığını görebilmek

Bu ders, Rust fonksiyonlar ve kontrol akışı dersini tamamladığını varsayar.

Rust ownership nedir?

Kısa cevap: Rust ownership, her değerin tek bir sahibi olmasını ve sahibi kapsamdan çıkınca değerin otomatik serbest bırakılmasını sağlayan derleme zamanı kuralıdır. Bu sayede Rust, çalışma zamanında çöp toplayıcı olmadan bellek güvenliği sunar.

Sahiplik, Rust’ı diğer sistem dillerinden ayıran temel mekanizmadır: derleyici hangi değişkenin hangi bellek bölgesini yönettiğini izler ve kural ihlallerini program çalışmadan reddeder. Sahiplik; ödünç alma (borrowing) ve yaşam süreleri (lifetimes) ile birlikte çalışır, bu derste yalnızca sahiplik ayağını işliyoruz.

Pratikte bu, “bu String’i fonksiyona verirsem elimde kalır mı?” sorusunun cevabını derleyicinin vermesi demektir. Cevap hayırsa kod derlenmez; bu sertlik, serbest bırakılmış belleğe erişim (use-after-free), çift serbest bırakma (double free) ve sarkan işaretçi gibi bellek hatalarını derleme zamanında engeller. Bellek sızıntısı ise Rust’ta güvenli sayılır; sahiplik bunu zorlaştırır ama garanti etmez.

Sahipliğin üç kuralı

Kısa cevap: Rust sahiplik kuralları üç maddedir: her değerin tam olarak bir sahibi vardır, aynı anda yalnızca bir sahip bulunabilir ve sahip kapsam dışına çıktığında değer düşürülür. Bu üç kural, sahiplik davranışının tamamını özetler.

  1. Her değerin bir sahibi vardır. Bir String oluşturulduğunda onu tutan değişken sahibi olur.
  2. Aynı anda yalnızca bir sahip olabilir. Sahiplik başka bir değişkene devredilirse eskisi geçersizleşir.
  3. Sahip kapsam dışına çıkınca değer düşürülür. Kapsam bitince Rust bellek temizliğini otomatik yapar.

Resmi kaynakta bu kurallar The Rust Programming Language, bölüm 4.1 içinde aynı sırayla verilir. Kurallar kısa; zor olan, günlük kod yazarken bunları alışkanlığa dönüştürmek.

Stack ve heap: neden önemli

Kısa cevap: Stack sabit boyutlu ve hızlı, heap ise esnek ama daha yavaş bir bellek alanıdır; sahiplik kuralları büyük ölçüde heap’teki veriyi kimin temizleyeceğini belirlemek için vardır. Stack’teki veriler kapsamla birlikte kendiliğinden gider, heap’teki veriler ise bir sahibe ihtiyaç duyar.

String tipi bu ayrımın en iyi örneğidir: değişkenin kendisi stack’te üç alanla (işaretçi, uzunluk, kapasite) durur, karakterler heap’te yaşar. Değişken kapsamdan çıkınca Rust hem stack kaydını hem heap tahsisini temizler.

Özellik Stack Heap
Boyut Derleme zamanında bilinir Çalışma zamanında belirlenir
Hız Çok hızlı, işaretçi hareketi Daha yavaş, tahsis ve arama gerekir
Temizlik Kapsam sonunda otomatik Sahip üzerinden Drop ile
Tipik tipler i32, bool, char, &str String, Vec<T>, Box<T>

Bu yüzden i32 gibi tipleri kopyalamak neredeyse bedavayken, String kopyalamak heap’te yeni bir tahsis demektir. Sahiplik modeli tam olarak bu maliyet farkını görünür kılar.

Move: değer taşındığında ne olur

Kısa cevap: Rust move semantiği, bir değer başka bir değişkene atandığında veya fonksiyona geçirildiğinde sahipliğin devredilmesi ve eski değişkenin geçersizleşmesi demektir. Heap’teki veri taşınmaz; yalnızca onu işaret eden stack kaydı yeni değişkene kopyalanır.

Bellek düzeyinde olanlar sırayla şöyle:

  1. let s2 = s1; satırı stack’teki işaretçi, uzunluk ve kapasite üçlüsünü s2‘ye kopyalar.
  2. Heap’teki merhaba baytları kopyalanmaz; iki değişken aynı tamponu gösterir.
  3. Derleyici s1‘i geçersiz olarak işaretler, böylece kapsam sonunda tampon yalnızca s2 üzerinden bir kez serbest bırakılır.

Move, çalışma zamanında ucuz bir bit kopyasıdır; Copy‘den tek farkı kaynağın geçersizleşmesidir.

fn main() {
    let s1 = String::from("merhaba");
    let s2 = s1; // move: sahiplik s2'ye geçti

    println!("s2 = {}", s2);

    let x = 5;
    let y = x; // i32 Copy olduğu için kopyalanır

    println!("x = {}, y = {}", x, y);

    let s3 = s2.clone(); // açık kopya
    println!("s3 = {}", s3);
}
s2 = merhaba
x = 5, y = 5
s3 = merhaba

Yukarıdaki programda s1 atamasından sonra s1 kullanılmıyor; çünkü sahiplik s2‘ye geçti. Aynı satır i32 için farklı davranır: x hâlâ geçerlidir, çünkü i32 Copy trait’ini uygular.

E0382 hatasını satır satır okumak

Aşağıdaki parça, taşınmış bir değeri kullanmaya çalıştığı için derlenmez. Hata çıktısı rustc ile alınmıştır ve kısaltılmıştır.

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

    println!("{}", s1);
}
error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:5:20
  |
2 |     let s1 = String::from("merhaba");
  |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 |
5 |     println!("{}", s1);
  |                    ^^ value borrowed here after move
  |
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let s2 = s1.clone();
  |                ++++++++
  • Hata kodu: E0382, taşındıktan sonra kullanılan değer anlamına gelir. Burada println! değeri ödünç aldığı için mesaj borrow of moved value diyor; doğrudan taşıma yapan bir ifade olsaydı use of moved value yazardı.
  • --> satırı: hatanın dosyasını, satırını (5) ve sütununu (20) gösterir.
  • 2. satır: Taşınmanın nedeni: s1‘in tipi String ve String Copy uygulamıyor.
  • 3. satır: -- işaretleriyle “value moved here” denerek taşınmanın tam noktası gösteriliyor.
  • 5. satır: ^^ işareti hatanın gerçekleştiği ifadeyi işaret ediyor; burada taşınmış değer yazdırılmaya çalışılıyor.
  • help bloğu: Derleyici somut bir düzeltme öneriyor: s1.clone() ile açık kopya almak.

Bu mesajı okumayı öğrenmek zaman kazandırır; derleyici hatayı bildirmekle kalmaz, çoğu zaman düzeltmeyi de önerir. Hata kodunun resmi açıklaması rustc hata indeksinde yer alır.

Clone ve Copy farkı

Kısa cevap: Rust clone ve Copy farkı şudur: Copy, derleyicinin atama sırasında sessizce bit kopyası yaptığı işaretleyici trait’tir; Clone ise açıkça .clone() çağrılarak veri kopyalayan trait’tir. Copy yalnızca stack’te yaşayan basit tipler için uygundur, heap sahibi tipler Copy olamaz.

Özellik Copy Clone
Anlamı Örtük bit kopyası Açık .clone() çağrısı
Ne zaman devreye girer Atama, fonksiyon parametresi, dönüş değeri Yalnızca elle çağrıldığında
Metot Yok, işaretleyici trait fn clone(&self) -> Self
Uygun tipler i32, f64, bool, char, &T, tüm elemanları Copy olan demetler ve diziler, ör. (i32, bool), [u8; 4] String, Vec<T>, HashMap<K, V>
Maliyet Çok düşük, stack kopyası Heap tahsisi içerebilir

Kendi struct’larında iki trait’i de türetebilirsin; ancak Copy türetmek için tüm alanların da Copy olması gerekir. Resmi tanım std::marker::Copy sayfasında listelenir.

#[derive(Debug, Clone, Copy)]
struct Nokta {
    x: i32,
    y: i32,
}

String neden Copy değildir?

String heap’te bir tampon sahibidir. Copy olsaydı atama sırasında iki değişken aynı tamponu gösterir ve ikisi de kapsam sonunda aynı belleği serbest bırakmaya çalışırdı; bu, çift serbest bırakma (double free) hatasına yol açardı. Rust bu yüzden String için Copy yerine Clone sunar ve kopyalamanın açıkça istenmesini zorunlu kılar.

Fonksiyonlara değer geçirmek ve geri almak

Kısa cevap: Fonksiyona sahipliği geçirirsen değer fonksiyonun içine taşınır ve çağıran tarafta kullanılamaz; değeri geri almak için fonksiyonun onu döndürmesi ya da değeri &T ile ödünç vermen gerekir.

fn uzunluk_al(s: String) -> usize {
    s.len()
}

fn uzunluk_odunc(s: &str) -> usize {
    s.len()
}

fn unlem_ekle(mut s: String) -> String {
    s.push('!');
    s
}

fn main() {
    let metin = String::from("sahiplik");

    println!("uzunluk: {}", uzunluk_odunc(&metin));
    println!("metin hala burada: {}", metin);

    let metin = unlem_ekle(metin); // sahiplik verildi ve geri alındı
    println!("geri alindi: {}", metin);

    println!("uzunluk: {}", uzunluk_al(metin));
}
uzunluk: 8
metin hala burada: sahiplik
geri alindi: sahiplik!
uzunluk: 9

Burada üç strateji yan yana duruyor: uzunluk_odunc yalnızca okur ve değeri geri vermez, unlem_ekle sahipliği alır ve değiştirip geri döndürür, uzunluk_al ise sahipliği tüketir. Gerçek projelerde okuma amaçlı fonksiyonlar için referans tercih edilir; sahiplik aktarımı yalnızca değeri gerçekten fonksiyona devretmek istediğinde kullanılır.

Son satırdaki uzunluk_al(metin) çağrısı sahipliği tükettiği için, ondan sonra metin kullanılamaz:

fn uzunluk_al(s: String) -> usize {
    s.len()
}

fn main() {
    let metin = String::from("sahiplik");
    println!("{}", uzunluk_al(metin));
    println!("{}", metin); // error[E0382]: borrow of moved value: `metin`
}

Parametre olarak &String yerine &str almak daha esnektir; hem String hem string literal bu tipe dönüşebilir. Değeri fonksiyona verip geri istemen gerekiyorsa demet döndürmek de geçerlidir:

fn uzunluk_ve_geri(s: String) -> (String, usize) {
    let uzunluk = s.len();
    (s, uzunluk)
}

Bu imza çalışır ama her çağrıda demet açmayı gerektirir; çoğu durumda referans kullanmak daha sade. Ödünç alma kurallarını serinin sonraki dersinde işliyoruz.

Drop ve kapsam sonu

Kısa cevap: Rust Drop trait’i, sahibi kapsamdan çıkan bir değerin kaynaklarını serbest bırakan mekanizmadır ve yıkıcı (destructor) görevini görür. Derleyici drop çağrısını kapsamın sonuna otomatik olarak yerleştirir.

struct Kayit {
    ad: String,
}

impl Drop for Kayit {
    fn drop(&mut self) {
        println!("{} kaydı bellekten temizlendi", self.ad);
    }
}

fn main() {
    let _a = Kayit { ad: String::from("birinci") };
    let _b = Kayit { ad: String::from("ikinci") };
    {
        let _c = Kayit { ad: String::from("ucuncu") };
        println!("iç kapsam bitti");
    }
    println!("dış kapsam bitiyor");
}
iç kapsam bitti
ucuncu kaydı bellekten temizlendi
dış kapsam bitiyor
ikinci kaydı bellekten temizlendi
birinci kaydı bellekten temizlendi

Çıktı sırası tesadüf değil: iç kapsamdaki _c önce düşürülür, ardından dış kapsam biter. Aynı kapsamda birden fazla değer varsa Rust bunları oluşturulma sırasının tersine (LIFO) temizler; bu yüzden _b, _a‘dan önce düşer.

Drop sırası, dosya tanıtıcıları ve kilitler gibi kaynaklarda önemlidir; kaynakların ters sırada bırakılması, bağımlılıkların güvenle kapanmasını sağlar.

Bir değeri kapsam bitmeden bırakmak istersen std::mem::drop kullanılır: drop(a); çağrısı a‘yı hemen tüketir. Buna karşılık a.drop() yazmak derlenmez; derleyici E0040 hatasıyla “explicit destructor calls not allowed” der. Ayrıntılar std::ops::Drop belgelerinde yer alır.

Ownership ile Rust neden çöp toplayıcıya ihtiyaç duymaz

Kısa cevap: Rust’ta bellek, çalışma zamanında izlenen bir çöp toplayıcı yerine derleme zamanında bilinen sahiplik ve kapsam bilgisiyle serbest bırakılır; bu yüzden GC duraklaması yaşanmaz. Serbest bırakma noktasını derleyici doğrudan üretilen koda yerleştirir.

Çöp toplayıcılı dillerde bellek, çalışma zamanında erişilebilirlik taramasıyla temizlenir. Rust’ta ise derleyici, her değerin nerede düşürüleceğini statik olarak bilir; çalışma zamanında ek bir izleyici yoktur. Sahiplik denetimi, Rust’ın sıfır maliyetli soyutlama ilkesinin bir örneğidir: kontroller derleme zamanında biter, çalışma zamanına ek yük bırakmaz.

Konu C++ Go Rust
Bellek yönetimi Elle; RAII ve akıllı işaretçiler Çöp toplayıcı Derleme zamanı sahiplik
Serbest bırakma Yıkıcı (destructor) GC Drop trait’i
Taşınmış değere erişim Derlenir; nesne geçerli ama belirsiz durumda kalır (hata derleyicide yakalanmaz) Move kavramı yok; atama değeri kopyalar ya da aynı veriye işaret eden başlığı paylaşır, belleği GC yönetir Derleme hatası (E0382)
Çalışma zamanı maliyeti Yok GC duraklamaları olabilir Yok
Veri yarışı denetimi Elle, araçlarla Çalışma zamanı race detector Derleme zamanı (Send/Sync)

Tablodaki fark, Rust’ın neden hem C++ benzeri performans hem de bellek güvenliği vaat ettiğini açıklar. Bedeli, derleyiciyle daha fazla konuşman ve sahiplik kararlarını kodda açıkça yazmandır.

Sık Yapılan Hatalar

1. Move sonrası eski değişkeni kullanmak

Belirti: error[E0382]: borrow of moved value mesajı alırsın. Neden: Atama veya fonksiyon çağrısı sahipliği devretmiştir, eski bağlama artık geçersizdir.

fn main() {
    let s1 = String::from("merhaba");
    let s2 = s1;
    println!("{}", s1); // hata: s1 taşındı
    println!("{}", s2);
}

Çözüm: Taşınan bağlamayı kullan ya da kopyayı açıkça iste.

fn main() {
    let s1 = String::from("merhaba");
    let s2 = s1.clone();
    println!("{} {}", s1, s2);
}

2. Her yerde clone çağırmak

Belirti: Kod derlenir ama gereksiz heap tahsisleri birikir. Neden: Derleyiciyi susturmanın en kolay yolu clone() olduğu için refleks hâline gelir.

fn uzunluk(s: String) -> usize {
    s.len()
}

fn main() {
    let metin = String::from("sahiplik");
    println!("{}", uzunluk(metin.clone()));
}

Çözüm: Okuma amaçlı fonksiyonlarda &str parametresi kullan; kopyayı yalnızca iki bağımsız sahip gerçekten gerektiğinde al.

fn uzunluk(s: &str) -> usize {
    s.len()
}

fn main() {
    let metin = String::from("sahiplik");
    println!("{}", uzunluk(&metin));
}

3. Fonksiyona String verip sonra kullanmaya çalışmak

Belirti: Fonksiyon çağrısından sonra aynı değişkeni yazdırmak E0382 üretir. Neden: Parametre String olarak tanımlandığında sahiplik fonksiyona geçer.

fn yaz(s: String) {
    println!("{}", s);
}

fn main() {
    let metin = String::from("merhaba");
    yaz(metin);
    println!("{}", metin); // hata: metin taşındı
}

Çözüm: Parametreyi &str yap ve çağrıda referans geçir.

fn yaz(s: &str) {
    println!("{}", s);
}

fn main() {
    let metin = String::from("merhaba");
    yaz(&metin);
    println!("{}", metin);
}

4. Struct alanını taşıyıp struct’ı bütün olarak kullanmak

Belirti: error[E0382]: borrow of partially moved value: `k` mesajını görürsün. Neden: Bir alan başka değişkene taşındığında struct kısmen geçersizleşir.

#[derive(Debug)]
struct Kullanici {
    ad: String,
    yas: u32,
}

fn main() {
    let k = Kullanici { ad: String::from("Ada"), yas: 30 };
    let ad = k.ad;
    println!("{:?}", k); // hata: k kısmen taşındı
    println!("{}", ad);
}

Çözüm: Alanı ödünç al ya da açıkça kopyala; böylece struct bütün olarak geçerli kalır.

#[derive(Debug)]
struct Kullanici {
    ad: String,
    yas: u32,
}

fn main() {
    let k = Kullanici { ad: String::from("Ada"), yas: 30 };
    let ad = k.ad.clone();
    println!("{:?}", k);
    println!("{}", ad);
}

Sık Sorulan Sorular

Rust ownership neden var?

Sahiplik, bellek güvenliğini ve veri yarışı denetimini çalışma zamanı maliyeti olmadan sağlamak için vardır. Derleyici, aynı belleğe iki sahip olmasını ve serbest bırakılmış veriye erişilmesini program çalışmadan engeller. Böylece çöp toplayıcıya duyulan ihtiyaç ortadan kalkar.

Rust’ta move ile copy arasındaki fark nedir?

Move, sahipliğin devredilmesidir ve eski bağlamayı geçersiz kılar; copy ise değerin yeni bir kopyasının oluşturulmasıdır ve iki bağlama da kullanılabilir kalır. Copy trait’ini uygulayan tiplerde atama otomatik olarak kopyalar, diğer tiplerde ise taşır. Clone ile kopyayı sen açıkça istersin.

String neden Copy değildir?

String heap’te bir tampon sahibidir; Copy olsaydı iki değişken aynı tamponu gösterir ve kapsam sonunda aynı bellek iki kez serbest bırakılırdı. Rust bu çift serbest bırakma riskini, String için Copy yerine Clone sunarak engeller.

clone kullanmak performansı düşürür mü?

String ve Vec gibi heap sahibi tiplerde clone() yeni tahsis ve veri kopyası yapar; i32 gibi Copy tiplerde ya da Rc/Arc içinde ise maliyet çok düşüktür. Sıcak döngülerde sık çağrılan clone() ölçülebilir maliyet oluşturur. Bu yüzden okuma amaçlı fonksiyonlarda referans, gerçekten bağımsız bir kopya gerekiyorsa clone() tercih edilir.

Özet ve sonraki ders

  • Her değerin tek bir sahibi vardır; sahip kapsamdan çıkınca değer Drop ile temizlenir.
  • Atama ve fonksiyon çağrısı varsayılan olarak move yapar; eski bağlama geçersizleşir, onu kullanmaya çalışırsan E0382 alırsın.
  • Copy örtük ve ucuz bit kopyasıdır, Clone açık ve potansiyel olarak maliyetli kopyadır.
  • Sahipliği aktarmak yerine &T veya &str ile ödünç vermek çoğu zaman doğru tercihtir.
  • Rust, bu model sayesinde çöp toplayıcı olmadan bellek güvenliği sağlar.

Serinin sonraki dersinde sahipliğin kaçınılmaz tamamlayıcısı olan ödünç alma kurallarını, & ve &mut referanslarını ve Rust borrow checker’ın verdiği hataları ele alıyoruz.

Kaynaklar

  1. doc.rust-lang.org doc.rust-lang.org

Faydalı olduysa paylaş

Yorum yaz