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.
İç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.
- Her değerin bir sahibi vardır. Bir
Stringoluşturulduğunda onu tutan değişken sahibi olur. - Aynı anda yalnızca bir sahip olabilir. Sahiplik başka bir değişkene devredilirse eskisi geçersizleşir.
- 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:
let s2 = s1;satırı stack’teki işaretçi, uzunluk ve kapasite üçlüsünüs2‘ye kopyalar.- Heap’teki
merhababaytları kopyalanmaz; iki değişken aynı tamponu gösterir. - Derleyici
s1‘i geçersiz olarak işaretler, böylece kapsam sonunda tampon yalnızcas2ü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 mesajborrow of moved valuediyor; doğrudan taşıma yapan bir ifade olsaydıuse of moved valueyazardı. -->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 tipiStringveStringCopyuygulamı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
Dropile 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,Cloneaçık ve potansiyel olarak maliyetli kopyadır.- Sahipliği aktarmak yerine
&Tveya&strile ö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
- doc.rust-lang.org doc.rust-lang.org
Faydalı olduysa paylaş